Preemptive scheduling behavior in FreeRTOS - Deep Dive

Overview - Preemptive scheduling behavior

What is it?

Preemptive scheduling is a way an operating system decides which task to run by interrupting the current task to run a higher priority one. In FreeRTOS, this means the system can switch tasks automatically when a more important task needs the CPU. This helps keep the system responsive and efficient by always running the most urgent work first. It works by the scheduler checking task priorities and switching tasks without waiting for the current one to finish.

Why it matters

Without preemptive scheduling, tasks would have to finish on their own before others run, which can cause delays and make the system slow or unresponsive. Preemptive scheduling ensures critical tasks get immediate attention, improving real-time performance. This is important in devices like medical monitors or robots where delays can cause failures or safety issues. It helps systems handle many tasks smoothly and predictably.

Where it fits

Before learning preemptive scheduling, you should understand basic multitasking and what a task or thread is. After this, you can learn about task priorities, context switching, and synchronization methods like semaphores. Later, you might explore advanced scheduling policies and real-time operating system design.

Mental Model

Core Idea

Preemptive scheduling lets the system pause a running task anytime to run a more important one, ensuring urgent work is done first.

Think of it like...

Imagine a busy kitchen where the head chef can stop a cook preparing a side dish to immediately start cooking the main course if it’s more important. The cook must pause and let the chef handle the urgent meal first.

┌───────────────┐
│ Running Task 1│
└──────┬────────┘
       │ Higher priority task arrives
       ▼
┌───────────────┐
│ Preempt Task 2│
└──────┬────────┘
       │ Task 2 finishes or blocks
       ▼
┌───────────────┐
│ Resume Task 1 │
└───────────────┘

Build-Up - 7 Steps

1

Foundation

Understanding Tasks and Priorities

Concept: Learn what tasks are and how priorities rank their importance.

In FreeRTOS, a task is a small program that runs independently. Each task has a priority number; higher numbers mean more important tasks. The scheduler uses these priorities to decide which task should run.

Result

You know tasks are like workers with different importance levels.

Understanding tasks and priorities is the base for knowing how the system decides who works first.

2

Foundation

What is Scheduling in FreeRTOS?

Concept: Scheduling means choosing which task runs on the CPU at any time.

FreeRTOS scheduler manages tasks by switching between them. It can run one task at a time and switches tasks to share CPU time. Scheduling can be cooperative or preemptive.

Result

You see scheduling as a manager assigning CPU time to tasks.

Knowing scheduling basics helps you grasp how tasks share the CPU and why switching is needed.

3

Intermediate

How Preemptive Scheduling Works

🤔Before reading on: do you think the current task must finish before switching to a higher priority task? Commit to your answer.

Concept: Preemptive scheduling interrupts the current task immediately if a higher priority task is ready.

In FreeRTOS, when a higher priority task becomes ready, the scheduler stops the current task and switches to the higher priority one. This happens automatically using interrupts and context switching.

Result

The system always runs the most important ready task without delay.

Understanding immediate task switching explains how FreeRTOS keeps critical tasks responsive.

4

Intermediate

Context Switching Explained

Concept: Context switching saves and restores task states to switch between tasks smoothly.

When FreeRTOS switches tasks, it saves the current task's CPU registers and stack info, then loads the next task's saved state. This lets tasks pause and resume as if they never stopped.

Result

Tasks can run seemingly at the same time by switching quickly.

Knowing context switching mechanics clarifies how multitasking feels seamless.

5

Intermediate

Role of the Tick Interrupt

Concept: A timer interrupt triggers the scheduler regularly to check if a task switch is needed.

FreeRTOS uses a hardware timer called the tick. Every tick, an interrupt occurs, and the scheduler runs to see if a higher priority task is ready. If yes, it preempts the current task.

Result

The system checks for task changes often and stays responsive.

Understanding the tick interrupt shows how the scheduler stays active and timely.

6

Advanced

Handling Equal Priority Tasks

🤔Before reading on: do you think FreeRTOS runs equal priority tasks in a fixed order or switches between them? Commit to your answer.

Concept: FreeRTOS uses time slicing to share CPU fairly among tasks with the same priority.

When multiple tasks have the same priority, FreeRTOS switches between them on each tick interrupt, giving each a slice of CPU time. This prevents one task from blocking others of equal importance.

Result

Equal priority tasks get fair CPU time in turns.

Knowing time slicing prevents confusion about how tasks of the same priority share CPU.

7

Expert

Preemption and Critical Sections

🤔Before reading on: do you think preemption can happen inside critical sections? Commit to your answer.

Concept: Critical sections temporarily disable preemption to protect shared resources.

In FreeRTOS, critical sections disable interrupts to prevent task switches during sensitive code. This avoids data corruption but can delay higher priority tasks briefly.

Result

Preemption is controlled to balance safety and responsiveness.

Understanding critical sections reveals the tradeoff between data safety and real-time responsiveness.

Under the Hood

FreeRTOS uses a hardware timer to generate periodic tick interrupts. On each tick, the scheduler runs to check task states and priorities. If a higher priority task is ready, the scheduler triggers a context switch by saving the current task's CPU registers and stack pointer, then loading the new task's saved state. This switch happens in assembly code to ensure speed and correctness. Interrupts are managed carefully to avoid corruption during switching.

Why designed this way?

Preemptive scheduling was designed to meet real-time requirements where urgent tasks must run immediately. Using hardware timer interrupts ensures timely checks without wasting CPU cycles. Context switching at the assembly level minimizes overhead. Alternatives like cooperative scheduling rely on tasks to yield, which can cause delays and unpredictability, unsuitable for critical embedded systems.

┌───────────────┐
│ Hardware Tick │
│ Interrupt     │
└──────┬────────┘
       │ Triggers
       ▼
┌───────────────┐
│ Scheduler     │
│ Checks Tasks  │
└──────┬────────┘
       │ If higher priority task ready
       ▼
┌───────────────┐
│ Context Switch│
│ Save Current  │
│ Load New Task │
└──────┬────────┘
       │
       ▼
┌───────────────┐
│ New Task Runs │
└───────────────┘

Myth Busters - 4 Common Misconceptions

Quick: Does preemptive scheduling mean tasks can be interrupted anytime, even during critical code? Commit yes or no.

Common Belief: Preemptive scheduling interrupts tasks at any moment, even inside critical sections.

Reality: FreeRTOS disables interrupts during critical sections to prevent preemption and protect shared data.

Why it matters: Believing tasks can be interrupted anytime leads to unsafe code assumptions and bugs like data corruption.

Quick: Do you think FreeRTOS runs all tasks simultaneously on multiple CPUs by default? Commit yes or no.

Common Belief: FreeRTOS runs multiple tasks at the same time on multiple processors automatically.

Reality: FreeRTOS runs one task at a time on a single CPU core; it switches tasks rapidly to simulate multitasking.

Why it matters: Assuming true parallelism can cause design errors in synchronization and timing.

Quick: Is it true that higher priority tasks always run immediately, no matter what? Commit yes or no.

Common Belief: Higher priority tasks always preempt lower ones instantly without delay.

Reality: Preemption can be delayed if interrupts are disabled or the system is in a critical section.

Why it matters: Ignoring this can cause missed deadlines or unexpected latency in real-time systems.

Quick: Do you think tasks with the same priority run in the order they were created? Commit yes or no.

Common Belief: Tasks with equal priority run in creation order, one finishing before the next starts.

Reality: FreeRTOS time-slices equal priority tasks, switching between them each tick to share CPU fairly.

Why it matters: Misunderstanding this leads to wrong assumptions about task execution order and timing.

Expert Zone

1

Preemptive scheduling overhead depends on context switch frequency; minimizing unnecessary switches improves performance.

2

Disabling interrupts too long in critical sections can starve higher priority tasks, causing priority inversion issues.

3

Nested interrupts and interrupt priorities interact with preemption, requiring careful design to avoid missed deadlines.

When NOT to use

Preemptive scheduling is not ideal for very simple or cooperative systems where tasks can yield voluntarily. In such cases, cooperative scheduling or event-driven designs reduce complexity and overhead.

Production Patterns

In real embedded systems, preemptive scheduling is combined with priority inheritance to handle resource sharing safely. Developers use careful priority assignment and critical section management to balance responsiveness and data integrity.

Connections

Interrupt Handling

Preemptive scheduling relies on interrupts to trigger task switches.

Understanding interrupts helps grasp how the scheduler gains control to switch tasks immediately.

Priority Inversion Problem

Preemptive scheduling can cause priority inversion if not managed with protocols like priority inheritance.

Knowing this problem helps design systems that avoid delays caused by lower priority tasks blocking higher ones.

Traffic Control Systems

Both use priority rules to decide which flow proceeds first to avoid congestion.

Seeing scheduling like traffic lights clarifies how priorities manage resource access fairly and efficiently.

Common Pitfalls

#1 Assuming tasks cannot be interrupted during critical sections.

Wrong approach:

void critical_section() {
// No interrupt disable
shared_data++;
// Assume no preemption here
}

Correct approach:

void critical_section() {
taskENTER_CRITICAL();
shared_data++;
taskEXIT_CRITICAL();
}

Root cause:

Misunderstanding that critical sections disable interrupts to prevent preemption and protect shared data.

#2 Setting all tasks to the same priority expecting sequential execution.

Wrong approach:

xTaskCreate(task1, "Task1", 1000, NULL, 1, NULL);
xTaskCreate(task2, "Task2", 1000, NULL, 1, NULL);

Correct approach:

xTaskCreate(task1, "Task1", 1000, NULL, 2, NULL);
xTaskCreate(task2, "Task2", 1000, NULL, 1, NULL);

Root cause:

Not realizing that equal priority tasks time-slice and do not run strictly one after another.

#3 Disabling interrupts for too long causing missed deadlines.

Wrong approach:

taskENTER_CRITICAL();
// Long processing here
process_data();
taskEXIT_CRITICAL();

Correct approach:

taskENTER_CRITICAL();
// Minimal critical code
update_shared_data();
taskEXIT_CRITICAL();
// Long processing outside critical section
process_data();

Root cause:

Not understanding that long critical sections block preemption and delay higher priority tasks.

Key Takeaways

Preemptive scheduling lets FreeRTOS run the highest priority ready task immediately by interrupting lower priority ones.

Context switching saves and restores task states so tasks can pause and resume seamlessly.

The tick interrupt triggers the scheduler regularly to keep the system responsive and fair.

Critical sections disable interrupts briefly to protect shared data but can delay urgent tasks.

Understanding preemptive scheduling is key to designing responsive and reliable real-time embedded systems.