Task pooling for dynamic workloads in FreeRTOS - Mini Project: Build & Apply

Task pooling for dynamic workloads

📖 Scenario: You are building a FreeRTOS application that needs to handle multiple tasks dynamically. Instead of creating and deleting tasks repeatedly, you want to use a task pool to reuse tasks efficiently. This helps save system resources and improves performance.

🎯 Goal: Build a simple task pool system in FreeRTOS where a fixed number of tasks wait for work from a queue. When new work arrives, a task picks it up, processes it, and then waits for more work. You will create the data structures, configure the queue, implement the task pool logic, and print the results.

📋 What You'll Learn

Create an array of task handles for the task pool

Create a FreeRTOS queue to hold work items

Implement worker tasks that wait on the queue and process work

Print the processed work item IDs from the tasks

💡 Why This Matters

🌍 Real World

Task pooling is used in embedded systems to efficiently manage limited resources by reusing tasks instead of creating and deleting them repeatedly.

💼 Career

Understanding task pooling and FreeRTOS queues is important for embedded software developers working on real-time systems like IoT devices, automotive controllers, and industrial automation.

1

Create the task pool handles array

Create an array called taskPool of type TaskHandle_t with size 3 to hold the task handles.

FreeRTOS

# Create an array called taskPool of type TaskHandle_t with size 3
# Your code here

Hint

Use the syntax TaskHandle_t arrayName[size]; to declare the array.

2

Create the work queue

Create a queue handle called workQueue using QueueHandle_t. Then create the queue with xQueueCreate to hold 5 integers representing work item IDs.

FreeRTOS

TaskHandle_t taskPool[3];
// Create a queue handle called workQueue and create the queue for 5 integers
# Your code here

Hint

Use QueueHandle_t for the queue handle and xQueueCreate(5, sizeof(int)) to create the queue.

3

Implement the worker task function

Write a function called workerTask that takes void *pvParameters. Inside, declare an integer workItem. Use an infinite loop to call xQueueReceive on workQueue with portMAX_DELAY. When a work item is received, print its ID using printf with the format "Task processed work item: %d\n".

FreeRTOS

TaskHandle_t taskPool[3];
QueueHandle_t workQueue;
workQueue = xQueueCreate(5, sizeof(int));

// Write the workerTask function below
# Your code here

Hint

Use an infinite loop with for (;;) and xQueueReceive to wait for work.

4

Create tasks and send work items

Create 3 tasks using xTaskCreate with workerTask, names "Worker1", "Worker2", "Worker3", stack size 1000, no parameters, priority 1, and store their handles in taskPool. Then send 5 work items (integers 1 to 5) to workQueue using xQueueSend. Finally, start the scheduler with vTaskStartScheduler().

FreeRTOS

TaskHandle_t taskPool[3];
QueueHandle_t workQueue;
workQueue = xQueueCreate(5, sizeof(int));

void workerTask(void *pvParameters) {
    int workItem;
    for (;;) {
        if (xQueueReceive(workQueue, &workItem, portMAX_DELAY) == pdPASS) {
            printf("Task processed work item: %d\n", workItem);
        }
    }
}

// Create 3 tasks, send 5 work items, and start scheduler
# Your code here

Hint

Use xTaskCreate to create tasks and xQueueSend to send work items.

Practice

1. What is the main advantage of using a task pool in FreeRTOS for dynamic workloads?

easy

A. It reuses a fixed number of tasks to handle many jobs efficiently.

B. It creates a new task for every job to maximize parallelism.

C. It eliminates the need for queues in task communication.

D. It requires more memory but improves task priority handling.

Solution

1. Step 1: Understand task pooling concept

   Task pooling means reusing a limited number of tasks instead of creating new ones for each job.

2. Step 2: Identify benefits of task pooling

   This reuse saves memory and improves efficiency by avoiding overhead of task creation and deletion.

3. Final Answer:

   It reuses a fixed number of tasks to handle many jobs efficiently. -> Option A

4. Quick Check:

   Task pooling = reuse fixed tasks [OK]

Hint: Task pooling means reuse tasks, not create new ones [OK]

Common Mistakes:

• Thinking task pooling creates a new task per job
• Believing task pooling removes the need for queues
• Assuming task pooling uses more memory

2. Which FreeRTOS API is typically used to send work items to a task pool?

easy

A. vTaskDelay()

B. xQueueSend()

C. xSemaphoreTake()

D. vTaskDelete()

Solution

1. Step 1: Identify communication method for task pools

   Task pools receive work items via queues to distribute jobs among tasks.

2. Step 2: Match API to queue sending

   xQueueSend() is the FreeRTOS function to send data to a queue.

3. Final Answer:

   xQueueSend() -> Option B

4. Quick Check:

   Send work to queue = xQueueSend() [OK]

Hint: Use xQueueSend() to send work to task pool queue [OK]

Common Mistakes:

• Confusing delay or semaphore functions with queue sending
• Using vTaskDelete() which deletes tasks, not send work

3. Given this snippet, what will be printed?

void workerTask(void *params) {
  int workItem;
  while (xQueueReceive(workQueue, &workItem, portMAX_DELAY)) {
    printf("Processing %d\n", workItem);
  }
}

// Main code
int main() {
  int item = 42;
  xQueueSend(workQueue, &item, 0);
  vTaskStartScheduler();
  return 0;
}

medium

A. Processing 0

B. No output, queue is empty

C. Processing 42

D. Compilation error due to missing queue creation

Solution

1. Step 1: Check queue usage in code

   The code uses workQueue but does not show it being created or initialized.

2. Step 2: Understand FreeRTOS queue requirements

   Queues must be created with xQueueCreate before use; missing this causes compile or runtime errors.

3. Final Answer:

   Compilation error due to missing queue creation -> Option D

4. Quick Check:

   Queue must be created before use [OK]

Hint: Always create queues before sending or receiving [OK]

Common Mistakes:

• Assuming queue exists without creation
• Expecting output without scheduler running properly
• Ignoring queue initialization

4. Identify the error in this task pool worker function:

void workerTask(void *params) {
  int workItem;
  while (xQueueReceive(workQueue, &workItem, 0)) {
    process(workItem);
  }
}

medium

A. Using zero timeout causes busy waiting and high CPU usage.

B. workItem should be a pointer, not int.

C. process() is not a valid FreeRTOS API.

D. xQueueReceive requires a NULL pointer for workItem.

Solution

1. Step 1: Analyze xQueueReceive timeout parameter

   Timeout of 0 means non-blocking call; if queue empty, returns immediately causing loop to run continuously.

2. Step 2: Understand impact on CPU usage

   This busy loop wastes CPU cycles, leading to high CPU usage and inefficient task pooling.

3. Final Answer:

   Using zero timeout causes busy waiting and high CPU usage. -> Option A

4. Quick Check:

   Zero timeout = busy wait [OK]

Hint: Use portMAX_DELAY to block and avoid busy waiting [OK]

Common Mistakes:

• Thinking zero timeout is safe for task pools
• Confusing pointer types for queue data
• Assuming process() is FreeRTOS API

5. You want to implement a task pool with 3 worker tasks to handle variable workloads efficiently. Which approach is best?

hard

A. Use a single task with vTaskDelay to process all work items sequentially.

B. Create 3 tasks that poll the queue with zero timeout in a tight loop.

C. Create 3 tasks that block on xQueueReceive with portMAX_DELAY and send work via a queue.

D. Create a new task for each work item dynamically and delete it after processing.

Solution

1. Step 1: Understand efficient task pooling

   Efficient pooling uses fixed tasks that wait (block) for work to avoid wasting CPU.

2. Step 2: Evaluate options for workload handling

   Blocking on xQueueReceive with portMAX_DELAY lets tasks sleep until work arrives, saving CPU and memory.

3. Final Answer:

   Create 3 tasks that block on xQueueReceive with portMAX_DELAY and send work via a queue. -> Option C

4. Quick Check:

   Block on queue = efficient task pool [OK]

Hint: Block tasks on queue to save CPU and handle dynamic work [OK]

Common Mistakes:

• Polling queue wastes CPU
• Creating tasks dynamically wastes memory
• Using single task delays reduces responsiveness