Real-Time Linux as an RTOS: the preempt_rt patch

Explore the Linux kernel as the core translator between hardware and applications, covering process and memory management, device drivers, system calls, file systems, and networking.

Explore what a process is and how the Linux scheduler uses preemptive multitasking to manage processes, states, and priorities, including CFS and real-time policies, with top, nice, and renice.

Master virtual memory concepts, including the virtual address space, process isolation, memory protection, and efficiency via paging, page faults, and swapping, plus the kernel's buddy and slab allocators.

Understand hardware interrupts and software traps, and how system calls let user apps request kernel services; PREEMPT_RT reduces latency by preempting interrupt handlers and syscalls.

Learn how determinism in operating systems yields predictable timing, bounded latency, and repeatable results, and identify nondeterminism sources such as scheduling, memory management, I/O, and interrupts.

Discover how the fifo real-time scheduling policy delivers deterministic task execution with fixed priorities, no time slicing, and preemption by higher-priority tasks, used in critical control systems.

Write a real-time Linux C++ task that sets its priority with SCHED_FIFO using pthread_setschedparam, yields with sched_yield, and loops to simulate processing and monitoring.

The lecture covers the real-time round robin scheduling policy (SCHED_RR) with time slicing and a two-millisecond quantum to fairly share CPU among same-priority tasks, including preemption.

Set the scheduling policy to SCHED_RR in a C++ application, print the system time slice (system-wide quantum, typically 100 ms), and verify the policy is round robin.

Explore the deadline scheduler, driven by dynamic priorities and earliest deadline first, using runtime, deadline, and period to guarantee deadlines under 100% CPU demand for hard real-time workloads.

Learn to implement a c++ application that sets a task to the SCHED_DEADLINE policy via a Linux syscall, defining runtime, deadline, and period in nanoseconds.

Apply best practices for real time scheduling policies, using fifo for high-priority tasks, round robin for equal priorities, and deadline scheduling with schedulability tests.

Explore Linux real-time limits by querying the kernel schedulers, including CFS, FIFO, RR, and the Deadline scheduler, and verify a 95% RT runtime against a 1 second period.

Explore how the PREEMPT_RT patch turns Linux into a real-time OS, integrated into mainline as of Linux 6.6, with full preemption, threaded interrupts, preemptible spinlocks, and priority inheritance.

Choose the right kernel version for the preempt patch to balance stability, latency, and hardware support, favoring long-term support kernels for industrial real-time deployments as mainline real-time features merge.

Install build dependencies, download and patch the kernel, configure for a fully preemptible preempt-rt kernel, build and install it, then verify with bootloader updates and latency tests.

Configure real-time linux boot parameters to optimize interrupt routing, cpu isolation, and timing at the kernel level, using thread irqs, iso CPUs, nohz_full, and rtk affinity.

Learn to create a real-time thread with pthread on a real-time Linux system by configuring fifo scheduling, setting explicit priority to 80, initializing thread attributes, and managing creation and execution.

learn to implement high-resolution timers in real-time linux by replacing sleep with nano sleep on the monotonic clock, using a 1 millisecond interval, and handling nanosecond overflow for periodic timing.

Understand how priority inheritance solves priority inversion in real-time Linux by boosting the low-priority mutex holder, and implement it in a C++ pthread example.

Learn to measure real-time latency with cyclictest, including wakeup latency, jitter, and worst-case latency, by installing rt tests, running multi-threaded tests, setting CPU affinity, and simulating stress.

Explore real-time Linux tracing with Ftrace and the trace command, capturing scheduler switches, wakeups, and latency sources. Record events and use function graph tracing for RT applications.

Review real-time linux fundamentals: processes, scheduling priorities, memory management, interrupts, and syscalls; explore rt scheduling policies and the preemptive patch for real-time c++ apps with pthreads.