buck@siswat.UUCP (A. Lester Buck) (11/03/90)
The book "The LOCUS Distributed System Architecture" (1985), by Popek and
Walker, begins with a general discussion of distributed operating systems.
They cover the desirable features of transparency to hide the distributed
nature of the system. But then they deal with the very real issue of
optimization control. Excerpts:
One of the functions that conventional, nontransparent systems
provide is the ability of applications to take explicit
network-related actions for the sake of optimization. Placing
a given file at a particular site, or moving a resource from one
site to another, are obvious examples. [...] Unless some means
are provided in a transparent environment to accomplish the same
optimization actions, one could fairly expect significant
performance difficulties, even in a local network.
The principle by which this optimization goal can be accomplished
is straightforward. One can think of the set of functions by
which the distributed system provides service to applications
as an _effect language_. [...] We argue that a separate
_optimization language_ should be created, _orthogonal_ to the
effect language. The optimization language is _semantics free_,
in the sense that whatever is stated in the optimization language
cannot effect the outcome of a program; i.e., cannot change the
result of any statement or series of statements in the effect
language. The optimization language permits one to determine
the location of resources, request that the system move a
resource, etc. [...] In the case of a distributed operating
system, this orthogonal language might consist of additional
system calls such as:
my_loc - returns the site name at which the call is made
object_loc(object_name) - returns the site name of the named
object
make_near(object_name, site_name) - tries to move object_name
to a site where access from site_name will be efficient
With this kind of interface, a program such as the fragment below
executes correctly whether or not the optimization commands are
successfully performed by the system.
x = my_loc;
make_near(file_foo, x);
open(file_foo);
Note that the total set of system calls is available to a given
program, so that it is certainly possible to create a program
that will behave differently depending on the site of execution
(i.e., not in a transparent manner). Consider the following
program fragment:
if object_loc(file_foo) = my_loc
then call x else call y
We consider the above a necessary dimension to the transparency
concept. [Mention of how the optimization language is non-procedural
in a programming language based transparent system.]
I am working on various aspects of large distributed mass storage systems
where the applications want complete transparency to the storage of the
data, but where certain types of data must be "near" where the data will be
used (e.g., Cray data on co-located high speed disk array). Does anyone
know of implementations of such an optimization language in a distributed
operating system? IBM's Transparent Computing Facility (TCF), which is an
instantiation of the Locus architecture, offers a few pieces of the
optimization language. A user may give fstore values which determines where
files are stored and how many copies are replicated, and may move the
computation to the file (but not the other way around). I was looking for
more full blown optimization languages from other distributed systems.
Please post and/or email and I will summarize if there is any interest.
Thanks alot!
--
A. Lester Buck buck@siswat.lonestar.org ...!uhnix1!lobster!siswat!buck