Show understanding of the use of buffers

3.1 Computers and Their Components – Buffers

1. Definition and purpose (AO1)

A buffer is a temporary storage area – usually a block of RAM – that holds data while it is being transferred between a producer (e.g., a peripheral) and a consumer (e.g., the CPU). By decoupling the two sides, a buffer:

• prevents loss of data when the producer is faster than the consumer,
• maintains data integrity by ensuring that each datum is delivered in the correct order, and
• provides a point at which safety checks (bounds‑checking, canaries, etc.) can be applied, supporting system security.

2. Why buffers are needed (AO1)

• Rate mismatch: the producer may generate data faster or slower than the consumer can handle.
• Timing differences: devices often operate asynchronously; a buffer removes the need for exact synchronisation.
• Reduced CPU overhead: the CPU can read or write larger blocks instead of handling each byte individually.
• Improved throughput: continuous streaming is possible even when one side pauses briefly.
• Data‑integrity protection: buffering gives the system time to perform error‑checking and security checks before data are used.

3. Interaction with CPU, bus and system software (AO2)

Buffers are not only a software concept. In a typical computer they sit on the address/data bus between a peripheral’s registers and main memory.

• Hardware buffer (FIFO) inside the peripheral: data are written to the buffer at the peripheral’s clock speed.
• CPU access: the CPU reads or writes the buffered data via the bus, usually in larger blocks.
• DMA (Direct Memory Access): a DMA controller can move data directly between the peripheral buffer and RAM without CPU intervention, further decoupling the two clocks.
• System‑software link: compilers and language translators generate code that uses these buffers (e.g., standard library I/O functions that employ file‑I/O buffers).

4. Types of buffers (AO1)

5. Numerical example – rate mismatch (AO2)

Consider a 4‑byte FIFO input buffer. The peripheral produces a byte every 2 ms, while the CPU reads one byte every 5 ms.

1. Time 0 ms – buffer empty, peripheral writes byte A (buffer: A).
2. Time 2 ms – peripheral writes byte B (buffer: A, B).
3. Time 4 ms – peripheral writes byte C (buffer: A, B, C).
4. Time 5 ms – CPU reads byte A (buffer: B, C).
5. Time 6 ms – peripheral writes byte D (buffer: B, C, D).
6. Time 8 ms – peripheral attempts to write byte E; buffer is full (4 bytes). Overflow occurs – the byte is discarded or the peripheral must wait.

This simple timeline shows how overflow can arise when the producer’s rate exceeds the consumer’s average rate.

6. Real‑world examples (AO1)

• Keyboard input buffer: stores keystrokes until the OS processes them.
• Graphics double buffer: one frame is drawn while the previous frame is being sent to the monitor.
• Audio circular buffer: continuous sound data are streamed from a microphone to the DAC.
• Network card buffer: holds incoming packets before the protocol stack processes them.
• File‑I/O buffer: standard library functions (e.g., fread, fwrite) read/write blocks of data to minimise disk‑access latency.

7. Buffer operation – pseudocode (AO3)

Cambridge‑style FIFO implementation (size = 8 bytes). The code follows the pseudocode conventions used in the syllabus (e.g., ENDIF, ENDWHILE).

CONST SIZE = 8
ARRAY BYTE buffer[SIZE]
INTEGER head = 0          // index of next byte to read
INTEGER tail = 0          // index of next free slot
INTEGER count = 0         // number of bytes currently stored
PROCEDURE enqueue(BYTE data) RETURNS BOOLEAN
IF count = SIZE THEN          // buffer full → overflow
RETURN FALSE              // reject the byte
ENDIF
buffer[tail] := data
tail := (tail + 1) MOD SIZE
count := count + 1
RETURN TRUE
ENDPROCEDURE
PROCEDURE dequeue() RETURNS (BOOLEAN, BYTE)
IF count = 0 THEN             // buffer empty → underflow
RETURN (FALSE, 0)
ENDIF
BYTE data := buffer[head]
head := (head + 1) MOD SIZE
count := count - 1
RETURN (TRUE, data)
ENDPROCEDURE

8. Overflow, underflow and security (AO1‑AO3)

• Buffer overflow: producer writes when the buffer is full. Consequences include data loss, program crashes, and security vulnerabilities (e.g., arbitrary code execution).
• Buffer underflow: consumer reads when the buffer is empty, causing idle CPU cycles or erroneous data use.
• Security mitigation techniques:

  • Bounds‑checking before every read/write operation.
  • Use of safe library functions (e.g., strncpy instead of strcpy).
  • Stack canaries or guard values placed after buffers.
  • Language‑level safety (e.g., Java, Rust) that prevents unchecked memory writes.

9. Common issues (AO1)

• Overflow: data arriving faster than it can be removed – leads to loss or corruption.
• Underflow: consumer empties the buffer faster than producer fills it – causes idle time or use of stale data.
• Latency: data may be delayed while waiting in the buffer – problematic for hard real‑time systems.

10. Exam‑style questions (AO1‑AO3)

Q1 (extended response, 6 marks): A peripheral writes data to a 16‑byte input buffer. Explain what happens when the buffer is already full and the peripheral attempts to write another byte. In your answer, mention at least two possible consequences for the system.

Suggested points for full credit:

• The write is rejected; the peripheral must either block (wait) or discard the byte (non‑blocking I/O).
• If discarded, data loss occurs; if the system later reads beyond the buffer’s limits, a buffer overflow can corrupt memory, leading to crashes or security exploits.
• System‑level impact – reduced reliability, possible deadlock if the CPU waits for data that will never arrive, or a security breach if malicious data overwrite adjacent memory.

Q2 (short answer, 4 marks): List three different types of buffers covered in the syllabus and give one practical example for each.

Answer outline:

• Input buffer – keyboard keystrokes.
• Double (ping‑pong) buffer – graphics frame rendering.
• Circular buffer – real‑time audio capture.

Q3 (pseudocode, 6 marks): Write Cambridge‑style pseudocode for a routine that removes (dequeues) a byte from a circular buffer and returns a Boolean indicating success. Include comments that show how overflow/underflow is prevented.

Full‑credit answer (excerpt):

PROCEDURE dequeue() RETURNS (BOOLEAN, BYTE)
IF count = 0 THEN                 // underflow – buffer empty
RETURN (FALSE, 0)
ENDIF
BYTE data := buffer[head]         // read oldest byte
head := (head + 1) MOD SIZE       // advance read pointer
count := count - 1                // one less byte stored
RETURN (TRUE, data)               // successful read
ENDPROCEDURE

11. Key take‑aways (AO1)

• Buffers decouple producer and consumer speeds, preserving data integrity and improving throughput.
• Both software (FIFO queues, file‑I/O buffers) and hardware (DMA, cache‑line buffers) are covered by the syllabus.
• Remember the core terminology: FIFO, overflow, underflow, latency, blocking/non‑blocking I/O, and the security implications of buffer overflow.
• When answering exam questions, state the purpose of the buffer, identify its type, describe what happens on overflow/underflow, and mention at least one mitigation or consequence.