df_throughput.query("entities == 100000 and loss_pct == 0")["hz"].iloc[0]
)
hz_at_100k_5pct = float(
df_throughput.query("entities == 100000 and loss_pct == 5")["hz"].iloc[0]
)
hz_at_100k_0pct = _hz(100000, 0)
hz_at_100k_5pct = _hz(100000, 5)
rss_at_100k = float(
df_throughput.query("entities == 100000 and loss_pct == 0")["rss_mb"].iloc[0]
)
@@ -134,7 +134,7 @@ for DT sensor transport [@plantevin2026quic]. The present paper asks: do they
compose? Does integrating real QUIC traffic into the ECS ingest path introduce
coupling that degrades either substrate's claimed properties?
This paper makes three primary contributions. First, we provide a formal argument that ECS and QUIC are *complementary* substrates whose system boundary maps cleanly onto the DT runtime architecture (@sec-architecture). Second, we present an integrated prototype connecting a QUIC server (Quinn/Rust) to a Bevy ECS world via a three-tier channel bridge. This prototype functions not just as a telemetry pipeline, but as an active edge controller with continuous export to, and closed-loop actuation triggered from, a Grafana/Victoria Metrics observability stack (@sec-implementation). Finally, we conduct an empirical sweep on an industrial Raspberry Pi CM5 (Cortex-A76) confirming that the ECS tick rate remains stable under 0--5\% network loss. The sweep demonstrates that cross-tier QUIC isolation holds end-to-end through the ECS ingest layer and that the integration overhead remains negligible relative to independent substrate costs (@sec-evaluation).
This paper makes three primary contributions. First, we provide a formal argument that ECS and QUIC are *complementary* substrates whose system boundary maps cleanly onto the DT runtime architecture (@sec-architecture). Second, we present an integrated prototype connecting a QUIC server (Quinn/Rust) to a Bevy ECS world via a three-tier channel bridge. This prototype functions not just as a telemetry pipeline, but as an active edge controller with continuous export to, and closed-loop actuation triggered from, a Grafana/Victoria Metrics observability stack (@sec-implementation). Finally, we conduct an empirical sweep on an industrial Raspberry Pi CM5 (Cortex-A76) confirming that the ECS tick rate stays an order of magnitude above the cadence required for industrial DT operation across 0--5\% packet loss, and that cross-tier head-of-line blocking isolation holds end-to-end --- the lossy datagram tier surfaces no measurable loss-induced latency while the reliable bidirectional tier absorbs the expected QUIC retransmit cost (@sec-evaluation).
# Background {#sec-background}
@@ -292,82 +292,29 @@ accuracy; throughput measurements used the two-machine setup.
## Results
```{python}
#| label: tbl-latency
#| tbl-cap: "T1 datagram P99 latency (ms) on the CM5 across entity counts
#| and packet loss rates. Cross-host one-way timestamps include a
#| clock-offset component between the M4 Max generator and the
#| CM5 substrate; the additional latency induced by 1\\% and 5\\%
#| loss is within $\\pm 2$~ms of the 0\\%-loss baseline at all
#| entity counts, confirming that QUIC datagram delivery is not
#| measurably delayed by loss at the operational scale tested."
: T1 datagram P99 latency (ms) on the CM5 across entity counts and packet loss rates. Cross-host one-way timestamps include a clock-offset component between the M4 Max generator and the CM5 substrate; the across-row baseline drop from $\sim 47$~ms at 50k entities to $\sim 28$~ms at 200k entities reflects NTP convergence over the bench duration and is not an entity-count effect. The load-bearing signal is within-row: the additional latency induced by 1\% and 5\% loss is within $\pm 3$~ms of the 0\%-loss baseline at every entity count, confirming that the lossy T1 tier absorbs datagram drops without surfacing retransmit latency. {#tbl-latency}
wide = df_latency.pivot_table(
index="entities", columns="loss_pct",
values="t1_p99_us", aggfunc="mean"
).sort_index()
wide.columns = [f"{int(c)}% loss" for c in wide.columns]
#| Tick rate remains within 3% of the synthetic-ingest baseline
#| at all entity counts and loss rates."
: ECS DT runtime throughput and RSS under real QUIC traffic on the CM5 (two-machine, performance governor, 50~s measurement window per cell). Tick rate degrades 19--32\% from 0\% to 5\% loss but remains an order of magnitude above the cadence required for industrial DT operation across the full sweep. RSS grows linearly with entity count (slope $\sim 0.12$~MB per 1,000 entities). {#tbl-throughput}
: Substrate-initiated T3 bidirectional-stream RTT P99 (ms) under the same sweep. Unlike the lossy T1 tier (@tbl-latency), the reliable T3 tier surfaces packet loss as additional RTT exactly as the QUIC contract dictates: a uniform $\sim 38$~ms of retransmit recovery at 5\% loss, independent of entity count. Together with @tbl-latency this confirms that each tier delivers its contracted reliability/latency tradeoff under loss, end-to-end through the ECS ingest layer. {#tbl-t3-rtt}
**ECS tick rate under real network load.** At 100k entities the integrated
prototype sustains `{python} f"{hz_at_100k_0pct:,.0f}"`~Hz within
@@ -381,35 +328,39 @@ the bounded ingest channel without stalling the ECS schedule.
**Cross-tier isolation.** @tbl-latency shows that T1 datagram delivery is
not measurably delayed by packet loss at any tested entity count: the
per-row difference between 0\% and 5\% loss falls within $\pm 2$~ms of the
cross-host clock-offset baseline, indistinguishable from clock-drift noise.
@fig-isolation independently confirms cross-tier isolation in the loopback
regime where clock offset is absent: T3 P99 latency held at a 100~Hz
baseline remains within a 150--220~µs band as the concurrent T1 datagram
rate sweeps three orders of magnitude on the same QUIC connection.
Together these results confirm that QUIC head-of-line blocking isolation
and ECS system scheduling isolation compose without measurable interference
through the integrated substrate.
per-row difference between 0\% and 5\% loss falls within $\pm 3$~ms of
the cross-host clock-offset baseline, indistinguishable from clock-drift
noise. @tbl-t3-rtt shows the complementary picture for the reliable tier:
substrate-initiated T3 round-trips climb from a $\sim 9$~ms baseline at
0\% loss to $\sim 47$~ms at 5\% loss --- a uniform $\sim 38$~ms retransmit
cost across all tested entity counts, in line with QUIC's reliable-stream
recovery on a 1~Gbps link. The two tables together confirm that each tier
delivers its contracted behaviour end-to-end through the integrated
substrate: T1 absorbs loss silently as drops, T3 absorbs loss as RTT, and
neither bleeds into the other.
**Memory scaling.** A linear regression of mean RSS against entity count yields
a slope of `{python} f"{mb_per_1k:.2f}"`~MB per 1,000 entities
(R^2^ = `{python} f"{r2_memory:.2f}"`), confirming that no per-entity heap
allocation is accumulated tick-over-tick. The slope is well below the
1.02~MB-per-1{,}000 figure reported for the standalone ECS benchmark on a
1.02~MB-per-1,000 figure reported for the standalone ECS benchmark on a
Pi~5 [@plantevin2026ecs] — consistent with the QUIC bridge and Victoria
Metrics export adding no steady-state heap pressure of their own.
## Discussion
Three operational conclusions follow. First, ECS and QUIC are genuinely
Two operational conclusions follow. First, ECS and QUIC are genuinely
complementary: their system boundary (the three-tier channel bridge) is
clean and the two runtimes' scheduling and isolation guarantees compose
without interference. Second, the integration cost is negligible —
`IngestSystem` drain time adds less than 5% to the total tick budget at
100k entities, meaning the channel bridge is not a bottleneck at any tested
scale. Third, the Grafana/Victoria Metrics export path adds no measurable
runtime overhead, validating the "standard observability stack" claim without
custom instrumentation.
without measurable cross-tier interference, as @tbl-latency and
@tbl-t3-rtt jointly demonstrate. Second, the per-tier reliability/latency
tradeoffs that QUIC promises in isolation survive the integration: T1
datagram delivery is unaffected by network loss at the entity counts and
loss rates tested, while T3 absorbs the loss-induced retransmit cost
predictably and bounded. The throughput cost of network loss (@tbl-throughput)
manifests as ECS tick-rate degradation rather than as latency on either
tier --- the substrate stays well above the cadence industrial DT
operation requires across the full sweep.
# Related Work {#sec-related}
Reference in New Issue
Block a user
Blocking a user prevents them from interacting with repositories, such as opening or commenting on pull requests or issues. Learn more about blocking a user.
Valère Plantevin