1
Modul 12
Data Structure
EL3011 Arsitektur Sistem Komputer
STEI - Institut Teknologi Bandung
2
Contents
1. Arrays
• One-dimensional
• Multi-dimensional (nested)
• Multi-level
2. Structure
• Allocation
• Access
• Alignment
This module adopted from 15-213 Introduction to Computer Systems Lecture, Carnegie Mellon
University, 2020
3
Modul 12. Data Structure
12.2. Arrays
EL3011 Arsitektur Sistem Komputer
STEI - Institut Teknologi Bandung
4
Array Allocation
• Basic Principle
T A[L];
• Array of data type T and length L
• Contiguously allocated region of L * sizeof(T) bytes in
memory
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];
x x+8 x + 16 x + 24
5
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:
Type T*
int val[5]; 1 5 2 1 3
x x + 4 x + 8 x + 12 x + 16 x + 20
• Reference Type Value
val[4] int
val int *
val+1 int *
&val[2] int *
val[5] int
*(val+1) int
val + i int *
6
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:
Type T*
int val[5]; 1 5 2 1 3
x x + 4 x + 8 x + 12 x + 16 x + 20
• Reference Type Value
val[4] int 3
val int *
val+1 int *
&val[2] int *
val[5] int
*(val+1) int
val + i int *
7
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:
Type T*
int val[5]; 1 5 2 1 3
x x + 4 x + 8 x + 12 x + 16 x + 20
• Reference Type Value
val[4] int 3
val int * x
val+1 int * x + 4
&val[2] int * x + 8
val[5] int ??
*(val+1) int 5 //val[1]
val + i int * x + 4 * i //&val[i]
8
Array Example
#define ZLEN 5
typedef int zip_dig[ZLEN];
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; 1 5 2 1 3
16 20 24 28 32 36
zip_dig mit; 0 2 1 3 9
36 40 44 48 52 56
zip_dig ucb; 9 4 7 2 0
56 60 64 68 72 76
• Declaration “zip_dig cmu” equivalent to “int cmu[5]”
• Example arrays were allocated in successive 20 byte blocks
• Not guaranteed to happen in general
9
Array Accessing Example
zip_dig cmu; 1 5 2 1 3
16 20 24 28 32 36
int get_digit
(zip_dig z, int digit)
{
return z[digit]; n Register %rdi contains
} starting address of array
n Register %rsi contains
x86-64 array index
# %rdi = z n Desired digit at
# %rsi = digit %rdi + 4*%rsi
movl (%rdi,%rsi,4), %eax # z[digit] n Use memory reference
(%rdi,%rsi,4)
10
Array Loop Example
void zincr(zip_dig z) {
size_t i;
for (i = 0; i < ZLEN; i++)
z[i]++;
}
# %rdi = z
movl $0, %eax # i = 0
jmp .L3 # goto middle
.L4: # loop:
addl $1, (%rdi,%rax,4) # z[i]++
addq $1, %rax # i++
.L3: # middle
cmpq $4, %rax # i:4
jbe .L4 # if <=, goto loop
rep; ret
11
Array Loop Example
void zincr(zip_dig z) {
size_t i;
for (i = 0; i < ZLEN; i++)
z[i]++;
}
# %rdi = z
movl $0, %eax # i = 0
jmp .L3 # goto middle
.L4: # loop:
addl $1, (%rdi,%rax,4) # z[i]++
addq $1, %rax # i++
.L3: # middle
cmpq $4, %rax # i:4
jbe .L4 # if <=, goto loop
rep; ret
12
Understanding Pointers & Arrays #1
Decl A1 , A2 *A1 , *A2
Comp Bad Size Comp Bad Size
int A1[3]
int *A2
• Comp: Compiles (Y/N)
• Bad: Possible bad pointer reference (Y/N)
• Size: Value returned by sizeof
13
Understanding Pointers & Arrays #1
Decl A1 , A2 *A1 , *A2
Comp Bad Size Comp Bad Size
int A1[3]
int *A2
A1 Allocated pointer
Unallocated pointer
A2
Allocated int
Unallocated int
• Comp: Compiles (Y/N)
• Bad: Possible bad pointer reference (Y/N)
• Size: Value returned by sizeof
14
Understanding Pointers & Arrays #1
Decl A1 , A2 *A1 , *A2
Comp Bad Size Comp Bad Size
int A1[3] Y N 12 Y N 4
int *A2 Y N 8 Y Y 4
A1 Allocated pointer
Unallocated pointer
A2
Allocated int
Unallocated int
• Comp: Compiles (Y/N)
• Bad: Possible bad pointer reference (Y/N)
• Size: Value returned by sizeof
15
Understanding Pointers & Arrays #2
Decl An *An **An
Cmp Bad Size Cmp Bad Size Cmp Bad Size
int A1[3]
int *A2[3]
int
(*A3)[3]
Allocated pointer
Unallocated pointer
Allocated int
Unallocated int
16
Understanding Pointers & Arrays #2
Decl An *An **An
Cmp Bad Size Cmp Bad Size Cmp Bad Size
int A1[3]
int *A2[3]
int
(*A3)[3]
A1
A2
A3
Allocated pointer
Unallocated pointer
Allocated int
Unallocated int
17
Understanding Pointers & Arrays #2
Decl An *An **An
Cmp Bad Size Cmp Bad Size Cmp Bad Size
int A1[3] Y N 12 Y N 4 N - -
int *A2[3] Y N 24 Y N 8 Y Y 4
int Y N 8 Y Y 12 Y Y 4
(*A3)[3]
A1
A2
A3
Allocated pointer
Unallocated pointer
Allocated int
Unallocated int
18
Multidimensional (Nested) Arrays
• Declaration A[0][0] • • • A[0][C-1]
T A[R][C];
• 2D array of data type T • •
• •
• R rows, C columns • •
• Array Size A[R-1][0] • • • A[R-1][C-1]
• R * C * sizeof(T) bytes
• Arrangement
• Row-Major Ordering
int A[R][C];
A A A A A A
[0] • • • [0] [1] • • • [1] • • • [R-1] • • • [R-1]
[0] [C-1] [0] [C-1] [0] [C-1]
4*R*C Bytes
19
Nested Array Example
#define PCOUNT 4
typedef int zip_dig[5];
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
1 5 2 0 6 1 5 2 1 3 1 5 2 1 7 1 5 2 2 1
pgh[4];
76 96 116 136 156
• “zip_dig pgh[4]” equivalent to “int
pgh[4][5]”
• Variable pgh: array of 4 elements, allocated contiguously
• Each element is an array of 5 int’s, allocated contiguously
• “Row-Major” ordering of all elements in memory
20
Nested Array Row Access
• Row Vectors
• A[i] is array of C elements of type T
• Starting address A + i * (C * sizeof(T))
int A[R][C];
A[0] A[i] A[R-1]
A A A A A A
[0] ••• [0] • • • [i] ••• [i] • • • [R-1] ••• [R-1]
[0] [C-1] [0] [C-1] [0] [C-1]
A A+(i*C*4) A+((R-1)*C*4)
21
Nested Array Row Access Code
1 5 2 0 6 1 5 2 1 3 1 5 2 1 7 1 5 2 2 1
pgh pgh[2] int *get_pgh_zip(int index)
{
return pgh[index];
}
# %rdi = index
leaq (%rdi,%rdi,4),%rax # 5 * index
leaq pgh(,%rax,4),%rax # pgh + (20 * index)
• Row Vector
• pgh[index] is array of 5 int’s
• Starting address pgh+20*index
• Machine Code
• Computes and returns address
• Compute as pgh + 4*(index+4*index)
22
Nested Array Element 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[0] A[i] A[R-1]
A A A A A
[0] ••• [0] • • • ••• [i] ••• • • • [R-1] ••• [R-1]
[0] [C-1] [j] [0] [C-1]
A A+(i*C*4) A+((R-1)*C*4)
A+(i*C*4)+(j*4)
23
Nested Array Element Access Code
1 5 2 0 6 1 5 2 1 3 1 5 2 1 7 1 5 2 2 1
pgh pgh[1][1] int get_pgh_digit(int index, int dig)
{
return pgh[index][dig];
}
leaq (%rdi,%rdi,4), %rax # 5*index
addl %rax, %rsi # 5*index+dig
movl pgh(,%rsi,4), %eax # M[pgh + 4*(5*index+dig)]
• Array Elements
• pgh[index][dig] is int
• Address: pgh + 20*index + 4*dig
= pgh + 4*(5*index + dig)
24
Multi-Level Array Example
zip_dig cmu = { 1, 5, 2, 1, 3 }; • Variable univ denotes array
zip_dig mit = { 0, 2, 1, 3, 9 }; of 3 elements
zip_dig ucb = { 9, 4, 7, 2, 0 }; • Each element is a pointer
#define UCOUNT 3 • 8 bytes
int *univ[UCOUNT] = {mit, cmu, ucb}; • Each pointer points to array
of int’s
cmu
1 5 2 1 3
univ
16 20 24 28 32 36
160 36 mit
0 2 1 3 9
168 16
176 56 ucb 36 40 44 48 52 56
9 4 7 2 0
56 60 64 68 72 76
25
Element Access in Multi-Level Array
int get_univ_digit
(size_t index, size_t digit)
{
return univ[index][digit];
}
salq $2, %rsi # 4*digit
addq univ(,%rdi,8), %rsi # p = univ[index] + 4*digit
movl (%rsi), %eax # return *p
ret
• Computation
• Element access Mem[Mem[univ+8*index]+4*digit]
• Must do two memory reads
• First get pointer to row array
• Then access element within array
26
Array Element Accesses
Nested array Multi-level array
int get_pgh_digit int get_univ_digit
(size_t index, size_t digit) (size_t index, size_t digit)
{ {
return pgh[index][digit]; return univ[index][digit];
} }
Accesses looks similar in C, but address computations very different:
Mem[pgh+20*index+4*digit] Mem[Mem[univ+8*index]+4*digit]
27
N X N Matrix #define N 16
Code typedef int fix_matrix[N][N];
/* Get element A[i][j] */
int fix_ele(fix_matrix A,
• Fixed dimensions size_t i, size_t j)
• Know value of N at {
compile time return A[i][j];
}
#define IDX(n, i, j) ((i)*(n)+(j))
• Variable dimensions, /* Get element A[i][j] */
explicit indexing int vec_ele(size_t n, int *A,
size_t i, size_t j)
• Traditional way to {
implement dynamic return A[IDX(n,i,j)];
arrays }
/* Get element A[i][j] */
int var_ele(size_t n, int A[n][n],
• Variable dimensions, size_t i, size_t j) {
implicit indexing return A[i][j];
• Now supported by gcc }
28
16 X 16 Matrix Access
¢ Array Elements
§ int A[16][16];
§ Address A + i * (C * K) + j * K
§ C = 16, K = 4
/* Get element A[i][j] */
int fix_ele(fix_matrix A, size_t i, size_t j) {
return A[i][j];
}
# A in %rdi, i in %rsi, j in %rdx
salq $6, %rsi # 64*i
addq %rsi, %rdi # A + 64*i
movl (%rdi,%rdx,4), %eax # Mem[A + 64*i + 4*j]
ret
29
n X n Matrix Access
¢ Array Elements
§ size_t n;
§ int A[n][n];
§ Address A + i * (C * K) + j * K
§ C = n, K = 4
§ Must perform integer multiplication
/* Get element A[i][j] */
int var_ele(size_t n, int A[n][n], size_t i, size_t j)
{
return A[i][j];
}
# n in %rdi, A in %rsi, i in %rdx, j in %rcx
imulq %rdx, %rdi # n*i
leaq (%rsi,%rdi,4), %rax # A + 4*n*i
movl (%rax,%rcx,4), %eax # A + 4*n*i + 4*j
ret
30
Example: Array Access
#include <stdio.h>
#define ZLEN 5
#define PCOUNT 4
typedef int zip_dig[ZLEN];
int main(int argc, char** argv) {
zip_dig pgh[PCOUNT] =
{{1, 5, 2, 0, 6},
{1, 5, 2, 1, 3 },
{1, 5, 2, 1, 7 }, linux> ./array
{1, 5, 2, 2, 1 }};
int *linear_zip = (int *) pgh;
int *zip2 = (int *) pgh[2];
int result =
pgh[0][0] +
linear_zip[7] +
*(linear_zip + 8) +
zip2[1];
printf("result: %d\n", result);
return 0;
}
31
Example: Array Access
#include <stdio.h>
#define ZLEN 5
#define PCOUNT 4
typedef int zip_dig[ZLEN];
int main(int argc, char** argv) {
zip_dig pgh[PCOUNT] =
{{1, 5, 2, 0, 6},
{1, 5, 2, 1, 3 },
{1, 5, 2, 1, 7 }, linux> ./array
{1, 5, 2, 2, 1 }};
result: 9
int *linear_zip = (int *) pgh;
int *zip2 = (int *) pgh[2];
int result =
pgh[0][0] +
linear_zip[7] +
*(linear_zip + 8) +
zip2[1];
printf("result: %d\n", result);
return 0;
}
32
Understanding Pointers & Arrays #3
Decl An *An **An
Cmp Bad Size Cmp Bad Size Cmp Bad Size
int A1[3][5]
int *A2[3][5]
int (*A3)[3][5]
int *(A4[3][5])
int (*A5[3])[5]
Decl ***An
• Cmp: Compiles (Y/N)
• Bad: Possible bad pointer Cmp Bad Size
reference (Y/N) int A1[3][5]
• Size: Value returned by int *A2[3][5]
sizeof int (*A3)[3][5]
int *(A4[3][5])
int (*A5[3])[5]
33
Allocated pointer Declaration
Allocated pointer to unallocated int
int A1[3][5]
Unallocated pointer
Allocated int int *A2[3][5]
Unallocated int int (*A3)[3][5]
int *(A4[3][5])
int (*A5[3])[5]
34
Allocated pointer Declaration
Allocated pointer to unallocated int
int A1[3][5]
Unallocated pointer
Allocated int int *A2[3][5]
Unallocated int int (*A3)[3][5]
int *(A4[3][5])
A1 int (*A5[3])[5]
A2/A4
A3
A5
35
Understanding Pointers & Arrays #3
Decl An *An **An
Cmp Bad Size Cmp Bad Size Cmp Bad Size
int A1[3][5] Y N 60 Y N 20 Y N 4
int *A2[3][5] Y N 120 Y N 40 Y N 8
int (*A3)[3][5] Y N 8 Y Y 60 Y Y 20
int *(A4[3][5]) Y N 120 Y N 40 Y N 8
int (*A5[3])[5] Y N 24 Y N 8 Y Y 20
Decl ***An
• Cmp: Compiles (Y/N)
• Bad: Possible bad pointer Cmp Bad Size
reference (Y/N) int A1[3][5] N - -
• Size: Value returned by int *A2[3][5] Y Y 4
sizeof int (*A3)[3][5] Y Y 4
int *(A4[3][5]) Y Y 4
int (*A5[3])[5] Y Y 4
36
Modul 12. Data Structure
12.2. Structures
EL3011 Arsitektur Sistem Komputer
STEI - Institut Teknologi Bandung
37
Structure Representation
r
struct rec {
int a[4];
size_t i; a i next
struct rec *next;
0 16 24 32
};
• Structure represented as block of memory
• Big enough to hold all of the fields
• Fields ordered according to declaration
• Even if another ordering could yield a more compact
representation
• Compiler determines overall size + positions of fields
• Machine-level program has no understanding of the
structures in the source code
38
Generating Pointer to Structure Member
r r+4*idx
struct rec {
int a[4];
size_t i; a i next
struct rec *next;
0 16 24 32
};
• Generating Pointer to int *get_ap
(struct rec *r, size_t idx)
Array Element {
• Offset of each structure return &r->a[idx];
}
member determined at
compile time
# r in %rdi, idx in %rsi
• Compute as r + leaq (%rdi,%rsi,4), %rax
4*idx ret
39
struct rec {
Following Linked List #1 int a[4];
size_t i;
struct rec *next;
• C Code };
r
long length(struct rec*r) {
long len = 0L;
while (r) { a i next
len ++;
r = r->next; 0 16 24 32
}
return len; Register Value
} %rdi r
• Loop assembly code %rax len
.L11: # loop:
addq $1, %rax # len ++
movq 24(%rdi), %rdi # r = Mem[r+24]
testq %rdi, %rdi # Test r
jne .L11 # If != 0, goto loop
40
struct rec {
Following Linked List #2 int a[4];
size_t i;
struct rec *next;
• C Code };
r
void set_val
(struct rec *r, int val)
{ a i next
while (r) {
size_t i = r->i; 0 16 24 32
// No bounds check Element i
r->a[i] = val;
r = r->next; Register Value
} %rdi r
}
%rsi val
.L11: # loop:
movq 16(%rdi), %rax # i = Mem[r+16]
movl %esi, (%rdi,%rax,4) # Mem[r+4*i] = val
movq 24(%rdi), %rdi # r = Mem[r+24]
testq %rdi, %rdi # Test r
jne .L11 # if !=0 goto loop
41
Structures & Alignment
• Unaligned Data struct S1 {
char c;
c i[0] i[1] v
int i[2];
p p+1 p+5 p+9 p+17 double v;
} *p;
• Aligned Data
• Primitive data type requires B bytes implies
Address must be multiple of B
c 3 bytes i[0] i[1] 4 bytes v
p+0 p+4 p+8 p+16 p+24
Multiple of 4 Multiple of 8
Multiple of 8 Multiple of 8
42
Alignment Principles
• Aligned Data
• Primitive data type requires B bytes
• Address must be multiple of B
• Required on some machines; advised on x86-64
• Motivation for Aligning Data
• Memory accessed by (aligned) chunks of 4 or 8 bytes (system
dependent)
• Inefficient to load or store datum that spans cache lines (64 bytes).
Intel states should avoid crossing 16 byte boundaries.
[Cache lines will be discussed in Lecture 11.]
• Virtual memory trickier when datum spans 2 pages (4 KB pages)
[Virtual memory pages will be discussed in Lecture 17.]
• Compiler
• Inserts gaps in structure to ensure correct alignment of fields
43
Specific Cases of Alignment (x86-64)
• 1 byte: char, …
• no restrictions on address
• 2 bytes: short, …
• lowest 1 bit of address must be 02
• 4 bytes: int, float, …
• lowest 2 bits of address must be 002
• 8 bytes: double, long, char *, …
• lowest 3 bits of address must be 0002
44
Satisfying Alignment with Structures
• Within structure: struct S1 {
char c;
• Must satisfy each element’s alignment requirement int i[2];
• Overall structure placement double v;
} *p;
• Each structure has alignment requirement K
• K = Largest alignment of any element
• Initial address & structure length must be multiples of K
• Example:
• K = 8, due to double element
c 3 bytes i[0] i[1] 4 bytes v
p+0 p+4 p+8 p+16 p+24
Multiple of 4 Multiple of 8
Multiple of 8 Multiple of 8
Internal padding
45
Meeting Overall Alignment Requirement
struct S2 {
double v;
• For largest alignment requirement K int i[2];
char c;
• Overall structure must be multiple of K } *p;
External padding
v i[0] i[1] c 7 bytes
p+0 p+8 p+16 p+24
Multiple of K=8
46
Arrays of Structures struct S2 {
• Overall structure length multiple of K double v;
• Satisfy alignment requirement int i[2];
for every element char c;
} a[10];
a[0] a[1] a[2] • • •
a+0 a+24 a+48 a+72
v i[0] i[1] c 7 bytes
a+24 a+32 a+40 a+48
47
Accessing Array Elements
struct S3 {
short i;
float v;
• Compute array offset 12*idx short j;
• sizeof(S3), including alignment spacers } a[10];
• Element j is at offset 8 within structure
• Assembler gives offset a+8
• Resolved during linking
a[0] • • • a[idx] • • •
a+0 a+12 a+12*idx
i 2 bytes v j 2 bytes
a+12*idx a+12*idx+8
short get_j(int idx)
# %rdi = idx
{
leaq (%rdi,%rdi,2),%rax # 3*idx
return a[idx].j;
movzwl a+8(,%rax,4),%eax
}
48
Saving Space
• Put large data types first
struct S4 { struct S5 {
char c; int i;
int i; char c;
char d; char d;
} *p; } *p;
c 3 bytes i d 3 bytes 12 bytes
• Effect (largest alignment requirement K=4)
i c d 2 bytes 8 bytes
49
Example Struct Exam Question
http://www.cs.cmu.edu/~213/oldexams/exam1-f12.pdf
50
Example Struct Exam Question
a X X X X X X X b b b b b b b b
c c c c d d d X e e e e e e e e
f f f f f f f f|
http://www.cs.cmu.edu/~213/oldexams/exam1-f12.pdf
51
Example Struct Exam Question (Cont’d)
http://www.cs.cmu.edu/~213/oldexams/exam1-f12.pdf
52
Example Struct Exam Question (Cont’d)
a d d d c c c c b b b b b b b b
e e e e e e e e f f f f f f f f|
http://www.cs.cmu.edu/~213/oldexams/exam1-f12.pdf
53
Summary
• Arrays
• Elements packed into contiguous region of memory
• Use index arithmetic to locate individual elements
• Structures
• Elements packed into single region of memory
• Access using offsets determined by compiler
• Possible require internal and external padding to ensure alignment
• Combinations
• Can nest structure and array code arbitrarily
