1a) Write about Data Flow Analysis of structural programs? Ans: 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 that can be used for optimization. Basic Terminologies * Definition Point: a point in a program containing some definition, © Reference Point: a point in a program containing a reference to a data item. * Evaluation Point: a point in a program containing evaluation of expression, Lya=2 | Definition Point —-—__] 1 ———, Lo:b=a Reference Point ¥ ; Evaluation Point Lg: z=x*y | iv Data Flow Properties - * Available Expression — A expression is said to be available at a program point x paths its reaching to x. A Expression is available at its evaluation point An expression a+b is said to be available if none of the operands gets modified before their use. Example —y=x+d{lq] Bo Bs Expression 4 * i is available for block Bz B3 © Advantage — It is used to eliminate common sub expressions * 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. Example ~ [ Dy:x=4 | By 1 Dj is reaching definition for By but not for Bg since it is killed by Dz + Advantage — It is used in constant and variable propagation, * 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. Example -ais live at block B, , Bz Bg but killed at Bs * Advantage — 1. Itis useful for register allocation. 2. It is used in dead code elimination. * Busy Expression ~ An expression is busy along a path if its evaluation exists along that path and none of its operand definition exists before its evaluation along the path. Advantage — It is used for performing code movement optimization. 2c) Explain in detail the procedure that eliminates global common sub expression. Ans: Common Sub-expression Elimination: The expression or sub-expression that has been appeared and computed before and appears again during the computation of the code is the common sub-expression. Elimination of that sub-expression is known as Common sub-expression elimination. The advantage of this elimination method is to make the computation faster and beter by avoiding the re-computation of the expression. In addition, it utilizes memory efficiently. ‘Types of common sub-expression elimination The two types of elimination methods in common sub-expression elimination are: 1. Local Common Sub-expression climination— It is used within a single basic block. Where a basic block is a simple code sequence that has no branches. 2. Global Common Sub-expression elimination It is used for an entire procedure of common sub-expression eliminationExample Before climination a= 10; baati*2 c=atl*2; ‘c' has common expression as ‘b ier a= 10, baatI*2 ation d=bta, Let's understand Example 1 with a diagram : 12 +10 =22 fig.: Example 1 As shown in the figure (fig.: Example 1), the result of ‘d’ would be similar with both expressions. So, we will eliminate one of the common subexpressions, as it helps in faster execution and efficient memory utilization. Example Before elimination x=ll yall * 24: Zax" 24; ‘2’ has common expression as 'y' as 'v’ can be evaluated directly ax done in 'y. After elimination — y=11*23¢)Explain how copy propagation can be done using data flow equation. th fot py statemen gation tani fc F ratement a := b. Let h oi P The flow graph should also con f B along every path and ther ah 1 ng that path, We also need dus chair efinition and used fini bedi utput h i a nsformat Method : F h state \ i pert 1 ; ichable f fi 3) tisfies the condition mentioned in step (2) then remove s and replace uses of x found in (1) |nd x is not altered alon 1 then eliminate the copy by t, and then climinate 4e) Explain about machine dependent code optimization. Ans: Machin lependent Opti 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 memory hierarchy. Basic Blocks Source codes generally have a number of instructions, which are always executed in sequence and are considered as the basic blocks of the code. These basic blocks do not have any jump statements among them, i.e., when the first instruction is executed, all the instructions in the same basic block will be executed in their sequence of appearance without losing the flow control of the programA program can have various constructs as basic blocks, like IF-THEN-ELSE, SWITCH-CASE conditional statements and loops such as DO-WHILE, FOR, and REPEAT-UNTIL, etc. Basic block identification We may use the following algorithm to find the basic blocks in a program: + Search header statements of all the basic blocks from where a basic block starts: First statement of a program. o Stater ents that are target of any branch (conditional/unconditional). Statements that follow any branch statement + Header statements and the statements following them form a basic block. + A basic block does not include any header statement of any other basic block. Basic blocks are important concepts from both code generation and optimization point of view. y= 2 att; att; } wax az; w=xta; Source Code Basic Blocks Basic blocks play an important role in identifying variables, which are being used more than once in a single basic block. If any variable is being used more than once, the register memory allocated to that variable need not be emptied unless the block finishes execution. Control Flow Graph Basic blocks in a program can be represented by means of control flow graphs. A control flow graph depicts how the program control is being passed among the blocks. It is a useful tool that helps in optimization by help locating any unwanted loops in the program,ENTER w= 0; y= 0; if( x > z) Bi = 7 \ as B2 83 s3 \ f EXIT Basic Blocks Flow Graph Loop Opt Most programs run as a loop in the system. It becomes necessary to optimize the loops in order to save CPU cycles and memory. Loops can be optimized by the following techniques: + Invariant code : A fragment of code that resides in the loop and computes the same value at each iteration is called a loop-invariant code. This code can be moved out of the loop by saving it to be computed only once, rather than with each iteration. + Induction analysis ; A variable is called an induction variable if its value is altered within the loop by a loop-invariant value. + Strength reduction ; There are expressions that consume more CPU cycles, time, and memory. These expressions should be replaced with cheaper expressions without compromising the output of expression. For example, multiplication (x * 2) is expensive in terms of CPU cycles than (x << 1) and yields the same result. Dead-code Elimination Dead code is one or more than one code statements, which are: ization * Either never executed or unreachable, © Orif executed, their output is never used. Thus, dead code plays no role in any program operation and therefore it can simply be eliminated. Partially dead codeThere are some code statements whose computed values are used only under certain circumstances, i.e., sometimes the values are used and sometimes they are not. Such codes are known as partially dead-code. The above control flow graph depicts a chunk of program where variable ‘a’ is used to assign the output of expression ‘x * y’. Let us assume that the value assigned to ‘a’ is never used inside the loop.Immediately after the control leaves the loop, ‘a’ is assigned the value of variable ‘z', which would be used later in the program. We conclude here that the assignment code of ‘a’ is never used anywhere, therefore it is eligible to be eliminated. Likewise, the picture above depicts that the conditional statement is always false, implying that the code, written in true case, will never be executed, hence it can be removed. Partial Redundancy Redundant expressions are computed more than once in parallel path, without any change in operands.whereas partial-redundant expressions are computed more than once in a path, without any change in operands. For example,[redundant expression] [partially redundant expression] Loop-invariant code is partially redundant and can be eliminated by using a code-motion technique. Another example of a partially redundant code can be If (condition) { a=yOPz, } clse € ) c=yOPz; We assume that the values of operands (y and z) are not changed from assignment of variable a to variable c. Here, if the condition statement is true, then y OP z is computed twice, otherwise once. Code motion can be used to eliminate this redundancy, as shown below: If (condi t p) tmp ~y OPz, a= tmp; 5 else { tmp =y OPz, } c=tmp, SnHere, whether the condition is true or false; y OP z should be computed only once 5C) Discuss about the following: i) Copy Propagation ii) Dead code Elimination and iii) Code motion, iv) Constant folding » Ans: 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 The above code can be optimized using the common sub-expression elimination as The common sub expression t,:~4*i is eliminated as its computation is already in tr, And value of jis not been changed from tou > Copy Propagation: Assignments of the form : = g called copy statements, or copies for short. The idea behind the cony-propagation tansfommation is to use g for { whenever possible after the copy siaicment f= « Copy propagation means usc of onc variable insicad of another. This May not appear ta be an_improvement, but_as_we shall see it gives us_an opportunity to eliminate x. + For examplex=Pi ertry The optimization using copy propagation can be done as follows: A=Pi*r*r; Here the variable x is eliminated > Dead-Code Eliminations: + Avariable 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. An optimization can be done by eliminating dead code. Example: Here, ‘if’ statement is dead code because this condition will never get satisfied > Constant folding: * We can eliminate both the test and printing from the object code. More generally, 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_ofien tums the copy statement into dead code. v For example, a=3.14157/2 can be replaced by a=1.570 there by eliminating a division operation,