Heap storage. Dynamic allocation and stacks are generally incompatible.

Transcription

1 Heap storage Dynamic allocation and stacks are generally incompatible. 1

2 Stack and heap location Pointer X points to stack storage in procedure Q's activation record that no longer is live (exists) when procedure Q terminates. Such a reference is called a dangling reference. Dynamic storage is usually a separate structure in C, Ada, Pascal... 2

3 Heap storage problems Major storage for ML, LISP and Prolog is a heap. Get storage - allocate(x) free storage - free(x) Problems: Dangling reference: allocate(x);y = x; free(x); y still points to allocated Inaccessible storage: allocate(x); allocate(x); first allocation to x now lost. Memory fragmentation (next slide) 3

4 Memory fragmentation Memory fragmentation: allocate(a); allocate(x); allocate(y); free(a); allocate(z); free(y); allocate(b); No contiguous space for b 4

5 Garbage collection goal Process to reclaim memory.(solve Fragmentation problem.) Algorithm: You can do garbage collection if you know where every pointer is in a program. If you move the allocated storage, simply change the pointer to it. This is true in LISP, ML, Java, Prolog Not true in C, C++, Pascal, Ada 5

6 Garbage collection: Mark-sweep algorithm First assume fixed size blocks of size k. (Later blocks of size n*k.) This is the LISP case. Two simple algorithms follow. (This is only an introduction to this topic. Many other algorithms exist) Algorithm 1: Fixed size blocks; Two pass mark-sweep algorithm: 1. Keep a linked list (free list) of objects available to be allocated. 2. Allocate objects on demand. 3. Ignore free commands. 4. When out of space, perform garbage collection: Pass 1. Mark every object still allocated. Pass 2. Every unmarked objects added to free list of available blocks. 6

7 Heap storage errors Error conditions: Dangling reference - Cannot occur. Each valid reference will be marked during sweep pass 1. Inaccessible storage - Will be reclaimed during sweep pass 2. Fragmentation - Does not occur; fixed size objects. 7

8 Garbage collection: reference counts Algorithm 2: 1. Associate a reference counter field, initially 0, with every allocated object. 2. Each time a pointer is set to an object, up the reference counter by Each time a pointer no longer points to an object, decrease the reference counter by If reference counter ever is to 0, then free object. Error conditions: Dangling reference - Cannot occur. Reference count is 0 only when nothing points to it. Fragmentation - Cannot occur. All objects are fixed size. Inaccessible storage - Can still occur, but not easily. 8

9 Memory compaction: Variable-size elements With variable sized blocks, the previous two algorithms will not work. In the left heap below, a block of size 3 cannot be allocated, even though 7 blocks are free. If the allocated blocks are moved to the start of the heap (compaction) and the free blocks collected, then a block of size up to 7 can be allocated. 9

10 Compaction algorithm For variable sized blocks, in pass 2 of the mark-sweep algorithm: Move blocks to top of storage Need to reset pointers that point to the old storage location to now point to the new storage. How to do this? Use tombstones and two storage areas, an A area and a B area: 1. Fill area A. 2. When A fills, do mark-sweep algorithm. 3. Move all allocated storage to start of B area. Leave marker in A area so other pointers pointing to this object can be modified. 4. After everything moved, area A can discarded. Allocate in B and later compact from B back to A. 10

11 Compaction algorithm (continued) 11

12 In place compaction 12

13 LISP overview LISP was first designed and implemented by John McCarthy at MIT around 1960 LISP widely used for artificial intelligence research First language based on applicative execution LISP has equivalence of form between programs and data, which allows data structures to be executed as programs and programs to be modified as data In the late 1970s, Gerald Sussman and Guy Steele developed a variant named Scheme. This is the version that had the most impact on university use of LISP. In 1992 a standard for Common LISP was finally written 13

14 LISP features LISP functions are defined entirely as expressions. Data in LISP are rather restricted. Literal atoms and numeric atoms (numbers) are the basic elementary types. LISP provides a wide variety of primitives for the creation, destruction, and modification of lists (including property lists). Basic primitives for arithmetic are provided. LISP control structures are relatively simple. The expressions used to construct programs are written in strict Cambridge Polish form and may include conditional branching. Function parameters are transmitted either all by value or all by name depending on the classification of the function. Execution heavily dependent on heap storage 14

15 LISP (scheme) example 1 %lisp [> are environment prompts.] 2 >; Store values as a list of characters 3 >(define (SumNext V) 4 (cond ((null V) (progn (print "Sum=") 0)) 5 (T (+ (SumNext (cdr V)) (car V)) ) )) 6 SUMNEXT 7 >; Create vector of input values 8 (defun GetInput(f c) 9 (cond ((eq c 0) nil) 10 (T (cons (read f) (GetInput f (- c 1)))))) 11 GETINPUT 12 >(defun DoIt() 13 (progn 14 (setq infile (open '"lisp.data")) 15 (setq array (GetInput infile (read infile))) 16 (print array) 17 (print (SumNext array)))) Figure A.10 in text 15

16 LISP data structures Developed in 1960 by McCarthy at MIT 16

17 Basic LISP operations Operators: (car ( )) = 1 head of list (cdr ( ) ) = ( 2 3 ) tail of list (cons a ( b c d ) ) = ( a b c d ) join operation (cons ( car ( cdr (a b c))) ( c d)) = (b c d) But: (cons (a b ) ( c d ) ) = ( ( a b ) c d ) (+ 1 2) = 3 [also - * /] Conditional: (cond (predicate1) (predicate2) (T expression)) Evaluate each predicate and and stop when first predicate becomes true (T) Example if-then-else: (cond ((eq A 2)(print true )) (T (print false )) Define functions: applicative like in ML: (defun x) (expression) 17

18 Some simple functions atom - true if argument is an atom (not a list) null - true if list is empty numberp - true if argument is a number append - appends two lists eq - true if both arguments point to the same object equal - true if both arguments have the same list members quote - (quote X) = X [Also written as ( X)] [See next slide] and, or, not - Logical operations read - read from keyboard print - write to keyboard bye - exit LISP environment 18

19 LISP storage LISP is first language that makes heavy use of heap storage. Storage reclaimed automatically by LISP environment when out of space. Uses space efficiently. Each LISP item is a fixed size object allocated in the heap. As example shows, although based on a heap, LLISP still needs a stack for execution. Example: Trace execution of: (defun f1(x y z) (cons x (f2 y z ) ) ) (defun f2(v w) (cons v w) ) 19

20 20