I/O complexity and pebble games with partial computations

Optimizing data movements during program executions is essential for achieving high performance in modern computing systems. This has been classically modeled with the Red-Blue Pebble Game and its variants. In existing models, it is typically assumed that the number of red pebbles, i.e., the size of the fast memory, is larger than the maximum in-degree in the computational directed acyclic graph (DAG). Graphs that do not satisfy this constraint need to be first transformed appropriately, which is not a trivial task for general graphs. In this work we propose a Pebble Game variant to model DAGs with arbitrary in-degrees, by allowing partial computations. In the new model, we show that it is NP-complete to decide whether there exists an optimal pebbling strategy with cost $k$, even for single-level DAGs and when only two words fit in the fast memory. Approximation algorithms for special cases are also outlined.

💡 Research Summary

The paper tackles a fundamental limitation of the classic Red‑Blue Pebble Game (RBPG), which has been the standard model for analyzing I/O complexity—the assumption that the number of red pebbles (fast‑memory slots) must be at least one larger than the maximum in‑degree of the computation DAG. This assumption forces a preprocessing step that transforms any high‑in‑degree graph into an equivalent low‑in‑degree one. Such transformations are non‑trivial, often NP‑complete, and can dramatically increase the I/O cost, making the model unsuitable for many real‑world workloads (e.g., sparse matrix products, graph algorithms, large‑language‑model inference) that naturally exhibit large fan‑in.

To overcome this, the authors introduce a new pebble game that permits partial computations. In this variant, a node can be partially evaluated, turning its pebble from red (value matches main memory) to yellow (value has been modified but not yet stored). The game now uses four primitive operations:

• LOAD (cost 1) – places a red pebble on an empty node, bringing a word from main memory into cache.
• REMOVE (cost 0) – discards a red pebble from a node whose value has not been altered.
• COMPUTE (cost 0) – when two predecessor nodes each hold a pebble (red or yellow) and one predecessor is a leaf, the operation creates a yellow pebble on the target node and deletes the corresponding edge, representing a partial result.
• STORE (cost 1) – converts a yellow pebble back to red and writes the updated value to main memory (a blue pebble is placed there).

The game starts with an empty board and ends when all edges have been deleted and the output nodes are pebble‑free. The total cost is simply the number of LOAD and STORE actions.

The central theoretical contribution is a hardness proof: deciding whether there exists a pebbling strategy of cost at most k is NP‑complete, even for single‑level DAGs (all computation nodes are directly connected to the inputs) and with M = 2 (the fast memory can hold only two words). The reduction is from Hamiltonian Path. For each vertex of the original undirected graph a “gadget” is built: a bipartite sub‑graph with n inputs (one per original vertex) and a single output. Edges between gadgets are merged according to the adjacency in the original graph, creating shared input nodes. The authors show that eliminating a gadget costs n + 2 moves; eliminating two adjacent gadgets can be done in 2n + 3 moves, whereas non‑adjacent gadgets require at least 2n + 4 moves. Consequently, a strategy of total cost n² + n + 1 exists if and only if the original graph contains a Hamiltonian path. This establishes NP‑hardness, while membership in NP follows from the fact that any strategy longer than one zero‑cost move must incur cost 1 per subsequent move, allowing polynomial verification.

Beyond hardness, the paper proposes approximation algorithms for the special case of single‑level DAGs, which capture many important kernels such as sparse matrix multiplication. For M = 2 they achieve a 21/8‑approximation (≈2.625) and improve to 8/7‑approximation (≈1.143) when the machine can perform a LOAD and a STORE simultaneously in a single step. These are the first constant‑factor approximation guarantees reported for any I/O‑oriented pebble game, even in the restricted single‑level setting.

The authors also discuss two minor modeling limitations: (1) intermediate results must eventually be stored back to main memory (no “on‑the‑fly” consumption), and (2) the current analysis assumes a static cache‑line model (each node occupies a fixed location). Both can be relaxed with modest rule changes, but they do not affect the core results.

In summary, the paper makes three major contributions:

1. A new pebble game that naturally handles arbitrary fan‑in without graph transformation, by allowing partial results to be kept in cache as yellow pebbles.
2. Complexity analysis proving NP‑completeness of the optimal‑cost decision problem even under severe resource constraints (M = 2, single‑level DAG).
3. Algorithmic results delivering the first constant‑factor approximation algorithms for I/O‑aware pebble games, with explicit bounds for the practically relevant case of two‑word fast memory.

These results broaden the theoretical toolkit for I/O complexity, making it applicable to modern high‑performance computing workloads where large fan‑in operations are common. Future work may extend the model to multi‑level memory hierarchies, parallel processors, or relax the requirement that every intermediate value be stored, thereby bringing the theory even closer to real‑world execution environments.