Cache (computing)
A cache is a fast storage layer that holds copies of data so future requests can be served without recomputing or refetching from a slower backing store, exploiting temporal and spatial locality. Hit rate, miss handling, and eviction policies such as LRU define its performance. Hardware caches include CPU L1/L2/L3 and the TLB; software caches include browsers, DNS, CDNs, and Redis. The hard problems are coherence and invalidation.
In computing, a cache is a hardware or software layer that stores copies of data so future requests for that data can be served faster than recomputing or refetching it from a slower backing store. Caches exploit two patterns observed in real workloads: temporal locality (recently accessed data is likely to be accessed again soon) and spatial locality (data near a recently accessed item is likely to be accessed next). Performance is measured by the hit rate — the fraction of requests satisfied from the cache. A cache hit returns data quickly; a cache miss forces a fetch from the backing store and typically inserts the new item into the cache. Because cache capacity is bounded, each miss may evict an existing entry. Common replacement policies include least recently used (LRU), least frequently used (LFU), first-in first-out, and randomised eviction; each trades implementation cost against accuracy of the future-access prediction. Hardware caches include CPU cache levels (L1, L2, L3) between processor cores and main memory, GPU texture caches, and the translation lookaside buffer that caches virtual-to-physical address mappings. Software caches are pervasive: browser caches for HTTP responses, DNS caches for name lookups, content delivery networks that cache assets at edge locations, database buffer pools, and application-level caches such as Redis or Memcached. Caches must address cache coherence (keeping multiple copies consistent) and cache invalidation (knowing when stored data has become stale) — Phil Karlton's quip that the two hardest problems in computer science are cache invalidation and naming things is a running joke in the field. Memoization is a specialised form of caching restricted to the results of pure function calls; general-purpose caches make no such assumption about their contents and must therefore design explicit invalidation and consistency strategies.