Status. This is an argument and a set of proposals, not a results paper. Statements about existing standards, products and research are referenced. Proposals are labelled as proposals. HopBound is an open-source project I maintain for per-hop timing evidence on shared platforms; it is described in section 8 and has not yet produced measurements. Updated 16 November 2026: sections 5, 7 and 8 now refer to HopBound, which succeeds the earlier MCIB benchmark.
1. The problem: no contract about interference
A robot or vehicle that runs learned perception beside safety-relevant control on one system-on-chip is running two workloads with incompatible characteristics. Inference is bursty, memory-hungry and best-effort. Control is small, periodic and has a hard deadline. They contend for last-level cache, memory bandwidth, the interconnect, interrupt delivery, the hypervisor's scheduler and, increasingly, the accelerator itself.
As the mixed-criticality primer puts it, the failure is not that the model is inaccurate. It is that the platform underneath both workloads has no contract about interference.
That sentence understates the problem in one respect. A sensor-to-actuator path does not cross one boundary. It crosses many: a field network, a device-virtualisation backend, a hypervisor, a shared memory hierarchy, a middleware layer, an executor, an accelerator queue, and back out again. A principle that holds across firmware, protocols and IPC applies to each of them: at every domain boundary, make the contract explicit, formal and machine-readable. Most of the boundaries on that path have no timing contract at all.
2. Three contracts, one pattern
Every boundary on a shared platform needs an answer along three dimensions.
| Dimension | The question | Mature mechanisms | State |
|---|---|---|---|
| Access | Who is allowed to touch what, and what happens when they shouldn't? | SMMU stage 2, TZASC, MPC/PPC, vendor equivalents | Widely deployed in current SoCs |
| Trust | Is this component what it claims to be, running what it claims to run? | DICE, SPDM, PCIe/CXL IDE, TDISP | SPDM attestation ships in data-centre GPUs and SSDs; uneven elsewhere (section 6) |
| Time | How long may this step take, and how much of a shared resource may it use? | TSN on the network; LET and AUTOSAR Timing Extensions in automotive software | Islands that do not join up across a consolidated SoC |
The access row is the subject of Security and Safety by Isolation, which reduces every hardware protection mechanism to one form: initiator identity × target resource → access policy. The same article treats MPAM as the temporal half of freedom from interference, using the same form with a partition ID, cache ways or DRAM bandwidth, and a cap. The trust row is the subject of From specification to silicon. This paper is about the third row.
The three dimensions share three requirements. Each contract must be enforced at the target, because an initiator cannot be trusted to police itself. Each must be locked before untrusted software runs, because a configuration that untrusted code can change is a convention, not a guarantee. And each must be evidenced by something other than the system being judged.
They also map onto the three questions that safety and security share. Is the system intact? is a trust question. Is it behaving as intended? is an access and time question. Can it recover to a safe, secure state when it isn't? is what each contract's miss handler is for.
3. The chain of trust as a template
The trust chain is worth studying not because timing is a security problem, but because it is a worked example of how an industry turned an implicit assumption into a verifiable property. It has four established steps, a fifth that is still open, and two composition rules.
The steps run from manufacture to runtime: a hardware-rooted identity provisioned once; measured boot, which records what actually started; attestation, in which a relying party checks identity and measurements before admitting the device; runtime enforcement, in which IDE protects every transaction afterwards; and, still open, continuity, re-checking during a workload's lifetime rather than only at admission.
The composition rules matter more than the steps. First, admission and enforcement are only meaningful together: IDE without SPDM attestation is encryption without verified identity. Second, the chain is bounded by its weakest link: a platform's security posture is bounded by its least-attested component.
Proposal: build the chain of timing with the same structure.
| Step | Chain of trust (exists) | Chain of timing (proposed) |
|---|---|---|
| Identity | DICE identity provisioned at manufacture | A declared timing contract per workload and per hop: demand envelope, burst profile, worst-case latency |
| Measured boot | Each firmware stage measured as it starts | The partitioning configuration that bounds interference (cache and bandwidth partitions, SMMU stage 2, network gate schedules, core pinning) locked, then measured |
| Admission | SPDM attestation before a device is trusted | A critical workload admitted only once that locked configuration has been verified |
| Enforcement | IDE on every transaction | Budgets enforced at the source: bandwidth regulation, time-aware gates, bounded execution windows |
| Continuity | Runtime re-attestation (open problem) | Runtime overrun detection that leads to a defined safe state (open problem) |
The first composition rule carries over directly. A budget without verified configuration is a budget nobody can check; a verified configuration without enforcement is a measurement, not a guarantee; and a deadline monitor without either is an alarm. The second rule does not carry over, and that is the subject of the next section.
4. Why time is harder: it adds up
Security fails at the weakest link. Timing fails at the sum. The end-to-end latency of a sensor-to-actuator path is bounded only if every hop on it is bounded, and the bound is the composition of all of them. A strong hop does not compensate for a weak one, and one unbounded hop makes the whole path unbounded.
That has two consequences that a trust chain does not face.
- Budgets must be enforced at the source. In a trust chain, a compromised component damages its own trustworthiness. In a timing chain, an unpoliced aggressor consumes shared cache, bandwidth or accelerator time and breaks the bounds of components it never touches. A budget that the aggressor is trusted to respect is not a budget.
- Hop boundaries must compose. If each hop's output appears whenever that hop happens to finish, every scheduling change upstream moves the timing of everything downstream, and end-to-end analysis has to be redone. The Logical Execution Time (LET) model, which originated with time-triggered programming and is now used in automotive software (AUTOSAR's Timing Extensions model LET intervals directly), fixes this by making each task read its inputs at the start of a fixed window and publish its outputs at the end, whatever happens inside. Communication then occurs only at fixed points, which gives deterministic timing and data flow and lets tasks compose without re-analysis. Network hops can be modelled the same way, as windows sized to the worst-case transmission time.
LET has a cost: outputs appear at the end of the window even when the work finished early, which lengthens end-to-end latency, and current research reduces that pessimism using knowledge of the schedule. Its value is that it is the timing equivalent of a well-defined trust boundary. An overrun is detectable at exactly one point, the window end.
5. Where the chain of timing breaks today
Following a sensor sample through a consolidated platform, hop by hop, shows where timing is enforced, where it is only detected, and where nothing bounds it by design. The last column names the layer where the contention arises: the hop says where time is lost, the layer says why.
| Hop | What exists | Status | Where contention arises |
|---|---|---|---|
| Field network | TSN: IEEE 802.1AS shared time and 802.1Qbv time-aware gates | Enforced, when configured | Outside the SoC |
| Device-virtualisation backend | The VIRTIO specification defines no deadlines or delivery-time bounds for requests; timing appears only as device data, such as clock readings from the RTC device. On Linux, vhost worker threads run in the normal time-sharing class unless configured otherwise. Real-time prototypes exist for ACRN and Jailhouse. | Not bounded by design | Hypervisor and device backend |
| Hypervisor dispatch | vCPU wait time and VM-exit handling add to every path; static partitioning with dedicated cores removes the vCPU scheduling wait | Bounded only by configuration | Hypervisor scheduling |
| Shared memory hierarchy | Cache and bandwidth contention sit below what the hypervisor can see. Arm MPAM and cache colouring can partition them, but MPAM details are in many respects implementation-defined. | Partially enforceable | Cache, memory, interconnect |
| Middleware | DDS deadline and liveliness QoS notify both sides when a stream misses its expected interval or goes silent | Detected, not enforced | Middleware |
| Executor | The default ROS 2 scheduling is not aware of chain criticality; research schedulers such as PiCAS add chain priority and analysable bounds | Not bounded by default | Operating system and middleware scheduling |
| Accelerator | Many accelerators offer limited or no preemption, so a long job can hold the engine; research frameworks such as PAAM schedule accelerator requests by chain priority | Not bounded by default | Accelerator |
Three observations follow.
- Enforcement is strongest at the edge. TSN schedules the network by design. Inside the SoC, where the inference and the control loop actually meet, enforcement is partial and depends on configuration, and several hops are only detected or not bounded at all.
- Detection is often mistaken for enforcement. A deadline callback reports a miss after it has happened. It is the timing equivalent of an intrusion alarm: necessary, and no substitute for a lock.
- In my assessment, the accelerator is the least-contracted hop and the most important one for Physical AI, because perception and vision-language-action inference run there.
Each loose hop has research that bounds it in isolation. What none of them has is a contract that carries across to the next hop.
6. The trust chain has gaps too
The trust row of the table in section 2 is not uniformly mature either, and the picture differs by domain.
Automotive sensors now have a standard path. The MIPI Camera Security Framework, released in 2024, uses DMTF SPDM to authenticate image sensors and the SerDes bridges that connect them to an ECU, and adds integrity protection and optional encryption of the image stream. MIPI positions it against UN R155, which lists manipulation of sensor data among in-vehicle vulnerabilities. A command-and-control companion specification followed in December 2025, and security IP implementing the framework was announced in 2026. I have not found evidence of production vehicles shipping it yet.
Robotics has no native equivalent that I could find. ROS 2 security, through SROS 2 and DDS-Security, authenticates and authorises software participants and encrypts topics. As a 2026 analysis points out, those guarantees apply once messages enter the protected stack; they do not establish whether the published data reflects the robot's physical state. I found hardware attestation of robot nodes in research and in component-level authenticator chips, but no robotics standard for it. MIPI describes the framework as applicable to other machine-vision uses of the same camera interface as well, so robot cameras have a route even though robotics did not create it.
The two dimensions meet at this point. A sample can be authentic and stale. It can be fresh and from a tampered sensor. A control loop needs both properties, and today they are checked, where they are checked at all, by unrelated mechanisms.
7. What would close it
All of the following are proposals.
Five building blocks
- Declared timing contracts. Each workload and each hop declares its demand and its bound in machine-readable form: memory footprint, bandwidth envelope, burst profile, worst-case latency split into floor and tail. Automotive software already has a machine-readable form for timing inside AUTOSAR models: the Timing Extensions describe event chains with latency and age constraints. What is missing is the same kind of contract for the hops outside that model, such as virtualised devices, middleware and accelerators. HopBound's specification outlines one candidate: a timing contract per hop, stating its needs, its promise and its sensitivity to each shared resource, derived from measurement.
- Enforcement at the source. Every declared budget is backed by a mechanism that limits the aggressor, not by the victim's hope: bandwidth regulation and cache partitioning, time-aware gates, accelerator arbitration with priority and bounded preemption.
- Composable boundaries. LET-style windows at hop boundaries, so that end-to-end latency is a sum of fixed windows that can be analysed in advance, rather than a property discovered by measurement.
- Attest the lock. The configuration that bounds interference is locked at boot, then measured and reported the way firmware is. This reuses machinery that already exists: SPDM already defines measurement types for hardware configuration and firmware configuration as well as for code (DSP0274 1.1, section 7.10.1.1). It is integrity evidence that the intended configuration is in force. It is not, on its own, evidence that deadlines are met.
- Runtime continuity. Overrun detection at window boundaries, tied to a defined reaction: degrade, fall back or reach a safe state.
Who could act on what
| Community | Proposal |
|---|---|
| OASIS VIRTIO TC, virtio-msg work | The virtio-msg draft (May 2026) already requires a bounded completion policy for control-plane requests, but its events carry no capture time or deadline and may be delivered at any time. While the transport is still being standardised, consider optional timing metadata on data events (capture timestamp, deadline or window identifier) and, for sensor-class devices, a latest-value semantic alongside the in-order queue. |
| SOAFEE and platform integrators | Express mixed-criticality platform requirements as per-hop timing contracts, with the enforcing mechanism named for each hop, rather than as a single end-to-end latency figure. |
| ROS 2 Real-Time WG and DDS vendors | Pair each deadline QoS with an enforced budget in a lower layer, and make chain criticality visible to the executor and to accelerator access. |
| DMTF and TCG | Define how a platform reports its locked partitioning configuration as attestation evidence, alongside firmware measurements. |
| Robotics platform vendors | Adopt existing sensor authentication (for example the MIPI framework for cameras) instead of creating robotics-specific schemes. |
8. Where HopBound fits
HopBound is the evidence side of the timing chain. Its loop is profile → attribute → control → verify, applied the same way to bare-metal RTOS, virtualised, on-chip AMP and off-chip AMP deployments. Each attributed outlier ends in a control verdict: configure (a configuration change removes it), isolate (a named spatial or temporal isolation mechanism bounds it) or limit (a structural limit to design around or contain). In the terms of this paper, attribution tells you which hop broke its contract and why, and the verdict tells you whether that hop's contract can be enforced at all.
Its method fits the third shared requirement in section 2, evidence that does not come from the system being judged. Each hop declares how much of it can be observed: its own execution, the platform around it, or only its boundaries. Where the inside is visible, tracing shows the mechanism; in every case, measuring the hop with and without the competing workload establishes the cause, with hardware counters as corroboration where the silicon exposes them.
Its current state is stated plainly in its repository. It started in November 2026, its specification is an outline, and it has produced no measurements yet; its first campaign, a perception chain from camera to inference to consumer, is planned. Its output is characterisation data that can be an input to a safety argument made and assessed by others. It is not qualified safety evidence.
9. Open problems
- Continuity, in both chains. Trust is mostly verified at admission, and timing is mostly analysed or tested before deployment. Neither has a standard way to keep checking during operation.
- Accelerators. Without bounded preemption or arbitration on the accelerator, no contract above it can be enforced. The software can only measure the consequences.
- Composition across the SoC and the network. TSN bounds the wire and LET bounds tasks; joining them through virtualised devices and middleware into one analysable path is not yet standard practice.
- Formats. AUTOSAR's Timing Extensions describe timing within AUTOSAR models, but no agreed form spans virtualised devices, middleware and accelerators, and none reports partitioning configuration as attestation evidence.
- Freshness against completeness. Device protocols such as VIRTIO return every buffer the driver submits, in a queue. Control loops need the latest value, not every value. Contracts need a way to say which.
None of this promises that nothing will go wrong. It aims at something more useful: knowing where timing can go wrong, containing it, and holding evidence that does not come from the system being judged.
References
- Lei Zhou, Mixed-criticality on shared silicon: a primer for Physical AI; VirtIO and hypervisors; Security and Safety by Isolation; From specification to silicon: the SPDM/IDE trust chain.
- L. Maia and G. Fohler, Reducing end-to-end latencies of multi-rate cause-effect chains for the LET model; J. Martinez, I. Sañudo and M. Bertogna, Analytical characterization of end-to-end communication delays with Logical Execution Time, IEEE TCAD.
- OASIS, Virtual I/O Device (VIRTIO) Version 1.4 and specification source; Linaro, virtio-msg specification draft (transport-msg.tex, error handling); Linaro, What is virtio-msg?
- Linaro, Network latency with Time Sensitive Networking on a virtual machine (vhost thread scheduling class).
- Towards virtual networking for a time-triggered hypervisor (time-triggered virtio-net on ACRN); G. Schwäricke et al., A real-time virtio-based framework for predictable inter-VM communication, RTSS 2021; Clock synchronization in virtualized distributed real-time systems using IEEE 802.1AS and ACRN.
- Promwad, Mixed-criticality scheduling on shared SoCs; Arm MPAM overview (IRIT TRACES); MPAM on a CIX CD8180 SoC (RTSS 2025 WiP); A. Oliveira et al., H-MBR: hypervisor-level memory bandwidth reservation.
- Mouser, How TSN brings deterministic timing to industrial Ethernet.
- AUTOSAR, Specification of Timing Extensions, Classic Platform R24-11 (event chains, latency and age constraints, LET).
- DDS QoS policies (deadline and liveliness); RTI, Recognizing communication patterns.
- H. Choi, Y. Xiang and H. Kim, PiCAS: priority-driven chain-aware scheduling for ROS 2, RTAS 2021; PAAM: priority-driven accelerator access management, RTAS 2024.
- MIPI Alliance, New camera security framework for automotive and other embedded applications; Camera Security Framework addresses regulatory requirements; What's new in MIPI security: CCISE; Synopsys, MIPI CSE 2.0 security solution.
- ROS 2 design, ROS 2 DDS-Security integration; Seeing is not believing: breaking the physical-to-digital trust boundary in robotics (2026); Credential masquerading and OpenSSL Spy: exploring ROS 2 using DDS security (2019).
- HopBound, repository and specification.
About this paper
Written by Lei Zhou. Text © 2026 Lei Zhou, licensed CC BY 4.0.
Standards and research status reflects the sources linked above as of November 2026. The proposals are the author's and are offered for argument.
Disagree, or have data?
If you have measured a hop that confirms or contradicts the table in section 5, or know of a standard I have missed, I would like to hear about it. Comments are hosted in GitHub Discussions and need a GitHub account. Nothing loads from a third party until you click.