Systems that are distributed on a network and run on multiple machines, they support parallel computing and provide single system image on different machines as compared to those OS that run on a single machine. The advantage of distributed OS over other OS is that number of machines can do a lot of work at less time. So in this paper, we will discuss such an OS called Amoeba OS that is designed for such an environment that consists of multiple computers and they acts as a single system. It is developed by Andrew S. Tanenbaum. The fundamental goal of this OS is that the system is transparent to user.
Amoeba currently runs on SPARC, sun 3/50 and sun 3/60.
1.1. Goals
Main goals of amoeba OS are:
Distributed:
The first goal of this OS is that a number of amoeba machines are connected to each other and all these are disperse on a LAN.
Parallelism:
The second goal is that multiple processors can do a single task at the same time to achieve performance. E.g. if to compute the production number of 10 employees, you will need to perform 10 steps one by one if you have single computer but when using multiple processors, all operations can be perform in one steps as you can divide each step to ten different computers that are connected through servers.
Transparency:
One of the most important goals of amoeba OS is transparency. This means that amoeba users don't know how many processors are used and where these are located. When user wants to store a file, it also doesn't know which server stores a file or where they are located.
Performance:
High performance is achieved by using FLIP protocol.
Design:
1.2.1 Hardware design:
Amoeba is composed of four components namely: workstations, processor pool, gateways and specialized servers.
Figure 1: Amoeba architecture
In this architecture, each user has a workstation and they are configured to perform certain tasks. E.g. one workstation is used for editing purposes and others are used for other purposes. All workstations are diskless; it provides symmetry and ease of maintenance [1].
It is possible through pool processors to provide as many as processors as there are active user. This pool has number of processors and is assigned to user when it is needed and after completion of tasks, it is returned to pool and processes are managed through specialized servers such as bullet server, directory server etc. All these servers run all the time [1].
Gateways are used to connect system at different sites. This is the concept of hardware architecture of amoeba OS.
1.2.2. Software Design:
Amoeba is based on object model. In amoeba, object is a piece of data on which certain operations are performed [2]. E.g. on files certain operations are read, write etc. Servers
manages objects. When client want to perform some operations on objects, it mention the following parameters such as object name, operation type (read, write etc) and any other parameter, then it sends RPC call to server and server returns key to client. Key allows amoeba clients to access objects. So server uses a key as a capability.
Fig.2 Mechanism of capability [1]
In this mechanism, the server port finds a specific server process for a particular object that manages that object and only 8 operations are allowed for each object. The main issue is that how to prevent capability from duplication? This issue is resolved by using check field of capability. This is field is only known to server. When client sends operation, server check the check field by generating random number and compares with capability, if they match then it allowed the operation to perform.
process management
In amoeba OS, processes are objects and capabilities contains information of objects.
Fig 3. Processes in amoeba [1]
The Amoeba kernel is a collection of kernel threads that offer services to user processes [1]. All threads are managed by kernel, so when one thread is block, it schedule another thread which is ready at that time.
Processes have at least one thread, when it starts and during execution it adds more threads and terminate existing threads. Process management in amoeba is managed at three levels as shown in table.
Levels
Functions
Process server
It is part of microkernel.
They are kernel threads that run on all machines.
Library procedures
It acts as an interface e.g. exec, stun etc
Run server
It decides where these processes are run on machine.
Fig 4. Process management in amoeba
Process descriptor, a data structure is used that contains following information.
Fig 5. Process descriptor [3]
Semaphores, mutexes and signals provides for threads to synchronize.
Memory management
Amoeba memory is based on number of segments and these segments are mapped into and out of processes address space. When process segments are running, they are residing in memory because there is no concept of paging and swapping. It makes its design simple as compared to other operating systems.
FILE SYSTEM
File system of amoeba consists of several serves such as
Bullet fileserver:
When client create a file, file is in memory, it then send RPC to bullet server that store files and returns a capability to client. Once files are created, it cannot be changed. Operations on bullet files are only read delete and create. It follows contiguous allocation (files store on disk). It only stores the files not name the file.
Fig 6. Amoeba bullet server[1]
This type of server is fast and simple.
Directory file server:
It handles the name of files. It knows the physical location of files. Files are also modified. Operations on directory files are: read, delete, modify and create.
I/O MANAGEMENT
Device drivers are managed in amoeba kernel and then these drivers manage I/O for devices.
COMMUNICATION
Amoeba has two forms of communication
Point to point communication:
when client send a message to server, it then blocks until server reply.
Conclusion
We conclude that in amoeba there is a no concept of home machine because user is login in whole system not to a specific machine. User didn't know about the number of CPU's and file servers, so transparency is a key design issue in this system. Nowadays, other clustered OS are easier to use than amoeba OS.
