Stack size allocation in FreeRTOS - Step-by-Step Execution

Concept Flow - Stack size allocation

Define Task

↓

Specify Stack Size

↓

Create Task with Stack Size

↓

Task Runs

↓

Stack Used by Task

↓

Stack Overflow Check

↓

Adjust Stack Size if Needed

↩Back to Create Task

This flow shows how a FreeRTOS task is created with a specified stack size, how the task uses the stack, and how stack overflow is checked and handled.

Execution Sample

FreeRTOS

xTaskCreate(TaskFunction, "Task1", 128, NULL, 1, NULL);

Creates a FreeRTOS task named 'Task1' with a stack size of 128 words.

Execution Table

Step	Action	Stack Size (words)	Stack Used (words)	Stack Overflow Check	Result
1	Define TaskFunction	-	-	-	Task function code ready
2	Call xTaskCreate with stack size 128	128	0	No	Task created, stack allocated
3	Task starts running	128	20	No	Task uses 20 words of stack
4	Task runs more code	128	50	No	Stack usage increased to 50 words
5	Task runs deep function calls	128	130	Yes	Stack overflow detected
6	Adjust stack size to 256	256	130	No	Stack overflow prevented
7	Task runs safely	256	130	No	Task continues normally

💡 Execution stops when task runs safely without stack overflow.

Variable Tracker

Variable	Start	After Step 2	After Step 3	After Step 4	After Step 5	After Step 6	Final
Stack Size (words)	-	128	128	128	128	256	256
Stack Used (words)	0	0	20	50	130	130	130
Stack Overflow	No	No	No	No	Yes	No	No

Key Moments - 3 Insights

Why does the stack overflow even though we allocated 128 words?

Because the task used 130 words which is more than the allocated 128, as shown in execution_table row 5.

What happens if we don't adjust the stack size after overflow?

The task may crash or behave unpredictably due to stack overflow, so increasing stack size as in row 6 prevents this.

Is the stack size in bytes or words?

In FreeRTOS, stack size is specified in words, not bytes, so 128 means 128 words (usually 4 bytes each).

Visual Quiz - 3 Questions

Look at the execution_table, what is the stack usage at step 4?

A 50 words

B 130 words

C 20 words

D 128 words

💡 Hint

Check the 'Stack Used (words)' column at step 4 in the execution_table.

At which step does the stack overflow occur?

A Step 4

B Step 5

C Step 3

D Step 6

💡 Hint

Look for 'Stack Overflow Check' column showing 'Yes' in the execution_table.

If we change the initial stack size to 256, what would happen at step 5?

A Stack overflow occurs

B Task creation fails

C No stack overflow occurs

D Stack usage becomes 256

💡 Hint

Refer to execution_table row 6 and 7 where stack size is increased to 256 and no overflow occurs.

Concept Snapshot

FreeRTOS stack size allocation:
- Stack size is set in words when creating a task.
- Task uses stack during execution; usage varies.
- If usage exceeds allocation, stack overflow occurs.
- Adjust stack size to prevent overflow.
- Stack size must be enough for worst-case usage.

Full Transcript

In FreeRTOS, when you create a task, you specify how much stack memory it needs in words. The system allocates this stack for the task. As the task runs, it uses some of this stack for function calls and variables. If the task uses more stack than allocated, a stack overflow happens, which can cause errors. To avoid this, you monitor stack usage and increase the stack size if needed. This process ensures your task runs safely without crashing due to stack overflow.

Practice

1. What does the stack size parameter specify when creating a FreeRTOS task?

easy

A. The total heap size available to the system

B. The number of tasks that can run simultaneously

C. The amount of memory allocated for the task's temporary data in words

D. The priority level of the task

Solution

1. Step 1: Understand stack size meaning in FreeRTOS

   The stack size defines how much memory a task can use for its temporary data and function calls.

2. Step 2: Identify the unit of stack size

   In FreeRTOS, stack size is given in words, not bytes, when creating a task.

3. Final Answer:

   The amount of memory allocated for the task's temporary data in words -> Option C

4. Quick Check:

   Stack size = task memory in words [OK]

Hint: Stack size means task memory in words, not bytes [OK]

Common Mistakes:

• Confusing stack size with heap size
• Thinking stack size is in bytes
• Mixing stack size with task priority

2. Which of the following is the correct way to specify stack size when creating a FreeRTOS task in C?

easy

A. xTaskCreate(taskFunction, "Task", 128 / sizeof(int), NULL, 1, NULL);

B. xTaskCreate(taskFunction, "Task", 128 * sizeof(char), NULL, 1, NULL);

C. xTaskCreate(taskFunction, "Task", 128 * sizeof(int), NULL, 1, NULL);

D. xTaskCreate(taskFunction, "Task", 128, NULL, 1, NULL);

Solution

1. Step 1: Recall stack size unit in FreeRTOS

   Stack size is specified in words, so just giving 128 means 128 words.

2. Step 2: Analyze each option

   xTaskCreate(taskFunction, "Task", 128, NULL, 1, NULL); uses 128 words directly, which is correct. xTaskCreate(taskFunction, "Task", 128 * sizeof(char), NULL, 1, NULL); and C multiply by size, which is incorrect. xTaskCreate(taskFunction, "Task", 128 / sizeof(int), NULL, 1, NULL); divides, which is also wrong.

3. Final Answer:

   xTaskCreate(taskFunction, "Task", 128, NULL, 1, NULL); -> Option D

4. Quick Check:

   Stack size = number of words, no sizeof needed [OK]

Hint: Use stack size as word count, no sizeof multiplication [OK]

Common Mistakes:

• Multiplying stack size by sizeof(int)
• Dividing stack size by sizeof(int)
• Confusing bytes and words in stack size

3. Given the code snippet:

void vTaskCode(void * pvParameters) {
    int x = 0;
    for(int i = 0; i < 10; i++) {
        x += i;
    }
    vTaskDelete(NULL);
}

xTaskCreate(vTaskCode, "Task1", 50, NULL, 2, NULL);

What is the minimum stack size allocation (in words) to safely run this task without overflow?

medium

A. 50 words

B. 10 words

C. 100 words

D. 5 words

Solution

1. Step 1: Analyze task stack usage

   The task uses a few local variables (x, i) and a small loop. This requires some stack but not very large.

2. Step 2: Check stack size given

   The task is created with 50 words stack size, which is enough for simple local variables and loop.

3. Final Answer:

   50 words -> Option A

4. Quick Check:

   Simple task needs moderate stack, 50 words is safe [OK]

Hint: Simple tasks need tens of words, not just a few [OK]

Common Mistakes:

• Assuming 10 words is enough for loop variables
• Overestimating stack need as 100 words
• Underestimating stack causing overflow

4. You have a FreeRTOS task created with stack size 20 words, but it crashes with stack overflow. What is the best fix?

medium

A. Decrease the stack size to save memory

B. Increase the stack size to a larger value like 100 words

C. Change the task priority to higher

D. Remove local variables from the task

Solution

1. Step 1: Identify cause of crash

   Stack overflow means the task's stack is too small for its needs.

2. Step 2: Choose appropriate fix

   Increasing stack size to a larger value like 100 words prevents overflow safely.

3. Final Answer:

   Increase the stack size to a larger value like 100 words -> Option B

4. Quick Check:

   Stack overflow fix = increase stack size [OK]

Hint: Stack overflow? Increase stack size [OK]

Common Mistakes:

• Reducing stack size to save memory
• Changing priority instead of stack size
• Ignoring local variables impact

5. You want to create two FreeRTOS tasks: Task A needs 80 words stack, Task B needs 40 words stack. The total heap is 100 words. How should you allocate stack sizes to avoid crashes and minimize wasted memory?

hard

A. Allocate 60 words to Task A and 40 words to Task B

B. Allocate 80 words to Task A and 40 words to Task B

C. Allocate 80 words to Task A and 20 words to Task B

D. Allocate 50 words to each task

Solution

1. Step 1: Understand total heap limit

   Total heap is 100 words, so sum of stack sizes must not exceed 100.

2. Step 2: Allocate stack sizes within limit

   Task A needs 80 words ideally, Task B needs 40 words, total 120 words which is over heap.

3. Step 3: Adjust allocation to fit heap

   Reduce Task A to 60 words and keep Task B at 40 words to fit 100 words total.

4. Final Answer:

   Allocate 60 words to Task A and 40 words to Task B -> Option A

5. Quick Check:

   Sum stack ≤ heap, adjust sizes accordingly [OK]

Hint: Sum stack sizes ≤ heap size to avoid crashes [OK]

Common Mistakes:

• Allocating more stack than heap allows
• Ignoring total heap limit
• Splitting stack sizes evenly without need