Active Monitoring with RTLola: A Specification-Guided Scheduling Approach

Jan Baumeister, Bernd Finkbeiner, Frederik Scheerer

TL;DR

This paper introduces an "active" approach to runtime monitoring for cyber-physical systems like drones. Instead of passively receiving a fixed stream of sensor data, the monitor uses scheduling annotations within its formal specification to dynamically prioritize which sensors to query based on the system's current state, significantly reducing bandwidth usage while detecting safety violations faster.

What Problem Does This Paper Address?

Traditional stream-based monitoring is passive. The monitor sits at the end of a data pipe, processing whatever sensor readings the system sends its way. In resource-constrained environments—such as an autonomous drone with limited battery and communication bandwidth—this is inefficient.

If a drone is flying in the middle of a wide-open field, it doesn't need high-frequency GPS updates to ensure it stays within a geofence. However, if it drifts toward a restricted boundary, those updates become critical. Passive monitors usually rely on a fixed sampling frequency that is either too slow (missing critical events) or too fast (wasting energy and bandwidth). The authors tackle the challenge of how to make a monitor "intelligent" enough to decide which data it needs right now to maintain safety without overwhelming the system's resources.

Methods

The authors propose an Active Monitoring Framework built on top of RTLola, a stream-based specification language. Their approach consists of three main pillars:

  1. Scheduling Annotations: They extend the RTLola syntax to allow developers to attach priorities and deadlines directly to streams. For example, a geofence check can be assigned a "high" priority only when the drone is near a boundary.
  2. Formal Semantics for Scheduling: They define a mathematical framework for "Scheduled Monitor Semantics." This ensures that the scheduler respects bandwidth bounds (e.g., "only 2 sensor readings per cycle") while guaranteeing that no task is starved of data indefinitely.
  3. The Translation Approach: To keep the system compatible with existing tools, the authors developed a translator. It takes an annotated specification and converts the scheduling logic into "regular" RTLola output streams. These streams act as instructions for a separate Scheduler Component that interfaces with the actual hardware sensors.

Datasets

The researchers evaluated their framework using the Microsoft AirSim simulator, a high-fidelity environment for drones and cars.

  • Scenario: A drone flight tasked with collecting barometer data for an experiment while staying within a geofence and altitude limit.
  • Sensors: GPS (latitude/longitude), altitude sensor, and two experimental barometers.
  • Baselines: They compared their active monitor against four "fixed-frequency" passive monitors (ranging from 1/3 Hz to 2 Hz).

Key Insights and Ideas

  • The Monitor as the Brain: The core "aha moment" is realizing that the monitor is the only component with a comprehensive view of the system's state. Therefore, the monitor—not the sensors—should dictate the sampling schedule.
  • Context-Aware Bandwidth Allocation: By using state-dependent priorities, the monitor can "pivot." When the drone is safe, it allocates bandwidth to experimental data (the barometers). When a violation is imminent, it automatically shifts that bandwidth to safety-critical sensors (GPS).
  • Zero-Engine Modification: By translating scheduling annotations into standard RTLola streams, the authors show that active monitoring can be implemented without rewriting the underlying monitoring engine, making it highly portable.

Key Results

The evaluation demonstrated clear wins in both efficiency and safety:

  • Bandwidth Efficiency: The active monitor detected violations just as quickly as the fastest (2 Hz) fixed-frequency monitor but used 50% less bandwidth.
  • Faster Detection: When compared to a fixed-frequency monitor using the same amount of bandwidth (the 1 Hz baseline), the active monitor detected specification violations significantly sooner.
  • Dynamic Flexibility: The results showed the monitor successfully "starved" non-essential sensors to focus on critical inputs during high-risk maneuvers, then reverted to normal operation once the risk subsided.

Limitations and Future Work

  • Real-World Overhead: The study was conducted in a simulator. The authors acknowledge that the "active" role (sending queries to sensors) introduces its own communication overhead that needs to be measured on physical hardware.
  • Complex Task Dependencies: Currently, the model assumes a relatively simple relationship between sensors and streams. Future work will explore more complex scenarios where a single sensor produces multiple values or where sensors have intricate inter-dependencies.
  • Advanced Protocols: The current bandwidth model is a simple "count of inputs." Future iterations could account for varying bit-widths of different data types or specific hardware communication protocols.

Summary updated

Abstract

Stream-based monitoring is a well-established runtime verification approach which relates input streams, representing sensor readings from the monitored system, with output streams that capture filtered or aggregated results. In such approaches, the monitor is a passive external component that continuously receives sensor data from the system under observation. This setup assumes that the system dictates what data is sent and when, regardless of the monitor’s current needs. However, in many applications – particularly in resource-constrained environments like autonomous aircraft, where energy, size, or weight are limited – this can lead to inefficient use of communication resources. We propose making the monitor an active component that decides, based on its current internal state, which sensors to query and how often. This behavior is driven by scheduling annotations in the specification, which guide the dynamic allocation of bandwidth towards the most relevant data, thereby improving monitoring efficiency. We demonstrate our approach using the stream-based specification language RTLola and assess the performance by monitoring a specification from the aerospace domain. With equal bandwidth usage, our approach detects specification violations significantly sooner than monitors sampling all inputs at a fixed frequency.
BibTeX
@inproceedings{baumeister2025active,
  author = {Jan Baumeister and Bernd Finkbeiner and Frederik Scheerer},
  title = {{Active Monitoring with RTLola: A Specification-Guided Scheduling Approach}},
  booktitle = {RV},
  year = {2025},
  doi = {10.1007/978-3-032-05435-7\_11},
}

Loading related content...

Figure