Sun Sep 19 19:33:04 CEST 2010

Always-on / Image-based computing

What does it mean to take a snapshot of a memory image?  (I.e. OS
hybernate).  The bottom line is that memory-structure is simple, but
if memory points to external (non-memory) resources, one gets a hairy
problem of re-initialization on bootup.

Is it possible to design a computer that does not have any external
references?  I mean, start at the hardware: is it possible to design
hardware without hidden state?  Meaning, all state is exposed as RAM.

Probably not realistically..  However, it should be possible to at
least isolate initialization and limit them to an absolute minimum.

What does this mean?

Is initialized hardware maybe an "intermediate state", and is the
real, natural state of hardware the OFF position?

Is an interrupted machine and interrupted transaction that can be
simply restarted.

Can hardware initialization be seen as a transaction that never

What about this:

 - An OS image (a "soft" object) is a graph structure represented in
   RAM which is transformed by an interpreter (CPU).

 - Some of the leaves in this tree are opaque objects that represent
   connections to the outside world (stateful objects): ports.

 - Opaque ports have a single method: they can be initialized.
   Necessary parameters for the initialization are present in the
   image and are transparent.

 - To reflect real-world scenarios, ports can depend on each other.
   I.e. a port initializer can be parameterized by an other, low-level
   initialized port.

The point is that instead of seeing the whole OS as an opaque object,
it might be beneficial to reduce the granulairity of opaqueness.
Booting is "compilation", and hibernation and snapshotting is caching
of compiled results.

Moral: it takes a long time to restart a whole system.  It takes
significantly less time to restart only the non-memory resources of a

Most of the beef in modern computer systems is in the in-RAM data
structures, not the hardware configuration.  Rebooting mostly rebuilds
those data structures from more primitive (serialized, non-linked)