2

Cons operation calls for the allocation of a new cons-cell, like new in Pascal.

How to make it free?

3

1. Explicit Erasure

Adopted by Pascal (Dispose function)

Releasing each cell by Programmer

Linking the cell on to a Free-List

4

Problems with Explicit Erasure

Programmers must work harder– Who is the “Good” Programmer?

Remember the words against Fortran– Computer Take care of bookkeeping Details

Violating the Security Principle– Dangling Pointers ( pointers that do not point to an allocated cell)

5

Dangling Pointer

A cell still referenced by several other lists

Storage allocator reuses this cell

Corrupt the storage allocator’s Data structures

Free-List

C

Dangling Ref.

Garbage Collection with no explicit allocation/de-allocation: Responsible

Design Principle

7

Reference count

Explicit Erasure is Low level And Error-prone– Return a cell to free storage when it is no longer

needed (no longer accessible from the program)

Keep track of the accessibility of each cell– A cell is accessible only if it is referenced by the

other accessible cells.– The cells that are used by the interpreter are

Directly Accessible

8

Reference count

Maintain correctly– Increment with additional reference– Decrement when a reference destroyed

Overwrite the pointer( rplaca , rplacd) The cell containing the pointer become inaccessible

(reference count becomes zero)

Free-list become exhausted no more free-cell available the program aborted– 95% of reference counts are 1

9

Reference count

decrement (C) : reference count (C) := reference count (C) -1;if reference count (C) = 0 then

decrement (C^ left); decrement (C^ right); return C to free-list;

end if.

10

Cyclic structures

Are not reclaimed. One solution: Disallow cyclic structures

– Error prone & difficult to understand But some say:

– Cyclic structures are necessary for some problems. Another solution

11

3. Garbage Collection

Garbage : inaccessible cells which are not available for reuse

Inaccessible cells are abandoned After the exhaustion of the free space the system

enters a Garbage Collection Phase in which it identifies all of the unused cells and return them to free storage

– Ignores the storage reclamation until a crisis develops then deals with that

Mark-Sweep garbage collector– Mark phase : marks all of the accessible cells– Sweep phase : places all the inaccessible cells on the free

list

12

Mark phase

Mark phase:

for each root R, mark(R)

mark (R) :

if R is not marked then:

set mark bit of R;

mark (R^. left);

mark (R^. right);

end if.

13

Mark phase

There is a problem:– Mark phase is recursive

Requires space for it’s activation records.

– Garbage Collector is called only in crisis (no free storage available)

So how does this work???– Invoke G.C before the last cell is allocated and there is

enough space for G.C ‘s stack – Encode stack in a clever way (reversing link in the marked

nodes)

14

sweep phase

Unmarked cell:– Inaccessible & can be linked on to the Free-list

Marked cell:– Accessible & we reset its mark bit for the next

garbage collection.

Sweep phase:for each cell c: if c is marked then reset c’s mark bit, else link c onto the free-list.

15

Problems with Garbage Collection

Expensive in a large address space – It should trace down all of the lists– Visit every cell in the memory

There is a high-speed execution of the program until a garbage collection take place.

– The system will stop for minutes while a garbage collection is in the progress.

– This is apparent in an interactive system– A serious problem in real time situations (the program most

be guaranteed to respond at a certain amount of time ) solutions

– Parallel garbage collection: G.C takes place in parallel with normal program execution

16

LISP Evaluation

Successful in Artificial Intelligence – Ability to represent and manipulate complex interrelationships

among symbolic data. Suited to iII-Specified Problems

– (In artificial intelligence) the problem will not well understood – Specification of Abstract Data Types:

1st decide what data structures and data types 2nd necessary operation in terms of their input and output Finally the representation of the data structures and operators fixed

– On ill-defined problems this methodology does not work well: What operations on a data type will be required is unknown. It is difficult to fix the input-output when ultimate requirements that the

data structure must satisfy are not clear. Lisp with few restriction on invocation of procedures and passing

parameters is well suited.

17

Easy to extend, preprocess, generate

Lisp has simple structure syntax. The representation of the Lisp programs as Lisp lists. It has simplified writing programs that process other Lisp

programs such as compilers and optimizer. – It is very easy to manage Lisp programs using other Lisp

programs. ( As we saw in the eval interpreter )– Lisp programmers write many programming tools in Lisp

It has encouraged special–purpose extensions to Lisp for pattern matching, text processing, editing, type checking …

– This tools are provided by conventional languages– So why?

In conventional languages they are complicated because Pascal and … have character-oriented syntax

18

Lisp programming environments developed

Programming Environment– A system that supports all phases of programming including

design, program entry, debugging, documentation, maintenance Lisp programs can manipulate other Lisp programs has led to

the development of a wide variety of Lisp programming tools. The Interlisp programming environment

– 1966: BBN( Bolt Beraneck Newman)– 1972: a joint project with Xerox PARC (Palo Alto Research Center)

that was renamed Interlisp.– Grew during 1970s in response to the needs and ideas of

implementers and users.– The combination of Lisp language and an experimental approach

to tool developmentproduced a highly integrated but loosely coupled and flexible programming environment.

19

Lisp’s inefficiency discouraged it’s use

Why doesn’t every one use it? Because it is interpreted and often runs two orders of

magnitude slower than the code produced by the compiler

( 2*o(n) n-> compiler) recursion was inefficient on most machines

(we don’t have loop in Lisp) Dynamic storage allocation (and reclamation) is one

of the more expensive aspects but it is also one of the most valuable (it was a slow process)

20

Languages

Imperative languages :– Dependent heavily on assignment statements and

a changeable memory for accomplishing a programming task.

Applicative languages:– The central idea is function application that is

applying a function to it’s arguments.

21

Lisp shows what can be done with an applicative language

Lisp is the closest thing to an applicative language in widespread use.

The Lisp experience is evidence in favor of the practicality of functional programming languages.

22

Function-oriented languages

There is an emphasis on the use of pure functions Syntactic structure:

– Prefix notation

Data structure:– List is the principle data structure

Control structure:– Conditional expression and recursion are basic control

structures.

23

Function-oriented language properties

High level of abstraction which removes details and committing many classes of errors. (abstraction principle)

Independent of assignment statements, therefore allowing functions to be evaluated in many different orders.

– Suitable for parallel programming.

It is easier to prove the correctness mathematically and more suitable for analysis.