| Asynchronous events, such as hardware interrupts, have been source of continuous distress for event-driven and real-time systems where the jitter caused by interrupts incur hard-to-predict, adverse effects on timing. For many decades, hardware architectures have directed interrupt handling to the main processor, causing unavoidable jitter to high priority threads that might be running at the moment. Alongside system timers that periodically generate interrupts to provide fair CPU utilization and proper device servicing by the means of a scheduler; it is a strenuous task to try to mitigate the overhead caused by this current state of affairs. There has been a number of accepted software techniques that attempt to lessen the impact of interrupt-induced jitter; however, the effectiveness of these techniques are limited if we continue to adhere to classic hardware interrupt architectures. By revisiting the fundamental hardware design of interrupts, it is possible to provide a new mean to eliminate interrupt jitter. Hence, turning interrupt events into schedulable threads and allowing device handlers to run within the control envelope of a hardware-based scheduler. By changing the semantics of interrupt requests to thread scheduling requests, interrupt-induced jitter can be eliminated and programmers are given precise control over the running of device handlers. As a consequence, the hardware system becomes significantly more predictable, yet the system configuration remains transparent to the software developer. |
