1. Chapter 8 - Control II: Procedures and Environments
11/4/2017
Chapter 8 - Control II: Procedures and Environments
Louden, 2003

2. Three major parts of a runtime environment:
Static area allocated at load/startup time. Examples: global/static variables and load-time constants.
Stack area for execution-time data that obeys a last-in first-out lifetime rule. Examples: nested declarations and temporaries.
Heap or dynamically allocated area for "fully dynamic" data, i.e. data that does not obey a LIFO rule.
Chapter 8
K. Louden, Programming Languages

3. K. Louden, Programming Languages
Procedure Overview
When functions are “first class” data items themselves, they can be dynamically created and used like values just like any other data structure.
Thus, we need to be able to pass functions as arguments
A procedure is called or activated.
Activation record: collection of data needed to maintain a single execution of a procedure.
Worry about local and non-local references.
Static or dynamic environment (depending on scoping) must be accessible.
When a procedure depends only of parameters and fixed language features – closed form.
The code for a function together with its defining environment is called closure – as we can resolve all outstanding non-local environments.
Chapter 8
K. Louden, Programming Languages

4. Implementing “Simple” Subprograms
Call Semantics:
1. Save the execution status of the caller (calling environment)
2. Carry out the parameter-passing process by putting the parameters somewhere that the called function can access.
3. Pass the return address to the callee
4. Transfer control to the callee
Chapter 8
K. Louden, Programming Languages

5. Implementing “Simple” Subprograms
Return Semantics:
1. If it is a function, move the functional value to a place the caller can get it
2. Restore the execution status of the caller
3. Transfer control back to the caller
Chapter 8
K. Louden, Programming Languages

6. Implementing “Simple” Subprograms
Required Storage: Status information of the caller, parameters, return address, and functional value (if it is a function)
The format, or layout, of the noncode part of an executing subprogram is called an activation record
An activation record instance is a concrete example of an activation record (the collection of data for a particular subprogram activation)
Chapter 8
K. Louden, Programming Languages

7. An Activation Record for “Simple” Subprograms (no scoping issues)
Chapter 8
K. Louden, Programming Languages

8. K. Louden, Programming Languages
Code and Activation Records of a Program with “Simple” Subprograms If there is no recursion, we can have static activation records. If we have no non-local variables, everything we need is local and easy to find.
Chapter 8
K. Louden, Programming Languages

9. K. Louden, Programming Languages
Parameter Passing
Aliases may be created
Type checking parameters
a formal reference parameter is a nonlocal variable
the same data object passed for two parameters CALL S(X,X)
With aliasing, interesting problems in optimizations occur.
Chapter 8
K. Louden, Programming Languages

10. Models of Parameter Passing
Chapter 8
K. Louden, Programming Languages

11. K. Louden, Programming Languages
1. Pass-by-value (in mode)
Typically we copy the value in, but can do with a constant reference pointer.
Parameters are viewed as local variables of the procedure (with initial values given by values of arguments in the call)
Note can still change values outside procedure if we pass a reference.
Disadvantages of copy:
Requires more storage (duplicated space)
Cost of the moves (if the parameter is large)
Disadvantages of constant reference:
Must write-protect in the called subprogram or compiler check that there are no assignments.
Accesses cost more (indirect addressing)
Chapter 8
K. Louden, Programming Languages

12. K. Louden, Programming Languages
2. Pass-by-result (out mode)
function return value
Local’s value is passed back to the caller
Physical move is usually used (copy to call stack)
Disadvantages:
If value is passed, time and space
order dependence may be a problem
If return value is an address, when is it evaluated?
e.g.
procedure sub1(y: int, z: int);{y=0;z=5; }
sub1(x, x);
Value of x in the caller depends on order of assignments at the return
Chapter 8
K. Louden, Programming Languages

13. K. Louden, Programming Languages
OUT only parameters
formal parameter is a local variable with no initial value
copied back at termination of subprogram Pass by result
Explicit function Values: may be considered an extra OUT parameter
return(expr)
value to be returned by assignment to function name
if return is an address (e.g., list[index]), when is it evaluated? time of call? time of return?
Chapter 8
K. Louden, Programming Languages

14. K. Louden, Programming Languages
3. Inout mode
Pass by value-result (aka copy-in copy-out or copy-restore)
Physical move, both ways
value-result (or pass by copy)
Disadvantages
ordering may be a problem with a call like doit(x,x)
time/space issues
Need to know whether address is computed again before copying back. doit(i,a[i])
Chapter 8
K. Louden, Programming Languages

15. K. Louden, Programming Languages
IN OUT parameters
Value-restore. Copy value in on call Copy changed value back on return.
Used to save cost of indirect access.
aliases may be problematic - especially likely if pass same parameter twice. Then if arguments are changed, original values may be changed differently depending on order of change (if value-restore)
Chapter 8
K. Louden, Programming Languages

16. K. Louden, Programming Languages
4. In-out mode - pass by reference.
Issues:
access is slower (as indirect)
passing is faster
called program can access parameter through alias
Array element collisions:
e.g.
sub1(a[i], a[j]); /* if i = j */
Also, sub2(a, a[i]); (a different one)
Collision between formals and globals
Root cause of all of these is: The called subprogram is provided wider access to nonlocals than is necessary
Chapter 8
K. Louden, Programming Languages

17. K. Louden, Programming Languages
IN OUT parameters
transmission by reference formal parameter is local object of type pointer If expression is passed as an in/out parameter: a temporary location may be passed (and then the copy is changed, not the original)
Disadvantages:
access slower as is indirect (always follow a pointer to access), but passing is fast (only copy a pointer, not a whole structure)
may make inadvertent changes to parameters (if out only was desired)
Chapter 8
K. Louden, Programming Languages

18. Parameter Passing Methods
5. Pass-by-name (Unevaluated parameters)
By textual substitution
intended to be an advanced inlining
essentially like late evaluation
Name of t he argument (or its textual substitution at the point of call) replaces the name of the parameter it corresponds to.
Formals are bound to an access method at the time of the call, but actual binding to a value or address takes place at the time of a reference or assignment
Purpose: flexibility of late binding
Chapter 8
K. Louden, Programming Languages

19. K. Louden, Programming Languages
Pass-by-name
Resulting semantics:
If actual is a scalar variable, it is pass-by-reference
If actual is a constant expression, it is pass-by-value
If actual is an array element, it is like nothing else
e.g.
procedure sub1(x: int; y: int);
begin
x := 1; Seems like nothing is happening
y := 2; with first assignments but it is
x := 2;
y := 3;
end;
sub1(i, a[i]);
Chapter 8
K. Louden, Programming Languages

20. K. Louden, Programming Languages
5. Pass-by-name (continued)
If actual is an expression with a reference to a variable that is also accessible in the program, it is also like nothing else
e.g. (assume k is a global variable)
procedure sub1(x: int; y: int; z: int);
begin
k := 1; y := x;k := 5;z := x;
end;
sub1(k+1, j, a[i]);
Thunks: pass by name arguments are implemented by little procedure which evaluate the arguments.
Presumably the image was of little machines that “thunked” into place each time they were needed.
Chapter 8
K. Louden, Programming Languages

21. Parameter Passing (In Mode)
Pass-by-name: text for argument is passed to subprogram and expanded in each place parameter is used
Roughly same as using macros
Note, you can’t evaluate late without having “code” to execute
You also need to know a context for evaluating non-local variables
Achieves late binding
Chapter 8
K. Louden, Programming Languages

22. K. Louden, Programming Languages
Pass-by-name Example
integer INDEX= 1;
integer array ARRAY[1:2]
procedure UPDATE (PARAM);
integer PARAM
begin
PARAM := 3;
INDEX := INDEX + 1;
PARAM := 5;
end
UPDATE(ARRAY[INDEX]);
Chapter 8
K. Louden, Programming Languages

23. K. Louden, Programming Languages
Pass-by-name Example
Previous code puts 3 in ARRAY[1] and 5 in ARRAY[2]
How is this accomplished if the compiled code must work for ANY argument that is passed?
PARAM must be something that has a value, but can be x, Array[x+y], Array[2*t[6*x]+7]
How can you generate code for UPDATE when you don’t know what is passed?
If pass by name argument appears on left hand side, need to be able to compute the address.
If pass by name argument appears on right hand side (of assignment), need to be able to compute a value.
Chapter 8
K. Louden, Programming Languages

24. K. Louden, Programming Languages
New interest in functional languages means more interest in delayed evaluation.
Very flexible, but inefficient. Difficult to implement. Confusing to read/write.
Some simple operations are not possible with pass by name.
Lazy evaluation is another form of late binding. Only evaluate when it becomes necessary.
Substitute name or expression (in calling environment) for formal parameter
The name location binding is delayed until (and established fresh each time) the formal parameter is encountered.
Implemented by passing parameter-less subprograms (thunks) rather than variable name. An expression needs to be evaluated IN the proper environment. Don't have mechanism to do that other than thru procedure call.
Whenever formal parameter is referenced, a call is made to thunk, which evaluates the parameter in the proper (caller) environment and returns proper resulting value (or location)
Chapter 8
K. Louden, Programming Languages

25. K. Louden, Programming Languages
Example:
procedure R(var i,j: integer);
begin var
m:boolean;
m := true;
i := i + 1;
j := j + 1;
write(i,j);
end;
m := 2;
for(i=0;i<10;i++) c[i]=10*i;
R(m,c[m]);
pass by reference: adds 1 to m and c[2] Pass by name: adds 1 to m and c[3]
Chapter 8
K. Louden, Programming Languages

26. Example for Pass by Name
b1: begin real x,y;
y := 0.0;
procedure G(t): name t;
begin integer w; integer x;
w := 10; y := 20; x := 50
print t x:= 0;
print t
end G;
b2: begin real y;
y := 0.5; x := 1.0;
call G(y-x) end
end
thunk() return(y-x) end;
Chapter 8
K. Louden, Programming Languages

27. Parameter Passing Methods
Disadvantages of pass by name:
Very inefficient references
Too tricky; hard to read and understand
Chapter 8
K. Louden, Programming Languages

28. Parameter Passing Methods
Multidimensional Arrays as Parameters
If a multidimensional array is passed to a subprogram and the subprogram is separately compiled, the compiler needs to know the declared size of that array to build the storage mapping function
Programmer is required to include the declared sizes of all but the first subscript in the actual parameter
This disallows writing flexible subprograms
Solution: run time descriptor
Chapter 8
K. Louden, Programming Languages

29. Parameter Passing Methods
Design Considerations for Parameter Passing
1. Efficiency
2. One-way or two-way
These two are in conflict with one another!
Good programming => limited access to variables, which means one-way whenever possible
Efficiency => pass by reference is fastest way to pass structures of significant size
Also, functions should not allow reference parameters
Chapter 8
K. Louden, Programming Languages

30. Languages and Environments
Languages differ on where activation records must go in the environment:
Fortran is static: all data, including activation records, are statically allocated. (Each function has only one activation record—no recursion!)
Functional languages (Scheme,ML) and some OO languages (Smalltalk) are heap-oriented: all (or almost all) data, including activation records, are allocated dynamically.
Most languages are in between: data can go anywhere (depending on its properties); activation records go on the stack.
Chapter 8
K. Louden, Programming Languages

31. Simple stack-based allocation
Described in Chapter 5.
Nested declarations are added to the stack as their code blocks are entered, and removed as their code blocks are exited.
Example: Stack at Point 1: { int x; int y; { int z; } { int w; // Point 1 } }
Note ,z has been removed at point 1 as have exited scope x y w
Chapter 8
K. Louden, Programming Languages

32. K. Louden, Programming Languages
Example (C): main →q →p
int x;
void p( int y)
{ int i = x;
char c; ... }
void q ( int a)
{ int x;
p(1);
main()
{ q(2);
return 0;
Chapter 8
K. Louden, Programming Languages

33. Activation record of p:
© 2003 Brooks/Cole - Thomson Learning™
Chapter 8
K. Louden, Programming Languages

34. K. Louden, Programming Languages
Environment stack during exec of p: main →q →p (stack is shown growing down)
© 2003 Brooks/Cole - Thomson Learning™
Note: the ep in this picture actually points to the "bottom" of the frame, as do the control links (which are stored old ep values), so ep  top of stack.
Chapter 8
K. Louden, Programming Languages

35. Local variable access using the ep
In a typical language with a stack-based runtime environment, the local declarations in a procedure are fixed at compile-time, both in size and in sequence.
This information can be used to speed up accesses to local variables, by precomputing these locations as offsets from the ep.
Then the local frame need not have a name-based lookup operation (unlike the symbol table).
In fact, names can be dispensed with altogether.
The next slide shows how that would look for the procedure p of slide 7.
Chapter 8
K. Louden, Programming Languages

36. Non-local variable access
Requires that the environment be able to identify frames representing enclosing scopes.
Using the control link results in dynamic scope (and also kills the fixed-offset property as you are not sure which method will contain the x. Thus, you can’t depend on a fixed location).
If procedures can't be nested (C, C++, Java), the enclosing scope is always locatable by other means: it is either global (accessed directly) or belongs to the current object.
If procedures can be nested, to maintain lexical scope a new link must be added to each frame: the access link, pointing to the activation of the defining environment of each procedure.
Chapter 8
K. Louden, Programming Languages

37. Example (Ada-like) q→r → p → z → z:
1 procedure q is
x,u: integer
procedure p (y: integer) is
i: integer := x;
procedure z (t:float) returns float is
m: float;
begin
if (t >5) return z(t/2);
return t+m/i*y + u/x;
end z;
begin ...
end p;
procedure r (u:integer) is
x: float;
p(1);...
end r; r;
end q;
Chapter 8
K. Louden, Programming Languages

38. Environment during exec of p:
© 2003 Brooks/Cole - Thomson Learning™
Chapter 8
K. Louden, Programming Languages

39. K. Louden, Programming Languages
Nested Subprograms
The process of locating a nonlocal reference:
1. Find the correct activation record instance
2. Determine the correct offset within that activation record instance
May need to follow several links (access chaining)
The number of links is known from compile time.
If used stack of symbol tables, can count how many tables you had to search to find it.
If used individual stacks for each value, you can record the nesting depth of each variable.
Chapter 8
K. Louden, Programming Languages

40. Procedure values as pointer pairs
With nested procedures in lexically scoped languages requiring an access link, when a procedure is called, this access link must be available at the point of call. One way it can be is for the procedure itself to record its access link (necessary if procedures can be parameters).
Then each procedure becomes a pair of pointers: a code pointer (called the instruction pointer or ip in the text), and an environment pointer (ep in the text) pointing to the definition environment of the procedure (which will become the access link during a call).
Such an <ep,ip> pair is sometimes called a closure.
Chapter 8
K. Louden, Programming Languages

41. Fully dynamic environments
Languages with lambdas or where functions can be created locally and returned from a call (ML, Scheme).
Activation records cannot in general be popped after a call. Thus, activations no longer behave as LIFO structures and must be allocated in the heap.
Control links make little sense, since each control link might have to point far back in the stack.
Access links and closures still make perfect sense, however.
Chapter 8
K. Louden, Programming Languages

42. Implementing Subprograms in ALGOL-like Languages
The collection of dynamic links in the stack at a given time is called the dynamic chain, or call chain
Local variables can be accessed by their offset from the beginning of the activation record. This offset is called the local_offset
The local_offset of a local variable can be determined by the compiler
Assuming all stack positions are the same size, the first local variable declared has an offset of three plus the number of parameters, e.g., in main, the local_offset of Y in A is 3
Chapter 8
K. Louden, Programming Languages

43. The Process of Locating a Nonlocal Reference
Finding the offset is easy
Finding the correct activation record instance:
Static semantic rules guarantee that all nonlocal variables that can be referenced have been allocated in some activation record instance that is on the stack when the reference is made
Chapter 8
K. Louden, Programming Languages

44. K. Louden, Programming Languages
Nested Subprograms
Technique 1 - Static Chains
A static chain is a chain of static links that connects certain activation record instances
The static link in an activation record instance for subprogram A points to one of the activation record instances of A's static parent
The static chain from an activation record instance connects it to all of its static ancestors
Chapter 8
K. Louden, Programming Languages

45. Static Chains (continued)
To find the declaration for a reference to a nonlocal variable:
You could chase the static chain until the activation record instance (ari) that has the variable is found, searching each ari as it is found, if variable names were stored in the ari
Def: static_depth is an integer associated with a static scope whose value is the depth of nesting of that scope
Chapter 8
K. Louden, Programming Languages

46. Static Chains Show the static/dynamic chains when main →C →A →B →C
main static_depth = 0
A static_depth = 1
B static_depth = 2
C static_depth = 1
Chapter 8
K. Louden, Programming Languages

47. Static Chains (continued)
Def: The chain_offset or nesting_depth of a nonlocal reference is the difference between the static_depth of the reference and that of the scope where it is declared
A reference can be represented by the pair:
(chain_offset, local_offset)
where local_offset is the offset in the activation record of the variable being referenced
Chapter 8
K. Louden, Programming Languages

48. K. Louden, Programming Languages
Nested Subprograms
Static Chain Maintenance
At the call :
The activation record instance must be built
The dynamic link is just the old stack top pointer
The static link must point to the most recent ari of the static parent (in most situations)
Two Methods to set static chain:
1. Search the dynamic chain until the first ari for the static parent is found--easy, but slow
Chapter 8
K. Louden, Programming Languages

49. K. Louden, Programming Languages
Nested Subprograms
2. Treat procedure calls and definitions like variable references and definitions (have the compiler compute the nesting depth, or number of enclosing scopes between the caller and the procedure that declared the called procedure; store this nesting depth and send it with the call)
e.g. Look at MAIN_2 and the stack contents. At the call to SUB1 in SUB3, this nesting depth is 1, which is sent to SUB1 with the call. The static link in the new ari for SUB1 is set to point to the ari that is pointed to by the second static link in the static chain from the ari for SUB3
Chapter 8
K. Louden, Programming Languages

50. K. Louden, Programming Languages
Nested Subprograms
Evaluation of the Static Chain Method
Problems:
1. A nonlocal reference is slow if the number of scopes between the reference and the declaration of the referenced variable is large
2. Time-critical code is difficult, because the costs of nonlocal references are not equal, and can change with code upgrades and fixes
Chapter 8
K. Louden, Programming Languages

51. K. Louden, Programming Languages
Nested Subprograms
Technique 2 (for locating non-local variables) - Displays
The idea: Put the static links in a separate stack called a display. The entries in the display are pointers to the ari's that have the variables in the referencing environment.
Represent references as
(display_offset, local_offset)
where display_offset is the same as chain_offset
Can access via computation. display offset of 10 is one lookup (not a chain of length 10)
Chapter 8
K. Louden, Programming Languages

52. K. Louden, Programming Languages
Main – level 1
p level 1 p
p level 2
t level 2
q level 4
s level 3
r level 3
Chapter 8
K. Louden, Programming Languages

53. K. Louden, Programming Languages
Display contains pointers to each
activation record at each reachable level
100
main
100
Level 1
200
Level 2
300
Level 3
400
Level 4
200 t
300 s
400
main-> t -> s-> q q
When s calls q, a single element is added to the
table.
Chapter 8
K. Louden, Programming Languages

54. K. Louden, Programming Languages
100
main
100
Level 1
500
Level 2
300
Level 3
400
Level 4
200 t
300 s
400
main-> t -> s-> q-> p q
old level 2 is 200
When q calls p, a new level 2 entry is needed.
Store the old one, so you can get it back.
Level 3 and level 4 are unused (but unchanged)
500 p
Chapter 8
K. Louden, Programming Languages

55. K. Louden, Programming Languages
100
main
100
Level 1
600
Level 2
300
Level 3
400
Level 4
200 t
300 s q
400
main-> t -> s-> q-> p->t
old level 2 is 200 p
When p calls t, a new level 2 entry is needed
Level 3 and level 4 are unused (but unchanged)
500
old level 2 is 500
600 t
Chapter 8
K. Louden, Programming Languages

56. K. Louden, Programming Languages
Displays (continued)
Mechanics of references:
Use the display_offset to get the pointer into the display to the ari with the variable
Use the local_offset to get to the variable within the ari
Chapter 8
K. Louden, Programming Languages

57. K. Louden, Programming Languages
Displays (continued)
Display maintenance (assuming no parameters that are subprograms and no pass-by-name parameters)
Note that display_offset depends only on the static depth of the procedure whose ari is being built. It is exactly the static_depth of the procedure.
There are k+1 entries in the display, where k is the static depth of the currently executing unit (k=0 is for the main program)
Chapter 8
K. Louden, Programming Languages

58. K. Louden, Programming Languages
Displays (continued)
For a call to procedure P with a static_depth of k:
a. Save, in the new ari, a copy of the display pointer at position k (you will need a stack)
b. Put the link to the ari for P at position k in the display
At an exit, move the saved display pointer from the ari back into the display at position k
Chapter 8
K. Louden, Programming Languages

59. K. Louden, Programming Languages
Displays (continued)
To see that this works:
Let Psd be the static_depth of P, and Qsd be the static_depth of Q
Assume Q calls P
There are three possible cases:
1. Qsd = Psd
2. Qsd < Psd (would only differ by one)
3. Qsd > Psd (ignore higher levels)
Show example where each of these could happen.
Chapter 8
K. Louden, Programming Languages

60. K. Louden, Programming Languages
Blocks
Two Methods:
1. Treat blocks as parameterless subprograms
Use activation records
2. Allocate locals on top of the ari of the subprogram
Must use a different method to access locals
A little more work for the compiler writer
Chapter 8
K. Louden, Programming Languages

61. Implementing Dynamic Scoping
1. Deep Access (search) - nonlocal references are found by searching the activation record instances on the dynamic chain
Length of chain cannot be statically determined
Every activation record instance must have variable names recorded
Chapter 8
K. Louden, Programming Languages

62. Implementing Dynamic Scoping
2. Shallow Access - put locals in a central place
Methods:
a. One stack for each variable name
b. Central referencing table with an entry for each variable name
At subprogram entry, add location for each variable.
At subprogram exit, remove location for each variable.
Chapter 8
K. Louden, Programming Languages

63. Using Shallow Access to Implement Dynamic Scoping
Chapter 8
K. Louden, Programming Languages

64. Fundamentals of Subprograms
Actual/Formal Parameter Correspondence:
1. Positional (this is what we are used to)
2. Keyword
e.g. SORT(LIST => A, LENGTH => N);
Advantage: order is irrelevant
Disadvantage: user must know the formal parameter’s names
Default Values:
e.g. procedure SORT(LIST : LIST_TYPE;
LENGTH : INTEGER := 100);
...
SORT(LIST => A);
Chapter 8
K. Louden, Programming Languages

65. Overloaded Subprograms
Def: An overloaded subprogram is one that has the same name as another subprogram in the same referencing environment
C++ and Ada have overloaded subprograms built-in, and users can write their own overloaded subprograms
Chapter 8
K. Louden, Programming Languages

66. K. Louden, Programming Languages
Generic Subprograms
A generic or polymorphic subprogram is one that takes parameters of different types on different activations
Overloaded subprograms provide ad hoc polymorphism
A subprogram that takes a generic parameter that is used in a type expression that describes the type of the parameters of the subprogram provides parametric polymorphism
Chapter 8
K. Louden, Programming Languages

67. Separate & Independent Compilation
Def: Independent compilation is compilation of some of the units of a program separately from the rest of the program, without the benefit of interface information
Def: Separate compilation is compilation of some of the units of a program separately from the rest of the program, using interface information to check the correctness of the interface between the two parts.
Chapter 8
K. Louden, Programming Languages

68. K. Louden, Programming Languages
Benefit (of system controlled storage management): ability to delay the binding of a storage segment's size and/or location
reuse of a storage segment for different jobs (from system supervisor point of view)
reuse of storage for different data structures
increased generality, not have to specify maximum data structure size
dynamic data structures
recursive procedures - garbage collection is automatic
Benefits of programmer controlled storage management
Disadvantage: burden on programmer & may interfere with necessary system control May lead to subtle errors May interfere with system-controlled storage management
Advantage: difficult for system to determine when storage may be most effectively allocated and freed
Chapter 8
K. Louden, Programming Languages

69. K. Louden, Programming Languages
Heap management
Single-size cells vs. variable-size cells
Reference counters (eager approach) vs. garbage collection (lazy approach)
1. Reference counters: maintain a counter in every cell that store the number of pointers currently pointing at the cell
Disadvantages: space required, complications for cells connected circularly
Expensive - when making a pointer assignment p=q
decrement count for old value of p
if 0, return to free storage. Check if contains references to other blocks. Could be recursive
do pointer assignment
Increment reference count for q
Chapter 8
K. Louden, Programming Languages

70. One-bit reference counting
Another variation on reference counting, called one-bit reference counting, uses a single bit flag to indicate whether each object has either "one" or "many" references.
If a reference to an object with "one" reference is removed, then the object can be recycled.
If an object has "many" references, then removing references does not change this, and that object will never be recycled. It is possible to store the flag as part of the pointer to the object, so no additional space is required in each object to store the count.
One-bit reference counting is effective in practice because most actual objects have a reference count of one.
Chapter 8
K. Louden, Programming Languages

71. K. Louden, Programming Languages
2. Garbage collection: allocate until all available cells allocated; then begin gathering all garbage
Every heap cell has an extra bit used by collection algorithm
All cells initially set to garbage
All pointers traced into heap, and reachable cells marked as not garbage
All garbage cells returned to list of available cells
Disadvantages: when you need it most, it works worst (takes most time when program needs most of cells in heap)
Chapter 8
K. Louden, Programming Languages

72. K. Louden, Programming Languages
Mark-Sweep - Java uses
In a mark-sweep collection, the collector first examines the program variables; any blocks of memory pointed to are added to a list of blocks to be examined.
For each block on that list, it sets a flag (the mark) on the block to show that it is still required, and also that it has been processed. It also adds to the list any blocks pointed to by that block that have not yet been marked. In this way, all blocks that can be reached by the program are marked.
In the second phase, the collector sweeps all allocated memory, searching for blocks that have not been marked. If it finds any, it returns them to the allocator for reuse
Can find circular references.
Easy if regular use of pointers (Like in LISP)
All elements must be reachable by a chain of pointers which begins outside the heap
Have to be able to know where all pointers are - both inside the heap and outside. How can a chain be followed from a pointer if there is no predefined location for that pointer in the pointed-to cell?
Chapter 8
K. Louden, Programming Languages

73. K. Louden, Programming Languages
Conservative garbage collection
Although garbage collection was first invented in 1958, many languages have been designed and implemented without the possibility of garbage collection in mind. It is usually difficult to add normal garbage collection to such a system, but there is a technique, known as conservative garbage collection, that can be used.
The usual problem with such a language is that it doesn't provide the collector with information about the data types, and the collector cannot therefore determine what is a pointer and what isn't.
A conservative collector assumes that anything might be a pointer. It regards any data value that looks like a pointer to or into a block of allocated memory as preventing the recycling of that block.
You might think that conservative garbage collection could easily perform quite poorly, leaving a lot of garbage uncollected. In practice, it does quite well, and there are refinements that improve matters further.
Because references are ambiguous, some objects may be retained despite being actually unreachable. In practice, this happens rarely, and refinements such as black-listing can further reduce the odds.
Chapter 8
K. Louden, Programming Languages

74. K. Louden, Programming Languages
Incremental Garbage Collection
Older garbage collection algorithms relied on being able to start collection and continue working until the collection was complete, without interruption. This makes many interactive systems pause during collection, and makes the presence of garbage collection obtrusive.
Fortunately, there are modern techniques (known as incremental collection) to allow garbage collection to be performed in a series of small steps while the program is never stopped for long. In this context, the program that uses and modifies the blocks is sometimes known as the mutator. While the collector is trying to determine which blocks of memory are reachable by the mutator, the mutator is busily allocating new blocks, modifying old blocks, and changing the set of blocks it is actually looking at.
Chapter 8
K. Louden, Programming Languages

75. K. Louden, Programming Languages
Heap Storage Management - Variable Sized Elements
Memory operations
Initially one large block
Free space list, as space is recovered
allocate from free list: first fit, best fit, worst fit
compact: maintain a length of each block
recover via explicit, garbage collection or reference counts Need length of each to locate pieces and coalesce
fragmentation
partial compaction (coalescing of adjacent free blocks) full compaction (move blocks) Show how
Chapter 8
K. Louden, Programming Languages