Preemptive scheduling behavior in FreeRTOS - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Preemptive Scheduling: Task Priority Impact

Consider two FreeRTOS tasks: TaskA with priority 2 and TaskB with priority 3. Both tasks are ready to run at the same time. TaskA starts running first. What happens next?

FreeRTOS

void TaskA(void *pvParameters) {
    for (;;) {
        // TaskA code
    }
}

void TaskB(void *pvParameters) {
    for (;;) {
        // TaskB code
    }
}

int main() {
    xTaskCreate(TaskA, "TaskA", 1000, NULL, 2, NULL);
    xTaskCreate(TaskB, "TaskB", 1000, NULL, 3, NULL);
    vTaskStartScheduler();
    return 0;
}

A TaskB immediately preempts TaskA and starts running because it has higher priority.

B TaskA and TaskB run in a round-robin fashion regardless of priority.

C TaskA continues running until it blocks or yields, then TaskB runs.

D Both tasks run simultaneously on separate cores.

💡 Hint

Remember, in preemptive scheduling, the highest priority ready task runs immediately.

FreeRTOS uses preemptive scheduling. When a higher priority task becomes ready, it preempts the currently running lower priority task immediately.

❓ Predict Output

intermediate

Effect of vTaskDelay on Preemptive Scheduling

In FreeRTOS, if a running task calls vTaskDelay(), what happens to the CPU scheduling?

FreeRTOS

void TaskExample(void *pvParameters) {
    for (;;) {
        // Do some work
        vTaskDelay(pdMS_TO_TICKS(100));
    }
}

A The scheduler stops all tasks until the delay expires.

B The task yields but remains ready to run immediately after delay.

C The task continues running without interruption.

D The task blocks and the scheduler runs the highest priority ready task.

💡 Hint

Think about what happens when a task delays itself in FreeRTOS.

Calling vTaskDelay() blocks the task for the specified time, allowing the scheduler to run other ready tasks.

❓ Predict Output

advanced

Preemptive Scheduling with Equal Priority Tasks

Two tasks, Task1 and Task2, have the same priority in FreeRTOS. Both are ready to run. What is the expected behavior?

FreeRTOS

void Task1(void *pvParameters) {
    for (;;) {
        // Task1 code
    }
}

void Task2(void *pvParameters) {
    for (;;) {
        // Task2 code
    }
}

int main() {
    xTaskCreate(Task1, "Task1", 1000, NULL, 2, NULL);
    xTaskCreate(Task2, "Task2", 1000, NULL, 2, NULL);
    vTaskStartScheduler();
    return 0;
}

A Only Task1 runs because it was created first.

B The scheduler randomly picks one task to run forever.

C Tasks run in strict alternation using time slicing if enabled.

D Both tasks run simultaneously on different cores.

💡 Hint

Consider how FreeRTOS handles tasks with the same priority.

FreeRTOS uses time slicing (if configUSE_TIME_SLICING is enabled) to share CPU time fairly among tasks of equal priority.

❓ Predict Output

advanced

Preemption Behavior with Interrupts and Task Priorities

In FreeRTOS, an interrupt service routine (ISR) makes a higher priority task ready to run. What happens immediately after the ISR completes?

FreeRTOS

void vAnISR(void) {
    BaseType_t xHigherPriorityTaskWoken = pdFALSE;
    xTaskNotifyFromISR(xHighPriorityTaskHandle, 0, eNoAction, &xHigherPriorityTaskWoken);
    portYIELD_FROM_ISR(xHigherPriorityTaskWoken);
}

A The higher priority task preempts the currently running task immediately after ISR.

B The scheduler ignores the higher priority task until the next tick.

C The ISR blocks the higher priority task from running until manually resumed.

D The higher priority task runs only if the current task yields voluntarily.

💡 Hint

Think about how FreeRTOS handles context switches triggered by ISRs.

Using portYIELD_FROM_ISR() causes an immediate context switch to the higher priority task after the ISR ends.

🧠 Conceptual

expert

Preemptive Scheduling and Priority Inversion Scenario

In a FreeRTOS system, TaskLow (priority 1) holds a mutex needed by TaskHigh (priority 3). TaskMedium (priority 2) is ready to run. What problem can occur and how does FreeRTOS help prevent it?

A No problem occurs; TaskHigh preempts all tasks immediately.

B Priority inversion occurs; FreeRTOS uses priority inheritance to temporarily raise TaskLow's priority.

C TaskMedium blocks TaskHigh indefinitely; FreeRTOS disables preemption to fix this.

D TaskLow is forced to release the mutex immediately; FreeRTOS kills TaskMedium.

💡 Hint

Think about what happens when a low priority task blocks a high priority task and a medium priority task runs.

Priority inversion happens when a low priority task holds a resource needed by a high priority task. FreeRTOS uses priority inheritance to raise the low priority task's priority temporarily to prevent medium priority tasks from blocking progress.