Temporal Locality

The core mechanism of temporal locality: data accessed once is highly likely to be accessed again in the near future. This principle is observed in user behavior patterns—a video segment just watched, a file just opened, or a database record just queried has a non-uniform probability of immediate reuse.

• Loop structures in code exhibit strong temporal locality, repeatedly accessing the same memory addresses.
• Session-based interactions create temporal clusters where a user revisits the same content within a short window.
• Exploited directly by LRU (Least Recently Used) and LRU-K cache eviction policies, which prioritize retaining recently touched items.

Temporal locality is often paired with, but distinct from, spatial locality. Temporal locality refers to the reuse of the exact same resource over time, while spatial locality refers to accessing resources nearby in address space.

• Temporal: Re-watching the same video segment.
• Spatial: Pre-fetching the next sequential video segment.
• Combined: Modern caching systems use both—temporal for retention policies and spatial for pre-fetching heuristics.
• The distinction is critical for tuning cache line sizes and pre-fetch depth in hardware and software caches.

Temporal locality manifests mathematically in Zipfian distributions, where a small fraction of content accounts for the majority of requests. The probability of accessing an item is inversely proportional to its rank.

• The Pareto principle applies: roughly 20% of content generates 80% of traffic.
• This skew enables small, well-managed caches to achieve disproportionately high hit ratios.
• Content popularity prediction models leverage this distribution to anticipate which items will exhibit strong temporal reuse.
• Deviations from Zipf's Law, such as flash crowds, require adaptive caching strategies.

Temporal locality directly informs the design of cache eviction policies—the algorithms that decide which items to discard when a cache is full. Policies that ignore recency suffer from poor hit ratios.

• LRU (Least Recently Used): Evicts the item with the oldest access timestamp, directly exploiting temporal locality.
• LRU-K: Tracks the timestamp of the K-th most recent access, distinguishing between frequently and infrequently used items.
• TTL-Based Invalidation: Assigns a time-to-live to cached objects, removing them when temporal relevance decays.
• ARC (Adaptive Replacement Cache): Dynamically balances between recency and frequency to adapt to changing access patterns.

The working set is the collection of data a process or user actively references within a specific time window. Temporal locality defines the boundaries of this set.

• Denning's Working Set Principle: A program must have its working set resident in memory to execute efficiently.
• In caching, the working set represents the minimum data that must be retained to maintain high hit ratios.
• Thrashing occurs when the cache is too small to hold the active working set, causing constant evictions and reloads.
• Working set size estimation is critical for cache dimensioning in edge nodes and CDN PoPs.

In mobile networks, temporal locality is complicated by user mobility. A user's temporal access pattern at one base station must be transferred or predicted at the next.

• Handover prediction combined with temporal locality enables proactive cache migration.
• Mobility-Aware Caching extends the temporal window across spatial boundaries, pre-placing content on target cells.
• Federated caching architectures share temporal access metadata across edge nodes to maintain continuity.
• The challenge is balancing the cost of cache relocation against the latency benefit of maintaining temporal locality across cell boundaries.

The principle that content physically or logically adjacent to a recently requested item is likely to be accessed soon. In video delivery, this manifests as segment prefetching—when a user requests the first 2-second chunk of a video, the next several chunks are preemptively cached. Spatial locality is the dominant principle behind instruction caching in CPUs and tile-based caching in 360-degree video streaming, where only the viewport tiles are fetched at high resolution.

An algorithm that determines which data to discard when a cache reaches capacity. While temporal locality suggests keeping recently-used items, eviction policies formalize this:

• LRU (Least Recently Used): Discards the item with the oldest access timestamp
• LRU-K: Considers the time of the last K references, filtering out one-hit wonders
• LFU (Least Frequently Used): Tracks access frequency rather than recency
• ARC (Adaptive Replacement Cache): Dynamically balances recency and frequency

A power-law probability distribution that models content popularity: the frequency of a request is inversely proportional to its rank. The most popular item is requested roughly twice as often as the second, three times as often as the third, and so on. This heavy-tailed distribution means a small fraction of content generates the majority of traffic, making proactive caching of the top-N items highly effective. Zipf's Law is the mathematical justification for why temporal locality produces measurable cache hit ratios.

The key performance indicator measuring the percentage of content requests successfully served from cache versus requiring origin server retrieval. A hit ratio of 95% means only 5% of requests traverse the backhaul. Temporal locality directly improves this metric—recently accessed items remain resident. In MEC caching scenarios, hit ratios above 90% are achievable for popular content catalogs. The metric is calculated as: hits / (hits + misses) over a measurement window.

A metric ensuring cached data remains consistent with the origin server. Temporal locality creates tension with freshness—keeping items longer improves hit ratios but risks serving stale data. Mechanisms include:

• TTL (Time-to-Live): Absolute expiration timestamp set by the origin
• Stale-While-Revalidate: Serve stale content immediately while asynchronously refreshing
• Conditional Requests: Using ETags or Last-Modified headers to validate freshness without full re-download

A proactive strategy that extends temporal locality across physical movement. By predicting a user's trajectory through handover prediction, content is pre-placed on the next base station before the user arrives. This transforms temporal locality from a single-node concept into a spatiotemporally distributed one. For users moving at vehicular speeds, mobility-aware caching can maintain hit ratios above 85% even during frequent cell transitions by pre-warming target caches.