Glenn Elliott, University of North Carolina at Chapel Hill
James Anderson, University of North Carolina at Chapel Hill

Threaded interrupt handling is a common technique used in real-time operating systems since its use increases system responsiveness and reduces priority inversions. The PREEMPT_RT Linux kernel patch introduces aggressive threaded interrupt handling into the Linux kernel. However, under PREEMPT_RT, interrupt handling threads must be assigned a single fixed scheduling priority. This can become a significant limitation when an interrupt-generating device is shared by processes of differing priorities. In this paper, we show that there is no good option for assigning a single fixed priority to an interrupt handling thread in such cases: If an interrupt thread is given too low a priority, then high-priority device-using processes may be delayed from execution while waiting for their associated interrupts to be processed. If an interrupt thread is given too high a priority, then the processing of interrupts associated with low-priority device-using processes delay the execution of higher-priority processes, even those that may not use a device.

The limitation of fixed-priority threaded interrupt handling in PREEMPT_RT is demonstrated by an implementation-based study of graphics processing units (GPUs) used to perform general purpose computation, an increasingly common practice. We show that even when processes that have timing requirements on the order of twenty milliseconds, and each GPU interrupt takes only about thirty microseconds to process, too high of a GPU interrupt priority can increase the response time of non-GPU-using processes, while too low of a priority can increase the response times of high-priority GPU-using processes.

The paper then surveys real-time threaded interrupt approaches that appear in academic literature and several commercial real-time operating systems. We weigh the suitability of the surveyed approaches for different types of real-time workloads and discuss the pros and cons of each method. Special attention is given to unique situations that only appear in multiprocessor systems.

The goal of this paper is to demonstrate that there currently is a real limitation in PREEMPT_RT interrupt handling and to facilitate the discussion of alternative approaches that may remedy the situation.