Amoeba - A Distributed System for the 1990s

Group A6Abdul Aziz

Habib AmmariPearl ThomasVamsi Krishna

IntroductionIntroduction

• Amoeba: distributed operating system developed at the Free University (Amsterdam), and Center for Mathematics and Computer Science (Amsterdam)

• Single big timesharing system- Transparency of processors assigned to jobs- Transparency of user’s files storage and their replication- Transparency of processes-machine intercommunications

• Amoeba 4.0 system released in 1990

Amoeba Hardware architectureAmoeba Hardware architecture

• Workstations• Execution of processes interacting intensively with the user• Examples. Window manager, command interpreter, editors, CAD/CAM

graphical front-ends

• Processor Pool• Computing power• Large number of single-board computers (several megabytes of private

memory, network interface)

Amoeba Hardware architecture (cont’d)Amoeba Hardware architecture (cont’d)

Example. make <program>- <program>: program with dozens of source files- Processor allocation for running many compilations in parallel- Return of processors to the pool at the end of execution

• Multiprogrammed pool processors (best performance when a process is assigned its own processor)

• Dynamic number of processors• Crash of few processors will not affect the system (some jobs may have to

be restarted): degree of fault tolerance

Amoeba Hardware architecture (cont’d)Amoeba Hardware architecture (cont’d)• Specialized Servers• Running dedicated processes with unusual resource demands• Example: running file servers on machines having disks (performance

optimization)

4. Gateways• Gateways to other Amoeba systems accessed over wide area networks• Amoeba is spans several countries• Gateway: local machines protection from the idiosyncracies of the protocols

used over the wide area links

Centralized computing power: incremental growth, fault tolerance, large amount of computing power assigned to a single job (temporarily)

Amoeba Software architectureAmoeba Software architecture• Amoeba: Object-based system using clients and servers• Use or RPCs for client processes-server processes communication (sending

requests: operations on objects)• Objects identified and protected by capabilities• Capability structure

- Server port: server who manages the object- Object number: object identifier- Rights field: permitted operations- Check field: cryptographic protection (keeping users from tampering with the other fields)

• Capabilities embedded in a huge address space: key to protection in Amoeba• Capabilities managed by user processes

Amoeba Software architecture (cont’d)Amoeba Software architecture (cont’d)• Objects implemented by server processes (managers)• Server port used to locate the appropriate server process• RPCs: requests and replies delivered to authorized processes• Objects

- System level identification: capabilities- User level identification: human-sensible hierarchical naming scheme- Directory server: mapping of ASCII path names onto capabilities

• File server: Bullet server (faster than a speeding Bullet) storing immutable files as contiguous byte strings on disk and in its cache

• Amoeba kernel: memory segments management, multiple-threads processes and their interactions

• Process-management facilities: remote process creation, debugging, checkpointing, migration

Amoeba Software architecture (cont’d)Amoeba Software architecture (cont’d)• Other services (directory service) provided by user-level processes: flexible

system with high performance• Amoeba design: avoiding concessions to existing OS and software• Ajax: Unix emulation service developed for running existing software on

Amoeba

Communication in Amoeba

• Amoeba’s conceptual model is that of a client thread performing operations on objects.

• A client sends a request message to the service that manages the object

• A server thread accepts the message,carries out the request, and sends a reply message back to the client.

• Multiple server processes jointly manage a collection of objects of the same type to provide the service for fault tolerance and performance.

Remote Procedure Calls• The kernel provides three basic system calls

– GetRequest: used by servers to announce their willingness to accept messages addressed to a specific port.

– SendReply: used by servers, to send back replies.– DoOperation: sending a message to a server and then blocking until a

reply comes back

• user-oriented interface built on top of three system calls, to allow users to think directly in terms of objects and operations on these objects.

• Classes can be composed hierarchically, that is, a class may contain the operations from one or more underlying classes.

• This multiple inheritance mechanism allows many services to inherit the same interfaces for simple object manipulations, such as for changing the protection properties on an object, or deleting an object.

Remote Procedure Calls

RPC Transport

• The Amoeba Interface Language(AIL) compiler generates code to marshal or unmarshal the parameters of remote procedure calls into and out of message buffers and then call the Amoeba’s transport mechanism for the delivery of request and reply messages

• Messages consist of two parts, a header and a buffer.• The header has a fixed format and contains addressing

information, an operation code which selects the function to be called on the object, and some space for additional parameters.

RPC Transport Continued…

• The buffer can contain data.• With this setup, marshalling the file data takes zero

time, because the data can be transmitted directly from and to the arguments specified by the program.

Locating Objects• Before a request for an operation on an object can be delivered to a

server thread that manages the object, the location of such a thread must be found

• All capabilities contain a Service Port field, which identifies the service that manages the object the capability refers to.

• When a server thread makes a GetRequest call,it provides its service port to the kernel, which records it in an internal table.

• When a client thread call DoOperation, it is the kernels job to find a server thread with an outstanding GetRequest that matches the port in the capability provided by the client.

Locating Objects Continued…

• In a wide area network, a slightly different scheme is used, each server wishing to export its service sends a special message to all the domains in which it wants its service known.

• In each such domain, a dummy process, called a server agent is created, which does a GetRequest using the server’s port and then lies dormant until a request comes in, at which time it forwards the message to the server for processing.

Performance of Amoeba RPC

• We booted the Amoeba kernel on two 16.7 MHz Motorola 68020’s and created auser process on each and let them communicate over a 10 Mbps Ethernet.

• For just a header, the complete RPC took 1.4 msec.• With 8K of data it took 13.1 msec, and with 30K it took 44.0 msec.• The latter corresponds to a throughput of 5.4 megabits/sec, which is

half the theoretical capacity of the Ethernet, and much higher than most other systems achieve.

The Amoeba File System• Capabilities form the low-level naming mechanism of

Amoeba– Extra level of mapping provided from human sensible

hierarchical path names to capabilities.• Directory Server

– The Hierarchical Directory Structure– Directory as a set of (names, capabilities) pair.

• Lookup (DirCap, ObjectName)• Enter (DirCap, ObjectName, ObjectCap)• Delete (DirCap, ObjectName)

Amoeba File System - Cntd

• Complex sharing – directory as n+1 column table with ASCII names in

column 0 and capabilities in column 1 through n• The Bullet Server

– Support only three principal operations• ReadFile• CreateFile• DeleteFile

Amoeba File System - Cntd

• All files are immutable– Advantage: Final file size is known– Disadvantage: Segmentation

• Reliability– Directory Server has a crucial role

• Up & Running: Replication of data• Trusted to work correctly: Encryption

– Techniques:Fault Tolerant Database Systems

Process Management

• Amoeba processes can have multiple threads of control• A process consists of a segmented virtual address

space and one or more threads• Processes can be remotely created, destroyed,

checkpointed, migrated and debugged• Processes have explicit control over their address

space• adding and removing of new segments

• Process created by sending a process descriptor to a kernel in an execute process request

• A process consists of

Process Management - Cntd

Host Descriptor Process Capability

Handler Capability Number of segments

Segment Descriptor Number of Threads

Thread Descriptor

Process Management - Cntd

• Main System calls in Amoeba• DoOperation• GetRequest

• Processes can be in two states• Running• Stunned

Memory Management in Amoeba

• Process is entirely memory resident to run – extremely high transfer rates for large RPC’s are possible.

• Each segment is contiguosly stored in memory– Design is helpful for performance, simplicity and economics– Not having to page or swap makes the design considerably

simpler and makes the kernel smaller and more manageable• Large memories will substantially reduce the need for

paging and swapping, namely to fit large programs into small machines

Unix Emulation• The emulation facility does the work by calling the bullet

server, directory server and the Amoeba Process Management facilities

• Initially implemented system calls: open , close, dup, read, write, lseek

• Session server was developed to allocate Unix PIDs,PPIDs and assist in the handling of system calls involving(fork, exec, signal, kill, UNIX pipes etc)

• The X window system ported in Amoeba

Conclusion

• The concept of Distributed Operating system without attempting to restrict to existing operating systems

• It was remarkably easy to port all the Unix software to use in Amoeba

• Use of Objects and capabilities• The design to build directly on the hardware• Amoeba kernel is small and simple• The few operations that are implemented by Amoeba

kernel are versatile and simple to use.

Questions ?

Comments !&