df_throughput.query("entities == 100000 and loss_pct == 0")["hz"].iloc[0]
hz_at_100k_5pct = _hz(100000, 5)
)
hz_at_100k_5pct = float(
df_throughput.query("entities == 100000 and loss_pct == 5")["hz"].iloc[0]
)
rss_at_100k = float(
rss_at_100k = float(
df_throughput.query("entities == 100000 and loss_pct == 0")["rss_mb"].iloc[0]
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
compose? Does integrating real QUIC traffic into the ECS ingest path introduce
coupling that degrades either substrate's claimed properties?
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}
# Background {#sec-background}
@@ -292,82 +292,29 @@ accuracy; throughput measurements used the two-machine setup.
## Results
## Results
```{python}
| Entities | 0% loss | 1% loss | 5% loss |
#| label: tbl-latency
|---:|---:|---:|---:|
#| tbl-cap: "T1 datagram P99 latency (ms) on the CM5 across entity counts
#| 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."
from IPython.display import Markdown, display
: 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}
: 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}
#| label: tbl-throughput
#| tbl-cap: "ECS DT runtime throughput under real QUIC traffic on the CM5
: 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}
index="entities", columns="loss_pct",
values="hz", aggfunc="mean"
).sort_index()
tbl.columns = [f"Hz ({int(c)}% loss)" for c in tbl.columns]
**ECS tick rate under real network load.** At 100k entities the integrated
**ECS tick rate under real network load.** At 100k entities the integrated
prototype sustains `{python} f"{hz_at_100k_0pct:,.0f}"`~Hz within
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
**Cross-tier isolation.** @tbl-latency shows that T1 datagram delivery is
not measurably delayed by packet loss at any tested entity count: the
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
per-row difference between 0\% and 5\% loss falls within $\pm 3$~ms of
cross-host clock-offset baseline, indistinguishable from clock-drift noise.
the cross-host clock-offset baseline, indistinguishable from clock-drift
@fig-isolation independently confirms cross-tier isolation in the loopback
noise. @tbl-t3-rtt shows the complementary picture for the reliable tier:
regime where clock offset is absent: T3 P99 latency held at a 100~Hz
substrate-initiated T3 round-trips climb from a $\sim 9$~ms baseline at
baseline remains within a 150--220~µs band as the concurrent T1 datagram
0\% loss to $\sim 47$~ms at 5\% loss --- a uniform $\sim 38$~ms retransmit
rate sweeps three orders of magnitude on the same QUIC connection.
cost across all tested entity counts, in line with QUIC's reliable-stream
Together these results confirm that QUIC head-of-line blocking isolation
recovery on a 1~Gbps link. The two tables together confirm that each tier
and ECS system scheduling isolation compose without measurable interference
delivers its contracted behaviour end-to-end through the integrated
through the integrated substrate.
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
**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
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
(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
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
Pi~5 [@plantevin2026ecs] — consistent with the QUIC bridge and Victoria
Metrics export adding no steady-state heap pressure of their own.
Metrics export adding no steady-state heap pressure of their own.
## Discussion
## 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
complementary: their system boundary (the three-tier channel bridge) is
clean and the two runtimes' scheduling and isolation guarantees compose
clean and the two runtimes' scheduling and isolation guarantees compose
without interference. Second, the integration cost is negligible —
without measurable cross-tier interference, as @tbl-latency and
`IngestSystem` drain time adds less than 5% to the total tick budget at
@tbl-t3-rtt jointly demonstrate. Second, the per-tier reliability/latency
100k entities, meaning the channel bridge is not a bottleneck at any tested
tradeoffs that QUIC promises in isolation survive the integration: T1
scale. Third, the Grafana/Victoria Metrics export path adds no measurable
datagram delivery is unaffected by network loss at the entity counts and
runtime overhead, validating the "standard observability stack" claim without
loss rates tested, while T3 absorbs the loss-induced retransmit cost
custom instrumentation.
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}
# 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