Task notification vs queue performance in FreeRTOS - Hands-On Comparison

Task Notification vs Queue Performance in FreeRTOS

📖 Scenario: You are working on a FreeRTOS embedded system where tasks communicate with each other. You want to compare the performance of two common methods: task notifications and queues.This project will help you understand how to set up tasks, send data using task notifications and queues, and measure the time taken for each method.

🎯 Goal: Build a FreeRTOS program that creates two tasks: a sender and a receiver. The sender will send data to the receiver using task notifications and then using a queue. You will measure and compare the time taken for each communication method.

📋 What You'll Learn

Create a task notification based communication between two tasks

Create a queue based communication between two tasks

Measure the time taken for sending and receiving messages using both methods

Print the timing results to the console

💡 Why This Matters

🌍 Real World

Embedded systems often need efficient communication between tasks. Choosing the right method can improve responsiveness and reduce CPU load.

💼 Career

Understanding FreeRTOS task notifications and queues is essential for embedded software engineers working on real-time applications like IoT devices, automotive systems, and industrial controllers.

1

Create tasks and basic setup

Create two FreeRTOS tasks called SenderTask and ReceiverTask. Also, create a queue called messageQueue that can hold 5 integers. Use xTaskCreate for tasks and xQueueCreate for the queue.

FreeRTOS

#include "FreeRTOS.h"
#include "task.h"
#include "queue.h"
#include 

// Create SenderTask and ReceiverTask
// Create a queue called messageQueue with length 5
// Your code here

Hint

Use xQueueCreate(5, sizeof(int)) to create the queue. Use xTaskCreate to create tasks with a stack size of 1000 and priority 1.

2

Add a variable to hold the test count

Create an integer variable called testCount and set it to 1000. This will be the number of messages sent in each test.

FreeRTOS

#include "FreeRTOS.h"
#include "task.h"
#include "queue.h"
#include 

QueueHandle_t messageQueue;

int testCount = 1000;  // Number of messages to send

void SenderTask(void *pvParameters) {
    // Empty task for now
    for(;;) {
        vTaskDelay(pdMS_TO_TICKS(1000));
    }
}

void ReceiverTask(void *pvParameters) {
    // Empty task for now
    for(;;) {
        vTaskDelay(pdMS_TO_TICKS(1000));
    }
}

int main(void) {
    messageQueue = xQueueCreate(5, sizeof(int));
    xTaskCreate(SenderTask, "SenderTask", 1000, NULL, 1, NULL);
    xTaskCreate(ReceiverTask, "ReceiverTask", 1000, NULL, 1, NULL);
    vTaskStartScheduler();
    return 0;
}

// Your code here

Hint

Declare int testCount = 1000; outside of any function so both tasks can access it.

3

Implement sending and receiving using task notifications and queues

In SenderTask, send integers from 0 to testCount - 1 to ReceiverTask using xTaskNotifyGive and ulTaskNotifyTake. Then send the same integers using xQueueSend and receive them with xQueueReceive in ReceiverTask. Use ulTaskNotifyTake(pdTRUE, portMAX_DELAY) to wait for notifications. Use vTaskDelay of 1 tick between sends to avoid flooding. Use vTaskDelay of 1 tick in receiver loop as well.

FreeRTOS

#include "FreeRTOS.h"
#include "task.h"
#include "queue.h"
#include 

QueueHandle_t messageQueue;
int testCount = 1000;
TaskHandle_t receiverHandle = NULL;

void SenderTask(void *pvParameters) {
    // Send integers 0 to testCount-1 using task notifications
    // Then send integers 0 to testCount-1 using queue
    // Use vTaskDelay(1) between sends
    // Your code here
}

void ReceiverTask(void *pvParameters) {
    int receivedValue;
    // Receive integers using task notifications
    // Then receive integers using queue
    // Use vTaskDelay(1) in loops
    // Your code here
}

int main(void) {
    messageQueue = xQueueCreate(5, sizeof(int));
    xTaskCreate(SenderTask, "SenderTask", 1000, NULL, 1, NULL);
    xTaskCreate(ReceiverTask, "ReceiverTask", 1000, NULL, 1, &receiverHandle);
    vTaskStartScheduler();
    return 0;
}

Hint

Use xTaskNotifyGive(receiverHandle) to notify the receiver. Use ulTaskNotifyTake(pdTRUE, portMAX_DELAY) in receiver to wait. Use xQueueSend and xQueueReceive for queue communication. Add vTaskDelay(1) between sends and receives to avoid flooding.

4

Measure and print timing results

Add timing measurements using TickType_t start, end and xTaskGetTickCount() before and after sending and receiving loops for both task notifications and queue. Calculate elapsed ticks and print the results using printf. Print exactly these lines:
"Task Notification time: X ticks"
"Queue time: Y ticks" where X and Y are the elapsed ticks for each method.

FreeRTOS

#include "FreeRTOS.h"
#include "task.h"
#include "queue.h"
#include 

QueueHandle_t messageQueue;
int testCount = 1000;
TaskHandle_t receiverHandle = NULL;

void SenderTask(void *pvParameters) {
    // Your code here to measure and print timing
}

void ReceiverTask(void *pvParameters) {
    // Your code here to measure and print timing
}

int main(void) {
    messageQueue = xQueueCreate(5, sizeof(int));
    xTaskCreate(SenderTask, "SenderTask", 1000, NULL, 1, NULL);
    xTaskCreate(ReceiverTask, "ReceiverTask", 1000, NULL, 1, &receiverHandle);
    vTaskStartScheduler();
    return 0;
}

Hint

Use xTaskGetTickCount() before and after loops to measure elapsed ticks. Use printf to print results exactly as:
Task Notification time: X ticks
Queue time: Y ticks.

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