Scheduling Analysis of UAV Flight Control Workloads on PREEMPT RT Linux Using a Raspberry Pi 5
summary
The gist
Modern UAV architectures increasingly aim to unify high-level autonomy and low-level flight control on a single General-Purpose Operating System (GPOS) This paper performs an architectural analysis…
In short
The study analyzed how different Linux kernel activation methods affect a 250 Hz flight control loop on a Raspberry Pi 5. Standard Linux caused severe latency spikes over 9 ms, making it unsuitable for real-time control. Using PREEMPT_RT reduced this worst-case latency by nearly 88% to under 225 microseconds, ensuring the controller computes with fresh data every cycle.
Key concepts
- SoftIRQs
- These are deferred execution methods in the standard kernel where interrupt handling is postponed. This delay causes significant scheduling variance and large latency spikes, which is why the standard kernel failed to meet the strict timing requirements of a flight control system.
- Direct Activation Path
- PREEMPT_RT enforces this path by converting interrupt handlers into preemptible threads. This architecture flattens the task activation hierarchy, allowing hardware timers to wake user tasks almost immediately, drastically reducing the time spent waiting for OS scheduling.
- Residual Jitter
- Even with PREEMPT_RT, a small amount of timing variation (200–225 µs) remains. This jitter is not caused by the operating system scheduling itself but is due to hardware contention on shared resources like the L3 cache and memory bus on the Pi 5 SoC.
Terminology used across episodes
This episode discusses
- Scheduling Analysis of UAV Flight Control Workloads on PREEMPT RT Linux Using a Raspberry Pi 5 · Paper Radio
The paper
Scheduling Analysis of UAV Flight Control Workloads on PREEMPT RT Linux Using a Raspberry Pi 5 · Read on arXiv
Luiz Giacomossi, Hákan Forsberg, Baran 힜ıklü, Ivan Tomasic, Tommaso Cucinotta
Málardalen University · ReTiS Lab, Scuola Superiore Sant訤 Anna
Modern UAV architectures increasingly aim to unify high-level autonomy and low-level flight control on a single General-Purpose Operating System (GPOS). However, complex multi-core System-on-Chips (SoCs) introduce significant timing indeterminism due to shared resource contention. This paper performs an architectural analysis of the PREEMPT RT Linux kernel on a Raspberry Pi 5, specifically isolating the impact of kernel activation paths (deferred execution SoftIRQs versus real-time direct activation) on a 250 Hz control loop. Results show that under heavy stress, the standard kernel is unsuitable, exhibiting worst-case latencies exceeding 9 ms. In contrast, PREEMPT RT reduced the worst-case latency by nearly 88 percent to under 225 microseconds, enforcing a direct wake-up path that mitigates OS noise. These findings demonstrate that while PREEMPT RT resolves scheduling variance, the residual jitter on modern SoCs is primarily driven by hardware memory contention.
DOI: 10.1109/ETFA68377.2026.11724768
Transcript
Introduction to the show: ident: Robotics Radio. Generated commentary on the latest robotics and control papers.
Rosa: We're looking at the paper: "Scheduling Analysis of UAV Flight Control Workloads on PREEMPT RT Linux Using a Raspberry Pi 5".
Dev: Here's the gist of the paper. Modern UAV architectures increasingly aim to unify high-level autonomy and low-level flight control on a single General-Purpose Operating System (GPOS) This paper performs an architectural analysis of the PREEMPT RT Linux kernel on a Raspberry Pi 5, specifically isolating the impact of kernel activation paths—deferred execution (SoftIRQs) versus real-time direct activation—on a 250 Hz control loop Results show that under heavy stress, the standard kernel is unsuitable, exhibiting worst-case latencies exceeding 9 ms In contrast, PREEMPT RT reduced the worst-case latency by nearly 88% to under 225 µs, enforcing a direct wake-up path that mitigates OS noise These findings demonstrate that while PREEMPT RT resolves scheduling variance, the residual jitter on modern SoCs is primarily driven by hardware memory contention.
Rosa: Architectural Mechanism of Latency Reduction The core finding centers on how task activation paths dictate worst-case latency The standard kernel's reliance on Deferred Execution (SoftIRQs) is the primary cause of > 9 ms latency spikes Conversely, PREEMPT RT enforces a Direct Activation Path, which flattens the activation hierarchy by converting interrupt handlers into preemptible threads This architectural change drives the 87.9% reduction in worst-case latency for SCHED FIFO.
Dev: The trace data shows that the PREEMPT RT kernel allows the hardware timer interrupt to wake the user task directly, resulting in a wake-up latency of just 7 µs.
Rosa: Resource Contention and Residual Jitter While PREEMPT RT bounds OS scheduling latency, a residual worst-case jitter of 200–225 µs persists even on isolated CPU cores This indicates that the complexity of the Pi 5’s BCM2712 SoC, with its shared L3 cache and DRAM controller, is a major factor The authors hypothesize that "noisy neighbor" threads on Cores 0–1 induce L3 cache thrashing and memory bus contention This hardware-level interference is supported by the observation that the computational execution time of the control payload increased from ≈ 3.8 µs in the real-time kernel to ≈ 51 µs in the standard kernel.
Paper summary: Rosa: So we're looking at this paper titled "Scheduling Analysis of UAV Flight Control Workloads on PREEMPT RT Linux Using a Raspberry Pi five" <ref:2604.19275#pg1,Scheduling Analysis of UAV Flight Control Workloads on PREEMPT RT Linux Using>. The main idea here is trying to get high-level autonomy and low-level flight control onto one General-Purpose Operating System, which is a big goal for UAVs.
Dev: But complex multi-core System-on-Chips introduce timing problems because of shared resources, so this paper analyzes the PREEMPT RT Linux kernel on a Raspberry Pi five to see how different ways of activating tasks affect a control loop running at two hundred fifty Hz <ref:2604.19275#pg1,the PREEMPT RT Linux kernel on a Raspberry Pi 5>.
Taro: What's really interesting is they are isolating the effect of kernel activation paths, specifically looking at deferred execution SoftIRQs versus real-time direct activation. That sounds like it could explain a lot about where the delays are coming from.
Rosa: Yeah, and what they found is that under heavy stress, using the standard kernel is unsuitable for this kind of work because it shows worst-case latencies exceeding nine ms <ref:2604.19275#pg1,worst-case latencies exceeding 9 ms>.
Dev: That's a huge spike for a two hundred fifty Hz control loop <ref:2604.19275#pg1,a 250 Hz control loop>. But then they look at PREEMPT RT, and it reduces that worst-case latency by nearly eighty-eight percent, bringing it down to under two hundred twenty-five microseconds <ref:2604.19275#pg2>.
Taro: So the core mechanism is that PREEMPT RT enforces a direct wake-up path that cuts through the OS noise. That means the hardware timer interrupt wakes up the user task directly in just seven microseconds.
Rosa: Exactly, so they show that this architectural change really fixes scheduling variance, but they also found something else bothering them.
Dev: They found that even with PREEMPT RT bounding the scheduling latency, there's still a residual worst-case jitter of two hundred to two hundred twenty-five microseconds persisting on modern SoCs <ref:2604.19275#pg2>.
Taro: That suggests the problem isn't just the scheduler anymore; it points toward hardware memory contention being a major factor in these new architectures.
Rosa: And they support that with data showing that the computational execution time of the control payload actually increased from about three point eight microseconds in the real-time kernel to about fifty-one microseconds in the standard kernel.
Dev: That's a significant increase in processing time just because of how the standard kernel handles things under load. They also compared this against an industry-standard microcontroller baseline, and while PREEMPT RT has about ten times more jitter than a bare-metal RTOS, that worst-case jitter of two hundred twenty-four microseconds is only about five point six percent of the timing budget for that same two hundred fifty Hz control loop.
Taro: So it confirms that while Linux can't match microsecond precision, it gives you enough determinism for the control loop when you have all this computational power to work with.
Rosa: For someone just listening to the show, what this means is that if you want a unified UAV architecture on one board, PREEMPT RT provides the timing predictability needed for high-frequency control.
Paper summary: Dev: It suggests that a single GPOS running PREEMPT RT can be a viable alternative to using dual-processor designs in many UAV applications when the constraints aren't as strict. But they also noted a limitation: this analysis intentionally isolated CPU scheduling from I/O, and they should extend it to more refined effects of both.
Taro: So the paper provides a computational baseline for these unified architectures, but it stops short on fully integrating real-world sensor and actuator I/O effects.
Rosa: That’s the gist of this paper on "Scheduling Analysis of UAV Flight Control Workloads on PREEMPT RT Linux Using a Raspberry Pi five" <ref:2604.19275#pg1,Scheduling Analysis of UAV Flight Control Workloads on PREEMPT RT Linux Using>. It shows that choosing the right activation path in the kernel, moving from deferred execution to direct activation, can reduce worst-case latency for a two hundred fifty Hz loop from over nine milliseconds down to under two hundred twenty-five microseconds <ref:2604.19275#pg2>.
Dev: The main contribution is identifying that standard kernel reliance on SoftIRQs causes those large latency spikes, while PREEMPT RT’s Direct Activation path handles the wake-up directly, which cuts that latency by about eighty-eight percent <ref:2604.19275#pg2,PREEMPT RT’s Direct Activation path>.
Taro: But the paper also highlights a limitation: the residual jitter of two hundred to two hundred twenty-five microseconds still exists on modern SoCs because of hardware memory contention, which they say is driven by shared L3 cache and DRAM controller interference <ref:2604.19275#pg2>.
Rosa: And they use a comparison to an industry-standard microcontroller where PREEMPT RT shows about ten times higher jitter, but that measured worst-case jitter of two hundred twenty-four microseconds is only about five point six percent of the timing budget for that two hundred fifty Hz control loop.
Dev: The implication for us is that while PREEMPT RT solves the scheduling variance, the residual jitter on modern SoCs is really driven by hardware memory contention, which means we have to look at the silicon level when designing these systems.
Taro: And for someone who only listens to this show, it means you can use Linux on a single board if you configure it right with PREEMPT RT for good control loop timing, but you still have to account for the physical memory bottlenecks of the hardware.
Rosa: So, in conclusion regarding "Scheduling Analysis of UAV Flight Control Workloads on PREEMPT RT Linux Using a Raspberry Pi five", they show that a properly configured GPOS with PREEMPT RT gives the timing predictability needed for high-frequency control, making unified architectures a viable path for some UAVs <ref:2604.19275#pg1,Scheduling Analysis of UAV Flight Control Workloads on PREEMPT RT Linux Using>.
Dev: But they also lay out the caveat: the analysis is limited because it intentionally isolated CPU scheduling from I/O, and future work needs to integrate real-world sensor and actuator I/O to see how those combined effects play out.
Taro: That’s right, so the paper gives us a strong computational baseline for unified UAV architectures, but we still need more work on the interaction between the scheduler latency and hardware interrupt handling.
Conclusion: Rosa: So we're wrapping up this paper, "Scheduling Analysis of UAV Flight Control Workloads on PREEMPT RT Linux Using a Raspberry Pi five." Basically, they’re looking at how to get high-level autonomy and low-level flight control onto one operating system for drones.
Dev: Right, the core of it is isolating the effect of kernel activation paths—specifically SoftIRQs versus direct activation—on a two hundred fifty Hertz control loop running on a Raspberry Pi five.
Taro: I found that finding that standard Linux kernel's worst-case latencies were over nine milliseconds under stress was pretty telling for real-time stuff.
Rosa: Yeah, and PREEMPT RT brought that down by nearly eighty-eight percent to under two hundred twenty five microseconds. That’s a massive jump in performance for a control system.
Dev: That reduction happens because PREEMPT RT enforces this direct activation path, which flattens the interrupt handling hierarchy and cuts down on OS noise significantly.
Taro: But they also found that even with PREEMPT RT, there's still this residual jitter of two hundred to two twenty five microseconds. That means something else is fighting the scheduler.
Rosa: They point to hardware memory contention on the Pi five SoC—things like shared L3 cache and DRAM controller interference—as the main reason for that remaining timing uncertainty.
Dev: And they show that this hardware issue was real because the actual computational execution time of their control payload went from three point eight microseconds in the real-time kernel to fifty one microseconds in the standard kernel.
Taro: So, a two hundred twenty five microsecond jitter is still quite high for tight control, but it’s much better than nine milliseconds. The comparison to a bare-metal microcontroller shows that while Linux isn't microsecond precise, it gives you enough determinism when you have this much power.
Rosa: This paper suggests that a properly configured GPOS with PREEMPT RT is now a viable path for high-frequency flight control on single boards like the Pi five.
Dev: It opens up the idea that unified GPOS architectures might be better than dual-processor designs in some UAV applications where the constraints aren't as tight.
Taro: But remember, they intentionally isolated CPU scheduling from I/O, so this analysis doesn't fully capture how scheduler latency and hardware interrupts interact in a real-world sensor situation yet.
Rosa: Exactly, so the paper gives us a solid computational baseline for these unified UAV architectures on hardware like the Pi five.
Dev: It’s a useful starting point for understanding where we are in terms of achieving timing predictability with modern embedded Linux systems.
Taro: Next time, we look at how this performance holds up when you actually throw it into a messy, real-world failure mode scenario.
More episodes
- 2608.13438-ContactGuard: Pre-Contact Execution Monitoring with Action-Conditioned Latent World Models
- 2610.34593-Future Prediction as Training-Only Video Supervision for Pretrained VLA Policies
- 2610.35385-EmbodiedLab: Beyond Manipulation, Benchmarking Embodied Agents That Act to Know
- 2610.36378-Data-Driven Hamiltonian for Neural Optimal Control
- 2610.37275-A Heuristic for Scheduling Autonomous Vehicles at Intersections
- 2610.37288-Dynamic Coordination of Autonomous Vehicles at Intersections
- 2610.37632-Real-Time Coordination of Autonomous Vehicles at Intersections
- 2611.13779-Softness is something you also need! Why compliance helps control: information metrics of a passive walker with compliant ankle
- 2611.13411-Residual-Corrected Physics-Informed Neural Network KKL Observers with Input-to-State Stability Guarantees
- 2611.14488-Is Your Robot's Memory Just a Clock? Temporal Shortcuts in Memory-Augmented VLA Policies