1 / 36

Announcements

Announcements. Midterm info HW/SW concepts, numerical representation, pointers, stacks/procedures, arrays/ structs , C- asm -C mapping We will provide a cheat sheet ! Today’s subjects: Data structures! Yay. Data & addressing Integers & floats Machine code & C x86 assembly programming

drew
Download Presentation

Announcements

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript


  1. Announcements • Midterm info • HW/SW concepts, numerical representation, pointers, stacks/procedures, arrays/structs, C-asm-C mapping • We will provide a cheat sheet ! • Today’s subjects: • Data structures! Yay.

  2. Data & addressing Integers & floats Machine code & C x86 assembly programming Procedures & stacks Arrays & structs Memory & caches Processes Virtual memory Memory allocation Java vs. C Roadmap C: Java: Car c = new Car(); c.setMiles(100); c.setGals(17); float mpg = c.getMPG(); car *c = malloc(sizeof(car)); c->miles = 100; c->gals = 17; float mpg = get_mpg(c); free(c); Assembly language: get_mpg: pushq %rbp movq %rsp, %rbp ... popq %rbp ret OS: Machine code: 0111010000011000 100011010000010000000010 1000100111000010 110000011111101000011111 Computer system:

  3. Data Structures in Assembly • Arrays • One-dimensional • Multi-dimensional (nested) • Multi-level • Structs • Alignment • Unions

  4. Array Allocation • Basic Principle • T A[N]; • Array of data type T and length N • Contiguously allocated region of N * sizeof(T) bytes char string[12]; x x + 12 int val[5]; x x + 4 x + 8 x + 12 x + 16 x + 20 double a[3]; x x + 8 x + 16 x + 24 char* p[3];(or char *p[3];) IA32 x x + 4 x + 8 x + 12 x86-64 x x + 8 x + 16 x + 24

  5. 9 8 1 9 5 Array Access • Basic Principle • T A[N]; • Array of data type T and length N • Identifier A can be used as a pointer to array element 0: Type T* • Reference Type Value • val[4] int • valint * • val+1 int * • &val[2] int * • val[5] int • *(val+1) int • val + iint * int val[5]; x x + 4 x + 8 x + 12 x + 16 x + 20

  6. 9 8 1 9 5 Array Access • Basic Principle • T A[N]; • Array of data type T and length N • Identifier A can be used as a pointer to array element 0: Type T* • Reference Type Value • val[4] int • valint * • val+1 int * • &val[2] int * • val[5] int • *(val+1) int • val + iint * int val[5]; x x + 4 x + 8 x + 12 x + 16 x + 20 5 x x + 4 x + 8 ?? (whatever is in memory at address x + 20) 8 x + 4*i

  7. Array Example typedefint zip_dig[5]; zip_digcmu = { 1, 5, 2, 1, 3 }; zip_diguw = { 9, 8, 1, 9, 5 }; zip_digucb = { 9, 4, 7, 2, 0 };

  8. Declaration “zip_diguw” equivalent to “int uw[5]” Example arrays were allocated in successive 20 byte blocks Not guaranteed to happen in general 1 9 9 5 4 8 7 1 2 9 2 1 0 3 5 Array Example typedefint zip_dig[5]; zip_digcmu = { 1, 5, 2, 1, 3 }; zip_diguw = { 9, 8, 1, 9, 5 }; zip_digucb = { 9, 4, 7, 2, 0 }; zip_digcmu; zip_diguw ; 56 36 16 40 20 60 64 44 24 28 68 48 72 32 52 56 36 76 zip_digucb;

  9. 9 8 1 9 5 Array Accessing Example zip_diguw; int get_digit (zip_dig z, int dig) { return z[dig]; } 36 40 44 48 52 56 IA32 # %edx = z # %eax = dig movl (%edx,%eax,4),%eax # z[dig] • Register %edx contains starting address of array • Register %eax contains array index • Desired digit at 4*%eax + %edx • Use memory reference (%edx,%eax,4)

  10. 1 9 9 5 4 8 7 1 2 1 2 9 5 0 3 Referencing Examples zip_digcmu; zip_diguw; zip_digucb; • Reference Address Value Guaranteed? uw[3] uw[6] uw[-1] cmu[15] 36 56 16 40 60 20 44 24 64 68 28 48 52 32 72 56 76 36

  11. 1 9 9 5 4 8 7 2 1 2 1 9 5 3 0 Referencing Examples zip_digcmu; zip_diguw; zip_digucb; • Reference Address Value Guaranteed? uw[3] uw[6] uw[-1] cmu[15] 56 36 16 20 40 60 64 44 24 28 68 48 32 52 72 76 36 56 36 + 4* 3 = 48 9 36 + 4* 6 = 60 4 36 + 4*-1 = 32 3 16 + 4*15 = 76 ??

  12. 1 9 9 5 4 8 7 2 1 2 1 9 5 3 0 Referencing Examples zip_digcmu; zip_diguw; zip_digucb; • Reference Address Value Guaranteed? uw[3] uw[6] uw[-1] cmu[15] • No bounds checking • Location of each separate array in memory is not guaranteed 56 36 16 20 40 60 64 44 24 28 68 48 32 52 72 76 36 56 36 + 4* 3 = 48 9 Yes 36 + 4* 6 = 60 4 No 36 + 4*-1 = 32 3 No 16 + 4*15 = 76 ??No

  13. Array Loop Example int zd2int(zip_dig z) { int i; int zi = 0; for (i = 0; i < 5; i++) { zi = 10 * zi + z[i]; } return zi; }

  14. Array Loop Example int zd2int(zip_dig z) { int i; int zi = 0; for (i = 0; i < 5; i++) { zi = 10 * zi + z[i]; } return zi; } • Original • Transformed • Eliminate loop variable i,use pointer zend instead • Convert array code to pointer code • Pointer arithmetic onz • Express in do-while form(no test at entrance) int zd2int(zip_dig z) { int zi = 0; int *zend = z + 4; do { zi = 10 * zi + *z; z++; } while (z <= zend); return zi; }

  15. Array Loop Implementation (IA32) int zd2int(zip_dig z) { int zi = 0; int *zend = z + 4; do { zi = 10 * zi + *z; z++; } while(z <= zend); return zi; } int zd2int(zip_dig z) { int zi = 0; int *zend = z + 4; do { zi = 10 * zi + *z; z++; } while(z <= zend); return zi; } int zd2int(zip_dig z) { int zi = 0; int *zend = z + 4; do { zi = 10 * zi + *z; z++; } while(z <= zend); return zi; } int zd2int(zip_dig z) { intzi = 0; int *zend = z + 4; do { zi = 10 * zi + *z; z++; } while(z <= zend); return zi; } int zd2int(zip_dig z) { intzi = 0; int *zend = z + 4; do { zi = 10 * zi + *z; z++; } while(z <= zend); return zi; } • Registers %ecx z %eax zi %ebx zend • Computations • 10*zi + *zimplemented as *z + 2*(5*zi) • z++increments by 4 # %ecx = z xorl %eax,%eax # zi = 0 leal 16(%ecx),%ebx # zend = z+4 .L59: leal (%eax,%eax,4),%edx # zi + 4*zi = 5*zi movl (%ecx),%eax # *z addl $4,%ecx # z++ leal (%eax,%edx,2),%eax # zi = *z + 2*(5*zi) cmpl %ebx,%ecx # z : zend jle .L59 # if <= goto loop # %ecx = z xorl %eax,%eax # zi = 0 leal 16(%ecx),%ebx # zend = z+4 .L59: leal (%eax,%eax,4),%edx # zi + 4*zi = 5*zi movl (%ecx),%eax # *z addl $4,%ecx # z++ leal (%eax,%edx,2),%eax # zi = *z + 2*(5*zi) cmpl %ebx,%ecx # z : zend jle .L59 # if <= goto loop # %ecx = z xorl %eax,%eax # zi = 0 leal 16(%ecx),%ebx # zend = z+4 .L59: leal (%eax,%eax,4),%edx # zi + 4*zi = 5*zimovl (%ecx),%eax # *z addl $4,%ecx # z++ leal (%eax,%edx,2),%eax # zi = *z + 2*(5*zi) cmpl %ebx,%ecx # z : zend jle .L59 # if <= goto loop # %ecx = z xorl %eax,%eax # zi = 0 leal 16(%ecx),%ebx # zend = z+4 .L59: leal (%eax,%eax,4),%edx # zi + 4*zi = 5*zi movl (%ecx),%eax # *z addl $4,%ecx # z++ leal (%eax,%edx,2),%eax # zi = *z + 2*(5*zi) cmpl %ebx,%ecx # z : zend jle .L59 # if <= goto loop # %ecx = z xorl %eax,%eax # zi = 0 leal 16(%ecx),%ebx # zend = z+4 .L59: leal (%eax,%eax,4),%edx # zi + 4*zi = 5*zi movl (%ecx),%eax # *z addl $4,%ecx # z++ leal (%eax,%edx,2),%eax # zi = *z + 2*(5*zi) cmpl %ebx,%ecx # z : zend jle .L59 # if <= goto loop

  16. Nested Array Example Remember, T A[N] is an array with elements of type T, with length N #define PCOUNT 4 zip_digsea[PCOUNT] = {{ 9, 8, 1, 9, 5 }, { 9, 8, 1, 0, 5 }, { 9, 8, 1, 0, 3 }, { 9, 8, 1, 1, 5 }}; What is the layout in memory like?

  17. 1 9 9 9 9 8 8 8 8 1 1 1 1 9 0 0 5 3 5 5 Nested Array Example Remember, T A[N] is an array with elements of type T, with length N #define PCOUNT 4 zip_digsea[PCOUNT] = {{ 9, 8, 1, 9, 5 }, { 9, 8, 1, 0, 5 }, { 9, 8, 1, 0, 3 }, { 9, 8, 1, 1, 5 }}; • “Row-major” ordering of all elements • Guaranteed? sea[3][2]; 76 96 116 136 156

  18. A[0][0] • • • A[0][C-1] • • • • • • A[R-1][0] • • • A[R-1][C-1] Multidimensional (Nested) Arrays • Declaration • T A[R][C]; • 2D array of data type T • R rows, C columns • Type T element requires K bytes • Array size?

  19. A[0][0] • • • A[0][C-1] • • • • • • •  •  • A [1] [0] A [0] [0] • • • A [R-1] [0] • • • • • • A [1] [C-1] A [0] [C-1] A [R-1] [C-1] A[R-1][0] • • • A[R-1][C-1] Multidimensional (Nested) Arrays • Declaration • T A[R][C]; • 2D array of data type T • R rows, C columns • Type T element requires K bytes • Array size • R * C * K bytes • Arrangement • Row-major ordering int A[R][C]; 4*R*C Bytes

  20. A[0] A[i] A[R-1] • • • • • • A [R-1] [0] A [0] [0] • • • A [i] [0] A [0] [C-1] A [R-1] [C-1] A [i] [C-1] Nested Array Row Access • Row vectors • T A[R][C]: A[i] is array of C elements • Each element of type T requires K bytes • Starting address A + i * (C * K) int A[R][C]; •  •  • •  •  • A+i*C*4 A+(R-1)*C*4 A

  21. Nested Array Row Access Code int *get_sea_zip(int index) { returnsea[index]; } #define PCOUNT 4 zip_digsea[PCOUNT] = {{ 9, 8, 1, 9, 5 }, { 9, 8, 1, 0, 5 }, { 9, 8, 1, 0, 3 }, { 9, 8, 1, 1, 5 }};

  22. Nested Array Row Access Code int *get_sea_zip(int index) { returnsea[index]; } #define PCOUNT 4 zip_digsea[PCOUNT] = {{ 9, 8, 1, 9, 5 }, { 9, 8, 1, 0, 5 }, { 9, 8, 1, 0, 3 }, { 9, 8, 1, 1, 5 }}; • What data type is sea[index]? • What is its starting address? Translation? # %eax = index leal (%eax,%eax,4),%eax # 5 * index leal sea(,%eax,4),%eax # sea + (20 * index)

  23. Nested Array Row Access Code int *get_sea_zip(int index) { returnsea[index]; } #define PCOUNT 4 zip_digsea[PCOUNT] = {{ 9, 8, 1, 9, 5 }, { 9, 8, 1, 0, 5 }, { 9, 8, 1, 0, 3 }, { 9, 8, 1, 1, 5 }}; • Row Vector • sea[index]is array of 5 ints • Starting addresssea+20*index • IA32 Code • Computes and returns address • Compute assea+4*(index+4*index)=sea+20*index # %eax = index leal (%eax,%eax,4),%eax # 5 * index leal sea(,%eax,4),%eax # sea + (20 * index)

  24. A[0] A[i] A[R-1] • • • • • • • • • A [R-1] [0] • • • A [0] [0] A [i] [j] A [0] [C-1] A [R-1] [C-1] Nested Array Row Access int A[R][C]; •  •  • •  •  • A A + i*C*4 A + (R-1)*C*4 ?

  25. A[0] A[i] A[R-1] • • • • • • • • • A [R-1] [0] • • • A [0] [0] A [i] [j] A [0] [C-1] A [R-1] [C-1] Nested Array Row Access • Array Elements • A[i][j] is element of type T, which requires K bytes • Address A + i * (C * K) + j * K = A + (i * C + j)* K int A[R][C]; •  •  • •  •  • A A + i*C*4 A + (R-1)*C*4 A + i*C*4 + j*4

  26. Nested Array Element Access Code intget_sea_digit (int index, int dig) { returnsea[index][dig]; } zip_digsea[PCOUNT] = {{ 9, 8, 1, 9, 5 }, { 9, 8, 1, 0, 5 }, { 9, 8, 1, 0, 3 }, { 9, 8, 1, 1, 5 }}; • Array Elements • sea[index][dig] is int • Address: sea + 20*index + 4*dig • IA32 Code • Computes address sea + 4*dig + 4*(index+4*index) • movl performs memory reference # %ecx = dig # %eax = index leal 0(,%ecx,4),%edx # 4*dig leal (%eax,%eax,4),%eax # 5*index movl sea(%edx,%eax,4),%eax # *(sea + 4*dig + 20*index)

  27. 1 9 9 9 9 8 8 8 8 1 1 1 1 0 0 9 3 5 5 5 Strange Referencing Examples • Reference Address Value Guaranteed? sea[3][3] sea[2][5] sea[2][-1] sea[4][-1] sea[0][19] sea[0][-1] • Code does not do any bounds checking • Ordering of elements within array guaranteed zip_dig sea[4]; 76 96 116 136 156 • 76+20*3+4*3 = 148 1 Yes 76+20*2+4*5 = 136 9 Yes 76+20*2+4*-1 = 112 5 Yes 76+20*4+4*-1 = 152 5 Yes 76+20*0+4*19 = 152 5 Yes 76+20*0+4*-1 = 72 ?? No

  28. Multi-Level Array Example zip_digcmu = { 1, 5, 2, 1, 3 }; zip_diguw = { 9, 8, 1, 9, 5 }; zip_digucb = { 9, 4, 7, 2, 0 }; #define UCOUNT 3 int *univ[UCOUNT] = {uw, cmu, ucb}; Same thing as a 2D array?

  29. Variable univ denotes array of 3 elements Each element is a pointer 4 bytes Each pointer points to array of ints 9 9 1 4 5 8 1 7 2 2 9 1 3 5 0 univ 36 160 16 164 56 168 Multi-Level Array Example zip_digcmu = { 1, 5, 2, 1, 3 }; zip_diguw = { 9, 8, 1, 9, 5 }; zip_digucb = { 9, 4, 7, 2, 0 }; #define UCOUNT 3 int *univ[UCOUNT] = {uw, cmu, ucb}; cmu 36 56 16 60 20 40 44 64 24 28 68 48 72 32 52 36 76 56 uw ucb Note: this is how Java represents multi-dimensional arrays.

  30. Computation (IA32) Element access Mem[Mem[univ+4*index]+4*dig] Must do two memory reads First get pointer to row array Then access element within array Element Access in Multi-Level Array intget_univ_digit (int index, int dig) { return univ[index][dig]; } # %ecx = index # %eax = dig leal 0(,%ecx,4),%edx # 4*index movl univ(%edx),%edx # Mem[univ+4*index] movl (%edx,%eax,4),%eax # Mem[...+4*dig]

  31. Array Element Accesses Multi-level array Nested array intget_sea_digit (int index, int dig) { returnsea[index][dig]; } intget_univ_digit (int index, int dig) { return univ[index][dig]; } Access looks similar, but it isn’t: Mem[Mem[univ+4*index]+4*dig] Mem[sea+20*index+4*dig]

  32. 9 9 1 8 4 5 7 1 2 1 2 9 5 0 3 univ 36 160 16 164 56 168 Strange Referencing Examples cmu • Reference Address Value Guaranteed? univ[2][3] univ[1][5] univ[2][-1] univ[3][-1] univ[1][12] • Code does not do any bounds checking • Location of each lower-level array in memory is not guaranteed uw ucb 56 16 36 20 40 60 24 44 64 48 68 28 52 72 32 36 76 56 • 56+4*3 = 68 2 Yes 16+4*5 = 36 9 No 56+4*-1 = 52 5 No ?? ?? No 16+4*12 = 64 7 No

  33. Using Nested Arrays #define N 16 typedefintfix_matrix[N][N]; /* Compute element i,k of fixed matrix product */ intfix_prod_ele (fix_matrix a, fix_matrix b, inti, int k) { int j; int result = 0; for (j = 0; j < N; j++) result += a[i][j]*b[j][k]; return result; }

  34. Using Nested Arrays #define N 16 typedefintfix_matrix[N][N]; • Strengths • Generates very efficientassembly code • Avoids multiply in index computation • Limitation • Only works for fixed array size /* Compute element i,k of fixed matrix product */ intfix_prod_ele (fix_matrix a, fix_matrix b, inti, int k) { int j; int result = 0; for (j = 0; j < N; j++) result += a[i][j]*b[j][k]; return result; } a b k-th column x i-th row

  35. Dynamic Nested Arrays int * new_var_matrix(int n) { return (int *) calloc(sizeof(int), n*n); } • Strength • Can create matrix of any size • Programming • Must do index computation explicitly • Performance • Accessing single element costly • Must do multiplication intvar_ele (int *a, inti, intj, int n) { return a[i*n+j]; } movl 12(%ebp),%eax # i movl 8(%ebp),%edx # a imull 20(%ebp),%eax # n*i addl 16(%ebp),%eax # n*i+j movl (%edx,%eax,4),%eax # Mem[a+4*(i*n+j)]

  36. Arrays in C • Contiguous allocations of memory • No bounds checking • Can usually be treated like a pointer to first element

More Related