Linux Benchmarks

Generated 2026-11-16 from corosio 13bcf933adf8 — benchmark run. This page is fully generated; do not edit by hand (see the Benchmarks landing page).

Summary

Within noise means the relative difference is within twice the combined run-to-run noise (the root-sum-square of each side’s CV). Differences that small are indistinguishable from measurement jitter. See Methodology for how these figures are computed.

io_uring

73 faster · 37 within noise · 3 slower of 113 benchmarks — median +3.3% vs Boost.Asio (callbacks) on the same reactor.

Summary (io_uring) — Linux ← slower · within noise · faster → per benchmark, vs Boost.Asio (callbacks) local_socket_latency 12 benchmarks faster than asio (callbacks) 12 +30.8% socket_latency 12 benchmarks faster than asio (callbacks) 12 +16.7% socket_throughput 1 benchmark slower than asio (callbacks) 7 benchmarks within noise than asio (callbacks) 7 19 benchmarks faster than asio (callbacks) 19 +8.5% http_server 2 benchmarks within noise than asio (callbacks) 9 benchmarks faster than asio (callbacks) 9 +3.0% local_socket_throughput 16 benchmarks within noise than asio (callbacks) 16 8 benchmarks faster than asio (callbacks) 8 +2.3% fan_out 1 benchmark slower than asio (callbacks) 4 benchmarks within noise than asio (callbacks) 4 13 benchmarks faster than asio (callbacks) 13 +2.0% accept_churn 1 benchmark slower than asio (callbacks) 8 benchmarks within noise than asio (callbacks) 8 -0.6%

epoll

30 faster · 34 within noise · 49 slower of 113 benchmarks — median -1.4% vs Boost.Asio (callbacks) on the same reactor.

Summary (epoll) — Linux ← slower · within noise · faster → per benchmark, vs Boost.Asio (callbacks) local_socket_latency 4 benchmarks slower than asio (callbacks) 4 6 benchmarks within noise than asio (callbacks) 6 2 benchmarks faster than asio (callbacks) 2 +9.7% socket_latency 3 benchmarks slower than asio (callbacks) 3 1 benchmark within noise than asio (callbacks) 8 benchmarks faster than asio (callbacks) 8 +5.0% socket_throughput 5 benchmarks slower than asio (callbacks) 5 9 benchmarks within noise than asio (callbacks) 9 13 benchmarks faster than asio (callbacks) 13 +2.1% local_socket_throughput 4 benchmarks slower than asio (callbacks) 4 16 benchmarks within noise than asio (callbacks) 16 4 benchmarks faster than asio (callbacks) 4 +2.0% accept_churn 6 benchmarks slower than asio (callbacks) 6 3 benchmarks faster than asio (callbacks) 3 -3.4% http_server 9 benchmarks slower than asio (callbacks) 9 2 benchmarks within noise than asio (callbacks) 2 -4.4% fan_out 18 benchmarks slower than asio (callbacks) 18 -5.6%

Test Environment

CPU

AMD EPYC 7302P 16-Core Processor

Cores

4

RAM (GB)

31

OS

Linux 7.0.0-34-generic

Kernel/build

#34-Ubuntu SMP PREEMPT_DYNAMIC Wed Sep 2 14:29:37 UTC 2026

Compiler

c++ (Ubuntu 15.2.0-16ubuntu1) 15.2.0

CMake

cmake version 4.2.3

liburing

2.14-1

Boost commit

644b3c38a6c52972a1678677951307194ccb04e2

Asio commit

e99d9da6d9b76a222e29dcaf3d2df51c788b7527

Asio reactor

epoll and io_uring (matched per configuration)

Capy commit

25299eb4fd17423b761cc35d47008df7b68976d1

Corosio commit

13bcf933adf8c5ce8576bd3349ae58d2e46e5c53

Corosio branch

develop

Date (UTC)

2026-11-16

Iterations

7

Duration per benchmark (s)

2.0

Results

accept_churn

Rate of setting up and tearing down short-lived TCP connections: connect, accept, close.

io_uring

accept_churn (io_uring) — Linux ↑ faster · dotted line = asio (callbacks) · backend = io_uring corosio asio (coroutines) -6% -4% -2% +2% 0% burst/10 — N connects are fired at once, then all N are accepted before closing; N is the burst size. burst/10 — N connects are fired at once, then all N are accepted before closing; N is the burst size. burst/10 burst/100 — N connects are fired at once, then all N are accepted before closing; N is the burst size. +0% burst/100 — N connects are fired at once, then all N are accepted before closing; N is the burst size. -1% burst/100 burst_lockless/10 — Same as burst, with the context in single-threaded lockless mode; N is the burst size. burst_lockless/10 — Same as burst, with the context in single-threaded lockless mode; N is the burst size. burst_lockless/10 burst_lockless/100 — Same as burst, with the context in single-threaded lockless mode; N is the burst size. burst_lockless/100 — Same as burst, with the context in single-threaded lockless mode; N is the burst size. burst_lockless/100 concurrent/1 — N independent accept loops run on separate listeners at once, each doing a one-way one-byte transfer (client writes, server reads) per connection; N is the number of loops. concurrent/1 — N independent accept loops run on separate listeners at once, each doing a one-way one-byte transfer (client writes, server reads) per connection; N is the number of loops. -3% concurrent/1 concurrent/16 — N independent accept loops run on separate listeners at once, each doing a one-way one-byte transfer (client writes, server reads) per connection; N is the number of loops. concurrent/16 — N independent accept loops run on separate listeners at once, each doing a one-way one-byte transfer (client writes, server reads) per connection; N is the number of loops. concurrent/16 concurrent/4 — N independent accept loops run on separate listeners at once, each doing a one-way one-byte transfer (client writes, server reads) per connection; N is the number of loops. -4% concurrent/4 — N independent accept loops run on separate listeners at once, each doing a one-way one-byte transfer (client writes, server reads) per connection; N is the number of loops. concurrent/4 sequential — Single connect/accept/close loop with a one-way one-byte transfer (client writes, server reads) per connection, one connection at a time. sequential — Single connect/accept/close loop with a one-way one-byte transfer (client writes, server reads) per connection, one connection at a time. sequential sequential_lockless — Same as sequential, with the context in single-threaded lockless mode. sequential_lockless — Same as sequential, with the context in single-threaded lockless mode. sequential_lockless
Detailed results
Benchmark Implementation Median CV vs asio

burst/10

corosio (io_uring)

2.40K ops/s

0.99%

-0.2%

burst/10

asio (coroutines, io_uring)

2.39K ops/s

1.06%

-1.0%

burst/10

asio (callbacks, io_uring)

2.41K ops/s

0.91%

baseline (io_uring)

burst/100

corosio (io_uring)

246.9 ops/s

0.44%

+0.4%

burst/100

asio (coroutines, io_uring)

244.5 ops/s

1.13%

-0.6%

burst/100

asio (callbacks, io_uring)

245.9 ops/s

0.42%

baseline (io_uring)

burst_lockless/10

corosio (io_uring)

2.41K ops/s

1.19%

-0.4%

burst_lockless/10

asio (coroutines, io_uring)

2.40K ops/s

0.92%

-1.1%

burst_lockless/10

asio (callbacks, io_uring)

2.42K ops/s

0.18%

baseline (io_uring)

burst_lockless/100

corosio (io_uring)

248.0 ops/s

0.54%

+0.3%

burst_lockless/100

asio (coroutines, io_uring)

245.8 ops/s

0.60%

-0.6%

burst_lockless/100

asio (callbacks, io_uring)

247.3 ops/s

0.09%

baseline (io_uring)

concurrent/1

corosio (io_uring)

17.20K ops/s

0.76%

-0.6%

concurrent/1

asio (coroutines, io_uring)

16.87K ops/s

0.90%

-2.5%

concurrent/1

asio (callbacks, io_uring)

17.31K ops/s

0.71%

baseline (io_uring)

concurrent/16

corosio (io_uring)

18.80K ops/s

1.15%

-2.7%

concurrent/16

asio (coroutines, io_uring)

19.02K ops/s

1.12%

-1.5%

concurrent/16

asio (callbacks, io_uring)

19.32K ops/s

0.80%

baseline (io_uring)

concurrent/4

corosio (io_uring)

17.80K ops/s

0.85%

-3.7%

concurrent/4

asio (coroutines, io_uring)

18.17K ops/s

1.08%

-1.7%

concurrent/4

asio (callbacks, io_uring)

18.49K ops/s

0.75%

baseline (io_uring)

sequential

corosio (io_uring)

17.16K ops/s

0.30%

-0.6%

sequential

asio (coroutines, io_uring)

16.90K ops/s

0.85%

-2.1%

sequential

asio (callbacks, io_uring)

17.26K ops/s

0.98%

baseline (io_uring)

sequential_lockless

corosio (io_uring)

17.33K ops/s

0.78%

-1.0%

sequential_lockless

asio (coroutines, io_uring)

17.11K ops/s

1.06%

-2.2%

sequential_lockless

asio (callbacks, io_uring)

17.49K ops/s

0.95%

baseline (io_uring)

epoll

accept_churn (epoll) — Linux ↑ faster · dotted line = asio (callbacks) · backend = epoll corosio asio (coroutines) -10% -5% +5% 0% burst/10 — N connects are fired at once, then all N are accepted before closing; N is the burst size. -6% burst/10 — N connects are fired at once, then all N are accepted before closing; N is the burst size. -4% burst/10 burst/100 — N connects are fired at once, then all N are accepted before closing; N is the burst size. burst/100 — N connects are fired at once, then all N are accepted before closing; N is the burst size. burst/100 burst_lockless/10 — Same as burst, with the context in single-threaded lockless mode; N is the burst size. burst_lockless/10 — Same as burst, with the context in single-threaded lockless mode; N is the burst size. burst_lockless/10 burst_lockless/100 — Same as burst, with the context in single-threaded lockless mode; N is the burst size. burst_lockless/100 — Same as burst, with the context in single-threaded lockless mode; N is the burst size. burst_lockless/100 concurrent/1 — N independent accept loops run on separate listeners at once, each doing a one-way one-byte transfer (client writes, server reads) per connection; N is the number of loops. concurrent/1 — N independent accept loops run on separate listeners at once, each doing a one-way one-byte transfer (client writes, server reads) per connection; N is the number of loops. concurrent/1 concurrent/16 — N independent accept loops run on separate listeners at once, each doing a one-way one-byte transfer (client writes, server reads) per connection; N is the number of loops. concurrent/16 — N independent accept loops run on separate listeners at once, each doing a one-way one-byte transfer (client writes, server reads) per connection; N is the number of loops. -1% concurrent/16 concurrent/4 — N independent accept loops run on separate listeners at once, each doing a one-way one-byte transfer (client writes, server reads) per connection; N is the number of loops. concurrent/4 — N independent accept loops run on separate listeners at once, each doing a one-way one-byte transfer (client writes, server reads) per connection; N is the number of loops. concurrent/4 sequential — Single connect/accept/close loop with a one-way one-byte transfer (client writes, server reads) per connection, one connection at a time. sequential — Single connect/accept/close loop with a one-way one-byte transfer (client writes, server reads) per connection, one connection at a time. sequential sequential_lockless — Same as sequential, with the context in single-threaded lockless mode. +2% sequential_lockless — Same as sequential, with the context in single-threaded lockless mode. sequential_lockless
Detailed results
Benchmark Implementation Median CV vs asio

burst/10

corosio (epoll)

2.00K ops/s

0.82%

-6.3%

burst/10

asio (coroutines, epoll)

2.05K ops/s

0.35%

-3.9%

burst/10

asio (callbacks, epoll)

2.14K ops/s

0.22%

baseline (epoll)

burst/100

corosio (epoll)

203.3 ops/s

0.89%

-5.9%

burst/100

asio (coroutines, epoll)

209.5 ops/s

0.20%

-3.1%

burst/100

asio (callbacks, epoll)

216.1 ops/s

0.20%

baseline (epoll)

burst_lockless/10

corosio (epoll)

2.03K ops/s

0.81%

-5.6%

burst_lockless/10

asio (coroutines, epoll)

2.06K ops/s

0.14%

-3.9%

burst_lockless/10

asio (callbacks, epoll)

2.15K ops/s

0.26%

baseline (epoll)

burst_lockless/100

corosio (epoll)

206.0 ops/s

0.76%

-5.0%

burst_lockless/100

asio (coroutines, epoll)

209.9 ops/s

0.11%

-3.2%

burst_lockless/100

asio (callbacks, epoll)

216.9 ops/s

0.26%

baseline (epoll)

concurrent/1

corosio (epoll)

15.88K ops/s

0.37%

+1.4%

concurrent/1

asio (coroutines, epoll)

15.28K ops/s

0.78%

-2.4%

concurrent/1

asio (callbacks, epoll)

15.66K ops/s

0.45%

baseline (epoll)

concurrent/16

corosio (epoll)

15.92K ops/s

0.75%

-3.4%

concurrent/16

asio (coroutines, epoll)

16.25K ops/s

0.81%

-1.4%

concurrent/16

asio (callbacks, epoll)

16.49K ops/s

0.27%

baseline (epoll)

concurrent/4

corosio (epoll)

15.89K ops/s

0.24%

-1.5%

concurrent/4

asio (coroutines, epoll)

15.80K ops/s

0.69%

-2.0%

concurrent/4

asio (callbacks, epoll)

16.13K ops/s

0.37%

baseline (epoll)

sequential

corosio (epoll)

15.90K ops/s

0.34%

+1.5%

sequential

asio (coroutines, epoll)

15.30K ops/s

0.42%

-2.3%

sequential

asio (callbacks, epoll)

15.66K ops/s

0.49%

baseline (epoll)

sequential_lockless

corosio (epoll)

16.08K ops/s

0.33%

+2.2%

sequential_lockless

asio (coroutines, epoll)

15.38K ops/s

0.68%

-2.3%

sequential_lockless

asio (callbacks, epoll)

15.74K ops/s

0.36%

baseline (epoll)


fan_out

Fan-out/fan-in coroutine coordination: a parent starts concurrent sub-requests against echo servers and awaits their completion via a shared latch.

io_uring

fan_out (io_uring) — Linux, part 1 ↑ faster · dotted line = asio (callbacks) · backend = io_uring corosio asio (coroutines) -5% -2.5% +2.5% +5% 0% concurrent_parents/1 — N independent parents each fan out to 16 sub-requests at once; N is the number of parents. +2% concurrent_parents/1 — N independent parents each fan out to 16 sub-requests at once; N is the number of parents. -3% concurrent_parents/1 concurrent_parents/16 — N independent parents each fan out to 16 sub-requests at once; N is the number of parents. +3% concurrent_parents/16 — N independent parents each fan out to 16 sub-requests at once; N is the number of parents. -3% concurrent_parents/16 concurrent_parents/4 — N independent parents each fan out to 16 sub-requests at once; N is the number of parents. +3% concurrent_parents/4 — N independent parents each fan out to 16 sub-requests at once; N is the number of parents. -2% concurrent_parents/4 concurrent_parents_lockless/1 — Same as concurrent_parents, with the context in single-threaded lockless mode; N is the number of parents. +2% concurrent_parents_lockless/1 — Same as concurrent_parents, with the context in single-threaded lockless mode; N is the number of parents. -4% concurrent_parents_lockless/1 concurrent_parents_lockless/16 — Same as concurrent_parents, with the context in single-threaded lockless mode; N is the number of parents. +2% concurrent_parents_lockless/16 — Same as concurrent_parents, with the context in single-threaded lockless mode; N is the number of parents. -3% concurrent_parents_lockless/16 concurrent_parents_lockless/4 — Same as concurrent_parents, with the context in single-threaded lockless mode; N is the number of parents. +3% concurrent_parents_lockless/4 — Same as concurrent_parents, with the context in single-threaded lockless mode; N is the number of parents. -3% concurrent_parents_lockless/4
Detailed results
Benchmark Implementation Median CV vs asio

concurrent_parents/1

corosio (io_uring)

4.01K ops/s

0.15%

+1.9%

concurrent_parents/1

asio (coroutines, io_uring)

3.80K ops/s

0.31%

-3.3%

concurrent_parents/1

asio (callbacks, io_uring)

3.93K ops/s

0.77%

baseline (io_uring)

concurrent_parents/16

corosio (io_uring)

3.94K ops/s

0.17%

+2.6%

concurrent_parents/16

asio (coroutines, io_uring)

3.73K ops/s

0.22%

-2.9%

concurrent_parents/16

asio (callbacks, io_uring)

3.84K ops/s

0.80%

baseline (io_uring)

concurrent_parents/4

corosio (io_uring)

3.97K ops/s

0.19%

+3.0%

concurrent_parents/4

asio (coroutines, io_uring)

3.76K ops/s

0.37%

-2.5%

concurrent_parents/4

asio (callbacks, io_uring)

3.85K ops/s

0.84%

baseline (io_uring)

concurrent_parents_lockless/1

corosio (io_uring)

4.05K ops/s

0.21%

+1.8%

concurrent_parents_lockless/1

asio (coroutines, io_uring)

3.84K ops/s

0.25%

-3.5%

concurrent_parents_lockless/1

asio (callbacks, io_uring)

3.98K ops/s

0.63%

baseline (io_uring)

concurrent_parents_lockless/16

corosio (io_uring)

3.97K ops/s

0.10%

+2.3%

concurrent_parents_lockless/16

asio (coroutines, io_uring)

3.77K ops/s

0.30%

-2.7%

concurrent_parents_lockless/16

asio (callbacks, io_uring)

3.88K ops/s

0.26%

baseline (io_uring)

concurrent_parents_lockless/4

corosio (io_uring)

4.00K ops/s

0.22%

+2.6%

concurrent_parents_lockless/4

asio (coroutines, io_uring)

3.79K ops/s

0.37%

-2.7%

concurrent_parents_lockless/4

asio (callbacks, io_uring)

3.90K ops/s

0.29%

baseline (io_uring)

fan_out (io_uring) — Linux, part 2 ↑ faster · dotted line = asio (callbacks) · backend = io_uring corosio asio (coroutines) -15% -10% -5% +5% +10% 0% fork_join/1 — One parent starts N sub-requests to echo servers and waits for all to finish before repeating; N is the fan-out width. fork_join/1 — One parent starts N sub-requests to echo servers and waits for all to finish before repeating; N is the fan-out width. -12% fork_join/1 fork_join/16 — One parent starts N sub-requests to echo servers and waits for all to finish before repeating; N is the fan-out width. fork_join/16 — One parent starts N sub-requests to echo servers and waits for all to finish before repeating; N is the fan-out width. fork_join/16 fork_join/4 — One parent starts N sub-requests to echo servers and waits for all to finish before repeating; N is the fan-out width. -1% fork_join/4 — One parent starts N sub-requests to echo servers and waits for all to finish before repeating; N is the fan-out width. fork_join/4 fork_join/64 — One parent starts N sub-requests to echo servers and waits for all to finish before repeating; N is the fan-out width. +4% fork_join/64 — One parent starts N sub-requests to echo servers and waits for all to finish before repeating; N is the fan-out width. -2% fork_join/64 fork_join_lockless/1 — Same as fork_join, with the context in single-threaded lockless mode; N is the fan-out width. fork_join_lockless/1 — Same as fork_join, with the context in single-threaded lockless mode; N is the fan-out width. fork_join_lockless/1 fork_join_lockless/16 — Same as fork_join, with the context in single-threaded lockless mode; N is the fan-out width. fork_join_lockless/16 — Same as fork_join, with the context in single-threaded lockless mode; N is the fan-out width. fork_join_lockless/16 fork_join_lockless/4 — Same as fork_join, with the context in single-threaded lockless mode; N is the fan-out width. fork_join_lockless/4 — Same as fork_join, with the context in single-threaded lockless mode; N is the fan-out width. fork_join_lockless/4 fork_join_lockless/64 — Same as fork_join, with the context in single-threaded lockless mode; N is the fan-out width. fork_join_lockless/64 — Same as fork_join, with the context in single-threaded lockless mode; N is the fan-out width. fork_join_lockless/64 nested/16 — Two-level fan-out: the parent starts N groups of 4 sub-requests each, each group awaited via its own latch; N is the number of groups. nested/16 — Two-level fan-out: the parent starts N groups of 4 sub-requests each, each group awaited via its own latch; N is the number of groups. nested/16 nested/4 — Two-level fan-out: the parent starts N groups of 4 sub-requests each, each group awaited via its own latch; N is the number of groups. nested/4 — Two-level fan-out: the parent starts N groups of 4 sub-requests each, each group awaited via its own latch; N is the number of groups. nested/4 nested_lockless/16 — Same as nested, with the context in single-threaded lockless mode; N is the number of groups. nested_lockless/16 — Same as nested, with the context in single-threaded lockless mode; N is the number of groups. nested_lockless/16 nested_lockless/4 — Same as nested, with the context in single-threaded lockless mode; N is the number of groups. nested_lockless/4 — Same as nested, with the context in single-threaded lockless mode; N is the number of groups. nested_lockless/4
Detailed results
Benchmark Implementation Median CV vs asio

fork_join/1

corosio (io_uring)

54.58K ops/s

1.07%

+0.5%

fork_join/1

asio (coroutines, io_uring)

47.97K ops/s

0.82%

-11.7%

fork_join/1

asio (callbacks, io_uring)

54.30K ops/s

0.22%

baseline (io_uring)

fork_join/16

corosio (io_uring)

4.00K ops/s

0.17%

+1.9%

fork_join/16

asio (coroutines, io_uring)

3.81K ops/s

0.89%

-3.0%

fork_join/16

asio (callbacks, io_uring)

3.93K ops/s

0.26%

baseline (io_uring)

fork_join/4

corosio (io_uring)

15.01K ops/s

0.71%

-1.5%

fork_join/4

asio (coroutines, io_uring)

14.42K ops/s

0.81%

-5.4%

fork_join/4

asio (callbacks, io_uring)

15.24K ops/s

0.20%

baseline (io_uring)

fork_join/64

corosio (io_uring)

993.2 ops/s

0.46%

+3.7%

fork_join/64

asio (coroutines, io_uring)

940.2 ops/s

0.79%

-1.8%

fork_join/64

asio (callbacks, io_uring)

957.6 ops/s

0.32%

baseline (io_uring)

fork_join_lockless/1

corosio (io_uring)

56.06K ops/s

0.86%

+2.1%

fork_join_lockless/1

asio (coroutines, io_uring)

48.91K ops/s

0.73%

-11.0%

fork_join_lockless/1

asio (callbacks, io_uring)

54.93K ops/s

0.25%

baseline (io_uring)

fork_join_lockless/16

corosio (io_uring)

4.05K ops/s

0.75%

+2.0%

fork_join_lockless/16

asio (coroutines, io_uring)

3.85K ops/s

0.23%

-3.2%

fork_join_lockless/16

asio (callbacks, io_uring)

3.97K ops/s

0.17%

baseline (io_uring)

fork_join_lockless/4

corosio (io_uring)

15.25K ops/s

0.86%

-1.2%

fork_join_lockless/4

asio (coroutines, io_uring)

14.60K ops/s

0.33%

-5.4%

fork_join_lockless/4

asio (callbacks, io_uring)

15.43K ops/s

0.25%

baseline (io_uring)

fork_join_lockless/64

corosio (io_uring)

1.00K ops/s

1.05%

+3.1%

fork_join_lockless/64

asio (coroutines, io_uring)

951.2 ops/s

0.19%

-2.2%

fork_join_lockless/64

asio (callbacks, io_uring)

972.4 ops/s

0.21%

baseline (io_uring)

nested/16

corosio (io_uring)

988.6 ops/s

0.83%

+3.0%

nested/16

asio (coroutines, io_uring)

933.6 ops/s

0.34%

-2.8%

nested/16

asio (callbacks, io_uring)

960.2 ops/s

0.16%

baseline (io_uring)

nested/4

corosio (io_uring)

3.98K ops/s

0.97%

+1.4%

nested/4

asio (coroutines, io_uring)

3.77K ops/s

0.20%

-4.1%

nested/4

asio (callbacks, io_uring)

3.93K ops/s

0.25%

baseline (io_uring)

nested_lockless/16

corosio (io_uring)

998.5 ops/s

0.78%

+2.6%

nested_lockless/16

asio (coroutines, io_uring)

943.0 ops/s

0.35%

-3.1%

nested_lockless/16

asio (callbacks, io_uring)

973.1 ops/s

0.75%

baseline (io_uring)

nested_lockless/4

corosio (io_uring)

4.03K ops/s

0.91%

+1.2%

nested_lockless/4

asio (coroutines, io_uring)

3.81K ops/s

0.24%

-4.3%

nested_lockless/4

asio (callbacks, io_uring)

3.99K ops/s

0.47%

baseline (io_uring)

epoll

fan_out (epoll) — Linux, part 1 ↑ faster · dotted line = asio (callbacks) · backend = epoll corosio asio (coroutines) -7.5% -5% -2.5% +2.5% 0% concurrent_parents/1 — N independent parents each fan out to 16 sub-requests at once; N is the number of parents. -6% concurrent_parents/1 — N independent parents each fan out to 16 sub-requests at once; N is the number of parents. -5% concurrent_parents/1 concurrent_parents/16 — N independent parents each fan out to 16 sub-requests at once; N is the number of parents. -5% concurrent_parents/16 — N independent parents each fan out to 16 sub-requests at once; N is the number of parents. -4% concurrent_parents/16 concurrent_parents/4 — N independent parents each fan out to 16 sub-requests at once; N is the number of parents. -5% concurrent_parents/4 — N independent parents each fan out to 16 sub-requests at once; N is the number of parents. -5% concurrent_parents/4 concurrent_parents_lockless/1 — Same as concurrent_parents, with the context in single-threaded lockless mode; N is the number of parents. -6% concurrent_parents_lockless/1 — Same as concurrent_parents, with the context in single-threaded lockless mode; N is the number of parents. -5% concurrent_parents_lockless/1 concurrent_parents_lockless/16 — Same as concurrent_parents, with the context in single-threaded lockless mode; N is the number of parents. -5% concurrent_parents_lockless/16 — Same as concurrent_parents, with the context in single-threaded lockless mode; N is the number of parents. -4% concurrent_parents_lockless/16 concurrent_parents_lockless/4 — Same as concurrent_parents, with the context in single-threaded lockless mode; N is the number of parents. -5% concurrent_parents_lockless/4 — Same as concurrent_parents, with the context in single-threaded lockless mode; N is the number of parents. -5% concurrent_parents_lockless/4
Detailed results
Benchmark Implementation Median CV vs asio

concurrent_parents/1

corosio (epoll)

3.83K ops/s

0.16%

-6.1%

concurrent_parents/1

asio (coroutines, epoll)

3.89K ops/s

0.23%

-4.7%

concurrent_parents/1

asio (callbacks, epoll)

4.08K ops/s

0.26%

baseline (epoll)

concurrent_parents/16

corosio (epoll)

3.77K ops/s

0.27%

-5.3%

concurrent_parents/16

asio (coroutines, epoll)

3.82K ops/s

0.33%

-4.1%

concurrent_parents/16

asio (callbacks, epoll)

3.98K ops/s

0.85%

baseline (epoll)

concurrent_parents/4

corosio (epoll)

3.77K ops/s

0.19%

-5.4%

concurrent_parents/4

asio (coroutines, epoll)

3.80K ops/s

0.22%

-4.5%

concurrent_parents/4

asio (callbacks, epoll)

3.98K ops/s

0.35%

baseline (epoll)

concurrent_parents_lockless/1

corosio (epoll)

3.88K ops/s

0.28%

-5.8%

concurrent_parents_lockless/1

asio (coroutines, epoll)

3.92K ops/s

0.25%

-4.6%

concurrent_parents_lockless/1

asio (callbacks, epoll)

4.12K ops/s

0.79%

baseline (epoll)

concurrent_parents_lockless/16

corosio (epoll)

3.81K ops/s

0.23%

-4.9%

concurrent_parents_lockless/16

asio (coroutines, epoll)

3.85K ops/s

0.26%

-4.0%

concurrent_parents_lockless/16

asio (callbacks, epoll)

4.01K ops/s

0.83%

baseline (epoll)

concurrent_parents_lockless/4

corosio (epoll)

3.82K ops/s

0.30%

-5.1%

concurrent_parents_lockless/4

asio (coroutines, epoll)

3.84K ops/s

0.25%

-4.5%

concurrent_parents_lockless/4

asio (callbacks, epoll)

4.02K ops/s

0.88%

baseline (epoll)

fan_out (epoll) — Linux, part 2 ↑ faster · dotted line = asio (callbacks) · backend = epoll corosio asio (coroutines) -15% -10% -5% +5% 0% fork_join/1 — One parent starts N sub-requests to echo servers and waits for all to finish before repeating; N is the fan-out width. -8% fork_join/1 — One parent starts N sub-requests to echo servers and waits for all to finish before repeating; N is the fan-out width. -12% fork_join/1 fork_join/16 — One parent starts N sub-requests to echo servers and waits for all to finish before repeating; N is the fan-out width. fork_join/16 — One parent starts N sub-requests to echo servers and waits for all to finish before repeating; N is the fan-out width. fork_join/16 fork_join/4 — One parent starts N sub-requests to echo servers and waits for all to finish before repeating; N is the fan-out width. fork_join/4 — One parent starts N sub-requests to echo servers and waits for all to finish before repeating; N is the fan-out width. fork_join/4 fork_join/64 — One parent starts N sub-requests to echo servers and waits for all to finish before repeating; N is the fan-out width. fork_join/64 — One parent starts N sub-requests to echo servers and waits for all to finish before repeating; N is the fan-out width. fork_join/64 fork_join_lockless/1 — Same as fork_join, with the context in single-threaded lockless mode; N is the fan-out width. fork_join_lockless/1 — Same as fork_join, with the context in single-threaded lockless mode; N is the fan-out width. fork_join_lockless/1 fork_join_lockless/16 — Same as fork_join, with the context in single-threaded lockless mode; N is the fan-out width. fork_join_lockless/16 — Same as fork_join, with the context in single-threaded lockless mode; N is the fan-out width. fork_join_lockless/16 fork_join_lockless/4 — Same as fork_join, with the context in single-threaded lockless mode; N is the fan-out width. fork_join_lockless/4 — Same as fork_join, with the context in single-threaded lockless mode; N is the fan-out width. fork_join_lockless/4 fork_join_lockless/64 — Same as fork_join, with the context in single-threaded lockless mode; N is the fan-out width. -5% fork_join_lockless/64 — Same as fork_join, with the context in single-threaded lockless mode; N is the fan-out width. -4% fork_join_lockless/64 nested/16 — Two-level fan-out: the parent starts N groups of 4 sub-requests each, each group awaited via its own latch; N is the number of groups. nested/16 — Two-level fan-out: the parent starts N groups of 4 sub-requests each, each group awaited via its own latch; N is the number of groups. nested/16 nested/4 — Two-level fan-out: the parent starts N groups of 4 sub-requests each, each group awaited via its own latch; N is the number of groups. nested/4 — Two-level fan-out: the parent starts N groups of 4 sub-requests each, each group awaited via its own latch; N is the number of groups. nested/4 nested_lockless/16 — Same as nested, with the context in single-threaded lockless mode; N is the number of groups. nested_lockless/16 — Same as nested, with the context in single-threaded lockless mode; N is the number of groups. nested_lockless/16 nested_lockless/4 — Same as nested, with the context in single-threaded lockless mode; N is the number of groups. nested_lockless/4 — Same as nested, with the context in single-threaded lockless mode; N is the number of groups. nested_lockless/4
Detailed results
Benchmark Implementation Median CV vs asio

fork_join/1

corosio (epoll)

56.26K ops/s

0.09%

-7.6%

fork_join/1

asio (coroutines, epoll)

53.38K ops/s

0.33%

-12.3%

fork_join/1

asio (callbacks, epoll)

60.89K ops/s

0.22%

baseline (epoll)

fork_join/16

corosio (epoll)

3.84K ops/s

0.29%

-6.1%

fork_join/16

asio (coroutines, epoll)

3.88K ops/s

0.22%

-5.0%

fork_join/16

asio (callbacks, epoll)

4.09K ops/s

0.23%

baseline (epoll)

fork_join/4

corosio (epoll)

15.17K ops/s

0.17%

-6.0%

fork_join/4

asio (coroutines, epoll)

15.07K ops/s

0.24%

-6.5%

fork_join/4

asio (callbacks, epoll)

16.13K ops/s

0.33%

baseline (epoll)

fork_join/64

corosio (epoll)

944.2 ops/s

0.21%

-4.8%

fork_join/64

asio (coroutines, epoll)

953.5 ops/s

0.27%

-3.9%

fork_join/64

asio (callbacks, epoll)

992.1 ops/s

0.54%

baseline (epoll)

fork_join_lockless/1

corosio (epoll)

57.10K ops/s

0.16%

-7.4%

fork_join_lockless/1

asio (coroutines, epoll)

54.11K ops/s

0.11%

-12.3%

fork_join_lockless/1

asio (callbacks, epoll)

61.69K ops/s

0.85%

baseline (epoll)

fork_join_lockless/16

corosio (epoll)

3.88K ops/s

0.89%

-5.6%

fork_join_lockless/16

asio (coroutines, epoll)

3.93K ops/s

0.23%

-4.5%

fork_join_lockless/16

asio (callbacks, epoll)

4.11K ops/s

0.84%

baseline (epoll)

fork_join_lockless/4

corosio (epoll)

15.35K ops/s

0.61%

-5.6%

fork_join_lockless/4

asio (coroutines, epoll)

15.22K ops/s

0.30%

-6.4%

fork_join_lockless/4

asio (callbacks, epoll)

16.27K ops/s

0.89%

baseline (epoll)

fork_join_lockless/64

corosio (epoll)

954.2 ops/s

0.85%

-4.7%

fork_join_lockless/64

asio (coroutines, epoll)

963.2 ops/s

0.22%

-3.8%

fork_join_lockless/64

asio (callbacks, epoll)

1.00K ops/s

0.91%

baseline (epoll)

nested/16

corosio (epoll)

940.2 ops/s

0.89%

-5.0%

nested/16

asio (coroutines, epoll)

942.7 ops/s

0.18%

-4.8%

nested/16

asio (callbacks, epoll)

990.1 ops/s

0.32%

baseline (epoll)

nested/4

corosio (epoll)

3.82K ops/s

0.81%

-6.4%

nested/4

asio (coroutines, epoll)

3.83K ops/s

0.25%

-6.0%

nested/4

asio (callbacks, epoll)

4.08K ops/s

0.34%

baseline (epoll)

nested_lockless/16

corosio (epoll)

950.7 ops/s

0.23%

-4.8%

nested_lockless/16

asio (coroutines, epoll)

952.6 ops/s

0.17%

-4.6%

nested_lockless/16

asio (callbacks, epoll)

998.5 ops/s

0.12%

baseline (epoll)

nested_lockless/4

corosio (epoll)

3.86K ops/s

0.32%

-5.8%

nested_lockless/4

asio (coroutines, epoll)

3.87K ops/s

0.28%

-5.5%

nested_lockless/4

asio (callbacks, epoll)

4.10K ops/s

0.26%

baseline (epoll)


http_server

Request/response throughput of a minimal HTTP/1.1 server exchanging a fixed small request and canned response over persistent TCP loopback connections.

io_uring

http_server (io_uring) — Linux ↑ faster · dotted line = asio (callbacks) · backend = io_uring corosio asio (coroutines) -100% +100% +200% 0% concurrent/1 — N client/server pairs run the single_conn request/response loop concurrently; N is the number of connections. concurrent/1 — N client/server pairs run the single_conn request/response loop concurrently; N is the number of connections. concurrent/1 concurrent/16 — N client/server pairs run the single_conn request/response loop concurrently; N is the number of connections. concurrent/16 — N client/server pairs run the single_conn request/response loop concurrently; N is the number of connections. concurrent/16 concurrent/32 — N client/server pairs run the single_conn request/response loop concurrently; N is the number of connections. concurrent/32 — N client/server pairs run the single_conn request/response loop concurrently; N is the number of connections. -1% concurrent/32 concurrent/4 — N client/server pairs run the single_conn request/response loop concurrently; N is the number of connections. concurrent/4 — N client/server pairs run the single_conn request/response loop concurrently; N is the number of connections. concurrent/4 multithread/1 — 32 client/server pairs share one context serviced by N threads running the context; N is the thread count. multithread/1 — 32 client/server pairs share one context serviced by N threads running the context; N is the thread count. multithread/1 multithread/16 — 32 client/server pairs share one context serviced by N threads running the context; N is the thread count. multithread/16 — 32 client/server pairs share one context serviced by N threads running the context; N is the thread count. -6% multithread/16 multithread/2 — 32 client/server pairs share one context serviced by N threads running the context; N is the thread count. multithread/2 — 32 client/server pairs share one context serviced by N threads running the context; N is the thread count. multithread/2 multithread/4 — 32 client/server pairs share one context serviced by N threads running the context; N is the thread count. multithread/4 — 32 client/server pairs share one context serviced by N threads running the context; N is the thread count. multithread/4 multithread/8 — 32 client/server pairs share one context serviced by N threads running the context; N is the thread count. +156% multithread/8 — 32 client/server pairs share one context serviced by N threads running the context; N is the thread count. multithread/8 single_conn — One client repeatedly sends a fixed small HTTP request to one server and reads the response. +1% single_conn — One client repeatedly sends a fixed small HTTP request to one server and reads the response. single_conn single_conn_lockless — Same as single_conn, with the context in single-threaded lockless mode. single_conn_lockless — Same as single_conn, with the context in single-threaded lockless mode. single_conn_lockless
Detailed results
Benchmark Implementation Median CV vs asio

concurrent/1

corosio (io_uring)

53.57K ops/s

0.43%

+0.8%

concurrent/1

asio (coroutines, io_uring)

52.23K ops/s

0.73%

-1.7%

concurrent/1

asio (callbacks, io_uring)

53.15K ops/s

0.73%

baseline (io_uring)

concurrent/16

corosio (io_uring)

63.50K ops/s

0.26%

+3.0%

concurrent/16

asio (coroutines, io_uring)

60.73K ops/s

0.22%

-1.5%

concurrent/16

asio (callbacks, io_uring)

61.64K ops/s

0.81%

baseline (io_uring)

concurrent/32

corosio (io_uring)

63.51K ops/s

0.28%

+3.3%

concurrent/32

asio (coroutines, io_uring)

60.65K ops/s

0.22%

-1.3%

concurrent/32

asio (callbacks, io_uring)

61.46K ops/s

0.87%

baseline (io_uring)

concurrent/4

corosio (io_uring)

61.36K ops/s

0.29%

+2.7%

concurrent/4

asio (coroutines, io_uring)

58.60K ops/s

0.33%

-1.9%

concurrent/4

asio (callbacks, io_uring)

59.72K ops/s

0.58%

baseline (io_uring)

multithread/1

corosio (io_uring)

63.29K ops/s

0.19%

+2.9%

multithread/1

asio (coroutines, io_uring)

60.53K ops/s

0.25%

-1.5%

multithread/1

asio (callbacks, io_uring)

61.48K ops/s

0.74%

baseline (io_uring)

multithread/16

corosio (io_uring)

100.3K ops/s

0.37%

+133.2%

multithread/16

asio (coroutines, io_uring)

40.28K ops/s

1.22%

-6.4%

multithread/16

asio (callbacks, io_uring)

43.02K ops/s

1.58%

baseline (io_uring)

multithread/2

corosio (io_uring)

75.19K ops/s

0.31%

+36.1%

multithread/2

asio (coroutines, io_uring)

53.36K ops/s

7.53%

-3.4%

multithread/2

asio (callbacks, io_uring)

55.26K ops/s

5.65%

baseline (io_uring)

multithread/4

corosio (io_uring)

118.2K ops/s

0.82%

+152.5%

multithread/4

asio (coroutines, io_uring)

45.90K ops/s

0.57%

-1.9%

multithread/4

asio (callbacks, io_uring)

46.81K ops/s

0.48%

baseline (io_uring)

multithread/8

corosio (io_uring)

111.7K ops/s

1.05%

+155.9%

multithread/8

asio (coroutines, io_uring)

42.15K ops/s

1.29%

-3.4%

multithread/8

asio (callbacks, io_uring)

43.65K ops/s

1.22%

baseline (io_uring)

single_conn

corosio (io_uring)

53.43K ops/s

0.31%

+0.8%

single_conn

asio (coroutines, io_uring)

52.24K ops/s

0.79%

-1.5%

single_conn

asio (callbacks, io_uring)

53.02K ops/s

0.66%

baseline (io_uring)

single_conn_lockless

corosio (io_uring)

55.12K ops/s

0.32%

+2.6%

single_conn_lockless

asio (coroutines, io_uring)

52.70K ops/s

0.72%

-1.9%

single_conn_lockless

asio (callbacks, io_uring)

53.72K ops/s

0.76%

baseline (io_uring)

epoll

http_server (epoll) — Linux ↑ faster · dotted line = asio (callbacks) · backend = epoll corosio asio (coroutines) -8% -6% -4% -2% +2% 0% concurrent/1 — N client/server pairs run the single_conn request/response loop concurrently; N is the number of connections. concurrent/1 — N client/server pairs run the single_conn request/response loop concurrently; N is the number of connections. concurrent/1 concurrent/16 — N client/server pairs run the single_conn request/response loop concurrently; N is the number of connections. concurrent/16 — N client/server pairs run the single_conn request/response loop concurrently; N is the number of connections. concurrent/16 concurrent/32 — N client/server pairs run the single_conn request/response loop concurrently; N is the number of connections. concurrent/32 — N client/server pairs run the single_conn request/response loop concurrently; N is the number of connections. concurrent/32 concurrent/4 — N client/server pairs run the single_conn request/response loop concurrently; N is the number of connections. concurrent/4 — N client/server pairs run the single_conn request/response loop concurrently; N is the number of connections. concurrent/4 multithread/1 — 32 client/server pairs share one context serviced by N threads running the context; N is the thread count. multithread/1 — 32 client/server pairs share one context serviced by N threads running the context; N is the thread count. multithread/1 multithread/16 — 32 client/server pairs share one context serviced by N threads running the context; N is the thread count. +0% multithread/16 — 32 client/server pairs share one context serviced by N threads running the context; N is the thread count. multithread/16 multithread/2 — 32 client/server pairs share one context serviced by N threads running the context; N is the thread count. -5% multithread/2 — 32 client/server pairs share one context serviced by N threads running the context; N is the thread count. multithread/2 multithread/4 — 32 client/server pairs share one context serviced by N threads running the context; N is the thread count. multithread/4 — 32 client/server pairs share one context serviced by N threads running the context; N is the thread count. multithread/4 multithread/8 — 32 client/server pairs share one context serviced by N threads running the context; N is the thread count. multithread/8 — 32 client/server pairs share one context serviced by N threads running the context; N is the thread count. -4% multithread/8 single_conn — One client repeatedly sends a fixed small HTTP request to one server and reads the response. single_conn — One client repeatedly sends a fixed small HTTP request to one server and reads the response. single_conn single_conn_lockless — Same as single_conn, with the context in single-threaded lockless mode. single_conn_lockless — Same as single_conn, with the context in single-threaded lockless mode. -2% single_conn_lockless
Detailed results
Benchmark Implementation Median CV vs asio

concurrent/1

corosio (epoll)

56.66K ops/s

0.21%

-4.4%

concurrent/1

asio (coroutines, epoll)

57.95K ops/s

1.00%

-2.2%

concurrent/1

asio (callbacks, epoll)

59.25K ops/s

0.85%

baseline (epoll)

concurrent/16

corosio (epoll)

59.88K ops/s

0.31%

-4.4%

concurrent/16

asio (coroutines, epoll)

61.18K ops/s

0.30%

-2.3%

concurrent/16

asio (callbacks, epoll)

62.65K ops/s

0.29%

baseline (epoll)

concurrent/32

corosio (epoll)

59.41K ops/s

0.22%

-4.4%

concurrent/32

asio (coroutines, epoll)

60.72K ops/s

0.17%

-2.3%

concurrent/32

asio (callbacks, epoll)

62.18K ops/s

0.22%

baseline (epoll)

concurrent/4

corosio (epoll)

59.14K ops/s

0.16%

-4.7%

concurrent/4

asio (coroutines, epoll)

60.71K ops/s

0.16%

-2.2%

concurrent/4

asio (callbacks, epoll)

62.06K ops/s

0.36%

baseline (epoll)

multithread/1

corosio (epoll)

59.32K ops/s

0.27%

-4.5%

multithread/1

asio (coroutines, epoll)

60.65K ops/s

0.28%

-2.4%

multithread/1

asio (callbacks, epoll)

62.12K ops/s

0.16%

baseline (epoll)

multithread/16

corosio (epoll)

162.9K ops/s

0.58%

+0.2%

multithread/16

asio (coroutines, epoll)

157.3K ops/s

0.34%

-3.3%

multithread/16

asio (callbacks, epoll)

162.6K ops/s

0.57%

baseline (epoll)

multithread/2

corosio (epoll)

88.52K ops/s

0.36%

-5.3%

multithread/2

asio (coroutines, epoll)

90.71K ops/s

0.16%

-3.0%

multithread/2

asio (callbacks, epoll)

93.52K ops/s

0.43%

baseline (epoll)

multithread/4

corosio (epoll)

159.2K ops/s

0.94%

-3.9%

multithread/4

asio (coroutines, epoll)

159.4K ops/s

0.67%

-3.7%

multithread/4

asio (callbacks, epoll)

165.6K ops/s

0.84%

baseline (epoll)

multithread/8

corosio (epoll)

162.2K ops/s

0.42%

-1.0%

multithread/8

asio (coroutines, epoll)

157.1K ops/s

0.40%

-4.1%

multithread/8

asio (callbacks, epoll)

163.8K ops/s

0.77%

baseline (epoll)

single_conn

corosio (epoll)

56.63K ops/s

0.21%

-4.6%

single_conn

asio (coroutines, epoll)

57.97K ops/s

0.93%

-2.3%

single_conn

asio (callbacks, epoll)

59.35K ops/s

0.87%

baseline (epoll)

single_conn_lockless

corosio (epoll)

57.19K ops/s

0.24%

-4.4%

single_conn_lockless

asio (coroutines, epoll)

58.51K ops/s

1.06%

-2.2%

single_conn_lockless

asio (callbacks, epoll)

59.80K ops/s

0.92%

baseline (epoll)


local_socket_latency

Round-trip latency of a single Unix domain stream socket write/read exchange across message sizes and concurrent pair counts.

io_uring

local_socket_latency (io_uring) — Linux ↑ faster (lower mean latency) · dotted line = asio (callbacks) · backend = io_uring corosio asio (coroutines) -20% +20% +40% +60% 0% concurrent/1 — N independent 64-byte pingpong pairs run concurrently on one context; N is the number of connection pairs. concurrent/1 — N independent 64-byte pingpong pairs run concurrently on one context; N is the number of connection pairs. concurrent/1 concurrent/16 — N independent 64-byte pingpong pairs run concurrently on one context; N is the number of connection pairs. concurrent/16 — N independent 64-byte pingpong pairs run concurrently on one context; N is the number of connection pairs. concurrent/16 concurrent/4 — N independent 64-byte pingpong pairs run concurrently on one context; N is the number of connection pairs. concurrent/4 — N independent 64-byte pingpong pairs run concurrently on one context; N is the number of connection pairs. concurrent/4 concurrent_lockless/1 — Same as concurrent, with the context in single-threaded lockless mode; N is the number of connection pairs. concurrent_lockless/1 — Same as concurrent, with the context in single-threaded lockless mode; N is the number of connection pairs. concurrent_lockless/1 concurrent_lockless/16 — Same as concurrent, with the context in single-threaded lockless mode; N is the number of connection pairs. +3% concurrent_lockless/16 — Same as concurrent, with the context in single-threaded lockless mode; N is the number of connection pairs. concurrent_lockless/16 concurrent_lockless/4 — Same as concurrent, with the context in single-threaded lockless mode; N is the number of connection pairs. concurrent_lockless/4 — Same as concurrent, with the context in single-threaded lockless mode; N is the number of connection pairs. concurrent_lockless/4 pingpong/1 — One connected Unix domain socket pair ping-pongs a message client->server->client; N is the message size in bytes. pingpong/1 — One connected Unix domain socket pair ping-pongs a message client->server->client; N is the message size in bytes. pingpong/1 pingpong/1024 — One connected Unix domain socket pair ping-pongs a message client->server->client; N is the message size in bytes. pingpong/1024 — One connected Unix domain socket pair ping-pongs a message client->server->client; N is the message size in bytes. -5% pingpong/1024 pingpong/64 — One connected Unix domain socket pair ping-pongs a message client->server->client; N is the message size in bytes. +35% pingpong/64 — One connected Unix domain socket pair ping-pongs a message client->server->client; N is the message size in bytes. pingpong/64 pingpong_lockless/1 — Same as pingpong, with the context in single-threaded lockless mode; N is the message size in bytes. pingpong_lockless/1 — Same as pingpong, with the context in single-threaded lockless mode; N is the message size in bytes. pingpong_lockless/1 pingpong_lockless/1024 — Same as pingpong, with the context in single-threaded lockless mode; N is the message size in bytes. pingpong_lockless/1024 — Same as pingpong, with the context in single-threaded lockless mode; N is the message size in bytes. -3% pingpong_lockless/1024 pingpong_lockless/64 — Same as pingpong, with the context in single-threaded lockless mode; N is the message size in bytes. pingpong_lockless/64 — Same as pingpong, with the context in single-threaded lockless mode; N is the message size in bytes. pingpong_lockless/64
Detailed results
Benchmark Implementation Median CV vs asio

concurrent/1

corosio (io_uring)

5.64 µs

3.19%

+34.4%

concurrent/1

asio (coroutines, io_uring)

8.86 µs

2.73%

-3.0%

concurrent/1

asio (callbacks, io_uring)

8.60 µs

2.93%

baseline (io_uring)

concurrent/16

corosio (io_uring)

93.02 µs

0.20%

+6.6%

concurrent/16

asio (coroutines, io_uring)

103.12 µs

1.06%

-3.6%

concurrent/16

asio (callbacks, io_uring)

99.56 µs

1.09%

baseline (io_uring)

concurrent/4

corosio (io_uring)

23.35 µs

1.20%

+12.8%

concurrent/4

asio (coroutines, io_uring)

27.84 µs

1.27%

-4.0%

concurrent/4

asio (callbacks, io_uring)

26.77 µs

0.92%

baseline (io_uring)

concurrent_lockless/1

corosio (io_uring)

5.62 µs

4.68%

+31.7%

concurrent_lockless/1

asio (coroutines, io_uring)

8.50 µs

3.90%

-3.4%

concurrent_lockless/1

asio (callbacks, io_uring)

8.22 µs

3.61%

baseline (io_uring)

concurrent_lockless/16

corosio (io_uring)

92.83 µs

0.13%

+3.3%

concurrent_lockless/16

asio (coroutines, io_uring)

99.62 µs

0.87%

-3.7%

concurrent_lockless/16

asio (callbacks, io_uring)

96.03 µs

0.85%

baseline (io_uring)

concurrent_lockless/4

corosio (io_uring)

23.28 µs

1.55%

+10.7%

concurrent_lockless/4

asio (coroutines, io_uring)

27.06 µs

1.82%

-3.7%

concurrent_lockless/4

asio (callbacks, io_uring)

26.09 µs

0.80%

baseline (io_uring)

pingpong/1

corosio (io_uring)

6.00 µs

4.64%

+29.9%

pingpong/1

asio (coroutines, io_uring)

8.80 µs

2.87%

-2.9%

pingpong/1

asio (callbacks, io_uring)

8.55 µs

2.89%

baseline (io_uring)

pingpong/1024

corosio (io_uring)

6.53 µs

5.13%

+26.3%

pingpong/1024

asio (coroutines, io_uring)

9.28 µs

3.65%

-4.8%

pingpong/1024

asio (callbacks, io_uring)

8.86 µs

4.00%

baseline (io_uring)

pingpong/64

corosio (io_uring)

5.65 µs

0.20%

+34.6%

pingpong/64

asio (coroutines, io_uring)

8.86 µs

2.85%

-2.6%

pingpong/64

asio (callbacks, io_uring)

8.63 µs

3.94%

baseline (io_uring)

pingpong_lockless/1

corosio (io_uring)

5.59 µs

4.37%

+31.7%

pingpong_lockless/1

asio (coroutines, io_uring)

8.45 µs

0.18%

-3.2%

pingpong_lockless/1

asio (callbacks, io_uring)

8.19 µs

3.42%

baseline (io_uring)

pingpong_lockless/1024

corosio (io_uring)

6.18 µs

4.67%

+32.4%

pingpong_lockless/1024

asio (coroutines, io_uring)

9.37 µs

3.98%

-2.6%

pingpong_lockless/1024

asio (callbacks, io_uring)

9.14 µs

4.45%

baseline (io_uring)

pingpong_lockless/64

corosio (io_uring)

5.62 µs

4.85%

+31.9%

pingpong_lockless/64

asio (coroutines, io_uring)

8.49 µs

3.85%

-2.9%

pingpong_lockless/64

asio (callbacks, io_uring)

8.25 µs

3.96%

baseline (io_uring)

epoll

local_socket_latency (epoll) — Linux ↑ faster (lower mean latency) · dotted line = asio (callbacks) · backend = epoll corosio asio (coroutines) -20% -10% +10% +20% 0% concurrent/1 — N independent 64-byte pingpong pairs run concurrently on one context; N is the number of connection pairs. concurrent/1 — N independent 64-byte pingpong pairs run concurrently on one context; N is the number of connection pairs. concurrent/1 concurrent/16 — N independent 64-byte pingpong pairs run concurrently on one context; N is the number of connection pairs. concurrent/16 — N independent 64-byte pingpong pairs run concurrently on one context; N is the number of connection pairs. concurrent/16 concurrent/4 — N independent 64-byte pingpong pairs run concurrently on one context; N is the number of connection pairs. concurrent/4 — N independent 64-byte pingpong pairs run concurrently on one context; N is the number of connection pairs. concurrent/4 concurrent_lockless/1 — Same as concurrent, with the context in single-threaded lockless mode; N is the number of connection pairs. concurrent_lockless/1 — Same as concurrent, with the context in single-threaded lockless mode; N is the number of connection pairs. concurrent_lockless/1 concurrent_lockless/16 — Same as concurrent, with the context in single-threaded lockless mode; N is the number of connection pairs. -10% concurrent_lockless/16 — Same as concurrent, with the context in single-threaded lockless mode; N is the number of connection pairs. concurrent_lockless/16 concurrent_lockless/4 — Same as concurrent, with the context in single-threaded lockless mode; N is the number of connection pairs. concurrent_lockless/4 — Same as concurrent, with the context in single-threaded lockless mode; N is the number of connection pairs. concurrent_lockless/4 pingpong/1 — One connected Unix domain socket pair ping-pongs a message client->server->client; N is the message size in bytes. pingpong/1 — One connected Unix domain socket pair ping-pongs a message client->server->client; N is the message size in bytes. pingpong/1 pingpong/1024 — One connected Unix domain socket pair ping-pongs a message client->server->client; N is the message size in bytes. pingpong/1024 — One connected Unix domain socket pair ping-pongs a message client->server->client; N is the message size in bytes. pingpong/1024 pingpong/64 — One connected Unix domain socket pair ping-pongs a message client->server->client; N is the message size in bytes. +11% pingpong/64 — One connected Unix domain socket pair ping-pongs a message client->server->client; N is the message size in bytes. -3% pingpong/64 pingpong_lockless/1 — Same as pingpong, with the context in single-threaded lockless mode; N is the message size in bytes. pingpong_lockless/1 — Same as pingpong, with the context in single-threaded lockless mode; N is the message size in bytes. pingpong_lockless/1 pingpong_lockless/1024 — Same as pingpong, with the context in single-threaded lockless mode; N is the message size in bytes. pingpong_lockless/1024 — Same as pingpong, with the context in single-threaded lockless mode; N is the message size in bytes. -9% pingpong_lockless/1024 pingpong_lockless/64 — Same as pingpong, with the context in single-threaded lockless mode; N is the message size in bytes. pingpong_lockless/64 — Same as pingpong, with the context in single-threaded lockless mode; N is the message size in bytes. pingpong_lockless/64
Detailed results
Benchmark Implementation Median CV vs asio

concurrent/1

corosio (epoll)

7.15 µs

3.53%

+10.7%

concurrent/1

asio (coroutines, epoll)

8.29 µs

2.47%

-3.5%

concurrent/1

asio (callbacks, epoll)

8.01 µs

4.30%

baseline (epoll)

concurrent/16

corosio (epoll)

110.59 µs

0.70%

-9.2%

concurrent/16

asio (coroutines, epoll)

107.43 µs

0.39%

-6.1%

concurrent/16

asio (callbacks, epoll)

101.26 µs

0.51%

baseline (epoll)

concurrent/4

corosio (epoll)

28.04 µs

1.16%

-4.1%

concurrent/4

asio (coroutines, epoll)

28.01 µs

1.35%

-4.0%

concurrent/4

asio (callbacks, epoll)

26.93 µs

1.20%

baseline (epoll)

concurrent_lockless/1

corosio (epoll)

7.04 µs

4.83%

+9.8%

concurrent_lockless/1

asio (coroutines, epoll)

8.07 µs

3.23%

-3.4%

concurrent_lockless/1

asio (callbacks, epoll)

7.80 µs

0.75%

baseline (epoll)

concurrent_lockless/16

corosio (epoll)

109.31 µs

0.30%

-10.4%

concurrent_lockless/16

asio (coroutines, epoll)

104.57 µs

0.31%

-5.6%

concurrent_lockless/16

asio (callbacks, epoll)

99.05 µs

0.68%

baseline (epoll)

concurrent_lockless/4

corosio (epoll)

27.41 µs

1.76%

-5.3%

concurrent_lockless/4

asio (coroutines, epoll)

27.61 µs

1.57%

-6.0%

concurrent_lockless/4

asio (callbacks, epoll)

26.04 µs

1.44%

baseline (epoll)

pingpong/1

corosio (epoll)

7.11 µs

0.70%

+10.7%

pingpong/1

asio (coroutines, epoll)

8.23 µs

1.13%

-3.4%

pingpong/1

asio (callbacks, epoll)

7.96 µs

2.20%

baseline (epoll)

pingpong/1024

corosio (epoll)

7.39 µs

3.62%

+10.5%

pingpong/1024

asio (coroutines, epoll)

8.93 µs

3.73%

-8.2%

pingpong/1024

asio (callbacks, epoll)

8.26 µs

4.10%

baseline (epoll)

pingpong/64

corosio (epoll)

7.15 µs

0.33%

+10.8%

pingpong/64

asio (coroutines, epoll)

8.27 µs

1.00%

-3.2%

pingpong/64

asio (callbacks, epoll)

8.01 µs

0.70%

baseline (epoll)

pingpong_lockless/1

corosio (epoll)

7.02 µs

4.62%

+9.7%

pingpong_lockless/1

asio (coroutines, epoll)

8.05 µs

4.11%

-3.4%

pingpong_lockless/1

asio (callbacks, epoll)

7.78 µs

4.00%

baseline (epoll)

pingpong_lockless/1024

corosio (epoll)

7.72 µs

4.08%

+6.7%

pingpong_lockless/1024

asio (coroutines, epoll)

9.00 µs

3.66%

-8.7%

pingpong_lockless/1024

asio (callbacks, epoll)

8.28 µs

3.57%

baseline (epoll)

pingpong_lockless/64

corosio (epoll)

7.06 µs

4.51%

+9.7%

pingpong_lockless/64

asio (coroutines, epoll)

8.08 µs

4.48%

-3.3%

pingpong_lockless/64

asio (callbacks, epoll)

7.82 µs

2.59%

baseline (epoll)


local_socket_throughput

Sustained byte throughput of a Unix domain stream socket pair under continuous streaming across chunk sizes and directions.

io_uring

local_socket_throughput (io_uring) — Linux, part 1 ↑ faster · dotted line = asio (callbacks) · backend = io_uring corosio asio (coroutines) -20% +20% +40% 0% bidirectional/1024 — Both ends of the socket pair write and read simultaneously; N is the chunk size in bytes. +30% bidirectional/1024 — Both ends of the socket pair write and read simultaneously; N is the chunk size in bytes. +3% bidirectional/1024 bidirectional/1048576 — Both ends of the socket pair write and read simultaneously; N is the chunk size in bytes. bidirectional/1048576 — Both ends of the socket pair write and read simultaneously; N is the chunk size in bytes. bidirectional/1048576 bidirectional/16384 — Both ends of the socket pair write and read simultaneously; N is the chunk size in bytes. bidirectional/16384 — Both ends of the socket pair write and read simultaneously; N is the chunk size in bytes. bidirectional/16384 bidirectional/262144 — Both ends of the socket pair write and read simultaneously; N is the chunk size in bytes. bidirectional/262144 — Both ends of the socket pair write and read simultaneously; N is the chunk size in bytes. bidirectional/262144 bidirectional/4096 — Both ends of the socket pair write and read simultaneously; N is the chunk size in bytes. bidirectional/4096 — Both ends of the socket pair write and read simultaneously; N is the chunk size in bytes. bidirectional/4096 bidirectional/65536 — Both ends of the socket pair write and read simultaneously; N is the chunk size in bytes. -6% bidirectional/65536 — Both ends of the socket pair write and read simultaneously; N is the chunk size in bytes. bidirectional/65536 bidirectional_lockless/1024 — Same as bidirectional, with the context in single-threaded lockless mode; N is the chunk size in bytes. bidirectional_lockless/1024 — Same as bidirectional, with the context in single-threaded lockless mode; N is the chunk size in bytes. -10% bidirectional_lockless/1024 bidirectional_lockless/1048576 — Same as bidirectional, with the context in single-threaded lockless mode; N is the chunk size in bytes. bidirectional_lockless/1048576 — Same as bidirectional, with the context in single-threaded lockless mode; N is the chunk size in bytes. bidirectional_lockless/1048576 bidirectional_lockless/16384 — Same as bidirectional, with the context in single-threaded lockless mode; N is the chunk size in bytes. bidirectional_lockless/16384 — Same as bidirectional, with the context in single-threaded lockless mode; N is the chunk size in bytes. bidirectional_lockless/16384 bidirectional_lockless/262144 — Same as bidirectional, with the context in single-threaded lockless mode; N is the chunk size in bytes. bidirectional_lockless/262144 — Same as bidirectional, with the context in single-threaded lockless mode; N is the chunk size in bytes. bidirectional_lockless/262144 bidirectional_lockless/4096 — Same as bidirectional, with the context in single-threaded lockless mode; N is the chunk size in bytes. bidirectional_lockless/4096 — Same as bidirectional, with the context in single-threaded lockless mode; N is the chunk size in bytes. bidirectional_lockless/4096 bidirectional_lockless/65536 — Same as bidirectional, with the context in single-threaded lockless mode; N is the chunk size in bytes. bidirectional_lockless/65536 — Same as bidirectional, with the context in single-threaded lockless mode; N is the chunk size in bytes. bidirectional_lockless/65536
Detailed results
Benchmark Implementation Median CV vs asio

bidirectional/1024

corosio (io_uring)

354.0 MB/s

0.52%

+29.8%

bidirectional/1024

asio (coroutines, io_uring)

282.1 MB/s

4.12%

+3.4%

bidirectional/1024

asio (callbacks, io_uring)

272.8 MB/s

3.94%

baseline (io_uring)

bidirectional/1048576

corosio (io_uring)

3.60 GB/s

2.82%

+2.3%

bidirectional/1048576

asio (coroutines, io_uring)

3.52 GB/s

2.45%

+0.1%

bidirectional/1048576

asio (callbacks, io_uring)

3.52 GB/s

2.61%

baseline (io_uring)

bidirectional/16384

corosio (io_uring)

2.95 GB/s

9.23%

+4.2%

bidirectional/16384

asio (coroutines, io_uring)

2.92 GB/s

2.66%

+3.2%

bidirectional/16384

asio (callbacks, io_uring)

2.83 GB/s

4.85%

baseline (io_uring)

bidirectional/262144

corosio (io_uring)

3.53 GB/s

2.55%

+0.6%

bidirectional/262144

asio (coroutines, io_uring)

3.49 GB/s

3.00%

-0.5%

bidirectional/262144

asio (callbacks, io_uring)

3.51 GB/s

2.37%

baseline (io_uring)

bidirectional/4096

corosio (io_uring)

1.13 GB/s

0.46%

+21.3%

bidirectional/4096

asio (coroutines, io_uring)

917.4 MB/s

2.64%

-1.7%

bidirectional/4096

asio (callbacks, io_uring)

932.9 MB/s

2.78%

baseline (io_uring)

bidirectional/65536

corosio (io_uring)

3.45 GB/s

2.06%

-6.4%

bidirectional/65536

asio (coroutines, io_uring)

3.64 GB/s

4.24%

-1.2%

bidirectional/65536

asio (callbacks, io_uring)

3.68 GB/s

3.92%

baseline (io_uring)

bidirectional_lockless/1024

corosio (io_uring)

354.7 MB/s

0.92%

+16.0%

bidirectional_lockless/1024

asio (coroutines, io_uring)

274.1 MB/s

4.83%

-10.4%

bidirectional_lockless/1024

asio (callbacks, io_uring)

305.9 MB/s

4.71%

baseline (io_uring)

bidirectional_lockless/1048576

corosio (io_uring)

3.56 GB/s

2.16%

+2.2%

bidirectional_lockless/1048576

asio (coroutines, io_uring)

3.54 GB/s

3.19%

+1.9%

bidirectional_lockless/1048576

asio (callbacks, io_uring)

3.48 GB/s

2.84%

baseline (io_uring)

bidirectional_lockless/16384

corosio (io_uring)

2.97 GB/s

9.64%

-1.9%

bidirectional_lockless/16384

asio (coroutines, io_uring)

2.99 GB/s

1.74%

-1.2%

bidirectional_lockless/16384

asio (callbacks, io_uring)

3.03 GB/s

5.07%

baseline (io_uring)

bidirectional_lockless/262144

corosio (io_uring)

3.51 GB/s

3.35%

+0.7%

bidirectional_lockless/262144

asio (coroutines, io_uring)

3.58 GB/s

2.72%

+2.7%

bidirectional_lockless/262144

asio (callbacks, io_uring)

3.48 GB/s

2.45%

baseline (io_uring)

bidirectional_lockless/4096

corosio (io_uring)

1.13 GB/s

0.49%

+17.5%

bidirectional_lockless/4096

asio (coroutines, io_uring)

932.4 MB/s

2.79%

-3.1%

bidirectional_lockless/4096

asio (callbacks, io_uring)

962.1 MB/s

2.79%

baseline (io_uring)

bidirectional_lockless/65536

corosio (io_uring)

3.49 GB/s

2.99%

-4.4%

bidirectional_lockless/65536

asio (coroutines, io_uring)

3.68 GB/s

4.76%

+0.7%

bidirectional_lockless/65536

asio (callbacks, io_uring)

3.65 GB/s

4.15%

baseline (io_uring)

local_socket_throughput (io_uring) — Linux, part 2 ↑ faster · dotted line = asio (callbacks) · backend = io_uring corosio asio (coroutines) -20% +20% +40% 0% unidirectional/1024 — One writer streams to one reader as fast as possible; N is the write/read chunk size in bytes. +29% unidirectional/1024 — One writer streams to one reader as fast as possible; N is the write/read chunk size in bytes. unidirectional/1024 unidirectional/1048576 — One writer streams to one reader as fast as possible; N is the write/read chunk size in bytes. unidirectional/1048576 — One writer streams to one reader as fast as possible; N is the write/read chunk size in bytes. unidirectional/1048576 unidirectional/16384 — One writer streams to one reader as fast as possible; N is the write/read chunk size in bytes. unidirectional/16384 — One writer streams to one reader as fast as possible; N is the write/read chunk size in bytes. unidirectional/16384 unidirectional/262144 — One writer streams to one reader as fast as possible; N is the write/read chunk size in bytes. unidirectional/262144 — One writer streams to one reader as fast as possible; N is the write/read chunk size in bytes. unidirectional/262144 unidirectional/4096 — One writer streams to one reader as fast as possible; N is the write/read chunk size in bytes. unidirectional/4096 — One writer streams to one reader as fast as possible; N is the write/read chunk size in bytes. unidirectional/4096 unidirectional/65536 — One writer streams to one reader as fast as possible; N is the write/read chunk size in bytes. -11% unidirectional/65536 — One writer streams to one reader as fast as possible; N is the write/read chunk size in bytes. unidirectional/65536 unidirectional_lockless/1024 — Same as unidirectional, with the context in single-threaded lockless mode; N is the chunk size in bytes. unidirectional_lockless/1024 — Same as unidirectional, with the context in single-threaded lockless mode; N is the chunk size in bytes. -3% unidirectional_lockless/1024 unidirectional_lockless/1048576 — Same as unidirectional, with the context in single-threaded lockless mode; N is the chunk size in bytes. unidirectional_lockless/1048576 — Same as unidirectional, with the context in single-threaded lockless mode; N is the chunk size in bytes. unidirectional_lockless/1048576 unidirectional_lockless/16384 — Same as unidirectional, with the context in single-threaded lockless mode; N is the chunk size in bytes. unidirectional_lockless/16384 — Same as unidirectional, with the context in single-threaded lockless mode; N is the chunk size in bytes. unidirectional_lockless/16384 unidirectional_lockless/262144 — Same as unidirectional, with the context in single-threaded lockless mode; N is the chunk size in bytes. unidirectional_lockless/262144 — Same as unidirectional, with the context in single-threaded lockless mode; N is the chunk size in bytes. +1% unidirectional_lockless/262144 unidirectional_lockless/4096 — Same as unidirectional, with the context in single-threaded lockless mode; N is the chunk size in bytes. unidirectional_lockless/4096 — Same as unidirectional, with the context in single-threaded lockless mode; N is the chunk size in bytes. unidirectional_lockless/4096 unidirectional_lockless/65536 — Same as unidirectional, with the context in single-threaded lockless mode; N is the chunk size in bytes. unidirectional_lockless/65536 — Same as unidirectional, with the context in single-threaded lockless mode; N is the chunk size in bytes. unidirectional_lockless/65536
Detailed results
Benchmark Implementation Median CV vs asio

unidirectional/1024

corosio (io_uring)

353.5 MB/s

0.52%

+29.3%

unidirectional/1024

asio (coroutines, io_uring)

265.2 MB/s

4.40%

-3.0%

unidirectional/1024

asio (callbacks, io_uring)

273.3 MB/s

4.00%

baseline (io_uring)

unidirectional/1048576

corosio (io_uring)

3.51 GB/s

3.25%

-0.9%

unidirectional/1048576

asio (coroutines, io_uring)

3.55 GB/s

2.82%

+0.3%

unidirectional/1048576

asio (callbacks, io_uring)

3.54 GB/s

2.68%

baseline (io_uring)

unidirectional/16384

corosio (io_uring)

2.98 GB/s

9.98%

+5.1%

unidirectional/16384

asio (coroutines, io_uring)

2.80 GB/s

2.57%

-1.3%

unidirectional/16384

asio (callbacks, io_uring)

2.84 GB/s

1.37%

baseline (io_uring)

unidirectional/262144

corosio (io_uring)

3.55 GB/s

3.20%

+0.7%

unidirectional/262144

asio (coroutines, io_uring)

3.54 GB/s

3.03%

+0.6%

unidirectional/262144

asio (callbacks, io_uring)

3.52 GB/s

2.76%

baseline (io_uring)

unidirectional/4096

corosio (io_uring)

1.13 GB/s

0.56%

+28.6%

unidirectional/4096

asio (coroutines, io_uring)

861.2 MB/s

0.25%

-1.9%

unidirectional/4096

asio (callbacks, io_uring)

878.0 MB/s

3.16%

baseline (io_uring)

unidirectional/65536

corosio (io_uring)

3.47 GB/s

3.34%

-11.0%

unidirectional/65536

asio (coroutines, io_uring)

3.85 GB/s

7.15%

-1.5%

unidirectional/65536

asio (callbacks, io_uring)

3.90 GB/s

6.63%

baseline (io_uring)

unidirectional_lockless/1024

corosio (io_uring)

356.9 MB/s

0.88%

+26.1%

unidirectional_lockless/1024

asio (coroutines, io_uring)

273.9 MB/s

4.10%

-3.2%

unidirectional_lockless/1024

asio (callbacks, io_uring)

283.0 MB/s

4.42%

baseline (io_uring)

unidirectional_lockless/1048576

corosio (io_uring)

3.57 GB/s

1.99%

+0.9%

unidirectional_lockless/1048576

asio (coroutines, io_uring)

3.56 GB/s

1.11%

+0.6%

unidirectional_lockless/1048576

asio (callbacks, io_uring)

3.54 GB/s

2.38%

baseline (io_uring)

unidirectional_lockless/16384

corosio (io_uring)

3.06 GB/s

11.63%

+6.5%

unidirectional_lockless/16384

asio (coroutines, io_uring)

2.84 GB/s

1.62%

-1.2%

unidirectional_lockless/16384

asio (callbacks, io_uring)

2.88 GB/s

2.94%

baseline (io_uring)

unidirectional_lockless/262144

corosio (io_uring)

3.59 GB/s

3.00%

+1.7%

unidirectional_lockless/262144

asio (coroutines, io_uring)

3.57 GB/s

1.40%

+1.3%

unidirectional_lockless/262144

asio (callbacks, io_uring)

3.53 GB/s

2.24%

baseline (io_uring)

unidirectional_lockless/4096

corosio (io_uring)

1.13 GB/s

0.31%

+24.8%

unidirectional_lockless/4096

asio (coroutines, io_uring)

879.6 MB/s

2.42%

-2.8%

unidirectional_lockless/4096

asio (callbacks, io_uring)

904.9 MB/s

0.69%

baseline (io_uring)

unidirectional_lockless/65536

corosio (io_uring)

3.51 GB/s

2.38%

-9.7%

unidirectional_lockless/65536

asio (coroutines, io_uring)

3.86 GB/s

5.41%

-0.7%

unidirectional_lockless/65536

asio (callbacks, io_uring)

3.89 GB/s

6.74%

baseline (io_uring)

epoll

local_socket_throughput (epoll) — Linux, part 1 ↑ faster · dotted line = asio (callbacks) · backend = epoll corosio asio (coroutines) -30% -20% -10% +10% +20% 0% bidirectional/1024 — Both ends of the socket pair write and read simultaneously; N is the chunk size in bytes. bidirectional/1024 — Both ends of the socket pair write and read simultaneously; N is the chunk size in bytes. bidirectional/1024 bidirectional/1048576 — Both ends of the socket pair write and read simultaneously; N is the chunk size in bytes. bidirectional/1048576 — Both ends of the socket pair write and read simultaneously; N is the chunk size in bytes. +2% bidirectional/1048576 bidirectional/16384 — Both ends of the socket pair write and read simultaneously; N is the chunk size in bytes. bidirectional/16384 — Both ends of the socket pair write and read simultaneously; N is the chunk size in bytes. bidirectional/16384 bidirectional/262144 — Both ends of the socket pair write and read simultaneously; N is the chunk size in bytes. bidirectional/262144 — Both ends of the socket pair write and read simultaneously; N is the chunk size in bytes. bidirectional/262144 bidirectional/4096 — Both ends of the socket pair write and read simultaneously; N is the chunk size in bytes. bidirectional/4096 — Both ends of the socket pair write and read simultaneously; N is the chunk size in bytes. bidirectional/4096 bidirectional/65536 — Both ends of the socket pair write and read simultaneously; N is the chunk size in bytes. -19% bidirectional/65536 — Both ends of the socket pair write and read simultaneously; N is the chunk size in bytes. bidirectional/65536 bidirectional_lockless/1024 — Same as bidirectional, with the context in single-threaded lockless mode; N is the chunk size in bytes. +9% bidirectional_lockless/1024 — Same as bidirectional, with the context in single-threaded lockless mode; N is the chunk size in bytes. bidirectional_lockless/1024 bidirectional_lockless/1048576 — Same as bidirectional, with the context in single-threaded lockless mode; N is the chunk size in bytes. bidirectional_lockless/1048576 — Same as bidirectional, with the context in single-threaded lockless mode; N is the chunk size in bytes. bidirectional_lockless/1048576 bidirectional_lockless/16384 — Same as bidirectional, with the context in single-threaded lockless mode; N is the chunk size in bytes. bidirectional_lockless/16384 — Same as bidirectional, with the context in single-threaded lockless mode; N is the chunk size in bytes. bidirectional_lockless/16384 bidirectional_lockless/262144 — Same as bidirectional, with the context in single-threaded lockless mode; N is the chunk size in bytes. bidirectional_lockless/262144 — Same as bidirectional, with the context in single-threaded lockless mode; N is the chunk size in bytes. bidirectional_lockless/262144 bidirectional_lockless/4096 — Same as bidirectional, with the context in single-threaded lockless mode; N is the chunk size in bytes. bidirectional_lockless/4096 — Same as bidirectional, with the context in single-threaded lockless mode; N is the chunk size in bytes. -5% bidirectional_lockless/4096 bidirectional_lockless/65536 — Same as bidirectional, with the context in single-threaded lockless mode; N is the chunk size in bytes. bidirectional_lockless/65536 — Same as bidirectional, with the context in single-threaded lockless mode; N is the chunk size in bytes. bidirectional_lockless/65536
Detailed results
Benchmark Implementation Median CV vs asio

bidirectional/1024

corosio (epoll)

304.0 MB/s

0.83%

+4.1%

bidirectional/1024

asio (coroutines, epoll)

285.7 MB/s

4.93%

-2.2%

bidirectional/1024

asio (callbacks, epoll)

292.2 MB/s

4.32%

baseline (epoll)

bidirectional/1048576

corosio (epoll)

3.28 GB/s

2.01%

+1.4%

bidirectional/1048576

asio (coroutines, epoll)

3.31 GB/s

1.85%

+2.2%

bidirectional/1048576

asio (callbacks, epoll)

3.24 GB/s

2.50%

baseline (epoll)

bidirectional/16384

corosio (epoll)

3.09 GB/s

0.93%

+3.3%

bidirectional/16384

asio (coroutines, epoll)

2.92 GB/s

2.36%

-2.4%

bidirectional/16384

asio (callbacks, epoll)

2.99 GB/s

3.64%

baseline (epoll)

bidirectional/262144

corosio (epoll)

3.25 GB/s

2.44%

+0.3%

bidirectional/262144

asio (coroutines, epoll)

3.27 GB/s

2.40%

+0.9%

bidirectional/262144

asio (callbacks, epoll)

3.24 GB/s

2.44%

baseline (epoll)

bidirectional/4096

corosio (epoll)

998.7 MB/s

1.01%

+4.9%

bidirectional/4096

asio (coroutines, epoll)

905.4 MB/s

3.15%

-4.9%

bidirectional/4096

asio (callbacks, epoll)

951.8 MB/s

2.66%

baseline (epoll)

bidirectional/65536

corosio (epoll)

2.99 GB/s

2.34%

-19.2%

bidirectional/65536

asio (coroutines, epoll)

3.65 GB/s

1.49%

-1.4%

bidirectional/65536

asio (callbacks, epoll)

3.70 GB/s

2.74%

baseline (epoll)

bidirectional_lockless/1024

corosio (epoll)

305.7 MB/s

0.32%

+8.7%

bidirectional_lockless/1024

asio (coroutines, epoll)

268.9 MB/s

5.22%

-4.4%

bidirectional_lockless/1024

asio (callbacks, epoll)

281.2 MB/s

4.91%

baseline (epoll)

bidirectional_lockless/1048576

corosio (epoll)

3.29 GB/s

1.75%

+0.6%

bidirectional_lockless/1048576

asio (coroutines, epoll)

3.30 GB/s

1.46%

+1.1%

bidirectional_lockless/1048576

asio (callbacks, epoll)

3.27 GB/s

1.74%

baseline (epoll)

bidirectional_lockless/16384

corosio (epoll)

3.08 GB/s

2.29%

+2.6%

bidirectional_lockless/16384

asio (coroutines, epoll)

2.95 GB/s

1.03%

-1.8%

bidirectional_lockless/16384

asio (callbacks, epoll)

3.00 GB/s

5.37%

baseline (epoll)

bidirectional_lockless/262144

corosio (epoll)

3.25 GB/s

2.51%

-0.1%

bidirectional_lockless/262144

asio (coroutines, epoll)

3.27 GB/s

2.08%

+0.6%

bidirectional_lockless/262144

asio (callbacks, epoll)

3.25 GB/s

1.90%

baseline (epoll)

bidirectional_lockless/4096

corosio (epoll)

1.01 GB/s

0.58%

+4.3%

bidirectional_lockless/4096

asio (coroutines, epoll)

915.5 MB/s

1.64%

-5.1%

bidirectional_lockless/4096

asio (callbacks, epoll)

964.4 MB/s

2.61%

baseline (epoll)

bidirectional_lockless/65536

corosio (epoll)

3.03 GB/s

2.43%

-19.0%

bidirectional_lockless/65536

asio (coroutines, epoll)

3.66 GB/s

1.36%

-2.2%

bidirectional_lockless/65536

asio (callbacks, epoll)

3.74 GB/s

2.09%

baseline (epoll)

local_socket_throughput (epoll) — Linux, part 2 ↑ faster · dotted line = asio (callbacks) · backend = epoll corosio asio (coroutines) -40% -20% +20% 0% unidirectional/1024 — One writer streams to one reader as fast as possible; N is the write/read chunk size in bytes. +14% unidirectional/1024 — One writer streams to one reader as fast as possible; N is the write/read chunk size in bytes. unidirectional/1024 unidirectional/1048576 — One writer streams to one reader as fast as possible; N is the write/read chunk size in bytes. unidirectional/1048576 — One writer streams to one reader as fast as possible; N is the write/read chunk size in bytes. +2% unidirectional/1048576 unidirectional/16384 — One writer streams to one reader as fast as possible; N is the write/read chunk size in bytes. unidirectional/16384 — One writer streams to one reader as fast as possible; N is the write/read chunk size in bytes. unidirectional/16384 unidirectional/262144 — One writer streams to one reader as fast as possible; N is the write/read chunk size in bytes. unidirectional/262144 — One writer streams to one reader as fast as possible; N is the write/read chunk size in bytes. unidirectional/262144 unidirectional/4096 — One writer streams to one reader as fast as possible; N is the write/read chunk size in bytes. unidirectional/4096 — One writer streams to one reader as fast as possible; N is the write/read chunk size in bytes. unidirectional/4096 unidirectional/65536 — One writer streams to one reader as fast as possible; N is the write/read chunk size in bytes. -18% unidirectional/65536 — One writer streams to one reader as fast as possible; N is the write/read chunk size in bytes. unidirectional/65536 unidirectional_lockless/1024 — Same as unidirectional, with the context in single-threaded lockless mode; N is the chunk size in bytes. unidirectional_lockless/1024 — Same as unidirectional, with the context in single-threaded lockless mode; N is the chunk size in bytes. -9% unidirectional_lockless/1024 unidirectional_lockless/1048576 — Same as unidirectional, with the context in single-threaded lockless mode; N is the chunk size in bytes. unidirectional_lockless/1048576 — Same as unidirectional, with the context in single-threaded lockless mode; N is the chunk size in bytes. unidirectional_lockless/1048576 unidirectional_lockless/16384 — Same as unidirectional, with the context in single-threaded lockless mode; N is the chunk size in bytes. unidirectional_lockless/16384 — Same as unidirectional, with the context in single-threaded lockless mode; N is the chunk size in bytes. unidirectional_lockless/16384 unidirectional_lockless/262144 — Same as unidirectional, with the context in single-threaded lockless mode; N is the chunk size in bytes. unidirectional_lockless/262144 — Same as unidirectional, with the context in single-threaded lockless mode; N is the chunk size in bytes. unidirectional_lockless/262144 unidirectional_lockless/4096 — Same as unidirectional, with the context in single-threaded lockless mode; N is the chunk size in bytes. unidirectional_lockless/4096 — Same as unidirectional, with the context in single-threaded lockless mode; N is the chunk size in bytes. unidirectional_lockless/4096 unidirectional_lockless/65536 — Same as unidirectional, with the context in single-threaded lockless mode; N is the chunk size in bytes. unidirectional_lockless/65536 — Same as unidirectional, with the context in single-threaded lockless mode; N is the chunk size in bytes. unidirectional_lockless/65536
Detailed results
Benchmark Implementation Median CV vs asio

unidirectional/1024

corosio (epoll)

297.9 MB/s

1.16%

+14.1%

unidirectional/1024

asio (coroutines, epoll)

245.6 MB/s

4.40%

-5.9%

unidirectional/1024

asio (callbacks, epoll)

261.0 MB/s

2.63%

baseline (epoll)

unidirectional/1048576

corosio (epoll)

3.31 GB/s

1.93%

-2.1%

unidirectional/1048576

asio (coroutines, epoll)

3.43 GB/s

3.86%

+1.7%

unidirectional/1048576

asio (callbacks, epoll)

3.38 GB/s

2.23%

baseline (epoll)

unidirectional/16384

corosio (epoll)

3.10 GB/s

0.69%

+7.8%

unidirectional/16384

asio (coroutines, epoll)

2.75 GB/s

2.44%

-4.2%

unidirectional/16384

asio (callbacks, epoll)

2.87 GB/s

2.29%

baseline (epoll)

unidirectional/262144

corosio (epoll)

3.30 GB/s

2.49%

-3.3%

unidirectional/262144

asio (coroutines, epoll)

3.46 GB/s

3.95%

+1.4%

unidirectional/262144

asio (callbacks, epoll)

3.42 GB/s

2.06%

baseline (epoll)

unidirectional/4096

corosio (epoll)

976.7 MB/s

0.26%

+8.6%

unidirectional/4096

asio (coroutines, epoll)

861.5 MB/s

2.35%

-4.2%

unidirectional/4096

asio (callbacks, epoll)

899.2 MB/s

3.04%

baseline (epoll)

unidirectional/65536

corosio (epoll)

3.27 GB/s

1.76%

-17.6%

unidirectional/65536

asio (coroutines, epoll)

3.79 GB/s

1.24%

-4.5%

unidirectional/65536

asio (callbacks, epoll)

3.97 GB/s

3.10%

baseline (epoll)

unidirectional_lockless/1024

corosio (epoll)

299.3 MB/s

0.83%

+4.5%

unidirectional_lockless/1024

asio (coroutines, epoll)

260.3 MB/s

4.90%

-9.1%

unidirectional_lockless/1024

asio (callbacks, epoll)

286.3 MB/s

4.33%

baseline (epoll)

unidirectional_lockless/1048576

corosio (epoll)

3.35 GB/s

2.39%

-1.2%

unidirectional_lockless/1048576

asio (coroutines, epoll)

3.44 GB/s

2.58%

+1.4%

unidirectional_lockless/1048576

asio (callbacks, epoll)

3.39 GB/s

1.91%

baseline (epoll)

unidirectional_lockless/16384

corosio (epoll)

3.09 GB/s

1.21%

+5.0%

unidirectional_lockless/16384

asio (coroutines, epoll)

2.82 GB/s

1.67%

-4.2%

unidirectional_lockless/16384

asio (callbacks, epoll)

2.94 GB/s

4.47%

baseline (epoll)

unidirectional_lockless/262144

corosio (epoll)

3.35 GB/s

3.12%

-2.0%

unidirectional_lockless/262144

asio (coroutines, epoll)

3.43 GB/s

2.98%

+0.3%

unidirectional_lockless/262144

asio (callbacks, epoll)

3.42 GB/s

2.11%

baseline (epoll)

unidirectional_lockless/4096

corosio (epoll)

986.6 MB/s

0.84%

+14.1%

unidirectional_lockless/4096

asio (coroutines, epoll)

875.0 MB/s

0.85%

+1.2%

unidirectional_lockless/4096

asio (callbacks, epoll)

864.7 MB/s

2.99%

baseline (epoll)

unidirectional_lockless/65536

corosio (epoll)

3.30 GB/s

1.67%

-16.3%

unidirectional_lockless/65536

asio (coroutines, epoll)

3.83 GB/s

1.27%

-3.0%

unidirectional_lockless/65536

asio (callbacks, epoll)

3.95 GB/s

3.27%

baseline (epoll)


socket_latency

Round-trip latency of a TCP loopback connection. Each sample is one full round trip (request out, reply back) across message sizes and concurrent pair counts.

io_uring

socket_latency (io_uring) — Linux ↑ faster (lower mean latency) · dotted line = asio (callbacks) · backend = io_uring corosio asio (coroutines) -10% +10% +20% +30% 0% concurrent/1 — N independent 64-byte pingpong pairs run concurrently on one context; N is the number of connection pairs. concurrent/1 — N independent 64-byte pingpong pairs run concurrently on one context; N is the number of connection pairs. -1% concurrent/1 concurrent/16 — N independent 64-byte pingpong pairs run concurrently on one context; N is the number of connection pairs. concurrent/16 — N independent 64-byte pingpong pairs run concurrently on one context; N is the number of connection pairs. concurrent/16 concurrent/4 — N independent 64-byte pingpong pairs run concurrently on one context; N is the number of connection pairs. concurrent/4 — N independent 64-byte pingpong pairs run concurrently on one context; N is the number of connection pairs. concurrent/4 concurrent_lockless/1 — Same as concurrent, with the context in single-threaded lockless mode; N is the number of connection pairs. concurrent_lockless/1 — Same as concurrent, with the context in single-threaded lockless mode; N is the number of connection pairs. concurrent_lockless/1 concurrent_lockless/16 — Same as concurrent, with the context in single-threaded lockless mode; N is the number of connection pairs. +2% concurrent_lockless/16 — Same as concurrent, with the context in single-threaded lockless mode; N is the number of connection pairs. concurrent_lockless/16 concurrent_lockless/4 — Same as concurrent, with the context in single-threaded lockless mode; N is the number of connection pairs. concurrent_lockless/4 — Same as concurrent, with the context in single-threaded lockless mode; N is the number of connection pairs. -2% concurrent_lockless/4 pingpong/1 — One TCP connection ping-pongs a message client->server->client; N is the message size in bytes. pingpong/1 — One TCP connection ping-pongs a message client->server->client; N is the message size in bytes. pingpong/1 pingpong/1024 — One TCP connection ping-pongs a message client->server->client; N is the message size in bytes. pingpong/1024 — One TCP connection ping-pongs a message client->server->client; N is the message size in bytes. pingpong/1024 pingpong/64 — One TCP connection ping-pongs a message client->server->client; N is the message size in bytes. +18% pingpong/64 — One TCP connection ping-pongs a message client->server->client; N is the message size in bytes. pingpong/64 pingpong_lockless/1 — Same as pingpong, with the context in single-threaded lockless mode; N is the message size in bytes. pingpong_lockless/1 — Same as pingpong, with the context in single-threaded lockless mode; N is the message size in bytes. pingpong_lockless/1 pingpong_lockless/1024 — Same as pingpong, with the context in single-threaded lockless mode; N is the message size in bytes. pingpong_lockless/1024 — Same as pingpong, with the context in single-threaded lockless mode; N is the message size in bytes. pingpong_lockless/1024 pingpong_lockless/64 — Same as pingpong, with the context in single-threaded lockless mode; N is the message size in bytes. pingpong_lockless/64 — Same as pingpong, with the context in single-threaded lockless mode; N is the message size in bytes. pingpong_lockless/64
Detailed results
Benchmark Implementation Median CV vs asio

concurrent/1

corosio (io_uring)

13.64 µs

0.26%

+18.0%

concurrent/1

asio (coroutines, io_uring)

16.82 µs

1.20%

-1.2%

concurrent/1

asio (callbacks, io_uring)

16.63 µs

1.00%

baseline (io_uring)

concurrent/16

corosio (io_uring)

219.92 µs

0.19%

+3.3%

concurrent/16

asio (coroutines, io_uring)

230.88 µs

0.97%

-1.6%

concurrent/16

asio (callbacks, io_uring)

227.33 µs

0.95%

baseline (io_uring)

concurrent/4

corosio (io_uring)

54.71 µs

0.22%

+6.6%

concurrent/4

asio (coroutines, io_uring)

59.58 µs

1.11%

-1.7%

concurrent/4

asio (callbacks, io_uring)

58.59 µs

0.93%

baseline (io_uring)

concurrent_lockless/1

corosio (io_uring)

13.57 µs

0.16%

+16.6%

concurrent_lockless/1

asio (coroutines, io_uring)

16.59 µs

0.56%

-1.9%

concurrent_lockless/1

asio (callbacks, io_uring)

16.28 µs

0.98%

baseline (io_uring)

concurrent_lockless/16

corosio (io_uring)

219.70 µs

0.14%

+1.8%

concurrent_lockless/16

asio (coroutines, io_uring)

228.10 µs

0.82%

-2.0%

concurrent_lockless/16

asio (callbacks, io_uring)

223.67 µs

0.79%

baseline (io_uring)

concurrent_lockless/4

corosio (io_uring)

54.61 µs

0.21%

+5.5%

concurrent_lockless/4

asio (coroutines, io_uring)

58.93 µs

0.68%

-2.0%

concurrent_lockless/4

asio (callbacks, io_uring)

57.76 µs

0.46%

baseline (io_uring)

pingpong/1

corosio (io_uring)

13.54 µs

1.29%

+18.1%

pingpong/1

asio (coroutines, io_uring)

16.82 µs

1.05%

-1.7%

pingpong/1

asio (callbacks, io_uring)

16.54 µs

1.09%

baseline (io_uring)

pingpong/1024

corosio (io_uring)

13.85 µs

1.00%

+18.2%

pingpong/1024

asio (coroutines, io_uring)

17.14 µs

0.94%

-1.2%

pingpong/1024

asio (callbacks, io_uring)

16.93 µs

1.24%

baseline (io_uring)

pingpong/64

corosio (io_uring)

13.58 µs

1.02%

+18.3%

pingpong/64

asio (coroutines, io_uring)

16.89 µs

0.93%

-1.6%

pingpong/64

asio (callbacks, io_uring)

16.63 µs

1.22%

baseline (io_uring)

pingpong_lockless/1

corosio (io_uring)

13.52 µs

0.94%

+16.7%

pingpong_lockless/1

asio (coroutines, io_uring)

16.49 µs

0.86%

-1.6%

pingpong_lockless/1

asio (callbacks, io_uring)

16.23 µs

0.94%

baseline (io_uring)

pingpong_lockless/1024

corosio (io_uring)

13.85 µs

0.24%

+16.4%

pingpong_lockless/1024

asio (coroutines, io_uring)

16.82 µs

1.21%

-1.5%

pingpong_lockless/1024

asio (callbacks, io_uring)

16.57 µs

0.66%

baseline (io_uring)

pingpong_lockless/64

corosio (io_uring)

13.60 µs

0.22%

+16.7%

pingpong_lockless/64

asio (coroutines, io_uring)

16.55 µs

1.16%

-1.3%

pingpong_lockless/64

asio (callbacks, io_uring)

16.33 µs

0.91%

baseline (io_uring)

epoll

socket_latency (epoll) — Linux ↑ faster (lower mean latency) · dotted line = asio (callbacks) · backend = epoll corosio asio (coroutines) -10% -5% +5% +10% 0% concurrent/1 — N independent 64-byte pingpong pairs run concurrently on one context; N is the number of connection pairs. concurrent/1 — N independent 64-byte pingpong pairs run concurrently on one context; N is the number of connection pairs. concurrent/1 concurrent/16 — N independent 64-byte pingpong pairs run concurrently on one context; N is the number of connection pairs. concurrent/16 — N independent 64-byte pingpong pairs run concurrently on one context; N is the number of connection pairs. concurrent/16 concurrent/4 — N independent 64-byte pingpong pairs run concurrently on one context; N is the number of connection pairs. concurrent/4 — N independent 64-byte pingpong pairs run concurrently on one context; N is the number of connection pairs. -3% concurrent/4 concurrent_lockless/1 — Same as concurrent, with the context in single-threaded lockless mode; N is the number of connection pairs. concurrent_lockless/1 — Same as concurrent, with the context in single-threaded lockless mode; N is the number of connection pairs. -2% concurrent_lockless/1 concurrent_lockless/16 — Same as concurrent, with the context in single-threaded lockless mode; N is the number of connection pairs. -5% concurrent_lockless/16 — Same as concurrent, with the context in single-threaded lockless mode; N is the number of connection pairs. concurrent_lockless/16 concurrent_lockless/4 — Same as concurrent, with the context in single-threaded lockless mode; N is the number of connection pairs. concurrent_lockless/4 — Same as concurrent, with the context in single-threaded lockless mode; N is the number of connection pairs. concurrent_lockless/4 pingpong/1 — One TCP connection ping-pongs a message client->server->client; N is the message size in bytes. pingpong/1 — One TCP connection ping-pongs a message client->server->client; N is the message size in bytes. pingpong/1 pingpong/1024 — One TCP connection ping-pongs a message client->server->client; N is the message size in bytes. pingpong/1024 — One TCP connection ping-pongs a message client->server->client; N is the message size in bytes. pingpong/1024 pingpong/64 — One TCP connection ping-pongs a message client->server->client; N is the message size in bytes. +6% pingpong/64 — One TCP connection ping-pongs a message client->server->client; N is the message size in bytes. pingpong/64 pingpong_lockless/1 — Same as pingpong, with the context in single-threaded lockless mode; N is the message size in bytes. pingpong_lockless/1 — Same as pingpong, with the context in single-threaded lockless mode; N is the message size in bytes. pingpong_lockless/1 pingpong_lockless/1024 — Same as pingpong, with the context in single-threaded lockless mode; N is the message size in bytes. pingpong_lockless/1024 — Same as pingpong, with the context in single-threaded lockless mode; N is the message size in bytes. pingpong_lockless/1024 pingpong_lockless/64 — Same as pingpong, with the context in single-threaded lockless mode; N is the message size in bytes. pingpong_lockless/64 — Same as pingpong, with the context in single-threaded lockless mode; N is the message size in bytes. pingpong_lockless/64
Detailed results
Benchmark Implementation Median CV vs asio

concurrent/1

corosio (epoll)

14.82 µs

1.02%

+5.7%

concurrent/1

asio (coroutines, epoll)

16.09 µs

0.21%

-2.4%

concurrent/1

asio (callbacks, epoll)

15.71 µs

0.26%

baseline (epoll)

concurrent/16

corosio (epoll)

233.61 µs

0.98%

-3.7%

concurrent/16

asio (coroutines, epoll)

231.78 µs

0.14%

-2.9%

concurrent/16

asio (callbacks, epoll)

225.33 µs

0.16%

baseline (epoll)

concurrent/4

corosio (epoll)

58.30 µs

0.92%

-1.6%

concurrent/4

asio (coroutines, epoll)

59.05 µs

0.18%

-2.9%

concurrent/4

asio (callbacks, epoll)

57.36 µs

0.18%

baseline (epoll)

concurrent_lockless/1

corosio (epoll)

14.73 µs

0.80%

+5.1%

concurrent_lockless/1

asio (coroutines, epoll)

15.84 µs

0.08%

-2.1%

concurrent_lockless/1

asio (callbacks, epoll)

15.52 µs

0.21%

baseline (epoll)

concurrent_lockless/16

corosio (epoll)

232.48 µs

0.17%

-4.6%

concurrent_lockless/16

asio (coroutines, epoll)

228.53 µs

0.93%

-2.8%

concurrent_lockless/16

asio (callbacks, epoll)

222.20 µs

0.89%

baseline (epoll)

concurrent_lockless/4

corosio (epoll)

57.99 µs

0.18%

-2.3%

concurrent_lockless/4

asio (coroutines, epoll)

58.32 µs

0.77%

-2.9%

concurrent_lockless/4

asio (callbacks, epoll)

56.70 µs

0.82%

baseline (epoll)

pingpong/1

corosio (epoll)

14.76 µs

0.28%

+5.7%

pingpong/1

asio (coroutines, epoll)

15.99 µs

0.87%

-2.2%

pingpong/1

asio (callbacks, epoll)

15.65 µs

1.17%

baseline (epoll)

pingpong/1024

corosio (epoll)

15.11 µs

0.15%

+5.3%

pingpong/1024

asio (coroutines, epoll)

16.35 µs

1.05%

-2.5%

pingpong/1024

asio (callbacks, epoll)

15.95 µs

1.14%

baseline (epoll)

pingpong/64

corosio (epoll)

14.80 µs

0.24%

+5.7%

pingpong/64

asio (coroutines, epoll)

16.07 µs

0.99%

-2.4%

pingpong/64

asio (callbacks, epoll)

15.70 µs

1.21%

baseline (epoll)

pingpong_lockless/1

corosio (epoll)

14.66 µs

0.23%

+5.0%

pingpong_lockless/1

asio (coroutines, epoll)

15.79 µs

1.01%

-2.3%

pingpong_lockless/1

asio (callbacks, epoll)

15.43 µs

0.93%

baseline (epoll)

pingpong_lockless/1024

corosio (epoll)

15.00 µs

0.94%

+4.8%

pingpong_lockless/1024

asio (coroutines, epoll)

16.10 µs

0.23%

-2.1%

pingpong_lockless/1024

asio (callbacks, epoll)

15.76 µs

0.19%

baseline (epoll)

pingpong_lockless/64

corosio (epoll)

14.73 µs

0.27%

+4.9%

pingpong_lockless/64

asio (coroutines, epoll)

15.83 µs

1.07%

-2.2%

pingpong_lockless/64

asio (callbacks, epoll)

15.49 µs

0.89%

baseline (epoll)


socket_throughput

Sustained byte throughput of a TCP loopback connection under continuous streaming, varying chunk size, direction, and concurrency.

io_uring

socket_throughput (io_uring) — Linux, part 1 ↑ faster · dotted line = asio (callbacks) · backend = io_uring corosio asio (coroutines) -5% +5% +10% +15% 0% bidirectional/1024 — Both ends of the connection write and read simultaneously; N is the chunk size in bytes. bidirectional/1024 — Both ends of the connection write and read simultaneously; N is the chunk size in bytes. bidirectional/1024 bidirectional/1048576 — Both ends of the connection write and read simultaneously; N is the chunk size in bytes. bidirectional/1048576 — Both ends of the connection write and read simultaneously; N is the chunk size in bytes. bidirectional/1048576 bidirectional/16384 — Both ends of the connection write and read simultaneously; N is the chunk size in bytes. bidirectional/16384 — Both ends of the connection write and read simultaneously; N is the chunk size in bytes. -3% bidirectional/16384 bidirectional/262144 — Both ends of the connection write and read simultaneously; N is the chunk size in bytes. bidirectional/262144 — Both ends of the connection write and read simultaneously; N is the chunk size in bytes. bidirectional/262144 bidirectional/4096 — Both ends of the connection write and read simultaneously; N is the chunk size in bytes. bidirectional/4096 — Both ends of the connection write and read simultaneously; N is the chunk size in bytes. bidirectional/4096 bidirectional/65536 — Both ends of the connection write and read simultaneously; N is the chunk size in bytes. bidirectional/65536 — Both ends of the connection write and read simultaneously; N is the chunk size in bytes. bidirectional/65536 bidirectional_lockless/1024 — Same as bidirectional, with the context in single-threaded lockless mode; N is the chunk size in bytes. bidirectional_lockless/1024 — Same as bidirectional, with the context in single-threaded lockless mode; N is the chunk size in bytes. bidirectional_lockless/1024 bidirectional_lockless/1048576 — Same as bidirectional, with the context in single-threaded lockless mode; N is the chunk size in bytes. bidirectional_lockless/1048576 — Same as bidirectional, with the context in single-threaded lockless mode; N is the chunk size in bytes. bidirectional_lockless/1048576 bidirectional_lockless/16384 — Same as bidirectional, with the context in single-threaded lockless mode; N is the chunk size in bytes. -2% bidirectional_lockless/16384 — Same as bidirectional, with the context in single-threaded lockless mode; N is the chunk size in bytes. bidirectional_lockless/16384 bidirectional_lockless/262144 — Same as bidirectional, with the context in single-threaded lockless mode; N is the chunk size in bytes. bidirectional_lockless/262144 — Same as bidirectional, with the context in single-threaded lockless mode; N is the chunk size in bytes. bidirectional_lockless/262144 bidirectional_lockless/4096 — Same as bidirectional, with the context in single-threaded lockless mode; N is the chunk size in bytes. bidirectional_lockless/4096 — Same as bidirectional, with the context in single-threaded lockless mode; N is the chunk size in bytes. bidirectional_lockless/4096 bidirectional_lockless/65536 — Same as bidirectional, with the context in single-threaded lockless mode; N is the chunk size in bytes. +12% bidirectional_lockless/65536 — Same as bidirectional, with the context in single-threaded lockless mode; N is the chunk size in bytes. +1% bidirectional_lockless/65536
Detailed results
Benchmark Implementation Median CV vs asio

bidirectional/1024

corosio (io_uring)

150.7 MB/s

0.17%

+9.3%

bidirectional/1024

asio (coroutines, io_uring)

136.1 MB/s

0.13%

-1.2%

bidirectional/1024

asio (callbacks, io_uring)

137.8 MB/s

0.17%

baseline (io_uring)

bidirectional/1048576

corosio (io_uring)

3.35 GB/s

0.69%

+0.7%

bidirectional/1048576

asio (coroutines, io_uring)

3.31 GB/s

1.19%

-0.5%

bidirectional/1048576

asio (callbacks, io_uring)

3.33 GB/s

1.48%

baseline (io_uring)

bidirectional/16384

corosio (io_uring)

1.62 GB/s

0.74%

-1.9%

bidirectional/16384

asio (coroutines, io_uring)

1.61 GB/s

1.83%

-2.5%

bidirectional/16384

asio (callbacks, io_uring)

1.65 GB/s

0.87%

baseline (io_uring)

bidirectional/262144

corosio (io_uring)

3.28 GB/s

0.58%

+10.3%

bidirectional/262144

asio (coroutines, io_uring)

2.97 GB/s

0.42%

-0.3%

bidirectional/262144

asio (callbacks, io_uring)

2.98 GB/s

0.69%

baseline (io_uring)

bidirectional/4096

corosio (io_uring)

520.9 MB/s

0.51%

+5.3%

bidirectional/4096

asio (coroutines, io_uring)

487.6 MB/s

0.23%

-1.4%

bidirectional/4096

asio (callbacks, io_uring)

494.5 MB/s

1.31%

baseline (io_uring)

bidirectional/65536

corosio (io_uring)

2.86 GB/s

1.54%

+8.5%

bidirectional/65536

asio (coroutines, io_uring)

2.63 GB/s

1.28%

-0.1%

bidirectional/65536

asio (callbacks, io_uring)

2.63 GB/s

0.93%

baseline (io_uring)

bidirectional_lockless/1024

corosio (io_uring)

150.7 MB/s

0.28%

+7.9%

bidirectional_lockless/1024

asio (coroutines, io_uring)

137.5 MB/s

0.27%

-1.6%

bidirectional_lockless/1024

asio (callbacks, io_uring)

139.7 MB/s

0.11%

baseline (io_uring)

bidirectional_lockless/1048576

corosio (io_uring)

3.34 GB/s

0.67%

+1.4%

bidirectional_lockless/1048576

asio (coroutines, io_uring)

3.30 GB/s

0.98%

+0.4%

bidirectional_lockless/1048576

asio (callbacks, io_uring)

3.29 GB/s

0.84%

baseline (io_uring)

bidirectional_lockless/16384

corosio (io_uring)

1.62 GB/s

0.93%

-2.0%

bidirectional_lockless/16384

asio (coroutines, io_uring)

1.63 GB/s

1.65%

-1.4%

bidirectional_lockless/16384

asio (callbacks, io_uring)

1.66 GB/s

1.24%

baseline (io_uring)

bidirectional_lockless/262144

corosio (io_uring)

3.25 GB/s

0.68%

+9.2%

bidirectional_lockless/262144

asio (coroutines, io_uring)

2.99 GB/s

1.73%

+0.5%

bidirectional_lockless/262144

asio (callbacks, io_uring)

2.97 GB/s

1.84%

baseline (io_uring)

bidirectional_lockless/4096

corosio (io_uring)

525.8 MB/s

0.24%

+4.5%

bidirectional_lockless/4096

asio (coroutines, io_uring)

491.9 MB/s

0.74%

-2.2%

bidirectional_lockless/4096

asio (callbacks, io_uring)

502.9 MB/s

0.50%

baseline (io_uring)

bidirectional_lockless/65536

corosio (io_uring)

2.90 GB/s

1.11%

+12.5%

bidirectional_lockless/65536

asio (coroutines, io_uring)

2.60 GB/s

1.95%

+0.8%

bidirectional_lockless/65536

asio (callbacks, io_uring)

2.58 GB/s

1.71%

baseline (io_uring)

socket_throughput (io_uring) — Linux, part 2 ↑ faster · dotted line = asio (callbacks) · backend = io_uring corosio asio (coroutines) -100% +100% +200% +300% +400% 0% multithread/2 — 32 bidirectional connection pairs share one context serviced by N threads running the context, with 64 KiB chunks; N is the thread count. +116% multithread/2 — 32 bidirectional connection pairs share one context serviced by N threads running the context, with 64 KiB chunks; N is the thread count. +2% multithread/2 multithread/4 — 32 bidirectional connection pairs share one context serviced by N threads running the context, with 64 KiB chunks; N is the thread count. +297% multithread/4 — 32 bidirectional connection pairs share one context serviced by N threads running the context, with 64 KiB chunks; N is the thread count. 0% multithread/4 multithread/8 — 32 bidirectional connection pairs share one context serviced by N threads running the context, with 64 KiB chunks; N is the thread count. +304% multithread/8 — 32 bidirectional connection pairs share one context serviced by N threads running the context, with 64 KiB chunks; N is the thread count. -1% multithread/8
Detailed results
Benchmark Implementation Median CV vs asio

multithread/2

corosio (io_uring)

4.25 GB/s

0.40%

+115.7%

multithread/2

asio (coroutines, io_uring)

2.02 GB/s

7.45%

+2.5%

multithread/2

asio (callbacks, io_uring)

1.97 GB/s

7.02%

baseline (io_uring)

multithread/4

corosio (io_uring)

6.81 GB/s

0.85%

+296.8%

multithread/4

asio (coroutines, io_uring)

1.71 GB/s

0.87%

-0.2%

multithread/4

asio (callbacks, io_uring)

1.72 GB/s

0.73%

baseline (io_uring)

multithread/8

corosio (io_uring)

6.89 GB/s

0.62%

+304.0%

multithread/8

asio (coroutines, io_uring)

1.69 GB/s

1.07%

-0.7%

multithread/8

asio (callbacks, io_uring)

1.71 GB/s

1.02%

baseline (io_uring)

socket_throughput (io_uring) — Linux, part 3 ↑ faster · dotted line = asio (callbacks) · backend = io_uring corosio asio (coroutines) -25% +25% +50% +75% 0% unidirectional/1024 — One writer streams to one reader as fast as possible; N is the write/read chunk size in bytes. +61% unidirectional/1024 — One writer streams to one reader as fast as possible; N is the write/read chunk size in bytes. unidirectional/1024 unidirectional/1048576 — One writer streams to one reader as fast as possible; N is the write/read chunk size in bytes. unidirectional/1048576 — One writer streams to one reader as fast as possible; N is the write/read chunk size in bytes. unidirectional/1048576 unidirectional/16384 — One writer streams to one reader as fast as possible; N is the write/read chunk size in bytes. unidirectional/16384 — One writer streams to one reader as fast as possible; N is the write/read chunk size in bytes. unidirectional/16384 unidirectional/262144 — One writer streams to one reader as fast as possible; N is the write/read chunk size in bytes. unidirectional/262144 — One writer streams to one reader as fast as possible; N is the write/read chunk size in bytes. unidirectional/262144 unidirectional/4096 — One writer streams to one reader as fast as possible; N is the write/read chunk size in bytes. unidirectional/4096 — One writer streams to one reader as fast as possible; N is the write/read chunk size in bytes. unidirectional/4096 unidirectional/65536 — One writer streams to one reader as fast as possible; N is the write/read chunk size in bytes. unidirectional/65536 — One writer streams to one reader as fast as possible; N is the write/read chunk size in bytes. unidirectional/65536 unidirectional_lockless/1024 — Same as unidirectional, with the context in single-threaded lockless mode; N is the chunk size in bytes. unidirectional_lockless/1024 — Same as unidirectional, with the context in single-threaded lockless mode; N is the chunk size in bytes. unidirectional_lockless/1024 unidirectional_lockless/1048576 — Same as unidirectional, with the context in single-threaded lockless mode; N is the chunk size in bytes. -4% unidirectional_lockless/1048576 — Same as unidirectional, with the context in single-threaded lockless mode; N is the chunk size in bytes. unidirectional_lockless/1048576 unidirectional_lockless/16384 — Same as unidirectional, with the context in single-threaded lockless mode; N is the chunk size in bytes. unidirectional_lockless/16384 — Same as unidirectional, with the context in single-threaded lockless mode; N is the chunk size in bytes. unidirectional_lockless/16384 unidirectional_lockless/262144 — Same as unidirectional, with the context in single-threaded lockless mode; N is the chunk size in bytes. unidirectional_lockless/262144 — Same as unidirectional, with the context in single-threaded lockless mode; N is the chunk size in bytes. +1% unidirectional_lockless/262144 unidirectional_lockless/4096 — Same as unidirectional, with the context in single-threaded lockless mode; N is the chunk size in bytes. unidirectional_lockless/4096 — Same as unidirectional, with the context in single-threaded lockless mode; N is the chunk size in bytes. unidirectional_lockless/4096 unidirectional_lockless/65536 — Same as unidirectional, with the context in single-threaded lockless mode; N is the chunk size in bytes. unidirectional_lockless/65536 — Same as unidirectional, with the context in single-threaded lockless mode; N is the chunk size in bytes. -3% unidirectional_lockless/65536
Detailed results
Benchmark Implementation Median CV vs asio

unidirectional/1024

corosio (io_uring)

148.4 MB/s

0.28%

+60.7%

unidirectional/1024

asio (coroutines, io_uring)

91.56 MB/s

0.96%

-0.9%

unidirectional/1024

asio (callbacks, io_uring)

92.35 MB/s

0.32%

baseline (io_uring)

unidirectional/1048576

corosio (io_uring)

3.41 GB/s

0.89%

+0.7%

unidirectional/1048576

asio (coroutines, io_uring)

3.37 GB/s

3.65%

-0.7%

unidirectional/1048576

asio (callbacks, io_uring)

3.39 GB/s

1.90%

baseline (io_uring)

unidirectional/16384

corosio (io_uring)

1.72 GB/s

0.33%

+29.2%

unidirectional/16384

asio (coroutines, io_uring)

1.30 GB/s

1.15%

-2.3%

unidirectional/16384

asio (callbacks, io_uring)

1.33 GB/s

1.39%

baseline (io_uring)

unidirectional/262144

corosio (io_uring)

3.26 GB/s

0.71%

+3.2%

unidirectional/262144

asio (coroutines, io_uring)

3.15 GB/s

1.04%

-0.4%

unidirectional/262144

asio (callbacks, io_uring)

3.16 GB/s

1.87%

baseline (io_uring)

unidirectional/4096

corosio (io_uring)

532.2 MB/s

1.41%

+47.7%

unidirectional/4096

asio (coroutines, io_uring)

357.5 MB/s

0.95%

-0.8%

unidirectional/4096

asio (callbacks, io_uring)

360.4 MB/s

0.46%

baseline (io_uring)

unidirectional/65536

corosio (io_uring)

2.81 GB/s

0.89%

+3.2%

unidirectional/65536

asio (coroutines, io_uring)

2.66 GB/s

1.74%

-2.5%

unidirectional/65536

asio (callbacks, io_uring)

2.73 GB/s

1.25%

baseline (io_uring)

unidirectional_lockless/1024

corosio (io_uring)

148.6 MB/s

0.27%

+58.8%

unidirectional_lockless/1024

asio (coroutines, io_uring)

92.55 MB/s

0.15%

-1.1%

unidirectional_lockless/1024

asio (callbacks, io_uring)

93.57 MB/s

0.15%

baseline (io_uring)

unidirectional_lockless/1048576

corosio (io_uring)

3.40 GB/s

1.39%

-4.0%

unidirectional_lockless/1048576

asio (coroutines, io_uring)

3.56 GB/s

0.56%

+0.4%

unidirectional_lockless/1048576

asio (callbacks, io_uring)

3.55 GB/s

0.55%

baseline (io_uring)

unidirectional_lockless/16384

corosio (io_uring)

1.72 GB/s

2.61%

+26.6%

unidirectional_lockless/16384

asio (coroutines, io_uring)

1.32 GB/s

1.75%

-2.3%

unidirectional_lockless/16384

asio (callbacks, io_uring)

1.36 GB/s

1.41%

baseline (io_uring)

unidirectional_lockless/262144

corosio (io_uring)

3.31 GB/s

1.27%

+5.9%

unidirectional_lockless/262144

asio (coroutines, io_uring)

3.17 GB/s

0.81%

+1.4%

unidirectional_lockless/262144

asio (callbacks, io_uring)

3.13 GB/s

0.50%

baseline (io_uring)

unidirectional_lockless/4096

corosio (io_uring)

520.7 MB/s

0.94%

+42.6%

unidirectional_lockless/4096

asio (coroutines, io_uring)

361.2 MB/s

0.17%

-1.1%

unidirectional_lockless/4096

asio (callbacks, io_uring)

365.1 MB/s

0.38%

baseline (io_uring)

unidirectional_lockless/65536

corosio (io_uring)

2.81 GB/s

2.79%

+3.3%

unidirectional_lockless/65536

asio (coroutines, io_uring)

2.63 GB/s

0.91%

-3.2%

unidirectional_lockless/65536

asio (callbacks, io_uring)

2.72 GB/s

1.05%

baseline (io_uring)

epoll

socket_throughput (epoll) — Linux, part 1 ↑ faster · dotted line = asio (callbacks) · backend = epoll corosio asio (coroutines) -10% -5% +5% +10% +15% 0% bidirectional/1024 — Both ends of the connection write and read simultaneously; N is the chunk size in bytes. bidirectional/1024 — Both ends of the connection write and read simultaneously; N is the chunk size in bytes. bidirectional/1024 bidirectional/1048576 — Both ends of the connection write and read simultaneously; N is the chunk size in bytes. bidirectional/1048576 — Both ends of the connection write and read simultaneously; N is the chunk size in bytes. bidirectional/1048576 bidirectional/16384 — Both ends of the connection write and read simultaneously; N is the chunk size in bytes. bidirectional/16384 — Both ends of the connection write and read simultaneously; N is the chunk size in bytes. -3% bidirectional/16384 bidirectional/262144 — Both ends of the connection write and read simultaneously; N is the chunk size in bytes. bidirectional/262144 — Both ends of the connection write and read simultaneously; N is the chunk size in bytes. bidirectional/262144 bidirectional/4096 — Both ends of the connection write and read simultaneously; N is the chunk size in bytes. bidirectional/4096 — Both ends of the connection write and read simultaneously; N is the chunk size in bytes. bidirectional/4096 bidirectional/65536 — Both ends of the connection write and read simultaneously; N is the chunk size in bytes. bidirectional/65536 — Both ends of the connection write and read simultaneously; N is the chunk size in bytes. +0% bidirectional/65536 bidirectional_lockless/1024 — Same as bidirectional, with the context in single-threaded lockless mode; N is the chunk size in bytes. -6% bidirectional_lockless/1024 — Same as bidirectional, with the context in single-threaded lockless mode; N is the chunk size in bytes. bidirectional_lockless/1024 bidirectional_lockless/1048576 — Same as bidirectional, with the context in single-threaded lockless mode; N is the chunk size in bytes. bidirectional_lockless/1048576 — Same as bidirectional, with the context in single-threaded lockless mode; N is the chunk size in bytes. bidirectional_lockless/1048576 bidirectional_lockless/16384 — Same as bidirectional, with the context in single-threaded lockless mode; N is the chunk size in bytes. bidirectional_lockless/16384 — Same as bidirectional, with the context in single-threaded lockless mode; N is the chunk size in bytes. bidirectional_lockless/16384 bidirectional_lockless/262144 — Same as bidirectional, with the context in single-threaded lockless mode; N is the chunk size in bytes. +9% bidirectional_lockless/262144 — Same as bidirectional, with the context in single-threaded lockless mode; N is the chunk size in bytes. bidirectional_lockless/262144 bidirectional_lockless/4096 — Same as bidirectional, with the context in single-threaded lockless mode; N is the chunk size in bytes. bidirectional_lockless/4096 — Same as bidirectional, with the context in single-threaded lockless mode; N is the chunk size in bytes. bidirectional_lockless/4096 bidirectional_lockless/65536 — Same as bidirectional, with the context in single-threaded lockless mode; N is the chunk size in bytes. bidirectional_lockless/65536 — Same as bidirectional, with the context in single-threaded lockless mode; N is the chunk size in bytes. bidirectional_lockless/65536
Detailed results
Benchmark Implementation Median CV vs asio

bidirectional/1024

corosio (epoll)

133.5 MB/s

0.37%

-5.5%

bidirectional/1024

asio (coroutines, epoll)

137.5 MB/s

1.11%

-2.7%

bidirectional/1024

asio (callbacks, epoll)

141.3 MB/s

0.12%

baseline (epoll)

bidirectional/1048576

corosio (epoll)

3.23 GB/s

2.57%

-2.7%

bidirectional/1048576

asio (coroutines, epoll)

3.31 GB/s

0.99%

-0.3%

bidirectional/1048576

asio (callbacks, epoll)

3.32 GB/s

1.45%

baseline (epoll)

bidirectional/16384

corosio (epoll)

1.63 GB/s

0.43%

-3.9%

bidirectional/16384

asio (coroutines, epoll)

1.64 GB/s

1.72%

-3.5%

bidirectional/16384

asio (callbacks, epoll)

1.70 GB/s

1.37%

baseline (epoll)

bidirectional/262144

corosio (epoll)

3.25 GB/s

0.61%

+9.3%

bidirectional/262144

asio (coroutines, epoll)

2.97 GB/s

1.42%

-0.2%

bidirectional/262144

asio (callbacks, epoll)

2.97 GB/s

1.09%

baseline (epoll)

bidirectional/4096

corosio (epoll)

503.7 MB/s

0.39%

-0.8%

bidirectional/4096

asio (coroutines, epoll)

494.8 MB/s

0.51%

-2.5%

bidirectional/4096

asio (callbacks, epoll)

507.5 MB/s

0.38%

baseline (epoll)

bidirectional/65536

corosio (epoll)

2.57 GB/s

1.76%

-1.4%

bidirectional/65536

asio (coroutines, epoll)

2.61 GB/s

1.78%

+0.4%

bidirectional/65536

asio (callbacks, epoll)

2.60 GB/s

1.70%

baseline (epoll)

bidirectional_lockless/1024

corosio (epoll)

133.8 MB/s

0.11%

-6.0%

bidirectional_lockless/1024

asio (coroutines, epoll)

138.8 MB/s

0.15%

-2.5%

bidirectional_lockless/1024

asio (callbacks, epoll)

142.4 MB/s

0.30%

baseline (epoll)

bidirectional_lockless/1048576

corosio (epoll)

3.28 GB/s

2.00%

-0.0%

bidirectional_lockless/1048576

asio (coroutines, epoll)

3.28 GB/s

0.86%

+0.2%

bidirectional_lockless/1048576

asio (callbacks, epoll)

3.28 GB/s

0.69%

baseline (epoll)

bidirectional_lockless/16384

corosio (epoll)

1.64 GB/s

1.15%

-4.4%

bidirectional_lockless/16384

asio (coroutines, epoll)

1.67 GB/s

1.64%

-2.5%

bidirectional_lockless/16384

asio (callbacks, epoll)

1.72 GB/s

1.61%

baseline (epoll)

bidirectional_lockless/262144

corosio (epoll)

3.22 GB/s

0.88%

+9.3%

bidirectional_lockless/262144

asio (coroutines, epoll)

2.93 GB/s

1.21%

-0.4%

bidirectional_lockless/262144

asio (callbacks, epoll)

2.94 GB/s

1.44%

baseline (epoll)

bidirectional_lockless/4096

corosio (epoll)

504.9 MB/s

0.47%

-1.4%

bidirectional_lockless/4096

asio (coroutines, epoll)

499.3 MB/s

1.05%

-2.5%

bidirectional_lockless/4096

asio (callbacks, epoll)

512.0 MB/s

0.55%

baseline (epoll)

bidirectional_lockless/65536

corosio (epoll)

2.60 GB/s

2.03%

-0.8%

bidirectional_lockless/65536

asio (coroutines, epoll)

2.57 GB/s

1.31%

-2.0%

bidirectional_lockless/65536

asio (callbacks, epoll)

2.62 GB/s

0.59%

baseline (epoll)

socket_throughput (epoll) — Linux, part 2 ↑ faster · dotted line = asio (callbacks) · backend = epoll corosio asio (coroutines) -20% +20% +40% +60% 0% multithread/2 — 32 bidirectional connection pairs share one context serviced by N threads running the context, with 64 KiB chunks; N is the thread count. +45% multithread/2 — 32 bidirectional connection pairs share one context serviced by N threads running the context, with 64 KiB chunks; N is the thread count. -5% multithread/2 multithread/4 — 32 bidirectional connection pairs share one context serviced by N threads running the context, with 64 KiB chunks; N is the thread count. +40% multithread/4 — 32 bidirectional connection pairs share one context serviced by N threads running the context, with 64 KiB chunks; N is the thread count. +0% multithread/4 multithread/8 — 32 bidirectional connection pairs share one context serviced by N threads running the context, with 64 KiB chunks; N is the thread count. +30% multithread/8 — 32 bidirectional connection pairs share one context serviced by N threads running the context, with 64 KiB chunks; N is the thread count. +0% multithread/8
Detailed results
Benchmark Implementation Median CV vs asio

multithread/2

corosio (epoll)

3.65 GB/s

0.73%

+45.2%

multithread/2

asio (coroutines, epoll)

2.40 GB/s

5.54%

-4.7%

multithread/2

asio (callbacks, epoll)

2.52 GB/s

1.21%

baseline (epoll)

multithread/4

corosio (epoll)

5.71 GB/s

1.11%

+40.3%

multithread/4

asio (coroutines, epoll)

4.09 GB/s

0.36%

+0.4%

multithread/4

asio (callbacks, epoll)

4.07 GB/s

0.45%

baseline (epoll)

multithread/8

corosio (epoll)

6.42 GB/s

0.65%

+30.3%

multithread/8

asio (coroutines, epoll)

4.93 GB/s

0.98%

+0.1%

multithread/8

asio (callbacks, epoll)

4.93 GB/s

0.36%

baseline (epoll)

socket_throughput (epoll) — Linux, part 3 ↑ faster · dotted line = asio (callbacks) · backend = epoll corosio asio (coroutines) -20% +20% +40% 0% unidirectional/1024 — One writer streams to one reader as fast as possible; N is the write/read chunk size in bytes. unidirectional/1024 — One writer streams to one reader as fast as possible; N is the write/read chunk size in bytes. unidirectional/1024 unidirectional/1048576 — One writer streams to one reader as fast as possible; N is the write/read chunk size in bytes. unidirectional/1048576 — One writer streams to one reader as fast as possible; N is the write/read chunk size in bytes. +0% unidirectional/1048576 unidirectional/16384 — One writer streams to one reader as fast as possible; N is the write/read chunk size in bytes. unidirectional/16384 — One writer streams to one reader as fast as possible; N is the write/read chunk size in bytes. unidirectional/16384 unidirectional/262144 — One writer streams to one reader as fast as possible; N is the write/read chunk size in bytes. unidirectional/262144 — One writer streams to one reader as fast as possible; N is the write/read chunk size in bytes. unidirectional/262144 unidirectional/4096 — One writer streams to one reader as fast as possible; N is the write/read chunk size in bytes. unidirectional/4096 — One writer streams to one reader as fast as possible; N is the write/read chunk size in bytes. unidirectional/4096 unidirectional/65536 — One writer streams to one reader as fast as possible; N is the write/read chunk size in bytes. unidirectional/65536 — One writer streams to one reader as fast as possible; N is the write/read chunk size in bytes. -4% unidirectional/65536 unidirectional_lockless/1024 — Same as unidirectional, with the context in single-threaded lockless mode; N is the chunk size in bytes. +32% unidirectional_lockless/1024 — Same as unidirectional, with the context in single-threaded lockless mode; N is the chunk size in bytes. unidirectional_lockless/1024 unidirectional_lockless/1048576 — Same as unidirectional, with the context in single-threaded lockless mode; N is the chunk size in bytes. -8% unidirectional_lockless/1048576 — Same as unidirectional, with the context in single-threaded lockless mode; N is the chunk size in bytes. unidirectional_lockless/1048576 unidirectional_lockless/16384 — Same as unidirectional, with the context in single-threaded lockless mode; N is the chunk size in bytes. unidirectional_lockless/16384 — Same as unidirectional, with the context in single-threaded lockless mode; N is the chunk size in bytes. unidirectional_lockless/16384 unidirectional_lockless/262144 — Same as unidirectional, with the context in single-threaded lockless mode; N is the chunk size in bytes. unidirectional_lockless/262144 — Same as unidirectional, with the context in single-threaded lockless mode; N is the chunk size in bytes. unidirectional_lockless/262144 unidirectional_lockless/4096 — Same as unidirectional, with the context in single-threaded lockless mode; N is the chunk size in bytes. unidirectional_lockless/4096 — Same as unidirectional, with the context in single-threaded lockless mode; N is the chunk size in bytes. unidirectional_lockless/4096 unidirectional_lockless/65536 — Same as unidirectional, with the context in single-threaded lockless mode; N is the chunk size in bytes. unidirectional_lockless/65536 — Same as unidirectional, with the context in single-threaded lockless mode; N is the chunk size in bytes. unidirectional_lockless/65536
Detailed results
Benchmark Implementation Median CV vs asio

unidirectional/1024

corosio (epoll)

125.0 MB/s

0.88%

+32.0%

unidirectional/1024

asio (coroutines, epoll)

92.73 MB/s

0.24%

-2.1%

unidirectional/1024

asio (callbacks, epoll)

94.73 MB/s

0.89%

baseline (epoll)

unidirectional/1048576

corosio (epoll)

3.38 GB/s

0.68%

-1.4%

unidirectional/1048576

asio (coroutines, epoll)

3.43 GB/s

2.39%

+0.2%

unidirectional/1048576

asio (callbacks, epoll)

3.42 GB/s

1.66%

baseline (epoll)

unidirectional/16384

corosio (epoll)

1.54 GB/s

1.80%

+11.8%

unidirectional/16384

asio (coroutines, epoll)

1.35 GB/s

1.27%

-2.2%

unidirectional/16384

asio (callbacks, epoll)

1.38 GB/s

1.67%

baseline (epoll)

unidirectional/262144

corosio (epoll)

3.35 GB/s

1.17%

+5.9%

unidirectional/262144

asio (coroutines, epoll)

3.15 GB/s

1.78%

-0.4%

unidirectional/262144

asio (callbacks, epoll)

3.16 GB/s

1.39%

baseline (epoll)

unidirectional/4096

corosio (epoll)

469.2 MB/s

1.26%

+27.2%

unidirectional/4096

asio (coroutines, epoll)

360.1 MB/s

0.39%

-2.4%

unidirectional/4096

asio (callbacks, epoll)

368.9 MB/s

1.16%

baseline (epoll)

unidirectional/65536

corosio (epoll)

2.77 GB/s

4.67%

-0.2%

unidirectional/65536

asio (coroutines, epoll)

2.68 GB/s

1.41%

-3.5%

unidirectional/65536

asio (callbacks, epoll)

2.78 GB/s

2.39%

baseline (epoll)

unidirectional_lockless/1024

corosio (epoll)

125.7 MB/s

0.17%

+32.1%

unidirectional_lockless/1024

asio (coroutines, epoll)

93.29 MB/s

1.40%

-1.9%

unidirectional_lockless/1024

asio (callbacks, epoll)

95.15 MB/s

0.19%

baseline (epoll)

unidirectional_lockless/1048576

corosio (epoll)

3.31 GB/s

1.63%

-7.5%

unidirectional_lockless/1048576

asio (coroutines, epoll)

3.55 GB/s

3.14%

-0.7%

unidirectional_lockless/1048576

asio (callbacks, epoll)

3.58 GB/s

0.62%

baseline (epoll)

unidirectional_lockless/16384

corosio (epoll)

1.56 GB/s

0.78%

+13.2%

unidirectional_lockless/16384

asio (coroutines, epoll)

1.36 GB/s

0.82%

-1.4%

unidirectional_lockless/16384

asio (callbacks, epoll)

1.38 GB/s

0.86%

baseline (epoll)

unidirectional_lockless/262144

corosio (epoll)

3.33 GB/s

1.13%

+4.9%

unidirectional_lockless/262144

asio (coroutines, epoll)

3.17 GB/s

0.92%

-0.1%

unidirectional_lockless/262144

asio (callbacks, epoll)

3.18 GB/s

0.67%

baseline (epoll)

unidirectional_lockless/4096

corosio (epoll)

469.2 MB/s

1.14%

+26.3%

unidirectional_lockless/4096

asio (coroutines, epoll)

364.0 MB/s

1.12%

-2.0%

unidirectional_lockless/4096

asio (callbacks, epoll)

371.4 MB/s

0.32%

baseline (epoll)

unidirectional_lockless/65536

corosio (epoll)

2.82 GB/s

0.63%

+2.1%

unidirectional_lockless/65536

asio (coroutines, epoll)

2.68 GB/s

2.47%

-3.0%

unidirectional_lockless/65536

asio (callbacks, epoll)

2.76 GB/s

1.87%

baseline (epoll)