Boost.Corosio Performance Benchmarks

Executive Summary

This report presents comprehensive performance benchmarks comparing Boost.Corosio against Boost.Asio on Windows using the IOCP (I/O Completion Ports) backend. The benchmarks cover HTTP server throughput, socket latency, socket throughput, and raw io_context handler dispatch.

Bottom Line

Corosio demonstrates superior performance in high-parallelism I/O-bound workloads while exhibiting measurable per-operation overhead in single-threaded scenarios. The library’s coroutine-native architecture trades baseline latency for better scaling characteristics, making it well-suited for modern multi-core server deployments.

Where Corosio Excels

  • Multi-threaded HTTP throughput: Outperforms Asio by 8% at 8 threads (266 vs 247 Kops/s), with superior scaling factor (3.71× vs 2.72×)

  • Large-buffer throughput: Achieves 13% higher unidirectional throughput at 64KB buffers (5.02 vs 4.46 GB/s)

  • Tail latency at low concurrency: Delivers 27% better p99 latency in single-pair socket operations (21.8 vs 29.9 μs)

  • Multi-threaded scaling efficiency: Scales 36% more efficiently from 1→8 threads in HTTP workloads

Where Corosio Needs Improvement

  • Per-operation overhead: Adds ~2.5-2.8 μs per I/O round-trip, resulting in 20-30% lower single-threaded throughput

  • Small-buffer throughput: 21-27% slower at 1-4KB buffer sizes due to per-operation overhead dominating

  • Handler dispatch performance: Scheduler is 11-72% slower than Asio across all tested scenarios

  • Scheduler scalability: Throughput plateaus and slightly regresses at 8 threads (contention issue)

  • Tail latency under concurrency: p99 latency degrades faster than Asio as concurrent connections increase

Key Insights

The benchmarks reveal an architectural trade-off:

Component Assessment

I/O Completion Path

Corosio’s coroutine integration is highly efficient—compensates for scheduler overhead in real I/O workloads

Handler Scheduler

Asio’s scheduler is faster and scales better—Corosio has contention at high thread counts

Data Transfer Path

Corosio excels at large transfers; overhead matters more for small, frequent operations

Next Steps

  1. Profile scheduler contention: Investigate the 8-thread throughput plateau in handler dispatch—likely lock contention or false sharing

  2. Reduce per-operation overhead: Target the ~2.5 μs gap through coroutine frame optimization or allocation reduction

  3. Benchmark on Linux: Validate findings on epoll backend to ensure cross-platform consistency

  4. Test realistic workloads: Measure with mixed payload sizes and real-world HTTP traffic patterns

  5. Memory profiling: Quantify allocation behavior under sustained load

Detailed Results

HTTP Server Benchmarks

Scenario Corosio Asio Winner

Single connection sequential

73.7 Kops/s

90.3 Kops/s

Asio (+22%)

32 connections, 1 thread

71.7 Kops/s

90.9 Kops/s

Asio (+27%)

32 connections, 8 threads

266.3 Kops/s

246.9 Kops/s

Corosio (+8%)

Socket Throughput

Scenario Corosio Asio Winner

Unidirectional 1KB buffer

164 MB/s

207 MB/s

Asio (+27%)

Unidirectional 64KB buffer

5.02 GB/s

4.46 GB/s

Corosio (+13%)

Bidirectional 64KB buffer

4.98 GB/s

5.74 GB/s

Asio (+15%)

Socket Latency (Ping-Pong)

Scenario Corosio Asio Winner

Single pair (64B)

12.45 μs

9.61 μs

Asio (+30%)

Single pair p99

21.80 μs

29.92 μs

Corosio (-27%)

16 concurrent pairs

205.93 μs

167.20 μs

Asio (+23%)

io_context Handler Dispatch

Scenario Corosio Asio Winner

Single-threaded post

809 Kops/s

911 Kops/s

Asio (+13%)

Multi-threaded (8 threads)

2.36 Mops/s

4.06 Mops/s

Asio (+72%)

Interleaved post/run

1.03 Mops/s

1.65 Mops/s

Asio (+60%)

Test Environment

Platform

Windows (IOCP backend)

Benchmarks

HTTP server, socket latency, socket throughput, io_context handler dispatch

Measurement

Client-side latency and throughput

Benchmark Categories

Category What It Measures

HTTP Server

End-to-end request/response including parsing, I/O completion, and network stack

Socket Latency

Raw TCP round-trip time, isolating network I/O from protocol overhead

Socket Throughput

Bulk data transfer rates with varying buffer sizes

io_context Dispatch

Pure handler posting and execution, isolating scheduler from I/O

Benchmark Results

Single Connection (Sequential Requests)

Sequential requests over a single connection measure the baseline per-operation overhead with no concurrency.

Metric Corosio Asio Difference

Throughput

73.69 Kops/s

90.29 Kops/s

-18.4%

Mean latency

13.53 μs

11.03 μs

+22.7%

p50 latency

12.80 μs

10.50 μs

+21.9%

p90 latency

13.20 μs

10.80 μs

+22.2%

p99 latency

30.30 μs

23.70 μs

+27.8%

p99.9 latency

67.21 μs

69.60 μs

-3.4%

Min latency

12.00 μs

10.20 μs

+17.6%

Max latency

251.00 μs

185.90 μs

+35.0%

The ~2.5 μs mean latency difference suggests Corosio has additional per-operation overhead, likely from coroutine machinery.

Concurrent Connections (Single Thread)

Testing with multiple concurrent connections on a single thread measures how each implementation handles connection multiplexing.

Connections Requests Corosio Throughput Asio Throughput Gap Notes

1

10,000

76.33 Kops/s

92.47 Kops/s

-17.4%

Baseline

4

10,000

73.17 Kops/s

91.10 Kops/s

-19.7%

Minimal degradation

16

10,000

72.02 Kops/s

91.38 Kops/s

-21.2%

Gap widens slightly

32

9,984

73.91 Kops/s

89.94 Kops/s

-17.8%

Stable at scale

Observation: Both implementations maintain consistent throughput as connection count increases, demonstrating efficient IOCP utilization. Asio maintains a ~20% advantage throughout.

Latency Under Concurrency

Connections Corosio Mean Asio Mean Corosio p99 Asio p99

1

13.07 μs

10.78 μs

15.70 μs

17.00 μs

4

54.62 μs

43.86 μs

115.60 μs

63.00 μs

16

221.86 μs

174.78 μs

480.36 μs

208.96 μs

32

432.09 μs

354.78 μs

632.41 μs

476.11 μs

Corosio exhibits higher p99 tail latency under concurrent load, suggesting more variance in coroutine scheduling.

Multi-Threaded Scaling

The most significant benchmark: 32 concurrent connections with varying thread counts to measure scaling efficiency.

Threads Corosio Throughput Asio Throughput Gap Scaling Factor

1

71.70 Kops/s

90.92 Kops/s

-21.1%

(baseline)

2

100.95 Kops/s

119.20 Kops/s

-15.3%

1.41× / 1.31×

4

178.64 Kops/s

196.41 Kops/s

-9.1%

2.49× / 2.16×

8

266.34 Kops/s

246.88 Kops/s

+7.9%

3.71× / 2.72×

Scaling Efficiency

Threads   Corosio Scaling    Asio Scaling
   1         1.00×              1.00×
   2         1.41×              1.31×
   4         2.49×              2.16×
   8         3.71×              2.72×

Critical insight: Corosio achieves 3.71× scaling from 1 to 8 threads compared to Asio’s 2.72× scaling—a 36% better scaling factor.

Multi-Threaded Latency

Threads Corosio Mean Asio Mean Corosio p99 Asio p99

1

445.31 μs

351.06 μs

624.32 μs

494.55 μs

2

312.81 μs

266.20 μs

394.50 μs

337.81 μs

4

175.47 μs

159.89 μs

224.65 μs

192.70 μs

8

109.45 μs

111.63 μs

183.40 μs

157.26 μs

At 8 threads, mean latencies converge (109 μs vs 112 μs), while Corosio maintains slightly higher p99 tail latency.

Socket Latency

These benchmarks measure raw TCP socket round-trip latency using a ping-pong pattern, isolating network I/O from HTTP parsing overhead.

Ping-Pong Round-Trip Latency

Single socket pair exchanging messages of varying sizes (1,000 iterations each).

Message Size Corosio Mean Asio Mean Difference Corosio p99 Asio p99

1 byte

12.56 μs

10.49 μs

+19.7%

18.70 μs

27.51 μs

64 bytes

12.45 μs

9.61 μs

+29.6%

22.00 μs

11.11 μs

1024 bytes

12.51 μs

9.86 μs

+26.9%

17.34 μs

10.70 μs

Latency Distribution (64-byte messages)

Percentile Corosio Asio Difference

p50

12.10 μs

9.50 μs

+27.4%

p90

12.30 μs

9.70 μs

+26.8%

p99

22.00 μs

11.11 μs

+98.0%

p99.9

60.20 μs

28.50 μs

+111.2%

min

11.90 μs

9.20 μs

+29.3%

max

64.60 μs

32.80 μs

+96.9%

Observation: Corosio adds approximately 2.8 μs overhead per round-trip. This is consistent with the ~2.5 μs overhead observed in HTTP benchmarks, confirming the overhead is in the socket I/O path rather than HTTP parsing.

Concurrent Socket Pairs

Multiple socket pairs operating concurrently (64-byte messages).

Pairs Iterations Corosio Mean Asio Mean Corosio p99 Asio p99

1

1,000

12.42 μs

10.31 μs

21.80 μs

29.92 μs

4

500

51.78 μs

40.59 μs

113.10 μs

67.98 μs

16

250

205.93 μs

167.20 μs

300.75 μs

262.52 μs

Concurrent Latency Analysis

Mean Latency Gap vs Concurrency:

  1 pair:   Asio +20%  ████████████████████
  4 pairs:  Asio +28%  ████████████████████████████
  16 pairs: Asio +23%  ███████████████████████

p99 Tail Latency:

  1 pair:   Corosio -27%  ████████ ←── Corosio wins!
  4 pairs:  Asio +66%     ██████████████████████████████████
  16 pairs: Asio +15%     ███████████████

Notable finding: At single-pair operation, Corosio achieves 27% better p99 tail latency (21.80 μs vs 29.92 μs) despite higher mean latency. This suggests Corosio’s coroutine-based design has more predictable scheduling behavior under low load.

As concurrency increases, Asio’s p99 advantage grows, indicating Corosio’s scheduler introduces more variance under contention—consistent with the handler dispatch benchmark findings.

Socket Throughput

These benchmarks measure bulk data transfer performance, testing how efficiently each implementation handles sustained I/O with varying buffer sizes.

Unidirectional Throughput

Single direction transfer of 64 MB with varying buffer sizes.

Buffer Size Corosio Asio Difference

1024 bytes

163.75 MB/s

207.24 MB/s

-21.0%

4096 bytes

536.61 MB/s

681.62 MB/s

-21.3%

16384 bytes

2.07 GB/s

2.25 GB/s

-8.0%

65536 bytes

5.02 GB/s

4.46 GB/s

+12.5%

Throughput Scaling Analysis

Throughput vs Buffer Size:

Buffer    Corosio      Asio        Winner
1KB       164 MB/s     207 MB/s    Asio +27%
4KB       537 MB/s     682 MB/s    Asio +27%
16KB      2.07 GB/s    2.25 GB/s   Asio +9%
64KB      5.02 GB/s    4.46 GB/s   Corosio +13%  ←── Crossover!

Critical insight: The crossover at 64KB reveals Corosio’s per-operation overhead. At small buffers, more operations are needed to transfer the same data, amplifying the ~2.5 μs overhead. At large buffers, Corosio’s efficient I/O completion path dominates.

Bidirectional Throughput

Simultaneous transfer of 32 MB in each direction (64 MB total).

Buffer Size Corosio Asio Difference

1024 bytes

155.84 MB/s

196.83 MB/s

-20.8%

4096 bytes

590.39 MB/s

704.04 MB/s

-16.1%

16384 bytes

2.07 GB/s

2.41 GB/s

-14.1%

65536 bytes

4.98 GB/s

5.74 GB/s

-13.2%

Observation: Unlike unidirectional transfers, Asio maintains an advantage at all buffer sizes for bidirectional throughput. However, the gap narrows significantly as buffer size increases (from 21% at 1KB to 13% at 64KB).

Bidirectional vs Unidirectional

Buffer Corosio Uni Corosio Bidi Efficiency

1KB

164 MB/s

156 MB/s

95%

4KB

537 MB/s

590 MB/s

110%

16KB

2.07 GB/s

2.07 GB/s

100%

64KB

5.02 GB/s

4.98 GB/s

99%

Both implementations maintain near-100% efficiency in bidirectional mode, indicating good full-duplex I/O handling.

io_context Handler Dispatch

These benchmarks measure raw handler posting and execution throughput, isolating the scheduler from I/O completion overhead.

Single-Threaded Handler Post

Posting 1,000,000 handlers from a single thread and running them sequentially.

Metric Corosio Asio Difference

Handlers

1,000,000

1,000,000

—

Elapsed

1.235 s

1.098 s

+12.5%

Throughput

809.39 Kops/s

910.62 Kops/s

-11.1%

Multi-Threaded Scaling

Multiple threads running handlers concurrently (1,000,000 handlers total).

Threads Corosio Asio Corosio Speedup Asio Speedup

1

1.06 Mops/s

1.99 Mops/s

(baseline)

(baseline)

2

1.69 Mops/s

2.23 Mops/s

1.59×

1.12×

4

2.38 Mops/s

3.19 Mops/s

2.24×

1.60×

8

2.36 Mops/s

4.06 Mops/s

2.22×

2.04×

Scaling Analysis

Throughput vs Thread Count (Mops/s):

Threads    Corosio    Asio
   1        1.06      1.99     Asio +88%
   2        1.69      2.23     Asio +32%
   4        2.38      3.19     Asio +34%
   8        2.36      4.06     Asio +72%
             ↑
        (regression)

Notable observations:

  • Corosio shows better relative scaling at low thread counts (1.59× vs 1.12× at 2 threads)

  • Corosio plateaus at 4 threads and slightly regresses at 8 (2.38 → 2.36 Mops/s)

  • Asio continues scaling linearly through 8 threads

  • This suggests contention in Corosio’s scheduler at high thread counts

Interleaved Post/Run

Alternating between posting batches and running them (10,000 iterations × 100 handlers).

Metric Corosio Asio Difference

Total handlers

1,000,000

1,000,000

—

Elapsed

0.968 s

0.604 s

+60.3%

Throughput

1.03 Mops/s

1.65 Mops/s

-37.6%

This pattern tests the efficiency of small-batch scheduling—a common pattern in real applications.

Concurrent Post and Run

Four threads simultaneously posting and running handlers (250,000 handlers per thread).

Metric Corosio Asio Difference

Threads

4

4

—

Total handlers

1,000,000

1,000,000

—

Elapsed

0.591 s

0.541 s

+9.2%

Throughput

1.69 Mops/s

1.85 Mops/s

-8.6%

The concurrent post/run scenario shows the smallest gap (8.6%), suggesting Corosio’s architecture handles mixed producer/consumer patterns more efficiently than pure dispatch.

Analysis

Performance Characteristics

Single-Threaded Overhead

Corosio exhibits consistent per-operation overhead across all benchmarks:

Benchmark Overhead Evidence

HTTP round-trip

~2.5 μs

13.5 μs vs 11.0 μs mean

Socket ping-pong

~2.8 μs

12.5 μs vs 9.6 μs mean

Handler dispatch

~11%

809 vs 911 Kops/s

The consistent ~2.5-2.8 μs overhead in I/O operations, independent of payload size, suggests the overhead is in the coroutine machinery rather than data handling. Potential contributing factors:

  • Coroutine frame allocation and deallocation

  • Additional indirection in awaitable machinery

  • IOCP completion handling path differences

  • Memory allocation patterns in coroutine state

Tail Latency Advantage

An unexpected finding: Corosio achieves better p99 tail latency at low concurrency:

Single socket pair (64B):
  Corosio p99: 21.80 μs
  Asio p99:    29.92 μs  (+37% worse)

This suggests Corosio’s coroutine-based design has more deterministic scheduling under low load. However, this advantage disappears under contention—at 16 concurrent pairs, Asio has better p99.

HTTP vs Handler Dispatch: A Paradox

The benchmarks reveal an interesting pattern:

Benchmark 8-Thread Result Interpretation

HTTP Server

Corosio +8%

Corosio wins

Handler Dispatch

Asio +72%

Asio wins decisively

How can Corosio win HTTP benchmarks while losing handler dispatch?

The answer lies in what each benchmark measures:

  • Handler dispatch measures pure scheduler throughput—posting and executing handlers

  • HTTP benchmarks measure end-to-end I/O completion including network operations

This suggests Corosio’s advantage comes from I/O completion path efficiency, not scheduler performance. Possible explanations:

  • More efficient IOCP completion packet handling

  • Better integration between coroutine resumption and I/O completion

  • Reduced memory traffic in the completion path

  • Fewer allocations per I/O operation

Scheduler Scalability Gap

The io_context benchmarks reveal a scalability ceiling:

Corosio scaling: 1→4 threads = 2.24× (good)
                 4→8 threads = 0.99× (regression!)

Asio scaling:    1→4 threads = 1.60×
                 4→8 threads = 1.27× (continues improving)

Corosio’s scheduler shows contention at 8 threads, warranting investigation into:

  • Lock contention in the handler queue

  • False sharing in shared data structures

  • Work distribution fairness

HTTP Crossover Analysis

HTTP Performance Gap vs Thread Count:

  1 thread:  Asio +27%  ████████████████████████████
  2 threads: Asio +18%  ██████████████████
  4 threads: Asio +10%  ██████████
  8 threads: Corosio +8%        ████████ ←── Crossover

The crossover occurs between 4 and 8 threads for HTTP workloads. Despite the scheduler disadvantage shown in handler benchmarks, Corosio’s efficient I/O path compensates at high thread counts.

Conclusions

Strengths

Corosio:

  • Superior HTTP throughput at 8+ threads (+8%)

  • Excellent I/O completion path efficiency

  • Better HTTP multi-threaded scaling (3.71× vs 2.72×)

  • Better p99 tail latency at low concurrency (27% better single-pair p99)

  • Modern coroutine-based design

Asio:

  • Lower single-threaded overhead (~20-30% faster baseline)

  • Superior raw handler dispatch throughput

  • Better scheduler scalability (no plateau at high thread counts)

  • Better tail latency under high concurrency

  • Mature, battle-tested implementation

Architectural Insights

The benchmark results suggest a nuanced picture:

Component Assessment

I/O Completion Path

Corosio more efficient—compensates for scheduler overhead in real I/O workloads

Handler Scheduler

Asio faster and scales better—Corosio shows contention at 8 threads

Overall Architecture

Corosio optimized for I/O-bound workloads; Asio better for CPU-bound handler execution

Recommendations

Workload Recommendation

Single-threaded or low concurrency

Asio offers ~20% better throughput

I/O-bound servers (4+ threads)

Corosio competitive, consider either

Maximum I/O throughput (8+ threads)

Corosio provides best performance

Handler-heavy computation

Asio significantly faster

Future Work

  • Scheduler optimization: Investigate contention causing 8-thread plateau

  • Profile single-threaded path to identify overhead sources

  • Benchmark on Linux (epoll backend)

  • Test with realistic HTTP payloads

  • Measure memory consumption under load

  • Long-running stability tests

Appendix: Raw Data

Corosio HTTP Results

Backend: iocp

Single Connection (Sequential Requests)
  Requests: 10000
  Completed: 10000 requests
  Elapsed: 0.136 s
  Throughput: 73.69 Kops/s
  Request latency:
    mean:  13.53 us
    p50:   12.80 us
    p90:   13.20 us
    p99:   30.30 us
    p99.9: 67.21 us
    min:   12.00 us
    max:   251.00 us

Concurrent Connections
  1 conn:  76.33 Kops/s, mean 13.07 us, p99 15.70 us
  4 conn:  73.17 Kops/s, mean 54.62 us, p99 115.60 us
  16 conn: 72.02 Kops/s, mean 221.86 us, p99 480.36 us
  32 conn: 73.91 Kops/s, mean 432.09 us, p99 632.41 us

Multi-threaded (32 connections)
  1 thread:  71.70 Kops/s, mean 445.31 us, p99 624.32 us
  2 threads: 100.95 Kops/s, mean 312.81 us, p99 394.50 us
  4 threads: 178.64 Kops/s, mean 175.47 us, p99 224.65 us
  8 threads: 266.34 Kops/s, mean 109.45 us, p99 183.40 us

Asio HTTP Results

Single Connection (Sequential Requests)
  Requests: 10000
  Completed: 10000 requests
  Elapsed: 0.111 s
  Throughput: 90.29 Kops/s
  Request latency:
    mean:  11.03 us
    p50:   10.50 us
    p90:   10.80 us
    p99:   23.70 us
    p99.9: 69.60 us
    min:   10.20 us
    max:   185.90 us

Concurrent Connections
  1 conn:  92.47 Kops/s, mean 10.78 us, p99 17.00 us
  4 conn:  91.10 Kops/s, mean 43.86 us, p99 63.00 us
  16 conn: 91.38 Kops/s, mean 174.78 us, p99 208.96 us
  32 conn: 89.94 Kops/s, mean 354.78 us, p99 476.11 us

Multi-threaded (32 connections)
  1 thread:  90.92 Kops/s, mean 351.06 us, p99 494.55 us
  2 threads: 119.20 Kops/s, mean 266.20 us, p99 337.81 us
  4 threads: 196.41 Kops/s, mean 159.89 us, p99 192.70 us
  8 threads: 246.88 Kops/s, mean 111.63 us, p99 157.26 us

Corosio io_context Results

Backend: iocp

Single-threaded Handler Post
  Handlers:    1000000
  Elapsed:     1.235 s
  Throughput:  809.39 Kops/s

Multi-threaded Scaling (1M handlers)
  1 thread(s): 1.06 Mops/s
  2 thread(s): 1.69 Mops/s (speedup: 1.59x)
  4 thread(s): 2.38 Mops/s (speedup: 2.24x)
  8 thread(s): 2.36 Mops/s (speedup: 2.22x)

Interleaved Post/Run
  Iterations:        10000
  Handlers/iter:     100
  Total handlers:    1000000
  Elapsed:           0.968 s
  Throughput:        1.03 Mops/s

Concurrent Post and Run
  Threads:           4
  Handlers/thread:   250000
  Total handlers:    1000000
  Elapsed:           0.591 s
  Throughput:        1.69 Mops/s

Asio io_context Results

Single-threaded Handler Post
  Handlers:    1000000
  Elapsed:     1.098 s
  Throughput:  910.62 Kops/s

Multi-threaded Scaling (1M handlers)
  1 thread(s): 1.99 Mops/s
  2 thread(s): 2.23 Mops/s (speedup: 1.12x)
  4 thread(s): 3.19 Mops/s (speedup: 1.60x)
  8 thread(s): 4.06 Mops/s (speedup: 2.04x)

Interleaved Post/Run
  Iterations:        10000
  Handlers/iter:     100
  Total handlers:    1000000
  Elapsed:           0.604 s
  Throughput:        1.65 Mops/s

Concurrent Post and Run
  Threads:           4
  Handlers/thread:   250000
  Total handlers:    1000000
  Elapsed:           0.541 s
  Throughput:        1.85 Mops/s

Corosio Socket Latency Results

Backend: iocp

Ping-Pong Round-Trip Latency
  Message size: 1 bytes, Iterations: 1000
    mean:  12.56 us, p50: 12.10 us, p90: 12.30 us
    p99:   18.70 us, p99.9: 72.45 us
    min:   11.90 us, max: 120.60 us

  Message size: 64 bytes, Iterations: 1000
    mean:  12.45 us, p50: 12.10 us, p90: 12.30 us
    p99:   22.00 us, p99.9: 60.20 us
    min:   11.90 us, max: 64.60 us

  Message size: 1024 bytes, Iterations: 1000
    mean:  12.51 us, p50: 12.30 us, p90: 12.60 us
    p99:   17.34 us, p99.9: 33.81 us
    min:   12.00 us, max: 44.80 us

Concurrent Socket Pairs (64 bytes)
  1 pair:   mean=12.42 us, p99=21.80 us
  4 pairs:  mean=51.78 us, p99=113.10 us
  16 pairs: mean=205.93 us, p99=300.75 us

Asio Socket Latency Results

Ping-Pong Round-Trip Latency
  Message size: 1 bytes, Iterations: 1000
    mean:  10.49 us, p50: 9.50 us, p90: 9.90 us
    p99:   27.51 us, p99.9: 65.50 us
    min:   9.30 us, max: 68.20 us

  Message size: 64 bytes, Iterations: 1000
    mean:  9.61 us, p50: 9.50 us, p90: 9.70 us
    p99:   11.11 us, p99.9: 28.50 us
    min:   9.20 us, max: 32.80 us

  Message size: 1024 bytes, Iterations: 1000
    mean:  9.86 us, p50: 9.70 us, p90: 9.90 us
    p99:   10.70 us, p99.9: 28.20 us
    min:   9.50 us, max: 31.10 us

Concurrent Socket Pairs (64 bytes)
  1 pair:   mean=10.31 us, p99=29.92 us
  4 pairs:  mean=40.59 us, p99=67.98 us
  16 pairs: mean=167.20 us, p99=262.52 us

Corosio Socket Throughput Results

Backend: iocp

Unidirectional Throughput (64 MB transfer)
  Buffer 1024 bytes:  163.75 MB/s (0.410 s)
  Buffer 4096 bytes:  536.61 MB/s (0.125 s)
  Buffer 16384 bytes: 2.07 GB/s (0.032 s)
  Buffer 65536 bytes: 5.02 GB/s (0.013 s)

Bidirectional Throughput (32 MB each direction)
  Buffer 1024 bytes:  155.84 MB/s (0.431 s)
  Buffer 4096 bytes:  590.39 MB/s (0.114 s)
  Buffer 16384 bytes: 2.07 GB/s (0.032 s)
  Buffer 65536 bytes: 4.98 GB/s (0.013 s)

Asio Socket Throughput Results

Unidirectional Throughput (64 MB transfer)
  Buffer 1024 bytes:  207.24 MB/s (0.324 s)
  Buffer 4096 bytes:  681.62 MB/s (0.098 s)
  Buffer 16384 bytes: 2.25 GB/s (0.030 s)
  Buffer 65536 bytes: 4.46 GB/s (0.015 s)

Bidirectional Throughput (32 MB each direction)
  Buffer 1024 bytes:  196.83 MB/s (0.341 s)
  Buffer 4096 bytes:  704.04 MB/s (0.095 s)
  Buffer 16384 bytes: 2.41 GB/s (0.028 s)
  Buffer 65536 bytes: 5.74 GB/s (0.012 s)
Edit this Page