Task starvation and priority inversion in FreeRTOS - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to create a task with the highest priority.

FreeRTOS

xTaskCreate(taskFunction, "Task1", 1000, NULL, [1], NULL);

Drag options to blanks, or click blank then click option'

A0

B1

C5

DconfigMAX_PRIORITIES - 1

Attempts:

3 left

💡 Hint

Common Mistakes

Using 0 as highest priority (0 is the lowest).

Using a priority higher than configMAX_PRIORITIES - 1.

The highest priority in FreeRTOS is configMAX_PRIORITIES - 1 because priorities start at 0.

2fill in blank

medium

Complete the code to take a mutex to avoid priority inversion.

FreeRTOS

xSemaphoreTake([1], portMAX_DELAY);

Drag options to blanks, or click blank then click option'

AxQueue

BxTaskHandle

CxMutex

DxTimer

Attempts:

3 left

💡 Hint

Common Mistakes

Using a queue handle instead of a mutex.

Using a timer handle instead of a mutex.

Mutexes are used to avoid priority inversion by controlling access to shared resources.

3fill in blank

hard

Fix the error in the code to prevent task starvation by yielding the processor.

FreeRTOS

void vTaskFunction(void *pvParameters) {
    for(;;) {
        // Task code
        [1]();
    }
}

Drag options to blanks, or click blank then click option'

AtaskYIELD

BvTaskSuspend

CvTaskDelay

DxSemaphoreGive

Attempts:

3 left

💡 Hint

Common Mistakes

Using vTaskDelay without a delay time.

Suspending the task instead of yielding.

Calling taskYIELD() allows other tasks of the same priority to run, preventing starvation.

4fill in blank

hard

Fill both blanks to create a priority inheritance mutex and take it.

FreeRTOS

xMutex = xSemaphoreCreate[1]();
if(xSemaphoreTake(xMutex, [2]) == pdTRUE) {
    // Access resource
}

Drag options to blanks, or click blank then click option'

AMutex

BBinary

CportMAX_DELAY

D0

Attempts:

3 left

💡 Hint

Common Mistakes

Using binary semaphore instead of mutex for priority inheritance.

Using 0 as wait time which causes immediate failure if mutex is not available.

Creating a mutex with xSemaphoreCreateMutex() enables priority inheritance. Using portMAX_DELAY waits indefinitely to take the mutex.

5fill in blank

hard

Fill all three blanks to create a task that avoids starvation by delaying and yielding.

FreeRTOS

void vTaskFunction(void *pvParameters) {
    for(;;) {
        // Do work
        vTaskDelay([1]);
        [2]();
        vTaskDelay([3]);
    }
}

Drag options to blanks, or click blank then click option'

ApdMS_TO_TICKS(10)

BtaskYIELD

CpdMS_TO_TICKS(5)

DvTaskSuspend

Attempts:

3 left

💡 Hint

Common Mistakes

Using vTaskSuspend() which stops the task indefinitely.

Not yielding between delays.

Delaying the task with vTaskDelay() and yielding with taskYIELD() helps prevent starvation by allowing other tasks to run.

Practice

1. What does task starvation mean in FreeRTOS?

easy

A. Some tasks never get CPU time because others run too much

B. All tasks get equal CPU time regardless of priority

C. Tasks run in a random order without priority

D. Tasks share CPU time only when a mutex is free

Solution

1. Step 1: Understand task scheduling in FreeRTOS

   FreeRTOS schedules tasks based on priority, so higher priority tasks run more often.

2. Step 2: Define task starvation

   Task starvation happens when low priority tasks never get CPU time because higher priority tasks keep running.

3. Final Answer:

   Some tasks never get CPU time because others run too much -> Option A

4. Quick Check:

   Task starvation = some tasks starve for CPU [OK]

Hint: Starvation means some tasks get no CPU time [OK]

Common Mistakes:

• Confusing starvation with equal CPU sharing
• Thinking tasks run randomly
• Assuming mutex controls CPU time directly

2. Which FreeRTOS API is used to create a mutex that supports priority inheritance?

easy

A. xQueueCreate()

B. xSemaphoreCreateMutex()

C. vTaskDelay()

D. xTaskCreate()

Solution

1. Step 1: Identify mutex creation functions

   FreeRTOS uses xSemaphoreCreateMutex() to create mutexes with priority inheritance.

2. Step 2: Differentiate other APIs

   xQueueCreate() creates queues, vTaskDelay() delays tasks, and xTaskCreate() creates tasks, not mutexes.

3. Final Answer:

   xSemaphoreCreateMutex() -> Option B

4. Quick Check:

   Mutex with priority inheritance = xSemaphoreCreateMutex() [OK]

Hint: Mutex with priority inheritance uses xSemaphoreCreateMutex() [OK]

Common Mistakes:

• Choosing xQueueCreate() for mutex
• Confusing task creation with mutex creation
• Using delay functions instead of mutex APIs

3. Given three tasks with priorities High (3), Medium (2), and Low (1). Low task holds a mutex needed by High task. What happens without priority inheritance?

medium

A. Medium task is blocked until High task finishes

B. Low task immediately releases the mutex

C. High task waits indefinitely while Medium task runs

D. High task preempts Low task and runs

Solution

1. Step 1: Understand priority inversion scenario

   Low priority task holds mutex needed by High priority task, so High task blocks waiting.

2. Step 2: Effect without priority inheritance

   Medium priority task runs, preventing Low task from running and releasing mutex, causing High task to wait indefinitely.

3. Final Answer:

   High task waits indefinitely while Medium task runs -> Option C

4. Quick Check:

   Priority inversion without inheritance = High task blocked [OK]

Hint: Without inheritance, medium task blocks low task, blocking high task [OK]

Common Mistakes:

• Assuming low task releases mutex immediately
• Thinking high task preempts low task despite mutex
• Believing medium task is blocked

4. Identify the problem in this FreeRTOS code snippet causing priority inversion:

void lowTask(void *pvParameters) {
  xSemaphoreTake(mutex, portMAX_DELAY);
  // long processing
  xSemaphoreGive(mutex);
  vTaskDelete(NULL);
}

void highTask(void *pvParameters) {
  xSemaphoreTake(mutex, portMAX_DELAY);
  // quick processing
  xSemaphoreGive(mutex);
  vTaskDelete(NULL);
}

medium

A. Mutex created without priority inheritance support

B. High task does not take the mutex

C. Low task never releases the mutex

D. Tasks have the same priority

Solution

1. Step 1: Analyze mutex usage in code

   Both tasks take and give the mutex correctly, so no misuse in code logic.

2. Step 2: Check for priority inversion cause

   If mutex was created without priority inheritance, low task holding mutex blocks high task causing priority inversion.

3. Final Answer:

   Mutex created without priority inheritance support -> Option A

4. Quick Check:

   Priority inversion fix needs mutex with priority inheritance [OK]

Hint: Check if mutex supports priority inheritance to fix inversion [OK]

Common Mistakes:

• Assuming high task does not take mutex
• Thinking low task never releases mutex
• Believing tasks have same priority

5. How can you prevent task starvation and priority inversion in a FreeRTOS system with multiple tasks sharing resources?

hard

A. Use busy-wait loops in low priority tasks to keep CPU busy

B. Assign all tasks the same priority to avoid conflicts

C. Avoid using any synchronization primitives like mutexes

D. Use mutexes with priority inheritance and design balanced task priorities

Solution

1. Step 1: Understand causes of starvation and inversion

   Starvation happens when low priority tasks never run; inversion when low priority blocks high priority.

2. Step 2: Apply solutions in FreeRTOS

   Using mutexes with priority inheritance prevents inversion; balanced priorities avoid starvation.

3. Final Answer:

   Use mutexes with priority inheritance and design balanced task priorities -> Option D

4. Quick Check:

   Priority inheritance + balanced priorities prevent issues [OK]

Hint: Combine priority inheritance mutexes with balanced priorities [OK]

Common Mistakes:

• Setting all tasks to same priority causing inefficiency
• Avoiding mutexes causing race conditions
• Using busy-wait wastes CPU and worsens starvation