Task pooling for dynamic workloads in FreeRTOS - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to create a task pool with FreeRTOS.

FreeRTOS

xTaskCreate([1], "Task1", 1000, NULL, 1, NULL);

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

AvTaskFunction

BvTaskDelete

CxQueueCreate

DxSemaphoreCreate

Attempts:

3 left

💡 Hint

Common Mistakes

Using xQueueCreate instead of a task function.

Passing NULL as the task function.

Confusing task creation with semaphore or queue creation.

The function vTaskFunction is the task function passed to xTaskCreate to create a task.

2fill in blank

medium

Complete the code to initialize a queue for task communication.

FreeRTOS

QueueHandle_t xQueue = [1](10, sizeof(int));

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

AxTaskCreate

BxSemaphoreCreateBinary

CxQueueCreate

DvTaskDelay

Attempts:

3 left

💡 Hint

Common Mistakes

Using xTaskCreate instead of xQueueCreate.

Using semaphore creation functions instead of queue creation.

Confusing queue creation with task delay.

xQueueCreate creates a queue with a specified length and item size for task communication.

3fill in blank

hard

Fix the error in the task pool code by completing the missing function call.

FreeRTOS

if (xTaskCreate(vTaskFunction, "Task", 1000, NULL, 1, &[1]) != pdPASS) {
    // Handle error
}

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

AxQueue

BxTimer

CxSemaphore

DxTaskHandle

Attempts:

3 left

💡 Hint

Common Mistakes

Passing a queue or semaphore handle instead of a task handle.

Passing NULL when a handle pointer is needed.

Confusing timer handles with task handles.

The last argument to xTaskCreate is a pointer to a TaskHandle_t variable, here named xTaskHandle.

4fill in blank

hard

Fill both blanks to create a task pool that dynamically handles workload.

FreeRTOS

for (int i = 0; i < [1]; i++) {
    xTaskCreate(vTaskFunction, "Task", 1000, NULL, [2], NULL);
}

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

A5

B1

C10

D0

Attempts:

3 left

💡 Hint

Common Mistakes

Using zero tasks or zero priority which disables tasks.

Using too few tasks to handle workload.

Using priority zero which is invalid.

Creating 10 tasks with priority 1 allows a dynamic task pool to handle workload efficiently.

5fill in blank

hard

Fill all three blanks to implement a task pool that processes data from a queue.

FreeRTOS

void vTaskFunction(void *pvParameters) {
    int data;
    while (1) {
        if (xQueueReceive([1], &data, [2]) == pdPASS) {
            processData(data);
        }
        vTaskDelay([3]);
    }
}

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

AxQueue

BportMAX_DELAY

C100 / portTICK_PERIOD_MS

DNULL

Attempts:

3 left

💡 Hint

Common Mistakes

Using NULL instead of the queue handle.

Using zero timeout instead of portMAX_DELAY.

Using zero delay which causes tight looping.

The task receives data from xQueue, waits indefinitely (portMAX_DELAY), and delays 100 ms between checks.

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