Non-intrusive runtime verification can help embedded systems detect errors during operation without changing the timing of the software being monitored. This matters in safety-critical applications, where instrumentation can affect responsiveness and scheduling, while conventional trace streams may overwhelm the hardware available to analyze them. A proposed methodology addresses this challenge by filtering execution traces and using an automata processor to check system requirements in parallel.
Why embedded system tracing is difficult to verify in real time
Processor traces can include program counters, opcodes, memory activity and other information about execution. This data is valuable for debugging and monitoring, but collecting it cycle by cycle creates a substantial volume. A separate monitoring unit must process relevant information quickly and retain enough requirement state to assess behavior over time.
Software-based monitoring presents a different trade-off. Adding instrumentation can alter execution timing, which is a concern for real-time embedded applications. Some hardware trace approaches instead store data for later inspection or rely on external processing; those methods may require a system halt or be constrained by the available interface bandwidth. For online verification, a monitor needs a way to examine events as they occur while avoiding unnecessary changes to the target software.
A layered approach to non-intrusive runtime verification
The Trace Abstraction Layer (TAL) separates tracing and verification into functional layers. This structure is intended to accommodate differences among processor trace interfaces while passing only useful information to the verification hardware.
Compatibility layer
Processor platforms expose different trace signals, making a monitor designed for one interface difficult to reuse on another. The compatibility layer identifies or derives the information needed by the verification system. Program-counter addresses and opcodes provide a common starting point. Other elements, such as time tags or memory access details, may be generated or inferred where the processor interface does not supply them directly.
Filtering layer
Rather than forwarding every trace record, the filtering layer detects selected events and attaches timing information. Events can represent an address match, a memory read or write that meets a specified condition, or the arrival of a configured cycle period. Trace data unrelated to the defined filters is discarded, reducing the stream delivered to the next stage.
This distinction is important: the monitor does not need every instruction to check every requirement. It needs the events that describe relevant transitions, timing boundaries or variable conditions. Those events are then mapped to symbols for processing by the automata processor.
Verification and reporting layers
In the verification layer, requirements are represented as timed automata and transformed into non-deterministic finite automata (NFAs) that the processor can execute. A symbolizer converts filtered events into the processor’s input format. When an automaton reaches a reporting state, a report unit can communicate the result, including through a processor interrupt connection.
The TAL also describes debug and external-trace functions. For example, a configured address event can act as a breakpoint, with captured trace information passed to a debugger. These functions are distinct from online verification: debugging may halt the processor, whereas the verification path is designed to monitor execution without that interruption.
Using timed automata to express runtime requirements
Timed automata provide a way to describe system states, transitions and clock constraints. For runtime monitoring, a model can capture requirements such as how long a task may take, which events must occur in sequence, or what value must be observed during a memory operation. The model therefore connects formal properties to events that can be detected in the trace.
For example, a timing requirement can track the start and end of a task and check the interval between them. A sequence requirement can identify an unexpected ordering of task events. A memory-value requirement can check whether a read or write meets a specified condition. These models define the behaviors to monitor; they do not by themselves guarantee that every system-level interaction is represented. The quality of verification depends on suitable requirements and accurate mapping from processor traces to events.
What the pacemaker experiment demonstrates
The methodology was evaluated using a simulated network-connected pacemaker application, with requirements covering timing, execution sequence, synchronization and memory-value failures. The experiment injected 4,000 failures, divided equally among four failure types, then processed the resulting trace through filtering, symbolization and an automata-processor simulator.
Within that experimental setup, the monitor detected all injected failures. This is a result for the modeled application and tested failure set—not a general guarantee of detection for other systems or failure modes. The work also considered a collision-avoidance application, illustrating how the approach could be applied to another cyber-physical system.
The reported failure notification path was estimated at 43.5 cycles, or 326 nanoseconds, using the referenced automata-processor configuration. That figure describes the reporting path in the evaluated setup. The study also notes a processing-rate limitation: if events arrive faster than the automata processor can handle them, traces buffered by the filtering layer must be processed sequentially, adding latency.
Engineering considerations and practical implications
Applying this method requires more than selecting monitoring hardware. Verification specialists must define the requirements, connect them to observable trace events, and convert the timed-automata models into automata-processor representations. In the described approach, that conversion was manual, so model transformation and requirement development remain important engineering tasks.
Hardware resource use also depends on the implementation. The study used an FPGA prototype to estimate overhead, while noting that an FPGA implementation does not reproduce the efficiency of the automata processor itself. The processor’s limited symbol set was another design consideration; the work discusses symbol-set conversion as a way to accommodate more event mappings.
For system integrators and embedded engineers, the central design lesson is to treat monitoring as a pipeline: normalize platform-specific traces, filter for meaningful events, express requirements formally, and report violations promptly. A non-intrusive approach can reduce dependence on software instrumentation, but it still requires careful validation of trace coverage, model assumptions, processing capacity and failure-response behavior.
Conclusion
Automata-processor-based runtime verification offers a structured way to analyze selected execution events without instrumenting the monitored application. The TAL separates interface compatibility, event filtering and property checking, while timed automata provide a basis for expressing timing, sequence and value requirements. The reported experiments show the potential of this approach in modeled cyber-physical applications, alongside practical limitations in model conversion, symbol capacity and event throughput. Engineers evaluating it should assess those constraints against their system’s requirements and safety objectives.