Dynamic Storage Allocation. Memory Management. Memory. The Heap. Memory Layout. Function Call Mechanism 3/27/14

Transcription

1 Memory Management Based on slides from K. N. King and Dianna Xu Bryn Mawr College CS246 Programming Paradigm Dynamic Storage Allocation C s data structures, including arrays, are normally fixed in size, i.e., static. o Static data structures must have their sizes decided at time of compilation Fortunately, C supports dynamic storage allocation: the ability to allocate storage during program execution. o used most often for strings, arrays, and structures. o can be linked together to form lists, trees, and other data structures. o done by calling a memory allocation function. The The pool of memory from which dynamic memory is allocated is separate, and is known as the heap. There are library routines to allocate and free memory from the heap. memory is only accessible through pointers. Mixing statically and dynamically allocated memory is not allowed. Memory What is stored in memory? o Code o Constants o Global and static variables o Local variables o Dynamic memory (malloc) int SIZE; char* f(void) { char *c; SIZE = 10; c = malloc(size); return c; global local const dynamic 0 virtual address space Memory Layout How is memory organized? o Code Text o Constants o Global and static variables o Dynamic memory (malloc) o Local variables int SIZE; char* f(void) { char *c; SIZE = 10; c = malloc(size); return c; global local const dynamic 0 Text Function Call Mechanism Activation record (of a function call), also known as a stack frame A block of memory that contains: o Parameters passed to the function o Local variables declared in the function o Return address pointer to the instruction to be executed after the function call 1

2 Call A call stack is a region of memory that manages activation records The call stack is initialized with the activation record of main Activation record of a function is o Pushed onto the stack at the function call o Popped off the stack on return from the call The reason why local variables are only present during the function call A Typical Frame int foo(int arg1, int arg2); Two local vars grows upwards ESP and EBP: registers used to point to the top of the stack and the base ESP--> Callee saved registers (as needed) EBP-8 EBP-4 EBP+8 EBP+12 temporary storage local var1 local var2 Caller s EBP Return address arg1 arg2 Caller saved registers (as needed) Memory Allocation Functions The <stdlib.h> header declares three memory allocation functions: malloc Allocates a block of memory but doesn t initialize it. o void *malloc (size_t size); o Allocates a block of size bytes from the heap o Returns a pointer to the block allocated o size_t is an unsigned integer type used for very large integers. o type void * is a generic pointer. calloc Allocates a block of memory and clears it. realloc Resizes a previously allocated block of memory. void free (void *ptr); Null Pointers If a memory allocation function can t locate a memory block of the requested size, it returns a null pointer. p = malloc(10000); if (p == NULL) { //same as: if (!p) /* allocation failed; take appropriate action */ A null pointer is a special value that can be distinguished from all valid pointers. After we ve stored the function s return value in a pointer variable, we must test to see if it s a null pointer. 2

3 ,p5 3

4 ,p5,p5,p5 Example: String Allocation Allocate memory for a string of n characters: char * p; p = malloc(n + 1);//adding 1 for \0 By default void* will be casted to char*. char *concat(const char *s1, const char *s2){ char *result; result = malloc(strlen(s1) + strlen(s2) + 1); if (result == NULL) { printf("error: malloc failed in concat\n"); exit(exit_failure); strcpy(result, s1); strcat(result, s2); return result; Example: int Array Allocation Suppose a program needs an array of n integers, where n is computed during program execution. int *a; a = (int *) malloc(sizeof(int)*n); for (i = 0; i < n; i++) a[i] = 0; free(a); The calloc Function The calloc function is an alternative to malloc. void *calloc(size_t nmemb, size_t size); o Allocates space for an array with nmemb elements, each of which is size bytes long. o Returns a null pointer if the requested space isn t available. o Initializes allocated memory by setting all bits to 0. a = calloc(n, sizeof(int)); //array of n integers. struct point { int x, y; *p; p = calloc(1, sizeof(struct point)); 4

5 The realloc Function The realloc function can resize a dynamically allocated array. void *realloc(void *ptr, size_t size); o ptr must point to a memory block obtained by a previous call of malloc, calloc, or realloc to the new size specified by size. o Returns a NULL if expansion attempt fails. o If called with NULL as 1st argument ptr, behaves like malloc. o If called with 0 as 2 nd argument, behaves like free. Example: Deallocating Storage p = malloc(); q = malloc(); p = q; After q is assigned to p, both variables now point to the second memory block: Garbage A program that leaves garbage behind has a memory leak. Calling the free function to release unneeded memory. The Dangling Pointer Problem Using free leads to a new problem: dangling pointers. free(p) deallocates the memory block that p points to, but doesn t change p itself. If we forget that p no longer points to a valid memory block, chaos may ensue: char *p = malloc(4); free(p); strcpy(p, "abc"); /*** WRONG ***/ Always assign your pointers to malloced memory or by & of a variable. variables (i.e. locals in functions) are deallocated as soon as a function returns. Therefore, avoid assigning pointers to addresses of such variables. Working with Memory Blocks Generic pointers can not be dereferenced. string.h functions to work with typeless memory blocks pointed to by void *. o void *memcpy(void *des,void *src,size_t l); o void *memmove(void *des,const void *src,size_t l); o int memcmp(const void *p,cost void *q,size_t l); o void *memchr(const void *p, int val, size_t l); These are generic versions of the corresponding string functions (strcpy, strcmp and strchr). memmove is used instead of memcpy if the two blocks overlap. File I/O on Memory Blocks:Binary Files Binary files do not have a line-oriented structure. They consist of blocks of objects, and the format of these objects are application as well as machine dependent. When opening a binary file, always append a 'b' to the second argument, i.e. o fopen("test.exe", "wb"); o fopen("test.exe", "rb"); Current File Position long ftell(file *fp); Returns the current file position, or 1L. fseek is used to set the file position: fseek(fp, -sizeof(double), SEEK_CUR); ftell s return value is often used by fseek: long file_pos; file_pos = ftell(fp); /* saves current position */ fseek(fp, file_pos, SEEK_SET); /* returns to old position */ 5

6 File Positioning fgetpos(fp, &file_pos) stores the file position associated with fp in the file_pos variable. fsetpos(fp, &file_pos) sets the file position for fp to be the value stored in file_pos. fpos_t file_pos; fgetpos(fp, &file_pos); /* saves current position */ fsetpos(fp, &file_pos); /* returns to old position */ Read/Write a Binary File The fread and fwrite functions allow a program to read and write large blocks of data in a single step. size_t fread(void *buf, size_t s, size_t ne, FILE *in); Reads up to ne elements, each of size s in bytes and stores them in buf size_t fwrite(const void *buf, size_t s, sizt_t ne, FILE *out); Similarly, writes from buf up to ne blocks, each of size s Number of elements (not bytes!) successfully read/ written is returned Read/Write a Binary File A call of fread that reads the contents of a file into the array a: n = fread(a, sizeof(a[0]), sizeof(a) / sizeof(a[0]), fp); A call of fwrite that writes a structure variable s to a file: fwrite(&s, sizeof(s), 1, fp); fwrite is convenient for a program that needs to store data in a file before terminating. Later, the program (or another program) can use fread to read the data back into memory. 6