Spatial Locality

The most common manifestation of spatial locality. When a program or user accesses data item i, the probability of accessing item i+1 is extremely high.

• Video Streaming: Fetching video segment N strongly predicts a future request for segment N+1.
• Array Traversal: Iterating through a matrix row-by-row exhibits perfect spatial locality.
• Prefetching Trigger: This pattern allows hardware and software prefetchers to fetch the next cache line or data chunk before the explicit request arrives.

Modern memory hierarchies are built around the concept of fixed-size blocks called cache lines (typically 64 bytes). Spatial locality is the reason this design is efficient.

• Block Transfer: When a single byte is requested, the entire surrounding 64-byte block is loaded into the cache.
• Miss Minimization: A subsequent access to an adjacent byte results in a cache hit, avoiding a costly main memory or disk access.
• Edge Caching Analogy: In content delivery, this translates to pre-fetching a cluster of related web objects or video tiles rather than a single file.

A critical application of spatial locality in immersive media. Only the viewport—the specific spatial tiles a user is currently looking at—is streamed at high resolution.

• Viewport Prediction: Algorithms predict head movement to pre-fetch adjacent spatial tiles.
• Bandwidth Efficiency: Peripheral tiles are fetched at lower quality or not at all, reducing bandwidth by up to 80%.
• Stitching Logic: The system exploits the fact that tiles adjacent to the current viewport have a high probability of imminent display.

Central Processing Units (CPUs) rely heavily on spatial locality for instruction fetching. Code execution is rarely random; it proceeds sequentially through memory addresses.

• Branch Prediction: Even when a branch is taken, the target address often exhibits spatial locality relative to other code segments.
• Instruction Cache (I-Cache): Dedicated caches prefetch the next block of instructions during execution.
• Impact: Without spatial locality in instruction streams, modern superscalar processors would stall on every fetch, crippling performance.

While distinct, these two principles often work in concert. Temporal locality reuses the exact same data; spatial locality uses nearby data.

• Temporal: A loop counter accessed repeatedly.
• Spatial: The next element in an array processed by that loop.
• Combined Strategy: Effective caching algorithms like LRU-K track both recency (temporal) and adjacency (spatial) to optimize eviction and prefetching decisions.

Spatial locality is often poor in pointer-based structures like linked lists or graphs, leading to pointer chasing and cache thrashing.

• Memory Fragmentation: Nodes are scattered in heap memory, so traversing a pointer rarely hits the same cache line.
• Mitigation: Techniques like arena allocation or using flat arrays with indices instead of pointers force related nodes into contiguous memory blocks.
• Graph Neural Networks: GNNs processing large graphs must implement custom sampling and mini-batching to artificially induce spatial locality for GPU acceleration.

Streaming platforms exploit spatial locality by pre-fetching the next video segments in a sequence before the user requests them. When a user watches segment N, the client or edge cache automatically retrieves segments N+1, N+2, and N+3.

• DASH/HLS: Protocols divide video into sequential chunks, making spatial prefetching trivial.
• Adaptive Bitrate: The player adjusts which quality variant of the next segment to fetch based on current network conditions.
• Buffer Management: A playback buffer of 30-60 seconds is maintained by continuously fetching adjacent segments.

Immersive media uses viewport-adaptive streaming where only the spatial tiles within and immediately surrounding the user's current field of view are fetched at high resolution.

• Viewport Prediction: Algorithms forecast head movement to determine which adjacent tiles to prefetch.
• Quality Gradients: The directly viewed tile is highest quality; surrounding tiles are progressively lower resolution.
• Bandwidth Savings: Reduces data consumption by up to 80% compared to delivering the full 360° sphere.

Modern processors are the canonical example of spatial locality exploitation. When a CPU fetches an instruction from memory, it also retrieves a cache line of 64 bytes containing adjacent instructions.

• Cache Line Size: Typically 64 bytes, holding multiple sequential instructions.
• Branch Prediction: The prefetcher speculatively loads instructions from the predicted branch path.
• L1 Instruction Cache: A small, extremely fast memory directly on the CPU die stores these prefetched cache lines.

Social networks and e-commerce platforms model content as a graph where nodes are items and edges represent sequential access patterns. A user viewing item A triggers prefetch of its graph neighbors.

• Item-to-Item Collaborative Filtering: Amazon's classic algorithm identifies co-purchased products for prefetch.
• Session-Based Graphs: Short-term interaction sequences are modeled as directed graphs for next-click prediction.
• Graph Neural Networks: GNNs learn node embeddings that encode spatial relationships for more accurate prefetch decisions.

In cellular networks, spatial locality extends to geographic adjacency. A user moving through a cell trajectory will request content from sequentially adjacent base stations.

• Handover Prediction: RAN intelligence predicts the next cell a user will connect to.
• Proactive Content Placement: Content is pre-staged at the predicted target base station's MEC cache.
• Trajectory Modeling: Kalman filters and LSTMs model user paths to anticipate spatial content demand.