Task notification vs queue performance in FreeRTOS - Visual Side-by-Side Comparison

Concept Flow - Task notification vs queue performance

Task A sends notification

↓

Task B waits for notification

↓

Notification received

↓

Task B processes event

↓

Task A sends data to queue

↓

Task B waits for queue data

↓

Data received from queue

↓

Task B processes data

Shows two flows: one where a task sends a notification and another where a task sends data via a queue, highlighting the difference in communication and processing.

Execution Sample

FreeRTOS

/* Task A sends notification */
xTaskNotifyGive(taskBHandle);

/* Task B waits for notification */
ulTaskNotifyTake(pdTRUE, portMAX_DELAY);

/* Task A sends data to queue */
xQueueSend(queueHandle, &data, portMAX_DELAY);

/* Task B receives data from queue */
xQueueReceive(queueHandle, &receivedData, portMAX_DELAY);

This code shows Task A sending a notification or queue data to Task B, and Task B waiting and receiving it.

Execution Table

Step	Action	Task A State	Task B State	Communication Method	Result
1	Task A sends notification	Notification sent	Waiting for notification	Notification	Notification sent to Task B
2	Task B receives notification	Idle	Notification received	Notification	Task B unblocked and processes event
3	Task A sends data to queue	Data enqueued	Waiting for queue data	Queue	Data placed in queue
4	Task B receives data from queue	Idle	Data received	Queue	Task B unblocked and processes data
5	End	Idle	Idle	Both	Communication complete

💡 Both methods complete communication; notification is faster with less overhead, queue handles data transfer.

Variable Tracker

Variable	Start	After Step 1	After Step 2	After Step 3	After Step 4	Final
Task A State	Idle	Notification sent	Idle	Data enqueued	Idle	Idle
Task B State	Waiting	Waiting for notification	Notification received	Waiting for queue data	Data received	Idle
Queue Content	Empty	Empty	Empty	Data present	Empty	Empty
Notification Flag	Clear	Set	Cleared	Clear	Clear	Clear

Key Moments - 3 Insights

Why is task notification faster than queue communication?

Task notification uses a direct signal without copying data, as shown in execution_table steps 1 and 2, making it faster with less overhead.

When should I use a queue instead of a task notification?

Use a queue when you need to send actual data, not just signals. Execution_table steps 3 and 4 show data being transferred via queue.

Does task notification support sending data like queues?

No, task notifications only send signals or simple values, not complex data. For data transfer, queues are needed as shown in the variable_tracker.

Visual Quiz - 3 Questions

Look at the execution_table, what is Task B state after Step 2?

A Notification received

B Waiting for notification

C Waiting for queue data

D Idle

💡 Hint

Check the 'Task B State' column at Step 2 in execution_table.

At which step does the queue contain data?

A Step 1

B Step 3

C Step 2

D Step 4

💡 Hint

Look at the 'Queue Content' row in variable_tracker after Step 3.

If Task A sends notification twice before Task B receives it, what changes in the execution_table?

A Task B receives two notifications separately

B Task B state changes to waiting for queue data

C Only one notification is recorded; notifications do not queue

D Queue content increases

💡 Hint

Task notifications overwrite previous ones; see 'Notification Flag' in variable_tracker.

Concept Snapshot

Task notification is a lightweight signal from one task to another.
It is faster than queues because it avoids data copying.
Queues are used to send actual data between tasks.
Notifications do not store multiple signals; queues can buffer multiple items.
Use notifications for simple event signaling, queues for data transfer.

Full Transcript

This visual execution compares task notification and queue communication in FreeRTOS. Task A sends a notification or data to Task B. Notifications are simple signals that unblock Task B quickly without data copying, shown in steps 1 and 2. Queues transfer actual data, shown in steps 3 and 4, involving copying data into a buffer. Variable tracking shows Task A's and Task B's states, queue content, and notification flags changing step by step. Key moments clarify when to use notifications versus queues and why notifications are faster but limited. The quiz tests understanding of task states and data flow. The snapshot summarizes the main differences and use cases.

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