Priority inheritance behavior in FreeRTOS - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to create a mutex in FreeRTOS.

FreeRTOS

SemaphoreHandle_t xMutex = [1]();

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

AvTaskDelay

BxQueueCreate

CxSemaphoreCreateMutex

DxTaskCreate

Attempts:

3 left

💡 Hint

Common Mistakes

Using xQueueCreate instead of xSemaphoreCreateMutex.

The function xSemaphoreCreateMutex() creates a mutex in FreeRTOS.

2fill in blank

medium

Complete the code to take a mutex with a block time of 100 ticks.

FreeRTOS

if(xSemaphoreTake(xMutex, [1]) == pdTRUE) {
    // Critical section
}

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

A0

BportMAX_DELAY

CpdFALSE

D100

Attempts:

3 left

💡 Hint

Common Mistakes

Using 0 means no wait, which is not what is asked.

The second parameter is the block time in ticks. Here, 100 ticks means wait up to 100 ticks to take the mutex.

3fill in blank

hard

Fix the error in the code to release the mutex correctly.

FreeRTOS

xSemaphore[1](xMutex);

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

ADelete

BGive

CCreateMutex

DTake

Attempts:

3 left

💡 Hint

Common Mistakes

Using xSemaphoreTake instead of xSemaphoreGive.

To release a mutex, use xSemaphoreGive().

4fill in blank

hard

Fill both blanks to create a priority inheritance scenario: Task A takes the mutex, Task B has higher priority and waits.

FreeRTOS

xTaskCreate(TaskA, "TaskA", 1000, NULL, [1], NULL);
xTaskCreate(TaskB, "TaskB", 1000, NULL, [2], NULL);

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

A2

B1

C3

D0

Attempts:

3 left

💡 Hint

Common Mistakes

Assigning higher priority to Task A instead of Task B.

Task A has lower priority (1), Task B has higher priority (3) to demonstrate priority inheritance.

5fill in blank

hard

Fill all three blanks to implement priority inheritance: Task A takes mutex, Task B waits, and priority is temporarily boosted.

FreeRTOS

void TaskA(void *pvParameters) {
    xSemaphoreTake([1], portMAX_DELAY);
    // Critical section
    vTaskDelay([2]);
    xSemaphoreGive([3]);
    vTaskDelete(NULL);
}

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

AxMutex

B100

DxQueue

Attempts:

3 left

💡 Hint

Common Mistakes

Using different variables for take and give.

Task A takes the mutex xMutex, delays for 100 ticks simulating work, then gives back the mutex.

Practice

1. What is the main purpose of priority inheritance in FreeRTOS?

easy

A. To increase the priority of all tasks equally

B. To prevent low priority tasks from blocking high priority tasks for too long

C. To allow tasks to run in a random order

D. To disable task scheduling temporarily

Solution

1. Step 1: Understand priority inversion problem

   Priority inversion happens when a low priority task holds a resource needed by a high priority task, causing delays.

2. Step 2: Role of priority inheritance

   Priority inheritance temporarily raises the low priority task's priority to the high priority task's level to reduce blocking time.

3. Final Answer:

   To prevent low priority tasks from blocking high priority tasks for too long -> Option B

4. Quick Check:

   Priority inheritance prevents blocking = A [OK]

Hint: Priority inheritance helps high priority tasks run faster [OK]

Common Mistakes:

• Thinking it raises all tasks' priorities
• Confusing it with disabling scheduling
• Believing it randomizes task order

2. Which FreeRTOS synchronization primitive automatically supports priority inheritance?

easy

A. Semaphore (binary)

B. Event group

C. Mutex

D. Queue

Solution

1. Step 1: Identify synchronization primitives

   FreeRTOS offers semaphores, mutexes, queues, and event groups for task synchronization.

2. Step 2: Check which supports priority inheritance

   Mutexes in FreeRTOS implement priority inheritance automatically to avoid priority inversion.

3. Final Answer:

   Mutex -> Option C

4. Quick Check:

   Mutex = priority inheritance support [OK]

Hint: Mutexes handle priority inheritance automatically [OK]

Common Mistakes:

• Choosing binary semaphore which lacks priority inheritance
• Confusing queues or event groups with mutexes
• Assuming all synchronization primitives support priority inheritance

3. Consider three tasks: High, Medium, and Low priority. Low holds a mutex needed by High. Medium is ready to run. What happens when priority inheritance is enabled?

medium

A. Medium task runs before Low and High

B. Low task is blocked until Medium finishes

C. High task runs immediately, ignoring mutex

D. Low task inherits High priority, runs before Medium

Solution

1. Step 1: Analyze priority inversion scenario

   Low priority task holds mutex needed by High priority task, but Medium priority task is ready.

2. Step 2: Effect of priority inheritance

   Low task temporarily inherits High priority, so it runs before Medium to release mutex faster.

3. Final Answer:

   Low task inherits High priority, runs before Medium -> Option D

4. Quick Check:

   Priority inheritance boosts Low task priority = B [OK]

Hint: Low task runs at High priority to unblock High task [OK]

Common Mistakes:

• Assuming Medium runs before Low despite inheritance
• Thinking High runs without mutex
• Believing Low is blocked by Medium

4. You wrote code using a binary semaphore to protect a shared resource, but high priority tasks are blocked too long. What is the likely issue?

medium

A. Binary semaphore does not support priority inheritance

B. Mutex was not created properly

C. High priority tasks are not using the semaphore

D. Task priorities are all equal

Solution

1. Step 1: Identify synchronization primitive used

   Binary semaphore is used to protect shared resource.

2. Step 2: Check priority inheritance support

   Binary semaphores do not support priority inheritance, causing priority inversion issues.

3. Final Answer:

   Binary semaphore does not support priority inheritance -> Option A

4. Quick Check:

   Binary semaphore lacks priority inheritance = A [OK]

Hint: Use mutex, not binary semaphore, for priority inheritance [OK]

Common Mistakes:

• Assuming binary semaphore supports priority inheritance
• Blaming task priorities without checking synchronization
• Ignoring mutex creation correctness

5. In a system with tasks A (priority 3), B (priority 2), and C (priority 1), task C holds a mutex needed by A. Task B is CPU intensive. How does FreeRTOS priority inheritance help avoid priority inversion here?

hard

A. Task C temporarily inherits priority 3, preempting B to release mutex faster

B. Task B inherits priority 3 to run before C and A

C. Task A runs without waiting for mutex

D. Task C is blocked until B finishes

Solution

1. Step 1: Understand task priorities and mutex ownership

   Task C (low priority) holds mutex needed by Task A (high priority), while Task B (medium priority) is CPU intensive.

2. Step 2: Apply priority inheritance behavior

   Task C inherits Task A's high priority (3) temporarily, allowing it to preempt Task B and release the mutex quickly.

3. Final Answer:

   Task C temporarily inherits priority 3, preempting B to release mutex faster -> Option A

4. Quick Check:

   Priority inheritance boosts C to A's priority = C [OK]

Hint: Low priority task inherits high priority to beat medium task [OK]

Common Mistakes:

• Thinking medium priority task inherits high priority
• Assuming high priority task runs without mutex
• Believing low priority task is blocked by medium task