code optimization dominatorloop detection in code •useful in loop optimization process....
TRANSCRIPT
Code OptimizationM.B.Chandak
Lecture notes on Language Processor
Approaches:
• Local Optimization
• Loop Optimization
• Peep Hole optimization
Basis:
• Optimized code should generate same results as original code.
Trade off:
• Time spent in optimization and outcome should be balanced
Local optimization: 1. Elimination of Common Sub-expression
• Common Sub-expressions
• Repeated in code and executed more than once
• Example
A = B+C*D
X = Y+C*D
• Common expression can be found from TAC
T1 = C*D
T2 = B+T1
T3 = C*D
T4 = Y + T3
Idea: To identify and replace
Implementation: Removal of Common SE
DAG: Directed Acyclic Graph
• Construction: From leaf node to root node
• Root node = Operator, Leaf node=Generally operands
• Left hand side rule is used to construct DAG
STEPS
• Given Program Segment – Construct TAC – Construct DAG – identify Common Sub Expressions – Remove Common SE – Rewrite TAC [optimized]
Examples: DAGLabel Code
100 T1 = 4 * I
101 T2 = ADD(A) – 4
102 T3 = T2[T1]
103 T4 = 4 * I
104 T5 = ADD[B] – 4
105 T6 = T5[T4]
106 T7 = T3*T6
107 T8=PROD + T7
108 T9 = I + 1
109 I = T9
110 IF (I<=20) GOTO 100
i4
* T1
ADD
(a)
- T2
[] T3
T4
ADD
(b)
-T5
[] T6
* T7
Prod
+ T8
1
+T9
i
20
<=
100
ExampleLabel Code
100 T1 = I * 4
102 T2 = ADD(A) - 4
103 T3 = T2[T1]
104 X = T3
105 T4 = J * 4
106 T5 = ADD(P) – 4
107 T6 = T5[T4]
108 T7 = I * 4
109 T8 = ADD(A) – 4
110 T9 = T8[T7]
111 Z = T9
Conversion of TAC into PFG
• Program flow graph is partitioned graph of Three Address Code.
• For construction of PFG: Leader statements are identified, basic blocks designed and connected.
• Leader statement rules:
• First Statement of TAC is leader
• Target of conditional and unconditional goto statement is leader.
• Statement immediately following conditional goto statement is leader.
Basic Blocks of PFG and connection rules
• Once leader statements are identified, TAC is divided into basic blocks depending upon the boundaries of TAC
• Connection rules:
• If B1 and B2 are two blocks, then add an edge from B1 to B2; if B2 follow B1 in execution.
• B2 follows B1 in execution if:
• 1) First statement of Block B2 immediately follows the last statement of block B1 in TAC and last statement of B1 is not an unconditional goto.
• 2) Last statement of block B1 is either a conditional or unconditional Goto and first statement of block B2 is target of goto statement.
Loop detection in code
• Useful in loop optimization process.
• Process:
• Given Program Segment
• Design program flow graph (PFG)
• In PFG, two types of edges: forward edge and backward edge
• Detect Backward edge, to find loops
• Process of detecting backward edge, involves calculation of Dominators between blocks of PFG.
Example:• Program Segment
Int demo(int t)
{
int a, b
amt=a
rate=a
while(a>10)
{
amt=amt*rate
amt=amt+100
a=a+1;
}
}
Three Address Code
10: amt=a
20: rate=a
30: if(a>10) goto 50
40: goto 120
50: t1=amt*rate
60: amt=t1
70: t2=amt+100
80: amt=t2
90: t3=a+1
100: a=t3
110: goto 30
120: Exit
L1
L2
L3
L4
L5
Three Address Code
10: amt=a
20: rate=a
30: if(a>10) goto 50
40: goto 120
50: t1=amt*rate
60: amt=t1
70: t2=amt+100
80: amt=t2
90: t3=a+1
100: a=t3
110: goto 30
120: Exit
B0
B1
B2
B3
B4
Connectivity between blocks
Block 0
amt=a
Rate=a
Block 1
If(a>10) goto 50
Block 2
Goto 120
Block 3
t1=amt*rate
:
Goto 30
Block 4
Exit
Example: PFG and Block
int func(int a, int b)
{
int i,tot;
int n1,n2;
i =0;
n1 = a * b
n2 = a – b
while (a[i] > n1*n2)
i = i + 1
retrun i;
}
Label Code Leader Block
100 i=0 L1 B1
101 T1 = a*b
102 N1=t1
103 T2 = a-b
104 N2=t2
105 T3 = i*4 L2 B2
106 T4 = add(a) – c
107 T5 = t4[t5]
108 T6=t1*t2
109 If(t5 > t6) goto 111
110 Goto 114 L3 B3
111 T7=i+1 L4 B4
112 i=t7
113 Goto 105
114 Return i L5 B5
115 Exit
Example: Perform local optimization, convert to PFG, draw block structure, detect loop
int func(int a, int b)
{
int i, j, k;
i = 45;
j = a + b;
While(j < 25)
{
if(a+i > 100)
k = a + j;
else
k = b + j;
j = j + 4
}
return (k)
}
Dominators• Dominators allows to detect loops within program flow graph.
• A node “d” of flow graph dominates node “n” if every path from the initial node to node “n” goes/flow through node “d”.
• It is represented as d dom n
• Every node dominates itself
Block / node Dominator
Block 0 {0}
Block 1 {0,1}
Block 2 {0,1,2}
Block 3 {0,1,3}
Block 4 {0,1,2,4}
Finding back edge
• In the program flow graph every edge flows from Tail to Head.
• If block 0 is connected to block 1, then Tail=Block 0 and Head=Block=1
• Steps:
• Compute edges in PFG
• Compute Head and Tail information from edges
• Find dominator of head and dominator of tail
• Rule: If in the dominator of tail, head node is present, then the edge is denoted as back edge.
Edges and dominator tableEdge Head Tail Dominator[H] Dominator[T] Remarks
0 � 1 1 0 {0,1} {0}
1 � 2 2 1 {0,1,2} {0,1}
1 � 3 3 1 {0,1,3} {0,1}
3 � 1 1 3 {0,1} {0,1,3} Back Edge
2 � 4 4 2 {0,1,2,4} {0,1,2}
Block / node Dominator
Block 0 {0}
Block 1 {0,1}
Block 2 {0,1,2}
Block 3 {0,1,3}
Block 4 {0,1,2,4}
The back edge 3����1 indicates presence of loop between block 3 and 1. All the blocks
present between 3 and 1 path and path from 1 to 3 will be part of loop.
For example: loop will be 3-1-3
Example-2
Solution
Example-3