Principal source of optimization in compiler design

PRINCPAL SOURCES OF OPTIMISATION
R. Rajkumar
AP | CSE
SRM IST
UNIT 5

Principle SOURCES OF OPTIMISATION
•A compiler optimization must preserve the semantics of the
original program.
•Except in very special circumstances, once a programmer
chooses and implements a particular algorithm, the compiler
cannot understand enough about the program to replace it
with a substantially different and more efficient algorithm.
•A compiler knows only how to apply relatively low-level
semantic transformations, using general facts.

Function-Preserving Transformations
There are a number of ways in which a compiler can improve a
program without changing the function it computes.
Function preserving transformations examples:
• 1. Common sub expression elimination
• 2. Copy propagation,
• 3. Dead-code elimination
• 4. Constant folding

Common Sub expressions elimination:
An occurrence of an expression E is called a common
sub-expression if E was previously computed, and the
values of variables in E have not changed since the
previous computation.
We can avoid recomputing the expression if we can use
the previously computed value.

For example
t1: = 4*i
t2: = a [t1]
t3: = 4*j
t4: = 4*i
t5: = n
t6: = b [t4] +t5
The common sub-
expression elimination as
t1: = 4*i
t2: = a [t1]
t3: = 4*j
t5: = n
t6: = b [t1] +t5
[ The common sub expression t4:
=4*i is eliminated as its
computation is already in t1 and
the value of i is not been changed
from definition to use.]

Copy Propagation:
Assignments of the form f : = g called copy statements, or copies for short.
The idea behind the copy-propagation transformation is to use g for f,
whenever possible after the copy statement f: = g.
Copy propagation means use of one variable instead of another. This may not
appear to be an improvement, but as we shall see it gives us an opportunity
to eliminate x.
• For example:
x=Pi;
A=x*r*r;
The optimization using copy propagation can be done as follows: A=Pi*r*r;
Here the variable x is eliminated

Dead-Code Eliminations:
A variable is live at a point in a program if its value can be used subsequently;
otherwise, it is dead at that point. A related idea is dead or useless code,
statements that compute values that never get used. While the programmer is
unlikely to introduce any dead code intentionally, it may appear as the result of
previous transformations.
Example:
i=0;
if(i=1)
{
a=b+5;
} Here, ‘if’ statement is dead code because this condition will never get satisfied.

Constant folding:
Deducing at compile time that the value of an expression is a constant
and using the constant instead is known as constant folding. One
advantage of copy propagation is that it often turns the copy statement
into dead code.
For example,
a=3.14157/2 can be replaced by
a=1.570 there by eliminating a division operation.

Loop Optimizations
In loops, especially in the inner loops, programs tend to spend the bulk of
their time. The running time of a program may be improved if the number of
instructions in an inner loop is decreased, even if we increase the amount of
code outside that loop.
Three techniques are important for loop optimization:
• Code motion, which moves code outside a loop;
• Induction-variable elimination, which we apply to replace variables from
inner loop.
• Reduction in strength, which replaces and expensive operation by a
cheaper one, such as a multiplication by an addition.

Principal source of optimization in compiler design

Data flow analysis
• It is the analysis of flow of data in control flow graph, i.e., the analysis
that determines the information regarding the definition and use of
data in program. With the help of this analysis optimization can be
done. In general, its process in which values are computed using data
flow analysis. The data flow property represents information which
can be used for optimization.

A expression is said to be available at a program point x iff along paths its reaching to x.
A Expression is available at its evaluation point.
A expression a+b is said to be available if none of the operands gets modified before their use.
Example
AVAILABLE EXPRESSION

Reaching Definition
• A definition D is reaches a point x if there is path from D to x in
which D is not killed, i.e., not redefined.

Live variable
A variable is said to be live at some point p if from p to end the
variable is used before it is redefined else it becomes dead.
Advantages:
It is useful for register allocation.
It is used in dead code elimination.

Summary
• Principle Sources of Optimisation
• Function-Preserving Transformations
• Common Sub expressions elimination:
• Copy Propagation:
• Dead-Code Eliminations:
• Constant folding:
• Loop Optimizations
• Data flow analysis
• Available Expression
• Reaching Definition
• Live variable

Principal source of optimization in compiler design

More Related Content

What's hot (20)

Similar to Principal source of optimization in compiler design (20)

More from Rajkumar R (13)

Recently uploaded (20)

Principal source of optimization in compiler design