1. 1 Code Optimization

2. 2 Outline Machine-Independent Optimization –Code motion –Memory optimization Suggested reading –5.2 ~ 5.6

3. 3 Motivation Constant factors matter too! –easily see 10:1 performance range depending on how code is written –must optimize at multiple levels algorithm, data representations, procedures, and loops

4. 4 Motivation Must understand system to optimize performance –how programs are compiled and executed –how to measure program performance and identify bottlenecks –how to improve performance without destroying code modularity and generality

5. 5 5.2 Expressing Program Performance

6. 6 Time Scales P382 Absolute Time –Typically use nanoseconds 10 –9 seconds –Time scale of computer instructions

7. 7 Time Scales Clock Cycles –Most computers controlled by high frequency clock signal –Typical Range 100 MHz –10 8 cycles per second –Clock period = 10ns 2 GHz –2 X 10 9 cycles per second –Clock period = 0.5ns

8. 8 CPE P383 1 void vsum1(int n) 2 { 3 int i; 4 5 for (i = 0; i < n; i++) 6 c[i] = a[i] + b[i]; 7 } 8

9. 9 CPE P383 9 /* Sum vector of n elements (n must be even) */ 10 void vsum2(int n) 11 { 12 int i; 13 14 for (i = 0; i < n; i+=2) { 15 /* Compute two elements per iteration */ 16 c[i] = a[i] + b[i]; 17 c[i+1] = a[i+1] + b[i+1]; 18 } 19 }

10. 10 Cycles Per Element Convenient way to express performance of program that operators on vectors or lists Length = n T = CPE*n + Overhead

11. 11 Cycles Per Element Figure 5.2 P383 vsum1 Slope = 4.0 vsum2 Slope = 3.5

12. 12 5.3 Program Example 5.4 Eliminating Loop Inefficiencies 5.5 Reducing Procedure Calls 5.6 Eliminating Unneeded Memory References

13. 13 5.3 Program Example

14. 14 Vector ADT P384 typedef struct { int len ; data_t *data ; } vec_rec, *vec_ptr ; typedef int data_t ; length data      012length–1 Figure 5.3 P385

15. 15 Procedures P386 vec_ptr new_vec(int len) –Create vector of specified length data_t *get_vec_start(vec_ptr v) –Return pointer to start of vector data P392 P386

16. 16 Procedures int get_vec_element( vec_ptr v, int index, int *dest ) –Retrieve vector element, store at *dest –Return 0 if out of bounds, 1 if successful Similar to array implementations in Pascal, Java –E.g., always do bounds checking P386

17. 17 Vector ADT vec_ptr new_vec(int len) { /* allocate header structure */ vec_ptr result = (vec_ptr) malloc(sizeof(vec_rec)) ; if ( !result ) return NULL ;

18. 18 Vector ADT /* allocate array */ if ( len > 0 ) { data_t *data = (data_t *)calloc(len, sizeof(data_t)) ; if ( !data ) { free( (void *)result ) ; return NULL ; /* couldn’t allocte stroage */ } result->data = data } else result->data = NULL return result ; }

19. 19 Vector ADT /* * Retrieve vector element and store at dest. * Return 0 (out of bounds) or 1 (successful) */ int get_vec_element(vec_ptr v, int index, data_t *dest) { if ( index = v->len) return 0 ; *dest = v->data[index] ; return 1; }

20. 20 Vector ADT /* Return length of vector */ int vec_length(vec_ptr) { return v->len ; } /* Return pointer to start of vector data */ data_t *get_vec_start(vec_ptr v) { return v->data ; } P392

21. 21 Optimization Example P385 #ifdef ADD #define IDENT 0 #define OPER + #else #define IDENT 1 #define OPER * #endif

22. 22 Optimization Example P387 void combine1(vec_ptr v, data_t *dest) { int i; *dest = IDENT; for (i = 0; i < vec_length(v); i++) { int val; get_vec_element(v, i, &val); *dest = *dest OPER val; }

23. 23 Optimization Example Procedure –Compute sum (product) of all elements of vector –Store result at destination location

24. 24 Time Scales P387 void combine1(vec_ptr v, int *dest) { int i; *dest = 0; for (i = 0; i < vec_length(v); i++) { int val; get_vec_element(v, i, &val); *dest += val; } 5.3 Program Example

25. 25 Time Scales P385 Procedure –Compute sum of all elements of integer vector –Store result at destination location –Vector data structure and operations defined via abstract data type Pentium II/III Performance: CPE –42.06 (Compiled -g)31.25 (Compiled -O2)

26. 26 Understanding Loop void combine1-goto(vec_ptr v, int *dest) { int i = 0; int val; *dest = 0; if (i >= vec_length(v)) goto done; loop: get_vec_element(v, i, &val); *dest += val; i++; if (i < vec_length(v)) goto loop done: } 1 iteration

27. 27 Inefficiency Procedure vec_length called every iteration Even though result always the same 5.4 Eliminating Loop Inefficiencies

28. 28 Code Motion P388 void combine2(vec_ptr v, int *dest) { int i; int length = vec_length(v); *dest = 0; for (i = 0; i < length; i++) { int val; get_vec_element(v, i, &val); *dest += val; }

29. 29 Code Motion P388 Optimization –Move call to vec_length out of inner loop Value does not change from one iteration to next Code motion –CPE: 22.61 (Compiled -O2) vec_length requires only constant time, but significant overhead

30. 30 Reduction in Strength P392 void combine3(vec_ptr v, int *dest) { int i; int length = vec_length(v); int *data = get_vec_start(v); *dest = 0; for (i = 0; i < length; i++) { *dest += data[i]; } 5.5 Reducing Procedure Calls

31. 31 Reduction in Strength Optimization –Avoid procedure call to retrieve each vector element Get pointer to start of array before loop Within loop just do pointer reference Not as clean in terms of data abstraction –CPE: 6.00 (Compiled -O2) Procedure calls are expensive! Bounds checking is expensive

32. 32 Eliminate Unneeded Memory References P394 void combine4(vec_ptr v, int *dest) { int i; int length = vec_length(v); int *data = get_vec_start(v); int sum = 0; for (i = 0; i < length; i++) sum += data[i]; *dest = sum; } 5.6 Eliminating Unneeded Memory References

33. 33 Eliminate Unneeded Memory References Optimization –Don’t need to store in destination until end –Local variable sum held in register –Avoids 1 memory read, 1 memory write per cycle –CPE: 2.00 (Compiled -O2) Memory references are expensive!

34. 34 Detecting Unneeded Memory References.L18: movl (%ecx,%edx,4),%eax addl %eax,(%edi) incl %edx cmpl %esi,%edx jl.L18.L24: addl (%eax,%edx,4),%ecx incl %edx cmpl %esi,%edx jl.L24 Combine3Combine4

35. 35 Detecting Unneeded Memory References Performance –Combine3 5 instructions in 6 clock cycles addl must read and write memory –Combine4 4 instructions in 2 clock cyles