how was TCF different or similar to Mosix - COFF

3 Apr 2021

On Fri, Apr 2, 2021 at 1:50 PM Theodore Ts'o &lt;tytso(a)mit.edu&gt; wrote:

...
  Out of curiousity, how was TCF different or similar to
Mosix?
 Many similar ideas.  TCF was basically the commercial implementation of the
Locus, which Jerry and students built at UCLA (one 11/70s original).  I
want to say the Locus papers are in some early SOSPs.

MOSIX was its own Unix-like OS, as was Locus [and some of this was in
Sprite too BTW].  TCF was a huge number of rewrites to BSD and was UNIX.
The local/remote restructuring was ad-hoc.   By the time Roman and I lead
TNF, we had created a formal VPROC layer as an analog to the VFS  layer
(more in a minute).   TNC was to be the gut of Intel's Paragon using OSF/1
as base OS.

The basic idea of all of them is that the cluster is looks like a single
protection domain with nodes contributing resources.   A Larry says a ps is
cluster-wide.  TCF had the idea of features that each node provides (ISA,
floating-point unit, AP, *etc*..) so if a process needed specific
resources, it would only run on a node that had those resources.   But it
also meant that processes could be migrated from a node that had the same
resources.

One of the coolest demos I ever saw was we took a new unconfigured PS/2 at
a trade show and connected the ethernet to it on the trade show network,
and put in a boot floppy. We dialed back into a system at an LCC, and
filled in some security things, details like the IP address of the new
system and soon it booted and joined the cluster.   It immediately started
to add services to the cluster, we walked away, and (overnight) the system
had set up the hard disk and started caching locally things that were
needed for speed.  Later I was editing a file and from another screen
migrated the process around the cluster while the editing was active.

The problem with VPROC (like VFS) is it takes surgery all over the kernel.
 In fact, for Linux 2.x kernel the OpenSSI
<https://sourceforge.net/projects/ssic-linux/> folks did all the kernel
work to virtualize the concept of process, which sadly never got picked up
as the kernel.org folks did not like it (a real shame IMO).   BTW, one of
the neat side effects of a layer like VPROC is things like
checkpoint/restart are free -- you are just migrating a process to the
storage instead of an active processor.

Anyway, Mosix has a lot of the same types of ideas.  I have much less
experience with it directly.