2.5.1. Temporal Locality

Principle of the locality of reference is based on the fact that programs tend to access data and instructions in clusters, in the vicinity at a given memory location. Programs access a small portion of memory at a given time. Why? Because programs typically contain a large number of loops and subroutines, and within a loop, a small set of instructions is repeatedly accessed. These instructions again tend to access data in clusters.

The principle of locality of reference suggests that when a program operates, it doesn’t typically access memory randomly. Instead, it tends to focus on specific memory locations or small ranges of memory. This behavior is largely due to the structure of programs, which often contain loops and routines that repeatedly access a limited set of instructions and the data they work with. Thus, instead of scattering memory accesses all over, programs are more concentrated, allowing for optimization in accessing memory.

Imagine you are reading a book. You don’t jump around to random pages; instead, you read a section at a time, flipping through a few adjacent pages. Similarly, a computer program reads a small section of memory repeatedly, especially if it involves loops, just like you repeatedly return to the same pages for understanding.

Temporal locality which says that items accessed recently are likely to be accessed again. For example, the instructions within a loop. So, if the instructions within one iteration of the loop will be accessed again in the next iteration of the loop.

Temporal locality emphasizes that if a piece of data or instruction is accessed now, it's highly likely that it will be accessed again soon. For example, when a loop is executed, the same instructions are run multiple times, which creates a high chance of re-accessing the same memory locations. This predictability allows systems to optimize data storage and retrieval, especially in cache memory, by keeping frequently accessed items close at hand.

Think of recalling a phone number that you have dialed a few times recently. You are more likely to remember that number or have it stored in your recent calls list. Just like that, the system anticipates that if you needed that number once, you might need it again soon.

Spatial locality in items near those accessed recently are likely to be accessed soon; for example, sequential access of data from an array. So, if you have a big array, we tend to access data one by one from the array in sequence.

Spatial locality refers to the tendency for programs to access data that are located close to each other in memory. For instance, when processing an array, a program might read data sequentially, moving through adjacent memory locations. This behavior can be exploited by memory systems, which can prefetch data that are likely to be needed soon based on recent accesses. Thus, storing nearby data together can significantly improve access times.

Picture a librarian fetching books from shelves. If a librarian just retrieved a book on a topic, they are likely to pick up nearby books on similar subjects. Likewise, when a program accesses one piece of data in an array, it’s probable it will need the next few pieces right after it.

So, how does this locality principle help to maintain this hierarchical memory organization? The principle of locality makes hierarchical organization of memory possible. For example, we can store everything in the magnetic disk and then we copy recently accessed and nearby data in a small DRAM memory or the main memory.

The principle of locality suggests that a hierarchical memory structure is efficient. By keeping the most frequently accessed data in the fastest memory (like cache or DRAM), and using slower but larger memory (like magnetic disks) for less frequently accessed data, the system ensures quick access to commonly used instructions and data. Thus, locality allows systems to operate efficiently by maximizing speed while minimizing cost.

Consider how a chef organizes their kitchen. They keep utensils and ingredients that they use frequently within arm's reach (like a countertop), while less-used items are stored away in cabinets. This organization speeds up cooking without clutter, similar to how hierarchical memory works to speed up computing.

--