Microprocessor Call Return Stack Bypass Execution Pipeline
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
Conventional microprocessors incur significant latency and resource usage when executing call and return instructions due to speculative execution, as they require updating architectural state only after resolving outstanding conditional branches, leading to inefficient use of resources and increased latency.
Innovation Solution
A microprocessor with a call/return stack that allows immediate execution of call and return instructions in a fetch unit, eliminating the need for dispatching them to the execution pipeline, thereby reducing latency and resource usage by directly modifying the architectural state within the fetch unit.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Reliability
If call and return instructions are executed through the execution pipeline with speculative execution, then program correctness is maintained, but latency increases and resources are consumed
Solution Approach 1:
The patent segments the execution process by separating call/return instruction handling from the general execution pipeline. A dedicated call/return stack is created to manage these instructions independently, allowing them to be executed without passing through the full speculative execution pipeline. This segmentation enables faster execution while maintaining correctness by isolating the critical path of call/return operations.
Solution Approach 2:
The patent extracts call and return instructions from the general execution pipeline and handles them through a specialized mechanism. The call/return stack is extracted as a separate data structure that manages these instructions directly, removing them from the speculative execution path. This extraction eliminates the latency and resource consumption associated with pipeline processing while preserving the correctness guarantees.
2Reliability
If call and return instructions flow through the execution pipeline, then architectural state is updated correctly, but execution unit resources are consumed
Solution Approach 1:
The patent extracts call and return instructions from the execution pipeline, eliminating their consumption of execution unit resources. By handling these instructions through the dedicated call/return stack mechanism, the system maintains architectural state correctness without occupying precious execution unit slots, register alias table entries, or reorder buffer entries that would otherwise be consumed by pipeline processing.
Solution Approach 2:
The call/return stack mechanism serves itself by directly managing architectural state updates for call and return instructions without requiring execution unit resources. The system uses the stack structure to automatically handle the state changes, eliminating the need for execution units to process these instructions and thereby avoiding resource consumption while maintaining correctness.
3Device complexity
If call and return instructions are processed like other instructions, then unified processing is simplified, but performance degrades due to speculative execution requirements
Solution Approach 1:
The patent segments instruction processing into two paths: the general execution pipeline for most instructions and a specialized fast path for call/return instructions. This segmentation allows call/return instructions to bypass speculative execution requirements and be processed directly through the call/return stack, achieving higher performance while maintaining a relatively simple unified architecture by adding only the necessary specialized components.
Data Source
AI summary
A microprocessor includes an instruction set architecture, comprising a call instruction type, a return instruction type, and other instruction types. Execution units correctly execute program instructions of the other instruction types. A call/return stack has a plurality of entries arranged in a last-in-first-out manner. The call/return stack is architectural state of the microprocessor not modifiable by program instructions of the other instruction types. The call/return stack is architectural state of the microprocessor indirectly modifiable by program instructions of the call and return instruction types. The microprocessor also includes a fetch unit that fetches program instructions and sends the program instructions of the other instruction types to the execution units to be correctly executed. The fetch unit correctly executes program instructions of the call and return instruction types without sending the program instructions of the call and return instruction types to the execution units to be correctly executed.