Motivation[ edit ] There is an inherent trade-off between size and speed given that a larger resource implies greater physical distances but also a tradeoff between expensive, premium technologies such as SRAM vs cheaper, easily mass-produced commodities such as DRAM or hard disks. The buffering provided by a cache benefits both bandwidth and latency: This is mitigated by reading in large chunks, in the hope that subsequent reads will be from nearby locations.
Cache Write Policies Introduction: One of two things will happen: But eventually, the data makes its way from some other level of the hierarchy to both the processor that requested it and the L1 cache.
The L1 cache then stores the new data, possibly replacing some old data in that cache block, on the hypothesis that temporal locality is king and the new data is more likely to be accessed soon than the old data was.
Throughout this process, we make some sneaky implicit assumptions that are valid for reads but questionable for writes. We will label them Sneaky Assumptions 1 and 2: If the access is a miss, we absolutely need to go get that data from another level of the hierarchy before our program can proceed.
Why these assumptions are valid for reads: Bringing data into the L1 or L2, or whatever just means making a copy of the version in main memory. If we lose this copy, we still have the data somewhere. If the request is a load, the processor has asked the memory subsystem for some data.
In order to fulfill this request, the memory subsystem absolutely must go chase that data down, wherever it is, and bring it back to the processor. Why these assumptions are questionable for writes: We would want to be sure that the lower levels know about the changes we made to the data in our cache before just overwriting that block with other stuff.
So the memory subsystem has a lot more latitude in how to handle write misses than read misses. Keeping Track of Modified Data More wild anthropomorphism ahead As requested, you modify the data in the appropriate L1 cache block.
Now your version of the data at Address XXX is inconsistent with the version in subsequent levels of the memory hierarchy L2, L3, main memory Since you care about preserving correctness, you have only two real options: You and L2 are soulmates.
Inconsistency with L2 is intolerable to you. To deal with this discomfort, you immediately tell L2 about this new version of the data. You have a more hands-off relationship with L2.
Your discussions are on a need-to-know basis. You quietly keep track of the fact that you have modified this block.
Write-Through Implementation Details naive version With write-through, every time you see a store instruction, that means you need to initiate a write to L2. This is no fun and a serious drag on performance. Write-Through Implementation Details smarter version Instead of sitting around until the L2 write has fully completed, you add a little bit of extra storage to L1 called a write buffer.
If the write buffer does fill up, then, L1 actually will have to stall and wait for some writes to go through.
Today there is a wide range of caching options available – write-through, write-around and write-back cache, plus a number of products built around these – and the array of options makes it. Although either write-miss policy could be used with write through or write back, write-back caches generally use write allocate (hoping that subsequent writes to . Cache Write Policies and Performance Norman P. Jouppi Second, tradeoffs between write-through and write-back caching when writes hit in a cache are con-sidered. A mixture of these two alternatives, called write 16B lines, using write-allocate with fetch-on-write. Figure.
Instead, we just set a bit of L1 metadata the dirty bit -- technical term!A cache with a write-through policy (and write-allocate) reads an entire block (cacheline) from memory on a cache miss and writes only the updated item to memory for a store.
Write-through, write-around and write-back cache There are three main caching techniques that can be deployed, each with their own pros and cons.
Write-through cache directs write I/O onto cache and through to underlying permanent storage before confirming I/O completion to the host. Write through is also more popular for smaller caches that use no-write-allocate (i.e., a write miss does not allocate the block to the cache, potentially reducing demand for L1 capacity and L2 read/L1 fill bandwidth) since much of the hardware requirement for write through is .
The types of locality are Letter Answer A Punctual, tardy B Spatial and Temporal C Instruction and data D Write through and write back E Write allocate and no-write allocate.
—Write-back? Block allocation policy on a write miss Cache performance.
2 Write-through caches A write-through cache forces all writes to update both the cache and the main memory. This is simple to implement and keeps the cache and memory consistent. Although either write-miss policy could be used with write through or write back, write-back caches generally use write allocate (hoping that subsequent writes to .