8 Optimisation. 8.2 Machine-Independent Optimisation

Transcription

1 8 8.2 Machine-Independent Replacing binary with Unary operations Replacing binary with Unary operators The following operations do not produce redundant quads: a=c-d; 1. (-, c, d, t1) b=d-c; => 2. (=, t1,, a) 3. (-, d, c, t2) 4. (=, t2,, b) However, as humans we can note that t1 will hold the same value as t2, only negated We can extend our redundancy elimination routine to look for such cases, and replace the 3rd quadruple with a unary minus: 1. (-, c, d, t1) 2. (=, t1,, a) 3. (_, t1,, t2) 4. (=, t2,, b) Using Unary Operators We have the same number of operations, But unary operations are cheaper than binary 2 1

2 8 8.2 Machine-Independent Reducing number of intermediate variables Reducing Intermediate Variables Reducing number of intermediate variables The intermediate variables (t1, t2, etc.) used in quads allow partial results from one sub-expression to be passed to the next sub-expression. Each of these variables would ideally be held in a machine register, as operations on registers are fast, while storage in the stack or in addressable memory are slower. However, the number of registers on a given machine is restricted. If we can reduce the number of intermediate variables used by our code, then we can perhaps optimise use of registers. 4 2

3 Reducing Intermediate Variables Reducing number of intermediate variables: reusing temp vars A first step here would be to note where an intermediate variable has no more acceses, and allow it to be re-used. 1.(*, a, b, t1) (a*b)+(c+d) => 2. (+, c, d, t2) 3. (+, t1, t2, t3) Analysing the quadruples after (3) would show that t1 is not needed again. We could thus replace all references to t3 in the quadruples with t1, thus reducing the number of temp vars. 5 Reducing Intermediate Variables Reducing number of intermediate variables: example Some orderings of operations allow more of this type of optimisation. For example, the following two expressions are equivalent: (a*b)+(c+d) and ((a*b)+c)+d However, the quadrupes they produce require different numbers of intermediate variables: 1.(*, a, b, t1) (a*b)+(c+d) => 2. (+, c, d, t2) 3. (+, t1, t2, t1) 1.(*, a, b, t1) ((a*b)+c)+d => 2. (+, t1, c, t1) 3. (+, t1, d, t1) 6 3

4 Reducing Intermediate Variables Reducing number of intermediate variables: example Similar result for the following: (a+b)*(c*d) and ((a+b)*c)*d In general, we can optimise by recognising where a bracketed expression has the same operator as that which applies to it, and changing the order in which we apply the operators. Note also that in some cases we first need to reorder the bracketed expressions: (c*d)*(a+b) We will still need two operations here, unless we reorder: (a+b)*(c*d) Machine-Independent Optimising Loops 4

5 Loop Optimising Loops Much of the execution time in a program will be consumed with a loop, or within nested loops. Any simplification we make within the loop will thus have substantial effect on efficiency as a whole. We will look at two types of optimisation here: 1. Moving Loop-invariant instructions outside of the loop 2. Reduction of Force: replacing expensive operations with cheaper ones 9 Loop Intermediate Representation of Loops The direct Translation of a loop can be as follows: int a, b=10, c=5; for (i=0; i<10; i++) { a=i*(b+c); } Initialisation: Body: Increment: 1. (:=, 10,, b) 2. (:=, 5,, c) 3. (:=, 0,, i) 4. (<, i, 10, t1) 5. (jfalse, 11,, ) 6. (+, b, c, t2) 7. (*, i, t2, t3) 8. (:=, t3,, a) 9. (+, i, 1, i) 10.(jmp, 4,, )

6 Some concepts: int a, b=10, c=5; for (i=0; i<10; i++) { a=i*(b+c); } Loop Variable: the loop counter (i) Loop Loop Increment: the quantity added to the loop variable on each loop Loop Invariants: variables used within the loop which do not change value within the loop (b, c) 1. (:=, 10,, b) 2. (:=, 5,, c) 3. (:=, 0,, i) 4. (<, i, 10, t1) 5. (jfalse, 11,, ) 6. (+, b, c, t2) 7. (*, i, t2, t3) 8. (:=, t3,, a) 9. (+, i, 1, i) 10.(jmp, 4,, ) : Loop-Invariant Instructions In this optimisation, we look for quadruples within the loop body where the operands do not change within the loop. For example: int a, b=10, c=5; for (i=0; i<10; i++) { a=i*(b+c); } Loop Body: 1. (:=, 10,, b) 2. (:=, 5,, c) 3. (:=, 0,, i) 4. (<, i, 10, t1) 5. (jfalse, 11,, ) 6. (+, b, c, t2) 7. (*, i, t2, t3) 8. (:=, t3,, a) 9. (+, i, 1, i) 10.(jmp, 4,, )

7 Loop Loop-Invariant Instructions In such cases, we can move the loop invariant code BEFORE the loop, into the Initialisation part 1. (:=, 10,, b) 2. (:=, 5,, c) 3. (:=, 0,, i) 4. (<, i, 10, t1) 5. (jfalse, 11,, ) 6. (+, b, c, t2) 7. (*, i, t2, t3) 8. (:=, t3,, a) 9. (+, i, 1, i) 10.(jmp, 4,, ) 11. Init Body 1. (:=, 10,, b) 2. (:=, 5,, c) 3. (:=, 0,, i) 4. (+, b, c, t2) 5. (<, i, 10, t1) 6. (jfalse, 11,, ) 7. (*, i, t2, t3) 8. (:=, t3,, a) 9. (+, i, 1, i) 10.(jmp, 4,, ) 11. Init Body 13 Loop Loop-Invariant Instructions To spot such cases, we do the following: Calculate the Loop-variant variables: 1. Set LOOP_VARS to { } 2. For each quadruple within the loop: If there is a RES field, place it in LOOP_VARS Locate Loop-invariant Instructions: 3. For each quadruple within the loop: If operator is not a jump: if neither OP1 nor OP2 is in LOOP_VARS: Move the quad outside of the loop If no other quad in the loop sets RES, delete RES from LOOP_VARS 14 7

8 Loop 1: Reduction of Force Often loops contain multiplication of the loop variable: for (i=1; i<10; i++) { a=i*d; } Such cases can be re-written using a less expensive operation, addition: a=0; for (i=1; i<10; i++) { a = a+d; } The result is exactly the same 15 Loop Spotting Candidates for reduction of force We can look at code within a loop for quadruples which match the following: (*, loop_invariant, loop_variable, result) or (*, loop_variable, loop_invariant, result) 16 8

9 Loop Reduction of force: the simple case The simple case: loop increment is 1, Assume we recognise a quadrule: (*, loop_invariant, loop_variable, result) In such cases, we: 1. Move the Quad into the initialisation step (outside the loop), but after the loop variable is initialised 2. Place in the increment part: (+, result, loop_invariant, result) 17 Loop Reduction of force: the simple case 1. (:=, 1,, i) 2. (<, i, 10, t1) 3. (jfalse, 8,, ) 4. (*, i, d, t2) 5. (:=, t2,, a) 6. (+, i, 1, i) 7. (jmp, 2,, ) (:=, 1,, i) Init 2. (*, i, d, t2) 3. (<, i, 9, t1) 4. (jfalse, 9,, ) 5. (:=, t2,, a) 6. (+, i, 1, i) 7. (+, t2, d, t2) Incr 8. (jmp, 3,, )

10 Loop Reduction of force: More complex cases Loop increment might not be 1 (could be -1 or > 1): Loop initial value might not be 1 Assume we recognise a quadrule: (*, loop_invariant, loop_variable, result) In such cases, we: 1. Move the matched quadruple to the init phase (after the initialisation of the loop variable ) 2. Insert AFTER this line: (*, loop_increm, loop_invariant, new_invar) ; the increm 3. Place in the Increment part : (+, result, new_invar, result) 19 Loop Reduction of force: complex case Initial value of i = 4, increment = 2 1. (:=, 4,, i) 2. (<, i, 10, t1) 3. (jfalse, 8,, ) 4. (*, i, d, t2) 5. (:=, t2,, a) 6. (+, i, 2, i) 7. (jmp, 2,, ) (:=, 4,, i) 2. (*, i, d, t2) 3. (*, 2, d, ni) 4. (<, i, 10, t1) 5. (jfalse, 11,, ) 6. (:=, t2,, a) 7. (+, i, 2, i) 8. (+, t2, ni, t2) 9. (jmp, 4,, )

11 Loop Reduction of force: complex case Note that if the loop is executed few times, the extra executions OUTSIDE the loop may outway the gain. 1. (:=, 4,, i) 2. (<, i, 10, t1) 3. (jfalse, 8,, ) 4. (*, i, d, t2) 5. (:=, t2,, a) 6. (+, i, 2, i) 7. (jmp, 2,, ) (:=, 4,, i) 2. (*, i, d, t2) 3. (*, 2, d, ni) 4. (<, i, 10, t1) 5. (jfalse, 11,, ) 6. (:=, t2,, a) 7. (+, i, 2, i) 8. (+, t2, ni, t2) 9. (jmp, 4,, ) Reduction of force: Example Given the following source code: for (j=1; j<50; j=j+2;) { k= ( d+j*f ) } Loop The following quadruples could be generated for this code: INIT: (=, 1,, j) LOOP: (*, j, f, t1) (+, t1, d, t2) INCR: (+, j, 2, j) Consider: d and f as loop invariant. The label INIT indicates the start of the INITIALISATION part of the loop. The label LOOP, indicates the start of the BODY of the loop. The label INCR indicates the start of the INCREMENT part of the loop Questions: What is the Loop Variable? What is the Loop Increment? Apply the reduction of force optimisation to the quadruples above 22 11

12 8 8.2 Machine-Independent Dead Code Elimination Dead Code Elimination Identification and Elimination of Dead Code During the coding of applications, involving frequent modification of the source code, sometimes it occurs that variables are set without their value being utilised. Also, as a result of reduction of force and similar optimisations, some assignments might cease to be useful

13 Dead Code Elimination Identification and Elimination of Dead Code Take the following code: void foo() { int a = 24; int b = 25; int c; c = a << 2; return; b = 24; } The last line is unreachable due to the return before it, it can be eliminated. The assignment to b above can also be eliminated, as b is never used. Since c is a local variable, not accessible from outside the function, c and thus a can be eliminated from the function. In fact, since the function returns nothing, and has no global effects, the whole function could be eliminated. 25 Dead Assignments Dead Code Elimination Where an assignment is made to a variable, but the value is never utilised Algorithm: For each occurrence of an assignment to variable V Look at the quadruples below in the same block If we reach another assignment to V BEFORE V is referenced (in Op1 or Op2 field), then we have a dead assignment We can eliminate the earlier assignment to V Note this may create new dead assignments, if the operands of the deleted quadruple have no other reference. For each operand in the deleted quadruple If the operand is a variable Find the previous occuring assignment to that variable repeat this algorithm on that assignment

14 8 8.3 Machine-Dependent Re-arrangement of code Re-arrangement of code Re-arrangement of code In some circumstances, the rearrangement of instructions permits reduction of the size or the complication of the object code. Example In many machines: fixed point multiplication of two integer operands produces a doublelength result, division takes a double and a long as operands, and generates a quotient and a remainder of long length. A simple rearrangement of the operations can give rise to optimizations