Algebraic Expression Rearrangement via Operand Ranking
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
Program code often contains algebraic expressions that are inefficient in terms of execution order and memory usage, leading to suboptimal performance due to inefficient combinations of operations and operands.
Innovation Solution
A computer-implemented method for optimizing algebraic expressions in program code by rearranging operations to prioritize scalar operands over array operands, using commute and associate transformations to reorder binary operations and propagate types, ensuring efficient execution and memory usage.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Productivity
If algebraic expressions are executed in the original order specified by the programmer, then the code maintains simplicity and readability, but execution efficiency and memory usage deteriorate
Solution Approach 1:
The compiler performs preliminary analysis of algebraic expressions during the compilation phase to identify optimization opportunities. By analyzing the expression structure before execution, the compiler can rearrange operations to combine scalar operands first, then array operands, thereby improving execution efficiency without requiring changes to the original program logic.
Solution Approach 2:
The expression execution order is made dynamic based on the types of operands involved. The compiler generates different execution strategies depending on whether operands are scalars or arrays, selecting the optimal evaluation order at compile time. This allows the same algebraic expression to be executed efficiently regardless of the specific operand types.
2Productivity
If algebraic expressions combine array operands before scalar operands, then array operations are performed first, but the number of operations increases and memory usage increases
Solution Approach 1:
The compiler merges scalar operations together and array operations together, creating separate computation streams. By combining all scalar operands first through scalar-scalar operations, then combining the result with array operands through a single array-scalar operation, the compiler reduces the total number of operations and minimizes memory usage compared to performing array operations first.
3Productivity
If the compiler rearranges algebraic expressions to optimize execution, then computational efficiency improves, but the complexity of the compilation process increases
Solution Approach 1:
The compiler divides the algebraic expression into distinct segments based on operand types (scalar segments and array segments). By segmenting the expression, the compiler can independently optimize each segment and then combine them, simplifying the overall optimization process while achieving significant execution speed improvements.
Solution Approach 2:
The compiler changes the evaluation parameters of the algebraic expression by altering the order of operations based on operand types. This parameter change (execution order) is achieved through systematic analysis of the expression structure and application of type-based evaluation rules, managing compiler complexity through structured approaches.
Data Source
AI summary
A system and method for rearranging algebraic expressions occurring in program code based on a scheme of ranking operands. The system scans program code to identify an algebraic expression specified by the program code. The expression includes binary operations, scalar operands and at least one array operand. The system operates on the algebraic expression to obtain a final expression by: computing a rank for each of the operands; and performing algebraic transformations on selected subexpressions of the algebraic expression so that in the final expression operands are combined in the order of their rank. The ranking scheme may be designed to force scalars to be combined before arrays, and/or, to force constants to be combined first, loop invariants second, and variants last. In some embodiments, the ranking scheme is a vector ranking scheme including two or more components (such as invariance rank, dimensional rank and data-size rank).