Out of Order Store Commit Mechanism
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
In processors, the store queue often becomes a bottleneck due to older speculative stores being queued for a long time, preventing younger non-speculative stores from being committed, leading to processor stalling and inefficiency.
Innovation Solution
Implementing a system where store instructions are issued out of order from the store queue, with younger non-speculative stores being committed before older speculative ones, using status indicators and pending miss requests to determine readiness for commitment.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Reliability
If stores are committed in order from the store queue, then memory ordering is maintained, but processor stalling occurs when older speculative stores take long time to commit
Solution Approach 1:
The patent applies out-of-order commit for stores that are safe to commit (non-speculative or with resolved dependencies), while maintaining in-order commit for stores that require ordering guarantees. This selective inversion allows younger stores to bypass older speculative stores in the commit process, improving throughput without violating memory ordering constraints for stores that require it.
Solution Approach 2:
The patent changes the state parameter of store instructions from speculative to non-speculative based on dependency resolution. When an older speculative store's dependencies are resolved, its state changes, allowing younger stores to be committed out of order. This dynamic parameter change enables flexible commit ordering that balances throughput and correctness.
2Quantity of substance
If the store queue size is increased to accommodate more stores, then store buffering capacity is improved, but the store queue becomes a larger gating factor and consumes more resources
Solution Approach 1:
The patent extracts the commitment decision logic from the store queue structure itself and implements it in the completion unit. This allows the store queue to remain relatively small while still enabling out-of-order commitment of stores, as the completion unit independently determines which stores are ready to commit without being blocked by queue position.
Solution Approach 2:
The patent implements dynamic store commitment based on real-time dependency resolution status. Instead of a static first-in-first-out commit order, the system dynamically evaluates which stores have resolved dependencies and can be safely committed, allowing flexible commitment timing that adapts to changing execution conditions.
3Reliability
If older speculative stores are held in the store queue for a long time, then speculative memory operations are preserved, but younger non-speculative stores are blocked from committing
Solution Approach 1:
The patent performs preliminary dependency checking and state transition for older speculative stores before they block younger stores. When an older speculative store's dependencies are resolved, it transitions to a non-speculative state in advance, enabling subsequent younger stores to be committed out of order without waiting for the older store's actual memory operation to complete.
Solution Approach 2:
The patent introduces the completion unit as an intermediary between the store queue and the commit mechanism. This intermediary independently evaluates store readiness based on dependency resolution and facilitates out-of-order commitment of eligible stores, decoupling the commit process from the strict queue order and reducing blocking delays.
Data Source
AI summary
Systems, apparatuses, and methods for committing store instructions out of order from a store queue are described. A processor may store a first store instruction and a second store instruction in the store queue, wherein the first store instruction is older than the second store instruction. In response to determining the second store instruction is ready to commit to the memory hierarchy, the processor may allow the second store instruction to commit before the first store instruction, in response to determining that all store instructions in the store queue older than the second store instruction are non-speculative. However, if it is determined that at least one store instruction in the store queue older than the second store instruction is speculative, the processor may prevent the second store instruction from committing to the memory hierarchy before the first store instruction.