4 GC Collector Language, 2
GC Collector Scheme is based on PLAI. It provides
additional procedures and syntax for writing garbage collectors.
4.1 Garbage Collector Interface for GC2
The GC Collector Scheme language provides the following functions that provide access
to the heap and root set:
Returns the size of the heap. The size of the heap is specified by the mutator
that uses the garbage collector. See
allocator-setup for more
information.
Determines if
v is an integer between
0 and
(- (heap-size) 1) inclusive.
Determines if v is a root.
Sets the value at loc to val.
Returns the value at loc.
Returns the current
root?s as a list. This returns
valid roots only when invoked via the mutator language. Otherwise
it returns only what has been set up with
with-roots.
Returns the location of root.
Updates root to refer to loc.
Creates a new root. When
read-root is called, it invokes
get and when
set-root! is called, it invokes
set.
For example, this creates a root that uses the local variable
x to hold its location:
Evaluates each of the body-exprs in a context where
the value of heap-expr is used as the heap. Useful in
tests:
(with-roots (root-var ...) expr1 expr2 ...)
|
| |
|
Evaluates each of
expr1 and the
expr2s in
in a context with additional roots, one for each of
the
root-vars. The
get-root-set function
returns these additional roots. Calling
read-root on
one of the newly created roots returns the value of the
corresponding
root-var and calling
set-root!
mutates the corresponding variable.
This form is intended to be used in test suites
for collectors. Since your test suites are not running
in the
language,
get-root-set
returns a list consisting only of the roots it created,
not all of the other roots it normally would return.
Use
with-roots to note specific locations as roots
and set up better tests for your GC.
4.2 Garbage Collector Exports for GC2
A garbage collector must define the following functions:
init-allocator is called before all other procedures by a
mutator. Place any requisite initialization code here.
Given the location of a flat value, this procedure should return that
value. If the location does not hold a flat value, this function should signal
an error.
This procedure should allocate a flat value (number, symbol, boolean,
closure or empty list) on the heap, returning its location (a number). The
value should occupy a single heap cell, though you may use additional space to
store a tag, etc. You are also welcome to pre-allocate common constants (e.g.,
the empty list). This procedure may need to perform a garbage-collection. If
there is still insufficient space, it should signal an error.
Note that closures are flat values. The environment of a closure is internally
managed, but contains references to values on the heap. Therefore, during
garbage collection, the environment of reachable closures must be updated. The
language exposes the environment via the procedure-roots function.
Given two roots, one for the first and rest values, this
procedure must allocate a cons cell on the heap. If there is insufficient
space to allocate the cons cell, it should signal an error.
If the given location refers to a cons cell, this should return the first
field. Otherwise, it should signal an error.
If the given location refers to a cons cell, this should return the rest
field. Otherwise, it should signal an error.
If cons-cell refers to a cons cell, set the head of the cons cell to
first-value. Otherwise, signal an error.
If cons-cell refers to a cons cell, set the tail of the cons cell to
rest-value. Otherwise, signal an error.
Returns #true if loc refers to a cons cell. This function
should never signal an error.
Returns #true if loc refers to a flat value. This function
should never signal an error.
Allocates a closure with code-ptr and the free variables
in the list free-vars.
Given a location returned from an earlier allocation
check to see if it is a closure; if not signal an
error. if so, return the code-ptr for that closure.
Given a location returned from an earlier allocation, check
to see if it is a closure; if not signal an error. Uf so,
return the ith variable in the closure (counting from 0).
Determine if a previously allocated location
holds a closure. This function will be called only
with locations previous returned from an allocating
function or passed to
set-root!. It should
never signal an error.