Systems Programming and Computer Architecture ( )

Size: px

Start display at page:

Download "Systems Programming and Computer Architecture ( )"

Merry Sharyl Black
6 years ago
Views:

1 Systems Group Department of Computer Science ETH Zürich Systems Programming and Computer Architecture ( ) Timothy Roscoe Herbstsemester 2016 AS 2016 Dynamic Memory Allocation 1

2 5: Dynamic memory allocation Computer Architecture and Systems Programming , Herbstsemester 2016 Timothy Roscoe AS 2016 Dynamic Memory Allocation 2

3 Allocating memory so far counter is statically allocated allocated when program is loaded deallocated when program exits a, x, y are automatically allocated allocated when function is called deallocated when function returns // a global variable int counter = 0; int main(int argc, char *argv[]) { counter++; return 0; int foo(int a) { int x = a + 1; return x int main(int argc, char *argv[]) { int y = foo(10); return 0; AS 2016 Dynamic Memory Allocation 3

4 Often we want memory that Persists across multiple function calls, but not for the whole lifetime of the program. Is too big to fit on the stack. Is allocated and returned by a function as a result whose size is not known to the caller. // This is pseudo-c! char *ReadFile(char *filename) { int size = FileSize(filename); char *buffer = AllocateMemory(size); ReadFileIntoBuffer(filename, buffer); return buffer; AS 2016 Dynamic Memory Allocation 4

5 Dynamically allocated memory Program explicitly requests new block of memory Language runtime allocates it, perhaps using the OS Dynamically allocated memory persists until: code explicitly deallocates it [manual memory management], or garbage collector collects it [automatic memory management] C requires manual memory management Much more control Much more care needed AS 2016 Dynamic Memory Allocation 5

6 This is the heart of C! and much systems programming! Non-trivial C programs are all about: Allocating and managing memory explicitly Filling it with structured types Using pointers to build complex dynamic data structures AS 2016 Dynamic Memory Allocation 6

7 5.1: The C memory API Computer Architecture and Systems Programming , Herbstsemester 2016 Timothy Roscoe AS 2016 Dynamic Memory Allocation 7

8 malloc() // declared in stdlib.h typedef unsigned long size_t; void *malloc(size_t sz); Allocates a block of memory of the given size returns a pointer to the first byte of that memory returns NULL if the memory cannot be allocated you should assume the memory initially contains garbage typically use sizeof() to calculate the size you need float *arr = (float *)malloc(10*sizeof(float)); if (arr == NULL) { return ERRCODE; arr[0] = 5.1; // etc. AS 2016 Dynamic Memory Allocation 8

9 calloc() // declared in stdlib.h void *calloc(size_t nm, size_t sz); Allocates a block of memory size (nm sz) Like malloc(), a pointer to the first byte of that memory returns NULL if the memory cannot be allocated zeroes the memory - unlike malloc() Slightly slower, but less error-prone, more readable float *arr = (float *)calloc(10, sizeof(float)); if (arr == NULL) { return ERRCODE; arr[0] = 5.1; // etc. AS 2016 Dynamic Memory Allocation 9

10 Deallocation // declared in stdlib.h void free(void *); Releases memory at the pointer Must point to the first byte of malloc ed memory After freeing, memory might be reallocated by some future malloc()/calloc() Good practice to NULL the pointer after freeing. float *arr = (float *)calloc(10, sizeof(float)); if (arr == NULL) { return ERRCODE; // Do something... free(arr); arr = NULL; AS 2016 Dynamic Memory Allocation 10

11 Reallocation // declared in stdlib.h void *realloc(void *ptr, size_t size); Allocations have a fixed size. realloc() changes the size of the block As with free(), must point to first byte of a malloc ed block Might (almost certainly will!) copy the data to a new location Always use the new address returned! Returns NULL if failed. float *arr; if (!(arr = (float *)malloc(10*sizeof(float)))) { return ERRCODE; //... do something... if (!(arr = (float *)realloc(arr, 20*sizeof(float)))) { return ERRCODE; AS 2016 Dynamic Memory Allocation 11

12 A bit more about size_t size_t: An unsigned integer of some size Return type of sizeof() Large enough to hold the size of the largest possible array in memory can be used to store a pointer ptrdiff_t: An unsigned integer of some size Result of subtracting two pointers Used for array loops, size calculations, etc. Ends up identical to size_t AS 2016 Dynamic Memory Allocation 12

13 A variety of size models ( AS 2016 Dynamic Memory Allocation 13

14 Summary /* This program simply reads integers into a dynamic array until eof. The array is expanded as needed */ #include <stdio.h> #include <stdlib.h> // Initial array size #define INIT_SIZE 8 int main(int argc, char *argv[]) { int num; // Num. of integers int *arr; // Array of ints. size_t sz; // Array size int m, in; // Index & input num // Allocate the initial space. sz = INIT_SIZE; arr = (int *)calloc(sz, sizeof(int)); if (arr == NULL) { fprintf(stderr, realloc failed.\n"); exit(1); // Read in the numbers. num = 0; while(scanf("%d", &in) == 1) { // See if there's room. if(num >= sz) { // There's not. Get more. sz *= 2; arr = (int *)realloc(arr, sz*sizeof(int)); if(arr == NULL) { fprintf(stderr, realloc failed.\n"); exit(1); // Store the number. arr[num++] = in; // Print out the numbers for(m = 0; m < num; ++m) { printf("%d\n", arr[m]); free(arr); // Always good to free return 0; calloc.c AS 2016 Dynamic Memory Allocation 14

15 5.2: Managing the heap Computer Architecture and Systems Programming , Herbstsemester 2016 Timothy Roscoe AS 2016 Dynamic Memory Allocation 15

16 Where does all this memory come from? The heap (or free store ) Large pool of unused memory, used for dynamically allocated data structures malloc() allocates chunks of memory in the heap, free() returns them malloc() maintains bookkeeping data in the heap to track allocated blocks. Kernel virtual memory User stack shared libraries Run-time heap Read/write segment (.data,.bss) Read-only segment (.init,.text,.rodata) Unused 0xffffffffffffffff 0x AS 2016 Dynamic Memory Allocation 16

17 Memory corruption There are lots of ways to corrupt memory in C. #include <stdio.h> #include <stdlib.h> int main(int argc, char **argv) { int a[2]; int *b = malloc(2*sizeof(int)), *c; a[2] = 5; // assign past the end of an array a[0] += 2; // assume malloc zeroes out memory c = b+3; // mess up your pointer arithmetic free(&(a[0])); // pass pointer to free() that wasn't malloc'ed free(b); free(b); // double-free the same block b[0] = 5; // use a free()'d pointer // any many more! return 0; Dynamic Memory Allocation memcorrupt.c 17

18 Memory leaks A memory leak happens when code fails to deallocate memory that will no longer be used. // assume we have functions FileLen, // ReadFileIntoBuffer, and NumWordsInString int NumWordsInFile(char *filename) { char *filebuf = (char *)malloc(filelen(filename)+1); if (filebuf == NULL) { return -1; ReadFileIntoBuffer(filename, filebuf); // Leak! we never free(filebuf); return NumWordsInString(filebuf); AS 2016 Dynamic Memory Allocation 18

19 Implications of a leak Program s memory footprint will keep growing. For short-lived programs, this might be OK For long-lived programs, this is usually bad: Might slow down over time due to VM thrashing Might use up all available memory and crash Might starve other programs of memory Myth: garbage-collected languages like Eiffel and C# can t have memory leaks But they are are much less likely. AS 2016 Dynamic Memory Allocation 19

20 5.3: Structures and unions Computer Architecture and Systems Programming , Herbstsemester 2016 Timothy Roscoe AS 2016 Dynamic Memory Allocation 20

21 Structured data struct typename { type name; type name; type name; ; // New structured data type called "struct Point" struct Point { float x,y; ; struct Point origin = { 0.0, 0.0 ; struct: a C type that contains a set of fields a bit like a class, but no methods or constructors instances can be allocated on stack or heap AS 2016 Dynamic Memory Allocation 21

22 Using structs Use "." to refer to fields in a struct Use "->" to refer to fields through a pointer to a struct struct Point { float x, y; ; int main(int argc, char **argv) { struct Point p1 = {0.0, 0.0; // p1 on the stack struct Point *p1_ptr = &p1; p->x is nicer than (*p).x p1.x = 1.0; p1_ptr->y = 2.0; return 0; simplestruct.c AS 2016 Dynamic Memory Allocation 22

23 Copy by assignment You can assign the value of a struct from a struct of the same type; this copies the entire contents #include <stdio.h> struct Point { float x, y; ; int main(int argc, char **argv) { struct Point p1 = {0.0, 2.0; struct Point p2 = {4.0, 6.0; printf("p1: {%f,%f p2: {%f,%f\n", p1.x, p1.y, p2.x, p2.y); p2 = p1; printf("p1: {%f,%f p2: {%f,%f\n", p1.x, p1.y, p2.x, p2.y); return 0; structassign.c Dynamic Memory Allocation 23

24 structs as arguments #include <stdio.h> // Point is a (struct point_st) // PointPtr is a (struct point_st *) typedef struct point_st { int x, y; Point, *PointPtr; void DoubleXBroken(Point p) { p.x *= 2; void DoubleXWorks(PointPtr p) { p->x *= 2; int main(int argc, char *argv) { Point a = {1,1; structs are passed by value like everything in C entire structure is copied to pass by reference, pass a pointer to a struct DoubleXBroken(a); printf("(%d,%d)\n", a.x, a.y); DoubleXWorks(&a); printf("(%d,%d)\n", a.x, a.y); return 0; structarg.c 24

25 You can return structs // a complex number is a + bi typedef struct complex_st { double real; // real component double imag; // imaginary component Complex, *ComplexPtr; Complex AddComplex(Complex x, Complex y) { Complex retval; retval.real = x.real + y.real; retval.imag = x.imag + y.imag; return retval; Complex MultiplyComplex(Complex x, Complex y) { Complex retval; retval.real = (x.real * y.real) - (x.imag * y.imag); retval.imag = (x.imag * y.real) - (x.real * y.imag); return retval; AS 2016 Dynamic Memory Allocation 25 complexstruct.c

26 Unions Like a struct, but holds only one of a set of alternative values: union u { int ival; float fval; char *sval; my_uval; Accessed like a struct No checking on which value is correct! AS 2016 Dynamic Memory Allocation 26

27 Summary Structured data: C structs Assigning structs Passing structs as arguments Returning structs Unions AS 2016 Dynamic Memory Allocation 27

28 5.4: Type definitions Computer Architecture and Systems Programming , Herbstsemester 2016 Timothy Roscoe AS 2016 Dynamic Memory Allocation 28

29 typedef Introduces a new type definition New name for a type Examples: typedef unsigned uint32_t; uint32_t ui; typedef int **myptr; int *p; myptr mp = &p; typedef struct skbuf skbuf_t; skbuf_t *sptr; AS 2016 Dynamic Memory Allocation 29

30 Avoiding Complex Declarations Use typedef to build up the declaration Instead of int (*(*x[3])())[5] : typedef int fiveints[5]; typedef fiveints* p5i; typedef p5i (*f_of_p5is)(); f_of_p5is x[3]; x is an array of 3 elements, each of which is a pointer to a function returning an array of 5 ints AS 2016 Dynamic Memory Allocation 30

31 Struct tags and typedefs Structure tag struct list_el { unsigned long val; struct list_el *next; ; struct list_el my_list; Need the struct keyword to refer to a tag Also applies to unions AS 2016 Dynamic Memory Allocation 31

32 Struct tags and typedefs You can: Or even: typedef struct list_el el_t; typedef struct list_el { unsigned long val; struct list_el *next; el_t; Or even: struct list_el my_list; el_t my_other_list; typedef struct list_el { unsigned long val; struct list_el *next; list_el; struct list_el my_list; list_el my_other_list; Confusing. Better to stay with always using tags. AS 2016 Dynamic Memory Allocation 32

33 C namespaces 1. Label names (see goto ) 2. Tags one namespace for all struct, union, enum s 3. Member names One namespace for each struct, union, enum 4. Everything else (mostly) Including typedef AS 2016 Dynamic Memory Allocation 33

34 Summary Type definitions Structure and union tags C Namespaces AS 2016 Dynamic Memory Allocation 34

35 5.5: Dynamic data structures Computer Architecture and Systems Programming , Herbstsemester 2016 Timothy Roscoe AS 2016 Dynamic Memory Allocation 35

36 Example: a singly-linked list Each node in the list contains: Some element as its payload A pointer to the next node in the linked list Last node in the list contains NULL instead of the next pointer. element Z element X head element Y AS 2016 Dynamic Memory Allocation 36

37 Linked list node Represent each node as a struct Assume for now each element is an int #include <stdio.h> typedef struct node_st { int element; struct node_st *next; Node; n1 element 1 next int main(int argc, char **argv) { Node n1, n2; element n2 n1.element = 1; n1.next = &n2; n2.element = 2; n2.next = NULL; return 0; manual_list.c next 2 NULL AS

$h> (main) list typedef struct node_st { int element; struct node_st *next; Node; Node *Push(Node *head, int e) { Node *n = (Node *) malloc(sizeof(node)); assert(n!$

38 Push() #include <stdio.h> #include <stdlib.h> #include <assert.h> (main) list typedef struct node_st { int element; struct node_st *next; Node; Node *Push(Node *head, int e) { Node *n = (Node *) malloc(sizeof(node)); assert(n!= NULL); // crashes if false n->element = e; n->next = head; (Push) head (Push) e (Push) n NULL 1 return n; int main(int argc, char **argv) { Node *list = NULL; element next 1 NULL list = Push(list, 1); list = Push(list, 2); return 0; push_list.c 38

39 Push() #include <stdio.h> #include <stdlib.h> #include <assert.h> typedef struct node_st { int element; struct node_st *next; Node; (main) list (Push) head Node *Push(Node *head, int e) { Node *n = (Node *) malloc(sizeof(node)); assert(n!= NULL); // crashes if false n->element = e; n->next = head; (Push) e (Push) n 2 return n; int main(int argc, char **argv) { Node *list = NULL; element next 1 NULL list = Push(list, 1); list = Push(list, 2); element next return 0; push_list.c 2 39

40 Push() #include <stdio.h> #include <stdlib.h> #include <assert.h> (main) list typedef struct node_st { int element; struct node_st *next; Node; Node *Push(Node *head, int e) { Node *n = (Node *) malloc(sizeof(node)); assert(n!= NULL); // crashes if false n->element = e; n->next = head; return n; int main(int argc, char **argv) { Node *list = NULL; element next 1 NULL list = Push(list, 1); list = Push(list, 2); element next return 0; push_list.c 2 40

41 Push() #include <stdio.h> #include <stdlib.h> #include <assert.h> typedef struct node_st { int element; struct node_st *next; Node; Node *Push(Node *head, int e) { Node *n = (Node *) malloc(sizeof(node)); a (benign) leak! Try running with valgrind: $ gcc o push_list g Wall push_list.c $ valgrind leak-check=full./push_list assert(n!= NULL); // crashes if false n->element = e; n->next = head; return n; int main(int argc, char **argv) { Node *list = NULL; element next 1 NULL list = Push(list, 1); list = Push(list, 2); element next return 0; push_list.c 2 41

42 5.6: Generic data structures Computer Architecture and Systems Programming , Herbstsemester 2016 Timothy Roscoe AS 2016 Dynamic Memory Allocation 42

$typedef struct node_st { void *element; struct node_st *next; Node; element Node *Push(Node *head, void *e) { Node *n = (Node *) malloc(sizeof(node)); next assert(n!$

43 A generic linked list We've seen a linked list of ints What if we want to let the client choose the element type? Idea: push a generic pointer (void *) instead. typedef struct node_st { void *element; struct node_st *next; Node; element Node *Push(Node *head, void *e) { Node *n = (Node *) malloc(sizeof(node)); next assert(n!= NULL); // crashes if false n->element = e; n->next = head; element return n; next NULL 43

44 Using a generic linked list To use it, clients need to use type casting Convert data type to a (void *) before pushing Convert from a (void *) back when accessing typedef struct node_st { void *element; struct node_st *next; Node; int main(int argc, char **argv) { char *hello = "Hi there!"; char *goodbye = "Bye bye."; Node *list = NULL; list = Push(list, (void *) hello); list = Push(list, (void *) goodbye); printf("payload is: '%s'\n", (char *) list->next->element); return 0; AS manual_list_void.c

$\0 element next NULL H i t h e r e!$

45 Result (main) list (main) goodbye (main) hello element next B y e b y e. \0 element next NULL H i t h e r e! \0 AS 2016 Dynamic Memory Allocation 45

CSE 333 Lecture 4 - malloc, free, struct, typedef

CSE 333 Lecture 4 - malloc, free, struct, typedef Administrivia HW1 is due on Friday, January 25th, 11:15am - see course overview web page for the late policy Be sure to check out the course discussion