Amoeba Distributed Operating System - Distributed Operating Systems - Lecture Slides, Slides of Computer Science

Download Amoeba Distributed Operating System - Distributed Operating Systems - Lecture Slides and more Slides Computer Science in PDF only on Docsity!

Amoeba Distributed Operating

System

History

• The history of modern computing can be

divided into the following eras:

• 1970s: Timesharing (1 computer with many users)
• 1980s: Personal computing (1 computer per user)
• 1990s: Parallel computing (many computers per user)

What is Amoeba

• Amoeba is a distributed operating system

• Developed by Andrew Tannenbaum

• Uses timesharing

• User logs into the system as a whole, not just

his local machine.

• When the user runs a program, the system

decides which machine (or machines) in the

system should execute it.

• This decision is invisible to the user.

Design Goals

• The basic design goals of Amoeba are:

• Distribution—Connecting together many machines
• Parallelism—Allowing individual jobs to use multiple CPUs

easily

• Transparency—Having the collection of computers act like a

single system

• Performance—Achieving all of the above in an efficient

manner

Features in Amoeba

• Microkernel and Server Architecture

• Amoeba is built upon a microkernel architecture.
• The microkernel supports the basic process,

communications, and object primitives. It also handles

device I/O and memory management.

• Each machine in the Amoeba system runs a small identical

software program - called the microkernel.

• The function of the kernel is to allow efficient

communication between client processes, which run

application programs, and server processes, such as the

Bullet File server or the directory server.

Features

• Threads
• Each process has its own address space and contains multiple threads.
• These threads have their own stack and program counter, but share the global data and code of the process.
• Remote Procedure Calls
• RPC is the basic communication mechanism in Amoeba. Communication consists of a client thread sending a message to a server thread, then blocking until the server thread sends back a return message, at which time the client is unblocked.
• Amoeba uses stubs to access remote services which hide the details of the remote services from the user. A special language in Amoeba called the Amoeba Interface Language (AIL) generates these stubs automatically. The stubs will then marshal parameters and hide the communication details from the user.

Differences from Network OS

• Amoeba

• Programs can execute wherever OS decides.
• No concept of host machine.
• Objects and Capabilities are used to manage file systems.

• Network OS

• Programs run locally unless specified.
• User aware he is using a local host machine.
• Files are maintained and accessed from local machine

unless using a remote file system.

Architecture

• Four principle components

– Workstations

– Processor Pool

– Specialized Servers (directory, file, block...)

– WAN Gateways

Architecture

• Objects
  • Abstract data types with data and behaviors.
  • Amoeba primarily supports software objects, but hardware objects also exist.
  • Each object is managed by a server process to which RPCs can be sent. Each RPC specifies the object to be used, the operation to be performed, and any parameters to be passed
• Capabilities
  • 128-bit value object description created and returned to the caller when the object is created.
  • Subsequent operations on the object require the user to send its capability to the server to both specify the object and prove the user has permission to manipulate the object.
  • Capabilities are encrypted to prevent tampering.

How to use Amoeba

• Amoeba is freeware

• It can be loaded on a LAN or University

computer system

• Editors such as elvis, jove, ed come with the

installation package

• Compilers such as C, Pascal, Fortran 77, Basic,

and Modula 2

• Orca - used for Parallel Programming

Applications

• Parallel make
  • Amoeba runs contains a processor pool with several processors.
  • One application for these processors in a UNIX environment is a parallel version of make.
  • When make discovers that multiple compilations are needed, they are run in parallel on different processors.
  • pmake was developed based on the UNIX make but with additional code to handle parallelism.
  • many medium-sized files = considerable speedup
  • one large source file and many small ones = total time can never be smaller than the compilation time of the large one.
  • A speedup of about a factor of 4 over sequential make has been observed in practice on typical makefiles.

Applications

• The Traveling Salesman

– The computer is given a starting location and a list

of cities to be visited. The idea is to find the

shortest path that visits each city exactly once,

and then returns to the starting place.

– Amoeba was programmed to run this application

in parallel by having one pool processor act as

coordinator, and the rest as slaves.

Significance of points

• Amoeba is a distributed operating system which successfully

allows users to execute jobs transparently over multiple CPUs.

• It was primarily developed by Andrew Tannenbaum and

others at the Vrije Universiteit Amsterdam, Netherland.

• Its basic design goals are –
  • Distribution—Connecting together many machines
  • Parallelism—Allowing individual jobs to use multiple CPUs easily
  • Transparency—Having the collection of computers act like a single system
  • Performance—Achieving all of the above in an efficient manner.

Significance of Points

• It is based on a microkernel architecture.
• It uses objects to encapsulate data and processes and capabilities to describe the objects.
• The kernel provides just three major system calls
• trans(Msg *requestHeader, char *requestBuffer, int requestSize, Msg replyHeader, charreplyBuffer, int replySize)
• get_request(Msg *requestHeader, char *requestBuffer, int requestSize)
• put_reply(Msg *replyHeader, char *replyBuffer, int replySize)
• It has proven to be successful at implementing speedup on many common computer science algorithms including UNIX emulation, parallel make, traveling salesman, and alpha-beta search.