Amoeba is a micro-kernel-based systems are tough makes many personal workstation into a single distributed system transparently. This system is already widely used in academic circles, industry and Government for about 5 years.
Amoeba is intended for distributed computing well (some independent users working on different projects) and parallel computing (for example, one user is using CPU 50 to play chess in parallel). The operating system also provides the mechanisms needed to do both the distributed and parallel applications, but the policy is fully determined by a user-level program. For example, both traditional (i.e. sequentially) makes a new and parallel amake provided.
When the user will use this operating system users will be shown a login screen which is almost similar to the look of the Linux GUI. Display logged on the Amoeba operating system can be seen in the picture below :
The purpose of the basic design of the Amoeba is :
That’s where Connecting together many machines
Allowing individual work is to use multiple CPUS with ease
Having a collection of computers act like a single system
Achieving all of the above in an efficient manner
The other main goal is transparency. Users do not need to know the number or location of the CPU, as well as the place where the file is stored. Similarly, issues such as file replication is handled largely automatically, without user intervention bythe.
Put in different terms, a user is not logged in to a particular machine, but to the system as a whole. There is no concept of a home machine. Once logged in, users do not need to provide remote login command specifically to take advantage of multiple processors or remote mount special operations to access remote files. For users, the whole system like a conventional timesharing system.
Performance and reliability have always been key issues in the operating system, so a substantial effort has gone into in dealing with them. In particular, the basic mechanisms of communication have been optimized to allow messages to be sent and the replies received with minimum delay, and to allow large blocks of data to be sent from machines of high bandwidth. This building block serves as the base for the implementation of high-performance subsystems and applications onAmoeba.
Basic concepts in Amoeba
The following sections provide an introduction to Amoeba and some of its characteristics.
Amoeba is designed with what is currently referred to as the microkernel architecture. This means that every machine in a system running a small, identical Amoeba of a piece of software called kernel. The kernel supports the basic processes, communication, and primitive objects. It also handles raw device i/o and memory management. Everything else is built ontop of this fundamental, usually byuser-space server process.
Thus the system is structured as a set of independent processes. Some of this is the process for a user, run the application program. The process is called a client. Process servers, such as file server or directory server Bullet. The basic functions of the microkernel is to provide an environment where clients and servers can be running and communicating with each other.
This modular design makes it easier to understand, maintain, and modify the system. For example, for a file server is a server is isolated, not being an integral part of the operating system, it is possible for users to implement the new file server for special purposes (e.g. NFS, database). In conventional systems, such as UNIX, add an additional user-defined file system infeasible.
Many of the traditional operating system, a process consisting of an address space and a single thread of control. In Amoeba, each process has its own address space, but may include some controls the thread (yarn). Each thread has its own program counter and stack yourself, but the code shares and global data with all other threads in the process.
- Remote Procedure Call
Threads often need to communicate with each other. Threads within a process can only communicate via shared memory, but the thread is located in the various processes require a different mechanism. Basic communication mechanism of the Amoeba’s remote procedure call (RPC). Communication thread composed of clients sending messages to a server thread, then blocking until the server sends back the thread back on message, and at the time of the client is blocked.
To protect the user from naive these details, the procedure of special library, called stubs, are provided to access remote services. Amoeba has a special language called Amoeba Interface Language (AIL) to automatically generate stub with this procedure. They marshal the parameters and hiding the details of the communication of the users.
- Group communication
For many applications, a one-to-many communication is required, where a sender wants to send a message to multiple recipients. For example, a group of collaboration servers may need to do this when the data structure is updated. Also often needed for parallel programming. Ameba provides a basis for credible, totally ordered communication groups, where all recipients of a guaranteed for groups get all the messages in the exact same order. This mechanism simplifies a lot of distributed and parallel programming problem.
- The object and the ability
Amoeba is mainly software support the object, but the object there is also hardware. Each of these objects is managed by a process server who can sent RPCs. each RPC determines the object that will be used, the operation should be performed, and any parameters that will be passed.
- Memory Management
Amoeba model of memory that is simple and efficient. A process address space consists of one or more segments of users mapped to the specified virtual address. When the process of implementing, all the segments in memory. There are swapping or paging in now, thus the Amoeba can only run programs that fit in physical memory. The main advantage of this scheme is its simplicity and high performance. Major drawback is that it is not possible to run a program larger than physical memory.
I/O is also handled by the kernel threads. To read the raw block of the disk, for example, the user has the proper authorization, whether RPCs with disk I/O threads on the kernel. Callers do not realize that the server is actually a kernel thread, since kernel threads and user-interface threads are identical. In General, only the file server and the system is similar to the process of communicating with the kernel I/O thread.