Operand Data Structure for Accelerated Address Generation
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
High-performance computing systems experience a low ratio of sustained performance to peak performance due to unutilized computational capacity, necessitating improved address generation within data processing systems.
Innovation Solution
A method of compiling code that includes an address generation accelerator within a block computation engine to generate read and write requests for operand data structures, accelerating address computation for iterated operations with defined addressing relationships.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Productivity
If traditional address generation methods are used in high-performance computing systems, then peak performance can be achieved, but sustained performance remains low due to unutilized computational capacity
Solution Approach 1:
The operand data structure is prepared in advance during code compilation, organizing addressing relationships for multiple operands before execution. This preliminary organization enables the address generation accelerator to quickly compute addresses during runtime without requiring complex runtime analysis, thereby improving sustained performance while maintaining peak performance capability.
Solution Approach 2:
The operand data structure acts as an intermediary between the compiled code and the address generation accelerator. It provides pre-organized addressing relationship information that the accelerator can efficiently process, bridging the gap between high-level code structures and low-level address computation, thus improving sustained performance without sacrificing peak performance.
2Productivity
If address generation is accelerated using an address generation accelerator, then sustained performance improves, but the device complexity increases due to additional hardware components
Solution Approach 1:
The address generation function is segmented into two parts: complex addressing relationship definition (handled by the operand data structure prepared in advance) and actual address computation (handled by the accelerator). This segmentation allows the accelerator to focus only on the computational aspect using pre-prepared data, reducing its complexity while still achieving sustained performance improvement.
Solution Approach 2:
The system changes the parameter representation of addressing relationships from complex runtime computations to pre-compiled data structures with simplified addressing patterns. By transforming the problem from computing addresses during execution to retrieving and applying pre-computed addressing relationships, the accelerator's complexity is reduced while maintaining effectiveness.
3Speed
If operand data structures are prepared in advance during code compilation, then address generation speed improves, but the compilation process complexity increases
Solution Approach 1:
The addressing relationship information is extracted from the compiled code and placed into separate operand data structures. This extraction allows the compiler to handle the complex task of analyzing addressing relationships once during compilation, while the runtime system simply uses the pre-extracted information, thereby improving address generation speed without requiring the compiler to be overly complex.
Solution Approach 2:
The compiler performs preliminary analysis and organization of addressing relationships during the compilation phase, creating operand data structures that capture these relationships in advance. This preliminary action shifts the complexity burden to compilation time rather than runtime, enabling faster address generation during execution without making the runtime system overly complex.
Data Source
Figure 1
Figure 2
Figure 3
AI summary
In response to receiving pre-processed code, a compiler identifies a code section that is not a candidate for acceleration and a code block that is a candidate for acceleration. The code block specifies an iterated operation having a first operand and a second operand, where each of multiple first operands and each of multiple second operands for the iterated operation has a defined addressing relationship. In response to the identifying, the compiler generates post-processed code containing lower level instruction(s) corresponding to the identified code section and creates and outputs an operand data structure separate from the post-processed code. The operand data structure specifies the defined addressing relationship for the multiple first operands and for the multiple second operands. The compiler places a block computation command in the post-processed code that invokes processing of the operand data structure to compute operand addresses.