efficient viewpoints in Self
Jecel Assumpcao Jr
jecel at merlintec.com
Tue Feb 26 16:22:08 UTC 2002
It is possible to transform the Self virtual machine into an Us one
(see "A Simple and Unifying Approach to Subjective Objects",
http://citeseer.nj.nec.com/smith96simple.html ) that is acceptably
efficient. The solution is simple enough and obvious enough that I feel
very silly having taken a whole year to see it.
The basic idea is to extend customization from {source method, receiver
type} to {source method, receiver type, viewpoint}. For N active
viewpoints that would make the code cache N times larger, which is very
bad. Unless we do "selective customization" as I described in some
previous messages or some comparable scheme. Then only methods that are
actually called and are affected by a change in viewpoint will have
multiple versions in the cache. There would still be a time cost since
whenever a given method is called from a new viewpoint we have to redo
all the lookups to see if the code can be shared or must be recompiled,
but that shouldn't be too bad.
That structure of the objects in memory would have to be slightly
changed. The maps would have a list of slots for each layer and lookup
would have to visit these "pieces" in the order indicated by the
current viewpoint. The objects themselves would be just single
sequences of words. Imagine that each layer is stored in a separate
snapshot file and that a given object has four data slots and points to
a map with pieces from layers 1 to 7. Now we read in two files which
will add a layer 8 and a 9 to the map. Layer 8 includes two data slots
and these are mapped to words 5 and 6 in the object (which has to be
extended, obviously) and layer 9 has one data slot mapped to word 7 in
the object.
Note that these extensions don't have any effect on code that has
already been compiled since none of the previously available viewpoints
made any use of layers 8 or 9. The order of the mapping between data
slots in the layers and words in the object is not important as long as
it doesn't change while there is compiled code that depends on it.
Reading in a layer might cause objects that previously shared a map to
go their separate ways, but that is not a problem. Note that if we can
flush viewpoints and layers from the system, some objects could be left
with unused words in the middle of them (we don't compact), but I don't
think this is a big deal either.
If only one viewpoint and one layer are used, the overhead compared to
the current VM will be very small. So the extra stuff doesn't cost you
unless you actually need them.
I'll have to rewrite my "persistent object store" swiki page to be
compatible with this proposal.
-- Jecel
More information about the Self-interest
mailing list