Désolé, il n'y a pas de version française !
This is a brief description of the SOS distributed operating system. SOS was developed by the SOR group at INRIA. The most interesting research results of SOS include a simple, generic, powerful object model, and the concept of Fragmented Objects to structure distributed abstractions. In addition, SOS developed a flexible naming service, a dynamic linking package, and a library of application oriented communication protocols.
OverviewThe SOS system support object creation, deletion, remote invocation, migration, and long-term storage. It also provides for grouping of "elementary" objects into distributed groups called Fragmented Objects (FOs; see below).
An SOS object is any region of memory declared to the system as
being an object. The system allocates a descriptor for the object,
containing (among other things) a list of prerequisites and
an upcall table. The upcall table is a list of methods which
can be called by SOS in certain circumstances. For instance, when a
client asks to access a FO, the system upcalls a corresponding
giveProxy method, allowing it to allocate a proxy for
migration. Similarly, after an object is migrated, SOS calls its
reinitialize method, allowing it (for example) to fix its
pointers or import more objects.
A prerequisite of some object is another object Y which X needs in its environment. When X is migrated into some address space, SOS will (recursively) import its missing prerequisite into the same space.
Taken together, the prerequisite and the upcall mechanism allow
language environments or applications to tailor the object model to
their needs. For instance, we developed a C++ environment. A typical
data object has two prerequisites: a type prerequisite, a code
prerequisite. The latter takes care of reading and writing its
long-term representation. The type object carries its type
information, and the code object contains the compiled code of its
methods. When an object is imported, the type object's
reinitialize does a dynamic type-check, and the code
object's reinitialize does a dynamic link. The code
object in turn has at least one prerequisite (the dynamic linker); if
it represents a derived class it will also have as prerequisites the
code objects for the superclasses. Furthermore, a persistent object
has a storage prerequisite which makes sure the representation is
up-to-date.
Fragmented Objects
In object-oriented programming, the interfaces of different components can be encapsulated by abstract types. While there are several object oriented programming languages which can be used to defined these abstract types (e.g. C++), too few tools address the problem of structuring distributed applications. Usually a distributed application is made of a set of cooperative objects located in different address spaces. For different reasons, these objects sometimes need to communicate with one another, without the interference from other objects.
Fragmented Objects (FOs) is a model which allows to structure and interface cleanly the distributed components of such applications. The FO concept provides two different levels of abstraction: distribution of fragments is hidden to the FO's clients, whereas distribution us under the control of the implementor. This two-level transparency approach fits well to the respective needs of both implementors and users of distributed applications.
The SOR group has developed a specific language, FOG, to ease structuring distributed applications as fragmented objects. The SOR group has developed a FOG pre-compiler for C++. Other pre-compilers can be considered as well.
Publications about SOS