1. Yousuf Surmust Instructor: Marius Soneru Course: CS550 Fall 2001
Amoeba Vs. Mach OS
Yousuf Surmust
Instructor: Marius Soneru
Course: CS550 Fall 2001

2. Amoeba Vs. Mach OS
Comparing Amoeba and Mach OS on the following grounds:
Design Goals
Architecture
Microkernel
Memory Management
Communication

3. Amoeba Design Goals Network transparency:
All resource accesses to be network transparent.
A seamless system-wide file system
Processes execute at a processor of the system's choosing, without the user's knowledge.
Object-based resource management:
Each resource is regarded as an object and all objects, irrespective of their type, are accessed by a uniform naming scheme.
Objects are managed by servers, where they can be accessed only by sending messages to the servers.
User-level servers:
The system software was to be constructed as far as possible as a collection of servers executing at user-level, on top of a standard microkernel that was to run at all computers in the system, regardless of their role.

4. Mach Design Goals Multiprocessor operation:
Execute on a shared memory multiprocessor.
Both kernel-mode threads and user-mode threads could be executed by any processor.
Operating system emulation:
To support the binary-level emulation of UNIX and other operating systems.
Mach allows for the transparent redirection of operating system calls to emulation library calls and thence to user-level operating system servers.
Flexible virtual memory implementation:
Mach provides the ability to layer emulation of other operating systems as well, and they can even run concurrently.
Portability: Designed to be portable to a variety of hardware platforms.

5. Mach Design Goals Support for diverse architectures:
including multiprocessors with varying degrees of shared memory access.
Integrated memory management and inter-process communication
to provide efficient communications of large numbers of data
Heterogeneous system support:
make Mach widely available
Compatibility:
offers full compatibility with UNIX 4.3BSD.
Ability to function with varying inter-computer network speeds
Simplified kernel structure
Distributed operation, providing network transparency to clients and an Object oriented organization both internally and externally.

6. Basic Concepts Amoeba Mach
A distributed system for use on CPU collection connected by LAN. Multiprocessors and WAN added later.
Amoeba has pool. User logs into machine.
OS decides where to run command, based on load.
No concept of home machine.
Mach
A single, multiprocessors and LAN added later.
Mach do not attempt to attempt to spread lout load.
Concept of home machine is present.

7. Current Hardware Amoeba SPARC (SUN4c & SUN4m) 386/486 68030 SUN 3/50
At the Vrije Universiteit, Amoeba runs on a collection of 80 single-board SPARC computers connected by an Ethernet, forming a powerful processor pool.
Mach
MicroVAX I & II
VAX11/750, 11/780, 11/785, 820x, 8300, 8600, 8650.
VAX 11/ /780's with 8 megabytes of shared memory.
VAX 11/ /785's.
IBM RT/PC.SUN3
Encore MultiMax.

8. Comparison of Microkernels
Amoeba is a complete distributed operating system constructed as a collection of user-level servers supported by the microkernel
Amoeba has a minimal kernel
Less number of system calls
Mach is primarily microkernel designs geared towards the emulation of existing operating systems, in a distributed system.
Mach kernel functionality to support widest range of applications.
Mach has more than five times number of systems calls as compare to the amoeba.

9. Process Management Scheduling:
Amoeba gives processes the choice of run-to-completion vs. Preemptive scheduling for its threads. Mach allows processes to determine the priorities and scheduling policies of their threads in software.
Multiprocessors:
Both kernels run on multiprocessors, but they differ in how they use the CPUs.
Object model and capabilities:
Amoeba is based on the object model, and has capabilities for processes, segments, and other kernel and user objects, providing an integrated naming and protection scheme for all objects in the entire system.
Mach only has capabilities for ports managed by kernel in capability lists, one per process. Port capabilities passed in controlled way.

10. Process Management
Thread Synchronization
Thread synchronization is done by mutexes and semaphores in Amoeba. In Mach it is done by mutexes and condition variables.
Scheduling:
Both systems support processes with multiple threads per process. In both cases, the threads are managed and scheduled by the kernel, although user-level threads packages can be built on top of them.
Thread migration concept:
Amoeba threads run on the same processor but processes may be spread over the CPUs. Threads on different processor can share same address space.
Mach use processor set concept to control of which threads assigned to which processor. This mechanism allows true parallelism among the threads of a single process.

11. Memory Management Address space
In Amoeba, a process can have any number of variable length segments mapped into its virtual address space wherever it wants to. Mach provides to its user processes is a linear address space from 0 to some maximum address. Within this address space, processes can define regions, which are ranges of addresses, and can map memory objects onto regions.
Paging
Amoeba does not support demand paging, so all of a process segments must be in memory when it is running.
In Mach pages can be moved in and out of memory, as space requires. A memory object need not be fully in memory to be used. When an absent page is touched, its external pager is told to find it and bring it in. This mechanism supports full demand paging.

12. Memory Management Object based system and page based system
Amoeba supports an object-based system that allows variable-sized software objects to be shared using the kernel’s reliable broadcast mechanism. Mach has a network message server that supports a page-based system.
Distributed shared memory
Both systems support distributed shared memory but they do it in different ways. Amoeba supports shared objects replicated on all machines. Objects can be of any size and support operations. Reads are done locally and writes use reliable broadcast. Mach use paged based distributed shared memory.

13. Communication Form of communication:
Amoeba supports three forms of communication: unreliable one-way message passing, reliable RPC, and reliable totally ordered group communication. Mach supports one form: reliable one-way message passing.
Messages typed:
Messages in Amoeba have a fixed part and a variable part and are un-typed. Messages in Mach have only a variable part and are typed.
Only Amoeba allows multiple replicated servers to listen to the same service address to stochastically distribute the requests over the servers.

14. Communication Message transmission:
Amoeba uses a custom protocol called FLIP (Fast Local Internet Protocol) for actual message transmission. In OSI terms, FLIP is a network layer protocol, whereas RPC is more of connectionless transport or session protocol. 
Mach allows messages to be transmitted from one process to another using the copy-on-write mechanism. Amoeba does not have this.
Ports: In Amoeba, messages are addressed to service addresses. The receiving thread must do a RECEIVE call that provides the buffer directly in user space. In Mach, messages are sent to ports. Mach support port sets, although they are only for receiving, not sending.
Mach’s ports are named by capabilities managed by the kernel and referred to by their indices in the kernel’s capability list.
Only Mach has SEND-ONCE capabilities.

15. Conclusion
In this paper I have thoroughly surveyed and compared two operating systems, Amoeba and Mach. I have found that these two OS microkernels are quite similar in various ways. Since both OS were independently designed and implemented but it is surprising fact that these differences are not very big. Both Amoeba and Mach were tested several times by their designer and they changed OS several times based on experiences gained form earlier versions.