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.

Practice

1. What happens in FreeRTOS when a higher priority task becomes ready while a lower priority task is running under preemptive scheduling?

easy

A. The scheduler ignores the higher priority task until the lower priority task yields.

B. The lower priority task continues running until it finishes.

C. Both tasks run at the same time.

D. The higher priority task immediately preempts the lower priority task and starts running.

Solution

1. Step 1: Understand preemptive scheduling behavior

   In preemptive scheduling, the system always runs the highest priority task that is ready.

2. Step 2: Apply to the scenario

   When a higher priority task becomes ready, it interrupts the lower priority task immediately.

3. Final Answer:

   The higher priority task immediately preempts the lower priority task and starts running. -> Option D

4. Quick Check:

   Preemptive scheduling = immediate switch to higher priority task [OK]

Hint: Higher priority tasks always interrupt lower ones immediately [OK]

Common Mistakes:

• Thinking tasks run simultaneously on a single core
• Believing lower priority tasks finish before switching
• Confusing preemptive with cooperative scheduling

2. Which of the following is the correct way to enable preemptive scheduling in FreeRTOS configuration?

easy

A. #define configUSE_PREEMPTION 1

B. #define configENABLE_PREEMPTION true

C. #define configPREEMPTIVE_SCHEDULING 1

D. #define configUSE_PREEMPTION 0

Solution

1. Step 1: Recall FreeRTOS config option for preemption

   The correct macro to enable preemption is configUSE_PREEMPTION.

2. Step 2: Identify correct value to enable preemption

   Setting configUSE_PREEMPTION to 1 enables preemptive scheduling.

3. Final Answer:

   #define configUSE_PREEMPTION 1 -> Option A

4. Quick Check:

   configUSE_PREEMPTION = 1 enables preemption [OK]

Hint: Enable preemption by setting configUSE_PREEMPTION to 1 [OK]

Common Mistakes:

• Using 0 instead of 1 to enable preemption
• Using wrong macro names
• Using boolean true instead of 1

3. Consider two tasks in FreeRTOS: TaskA with priority 2 and TaskB with priority 3. TaskA is running when TaskB becomes ready. What will be the output if both tasks print their names when running?

medium

A. TaskA prints first, then TaskB prints after TaskA finishes.

B. TaskB prints immediately, preempting TaskA.

C. Both tasks print simultaneously.

D. No output because tasks block each other.

Solution

1. Step 1: Identify task priorities and running state

   TaskA has priority 2 and is running; TaskB has higher priority 3 and becomes ready.

2. Step 2: Apply preemptive scheduling rules

   TaskB will preempt TaskA immediately and run first, printing its name.

3. Final Answer:

   TaskB prints immediately, preempting TaskA. -> Option B

4. Quick Check:

   Higher priority task runs first = TaskB prints first [OK]

Hint: Higher priority task prints first by preempting lower priority [OK]

Common Mistakes:

• Assuming lower priority task finishes before switching
• Thinking tasks run at the same time
• Ignoring task priorities

4. Given this FreeRTOS snippet, what is the error that prevents preemptive scheduling from working?

#define configUSE_PREEMPTION 0

void Task1(void *pvParameters) {
  while(1) {
    // Task code
  }
}

void Task2(void *pvParameters) {
  while(1) {
    // Task code
  }
}

medium

A. configUSE_PREEMPTION is set to 0, disabling preemption.

B. Tasks are missing priority assignments.

C. Task functions must return int, not void.

D. Tasks need to call vTaskDelay to allow switching.

Solution

1. Step 1: Check configUSE_PREEMPTION value

   The macro is set to 0, which disables preemptive scheduling.

2. Step 2: Understand effect on scheduling

   With preemption disabled, tasks will not be interrupted automatically by higher priority tasks.

3. Final Answer:

   configUSE_PREEMPTION is set to 0, disabling preemption. -> Option A

4. Quick Check:

   configUSE_PREEMPTION = 0 disables preemption [OK]

Hint: Preemption disabled if configUSE_PREEMPTION = 0 [OK]

Common Mistakes:

• Thinking tasks must return int
• Assuming missing priorities cause preemption failure
• Believing vTaskDelay is required for preemption

5. You have three tasks: TaskX (priority 2), TaskY (priority 3), and TaskZ (priority 3). TaskX is running, then both TaskY and TaskZ become ready at the same time. Which task will FreeRTOS run first under preemptive scheduling, and why?

hard

A. TaskY runs first because it was created before TaskZ.

B. TaskZ runs first because it has the same priority as TaskY but higher than TaskX.

C. Either TaskY or TaskZ runs first; FreeRTOS uses time slicing between equal priorities.

D. TaskX continues running until it yields.

Solution

1. Step 1: Identify task priorities and ready state

   TaskX priority 2 is running; TaskY and TaskZ both have priority 3 and become ready simultaneously.

2. Step 2: Understand FreeRTOS behavior with equal priority tasks

   FreeRTOS uses time slicing (round-robin) between tasks of equal highest priority.

3. Step 3: Determine which task runs first

   Either TaskY or TaskZ can run first; the scheduler switches between them fairly.

4. Final Answer:

   Either TaskY or TaskZ runs first; FreeRTOS uses time slicing between equal priorities. -> Option C

5. Quick Check:

   Equal priority tasks share CPU time via time slicing [OK]

Hint: Equal priority tasks share CPU time by time slicing [OK]

Common Mistakes:

• Assuming creation order decides first run
• Thinking lower priority task continues running
• Believing one equal priority task always runs first