In this CLASS:

 What is Kernel?

 What is Real Time Kernel?

 Over view of Real Time Kernel

 Principles of Real Time Kernel design

 Design issues of Real Time Kernel

 WHAT IS KERNEL?

 Kernel is part of operating system

 Kernel is lower layer of OS

 Kernel is an interface between system’s hardware and

software

 Kernel loads first in memory after OS has been loaded and

remains in memory until OS is shutdown

 Functions of Kernel are:

• Device management
• Memory management
• Task management
 WHAT IS REAL TIME KERNEL?

A real-time system responds to events within a specified deadline. If

the timing constraints of the system are unmet, failure has occurred. In the
kernel context, real-time denotes a deterministic response to an external
event, aiming to minimize the response time guarantee.
Over view of Real Time Kernel:

 A real-time kernel is a fundamental component of a real-time operating system (RTOS).

An RTOS is designed to handle real-time applications that require precise timing and
predictability in their operations. A real-time kernel is responsible for managing the
execution of tasks and providing the necessary services to support real-time requirements.

 In an RTOS, the kernel is the core component that controls the scheduling and execution
of tasks. It provides mechanisms for task creation, prioritization, scheduling,
synchronization, and communication. The real-time kernel ensures that tasks with higher
priority are executed before lower-priority tasks and that tasks meet their deadlines.

 Real-time kernels are typically designed to be compact, efficient, and fast, as they must
respond quickly to time-critical events. They are often implemented as a set of software
components that can be configured and customized according to the specific requirements
of the real-time application.

 Overall, the real-time kernel plays a crucial role in an RTOS by providing the necessary
infrastructure for managing real-time tasks and ensuring that the system meets its timing
constraints.
Principles of Real Time Kernel Design:
 Determinism:
Real-time kernels aim to provide deterministic behavior, meaning that the system's response to
events is consistent and predictable. To achieve determinism, the kernel should have well-defined and
bounded latencies for task scheduling, interrupt handling, and other critical operations.

 Task Scheduling:
The kernel should implement an efficient task scheduling algorithm that assigns priorities to tasks
and schedules their execution based on those priorities. Common scheduling algorithms used in real-
time kernels include rate-monotonic scheduling (RMS) and earliest deadline first (EDF) scheduling.

 Priority Inversion Prevention:

Priority inversion occurs when a lower-priority task holds a resource required by a higher-priority
task, leading to a priority inversion and potential missed deadlines. Real-time kernels employ
techniques such as priority inheritance or priority ceiling protocols to mitigate priority inversion and
ensure higher-priority tasks are not blocked by lower-priority tasks.

 Minimal Overhead:
Real-time kernels should have low overhead in terms of memory footprint, context switching
time, and system call execution time. Minimizing overhead allows the system to respond quickly to
events and maximize its real-time performance.
Principles of Real Time Kernel Design: (contd..)
 Interrupt Handling:
Real-time kernels need to handle interrupts in a timely and efficient manner. Interrupt
latency, the time taken from the occurrence of an interrupt to the execution of its associated
interrupt service routine (ISR), should be minimized to ensure timely response to time-critical
events.

 Synchronization and Communication:

Real-time systems often require tasks to synchronize their actions or exchange data. The
kernel should provide mechanisms for inter-task communication, such as semaphores, mutexes,
message queues, and event flags, to facilitate coordination among tasks while maintaining
determinism.

 Configurability and Customization:

Real-time kernels should be configurable to adapt to different application requirements.
They should provide options for adjusting parameters like scheduling policies, interrupt
priorities, and resource management to optimize the system's behavior for specific real-time
applications.
Design Issues -Real Time Kernel Design:

 Scheduling Policy:
Choosing an appropriate scheduling policy is crucial for real-time systems. Different
scheduling policies, such as fixed-priority, dynamic-priority, or hybrid approaches, have different
trade-offs in terms of simplicity, predictability, and responsiveness. The design of the kernel
should support the desired scheduling policy and provide mechanisms for task prioritization and
scheduling.
 Task Management:
The kernel needs to manage tasks efficiently, including task creation, deletion, and context
switching. Task management involves allocating and deallocating resources, maintaining task
states, and ensuring the proper execution order based on priorities. Careful design is required to
minimize the overhead associated with task management operations.
 Interrupt Handling:
Interrupts play a crucial role in real-time systems, as they allow the system to respond to
external events in a timely manner. The kernel must handle interrupts efficiently, minimizing
interrupt latency and ensuring that critical interrupts are serviced promptly. Proper interrupt
management, including prioritization and interrupt nesting, is essential for meeting real-time
requirements.
Design Issues -Real Time Kernel Design:(contd..)

 Synchronization and Communication:

Real-time systems often require synchronization and communication between tasks. The kernel
needs to provide mechanisms for inter-task synchronization (e.g., semaphores, mutexes) and
communication (e.g., message queues, shared memory) while maintaining determinism and avoiding
deadlocks or priority inversions.

 Resource Management:
Real-time systems often have limited resources, such as CPU time, memory, and I/O devices.
The kernel should manage these resources effectively, allocating them based on task priorities and
requirements. Resource management mechanisms, such as resource reservation, priority inheritance,
or priority ceiling protocols, need to be carefully designed and implemented.

 Timing and Timers:

Real-time systems rely on accurate and precise timing. The kernel must provide mechanisms for
measuring time, setting timers, and generating periodic or one-shot events. It should support high-
resolution timers, handle timer rollover and drift, and ensure that timing constraints are met.
Design Issues -Real Time Kernel Design:(contd..)

 Error Handling and Fault Tolerance:

Real-time systems often operate in critical environments, where errors or faults can have
severe consequences. The kernel design should include error handling mechanisms, such as
exception handling, error recovery, and fault tolerance techniques, to ensure system reliability
and resilience.

 Scalability:
Real-time systems can vary widely in terms of complexity and scale. The kernel design
should be scalable to handle different system sizes, from small embedded systems to large
distributed real-time applications. It should efficiently utilize system resources while
maintaining real-time guarantees.

 Portability:
Real-time kernels are often used across different hardware platforms and architectures.
The kernel design should be portable, allowing easy adaptation and implementation on various
target systems. This requires careful consideration of hardware dependencies and providing
abstraction layers to isolate the kernel from platform-specific details.
NEXT CLASS:

 Pooled Loop System

 RTOS porting to a target