Cache Eviction Control Using Read-After-Read Buffer
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
In data processing apparatuses that execute instructions out-of-order, there is a risk of data hazards when data evicted from a private cache is modified by other agents with access to shared storage, particularly if a younger load's data is evicted before being accessed by an older load, leading to potential data hazards and inefficiencies.
Innovation Solution
Implementing a read-after-read buffer to track not-yet-committed load instructions and controlling cache evictions based on the presence of valid entries in this buffer, ensuring that data is not evicted to shared storage if it has corresponding valid entries, thereby maintaining data exclusivity and preventing data hazards.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Quantity of substance
If data is evicted from private cache to shared storage location, then cache space is freed for new data, but data hazards may occur when other agents modify the evicted data
Solution Approach 1:
A read-after-read buffer is introduced as an intermediary structure between the private cache and shared storage. This buffer tracks addresses of load instructions that have executed but not yet committed, serving as a mediator to prevent premature eviction of data that might be read again. The buffer acts as a gatekeeper, controlling when data can safely be evicted from the private cache without causing data hazards.
Solution Approach 2:
The system performs preliminary tracking of load instruction addresses in the read-after-read buffer before allowing cache eviction. By recording which addresses are currently being used by in-flight load instructions, the system proactively prevents eviction of data that will be needed soon, thereby avoiding data hazards before they can occur.
2Productivity
If out-of-order execution is implemented, then instruction throughput is improved, but data hazards may occur when younger loads execute before older loads
Solution Approach 1:
The read-after-read buffer provides feedback information to the cache eviction control logic about which addresses are currently being accessed by out-of-order executed load instructions. This feedback mechanism allows the system to dynamically adjust eviction decisions based on the actual execution state, preventing data hazards while maintaining out-of-order execution benefits.
Solution Approach 2:
The read-after-read buffer serves as an intermediary tracking structure that mediates between the out-of-order execution engine and the cache eviction mechanism. It captures address information from executed load instructions and provides this information to eviction control, enabling safe eviction decisions even when instructions execute out of program order.
3Reliability
If cache eviction control checks read-after-read buffer, then data hazards are prevented, but additional control logic complexity is introduced
Solution Approach 1:
The eviction control logic is extracted and separated into a distinct functional unit that specifically handles read-after-read buffer checks. By isolating this control function, the complexity is contained and managed separately from the main cache eviction mechanism, making the system more modular and easier to understand despite the added complexity.
Data Source
AI summary
Apparatuses and methods relating to controlling cache evictions are disclosed. Processing circuitry which execute instructions out-of-order is provided with a private cache into which blocks of data are copied from a shared storage location to which the processing circuitry shares access. The processing circuitry also has a read-after-read buffer, into which an entry is allocated when out-of-order execution of a load instruction occurs comprising an address accessed by the load instruction. The address remains as a valid entry in the read-after-read buffer until the load instruction is committed. Eviction of an eviction candidate block of data from the private cache to the shared storage location is controlled in dependence on whether the eviction candidate block of data has a corresponding valid entry in the read-after-read buffer.