Task notification vs queue performance in FreeRTOS - Practice Questions

Challenge - 5 Problems

❓ Predict Output

intermediate

Task Notification vs Queue: Which is faster?

Consider two FreeRTOS tasks communicating data. One uses a task notification to send a single integer value, the other uses a queue to send the same integer. What is the expected difference in performance?

Given the code snippets below, which output best describes the timing results?

FreeRTOS

/* Task Notification example */
uint32_t value = 42;
xTaskNotify(taskHandle, value, eSetValueWithOverwrite);

/* Queue example */
uint32_t value = 42;
xQueueSend(queueHandle, &value, 0);

A Task notification is faster because it uses direct-to-task signaling with minimal overhead, while queues involve copying data and managing queue structures.

B Queue is faster because it supports multiple items and task notifications are limited to one value, causing delays.

C Both have the same performance since both use interrupts internally to signal tasks.

D Task notification is slower because it requires more CPU cycles to manage the notification bits compared to queues.

💡 Hint

Think about how much data copying and synchronization each method requires.

Task notifications are designed for fast, lightweight signaling between tasks. They avoid the overhead of copying data into a queue and managing queue pointers, making them faster for simple data like integers.

🧠 Conceptual

intermediate

When to prefer task notifications over queues?

Which scenario best fits the use of task notifications instead of queues in FreeRTOS?

A When sending large amounts of data between tasks frequently.

B When tasks require guaranteed message order and buffering of multiple messages.

C When multiple tasks need to receive the same message simultaneously.

D When signaling a task with a simple event or a single integer value without data buffering needs.

💡 Hint

Task notifications are lightweight and limited in data size.

Task notifications are ideal for simple signaling or passing a single integer value. Queues are better for buffering multiple messages or larger data.

❓ Predict Output

advanced

Output of task notification value after multiple sends

Given the following FreeRTOS code snippet, what is the value received by the task after two notifications?

FreeRTOS

uint32_t ulValue;

// Task waits for notification and reads value
xTaskNotifyWait(0x00, 0xffffffff, &ulValue, portMAX_DELAY);

// Elsewhere in code:
xTaskNotify(taskHandle, 5, eSetValueWithOverwrite);
xTaskNotify(taskHandle, 3, eSetValueWithOverwrite);

A 0

B 5

C 3

D 8

💡 Hint

Check how eSetValueWithOverwrite affects the notification value.

eSetValueWithOverwrite replaces the notification value with the new one. The second call overwrites the first, so the task receives 3.

❓ Predict Output

advanced

Queue length after multiple sends and receives

What is the length of the queue after the following operations?

FreeRTOS

QueueHandle_t queue = xQueueCreate(3, sizeof(int));
int val = 10;
xQueueSend(queue, &val, 0);
val = 20;
xQueueSend(queue, &val, 0);
int received;
xQueueReceive(queue, &received, 0);
xQueueSend(queue, &val, 0);

A 3

B 2

C 0

D 1

💡 Hint

Count how many items are sent and received.

Two items are sent initially, one is received (removed), then one more is sent. So total items in queue: 2.

🧠 Conceptual

expert

Why might task notifications be unsuitable for complex data transfer?

Which is the main reason task notifications are not recommended for transferring complex or large data between tasks?

A Task notifications can only send a 32-bit value and do not support buffering multiple messages.

B Task notifications require dynamic memory allocation which is slow for large data.

C Task notifications block the scheduler causing delays in other tasks.

D Task notifications automatically copy data which increases CPU usage.

💡 Hint

Think about the size and buffering capabilities of task notifications.

Task notifications are limited to a single 32-bit value and do not provide buffering, making them unsuitable for complex or large data transfers.

Practice

1. Which statement best describes the performance difference between FreeRTOS task notifications and queues?

easy

A. Task notifications and queues have the same performance.

B. Queues are faster and use less memory than task notifications.

C. Task notifications are faster and use less memory than queues.

D. Queues are only used for signaling, not data transfer.

Solution

1. Step 1: Understand task notifications

   Task notifications are designed as lightweight signals between tasks, using minimal resources.

2. Step 2: Compare with queues

   Queues provide more flexibility but require more memory and processing time, making them slower.

3. Final Answer:

   Task notifications are faster and use less memory than queues. -> Option C

4. Quick Check:

   Task notifications = faster, less memory [OK]

Hint: Task notifications are lightweight signals, queues hold data [OK]

Common Mistakes:

• Thinking queues are always faster
• Confusing signaling with data transfer
• Assuming task notifications can hold large data

2. Which of the following is the correct syntax to send a task notification in FreeRTOS?

easy

A. xTaskNotifyGive(taskHandle);

B. xQueueSend(queueHandle, &data, portMAX_DELAY);

C. xTaskNotifySend(taskHandle, 0);

D. xQueueReceive(queueHandle, &data, 0);

Solution

1. Step 1: Identify task notification sending functions

   The function xTaskNotifyGive() is used to send a notification to a task.

2. Step 2: Differentiate from queue functions

   xQueueSend() and xQueueReceive() are queue operations, not task notifications.

3. Final Answer:

   xTaskNotifyGive(taskHandle); -> Option A

4. Quick Check:

   Send notification = xTaskNotifyGive() [OK]

Hint: Use xTaskNotifyGive() to send notifications, not queue functions [OK]

Common Mistakes:

• Using queue functions to send notifications
• Confusing xTaskNotifySend with xTaskNotifyGive
• Incorrect parameters in notification functions

3. Consider the following code snippet in FreeRTOS:

uint32_t value = 0;
if (xTaskNotifyWait(0x00, 0xFFFFFFFF, &value, 0) == pdTRUE) {
    // Notification received
    process(value);
} else {
    // No notification
    process(0);
}

What will happen if a task notification with value 5 was sent before this check?

medium

A. process(0) will be called because timeout is zero.

B. process(5) will be called because notification value is received.

C. The code will block until a notification arrives.

D. An error occurs because value is not initialized.

Solution

1. Step 1: Understand xTaskNotifyWait behavior

   This function checks for a notification and retrieves its value if available, returning pdTRUE.

2. Step 2: Analyze the timeout and notification value

   Since a notification with value 5 was sent before, the function returns immediately with pdTRUE and sets value to 5.

3. Final Answer:

   process(5) will be called because notification value is received. -> Option B

4. Quick Check:

   Notification received = process(value) [OK]

Hint: If notification sent, xTaskNotifyWait returns true immediately [OK]

Common Mistakes:

• Assuming zero timeout causes blocking
• Ignoring the notification value received
• Thinking uninitialized value causes error

4. Given this FreeRTOS code snippet, what is the main issue?

uint32_t notifyValue;
if (xTaskNotifyWait(0, 0xFFFFFFFF, ¬ifyValue, portMAX_DELAY) == pdTRUE) {
    // Process notification
    process(notifyValue);
}
// Later
xQueueSend(queueHandle, &data, 0);

medium

A. xQueueSend is called without checking if the queue is full.

B. xTaskNotifyWait cannot be used with queues.

C. notifyValue is not initialized before use.

D. Using portMAX_DELAY in xTaskNotifyWait can cause indefinite blocking.

Solution

1. Step 1: Analyze xTaskNotifyWait usage

   Using portMAX_DELAY causes the task to block indefinitely until a notification arrives.

2. Step 2: Consider implications

   This indefinite block can cause deadlocks if notifications are not sent, which is a common issue.

3. Final Answer:

   Using portMAX_DELAY in xTaskNotifyWait can cause indefinite blocking. -> Option D

4. Quick Check:

   portMAX_DELAY = indefinite block risk [OK]

Hint: portMAX_DELAY blocks forever; use timeout carefully [OK]

Common Mistakes:

• Ignoring blocking behavior of portMAX_DELAY
• Assuming notifyValue must be initialized
• Confusing queue and notification usage

5. You need to send multiple integer values from one task to another in FreeRTOS with minimal delay. Which approach is best for performance and why?

hard

A. Use task notifications only for signaling and queues for data transfer.

B. Use a queue to send each integer separately, ensuring order and data integrity.

C. Use global variables protected by mutexes to share data.

D. Use task notifications with bitwise encoding to send multiple values quickly.

Solution

1. Step 1: Understand task notifications limitations

   Task notifications are fast but designed for simple signals or small data (like a single 32-bit value).

2. Step 2: Consider queues for multiple data items

   Queues can hold multiple messages and maintain order, suitable for sending multiple integers reliably.

3. Step 3: Choose best practice

   Use task notifications for signaling and queues for actual data transfer to balance performance and correctness.

4. Final Answer:

   Use task notifications only for signaling and queues for data transfer. -> Option A

5. Quick Check:

   Notifications = signals, queues = data [OK]

Hint: Notifications signal; queues transfer multiple data items [OK]

Common Mistakes:

• Trying to encode multiple values in notifications
• Ignoring data integrity with global variables
• Assuming notifications can replace queues for data