Memory Management. CS31 Pascal Van Hentenryck CS031. Lecture 19 1

Size: px

Start display at page:

Download "Memory Management. CS31 Pascal Van Hentenryck CS031. Lecture 19 1"

Audra Holly Hunter
6 years ago
Views:

1 Memory Management CS31 Pascal Van Hentenryck CS031 Lecture 19 1

2 Memory Management What is it? high-level languages abstract many aspects of memory management Support varies with the language Java (ML/Prolog/Lisp/Smalltalk) C++ C Highest level of abstraction Explicit destruction of objects High-level assembly language CS031 Lecture 19 2

3 Memory Management Two types of memory allocation Stack allocation Heap allocation Stack allocation Parameters Return address Local variables Heap Allocation Objects (Java, C++) Dynamic data in C Nothing to do with the heap data structure: it is a real heap CS031 3

4 Memory Management 3 types of memory allocation Stack allocation Heap allocation Static allocation Stack allocation Parameters & Local variables Heap Allocation Objects (Java, C++) Static Allocation Static data in your program CS031 4

5 MM in Java Memory allocation new allocates memory for an object Memory deallocation No explicit deallocation Objects are deallocated whenever they are not needed How do you know that? Garbage collection CS031 5

6 Simple Lists Conventions A list is a pointer to a list node A null reference/pointer indicates an empty list List Node A key (e.g., an int) A pointer to the next element in the list The pointer/reference is null when there are no further element Close to lists in Lisp/Scheme CS031 6

7 Simple Lists in Java class List { ListNode _head; List() { _head = null; Class ListNode { int _key; ListNode _next; ListNode(int key,listnode n) { _key = key; _next = n; int getkey() { return _key; ListNode getnext() { return _next; void setnext(listnode n) { _next = n; CS031 7

8 MM in Java class List { ListNode _head; Memory List() { _head = null; allocation void insert(int key) { _head = new ListNode(key,_head); void remove(int key) { Class ListNode { int _key; ListNode _next; ListNode(int key,listnode n) { _key = key; _next = n; int getkey() { return _key; ListNode getnext() { return _next; void setnext(listnode n) {_next = n; ListNode remove(int key) { CS031 8

9 MM in Java class ListNode { ListNode remove(int key) { if (key == _key) return _next; Possible memory else { deallocation _next = _next.remove(key); return this; Possible memory class List { deallocation void remove(int key) { _head = _head.remove(key); CS031 9

10 MM in Java class ListNode { ListNode remove(int key) { if (key == _key) return _next; else { _next = _next.remove(key); return this; Possible memory class List { deallocation void remove(int key) { _head = _head.remove(key); Space complexity? Linear in the worst case Possible memory deallocation Possible memory deallocation CS031 10

11 MM in Java Why is it linear in space? Each recursive call takes space on the stack There are as many recursive calls as they are elements in the list in the worst case This is a terrible implementation from an efficiency standpoint! How to improve it? Do not use the stack! Use iterations/loops CS031 11

12 MM in Java void remove(int key) { ListNode cur = _head; ListNode prev = null; while (cur!= null) { if (cur.getkey() == key) break; prev = cur; cur = cur.getnext(); if (cur!= null) { if (prev!= null) prev.setnext(cur.getnext()); else _head = cur.getnext(); CS031 12

13 MM in Java ListNode remove(int key) { ListNode cur = _head; ListNode prev = null; while (cur!= null) { if (cur.getkey() == key) break; prev = cur; cur = cur.getnext(); if (curr!= null) { if (prev!= null) prev.setnext(cur.getnext()); else _head = cur.getnext(); What happens to the removed element? Java will garbage-collect it at some point. How do we figure out what is garbage? We do not need it any more CS031 13

14 MM in C++ High-level View Similar to Java Explicit memory deallocation No garbage collection Programmers are responsible to take their garbage out Main Support Destructors for deallocation This lecture Java with the C++ model C++ is much more compicated pointers, superset of C CS031 14

15 MM in C++ C++ automates many aspects Memory allocation Memory deallocation Main abstraction No need to know how memory is allocated/deallocated Main responsibility Programmers must specify which objects are no longer needed Nasty bugs Segmentation faults Bus error Memory leaks CS031 15

$MM in C++ class ListNode { int _key; ListNode _next; ListNode(int$

16 MM in C++ class ListNode { int _key; ListNode _next; ListNode(int key,listnode n) { _key = key, _next = n; ~ListNode() { Terminator CS031 16

17 MM in C++ When do I need to delete? a node which is deleted the list and all its nodes when the list is deleted CS031 17

18 MM in C++ void remove(int key) { ListNode cur = _head; ListNode prev = null; while (cur!= null) { if (cur.getkey() == key) break; prev = cur; cur = cur.getnext(); if (curr!= null) { if (prev!= null) prev.setnext(cur.getnext()); else _head = cur.getnext(); delete curr; Memory deallocation CS031 18

19 MM in C++ class List { ListNode _head; List() { ~List() { ListNode n; ListNode c = _head; while (c!=null) { n = c; c = c.getnext(); delete n; CS031 19

20 MM in C++ class List { ListNode _head; List() { ~List() { ListNode c = _head; while (c!=null) { delete c; c = c.getnext(); CS031 20

21 MM in C++ Memory bugs Using a freed object The data will become incorrect Freeing an object twice The space may be allocated twice later Forgetting to release an object Your program eats up the whole memory Nasty bugs Time discrepancy between the bug and the symptoms Things generally look fine until the space is reallocated to another object, at which time values may start being overwritten. The new values may have no meaning in the original context. CS031 21

22 MM in C C is a high-level assembly language Mixture of Pascal and Assembly Predecessor was B Successor D never saw the light Basic features Explicit memory management Bits and bytes and words Casting Pointer manipulation Pointers to any type (int, ) Structures on the stack No objects Only functions CS031 Lecture 19 22

23 MM in C struct ListNode { ; int _key; void test() { ListNode n; n._key = 5; ListNode* p = &n; free(p); Structure declaration Structure instance Observations ListNode is allocated on the stack It does not exist after the function call We need pointers to structures CS031 23

24 Pointers in C Religious wars Two syntax(es) The type-based syntax int* a; The dereference-based syntax int *a; Dereferencing a pointer int v = *a; CS031 24

25 MM in C struct ListNode { int _key; ListNode* _next; ; struct List { ; ListNode* _head; ListNode* search(list* l,int key) { ListNode* c = l->_head; while (c) { if (c->_key == key) else return c; c = c->_next; Pointer to a ListNode We are manipulating pointers! CS031 25

26 MM in C ListNode* search(list* l,int key) { ListNode* c = l->_head; while (c) { if (c->_key == key) return c; else c = c->_next; Dereferencing again! c = c->_next; Dereferencing operator is equivalent to c = (*c)._next; CS031 26

27 MM in C How to allocate memory? char* malloc(int sizeb) returns a pointer to sizeb bytes of memory space sizeof can be used to know the size of structures and other types In C, you are responsible of allocating memory space How to deallocate memory? free(void* ptr) frees the space allocated to ptr CS031 27

28 MM in C ListNode* createnode(int key,listnode* next) { ListNode* n; n = (ListNode*) malloc(sizeof(listnode)); n->_key = key; n->_next = next; return n; More bugs Allocate the wrong space Change the pointers n = n + 345; frees the wrong pointers Frees/returns objects from the stack CS031 28

29 MM in C++/C Assume that you want an array a ranging over int* a = new int[82];! a -= 18;! for(int i = 18; i <= 99; i++)! a[i] = 0;! a += 18;! delete[] a;! CS031 29

In Java we have the keyword null, which is the value of an uninitialized reference type

+ More on Pointers + Null pointers In Java we have the keyword null, which is the value of an uninitialized reference type In C we sometimes use NULL, but its just a macro for the integer 0 Pointers are