A comparison between tokio and our C++ coroutine lib

[beef9999]

Our lib is based on stackful coroutine, while tokio is stackless.

Our tests showed that tokio ranks the top 3 in terms of network performance.

We are both faster than Golang, any way. 🤣

[Noah-Kennedy]

We are looking to add support for io_uring in the future, which should allow for better throughput for these sorts of "move dumb bytes around" programs.

[beef9999]

As per our tests, the Streaming mode (for example, RPC) was not friendly to io_uring, it has to be epoll socket to achieve the best score.

io_uring is good at dealing Ping-pong mode. I believe you will meet the same problem later when introducing io_uring.

[beef9999]

512 bytes buffer size is small. Kernel only spent 10% CPU to copy user string buffers, according to perf top. The scheduler is the key point.

[Noah-Kennedy]

I have some questions about your benchmarks.

1. Where are the benchmark implementations?
2. Which tokio runtime did you use (multiple current_thread or single multi_thread)?
3. Why did you choose to do just an echo server? This is almost never actually realistic for testing runtimes, as the workload is too simple for perf issues to come up which are improved with things like work-stealing.

[Noah-Kennedy]

Both

[beef9999]

use tokio::net::TcpListener;
use tokio::io::{AsyncReadExt, AsyncWriteExt};
use tokio::runtime;

fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Create the runtime
    let rt  = runtime::Builder::new_current_thread()
    .enable_io().build()?;

    // Spawn the root task
    rt.block_on(async {
        let listener = TcpListener::bind("0.0.0.0:9527").await?;

        loop {
            let (mut socket, _) = listener.accept().await?;

            tokio::spawn(async move {
                let mut buf = [0; 512];

                // In a loop, read data from the socket and write the data back.
                loop {
                    let n = match socket.read(&mut buf).await {
                        // socket closed
                        Ok(n) if n == 0 => return,
                        Ok(n) => n,
                        Err(e) => {
                            println!("failed to read from socket; err = {:?}", e);
                            return;
                        }
                    };

                    // Write the data back
                    if let Err(e) = socket.write_all(&buf[0..n]).await {
                        println!("failed to write to socket; err = {:?}", e);
                        return;
                    }
                }
            });
        }
    })
}

Our project code

And for the rest of the C++ projects in the list, or Golang, they all have typical echo server examples.

[Noah-Kennedy]

If you introduce random jitter on the client end between when you connect to the server and when you send data, how does this change the results for the different platforms?

[Noah-Kennedy]

Also, did you test latency results? The tails might be interesting.

[beef9999]

The data was collected long after the connections have be established. The send/recv are happening in while loops. So it won't bring changes.

As to the client latency, our client can print latency data, but we didn't collect them. And the Streaming mode has no latency, only Ping-pong mode does.