Double buffer technique in Embedded C - Time & Space Complexity
We want to see how the time needed changes when using the double buffer technique in embedded C.
How does the program's work grow as the data size grows when switching buffers?
Analyze the time complexity of the following code snippet.
#define BUFFER_SIZE 256
uint8_t buffer1[BUFFER_SIZE];
uint8_t buffer2[BUFFER_SIZE];
uint8_t* currentBuffer = buffer1;
void processData() {
for (int i = 0; i < BUFFER_SIZE; i++) {
currentBuffer[i] = readSensor();
}
// Swap buffers
currentBuffer = (currentBuffer == buffer1) ? buffer2 : buffer1;
}
This code reads sensor data into one buffer, then switches to the other buffer for the next read.
Identify the loops, recursion, array traversals that repeat.
- Primary operation: The for-loop that fills the buffer by reading sensor data.
- How many times: It runs once per call, iterating BUFFER_SIZE times.
As the buffer size grows, the number of sensor reads and writes grows directly with it.
| Input Size (BUFFER_SIZE) | Approx. Operations |
|---|---|
| 10 | 10 sensor reads and writes |
| 100 | 100 sensor reads and writes |
| 1000 | 1000 sensor reads and writes |
Pattern observation: The work grows linearly as the buffer size increases.
Time Complexity: O(n)
This means the time to fill the buffer grows directly with the buffer size.
[X] Wrong: "Switching buffers makes the program twice as fast or slower."
[OK] Correct: The buffer switch is just a pointer change and very fast; the main time is spent reading data, which depends on buffer size.
Understanding how buffer size affects processing time helps you explain performance in embedded systems clearly and confidently.
"What if we added a nested loop to process each buffer element multiple times? How would the time complexity change?"