A m o e b A
-
Upload
prayag-kapoor -
Category
Documents
-
view
226 -
download
0
Transcript of A m o e b A
-
7/31/2019 A m o e b A
1/18
A MO E B AThe Study of a Distributed Operating System
Compiled & Prepared By:
Patel Nupur ([email protected])
Shah Palak ([email protected])
VI th Semester - Computer Engg.
U.V.Patel College of Engg, Mehasana.
http://var/www/apps/conversion/current/tmp/scratch7889/[email protected]://var/www/apps/conversion/current/tmp/scratch7889/[email protected]://var/www/apps/conversion/current/tmp/scratch7889/[email protected]://var/www/apps/conversion/current/tmp/scratch7889/[email protected] -
7/31/2019 A m o e b A
2/18
-
7/31/2019 A m o e b A
3/18
AMOEBA
Fields Of Application ........15
Conclusion ............15
Bibliography.........16
ABSTRACT
For my physical studies like Measurement of velocity gradients in high viscose liquids I
use Amoeba as a compact and powerful lab measurement system with many reducedpc systems for only data recording together with high speed Pentium PC's for data
analysis connected through a standard 10 Mbps Ethernet network. Putting all machines
together to one large coupled system is very simple and flexible. Only less
administration work must be done.
Amoeba doesn't make any usage of the BIOS. All needed hardware driversare delivered within the Amoeba kernel. But the first bootstrap stage (Amoebastandalone boot program on floppy or hard disks) needs the BIOS to load the first
Amoeba kernel.Amoeba builds upon a traditional micro kernel. It supports true
multithreading (kernel controlled), segment based memory management.Currently, it's the fastest distributed operating system.
Here I m giving u concise and informal introduction to distributed operatingsystem-AMOEBA
Compiled & Prepared By Patel Nupur & Shah Palak 3
-
7/31/2019 A m o e b A
4/18
AMOEBA
WHAT IS AMOEBA?
Amoeba is a distributed operating
system. It collects a huge variety of single
machines connected over a (fast) network to
one, huge computer. It was originally
developed at the Vrije Universiteit in
Amsterdam by Andrew Tanenbaum and
many more. Amoeba was always designed to
be used, so it was deemed essential toachieve extremely high performance.
Amoeba system will connect the multiple
Amoeba system in different sites into a single
coherent system. This goal is obtained by
using the object and capabilities in a uniform
way. Currently, it's the fastest distributed
operating system. The original Amoeba
sources are handled under a public license -
similar the BSD license.Amoeba builds upon a traditional
micro kernel. It supports true multithreading
(kernel controlled), segment based memory
management. All Amoeba components
communicate with each other over a
standardized RPC (Remote Procedure Call)
Compiled & Prepared By Patel Nupur & Shah Palak 4
-
7/31/2019 A m o e b A
5/18
AMOEBA
interface - simple but very powerful. No
matter if a client or server thread is running
in kernel or user mode - it uses the same RPC
interface. Always. Everywhere. This leads to
a very clean and simple OS design, very wellsuited for beginners.
Because Amoeba was designed from
scratch with new concepts, never seen
before, it suffered from a lack of application
programs. Therefore a POSIX-compliant
UNIX emulation was added. It makes porting
UNIX programs much easier! Now, with
additional changes, a huge variety of
application programs from the UNIX-world
work under Amoeba: X11 with applications,
various compilers (gcc, ocaml, tcl/tk), bash
shell, editors and many, many more. Amoeba
is ready to use! Of course not without (little)
problems.
It's still in a slightly experimental
state, but ready to use. FSD-Amoeba is
intended to use for dedicatedprogrammers only, and not for end users!
HISTORY
Developed at the Vrije UniversiteitAmsterdam, Netherlands. Chief designer:
Andrew S. Tanenbaum Other developers were Frans Kaashock,
Sape J. Mullender, Robbert van Renesse,
Leendert van Doorn, Kees Verstoep and
many, many more. First proto release in 1983 (V1.0), last
official release 1996 (V5.3) Supports
multiple architectures: 68k, i80386,
SPARC
DESIGN GOALS
Transparency:
One of the main goals of the Amoebadevelopment was to design a transparent
distributed system that allows users to log
into system as a whole: Transparency. Thatmeans: Hiding the comlexities of a
distributed system from the users. Amoeba
users should not be concerned about thenumber of processors in the system, nor must
they know the location of the other machines
or servers (like the Filesystem server...).
Distribution:
Several machines connected over a networkoperate as a single system: Distribution.
Amoeba gives its users the illusion ofinteracting with a single, powerful system.
Parallelism:
On an Amoeba system, a single program orcommand can use multiple processors to
increase performance. The user simply
requests an operation, and the Amoeba OS
decides the best way to execute the request.Amoeba will decide which processor (or
processors) is appropriate for the request,based on the current state of the system.Additionally, special development tools have
been made for an Amoeba environment that
takes advantage of the inherent parallelism.For example, Amoeba supports a parallel
'make' program.
Small Kernel approach:
To enhance flexibility and to minimize kernel
size its design was based on micro kernel
approach. That is, in Amoeba several of the
standard services, such as file service, arebuilt outside kernel in user space. This helps
in enhancing flexibility because these
services can be easily modified and multipleversions of service can be simultaneously run
on the same system to suit the needs of
different users.
Compiled & Prepared By Patel Nupur & Shah Palak 5
-
7/31/2019 A m o e b A
6/18
AMOEBA
Performance:
Much effort was given to meet this goal!!!
This is accomplished with a newly developed
High Performance network protocol called
FLIP (Fast Local Internet Protocol). WhenFLIP was developed, none of the current
protocols provided adequate support for
distributed systems. FLIP performs clean,simple and efficient communication between
distributed nodes. Development from the scratch;
Amoeba doesnt based on anyexisting operating system
Amoeba interact with the user as a
UNIX-like Timesharing System
High performance IPC message
passing for local, privileged user processes;
transfer of several data buffers with one
transaction; shared segment support with VM
address translation by the IPC module:
Implemented, shared segment support now
available
User process interrupt handler:
working
User process I/O port access: done
fast context switch (both thread and
process): currently not achieved
Clean and simple virtual memory
(but without page swapping): exists
already
SYSTEM ARCHITECTURE
Amoeba implements a universaldistributed Client-Server-Model. In fact,basically the whole system needs only three
Functions to do all the work: The transaction
call from the Client, and the GetRequest andPutReply functions on the Server side.
Amoeba Many different Processor
architectures are supported: i80386
(Pentium), 68k, SPARC. Today, only the
i80386 architecture is significant for building
an Amoeba system (cheap!!!).System consists of four principle
components:
Workstations Pool Processors Specialized Servers (File server...) Gateways
File Servers
The file server distributed with
Amoeba is called the Bullet Server. It uses a
large buffer cache to provide very high
performance. Thus the file server should berun on a machine with a large amount of
RAM, and, of course, a disk. There is a
modified version of the bullet server, calledbulletb, using a different cache method, and
needing less memory.
For the file server, the more memory
present, the better the performance. Thefollowing table shows the minimum amount
of memory needed for an isolated file server
host, a boot host, the installation, and theworkstation kernel. It also shows the largest
main memory support by the kernel. In most
cases this will not be supported by thephysical machine.
On the various 80x86 machines it
may be possible to insert up to 512 MB**,
depending on the machine. You need at least
Compiled & Prepared By Patel Nupur & Shah Palak 6
-
7/31/2019 A m o e b A
7/18
AMOEBA
4 MB RAM to run the bare kernel and
perhaps a login shell, for example a text only
console or a special I/O Hardware Server, aprinter spooler or something else.
Kernel Minimum
MemoryRequirement
Software
Limit onMemory
Workstation 4 MB 512 MB
Fileserver 16 MB 512 MB
Installation 32 MB 512 MB
Boot (withFS)
64 MB 512MB
Fig. 1. Minimum memory requirements forfile server machines and maximum memory
configurations supported by Amoeba.
At heart of the Amoeba system are
several specialized servers that carry out andsynchronize the fundamental operations of
the kernel. Amoeba has a directory server(called SOAP) that is the naming service forall objects used in the system. SOAP
provides a way to assign ASCII names to an
object so it's easier to manipulate(by
humans). The directory server can replicate
files without fearing their change. Amoebahas of course a file server (called the Bullet
Server) that implements a stable high speedfile service. High speed is achieved by using
a large buffer cache. Since the files are first
created in cache, and are only written to diskwhen they are closed, all the files can be
stored contigously. The underlying idea
behind immutable files is to prevent the
replication mechanism from undergoing raceconditions. And file server crashes normally
don't result in an inconsistent file system!The Bullet server uses the virtual disk serverto perform I/O to disk, so it's possible that the
file server run as a normal user program!
The Boot server control all global systemservers (outside the kernel): start, check and
poll, restart if crashed.
Workstations
Workstations allow the users to gain access to
the Amoeba system. There is typically oneworkstation per user, and the workstation are
mostly diskless; only a workstation kernel
must be booted (from floppy, via tftp, burnedin Flash-EEPROM). Amoeba supports X-
Windows and UNIX-emulation.
The primary function of workstationsis to run the user interface (for example the X
window system) and so they do not require
large amounts of memory. 8 MB is the lower
limit for color and monochrome X servers. 16MB and more is recommended. For a generic
text terminal, 4MB is still enough. It is also
possible to use an X terminal as a
workstation. (If the X terminal does notunderstand the Amoeba network protocol it
will be necessary to use a TCP/IP server toconvert network protocols which reduces
perceived performance.)If no bitmap display
is available a regular terminal can be used.Itwill not run X windows, of course.
Pool Processors
.The V8-SPARC processor pool at the VU
Amoeba is designed as a collection of micro
kernels. Thus the Amoeba system consists ofmany CPU's connected over a network. Each
CPU owns his own local Memory in therange from 2MB to several 100MB. A huge
number of Processors build the so calledProcessor pool. This group of CPUs can be
dynamically allocated as needed by the
system and the users. Specialized servers,called Run server, distribute processes in a
fair manner to these machines.
Compiled & Prepared By Patel Nupur & Shah Palak 7
-
7/31/2019 A m o e b A
8/18
-
7/31/2019 A m o e b A
9/18
AMOEBA
performance on Ethernet networks - see the
performance page for details.
Interprocess Procedure Call (IPC): used byprocesses and the kernel (for example device
drivers in user space) to interchange
messages and data buffers on the localmachine; optimized for low latency and high
transfer rates
Kernel administration
Remote rebooting of kernels: with a simple
RPC boot request it's possible to boot new
kernels on machines already running with an
Amoeba kernel.
Remote status report: nearly all kernel
related informations and statistics can be
retrieved remotely using a simple RPC
request, including the kernel message buffer(the content you can see printed on the
terminal console).
Now it's possible to run device drivers,
network protocol stacks, file systemservers,..., in user mode as generic user
processes (with some more privileges). Local
modules now communicate with the newenhanced IPC interface.
Most device drivers and many other
parts (servers) currently inside the Amoeba
should move outside the kernel in usual userprocesses with privileged rights. Similar
concepts from Mach, VSTa, L3/4 and QNX
influenced the new design to create an
Operating System ready for the third
millenium!
MICRO KERNEL DESIGN
Clean and unified interaction betweenkernel modules and processes inside and
outside of the kernel device drivers can be
implemented as generic user processesoutside the kernel fast I/O response time
kernel and user thread support (both
controlled by the kernel) small set of system
callsA small piece of code, called the
microkernel, is present on all Amoeba
machines and they run nearly the samemicrokernel which handles Low level I/O management Communication between processes or
threads Low level Memory management Process and thread (kernel/user space)
managementServer processes (see above) supply
other operating system services and
generally run in user mode. This job
specialization allows the microkernel to besmall and efficient, increases reliability,
allows as much as possible of the operatingsystem to run as user processes, providing
flexibility and no extra burdens are added to
individual CPUs with facilities that it doesn'tneed.
Process concept:
Amoeba supports traditional processconcept
Processes consists of several threads (at
least one) Each thread has his own registers,
Instruction Pointer, stack; but all threads
of a process share the same memoryregion
Example: File server. Each request is
handled by one thread, but all threads use
the same cache; synchronization throughMutex and Semaphores
Memory management:
Compiled & Prepared By Patel Nupur & Shah Palak 9
-
7/31/2019 A m o e b A
10/18
AMOEBA
Threads can allocate and deallocate
blocks of memory, called Segments . These segments can be read and written,
and cans be mapped into and out of the
address space of the process.
A process owns at leat one segment, butmay have many more of them. Segments can be used for text, data,
stack, or any other purpose the processdesires. The operating system doesnt
enforce any particular pattern on segment
usage.
I/O-Management:
For each I/O-Device attached to a
machine, there is a device driver in the
kernel. The driver manages all I/O for the
device. All drivers are static linked to the kernel;
no dynamic Module support Mostly the communication with Device-
Drivers are performed through the
standard message protocol (like the restof the system in user space)
Communication:
Two forms of communication are
provided: Point-to-Point communication Group communication
AMOEBAS OBJECT CONCEPT &
CAPABILITIES
The central point of the software
concept for a server implementation is the
Object concept. Each object consists of
Data and Operations on this data
Amoeba is organized as a collection
of objects (essentially abstract data types);
each with some number of operations thatprocesses can perform on it. Operations on
an object are performed by sending a
message to the object's server. Objects arecreated by processes and managed by the
corresponding server. There are many
different object classes:
Files Directories
Memory segments Processes I/O-Devices (Hard drive...) Terminals ...
Operations on objects are performedwith Stub-procedures. When an object is
created, the server returns a Capability. All
Amoeba objects (files, programs, memory
segments, servers) are protected and
described with so called Capabilities thecapability is used to address and protect the
object. A typically capability is shownbelow.
Figure 6. Capability [Tanenbaumet.al(1990, p
42)]
Service Port field identifies theserver.
Object field tells which object is
being referred to, since a servernormally will manage several
objects.
Rights field specifies whichoperations are allowed (e.g.
capability for a file may be read
only). Since capabilities are
managed in user space
Check field is needed to protectthem cryptographically, to preventusers from tampering with them.
PROCESS MANAGEMENT
Compiled & Prepared By Patel Nupur & Shah Palak 10
-
7/31/2019 A m o e b A
11/18
AMOEBA
A process is an object in Amoeba.
Information about the processes in Amoeba
are contained in capabilities and in a datastructure called a process descriptor, which is
used for process creation and stunned
processes (and process migration). Theprocess descriptor consists of four
components:
The host descriptor provides the
requirements for the system where the
process must run, by describing whatmachine it can be run
The capabilities include the capability of
the process which every client needs, andthe capability of a handler, which deals
signals and process exit The segment component describes the
layout of the address space (see below) The thread component describes the state
of each of the threads (see below) in the
process and their state informations (IP,Stack,)
Amoeba supports a simple thread
model. When a process starts up, it has atleast one thread. The number of threads isdynamic. During execution, the process can
create additional threads. And existing
threads can terminate. All threads aremanaged by the kernel. The advantage of this
design is that when a thread does a RPC, the
kernel can block that thread and schedule
another one in the same process if one is
ready!
Three methods are provided for threadsynchronization: Mutexes
Semaphores Signals
Mutex is like a binary semaphore. It can be
in one of two states, locked or unlocked.Trying to lock an unlocked mutex causes it to
become locked. The calling thread continues.
Trying to lock a mutex that is already locked
causes the calling thread to block untilanother thread unlocks the mutex.
Semaphores is the second way threads can
synchronize is by counting These are slower
than mutexes, but there are times when theyare needed. A semaphore can't be negative.
Try down a zero semaphore causes thecalling thread to block until another thread
does an up operation on the semaphore.
Signals are asynchronous interrupts sentfrom one thread to another in the same
process. Signals can be raised, caught, or
ignored. Asynchronous interrupts between
processes use the stun mechanism.
MEMORY MANAGEMENT
Amoeba supplies a simple memory
management based on segments. Each
process owns at least three segments:
1. Text/Code segment
2. Stack segment for the mainthread/process
3. Data segment
Each further thread gets his own stack
segment, and the process can allocatedarbitrary additional data segments.
All segments are page protected by the
underlying MMU, the kernel segments, too.
Compiled & Prepared By Patel Nupur & Shah Palak 11
-
7/31/2019 A m o e b A
12/18
AMOEBA
COMMUNICATION
All processes, the kernel too, communicate
with a standardized RPC (Remote procedurecall) interface. There are only three functions
to reach this goal:
trans(req_header, req_buf, req_size,
rep_header,rep_buf, rep_size)
do a transaction to anotherserver
getreq(req_header,req_buf,req_siz)
get a client request
putrep(rep_header,rep_buf,rep_siz)
send a reply to the client
The first function is used by client to
send a message to a server, and get a reply
from the server on this request. The reply andrequest buffers are generic memory buffers
(char). The reply and request headers are
simple data structures to describe the requestand the capability of the server. On the other
side, teh server calls within an infinite loop
the getreq function. Each time a client sendsthis server (determined by a server port - see
capabilities for details) a message, the getreqfunction returns with the client data filled in
the request buffer, if any. The request headercontains informations about the client
request.
Because the client expects a reply, the
server must send a reply (either with orwithout reply data) using the reply function.
THE VIRTUAL AMOEBA MACHINE (VAM)
Compiled & Prepared By Patel Nupur & Shah Palak 12
-
7/31/2019 A m o e b A
13/18
-
7/31/2019 A m o e b A
14/18
AMOEBA
New operating systems mostly lack of
actual device drivers, especially on the i86-
pc platform. For specialized machines, for example
data acquisition systems, or device
minimized numeric cluster machines, thenative Amoeba kernel is the best choice,
featuring a modern and clean microkernel,
and exploring the power of the Amoebasystem.
GENERAL REQUIREMENTS
The Amoeba distributed operating
system can run on many different types andbrands of computers. It is intended that it
should run on a network with at least fivecomputers. Although it is today technicallypossible to run Amoeba with just a single
processor, it is not a satisfactory way to use
the system. For a standalone system (withperhaps additional secondary machines) the
main machine should be equipped with at
least 64 MB RAM (128 MB recommended)and at least with 500MB disk space. It is,after all, a distributed operating system. To
get good results from the system you should
have a separate machine for the file server,one workstation per user (to run the user
interface) and a group of pool processors to
perform the actual work and to run variousservers. In general, at least five hosts are
needed for pleasurable computing, although
it's not true today anymore because of todays
fast Pentium machines. All the Amoeba hostsmust be connected by a network so that they
can communicate with each other, although
they need not necessarily be all on the samenetwork, as long as all the networks are
connected via gateways.
Currently, Fireball Amoeba only supports
Ethernet. In special only the 10 MBit/s
connectivity with RJ45 or RG58 connectors,
and now 100 MBit/s Fast Ethernet, too.
IMPLEMENTATION
According to Tanenbaum (1990),AMOEBA system has been implemented to
five different CPU : 68010, NS 32016, 8088,
VAX, PDP-11. The idea is to provide auniversal single powerful time sharing
systems, which consists of a collection of
machines, potentially distributed amongseveral countries. Current configuration has
48 single board VME based computers using
68020 and 68030 CPU and also 10 VAX
CPU forming additional processor pool.
A library which supports to run UNIXprogram on AMOEBA had been written.
Current research includes connectingAMOEBA at 5 locations in 3 countries.
Using Wide Area Network facilities.
SECURITY
Amoeba has two level of protection:
Ports for protecting access to server
Capabilities for protecting access toindividual objects.
Since the kernel must be kept as small as
possible, to implement the security aspect
there is two solutions.
hardware solution: A small interface box
(F - box) are put between each processor
module and the network. It can be done byputting into the VLSI chip in interface card,
or on a small printed circuit board which
attach to network. This solution is currently
used.software solution: since ports for public
servers are known to all users it is easy for an
intruder to impersonate a server just by doinga get_rerequest on the servers port. So the F-
box is built as a cryptographic algorithms
which has the same function with the F-box.
Compiled & Prepared By Patel Nupur & Shah Palak 14
-
7/31/2019 A m o e b A
15/18
AMOEBA
The F box is one way function mapping Get-
port to Put-port
Put-port = F(Get-port)
Thus that given G, P can be computed, but
that given P, calculating G is not practicallyfeasible.
Figure 7. Network security[Goscinski(1991,
p823)]
COMPARISION OF AMOEBA AND
V
There are some similarity between
Amoeba and V. Some of feature in Amoeba
are adapted from V. Some features ofAmoeba had been planed by the designer of
V to be implemented in the future, for
instance processor pool concept. [Cheriton
(988)].
Amoeba and V use the small kernel to
provide the infrastructure of the distributed
system. Kernel provides the communication,
process manager, memory manager and asmall server. Most of other facilities which
usually are in the Operating System run on
the top of the kernel at the user level. Thisapproach makes V and Amoeba more flexible
and more reliable, because if something goes
wrong in a server, the other server which is inthe other site (physically or logically) can
take over the process).
Amoeba and V are free-market model
service, Service such as the file system are inprinciple just an ordinary user process. Any
user who unsatisfied with the standard file
system will be able to write their own system.
Amoeba and V use client-server and
remote procedure call. The difference is the
transport protocol, V uses the VMTP butAmoeba does not. V and Amoeba allow the
process to migrate to another processor, if the
processor is busy or high loaded.V does not have the processor pool,
and there is no dynamic processor allocation.
Amoeba has a processor pool and does the
processor allocation. V had not beendeveloped to use the Wide Area Network, but
Amoeba has been implemented using WAN.
By using workstation as the processor, V cantake advantages of the modern and powerful
workstation, and the system will be more
reliable, because the responsibility of process
is distributed in each workstation.
Amoeba use only a single naming
mechanism (object with capability), It makes
the system will be more consistent and easier
to used. V uses 3 level of naming. At the toplevel of V naming mechanism, the
mechanism will works similar with object
and capability.
Amoeba is more fault tolerance thanV (Cheriton 1988), because V was designed
for interactive workstation, so if there aresomething goes wrong, user can re-execute.Amoeba is more secure than V, first Amoeba
using cryptography for naming, and secondly
Amoeba uses the hardware one wayscrambler.
Amoeba performance depends on the
processor pool, thus if there is a malfunction
it the processor pool all system will stop. Incontrast, V uses the processor in every
workstation, thus the responsibility of the
work is distributed to each workstation.
In the development process, V ismainly addressed to provide a fast
communication between work station, but
Amoeba is addressed to provide an objectoriented distributed operating system. And V
is designed to support parallel and real time
Compiled & Prepared By Patel Nupur & Shah Palak 15
-
7/31/2019 A m o e b A
16/18
AMOEBA
application on shared memory multiprocessor
machine.
The performance comparison betweenAMOEBA and V
System Null
RPC
in
msec
Throughput
in KBps
Estimated
CPUMIPS
AMOEBA 1.1 820 3.0
V 2.5 546 2.0
Table 1. Comparison between V and Amoeba
[Tanenbaum(1990, p57)]
This measurement is done from user to user,
and using SUN 3/60 for AMOEBA and SUN3/75 for V system. From this table can be
shown that the throughput of Amoeba is
better than V. and the overall CPU MIPS isbetter as well.
FIELDS OF APPLICATION
The VAM system can be used in the
following applications fields: Distributed measuring and data
acquisition systems, for example remotedigital camera servers connected with
an Ethernet network. The native Amoeba kernel is very well
suited for embedded systems. Distributed control systems. High performance parallel computing
and other distributed numerical
computations.
Distributed file systems using raw disk
access on the top of standard operatingsystems.
An example for a processor pool: About
60-80 Sun motherboards were build into a
rack system at the Vrije Univerity. Of coursecheap and normal IBM-PC 's can be used as
CPU-Servers, too!!!
CONCLUSION
A distributed system potentially willbe more reliable and low cost than a time
sharing system. However some problem still
arises in the designing of a distributed system. Those problems are communication
primitives, naming , resource management,
fault tolerance and the protection issues. The
hardware configuration which will be used
will determine the model of the operatingsystem, for instance a processor poll model
will be difference with workstation poolmodel.
The kernel model provide definition
of each facility based on maximisingperformance, minimising complexity in the
kernel maximising the reliability and security
attribute of the system. By placing the other
service outside the kernel and keeping thekernel as small as possible, the system is
more flexible and reliable.The client-server model with remoteprocedure call have proved that using basic
primitive communication the overhead of
communication can be reduced. The speed ofcommunication between processor
determines the performance of the system.
By using the object and capabilitymodel, Amoeba is more flexible and more
easily be used. Amoeba is the only one
Distributed Operating System which
implements Wide Area Network.
BIBLIOGRAPHY
BOOK:
Distributed Operating Systems by Tanenbaum
Compiled & Prepared By Patel Nupur & Shah Palak 16
-
7/31/2019 A m o e b A
17/18
AMOEBA
Distributed Operating Systems Concepts and Design by Pradeep K. Sinha
Web site:
http://www.cs.odu.edu/
http://images.google.co.in/images?
q=distributed+operating+system&hl=en&btnG=Google+Search
http://fsd-amoeba.sourceforge.net/amoeba.html
BACK TO INDEX
Compiled & Prepared By Patel Nupur & Shah Palak 17
-
7/31/2019 A m o e b A
18/18
AMOEBA
Compiled & Prepared By Patel Nupur & Shah Palak 18