Locality-Aware Scheduling for Data-Intensive Distributed Systems

This direction is split into other directions: data-local computation. Its last version stays readable and citable here.

Version 1 of 1118 papers151 conceptsfrozen 2026-10-04

In the early days of distributed computing, the primary goal of a scheduler was simple: find an idle processor and give it work. This "compute-centric" approach assumed that the cost of moving data to a CPU was negligible compared to the computation itself. However, as datasets have scaled to petabytes and Large Language Model (LLM) contexts have grown to millions of tokens, the "data tax"—the latency, energy, and bandwidth cost of moving bits across a network—has become the dominant bottleneck.

Modern research has shifted toward Locality-Aware Scheduling. The core intuition is a reversal of the classical model: instead of moving data to the computation, we must move the computation to the data.

The Physics of Data Movement

The fundamental problem is that compute speeds have historically outpaced network and memory bandwidth. Didem Unat and colleagues note in Trends in Data Locality Abstractions for HPC Systems that in the exascale era, the energy cost of moving data across a system often exceeds the cost of the actual floating-point operations.

When a scheduler ignores where data lives, it triggers a "triangulation bottleneck." Adam Barker and Michael Luckeneder demonstrated in CloudForecast that even the placement of a "centralized brain" (the orchestrator) matters; if the controller is far from the data sources, execution times can skyrocket. By placing the orchestrator closer to the data-intensive nodes, they reduced execution times by 82%.

The Mechanism: Affinity over Load Balancing

Traditional schedulers prioritize load balancing—spreading work evenly to avoid hotspots. Locality-aware systems, however, often intentionally create "imbalance" to preserve data affinity.

  1. Sticky Routing: In LLM serving, Mingxing Zhang and the Mooncake team use a centralized scheduler to route requests to nodes that already contain the "KVCache" (intermediate states) for a specific prompt prefix. Reusing this cache is so much faster than recomputing it that it is better to wait for a "warm" node than to start immediately on a "cold" one.
  2. Expansion Factors: Not all data movement is equal. Abhishek Chandra and Benjamin Heintz identified the "expansion factor"—the ratio of intermediate data to input data—as a key scheduling metric. In Optimizing MapReduce for Highly Distributed Environments, they show that if a task generates massive intermediate results, it is more efficient to move the raw input to a node co-located with the next processing stage than to process it locally and shuffle the expanded results across a wide-area network.
  3. Bipartite Matching: To handle complex assignments, systems like TokenLake and Gaian (developed by Hexu Zhao et al.) treat scheduling as a linear sum assignment problem. They use algorithms like the Hungarian method to find the global optimum that minimizes the total "distance" between all active tasks and their required data segments.

Locality in Serverless and Edge Computing

The locality problem is particularly acute in "serverless" environments, where functions are ephemeral. Kostis Kaffes and Neeraja J. Yadwadkar argue in Hermes that the industry standard of random load balancing is sub-optimal. By tracking "warm" containers (infrastructure locality), their scheduler reduces function slowdown by 85%.

Similarly, in Mobile Edge Computing, Dezhong Yao and colleagues' EETS framework evaluates eight distinct combinations of where data resides (local device vs. cloud) to decide whether to offload a task. They highlight a common fallacy: assuming all data starts on the mobile device. If the data is already in the cloud, offloading the computation is a "win-win" that saves both time and battery.

The Future: Disaggregated Locality

As we move toward disaggregated architectures—where memory, compute, and storage are pooled separately—the definition of "local" is changing. Systems like MemServe by Cunchen Hu et al. use a global locality-aware scheduler to manage an elastic memory pool.

The intuition remains the same: the most efficient computation is the one that doesn't have to wait for the network. Whether it is Shaheen Ahmad’s 1987 work on robot control processors or Michael Luo’s 2025 Autellix engine for LLM agents, the path to performance lies in respecting the physical location of the data. By prioritizing data proximity over simple CPU availability, these systems transform the network from a bottleneck into a high-speed backbone for data-resident computation.

Papers in this version

Showing 60 of 118 papers.

History & citationVersion 1 · 2026-10-04

Split into other directions · Permanent link

View frozen version 1

Cite this direction

Latest version (a living page):

@misc{lacuna_locality_aware_scheduling_for_data_inten_3c3b1c54,
  title = {Locality-Aware Scheduling for Data-Intensive Distributed Systems},
  author = {{Lacuna}},
  howpublished = {Lacuna research direction},
  year = {2026},
  url = {https://lacuna.tiptreesystems.com/direction/locality-aware-scheduling-for-data-intensive-distributed-systems/rdr_3c3b1c54c34c440fbf188376c06acff3},
  note = {Latest version of a living research direction; cite a version for a fixed text. Accessed 2026-11-19},
}

This exact version (version 1, frozen text):

@misc{lacuna_locality_aware_scheduling_for_data_inten_3c3b1c54_v1,
  title = {Locality-Aware Scheduling for Data-Intensive Distributed Systems},
  author = {{Lacuna}},
  howpublished = {Lacuna research direction},
  year = {2026},
  url = {https://lacuna.tiptreesystems.com/direction/locality-aware-scheduling-for-data-intensive-distributed-systems/rdr_3c3b1c54c34c440fbf188376c06acff3/v/1},
  note = {Version 1, frozen 2026-10-04. Accessed 2026-11-19},
}