Ring buffer implementation in Embedded C - Step-by-Step Execution

Concept Flow - Ring buffer implementation

Start

↓

Check if buffer full?

Yes→Wait or overwrite

No↓

Write data at tail

↓

Move tail forward

↓

Check if buffer empty?

Yes→No data to read

No↓

Read data at head

↓

Move head forward

↓

Repeat or Stop

The ring buffer moves head and tail pointers to write and read data in a circular way, checking for full or empty conditions.

Execution Sample

Embedded C

char buffer[4];
int head=0, tail=0;
// Write 'A'
buffer[tail] = 'A';
tail = (tail + 1) % 4;

This code writes a character 'A' into the buffer at the tail position and moves the tail pointer forward circularly.

Execution Table

Step	Action	Head	Tail	Buffer State	Condition	Result
1	Initialize head and tail	0	0	['', '', '', '']	N/A	Start with empty buffer
2	Write 'A' at tail	0	0	['A', '', '', '']	Buffer full? No	Write allowed
3	Move tail forward	0	1	['A', '', '', '']	N/A	Tail updated
4	Write 'B' at tail	0	1	['A', 'B', '', '']	Buffer full? No	Write allowed
5	Move tail forward	0	2	['A', 'B', '', '']	N/A	Tail updated
6	Read data at head	0	2	['A', 'B', '', '']	Buffer empty? No	Read 'A'
7	Move head forward	1	2	['A', 'B', '', '']	N/A	Head updated
8	Write 'C' at tail	1	2	['A', 'B', 'C', '']	Buffer full? No	Write allowed
9	Move tail forward	1	3	['A', 'B', 'C', '']	N/A	Tail updated
10	Write 'D' at tail	1	3	['A', 'B', 'C', '']	Buffer full? Yes	Cannot write or overwrite
11	Read data at head	1	3	['A', 'B', 'C', '']	Buffer empty? No	Read 'B'
12	Move head forward	2	3	['A', 'B', 'C', '']	N/A	Head updated
13	Write 'D' at tail	2	3	['A', 'B', 'C', 'D']	Buffer full? No	Write allowed
14	Move tail forward	2	0	['A', 'B', 'C', 'D']	N/A	Tail wrapped to 0
15	Read data at head	2	0	['A', 'B', 'C', 'D']	Buffer empty? No	Read 'C'
16	Move head forward	3	0	['A', 'B', 'C', 'D']	N/A	Head updated
17	Read data at head	3	0	['A', 'B', 'C', 'D']	Buffer empty? No	Read 'D'
18	Move head forward	0	0	['A', 'B', 'C', 'D']	N/A	Head wrapped to 0
19	Buffer empty check	0	0	['A', 'B', 'C', 'D']	Head == Tail	Buffer empty now
20	Stop	0	0	['A', 'B', 'C', 'D']	N/A	No more data to read

💡 Execution stops when head equals tail, meaning buffer is empty.

Variable Tracker

Variable	Start	After Step 3	After Step 5	After Step 7	After Step 9	After Step 12	After Step 14	After Step 16	After Step 18	Final
head	0	0	0	1	1	2	2	3	0	0
tail	0	1	2	2	3	3	0	0	0	0
buffer	['', '', '', '']	['A', '', '', '']	['A', 'B', '', '']	['A', 'B', '', '']	['A', 'B', 'C', '']	['A', 'B', 'C', '']	['A', 'B', 'C', 'D']	['A', 'B', 'C', 'D']	['A', 'B', 'C', 'D']	['A', 'B', 'C', 'D']

Key Moments - 3 Insights

Why does the tail wrap back to 0 after reaching the buffer size?

Because the tail uses modulo operation with buffer size (tail = (tail + 1) % size), it wraps around to start to keep the buffer circular, as shown in step 14.

What happens when the buffer is full and we try to write more data?

The write is blocked or handled specially because tail + 1 would equal head, indicating full buffer (step 10). This prevents overwriting unread data.

How do we know when the buffer is empty?

When head equals tail, no unread data remains (step 19). This condition signals the buffer is empty.

Visual Quiz - 3 Questions

Look at the execution table at step 14, what is the value of tail?

A 4

B 3

C 0

D 2

💡 Hint

Check the 'Tail' column at step 14 in the execution_table.

At which step does the buffer become empty again?

A Step 10

B Step 19

C Step 7

D Step 3

💡 Hint

Look for the step where head equals tail in the execution_table.

If we increase buffer size to 5, how would step 10 change?

A Buffer would not be full, write allowed

B Buffer would still be full at step 10

C Head would move instead of tail

D Tail would not wrap

💡 Hint

Consider buffer full condition depends on buffer size and tail position in execution_table.

Concept Snapshot

Ring buffer stores data in a fixed-size array.
Use head and tail pointers to track read/write positions.
Tail moves forward on write; head moves forward on read.
Pointers wrap around using modulo to stay within buffer size.
Buffer full when (tail + 1) % size == head.
Buffer empty when head == tail.

Full Transcript

A ring buffer uses two pointers, head and tail, to manage data in a circular array. Writing data places it at the tail position and moves tail forward. Reading data takes from head and moves head forward. Both pointers wrap around to the start when reaching the buffer's end. The buffer is full when moving tail forward would collide with head, and empty when head equals tail. This trace shows writing and reading characters, pointer updates, and buffer full/empty checks step-by-step.

Practice

1.

What is the main purpose of the head pointer in a ring buffer?

easy

A. To reset the buffer to empty

B. To indicate where data will be read next

C. To store the total size of the buffer

D. To indicate where new data will be written next

Solution

1. Step 1: Understand the role of head in ring buffer

   The head pointer marks the position where the next data element will be stored (written) in the buffer.

2. Step 2: Differentiate head from tail

   The tail pointer is used for reading data, while the head is for writing new data.

3. Final Answer:

   To indicate where new data will be written next -> Option D

4. Quick Check:

   Head = write position [OK]

Hint: Head points to write location, tail points to read location [OK]

Common Mistakes:

• Confusing head with tail pointer
• Thinking head stores buffer size
• Assuming head resets the buffer

2.

Which of the following is the correct way to advance the head pointer in a ring buffer of size BUFFER_SIZE after writing one element?

head = ?;

easy

A. head = BUFFER_SIZE - head;

B. head = head + 1;

C. head = (head + 1) % BUFFER_SIZE;

D. head = (head - 1) % BUFFER_SIZE;

Solution

1. Step 1: Understand circular increment

   To move head forward in a circular buffer, increment and wrap around using modulo with buffer size.

2. Step 2: Apply modulo operation

   The expression (head + 1) % BUFFER_SIZE ensures head wraps to 0 after reaching the end.

3. Final Answer:

   head = (head + 1) % BUFFER_SIZE; -> Option C

4. Quick Check:

   Use modulo to wrap index [OK]

Hint: Use modulo (%) to wrap pointer in ring buffer [OK]

Common Mistakes:

• Not using modulo causes overflow
• Subtracting instead of adding
• Incorrect wrap calculation

3.

Given this code snippet for a ring buffer of size 4, what will be the value of head and tail after these operations?

int head = 0, tail = 0;
int BUFFER_SIZE = 4;

// Write 3 elements
for (int i = 0; i < 3; i++) {
    head = (head + 1) % BUFFER_SIZE;
}

// Read 1 element
tail = (tail + 1) % BUFFER_SIZE;

medium

A. head = 3, tail = 0

B. head = 3, tail = 1

C. head = 2, tail = 1

D. head = 1, tail = 1

Solution

1. Step 1: Calculate head after writing 3 elements

   Starting at 0, head increments 3 times with modulo 4: head = (0+1)%4=1, then 2, then 3.

2. Step 2: Calculate tail after reading 1 element

   Tail starts at 0, increments once: tail = (0+1)%4=1.

3. Final Answer:

   head = 3, tail = 1 -> Option B

4. Quick Check:

   Head=3, Tail=1 after ops [OK]

Hint: Increment pointers with modulo for each operation [OK]

Common Mistakes:

• Forgetting modulo wrap
• Mixing head and tail values
• Counting increments incorrectly

4.

Identify the bug in this ring buffer write function and select the correct fix:

void write(int data) {
    if ((head + 1) == tail) {
        // Buffer full
        return;
    }
    buffer[head] = data;
    head = (head + 1) % BUFFER_SIZE;
}

medium

A. Change condition to ((head + 1) % BUFFER_SIZE) == tail

B. Remove the condition; buffer never gets full

C. Increment tail instead of head after write

D. Use head == tail to check full buffer

Solution

1. Step 1: Analyze buffer full condition

   The buffer is full when the next head position wraps to tail, so modulo is needed to wrap index.

2. Step 2: Correct condition with modulo

   Using ((head + 1) % BUFFER_SIZE) == tail correctly detects full buffer.

3. Final Answer:

   Change condition to ((head + 1) % BUFFER_SIZE) == tail -> Option A

4. Quick Check:

   Modulo needed for circular check [OK]

Hint: Always use modulo when comparing circular indices [OK]

Common Mistakes:

• Missing modulo causes wrong full detection
• Confusing head and tail roles
• Incorrectly incrementing tail on write

5.

You want to implement a ring buffer that stores bytes and can hold exactly 8 bytes. Which of these buffer sizes and pointer update methods correctly avoids ambiguity between full and empty states?

Options:

1. Buffer size = 8, full when (head + 1) % 8 == tail
2. Buffer size = 9, full when (head + 1) % 9 == tail
3. Buffer size = 8, full when head == tail
4. Buffer size = 9, full when head == tail

hard

A. Use buffer size 9 with full condition (head + 1) % 9 == tail

B. Use buffer size 8 with full condition (head + 1) % 8 == tail

C. Use buffer size 8 with full condition head == tail

D. Use buffer size 9 with full condition head == tail

Solution

1. Step 1: Understand full vs empty ambiguity

   When head == tail, buffer is empty. To distinguish full, buffer size is often set to capacity + 1.

2. Step 2: Choose buffer size and condition

   Using buffer size 9 for 8 bytes capacity and full condition (head + 1) % 9 == tail avoids ambiguity.

3. Final Answer:

   Use buffer size 9 with full condition (head + 1) % 9 == tail -> Option A

4. Quick Check:

   Extra slot avoids full/empty confusion [OK]

Hint: Use buffer size one more than capacity to avoid confusion [OK]

Common Mistakes:

• Using buffer size equal to capacity causes ambiguity
• Checking full with head == tail
• Not reserving one slot for full detection