Path: utzoo!utgpu!news-server.csri.toronto.edu!clyde.concordia.ca!uunet!mcsun!hp4nl!star.cs.vu.nl!ast
From: ast@cs.vu.nl (Andy Tanenbaum)
Newsgroups: comp.os.misc
Subject: Test for distributedness
Message-ID: <6117@star.cs.vu.nl>
Date: 24 Mar 90 18:32:01 GMT
References: <6067@star.cs.vu.nl> <2604@quiche.cs.mcgill.ca> <6106@star.cs.vu.nl> <6548@becker.UUCP>
Sender: news@cs.vu.nl
Organization: Fac. Wiskunde & Informatica, VU, Amsterdam
Lines: 53

In article <6548@becker.UUCP> bdb@becker.UUCP (Bruce Becker) writes:
>	More or less. All resources can be allocated
>	to a job, including cpu, memory, files, disk
>	drives, modems, etc. The difference is that
>	you can tell (until the new version this
>	year perhaps) where the resource lives, but
>	you treat it locally (except for diskette
>	drives - inserting a diskette halfway across
>	a continent is a bit inconvenient 8^). One can
>	get an executable from one machine, execute
>	it on another, and have the screen/kybd i/o
>	sent to your own machine - all simple to do,
>	built in to the system. The name space isn't
>	as global as the way you describe, in the current
>	version - I imagine better name space management
>	might come with the POSIX version due out this
>	spring...
The key issue in a distributed system is transparency.  Are the users
aware of where things are? I propose a kind of Turing test for distributedness:

You take two teams of users and give each person a terminal.
The people on team A all have terminals on a standard timesharing system.
The people on Team B all have terminals attached to a distributed system.
The object of the game is for each team to figure out which system it has.
The object of the game for the system designers is to make them fail.
If nobody can tell, you have a distributed system.  In a funny way, the old
CDC Cybers are very distributed.  They have one or more CPUs and a whole
bunch of PPUs that do lots of work.  The users to not rlogin to PPUs or
tell them to do anything.  The average user doesn't know they exist even.
It looks like one system.  However, the Cybers are not really distributed
because an additional requirement really should be that the processors need
not necessarily all be in the same room, which they must be with the Cybers.

It is legitimate for person 1 to start up a huge CPU-bound computation to
see if person 2 notices any performance degradation.  On a timesharing
system, person 2 would see this (Butler Lampson once called this a covert
channel.)  If the system being tested has the property that your jobs always
run on your "home" machine, so that the other team members who happen
to be logged in elsewhere don't notice anything, it is not distributed.
There must be a common pool of resources shared equally among all users,
just like in a timesharing system.  Remember, the goal of the system designers 
is to make a system where the team can't tell.  This implies (as a bare
minimum, that the *system* does process scheduling, e.g. assigning processes
to processor at random, using round-robin, using lowest load, or something
like that.  The user should have nothing to do with it.

I don't think Amoeba would fully pass at the moment, but I don't think
any other existing system would either.  Nevertheless, that is clearly the
goal we are aiming at, and I think we are not doing all that much worse than
everyone else.  Could QNX pass the test?  How about Mach?  Chorus?  Sprite?
Others?

Andy Tanenbaum (ast@cs.vu.nl)