03 Buffered IO

Buffered I/O

The filesystem storage architecture relies on the block as its fundamental unit of addressing. Consequently, hardware and operating system kernels execute all I/O operations in integer multiples of this block size. Applications naturally operate on varying, non-block-aligned abstractions like single characters, arbitrary strings, or specific data structures. Issuing direct system calls for these unaligned or sub-block operations forces the kernel to perform inefficient fix-up routines—reading full blocks, modifying small segments, and rewriting the entire block—severely degrading performance.

User-buffered I/O bridges this gap by allocating a buffer within the program’s user-space memory. As an application executes small read or write requests, data is staged in this buffer until it reaches the optimal block size, at which point a single, aligned I/O system call is dispatched to the kernel. This strategy drastically reduces system call overhead and aligns all hardware transactions to physical boundaries.

To provide a standardized implementation of user-buffered I/O, the C standard library includes the Standard I/O (stdio) subsystem.

Standard I/O Fundamentals

Standard I/O isolates the application from raw integer file descriptors, operating instead on a data structure known as a file pointer, defined as FILE *. An open file managed via a file pointer is referred to as a stream.

• Opening Streams: fopen(const char *path, const char *mode) initializes a stream and associates it with a file path.
  • r: Read-only, positioned at file start.
  • r+: Read/write, positioned at file start.
  • w: Write-only, truncates existing files to zero length or creates new ones.
  • w+: Read/write, truncates or creates.
  • a: Write/append, positioned at file end. All writes append regardless of seek operations.
  • a+: Read/append, positioned at file end.
• Descriptor Conversion: fdopen(int fd, const char *mode) maps a pre-existing integer file descriptor to a new stream, requiring a mode compatible with the descriptor’s original access rights.
• Closing Streams: fclose(FILE *stream) flushes any unwritten buffered data to the kernel and closes the underlying file descriptor. fcloseall() aggressively flushes and closes all process streams, including stdin, stdout, and stderr.

With a stream properly initialized and assigned an access mode, the application can extract or insert data using a variety of boundary paradigms.

Stream Data Operations

Standard I/O provides granular interfaces for moving data into and out of the user-space buffer, depending on the application’s data abstraction.

• Character-Level I/O:
  • fgetc(FILE *stream) retrieves the next byte from an input stream. It returns the value as an unsigned char cast to an int, enabling the caller to distinguish valid data from EOF or error conditions.
  • ungetc(int c, FILE *stream) pushes a character back into the stream’s buffer in LIFO (last in, first out) order, allowing the application to “peek” at data.
  • fputc(int c, FILE *stream) writes a single byte to an output stream.
• Line and String I/O:
  • fgets(char *str, int size, FILE *stream) extracts up to size - 1 bytes into a buffer. Extraction halts upon encountering a newline (which is retained) or EOF, and the resulting string is null-terminated.
  • fputs(const char *str, FILE *stream) inserts a null-terminated string directly into an output stream.
• Binary and Structure I/O:
  • fread(void *buf, size_t size, size_t nr, FILE *stream) extracts nr discrete elements, each of size bytes, into the target buffer.
  • fwrite(void *buf, size_t size, size_t nr, FILE *stream) pushes binary data structures from memory into the stream.
  • Hardware Alignment Dependency: Binary I/O demands strict adherence to architecture-specific data alignment rules. Memory must be accessed along granular boundaries (e.g., 4-byte or 8-byte intervals) depending on the type size; unaligned binary access can trigger hardware exceptions (like SIGBUS) or silent bit corruption.

Navigating through files containing complex or non-linear data structures requires specialized interfaces to manipulate the stream’s internal position indicator.

Stream Positioning and State Management

Standard I/O manages an internal logical cursor for each stream, which can be queried and modified to execute random access read and write patterns.

• Position Manipulation:
  • fseek(FILE *stream, long offset, int whence) modifies the file position indicator. The whence parameter anchors the movement to SEEK_SET (absolute start), SEEK_CUR (relative to current position), or SEEK_END (relative to file termination). Executing fseek() clears the EOF indicator and nullifies any characters pushed back via ungetc().
  • rewind(FILE *stream) is a strict wrapper equivalent to fseek(stream, 0, SEEK_SET) that also clears the stream’s error indicators.
  • fsetpos() and fgetpos() handle arbitrary position states using the opaque fpos_t type, designed for non-Unix architectures where the long type is insufficient for file offsets.
• Position and State Retrieval:
  • ftell(FILE *stream) outputs the current numerical offset of the stream’s position indicator.
  • ferror(FILE *stream) evaluates the stream’s error indicator, returning nonzero if an error condition has occurred.
  • feof(FILE *stream) evaluates the EOF indicator, returning nonzero if the stream has reached the end of the file.
  • clearerr(FILE *stream) manually resets both the error and EOF indicators.
• Underlying Descriptors: fileno(FILE *stream) extracts the raw integer file descriptor backing the stream. Mixing stream operations and raw file descriptor operations causes data corruption unless the stream is explicitly flushed prior to the raw system call.

The core performance advantage of Standard I/O relies on managing when and how this data transitions between the user-space buffer and the underlying kernel file descriptor.

Buffer Control and Flushing

Standard I/O delegates I/O scheduling to configurable buffer paradigms, allowing applications to dictate the synchronization between the user-space buffer and the kernel.

• Explicit Flushing: fflush(FILE *stream) forces all unwritten, user-buffered data into the kernel. This operation bridges user space and kernel space but does not synchronize the data to the physical storage medium. To guarantee physical disk commitment, an application must follow fflush() with an fsync() operation on the underlying file descriptor.
• Buffer Modes: The setvbuf(FILE *stream, char *buf, int mode, size_t size) function overrides the default buffering behavior for a stream, provided it is executed before any other data operations occur on that stream.
  • _IONBF (Unbuffered): User-buffering is disabled, and data is submitted directly to the kernel. This is the default configuration for standard error (stderr).
  • _IOLBF (Line-buffered): The buffer submits its contents to the kernel every time a newline character is encountered. This is the default configuration for terminals and standard out (stdout).
  • _IOFBF (Block-buffered): The buffer submits to the kernel only when completely filled. This is the default configuration for file streams.

Managing these buffers safely in a concurrent, multi-threaded environment requires robust synchronization mechanisms to prevent race conditions.

Thread Safety and Concurrency

Standard I/O incorporates native mutual exclusion mechanisms to maintain data integrity when streams are accessed across multiple threads.

• Implicit Thread Safety: Standard I/O functions are inherently thread-safe. The C library associates a lock, a lock count, and an owning thread context with every active stream. Individual Standard I/O operations (e.g., a single fputs() or fread() invocation) automatically acquire and release this lock, ensuring atomic execution at the function level.
• Manual Stream Locking: When a critical region spans multiple Standard I/O operations, implicit locking is insufficient.
  • flockfile(FILE *stream) blocks the execution thread until the stream’s lock is available, acquires it, increments the lock count, and assigns thread ownership.
  • funlockfile(FILE *stream) decrements the lock count, releasing the stream to other threads once the count hits zero.
  • ftrylockfile(FILE *stream) provides a non-blocking locking attempt, returning a nonzero value immediately if another thread already holds the lock.
• Unlocked Operations: When manual locking wraps a critical region, the internal implicit locks of standard I/O functions become redundant overhead. Functions suffixed with _unlocked (e.g., fgetc_unlocked(), fwrite_unlocked()) bypass internal lock acquisition. These variants strictly optimize performance but demand that the developer manually enforce thread synchronization, or guarantee thread confinement where a stream is strictly isolated to a single thread.

While thread-safe and highly optimized for block alignment, the user-space buffering architecture of Standard I/O introduces specific systemic trade-offs regarding memory and system calls.

Critiques of Standard I/O

The primary architectural flaw of Standard I/O is the double-copy penalty. Because the Standard I/O library acts as an intermediary memory staging ground, data in transit must be copied twice across different memory boundaries.

• Read Penalty: Data is copied from kernel space into the Standard I/O user buffer, and then copied a second time from the Standard I/O buffer into the application’s target memory buffer.
• Write Penalty: Data is copied from the application’s memory into the Standard I/O user buffer, and then copied again via write() into kernel space.

High-performance applications mitigate this architectural constraint by implementing custom user-buffering. Custom read implementations return pointers directly addressing the buffer (bypassing the application copy phase), and custom write implementations track memory addresses to submit directly to the kernel via scatter/gather I/O (e.g., writev()), condensing multiple disjoint application buffers into a single system call without an intermediary staging buffer.