Real-Time Operating System

The core feature distinguishing an RTOS from a GPOS like Linux. The scheduler guarantees that the highest-priority task ready to run will be given CPU time within a bounded scheduling latency.

• Preemptive Priority-Based Scheduling: A running task is immediately interrupted when a higher-priority task becomes ready.
• Tickless Kernels: Modern RTOSes use tickless dynamic timers to achieve sub-microsecond jitter, avoiding the power waste and imprecision of periodic system clock interrupts.
• Priority Inversion Avoidance: Implements mechanisms like priority inheritance to prevent a high-priority task from being blocked indefinitely by a low-priority task holding a shared resource.

The time between a hardware interrupt asserting and the first instruction of the Interrupt Service Routine (ISR) executing. An RTOS is architected to minimize and bound this latency.

• Zero-Interrupt Latency: The kernel never disables interrupts for more than a few instruction cycles, ensuring the CPU is always responsive to external events.
• Deferred Interrupt Handling: Long ISRs are split into a short, critical top-half that acknowledges the hardware, and a schedulable bottom-half (or deferred procedure call) that performs the bulk of the processing.
• This is critical for Software-Defined Radio (SDR) applications where missing an ADC sample buffer interrupt results in catastrophic data loss.

The RTOS kernel always executes the highest-priority ready thread. Preemption ensures a low-priority task cannot monopolize the CPU.

• Strict Priority Ordering: A task with priority 10 will never run if a task with priority 5 is ready. This allows engineers to model the criticality of signal processing chains mathematically.
• Round-Robin Time-Slicing: For tasks of equal priority, the RTOS can optionally time-slice the CPU to ensure fair access without breaking the deterministic model.
• Rate Monotonic Scheduling (RMS): A common static priority assignment where tasks with shorter periods get higher priorities, proven to be optimal for static workloads.

Dynamic memory allocation (malloc/free) is non-deterministic and often banned in hard real-time systems. RTOSes provide deterministic alternatives.

• Static Memory Pools: Fixed-size blocks of memory are pre-allocated at compile time. Allocation and deallocation are O(1) constant-time operations with zero fragmentation.
• Memory Protection Units (MPU): A lightweight alternative to a full MMU. The MPU isolates task stacks and critical kernel data, preventing a rogue thread from corrupting the system while maintaining fast context switch times.
• Stack Overflow Detection: The kernel proactively checks stack canaries during context switches to prevent memory corruption before it occurs.

Mechanisms to safely pass data between asynchronous tasks and ISRs without data corruption or race conditions.

• Message Queues: Thread-safe FIFO buffers that allow tasks to pass data by value. They decouple the producer and consumer, absorbing bursts of data.
• Semaphores & Mutexes: Binary semaphores synchronize tasks with events (e.g., 'ADC buffer full'). Mutexes with priority inheritance protect shared resources like a DAC output register.
• Event Flags: A single 32-bit word where tasks can pend on a specific combination of bits, allowing a single task to synchronize with multiple events simultaneously.

An RTOS optimizes for energy efficiency without sacrificing determinism, crucial for battery-powered edge AI sensors.

• Dynamic Tick Suppression: When the system is idle, the periodic system tick interrupt is completely disabled. The CPU enters a deep sleep state and is only woken by a precisely timed hardware timer for the next scheduled task.
• Idle Task Hook: The kernel calls a user-defined function when no tasks are ready, allowing the application to gate clocks to peripherals or reduce PLL frequencies.
• This allows a TinyML device performing intermittent RF fingerprinting to draw near-zero current between sampling windows.

The core guarantee of an RTOS: a task's response time is bounded and predictable, not just fast. This is achieved through priority-based preemptive scheduling where the highest-priority ready task always runs.

• Hard Real-Time: Missing a deadline constitutes system failure (e.g., radar pulse deinterleaving).
• Soft Real-Time: Missing a deadline degrades performance but is tolerable (e.g., spectrum waterfall display).
• Priority Inversion: A critical bug where a high-priority task is blocked by a low-priority task, mitigated by protocols like priority inheritance.

The time from a hardware interrupt assertion to the execution of the first instruction of the Interrupt Service Routine (ISR). In an RTOS, this must be bounded and minimal.

• Interrupt Latency: The total delay, including hardware propagation, RTOS kernel critical sections, and context switch overhead.
• Interrupt Jitter: The variance in interrupt latency. High jitter introduces non-deterministic sampling errors in SDR pipelines.
• Zero-Interrupt Latency: A misnomer; the goal is to minimize the longest, non-maskable critical section.

The kernel can forcibly suspend the currently executing task to run a higher-priority task that has become ready. This is distinct from cooperative multitasking, where tasks voluntarily yield control.

• Context Switch: The process of saving the CPU state of the preempted task and restoring the state of the incoming task. This overhead is a critical RTOS performance metric.
• Tickless Kernel: An advanced RTOS mode that eliminates the periodic system tick interrupt to reduce power consumption and jitter, instead using a dynamic hardware timer for the next deadline.

Mechanisms for safe, deterministic data exchange between tasks and ISRs without corrupting shared memory.

• Message Queues: FIFO buffers that pass data by value, decoupling task execution rates.
• Semaphores: Binary or counting tokens used for task synchronization and guarding shared resources (mutexes).
• Event Flags: A bitmask-based mechanism allowing a task to pend on a combination of multiple synchronization events simultaneously.

RTOS memory allocation strategies avoid the non-deterministic behavior of general-purpose heap allocators.

• Static Allocation: All task stacks and resources are allocated at compile time, guaranteeing no runtime fragmentation.
• Memory Pools: Fixed-size block allocators that provide O(1) constant-time allocation and deallocation, preventing heap fragmentation.
• MMU/MPU Protection: A Memory Protection Unit isolates task memory spaces, preventing a faulty signal processing task from corrupting kernel data.

Specialized operating systems used in embedded signal processing and edge AI deployments.

• FreeRTOS: A widely used, open-source kernel with minimal footprint, often integrated with AWS IoT services.
• Zephyr: A scalable, open-source RTOS with a focus on connectivity and security, supported by the Linux Foundation.
• VxWorks: A proprietary, high-reliability RTOS used in aerospace, defense, and industrial control systems requiring safety certifications.
• QNX Neutrino: A commercial microkernel RTOS known for its fault tolerance and use in automotive and medical devices.