RTOS

Vocabulary flashcards summarizing essential terms and definitions from the RTOS Concepts for Embedded Systems lecture.

Real-Time System

A system that produces a deterministic response to an external event within specified timing constraints.

Determinism

Property of a system whose behavior is predictable and repeatable for a given input.

Timing Constraint

A deadline by which a real-time task must start or finish to maintain system correctness.

Predictability

Ability to guarantee that timing requirements will always be met over the system’s lifetime.

Hard Real-Time System

A system in which missing a deadline constitutes total system failure.

Soft Real-Time System

A system that aims to meet deadlines but can tolerate occasional deadline misses.

Firm Real-Time System

System that must meet deadlines almost all the time; rare misses degrade quality but may not cause failure.

RTOS (Real-Time Operating System)

An operating system designed to guarantee deterministic task scheduling and interrupt handling.

GPOS (General-Purpose Operating System)

An OS optimized for throughput and user tasks rather than strict timing guarantees.

Super Loop

Bare-metal main loop structure that sequentially polls peripherals without preemption.

Preemptive Scheduling

A scheduling method that allows a higher-priority task to interrupt and replace a running task.

Non-Preemptive Scheduling

Scheduling in which a running task cannot be interrupted until it voluntarily yields or finishes.

Cooperative Scheduling

A non-preemptive model where tasks yield control explicitly, often via taskYield() calls.

Task (Thread)

Basic unit of execution managed by an RTOS, with its own stack, context, and priority.

Task Priority

Numerical value indicating a task’s importance; higher priority tasks preempt lower ones.

Task Control Block (TCB)

Data structure that stores a task’s context, state, priority, and stack pointers.

Dormant State

Initial or terminated state in which a task is not yet part of the scheduler’s ready pool.

Ready State

State where a task is prepared to run and waiting for CPU availability.

Running State

The state of the task that currently owns the CPU on a single core.

Blocked / Waiting State

State where a task is paused until an event such as semaphore give, message arrival, or time delay occurs.

Suspended State

State in which a task is removed from scheduling until explicitly resumed.

Context Switch

Process of saving the current task context and restoring another task’s context.

PendSV

Lowest-priority Cortex-M exception used by FreeRTOS to perform context switches safely after ISRs.

MSP (Main Stack Pointer)

Stack pointer used for system/interrupt context on ARM Cortex-M devices.

PSP (Process Stack Pointer)

Stack pointer used for task-level code in Cortex-M RTOS implementations.

ISR (Interrupt Service Routine)

Callback routine executed in response to a hardware interrupt.

Interrupt Latency

Time from interrupt assertion to execution of the first instruction of its ISR.

Jitter

Variation in interrupt latency (or task response time) over multiple occurrences.

Deferred Interrupt Handling

Technique where an ISR unblocks a task so heavy processing occurs at task level instead of inside ISR.

Foreground / Background System

Architecture where ISRs handle urgent work (foreground) and tasks process data later (background).

Task-Level Response

Delay experienced from interrupt completion to task processing of the associated data.

Kernel

Core component of an RTOS providing scheduling, synchronization, timing, and memory services.

Scheduler

Kernel module that decides which task runs next based on priorities and states.

Schedulable Entity

Object (task or process) eligible for CPU time under the scheduler.

Semaphore

Kernel object used to signal and synchronize access to shared resources via a counter.

Binary Semaphore

Semaphore with count 0 or 1, often used as a simple event signal.

Counting Semaphore

Semaphore whose count can exceed 1, allowing multiple simultaneous resource accesses.

Mutex

Mutual-exclusion lock that grants exclusive access to a critical section and supports ownership.

Priority Inheritance

Protocol that temporarily raises a low-priority task’s priority when it holds a mutex needed by a higher-priority task.

Priority Inversion

Situation where a high-priority task is blocked by a lower-priority task holding a required resource.

Critical Section

Code region that must not be interrupted to prevent data corruption; often protected by disabling interrupts or using mutexes.

Reentrant Function

Function that can be safely interrupted and re-entered by concurrent execution without corrupting data.

Queue

FIFO kernel object enabling safe data transfer between tasks or ISRs and tasks.

Message Queue

Queue variant designed to pass fixed-size messages between tasks.

Mailbox

Message queue with length one, allowing single-message overwriting behavior.

Pipe

Kernel object enabling unstructured byte-stream exchange and synchronization among tasks.

Direct Task Notification

Lightweight RTOS feature that lets one task or ISR send a 32-bit value or signal directly to another task without a separate object.

Software Timer

Timer implemented by the RTOS that invokes a callback after a specified period using a shared timer task.

System Tick

Periodic interrupt that drives the RTOS time base and task delays; often 1 ms in FreeRTOS.

Heap_1

FreeRTOS heap scheme that supports allocation only—no freeing—for maximum determinism.

Heap_2

Heap scheme allowing malloc and free but without coalescing adjacent free blocks.

Heap_3

Wrapper around the C library’s malloc/free to provide thread-safe allocation.

Heap_4

FreeRTOS heap that supports allocation, free, and block coalescing for flexible dynamic memory use.

Heap_5

Heap implementation enabling a single logical heap spread across multiple non-contiguous memory regions.

Memory Management

RTOS services that allocate, free, and track RAM for stacks, queues, and other kernel objects.

Task Partitioning

Dividing application work into separate tasks that can be scheduled independently.

Time Slice (Tick)

Fixed scheduler interval after which tasks of equal priority are rotated in round-robin fashion.

Deadline

Latest time by which a real-time task must complete its execution.

Periodicity

Time interval between successive activations of a periodic task.

Computation Time (Ci)

Worst-case processor time required for a task to execute to completion.

Processor Utilization Factor (U)

Sum of Ci/Ti for all tasks, representing fraction of CPU time demanded.

Schedulability Analysis

Process of verifying that all tasks can meet deadlines under a given scheduling algorithm.

Worst-Case Execution Time (WCET)

Maximum time a task can take to execute on a specific hardware platform.

Static Scheduling

Scheduling based on a precomputed, repeating timetable created offline.

Dynamic Scheduling

Scheduling where priorities and execution order are decided at runtime.

Fixed Priority

Priority assignment that remains constant throughout task execution (e.g., Rate Monotonic).

Dynamic Priority

Priority that can change during runtime based on rules like earliest deadline (EDF).

Rate Monotonic Scheduling (RMS)

Fixed-priority algorithm where tasks with shorter periods get higher priorities.

Earliest Deadline First (EDF)

Dynamic-priority algorithm that always selects the task with the nearest absolute deadline.

Deadline Monotonic Scheduling (DMS)

Fixed-priority algorithm assigning higher priority to tasks with shorter relative deadlines.

Liu-Layland Bound

Utilization threshold (m·(2^{1/m}−1)) below which a task set is guaranteed schedulable under RMS.

Slack Time

Unused processor time that can be allocated to lower-priority tasks without jeopardizing deadlines.

Fault Tolerance

Capability of a system to continue correct operation despite hardware or software faults.

ISO 26262

Automotive functional-safety standard guiding fault tolerance and hazard mitigation in real-time systems.

Segger SystemView

Real-time tracing tool that provides RTOS-aware insights into task execution and timing behavior.

Interrupt Storm

Condition where a large number of interrupts occur in rapid succession, potentially increasing latency and causing hangs.

Utility Function (Hard RTS)

Binary measure (1 for deadline met, 0 for deadline missed) representing task success in hard real-time systems.

Lateness

Difference between completion time and deadline of a task (positive if late).

Tardiness

Max(0, Lateness); positive lateness value, zero if deadline met.

Earliness

Max(−Lateness, 0); amount by which a task finishes before its deadline.