Code Optimization in Compiler Design
The code optimization in the synthesis phase is a program transformation technique, which tries to improve the intermediate code by making it consume fewer resources (i.e. CPU, Memory) so that faster-running machine code will result. Compiler optimizing process should meet the following objectives :
- The optimization must be correct, it must not, in any way, change the meaning of the program.
- Optimization should increase the speed and performance of the program.
- The compilation time must be kept reasonable.
- The optimization process should not delay the overall compiling process.
When to Optimize?
Optimization of the code is often performed at the end of the development stage since it reduces readability and adds code that is used to increase the performance.
Types of Code Optimization –The optimization process can be broadly classified into two types :
- Machine Independent Optimization – This code optimization phase attempts to improve the intermediate code to get a better target code as the output. The part of the intermediate code which is transformed here does not involve any CPU registers or absolute memory locations.
- Machine Dependent Optimization – Machine-dependent optimization is done after the target code has been generated and when the code is transformed according to the target machine architecture. It involves CPU registers and may have absolute memory references rather than relative references. Machine-dependent optimizers put efforts to take maximum advantage of the memory hierarchy.
Code Optimization is done in the following different ways :
- Compile Time Evaluation :
(i) A = 2*(22.0/7.0)*r
Perform 2*(22.0/7.0)*r at compile
time
.
(ii) x = 12.4
y = x/2.3
Evaluate x/2.3 as 12.4/2.3 at compile
time
.
chevron_rightfilter_none - Variable Propagation :
//Before Optimization
c = a * b
x = a
till
d = x * b + 4
//After Optimization
c = a * b
x = a
till
d = a * b + 4
chevron_rightfilter_noneHence, after variable propagation, a*b and x*b will be identified as common sub-expression.
- Dead code elimination : Variable propagation often leads to making assignment statement into dead code
c = a * b
x = a
till
d = a * b + 4
//After elimination :
c = a * b
till
d = a * b + 4
chevron_rightfilter_none - Code Motion :
• Reduce the evaluation frequency of expression.
• Bring loop invariant statements out of the loop.a = 200;
while
(a>0)
{
b = x + y;
if
(a % b == 0}
printf
(“%d”, a);
}
//This code can be further optimized as
a = 200;
b = x + y;
while
(a>0)
{
if
(a % b == 0}
printf
(“%d”, a);
}
chevron_rightfilter_none - Induction Variable and Strength Reduction :
• An induction variable is used in loop for the following kind of assignment i = i + constant.
• Strength reduction means replacing the high strength operator by the low strength.i = 1;
while
(i<10)
{
y = i * 4;
}
//After Reduction
i = 1
t = 4
{
while
( t<40)
y = t;
t = t + 4;
}
chevron_rightfilter_none
Reference – https://en.wikipedia.org/wiki/Optimizing_compiler
This article is contributed by Priyamvada Singh. If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.
Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above.
Recommended Posts:
- Loop Optimization in Compiler Design
- Peephole Optimization in Compiler Design
- Introduction of Object Code in Compiler Design
- Intermediate Code Generation in Compiler Design
- Compiler Design | Detection of a Loop in Three Address Code
- Frequency Reduction in Code Optimization
- Three address code in Compiler
- Bootstrapping in Compiler Design
- Introduction of Compiler Design
- Why FIRST and FOLLOW in Compiler Design?
- Labeling Algorithm in Compiler Design
- Input Buffering in Compiler Design
- Types of Parsers in Compiler Design
- Basic Blocks in Compiler Design
- Error Handling in Compiler Design
Improved By : Palak Jain 5