h2load failed 0 requests in all nine grids, on every server at every payload. Its collapse at m=1-2 happens only against h2o and only at 1 KB (5k-14k req/s, recovering to 3.39M by m=64): a pairing-specific interaction between ngtcp2 and the quicly server at low concurrency, not general client behaviour, and it does not reappear at the larger payloads. h2o-httpclient's failures stay small throughout (128-319 per grid, process-teardown artifacts) except against nginx at 128 KB (2,773). --socket-per-conn costs h3x throughput at 1 KB (+16.1% against h2o, +25.0% against nginx) and buys reliability everywhere; at 128 KB the two modes are within noise of each other on throughput and spc still fails far less.

All 864 cells are one sitting (2026-07-29, bench/grid-v3.sh), same box, same servers, so columns and payloads are directly comparable. Each payload is served at its own URL (/, /20k.html, /128k.html) rather than by swapping one file's contents, and every cell re-derives the served object size from the client's own byte counters. A round of earlier sweeps here was invalidated by silently benchmarking a 20 KB object against 1 KB tables; naming the payload in the request makes that failure structurally impossible rather than merely checked for.

Four cells at 128 KB drift 2-3% from the nominal object size and are reported by the generator rather than hidden. Three are nginx h3x cells failing 11-23% of requests, where bytes from partial bodies count toward throughput while their requests count as failed, inflating bytes-per-completed. The fourth is haproxy h2load at 512x64, where 32,768 streams were still in flight at the 10 s cutoff, deflating it by the same mechanism in reverse. Both are artifacts of the measurement window. A real payload mix-up here would be 20x off, not 3%.

Single unpinned runs. One 10 s run per cell, no repeats. A control experiment across two grids, comparing cells whose configuration was byte-identical, saw swings from -17.6% to +13.5% with no consistent sign. So differences under roughly 20% are not distinguishable from run-to-run variance, and only the large effects should be read as real — which here means the payload-size reversal (h3x 21-1 to h2load 15-9 against h2o), the 4.6x nginx gap at 128 KB, the drop counts, and h2load's clean failure record. Separating anything smaller needs repeated samples per cell.

The trigger is multiplexing many QUIC connections over one UDP socket per worker. Differential tests against haproxy: one connection per socket is flawless (32 conns / 32 sockets: 7.19M requests, 0 drops, 0 re-dials; thread-count controlled separately with 4 conns / 4 sockets, also 0/0), while 8 connections per socket, same 32 connections and same multiplexing, drops 1,428 and re-dials constantly (355k requests on resumed connections in 5 s, with no reconnect flag). Confirmed at scale by the spc column, which fails 0 requests against nginx and 1,904 against haproxy versus shared-socket h3x's 3,914 and 53,372. Servers differ in how they tolerate multiple QUIC connections sharing a 4-tuple: h2o accepts it (this is h2o's own client architecture), nginx churns moderately, haproxy constantly. Every drop surfaces as "I/O error" at stream attach: a shared-socket connection dies, whatever was in flight on it fails, the pool re-dials with the cached ticket, and the run continues, so throughput barely dips while the drop counter grows. The close reason on the wire is still unread (CONNECTION_CLOSE is encrypted; reading it needs SSLKEYLOGFILE wiring), and against nginx there is additionally a smaller classic handshake-timeout tail under saturation (2,559 churn errors vs 489 timeouts in the probed cell). Fix: --socket-per-conn (one socket per connection, the h2load model), the spc column.

h2load failed 0 requests in all nine grids, on every server at every payload. Its collapse at m=1-2 happens only against h2o and only at 1 KB (5k-14k req/s, recovering to 3.39M by m=64): a pairing-specific interaction between ngtcp2 and the quicly server at low concurrency, not general client behaviour, and it does not reappear at the larger payloads. h2o-httpclient's failures stay small throughout (128-319 per grid, process-teardown artifacts) except against nginx at 128 KB (2,773). --socket-per-conn costs h3x throughput at 1 KB (+16.1% against h2o, +25.0% against nginx) and buys reliability everywhere; at 128 KB the two modes are within noise of each other on throughput and spc still fails far less.

All 864 cells are one sitting (2026-07-29, bench/grid-v3.sh), same box, same servers, so columns and payloads are directly comparable. Each payload is served at its own URL (/, /20k.html, /128k.html) rather than by swapping one file's contents, and every cell re-derives the served object size from the client's own byte counters. A round of earlier sweeps here was invalidated by silently benchmarking a 20 KB object against 1 KB tables; naming the payload in the request makes that failure structurally impossible rather than merely checked for.

Four cells at 128 KB drift 2-3% from the nominal object size and are reported by the generator rather than hidden. Three are nginx h3x cells failing 11-23% of requests, where bytes from partial bodies count toward throughput while their requests count as failed, inflating bytes-per-completed. The fourth is haproxy h2load at 512x64, where 32,768 streams were still in flight at the 10 s cutoff, deflating it by the same mechanism in reverse. Both are artifacts of the measurement window. A real payload mix-up here would be 20x off, not 3%.

Single unpinned runs. One 10 s run per cell, no repeats. A control experiment across two grids, comparing cells whose configuration was byte-identical, saw swings from -17.6% to +13.5% with no consistent sign. So differences under roughly 20% are not distinguishable from run-to-run variance, and only the large effects should be read as real — which here means the payload-size reversal (h3x 21-1 to h2load 15-9 against h2o), the 4.6x nginx gap at 128 KB, the drop counts, and h2load's clean failure record. Separating anything smaller needs repeated samples per cell.

The trigger is multiplexing many QUIC connections over one UDP socket per worker. Differential tests against haproxy: one connection per socket is flawless (32 conns / 32 sockets: 7.19M requests, 0 drops, 0 re-dials; thread-count controlled separately with 4 conns / 4 sockets, also 0/0), while 8 connections per socket, same 32 connections and same multiplexing, drops 1,428 and re-dials constantly (355k requests on resumed connections in 5 s, with no reconnect flag). Confirmed at scale by the spc column, which fails 0 requests against nginx and 1,904 against haproxy versus shared-socket h3x's 3,914 and 53,372. Servers differ in how they tolerate multiple QUIC connections sharing a 4-tuple: h2o accepts it (this is h2o's own client architecture), nginx churns moderately, haproxy constantly. Every drop surfaces as "I/O error" at stream attach: a shared-socket connection dies, whatever was in flight on it fails, the pool re-dials with the cached ticket, and the run continues, so throughput barely dips while the drop counter grows. The close reason on the wire is still unread (CONNECTION_CLOSE is encrypted; reading it needs SSLKEYLOGFILE wiring), and against nginx there is additionally a smaller classic handshake-timeout tail under saturation (2,559 churn errors vs 489 timeouts in the probed cell). Fix: --socket-per-conn (one socket per connection, the h2load model), the spc column.

h2load failed 0 requests in all nine grids, on every server at every payload. Its collapse at m=1-2 happens only against h2o and only at 1 KB (5k-14k req/s, recovering to 3.39M by m=64): a pairing-specific interaction between ngtcp2 and the quicly server at low concurrency, not general client behaviour, and it does not reappear at the larger payloads. h2o-httpclient's failures stay small throughout (128-319 per grid, process-teardown artifacts) except against nginx at 128 KB (2,773). --socket-per-conn costs h3x throughput at 1 KB (+16.1% against h2o, +25.0% against nginx) and buys reliability everywhere; at 128 KB the two modes are within noise of each other on throughput and spc still fails far less.

All 864 cells are one sitting (2026-07-29, bench/grid-v3.sh), same box, same servers, so columns and payloads are directly comparable. Each payload is served at its own URL (/, /20k.html, /128k.html) rather than by swapping one file's contents, and every cell re-derives the served object size from the client's own byte counters. A round of earlier sweeps here was invalidated by silently benchmarking a 20 KB object against 1 KB tables; naming the payload in the request makes that failure structurally impossible rather than merely checked for.

Four cells at 128 KB drift 2-3% from the nominal object size and are reported by the generator rather than hidden. Three are nginx h3x cells failing 11-23% of requests, where bytes from partial bodies count toward throughput while their requests count as failed, inflating bytes-per-completed. The fourth is haproxy h2load at 512x64, where 32,768 streams were still in flight at the 10 s cutoff, deflating it by the same mechanism in reverse. Both are artifacts of the measurement window. A real payload mix-up here would be 20x off, not 3%.

Single unpinned runs. One 10 s run per cell, no repeats. A control experiment across two grids, comparing cells whose configuration was byte-identical, saw swings from -17.6% to +13.5% with no consistent sign. So differences under roughly 20% are not distinguishable from run-to-run variance, and only the large effects should be read as real — which here means the payload-size reversal (h3x 21-1 to h2load 15-9 against h2o), the 4.6x nginx gap at 128 KB, the drop counts, and h2load's clean failure record. Separating anything smaller needs repeated samples per cell.

The trigger is multiplexing many QUIC connections over one UDP socket per worker. Differential tests against haproxy: one connection per socket is flawless (32 conns / 32 sockets: 7.19M requests, 0 drops, 0 re-dials; thread-count controlled separately with 4 conns / 4 sockets, also 0/0), while 8 connections per socket, same 32 connections and same multiplexing, drops 1,428 and re-dials constantly (355k requests on resumed connections in 5 s, with no reconnect flag). Confirmed at scale by the spc column, which fails 0 requests against nginx and 1,904 against haproxy versus shared-socket h3x's 3,914 and 53,372. Servers differ in how they tolerate multiple QUIC connections sharing a 4-tuple: h2o accepts it (this is h2o's own client architecture), nginx churns moderately, haproxy constantly. Every drop surfaces as "I/O error" at stream attach: a shared-socket connection dies, whatever was in flight on it fails, the pool re-dials with the cached ticket, and the run continues, so throughput barely dips while the drop counter grows. The close reason on the wire is still unread (CONNECTION_CLOSE is encrypted; reading it needs SSLKEYLOGFILE wiring), and against nginx there is additionally a smaller classic handshake-timeout tail under saturation (2,559 churn errors vs 489 timeouts in the probed cell). Fix: --socket-per-conn (one socket per connection, the h2load model), the spc column.

h2load failed 0 requests in all nine grids, on every server at every payload. Its collapse at m=1-2 happens only against h2o and only at 1 KB (5k-14k req/s, recovering to 3.39M by m=64): a pairing-specific interaction between ngtcp2 and the quicly server at low concurrency, not general client behaviour, and it does not reappear at the larger payloads. h2o-httpclient's failures stay small throughout (128-319 per grid, process-teardown artifacts) except against nginx at 128 KB (2,773). --socket-per-conn costs h3x throughput at 1 KB (+16.1% against h2o, +25.0% against nginx) and buys reliability everywhere; at 128 KB the two modes are within noise of each other on throughput and spc still fails far less.

All 864 cells are one sitting (2026-07-29, bench/grid-v3.sh), same box, same servers, so columns and payloads are directly comparable. Each payload is served at its own URL (/, /20k.html, /128k.html) rather than by swapping one file's contents, and every cell re-derives the served object size from the client's own byte counters. A round of earlier sweeps here was invalidated by silently benchmarking a 20 KB object against 1 KB tables; naming the payload in the request makes that failure structurally impossible rather than merely checked for.

Four cells at 128 KB drift 2-3% from the nominal object size and are reported by the generator rather than hidden. Three are nginx h3x cells failing 11-23% of requests, where bytes from partial bodies count toward throughput while their requests count as failed, inflating bytes-per-completed. The fourth is haproxy h2load at 512x64, where 32,768 streams were still in flight at the 10 s cutoff, deflating it by the same mechanism in reverse. Both are artifacts of the measurement window. A real payload mix-up here would be 20x off, not 3%.

Single unpinned runs. One 10 s run per cell, no repeats. A control experiment across two grids, comparing cells whose configuration was byte-identical, saw swings from -17.6% to +13.5% with no consistent sign. So differences under roughly 20% are not distinguishable from run-to-run variance, and only the large effects should be read as real — which here means the payload-size reversal (h3x 21-1 to h2load 15-9 against h2o), the 4.6x nginx gap at 128 KB, the drop counts, and h2load's clean failure record. Separating anything smaller needs repeated samples per cell.

The trigger is multiplexing many QUIC connections over one UDP socket per worker. Differential tests against haproxy: one connection per socket is flawless (32 conns / 32 sockets: 7.19M requests, 0 drops, 0 re-dials; thread-count controlled separately with 4 conns / 4 sockets, also 0/0), while 8 connections per socket, same 32 connections and same multiplexing, drops 1,428 and re-dials constantly (355k requests on resumed connections in 5 s, with no reconnect flag). Confirmed at scale by the spc column, which fails 0 requests against nginx and 1,904 against haproxy versus shared-socket h3x's 3,914 and 53,372. Servers differ in how they tolerate multiple QUIC connections sharing a 4-tuple: h2o accepts it (this is h2o's own client architecture), nginx churns moderately, haproxy constantly. Every drop surfaces as "I/O error" at stream attach: a shared-socket connection dies, whatever was in flight on it fails, the pool re-dials with the cached ticket, and the run continues, so throughput barely dips while the drop counter grows. The close reason on the wire is still unread (CONNECTION_CLOSE is encrypted; reading it needs SSLKEYLOGFILE wiring), and against nginx there is additionally a smaller classic handshake-timeout tail under saturation (2,559 churn errors vs 489 timeouts in the probed cell). Fix: --socket-per-conn (one socket per connection, the h2load model), the spc column.

h2load failed 0 requests in all nine grids, on every server at every payload. Its collapse at m=1-2 happens only against h2o and only at 1 KB (5k-14k req/s, recovering to 3.39M by m=64): a pairing-specific interaction between ngtcp2 and the quicly server at low concurrency, not general client behaviour, and it does not reappear at the larger payloads. h2o-httpclient's failures stay small throughout (128-319 per grid, process-teardown artifacts) except against nginx at 128 KB (2,773). --socket-per-conn costs h3x throughput at 1 KB (+16.1% against h2o, +25.0% against nginx) and buys reliability everywhere; at 128 KB the two modes are within noise of each other on throughput and spc still fails far less.

All 864 cells are one sitting (2026-07-29, bench/grid-v3.sh), same box, same servers, so columns and payloads are directly comparable. Each payload is served at its own URL (/, /20k.html, /128k.html) rather than by swapping one file's contents, and every cell re-derives the served object size from the client's own byte counters. A round of earlier sweeps here was invalidated by silently benchmarking a 20 KB object against 1 KB tables; naming the payload in the request makes that failure structurally impossible rather than merely checked for.

Four cells at 128 KB drift 2-3% from the nominal object size and are reported by the generator rather than hidden. Three are nginx h3x cells failing 11-23% of requests, where bytes from partial bodies count toward throughput while their requests count as failed, inflating bytes-per-completed. The fourth is haproxy h2load at 512x64, where 32,768 streams were still in flight at the 10 s cutoff, deflating it by the same mechanism in reverse. Both are artifacts of the measurement window. A real payload mix-up here would be 20x off, not 3%.

Single unpinned runs. One 10 s run per cell, no repeats. A control experiment across two grids, comparing cells whose configuration was byte-identical, saw swings from -17.6% to +13.5% with no consistent sign. So differences under roughly 20% are not distinguishable from run-to-run variance, and only the large effects should be read as real — which here means the payload-size reversal (h3x 21-1 to h2load 15-9 against h2o), the 4.6x nginx gap at 128 KB, the drop counts, and h2load's clean failure record. Separating anything smaller needs repeated samples per cell.

The trigger is multiplexing many QUIC connections over one UDP socket per worker. Differential tests against haproxy: one connection per socket is flawless (32 conns / 32 sockets: 7.19M requests, 0 drops, 0 re-dials; thread-count controlled separately with 4 conns / 4 sockets, also 0/0), while 8 connections per socket, same 32 connections and same multiplexing, drops 1,428 and re-dials constantly (355k requests on resumed connections in 5 s, with no reconnect flag). Confirmed at scale by the spc column, which fails 0 requests against nginx and 1,904 against haproxy versus shared-socket h3x's 3,914 and 53,372. Servers differ in how they tolerate multiple QUIC connections sharing a 4-tuple: h2o accepts it (this is h2o's own client architecture), nginx churns moderately, haproxy constantly. Every drop surfaces as "I/O error" at stream attach: a shared-socket connection dies, whatever was in flight on it fails, the pool re-dials with the cached ticket, and the run continues, so throughput barely dips while the drop counter grows. The close reason on the wire is still unread (CONNECTION_CLOSE is encrypted; reading it needs SSLKEYLOGFILE wiring), and against nginx there is additionally a smaller classic handshake-timeout tail under saturation (2,559 churn errors vs 489 timeouts in the probed cell). Fix: --socket-per-conn (one socket per connection, the h2load model), the spc column.

h2load failed 0 requests in all nine grids, on every server at every payload. Its collapse at m=1-2 happens only against h2o and only at 1 KB (5k-14k req/s, recovering to 3.39M by m=64): a pairing-specific interaction between ngtcp2 and the quicly server at low concurrency, not general client behaviour, and it does not reappear at the larger payloads. h2o-httpclient's failures stay small throughout (128-319 per grid, process-teardown artifacts) except against nginx at 128 KB (2,773). --socket-per-conn costs h3x throughput at 1 KB (+16.1% against h2o, +25.0% against nginx) and buys reliability everywhere; at 128 KB the two modes are within noise of each other on throughput and spc still fails far less.

All 864 cells are one sitting (2026-07-29, bench/grid-v3.sh), same box, same servers, so columns and payloads are directly comparable. Each payload is served at its own URL (/, /20k.html, /128k.html) rather than by swapping one file's contents, and every cell re-derives the served object size from the client's own byte counters. A round of earlier sweeps here was invalidated by silently benchmarking a 20 KB object against 1 KB tables; naming the payload in the request makes that failure structurally impossible rather than merely checked for.

Four cells at 128 KB drift 2-3% from the nominal object size and are reported by the generator rather than hidden. Three are nginx h3x cells failing 11-23% of requests, where bytes from partial bodies count toward throughput while their requests count as failed, inflating bytes-per-completed. The fourth is haproxy h2load at 512x64, where 32,768 streams were still in flight at the 10 s cutoff, deflating it by the same mechanism in reverse. Both are artifacts of the measurement window. A real payload mix-up here would be 20x off, not 3%.

Single unpinned runs. One 10 s run per cell, no repeats. A control experiment across two grids, comparing cells whose configuration was byte-identical, saw swings from -17.6% to +13.5% with no consistent sign. So differences under roughly 20% are not distinguishable from run-to-run variance, and only the large effects should be read as real — which here means the payload-size reversal (h3x 21-1 to h2load 15-9 against h2o), the 4.6x nginx gap at 128 KB, the drop counts, and h2load's clean failure record. Separating anything smaller needs repeated samples per cell.

The trigger is multiplexing many QUIC connections over one UDP socket per worker. Differential tests against haproxy: one connection per socket is flawless (32 conns / 32 sockets: 7.19M requests, 0 drops, 0 re-dials; thread-count controlled separately with 4 conns / 4 sockets, also 0/0), while 8 connections per socket, same 32 connections and same multiplexing, drops 1,428 and re-dials constantly (355k requests on resumed connections in 5 s, with no reconnect flag). Confirmed at scale by the spc column, which fails 0 requests against nginx and 1,904 against haproxy versus shared-socket h3x's 3,914 and 53,372. Servers differ in how they tolerate multiple QUIC connections sharing a 4-tuple: h2o accepts it (this is h2o's own client architecture), nginx churns moderately, haproxy constantly. Every drop surfaces as "I/O error" at stream attach: a shared-socket connection dies, whatever was in flight on it fails, the pool re-dials with the cached ticket, and the run continues, so throughput barely dips while the drop counter grows. The close reason on the wire is still unread (CONNECTION_CLOSE is encrypted; reading it needs SSLKEYLOGFILE wiring), and against nginx there is additionally a smaller classic handshake-timeout tail under saturation (2,559 churn errors vs 489 timeouts in the probed cell). Fix: --socket-per-conn (one socket per connection, the h2load model), the spc column.

h2load failed 0 requests in all nine grids, on every server at every payload. Its collapse at m=1-2 happens only against h2o and only at 1 KB (5k-14k req/s, recovering to 3.39M by m=64): a pairing-specific interaction between ngtcp2 and the quicly server at low concurrency, not general client behaviour, and it does not reappear at the larger payloads. h2o-httpclient's failures stay small throughout (128-319 per grid, process-teardown artifacts) except against nginx at 128 KB (2,773). --socket-per-conn costs h3x throughput at 1 KB (+16.1% against h2o, +25.0% against nginx) and buys reliability everywhere; at 128 KB the two modes are within noise of each other on throughput and spc still fails far less.

All 864 cells are one sitting (2026-07-29, bench/grid-v3.sh), same box, same servers, so columns and payloads are directly comparable. Each payload is served at its own URL (/, /20k.html, /128k.html) rather than by swapping one file's contents, and every cell re-derives the served object size from the client's own byte counters. A round of earlier sweeps here was invalidated by silently benchmarking a 20 KB object against 1 KB tables; naming the payload in the request makes that failure structurally impossible rather than merely checked for.

Four cells at 128 KB drift 2-3% from the nominal object size and are reported by the generator rather than hidden. Three are nginx h3x cells failing 11-23% of requests, where bytes from partial bodies count toward throughput while their requests count as failed, inflating bytes-per-completed. The fourth is haproxy h2load at 512x64, where 32,768 streams were still in flight at the 10 s cutoff, deflating it by the same mechanism in reverse. Both are artifacts of the measurement window. A real payload mix-up here would be 20x off, not 3%.

Single unpinned runs. One 10 s run per cell, no repeats. A control experiment across two grids, comparing cells whose configuration was byte-identical, saw swings from -17.6% to +13.5% with no consistent sign. So differences under roughly 20% are not distinguishable from run-to-run variance, and only the large effects should be read as real — which here means the payload-size reversal (h3x 21-1 to h2load 15-9 against h2o), the 4.6x nginx gap at 128 KB, the drop counts, and h2load's clean failure record. Separating anything smaller needs repeated samples per cell.

The trigger is multiplexing many QUIC connections over one UDP socket per worker. Differential tests against haproxy: one connection per socket is flawless (32 conns / 32 sockets: 7.19M requests, 0 drops, 0 re-dials; thread-count controlled separately with 4 conns / 4 sockets, also 0/0), while 8 connections per socket, same 32 connections and same multiplexing, drops 1,428 and re-dials constantly (355k requests on resumed connections in 5 s, with no reconnect flag). Confirmed at scale by the spc column, which fails 0 requests against nginx and 1,904 against haproxy versus shared-socket h3x's 3,914 and 53,372. Servers differ in how they tolerate multiple QUIC connections sharing a 4-tuple: h2o accepts it (this is h2o's own client architecture), nginx churns moderately, haproxy constantly. Every drop surfaces as "I/O error" at stream attach: a shared-socket connection dies, whatever was in flight on it fails, the pool re-dials with the cached ticket, and the run continues, so throughput barely dips while the drop counter grows. The close reason on the wire is still unread (CONNECTION_CLOSE is encrypted; reading it needs SSLKEYLOGFILE wiring), and against nginx there is additionally a smaller classic handshake-timeout tail under saturation (2,559 churn errors vs 489 timeouts in the probed cell). Fix: --socket-per-conn (one socket per connection, the h2load model), the spc column.

h2load failed 0 requests in all nine grids, on every server at every payload. Its collapse at m=1-2 happens only against h2o and only at 1 KB (5k-14k req/s, recovering to 3.39M by m=64): a pairing-specific interaction between ngtcp2 and the quicly server at low concurrency, not general client behaviour, and it does not reappear at the larger payloads. h2o-httpclient's failures stay small throughout (128-319 per grid, process-teardown artifacts) except against nginx at 128 KB (2,773). --socket-per-conn costs h3x throughput at 1 KB (+16.1% against h2o, +25.0% against nginx) and buys reliability everywhere; at 128 KB the two modes are within noise of each other on throughput and spc still fails far less.

All 864 cells are one sitting (2026-07-29, bench/grid-v3.sh), same box, same servers, so columns and payloads are directly comparable. Each payload is served at its own URL (/, /20k.html, /128k.html) rather than by swapping one file's contents, and every cell re-derives the served object size from the client's own byte counters. A round of earlier sweeps here was invalidated by silently benchmarking a 20 KB object against 1 KB tables; naming the payload in the request makes that failure structurally impossible rather than merely checked for.

Four cells at 128 KB drift 2-3% from the nominal object size and are reported by the generator rather than hidden. Three are nginx h3x cells failing 11-23% of requests, where bytes from partial bodies count toward throughput while their requests count as failed, inflating bytes-per-completed. The fourth is haproxy h2load at 512x64, where 32,768 streams were still in flight at the 10 s cutoff, deflating it by the same mechanism in reverse. Both are artifacts of the measurement window. A real payload mix-up here would be 20x off, not 3%.

Single unpinned runs. One 10 s run per cell, no repeats. A control experiment across two grids, comparing cells whose configuration was byte-identical, saw swings from -17.6% to +13.5% with no consistent sign. So differences under roughly 20% are not distinguishable from run-to-run variance, and only the large effects should be read as real — which here means the payload-size reversal (h3x 21-1 to h2load 15-9 against h2o), the 4.6x nginx gap at 128 KB, the drop counts, and h2load's clean failure record. Separating anything smaller needs repeated samples per cell.

The trigger is multiplexing many QUIC connections over one UDP socket per worker. Differential tests against haproxy: one connection per socket is flawless (32 conns / 32 sockets: 7.19M requests, 0 drops, 0 re-dials; thread-count controlled separately with 4 conns / 4 sockets, also 0/0), while 8 connections per socket, same 32 connections and same multiplexing, drops 1,428 and re-dials constantly (355k requests on resumed connections in 5 s, with no reconnect flag). Confirmed at scale by the spc column, which fails 0 requests against nginx and 1,904 against haproxy versus shared-socket h3x's 3,914 and 53,372. Servers differ in how they tolerate multiple QUIC connections sharing a 4-tuple: h2o accepts it (this is h2o's own client architecture), nginx churns moderately, haproxy constantly. Every drop surfaces as "I/O error" at stream attach: a shared-socket connection dies, whatever was in flight on it fails, the pool re-dials with the cached ticket, and the run continues, so throughput barely dips while the drop counter grows. The close reason on the wire is still unread (CONNECTION_CLOSE is encrypted; reading it needs SSLKEYLOGFILE wiring), and against nginx there is additionally a smaller classic handshake-timeout tail under saturation (2,559 churn errors vs 489 timeouts in the probed cell). Fix: --socket-per-conn (one socket per connection, the h2load model), the spc column.

h2load failed 0 requests in all nine grids, on every server at every payload. Its collapse at m=1-2 happens only against h2o and only at 1 KB (5k-14k req/s, recovering to 3.39M by m=64): a pairing-specific interaction between ngtcp2 and the quicly server at low concurrency, not general client behaviour, and it does not reappear at the larger payloads. h2o-httpclient's failures stay small throughout (128-319 per grid, process-teardown artifacts) except against nginx at 128 KB (2,773). --socket-per-conn costs h3x throughput at 1 KB (+16.1% against h2o, +25.0% against nginx) and buys reliability everywhere; at 128 KB the two modes are within noise of each other on throughput and spc still fails far less.

All 864 cells are one sitting (2026-07-29, bench/grid-v3.sh), same box, same servers, so columns and payloads are directly comparable. Each payload is served at its own URL (/, /20k.html, /128k.html) rather than by swapping one file's contents, and every cell re-derives the served object size from the client's own byte counters. A round of earlier sweeps here was invalidated by silently benchmarking a 20 KB object against 1 KB tables; naming the payload in the request makes that failure structurally impossible rather than merely checked for.

Four cells at 128 KB drift 2-3% from the nominal object size and are reported by the generator rather than hidden. Three are nginx h3x cells failing 11-23% of requests, where bytes from partial bodies count toward throughput while their requests count as failed, inflating bytes-per-completed. The fourth is haproxy h2load at 512x64, where 32,768 streams were still in flight at the 10 s cutoff, deflating it by the same mechanism in reverse. Both are artifacts of the measurement window. A real payload mix-up here would be 20x off, not 3%.

Single unpinned runs. One 10 s run per cell, no repeats. A control experiment across two grids, comparing cells whose configuration was byte-identical, saw swings from -17.6% to +13.5% with no consistent sign. So differences under roughly 20% are not distinguishable from run-to-run variance, and only the large effects should be read as real — which here means the payload-size reversal (h3x 21-1 to h2load 15-9 against h2o), the 4.6x nginx gap at 128 KB, the drop counts, and h2load's clean failure record. Separating anything smaller needs repeated samples per cell.

The trigger is multiplexing many QUIC connections over one UDP socket per worker. Differential tests against haproxy: one connection per socket is flawless (32 conns / 32 sockets: 7.19M requests, 0 drops, 0 re-dials; thread-count controlled separately with 4 conns / 4 sockets, also 0/0), while 8 connections per socket, same 32 connections and same multiplexing, drops 1,428 and re-dials constantly (355k requests on resumed connections in 5 s, with no reconnect flag). Confirmed at scale by the spc column, which fails 0 requests against nginx and 1,904 against haproxy versus shared-socket h3x's 3,914 and 53,372. Servers differ in how they tolerate multiple QUIC connections sharing a 4-tuple: h2o accepts it (this is h2o's own client architecture), nginx churns moderately, haproxy constantly. Every drop surfaces as "I/O error" at stream attach: a shared-socket connection dies, whatever was in flight on it fails, the pool re-dials with the cached ticket, and the run continues, so throughput barely dips while the drop counter grows. The close reason on the wire is still unread (CONNECTION_CLOSE is encrypted; reading it needs SSLKEYLOGFILE wiring), and against nginx there is additionally a smaller classic handshake-timeout tail under saturation (2,559 churn errors vs 489 timeouts in the probed cell). Fix: --socket-per-conn (one socket per connection, the h2load model), the spc column.