Solution for Assignment 1

Transcription

1 Solution for Assignment 1 Question 2 a) performance = 1/time infinity, 20, 20, b) infinity, 6, 8, 5 Note: To optimize the price-performance is not to optimize the value of price minus performance. We should optimize the value of price/performance. Question 3 a) Most cache misses are conflict misses to load b[k][j]. Because the cache is direct-mapped, there is one miss to load b[k][j] for each execution of sum+=a[i][k]*b[k][j]. The number of cache misses should be a little greater than 16 (256*256*256 ) million. When executing the inner most loop, ignoring the cache misses of matrix a, the cache should be like (assume b[0][0] maps to cache line 0): 1 st loop1 b[0][0-3]... index=1920 index = index=1920 index = nd loop b[0][0-3]... b[1][0-3]... ith loop th loop b[0][0-3]... b[1][0-3] b[62][0-3] 64 th loop b[0][0-3]... b[1][0-3] b[62][0-3] b[63][0-3] 65 th loop b[64][0-3]... b[1][0-3] b[62][0-3] b[63][0-3] 66 th loop b[64][0-3].. b[65][0-3] b[62][0-3] b[63][0-3] b) A compulsory miss occurs on the first reference to a value, such as a[0][0] when i=j=k=0. A capacity miss occurs when more locations have been referenced since the last reference to the address than there is room in the cache. For example, the b array is larger than the cache, so the load of b[0][0] when i=1, will be a miss, even though it was loaded into the cache earlier when i=0. A conflict miss occurs if a line is forced out of the cache by a reference to another location

2 with the same cache index. For example b[0][0] and b[64][0] have the same cache index. This means that the cache line for b[0][0] (which also holds b[0][1]) is not in the cache when i=0, j=1 and k=0. c) Reduce cache misses. Now b[64][0] is at index 64*8/32 = 16 and b[0-255][0-3] all map to different cache indexes. This means that when b[0][1] is accessed (j=1 loop) the b elements will be in the cache. d) Because C allows pointer operation and access. For example, M[i][j] can be accessed by *(M+256*i+j). Thus, the programmer can tell that the arrays shape has changed and write code that depends on details of the array layout. Question 4 a) Moved instruction preceding each jump into the delay slot after the jump. This works for all jumps except for the jr at the end. Moved the z++ into the delay slot for the branch on (x <= xx).this changes the offsets on stores in the loop from 0(z) to -4(z). Moved the slt $t0, $x, $xx into the delay slot for the branch at the end of the loop. Moved the slt $t0, $z, $zz into the delay slot for the branch on (y <= yy). I changed $t0 to $t3, and put a copy of the instruction into the (x > xx) case earlier. Moved the z++ into the delay slot for the branch on (z <= zz) in the second for loop. Unfilled delay slots: Following the branch on *x < *y. The jr at the end of the function. merge: addu $x, $a, $0 /* x = a */ sll $t0, $m, 2 /* $t0 = m*sizeof(int) */ addu $xx, $a0, $t0 /* xx = a + m */ addu $y, $xx, $0 /* y = xx */ sll $t0, $n, 2 /* $t0 = n*sizeof(int) */ addu $yy, $a, $t0 /* yy = a + n */ addu $zz, $tmp, $t0 /* zz = tmp + n */ j merge_a

3 merge_b: slt $t0, $x, $xx /* $t0 = (x < xx) */ bne $t0, $0, merge_c /* if(x >= xx) */ lw $t0, 0($y) /* $t0 = *y */ addiu $y, $y, 4 /* y++ */ slt $t0 $t3, $z, $zz /* $t0 = z < zz */ sw $t0, 0($z) /* *z = *(y++) */ j merge_d sw $t0, 0($z) /* *z = *(y++) */ merge_c: slt $t0, $y, $yy /* $t0 = (y < yy) */ bne $t0, $0, merge_e /* if(y >= yy) */ slt $t0 $t3, $z, $zz /* $t0 = z < zz */ lw $t0, 0($x) /* $t0 = *x */ sw $t0, 0($z) /* *z = *(x++) */ j merge_d sw $t0, 0 4($z) /* *z = *(x++) */ merge_e: lw $t0, 0($x) /* $t0 = *x */ lw $t1, 0($y) /* $t1 = *y */ slt $t2, $t1, $t0 /* $t2 = y < x */ bne $t2, $0, merge_f /* if(*x <= *y) */ (not filled) sw $t0, 0($z) /* *z = *(x++) */ j merge_d sw $t0, 0 4($z) /* *z = *(x++) */ merge_f: addiu $y, $y, 4 /* y++ */ sw $t1, 0 4($z) /* *z = *(y++) */ merge_d: merge_a: slt $t0, $z, $zz /* $t0 = z < zz */ bne $t0 $t3, $0, merge_b slt $t0, $x, $xx /* $t0 = (x < xx) */

4 addu $x, $a, $0 /* x = a */ j merge_g merge_h: lw $t0, 0($z) /* $t0 = *z */ sw $t0, 0($x) /* *x = *(z++) */ merge_g: slt $t1, $z, $zz /* $t1 = z < zz */ b) bne $t1, $0, merge_h jr $ra /* return */(not filled) There are two stalls. The slt for *x < *y depends on the immediately preceding load. The sw in the second for loop depends on the immediately preceding load. The second stall can be removed by moving the slt between the lw and sw. However, this messes up the first iteration of the loop. If merge() were static (only callable from this function) a compiler could determine that the loop is always performed at least once and eliminate the first branch. Because merge() could be called from outside of merge.c, the compiler must make a special provision for this. I made a copy of the slt instruction in the loop preamble, and put the moved the one for subsequent iterations between the load and store. I don't see a way to remove the first stall without making assumptions about x, y, and z. If, as suggested in the homework, they are all assumed to point at different locations, then writes to *z don't affect values loaded from *x and *y. addu $x, $a, $0 /* x = a */ slt $t1, $z, $zz /* $t1 = z < zz */ j merge_g merge_h: lw $t0, 0($z) /* $t0 = *z */ slt $t1, $z, $zz /* $t1 = z < zz */ sw $t0, 0($x) /* *x = *(z++) */

5 merge_g: slt $t1, $z, $zz /* $t1 = z < zz */ bne $t1, $0, merge_h jr $ra /* return */ c) First, the percent of misprediction of (*x<*y) should be around 50% because of the randomly generated elements. The loops condition z<zz is false until exit the loop. Therefore, the misprediction rate should be quite low. Similarly, the misprediction rate of (x>=xx) and (y>=yy) should be low. In fact, x/y is never greater than xx/yy, and it will not move backward, therefore, at the beginning x>=xx is false, later it is always true. It is easy to predict. My result: pred=not/act=not pred=not/act=tkn pred=tkn/act=not pred=tkn/act=tkn 0: : : : : Code: #define N 1000 #define NTRIALS 1000 #define NBRANCH 5 #include <stdio.h> struct BHT int count, outcome[4]; bht[nbranch]; void init_bht(struct BHT *b, int n) int i, j; for(i = 0; i < n; i++) b[i].count; for(j = 0; j < 4; j++) b >outcome[j] = 0; int min(int a, int b) return((a < b)? a : b); int max(int a, int b) return((a > b)? a : b);

6 int test(int cond, int bnum) int p, a, i; /* predicted and actual */ a = cond!= (bnum < 0); i = (bnum >= 0)? bnum : bnum; p = bht[i].count >= 0; bht[i].count = max(min(bht[i].count + 2*a 1, 1), 2); bht[i].outcome[2*p + a]++; return(cond); void merge(int *a, int m, int n, int *tmp) int *x, *y, *z; int *xx, *yy, *zz; x = a; xx = a+m; y = xx; yy = a+n; zz = tmp+n; for(z = tmp; test(z < zz, 0); z++) if(test(x >= xx, 1)) *z = *(y++); else if(test(y >= yy, 2)) *z = *(x++); else if(test(*x <= *y, 3)) *z = *(x++); else *z = *(y++); x = a; for(z = tmp; test(z < zz, 4); *(x++) = *(z++)); void sort(int *a, int n, int *tmp) int m; if(n == 1) return; m = n >> 1; sort(a, m, tmp); sort(a+m, n m, tmp); merge(a, m, n, tmp); int j; for(j = 0; j < n 1; j++) if(a[j] > a[j+1]) fprintf(stderr, "oops\n"); int main(int argc, char **argv) int i, j; int buf[n], tmp[n]; init_bht(bht, NBRANCH); for(i = 0; i < NTRIALS; i++) for(j = 0; j < N; j++) buf[j] = rand();

7 sort(buf, N, tmp); printf(" pred=not/act=not pred=not/act=tkn pred=tkn/act=not pred=tkn/act=tkn\n"); for(i = 0; i < NBRANCH; i++) printf("%2d: ", i); for(j = 0; j < 4; j++) printf("%16d ", bht[i].outcome[j]); printf("\n"); exit(0);