Rich writes:

> Can I suspend myProc and save it to disk (seperately from quitting and
> saving the whole image)? Can I load it into different objects and
> resume it? Can I sneaker net it to a different machine and load it in
> a completely different copy of Squeak? Or will bad things happen?

     Okay, you all saw it coming, but I'll say it anyway. :)

     This is straightforward in Spoon, although a process is transferred
directly from one running system to another (not to a distinct storage
artifact first). The providing system can ensure that all the necessary
objects Colin described are present in the target system, while actually
transferring only those objects which are missing from the target system.

     Both systems have a clear notion of exactly which versions of all
classes and methods are present. If the target system is extremely
different from the providing system, then it's possible that a
tremendous number of objects may need to be transferred. But I expect
the typical case would be that the target system is a simple copy of the
providing system before the process was started, so in most cases
relatively few objects would need to be transferred.

     It's worth noting again that Spoon transfers all method literals
perfectly, including shared ("pool") variables. This is something that
is notoriously error-prone when the transfer medium is source code or
static serialization (e.g., Squeak's ImageSegments or ReferenceStreams,
VisualWorks' BOSS). And this is possible because the target system gets
a say in what to transfer and how to transfer it, right while the
transfer is taking place; the providing system doesn't have to decide
all that by itself.

     Finally, one can distribute work amongst multiple systems at a
finer grain than processes (namely, at the level of individual
message-send). Cheap message-sends could remain local, while expensive
ones happen remotely (e.g., on remote hardware sufficiently fast to
amortize the network overhead, which would certainly be the case if the
message-send runtime is on the order of three hours :). Everything is
still happening in the same process as far as the local system is
concerned, and you can still debug everything live from one place.


-C

-- 
Craig Latta
http://netjam.org/resume