parallel io optimization
**Parallel I/O Optimization** is the **set of techniques for efficiently reading and writing data across parallel file systems and storage devices in HPC and data-intensive computing**, ensuring that I/O bandwidth scales with compute resources rather than becoming the bottleneck — a challenge that gives rise to the aphorism "supercomputers don't compute, they wait for I/O."
Modern supercomputers can perform exaflops of computation but their storage systems provide only terabytes per second of I/O bandwidth. Applications that checkpoint, read datasets, or produce output must optimize I/O patterns to approach the storage system's peak capability.
**Parallel File Systems**:
| File System | Developer | Architecture | Scale |
|------------|----------|-------------|-------|
| **Lustre** | DDN/Community | Object-based (OST/MDT) | 100K+ clients |
| **GPFS/Spectrum Scale** | IBM | Block-based + metadata | 10K+ nodes |
| **BeeGFS** | ThinkParQ | User-space, RDMA | 1K+ nodes |
| **DAOS** | Intel | Key-value, NVM-optimized | Next-gen |
| **Ceph** | Red Hat | Object + block + file | Cloud/HPC |
**Stripe-Aware I/O**: Parallel file systems stripe files across multiple storage targets (OSTs in Lustre). A file with stripe count=8 and stripe size=1MB distributes data round-robin across 8 storage servers. Optimal I/O aligns access patterns with stripes: each MPI process reads/writes data from its own stripe target, avoiding contention. Stripe configuration (`lfs setstripe` in Lustre) should match the application's I/O pattern — wide striping for large files accessed by many processes, narrow striping for many small files.
**MPI-IO**: The MPI standard includes parallel I/O (MPI-IO, defined in MPI-2) with collective operations: `MPI_File_write_all()` coordinates all processes' writes into a single optimized I/O operation. Collective I/O dramatically outperforms independent I/O (each process writing separately) by: **request aggregation** (combining many small requests into large sequential writes), **two-phase I/O** (shuffle data between processes to align with file stripes before writing), and **data sieving** (reading a large contiguous block and extracting scattered portions).
**I/O Libraries and Middleware**: **HDF5** and **NetCDF** provide high-level parallel I/O with self-describing data formats. **ADIOS2** (Adaptable I/O System) provides a staging and aggregation layer between application and file system. **Burst buffers** (SSD-based intermediate storage like DataWarp) absorb I/O bursts at local speed, draining to the parallel file system asynchronously.
**I/O Patterns and Anti-Patterns**: **Good**: large, contiguous, aligned writes from many processes collectively; **Bad**: many small random reads from many processes independently (metadata overload + poor bandwidth). File-per-process output is simple but creates millions of files that overwhelm metadata servers — shared-file output with collective MPI-IO is preferred. Checkpoint optimization using asynchronous I/O or multi-level checkpointing (local SSD + parallel FS) hides I/O latency behind computation.
**Parallel I/O optimization bridges the fundamental performance gap between compute and storage — properly optimized I/O can achieve 80-90% of the storage system's peak bandwidth, while naive I/O patterns may achieve less than 1%, making I/O optimization one of the highest-leverage activities in large-scale parallel computing.**