course 15-213
The that gives CMU its Zip!
Machine-Level Programming IV: Structured Data Sept. 19, 2002
Topics
Arrays Structs Unions
class08.ppt
Basic Data Types
Integral
Stored & operated on in general registers Signed vs. unsigned depends on instructions used
Intel GAS byte b word w double word [unsigned] int Floating Point
Bytes 1 2 l
C [unsigned] char [unsigned] short 4
Stored & operated on in floating point registers
2
Intel Single Double
GAS s l
Bytes 4 8
C float double
15-213, F02
Array Allocation
Basic Principle T A[L];
Array of data type T and length L Contiguously allocated region of L * sizeof(T) bytes
char string[12]; x int val[5]; double a[4]; x x+4 x+8 x + 12 x + 16 x + 20 x + 12
x char *p[3];
x+8
x + 16
x + 24
x + 32
x
3
x+4
x+8
15-213, F02
Array Access
Basic Principle T A[L];
Array of data type T and length L Identifier A can be used as a pointer to array element 0
1 x 5 x+4 2 x+8 1 x + 12 3 x + 16 x + 20
int val[5];
Reference val[4] val val+1 &val[2] val[5] 4 *(val+1)
Type int int * int * int * int int
Value 3 x x+4 x+8 ?? 5
15-213, F02
Array Example
typedef int zip_dig[5]; zip_dig cmu = { 1, 5, 2, 1, 3 }; zip_dig mit = { 0, 2, 1, 3, 9 }; zip_dig ucb = { 9, 4, 7, 2, 0 }; zip_dig cmu; 16 zip_dig mit; 36 zip_dig ucb; 56 9 60 0 40 4 64 1 20 2 44 7 68 5 24 1 48 2 72 2 28 3 52 0 76 1 32 9 56 3 36
Notes
5
Declaration zip_dig cmu equivalent to int cmu[5] Example arrays were allocated in successive 20 byte blocks
Not guaranteed to happen in general
15-213, F02
Array Accessing Example
Computation
Register %edx contains starting address of array Register %eax contains array index Desired digit at 4*%eax + %edx Use memory reference (%edx, %eax,4)
int get_digit (zip_dig z, int dig) { return z[dig]; }
Memory Reference Code
# %edx = z # %eax = dig movl (%edx,%eax,4),%eax # z[dig]
6
15-213, F02
Referencing Examples
zip_dig cmu; 16 zip_dig mit; 36 zip_dig ucb; 56 9 60 0 40 4 64 1 20 2 44 7 68 5 24 1 48 2 72 2 28 3 52 0 76 1 32 9 56 3 36
Code Does Not Do Any Bounds Checking! Reference mit[3] mit[5] mit[-1] cmu[15]
7
Address 36 + 4* 3 36 + 4* 5 36 + 4*-1 16 + 4*15
= = = =
Value 48 56 32 76
Guaranteed? 3 Yes No 9 No 3 No ??
15-213, F02
Out of range behavior implementation-dependent
No guaranteed relative allocation of different arrays
Array Loop Example
Original Source
int zd2int(zip_dig z) { int i; int zi = 0; for (i = 0; i < 5; i++) { zi = 10 * zi + z[i]; } 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; }
15-213, F02
Transformed Version
As generated by GCC Eliminate loop variable i Convert array code to pointer code Express in do-while form
No need to test at entrance
8
Array Loop Implementation
Registers %ecx z %eax zi %ebx zend Computations
10*zi + *z implemented as *z + 2*(zi+4*zi) z++ increments by 4
# %ecx = z xorl %eax,%eax leal 16(%ecx),%ebx .L59: leal (%eax,%eax,4),%edx movl (%ecx),%eax addl $4,%ecx leal (%eax,%edx,2),%eax cmpl %ebx,%ecx jle .L59
int zd2int(zip_dig z) { int zi = 0; int *zend = z + 4; do { zi = 10 * zi + *z; z++; } while(z <= zend); return zi; } # zi = 0 # zend = z+4 # # # # # # 5*zi *z z++ zi = *z + 2*(5*zi) z : zend if <= goto loop
9
15-213, F02
Nested Array Example
#define PCOUNT 4 zip_dig pgh[PCOUNT] = {{1, 5, 2, 0, 6}, {1, 5, 2, 1, 3 }, {1, 5, 2, 1, 7 }, {1, 5, 2, 2, 1 }}; zip_dig pgh[4]; 1 5 2 0 6 1 5 2 1 3 1 5 2 1 7 1 5 2 2 1 76
96
116
136
156
Declaration zip_dig pgh[4] equivalent to int pgh[4][5]
Variable pgh denotes array of 4 elements
Allocated contiguously Each element is an array of 5 ints Allocated contiguously
10
Row-Major ordering of all elements guaranteed
15-213, F02
Nested Array Allocation
Declaration T A[R][C];
A[0][0] A[R-1][0]
A[0][C-1]
Array of data type T R rows, C columns Type T element requires K bytes
A[R-1][C-1]
Array Size
R * C * K bytes
int A[R][C]; A A [R-1] [R-1] [0] [C-1]
15-213, F02
Arrangement
Row-Major Ordering
A A A A [0] [0] [1] [1] [0] [C-1] [0] [C-1] 4*R*C Bytes
11
Nested Array Row Access
Row Vectors
A[i] is array of C elements Each element of type T Starting address A + i * C * K
int A[R][C]; A[0] A [0] [0] A A [0] [C-1] A [i] [0] A[i] A A [i] [R-1] [C-1] [0] A[R-1] A [R-1] [C-1]
A+i*C*4
A+(R-1)*C*4
15-213, F02
12
Nested Array Row Access Code
int *get_pgh_zip(int index) { return pgh[index]; }
Row Vector
pgh[index] is array of 5 ints Starting address pgh+20*index
Code
Computes and returns address Compute as pgh + 4*(index+4*index)
# %eax = index leal (%eax,%eax,4),%eax # 5 * index leal pgh(,%eax,4),%eax # pgh + (20 * index)
13
15-213, F02
Nested Array Element Access
Array Elements
A[i][j] is element of type T Address A + (i * C + j) * K
A [i] [j]
int A[R][C]; A[0] A [0] [0] A A [0] [C-1] A[i] A [i] [j] A [R-1] [0] A[R-1] A [R-1] [C-1]
A+i*C*4 A+(i*C+j)*4
A+(R-1)*C*4
14
15-213, F02
Nested Array Element Access Code
Array Elements
pgh[index][dig] is int Address:
pgh + 20*index + Code
int get_pgh_digit (int index, int dig) { 4*dig return pgh[index][dig]; }
Computes address
pgh + 4*dig + 4*(index+4*index)
movl dig #%ecx = performs memory reference # %eax = index leal 0(,%ecx,4),%edx # 4*dig leal (%eax,%eax,4),%eax # 5*index movl pgh(%edx,%eax,4),%eax # *(pgh + 4*dig + 20*index)
15 15-213, F02
Strange Referencing Examples
zip_dig pgh[4]; 1 5 2 0 6 1 5 2 1 3 1 5 2 1 7 1 5 2 2 1 76 96 116 136 156
Reference Address pgh[3][3] 2 pgh[2][5] 1 pgh[2][-1] 112 3 pgh[4][-1] 152 1 16 pgh[0][19]
Value Guaranteed? Yes 76+20*3+4*3 = 148
Yes Yes No Yes 76+20*2+4*5 = 136 Yes 76+20*2+4*-1 =
76+20*4+4*-1 = 76+20*0+4*19 =
15-213, F02
Multi-Level Array Example
Variable univ denotes array of 3 elements Each element is a pointer
4 bytes
zip_dig cmu = { 1, 5, 2, 1, 3 }; zip_dig mit = { 0, 2, 1, 3, 9 }; zip_dig ucb = { 9, 4, 7, 2, 0 }; #define UCOUNT 3 int *univ[UCOUNT] = {mit, cmu, ucb};
Each pointer points to array of ints
univ 160 164 168 36 16 56
cmu 16
1 20 0 40 9 60
5 24 2 44 4 64
2 28 1 48 7 68
1 32 3 52 2 72
3 36 9 56 0 76
mit
ucb 36 56
17
15-213, F02
Element Access in Multi-Level Array
int get_univ_digit (int index, int dig) { return univ[index][dig]; }
Computation
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
# %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]
18 15-213, F02
Array Element Accesses
Similar C references
Different address computation
Nested Array
int get_pgh_digit (int index, int dig) { return pgh[index][dig]; }
Multi-Level Array
int get_univ_digit (int index, int dig) { return univ[index][dig]; }
Element at
Element at
Mem[pgh+20*index+4*dig]
Mem[Mem[univ+4*index]+4*dig]
cmu univ 160 164 168 16 0 40 9 60 4 64 1 20 2 44 7 68 5 24 1 48 2 72 2 28 3 52 0 76 1 32 9 56 3 36
1 5 2 0 6 1 5 2 1 3 1 5 2 1 7 1 5 2 2 1 76 96 116 136 156
36 16 56
mit
ucb 36 56
19
15-213, F02
Strange Referencing Examples
cmu univ 160 164 168 36 16 56 mit 16 0 40 9 60 4 64 1 20 2 44 7 68 5 24 1 48 2 72 2 28 3 52 0 76 1 32 9 56 3 36
ucb 36 56
Reference Address
univ[2][3] 56+4*3 = 68 univ[1][5] 16+4*5 = 36 univ[2][-1] 56+4*-1 = 52 univ[3][-1] ??
Value
2 0 9 ??
Guaranteed?
Yes No No No No
univ[1][12] 16+4*12 = 64 7 Code does not do any bounds checking
Ordering of elements in different arrays not guaranteed
15-213, F02
20
Using Nested Arrays
Strengths
#define N 16 typedef int fix_matrix[N][N]; /* Compute element i,k of fixed matrix product */ int fix_prod_ele (fix_matrix a, fix_matrix b, int i, int k) { int j; int result = 0; for (j = 0; j < N; j++) result += a[i][j]*b[j][k]; return result; }
C compiler handles doubly subscripted arrays Generates very efficient code
Avoids multiply in index
computation
Limitation
Only works if have fixed array size
(*,k) (i,*)
Row-wise
21
A
B
15-213, F02
Column-wise
Dynamic Nested Arrays
Strength
Can create matrix of arbitrary size
Programming
int * new_var_matrix(int n) { return (int *) calloc(sizeof(int), n*n); } int var_ele (int *a, int i, int j, int n) { return a[i*n+j]; } # # # # # i a n*i n*i+j Mem[a+4*(i*n+j)]
15-213, F02
Must do index computation explicitly
Performance
Accessing single element costly Must do multiplication
movl 12(%ebp),%eax movl 8(%ebp),%edx imull 20(%ebp),%eax addl 16(%ebp),%eax movl (%edx,%eax,4),%eax
22
Dynamic Array Multiplication
Without Optimizations
Multiplies
2 for subscripts 1 for data
Adds
4 for array indexing 1 for loop index 1 for data
(*,k) (i,*) Row-wise A B Column-wise
23
/* Compute element i,k of variable matrix product */ int var_prod_ele (int *a, int *b, int i, int k, int n) { int j; int result = 0; for (j = 0; j < n; j++) result += a[i*n+j] * b[j*n+k]; return result; }
15-213, F02
Optimizing Dynamic Array Mult.
{
Optimizations
Performed set when optimization level to -O2 Expression i*n can be computed outside loop
} {
Code Motion
int j; int result = 0; for (j = 0; j < n; j++) result += a[i*n+j] * b[j*n+k]; return result;
Strength Reduction
Incrementing j has effect of incrementing j*n+k by n
Performance
Compiler can optimize regular access patterns
}
int j; int result = 0; int iTn = i*n; int jTnPk = k; for (j = 0; j < n; j++) { result += a[iTn+j] * b[jTnPk]; jTnPk += n; } return result;
15-213, F02
24
Structures
Concept
Contiguously-allocated region of memory Refer to members within structure by names Members may be of different types
struct rec { int i; int a[3]; int *p; };
Memory Layout
i 0 4 a p 16 20
Accessing Structure Member
void set_i(struct rec *r, int val) { r->i = val; }
25
Assembly
# %eax = val # %edx = r movl %eax,(%edx)
# Mem[r] = val
15-213, F02
Generating Pointer to Struct. Member
r struct rec { int i; int a[3]; int *p; }; i 0 4 a p 16 r + 4 + 4*idx int * find_a (struct rec *r, int idx) { return &r->a[idx]; }
Generating Pointer to Array Element
Offset of each structure member determined at compile time
# %ecx = idx # %edx = r leal 0(,%ecx,4),%eax # 4*idx leal 4(%eax,%edx),%eax # r+4*idx+4
26 15-213, F02
Structure Referencing (Cont.)
C Code
struct rec { int i; int a[3]; int *p; }; void set_p(struct rec *r) { r->p = &r->a[r->i]; } 0 i 0 4 Element i i 4 a 16 a p 16
# %edx = r movl (%edx),%ecx leal 0(,%ecx,4),%eax leal 4(%edx,%eax),%eax movl %eax,16(%edx)
# # # #
r->i 4*(r->i) r+4+4*(r->i) Update r->p
27
15-213, F02
Alignment
Aligned Data
Primitive data type requires K bytes Address must be multiple of K Required on some machines; advised on IA32
treated differently by Linux and Windows!
Motivation for Aligning Data
Memory accessed by (aligned) double or quad-words
Inefficient to load or store datum that spans quad word
boundaries Virtual memory very tricky when datum spans 2 pages
Compiler
Inserts gaps in structure to ensure correct alignment of fields
15-213, F02
28
Specific Cases of Alignment
Size of Primitive Data Type:
1 byte (e.g., char)
no restrictions on address
2 bytes (e.g., short)
lowest 1 bit of address must be 02
4 bytes (e.g., int, float, char *, etc.)
lowest 2 bits of address must be 002
8 bytes (e.g., double)
Windows (and most other OSs & instruction sets):
lowest 3 bits of address must be 0002 Linux: lowest 2 bits of address must be 002 i.e., treated the same as a 4-byte primitive data type
12 bytes (long double)
Linux:
29
lowest 2 bits of address must be 002 i.e., treated the same as a 4-byte primitive data type
15-213, F02
Satisfying Alignment with Structures
Offsets Within Structure
Must satisfy elements alignment requirement
Overall Structure Placement
Each structure has alignment requirement K
Largest alignment of any element
struct S1 { char c; int i[2]; double v; } *p;
Initial address & structure length must be multiples of K
Example (under Windows):
K = 8, due to double element
i[0] p+4 Multiple of 4 p+8 i[1] p+16 Multiple of 8 Multiple of 8
15-213, F02
c p+0
v p+24
Multiple of 8
30
Linux vs. Windows
Windows (including Cygwin):
K = 8, due to double element
c i[0] p+4 p+8 i[1]
struct S1 { char c; int i[2]; double v; } *p; v p+16 Multiple of 8 p+24 Multiple of 8
p+0
Multiple of 4 Multiple of 8
Linux:
K = 4; double treated like a 4-byte data type
c p+0 i[0] p+4 p+8 i[1] p+12 Multiple of 4 Multiple of 4
15-213, F02
v p+20
Multiple of 4 Multiple of 4
31
Overall Alignment Requirement
struct S2 { double x; int i[2]; char c; } *p; x p+0 struct S3 { float x[2]; int i[2]; char c; } *p; x[0] p+0
32
p must be multiple of: 8 for Windows 4 for Linux
i[0] p+8 p+12 i[1] c p+16 Windows: p+24 Linux: p+20
p must be multiple of 4 (in either OS)
x[1] p+4 p+8
i[0] p+12
i[1]
c p+16 p+20
15-213, F02
Ordering Elements Within Structure
struct S4 { char c1; double v; char c2; int i; } *p; c1 p+0 struct S5 { double v; char c1; char c2; int i; } *p; v p+0
33
10 bytes wasted space in Windows
v p+8
c2 p+16 p+20
i p+24
2 bytes wasted space
c1 c2 p+8 p+12
i p+16
15-213, F02
Arrays of Structures
Principle
Allocated by repeating allocation for array type In general, may nest arrays & structures to arbitrary depth
struct S6 { short i; float v; short j; } a[10];
a[1].i a+12 a+16
a[1].v
a[1].j a+20 a+24
a[0] a+0 a+12
a[1] a+24
a[2] a+36
34
15-213, F02
Accessing Element within Array
Compute offset to start of structure
Compute 12*i as 4*(i+2i)
Access element according to its offset within structure
Offset by 8 Assembler gives displacement as a + 8
struct S6 { short i; float v; short j; } a[10];
Linker must set actual value short get_j(int idx) { return a[idx].j; }
a[0] a+0
# %eax = idx leal (%eax,%eax,2),%eax # 3*idx movswl a+8(,%eax,4),%eax
a+12i
a[i]
a[i].i a+12i
35
a[i].v
a[i].j a+12i+8
15-213, F02
Satisfying Alignment within Structure
Achieving Alignment
Starting address of structure array must be multiple of worst-case alignment for any element
a must be multiple of 4
Offset of element within structure must be multiple of elements alignment requirement
vs offset of 4 is a multiple of 4
Overall size of structure must be multiple of worst-case alignment for any element
Structure padded with unused space to be 12
struct S6 { short i; float v; short j; }...