Performance and Evaluation of Lisp Systems - Dreamsongs

6
to assign any location the name of the lexical variable at various times). Typical
locations for temporaries, both user-defined and compiler-defined, are the regis-
ters, the stack, and memory. Since Lisp code has a high proportion of function
calls to other operations, one expects register protection considerations to mean
that temporaries are generally stored on the stack or in memory. In addition,
since many Lisp programs are recursive, their code must be re-entrant and, hence,
must be read-only. This argues against general memory assignment of tempo-
raries. Consequently, most lexical variables are assigned to the stack in many
Lisp implementations. Variables that are in registers can be accessed faster than
those in memory, although cache memories reduce the differential. 4
Compilation of references to constants can be complicated by the fact that,
depending on the garbage collection strategy, the constants can move. Thus,
either the garbage collector must be prepared to relocate constant pointers from
inside code streams or the references must be made indirect through a reference-
table. Sometimes, the constants are ‘immediate’ (i.e., the bits can be computed at
compile time). On some systems, constants are in a read-only area, and pointers to
them are computed at load time. Immediate data are normally faster to reference
than other kinds, since the operand-fetch-and-decode unit performs most of the
work.
1.1.2.2 Free/Special Variable Lookup and Binding
There are two primary methods for storing the values of free/special variables:
shallow binding and deep binding. Deep binding is conceptually similar to ALIST
binding; 〈variable name, value〉 pairs are kept on a stack, and looking up the value
of a variable consists of finding the most recently bound 〈variable name, value〉
pair. Binding a free/special variable is simply placing on the stack a new pair
that will be found before any previous pairs with the same variable name in
a sequential search backwards along the variable lookup path (typically this is
along the control stack).
A shallow-binding system has a cell called the value cell for each variable.
The current value of the variable with the corresponding name is always found
4 And, in fact, on some machines the cache may be faster than the registers, making some
memory references faster than register references. A good example is the KL-10, where, unlike
KA-10, it is slower to execute instructions out of registers and to fetch registers as memory
operands than it is to perform those operations from the cache.