Real Time Systems

Definition

A real-time operating system (RTOS) is an operating system designed to process data as it comes in with minimum delay. The critical characteristic is that the system must guarantee that processing is completed within specified time constraints called deadlines. The system must respond to external events and complete tasks within strict timing requirements.

Basic Concept

In a real-time system:

  • Timing is critical - Must complete tasks by deadline
  • Deterministic behavior - Predictable execution time
  • High reliability - Must work correctly
  • Fast response - Quick reaction to events
  • Minimal latency - Very small delay
  • Priority-based - Important tasks run first

Types of Real-Time Systems

1. Hard Real-Time Systems

Definition: Missing a deadline is complete system failure - catastrophic consequences.

Characteristics:

  • Strict time constraints
  • Cannot tolerate any deadline misses
  • Guaranteed response time required
  • Safety-critical

Examples:

  • Cardiac Pacemakers: Must deliver electrical pulse at exact time
  • Aircraft Control Systems: Must respond to controls instantly
  • Nuclear Plant Control: Safety of thousands depends on timing
  • Missile Guidance Systems: Must guide missile precisely
  • Anti-lock Brake Systems (ABS): Must prevent skidding immediately

Requirements:

  • Formal verification (mathematical proof it works)
  • Extensive testing
  • Redundant systems for safety
  • No compromise on timing

Real Example - Pacemaker:

  • Must deliver electrical pulse every 1 second (for heart rate 60 BPM)
  • Missing one pulse could be fatal
  • Earliest is 0.9 seconds (too fast)
  • Latest is 1.1 seconds (too slow)
  • Window: exactly 0.1 seconds tolerance

2. Firm Real-Time Systems

Definition: Occasional missed deadlines are acceptable but undesirable. Task has no value after deadline passes.

Characteristics:

  • Firm time constraints
  • Few missed deadlines tolerable
  • Value drops to zero after deadline
  • Not safety-critical but performance-critical

Examples:

  • Video Streaming: Frame must arrive in time to play, late frame useless
  • Live Video Conference: Delayed video makes conversation difficult
  • Online Games: Late position update is useless
  • Multimedia Presentation: Frame synchronization critical
  • Air Traffic Control Displays: Real-time information needed

Real Example - Video Streaming:

  • Frame must arrive every 33 milliseconds (for 30 fps)
  • If frame arrives late, skip it, not displayed
  • Value of late frame is zero
  • Some missed frames OK, but not too many

3. Soft Real-Time Systems

Definition: Occasional deadline misses are acceptable. Task has reduced value after deadline.

Characteristics:

  • Flexible time constraints
  • Performance degrades gracefully with deadline misses
  • Not critical to functionality
  • Late result still has some value

Examples:

  • Online Games: Late update makes game less responsive but still playable
  • Virtual Reality Systems: Slight latency causes discomfort but not catastrophe
  • Telephone Systems: Slight delay in voice is annoying but tolerable
  • Weather Forecasting: Slightly old data still useful
  • Database Queries: Faster is better but delay tolerable

Real Example - Phone Call:

  • Voice delay up to 150ms is tolerable
  • Delay of 300ms is annoying
  • Delay of 1000ms makes conversation impossible
  • Performance degrades gradually

Key Performance Metrics

Latency (Response Time)

Time from event occurring to system responding.

Example - ABS System:

  • Wheel slip detected (event)
  • ABS must release brake in < 10 milliseconds (deadline)
  • Latency must be < 10ms

Formula: Latency = Time to respond - Time of event

Jitter

Variation in response time. Should be minimal in RTOS.

Good RTOS: Latency always 10±0.1 milliseconds (small jitter) Bad RTOS: Latency varies 10-50 milliseconds (large jitter)

Deadline Miss Ratio

Percentage of deadlines missed.

Hard RTOS: Must be 0% (zero tolerance) Soft RTOS: Can be < 5% (some tolerance)

Components of Real-Time Operating System

1. Task/Process Management

  • Create and manage real-time tasks
  • Assign priorities to tasks
  • Context switching between tasks
  • Task states and transitions

2. Real-Time Scheduler

Decides which task runs when to meet all deadlines.

Must ensure:

  • All deadlines are met
  • Highest priority tasks run first
  • CPU is fully utilized
  • No priority inversion

3. Timer and Clock

Precise timing measurement for:

  • Task deadlines
  • Event timing
  • Delay measurement
  • Interrupt generation

4. Interrupt Handler

Handles external events:

  • Hardware interrupts
  • Device interrupts
  • Software interrupts
  • Low interrupt latency required

5. Synchronization Mechanisms

  • Semaphores
  • Mutexes
  • Monitors
  • Message queues

Real-Time Scheduling Algorithms

1. Rate-Monotonic Scheduling (RMS)

How it works:

  • Assign priority inversely proportional to task period
  • Shorter period = higher priority
  • Preemptive scheduling

Example:

  • Task A: Period 50ms → High priority
  • Task B: Period 100ms → Lower priority
  • Task C: Period 200ms → Lowest priority

Utilization Formula: $$U \leq n(2^{1/n} - 1)$$

For 2 tasks: U ≤ 0.828 (82.8%) For 3 tasks: U ≤ 0.780 (78%)

Advantages:

  • Optimal for fixed priorities
  • Mathematically proven
  • Simple to implement

Disadvantages:

  • Not optimal for variable deadlines
  • Wastes CPU if deadlines different from periods

2. Earliest Deadline First (EDF)

How it works:

  • Always execute task with earliest deadline
  • Dynamic priority assignment
  • Preemptive scheduling

Example:

  • Task A: Deadline 20ms
  • Task B: Deadline 15ms
  • Task C: Deadline 30ms

Execute order: B (15ms deadline), then A (20ms), then C (30ms)

Utilization Bound: Can use up to 100% CPU

  • Much better than RMS
  • EDF is optimal for single processor

Disadvantages:

  • More complex implementation
  • Runtime overhead
  • Priority changes frequently

3. Priority-Based Scheduling

Static Priority: Assigned once, doesn’t change

  • Simple to implement
  • Predictable behavior
  • May be inefficient

Dynamic Priority: Changes during execution

  • More flexible
  • Better utilization
  • More complex

Priority Inversion Problem

What is it? Low-priority task prevents high-priority task from running.

Example:

High Priority Task: Waiting for resource
Medium Priority Task: Running
Low Priority Task: Holding resource needed by High Priority Task

Problem: High priority waits while Medium runs!
This is called priority inversion.

Solution 1: Priority Inheritance

  • Low priority task inherits high priority temporarily
  • When done, returns to low priority
  • High priority task can proceed

Solution 2: Priority Ceiling

  • Set maximum priority of resource
  • Any task using resource gets that priority
  • Prevents low priority tasks holding important resources

Design Challenges in RTOS

1. Worst-Case Execution Time (WCET)

Must determine how long each task takes in worst case:

  • Can’t be just average time
  • Must account for all loops, branches
  • Include all I/O delays
  • Add safety margin

Challenge: Difficult to calculate accurately

2. Timing Analysis

Must verify system meets all deadlines:

  • Calculate if schedule is feasible
  • Check all tasks meet deadlines
  • Verify under maximum load
  • Include jitter and overhead

Tools Used:

  • Schedulability analysis
  • Simulation
  • Testing under stress

3. Synchronization

Multiple tasks sharing resources:

  • Mutual exclusion (one at a time)
  • Priority inversion prevention
  • Deadlock prevention
  • Race condition avoidance

4. Memory Management

Memory is critical in RTOS:

  • Memory fragmentation reduces predictability
  • Virtual memory not suitable (too slow)
  • Fixed memory allocation preferred
  • Cache behavior unpredictable

5. Interrupt Handling

Interrupts must be handled deterministically:

  • Bounded interrupt latency
  • Fast context switching
  • Nested interrupt handling
  • Prevent disabling interrupts too long

Real-Time System Architecture

Typical structure:

External Events (Sensors, Timers)
        ↓
    Interrupt Handler
        ↓
    Real-Time Scheduler
        ↓
  Task Execution (CPU)
        ↓
Actuators (Motors, Valves)

Advantages of Real-Time Systems

  1. Predictability - Execution time is guaranteed
  2. Reliability - Works correctly every time
  3. Safety - Can be used in safety-critical systems
  4. Responsiveness - Quick reaction to events
  5. Control - Precise control over task execution
  6. Certification - Can be formally verified

Disadvantages of Real-Time Systems

  1. Complexity - Very complex to design
  2. Cost - Expensive development and verification
  3. Limited Functionality - Less features than general OS
  4. Performance Trade-off - Predictability costs performance
  5. Testing - Requires extensive testing
  6. Debugging - Difficult to debug timing issues
  7. Flexibility - Less flexible than general OS

Real-Time Operating System Examples

1. QNX Neutrino

  • Microkernel architecture
  • POSIX compatible
  • Used in automotive
  • Good determinism

2. VxWorks

  • Industry standard
  • Real-time kernel
  • Used in aerospace, defense, medical
  • Proven reliability

3. RTEMS

  • Real-Time Executive for Multiprocessor Systems
  • Open-source
  • POSIX compatible
  • Good for embedded systems

4. FreeRTOS

  • Free, open-source
  • Small footprint
  • Good for microcontrollers
  • Growing popularity

5. RT-Linux

  • Real-time extension for Linux
  • Hard real-time capabilities
  • Linux compatibility

6. INTEGRITY

  • High-security RTOS
  • Military and aerospace
  • Formally verified

Applications of Real-Time Systems

Industrial Control

  • Manufacturing automation
  • Robotics
  • Process control
  • Assembly lines

Aerospace and Defense

  • Aircraft avionics
  • Flight control systems
  • Missile guidance
  • Radar systems

Medical Devices

  • Pacemakers
  • Ventilators
  • Patient monitoring
  • Infusion pumps
  • Surgical robots

Automotive

  • Engine control
  • Transmission control
  • Anti-lock brakes (ABS)
  • Air bag deployment
  • Stability control

Telecommunications

  • Switching systems
  • Signal processing
  • Network routing
  • Call management

Home Automation

  • Smart thermostats
  • Security systems
  • Smart appliances

Important Concepts

Deadline

  • Time by which task must complete
  • Hard: Cannot be missed
  • Firm: Should not be missed
  • Soft: Preferably not missed

Period

  • Time interval between successive instances of periodic task
  • Task executes every period

Schedulability

  • Whether system can schedule all tasks to meet deadlines
  • Must be verified before deployment

Preemption

  • Ability to interrupt running task
  • Essential for high priority tasks
  • Necessary for deadline meeting

Task Switching

  • Changing from one task to another
  • Must be fast in RTOS
  • Overhead should be minimal

Exam Important Points

  1. Define real-time system
  2. Three types (hard, firm, soft) with examples
  3. Key metrics (latency, jitter, deadline miss ratio)
  4. Components of RTOS
  5. Rate-Monotonic Scheduling
  6. Earliest Deadline First
  7. Priority inversion problem and solution
  8. Advantages and disadvantages
  9. Real RTOS examples
  10. Applications