. Memory Management

Memory Organization u During run time, variables can be stored in one of three “pools”  Stack  Static heap  Dynamic heap

Stack u Maintains memory during function calls  Argument of the function  Local variables  Call Frame u Variables on the stack have limited “life time”

Stack - Example int foo( int a, double f ) { int b; … } a f b

Stack - Example int foo( int a, double f ) { int b; … { int c; … } … } a f b

Stack - Example int foo( int a, double f ) { int b; … { int c; … } … } a f b c

Stack - Example int foo( int a, double f ) { int b; … { int c; … } … } a f b c

Stack - Example int foo( int a, double f ) { int b; … { int c; … } … } a f b c

Stack – recursive example void foo( int depth ) { int a; if( depth > 1 ) foo( depth-1 ); } int main() { foo(3); … depth a depth a depth a

Stack -- errors void foo( int depth ) { int a; if( depth > 1 ) foo( depth ); } Will result in run time error: out of stack space

Static heap u Memory for global variables #include const int ListOfNumbersSize = 1000; int ListOfNumbers[ListOfNumbersSize]; int main() { …

Static heap u Variables on the static heap are defined throughout the execution of the program u Memory on the static heap must be defined at compile time

Static heap: reverse example Example: program to reverse the order of lines of a file To this task, we need to u read the lines into memory u Print lines in reverse How do we store the lines in memory?

Static heap: reverse example const int LineLength = 100; const int NumberOfLines = 10000; char Lines[NumberOfLines][LineLength]; … int main() { int n = ReadLines(); for( n-- ; n >= 0; n-- ) printf(“%s\n”, Lines[n]); }

Static heap: reverse example This solution is problematic: u The program cannot handle files larger than these specified by the compile time choices  If we set NumberOfLines to be very large, then the program requires this amount of memory even if we are reversing a short file  Want to use memory on “as needed” basis

Dynamic Heap u Memory that can be allocated and freed by the program during run time u The program controls how much is allocated and when u Limitations based on run-time situation  Available memory on the computer

Allocating Memory from Heap void *malloc( size_t Size );  Returns a pointer to a new memory block of size Size  Returns NULL if it cannot allocate memory of this size

Example: strdup Function to duplicate a string: char * strdup( char const *p ) { int n = strlen(p); char* q =(char*)malloc(sizeof(char)*(n+1)); if( q != NULL ) strcpy( q, p ); return q; } This function is part of the standard library

Memory Management void foo( char const* p ) { char *q = strdup( p ); // do something with q } The allocated memory remains in use u cannot be reused later on p q … Heap ‘a’ ‘b’ ‘\0’

De-allocating memory void free( void *p );  Returns the memory block pointed by p to the pool of unused memory u No error checking!  If p was not allocated by malloc, undefined behavior

Example of free void foo( char const* p ) { char *q = strdup( p ); // do something with q free(q); } This version frees the allocated memory

Further Knowledge Read manual page of u malloc u calloc u free

Interfaces u A definition of a set of functions that provide a coherent module (or library)  Data structure (e.g., list, binary tree)  User interface (e.g., drawing graphics)  Communication (e.g., device driver)

Interface - modularity u Hide the details of implementing the module from its usage  Specification – “what”  Implementation – “how”

Interface – information hiding u Hide “private” information from outside  The “outside” program should not be able to use internal variables of the module  Crucial for modularity u Resource management  Define who controls allocation of memory

Example interface - StrStack u A module that allows to maintain a stack of strings u Operations:  Create new  Push string  Pop string  IsEmpty [See attached StrStack.h]

Implementation of StrStack Decision #1: data structure u Linked list u Array (static? dynamic?) u Linked list of arrays u … We choose linked list for simplicity

Implementation of StrStack Decision #2: Resource allocation u Duplicated strings on stack or keep pointer to original? u If duplicate, who is responsible for freeing them? We choose not to duplicate --- leave this choice to user of module

Implementation of StrStack u See StrStack.c

Using StrStack int main() { char *Line; StrStack *Stack = StrStackNew(); while( (Line = ReadLine()) != NULL ) StrStackPush( Stack, Line ); while( (Line = StrStackPop(Stack)) != NULL ) { printf("%s\n", Line ); free( Line ); } return 0; }

Interface Principles Hide implementation details u Hide data structures u Don’t provide access to data structures that might be changed in alternative implementation u A “visible” detail cannot be later changed without changing code using the interface!

Interface Principles Use small set of “primitive” actions u Provide to maximize functionality with minimal set of operations u Do not provide unneeded functions “just because you can”

Interface Principles Don’t reach behind the back u Do not use global variables or unexpected side effects u Do not assume specific order of operations by the user  Such assumptions suggest the set of primitives is wrong

Interface Principle Consistent Mechanisms u Do similar things in a similar way  strcpy(dest, source)  memcpy(dest, source)

Interface Principle Resource Management u Free resource at the same level it was allocated u Assumptions about resources

Debugging “Define” the bug --- reproduce it 2. Use debugger 3. Don’t panic --- think! 4. Divide & Conquer