TMA
- Jan 2001
Make 2-3 pages summary
report on design strategies
of UNIX, Mach and OSF/1 for
parallel computer.
Answer
- Design strategies of Unix
for parallel computer:
The Unix functions are implemented
with a large amount of system
software, much too large to
fit in its entirety in the main
memory. The portion of the O.S.
that resides continuously in
the main memory is called the
kernel and remaining components,
such as the file management
system and compilers for various
languages, are stored on disk
and brought into the main memory
only when needed. The increasing
role of Unix provides more flexibility
in customizing the kernel control
in dedicated environments for
real-time and transaction processing
applications. Unix supports
multitasking in which multiple
processes within a program can
run at the same time. In UNIX,
the foreground tasks are executed
at user processors through interactive
keyboard/display operations
performed by the users. The
background tasks, such as mail-a-message
and print-a-file, are handled
simultaneously, overlapping
with the foreground tasks. The
presence of multiple processors
should be hidden to provide
portability and compatibility.
These are two very important
issues in porting UNIX on computer
systems for parallel or distributed
processing. The kernel functions
should be designed to be architecture-independent
with the help of special hardware
and user interfaces. UNIX for
parallel computers should be
compatible with some existing
UNIX system such as Berkeley
BSD or Bell Laboratory’s
System V, among others. Multiprocessor
UNIX should be designed to explore
all opportunities for parallelism.
These include using multiple
threads of control in the kernel,
supporting fast interprocessor
synchronizations and self-scheduling,
and allowing multitasking or
multithreading at various MIMD
grain levels. A multiprocessor
UNIX should be able to support
parallel I/O activities, share
virtual memory in addition to
sharing physical memory, facilitate
better network messaging, allow
distributed program debugging,
and provide a large body of
UNIX libraries and utilities
for multiprocessing or multicomputing
applications. These design goals
will be reexamined as we proceed
with the study of various UNIX
extensions for multiprocessors
and multicomputers.
- Design strategies of Mach
for parallel computer:
Mach designers introduced five
program abstractions, task,
thread, port, message, and memory
objects. These have been improved
from existing UNIX for centralized
processing to parallel and distributed
computing. The Mach kernel contains
essentially three basic service
functions: processor scheduling,
interprocess communication,
and virtual memory management.
Conventional UNIX has been upgraded
in Mach to support parallel
processing on multiprocessors
and multicomputers. Mach design
support for both tightly coupled
multiprocessors and loosely
coupled multicomputers by separating
the process abstraction into
tasks and threads, with the
ability to execute multiple
threads within a task simultaneously.
Mach design has the capability-based
interprocess communication facility
that transparently extends across
network boundaries and integrates
with a virtual memory system
to allow the transfer of large
amounts of data via copy-on-write
techniques. A task includes
protected access and control
of all system resources, including
CPUs, physical I/O ports, and
either virtual or real memory.
A thread is the basic unit of
CPU utilization. It is equivalent
to a program stream with an
independent program counter
operating within a task. A task
may have multiple threads with
all threads under the same task-sharing
capabilities and resources.
A thread can also be treated
as an object capable of performing
computations with low overhead
and minimal state representation.
Mach’s virtual memory
system makes few assumptions
about the underlying machine
architecture, which has facilitated
porting of the Mach system to
various machines. Mach needs
no in-memory hardware-defined
data structure to manage the
virtual memory. The multiprocessor
system also adds to the difficulty
of connecting a universal model
of virtual memory. In addition
to address translation hardware,
multiprocessors also differ
in the kind of shared-memory
access they provide for individual
CPUs. Mach had been ported only
to multiprocessors with uniform
or nonuniform shared memory.
By taking advantage of its elaborate
message-passing facility, Mach
is able to integrate loosely
coupled multicomputers systems.
The impact of Mach on UNIX systems
is increasing steadily in the
parallel processing community.
- Design strategies of OSF/1
for parallel computer:
The OSF/1 is an operating system
compliant with standards, is
compatible with other versions
of UNIX, and contains some innovative
features. OSF/1’s innovation
involving the kernel comes primarily
from its Mach-based technology
and the provision of loadable
device drivers and streams modules
while the operating system is
running. The Open Software Foundation’s
OSF/1 kernel is a highly multithreaded
version of the Mach/OS. The
long-term goal was to return
to UNIX’s original small,
compact kernel. The OSF/1 include
multiple file systems, POSIX
compliance, a program loader,
a logical volume manager, streams,
and C2/B1 security. The OSF/1
kernel includes an internal
file system switch to facilitate
using multiple file systems.
The program loader is a new
feature developed in OSF/1.
It extends from the object file
format, has a format-independent
design, and supports a shared
library. The loader actually
runs primarily in user space.
The loader is mapped into the
processor’s virtual space
and the loader then maps the
application program into the
virtual memory. In OSF/1, the
kernel software for handling
a stream consists of a driver
and one or more modules. The
application creates a specific
driver for a stream via the
open system call and returns
with a standard UNIX file descriptor.
Data is passed between streams
modules in messages. The OSF/1
uses a thread for a compute-intensive
module. Multiple streams are
handled by multiple threads
on the symmetric multiprocessor
system. When multiple streams
modules are involved, messages
are exchanged in message queues.
A set of queues can be associated
with every module. An awakened
streams thread calls the module’s
service procedure, which processes
the message. It then calls the
next module’s put call.
The last module called returns
to the streams head and then
returns to the application program.
The OSF/1 logical volume manager
is a mechanism not only for
addressing a problem with traditional
UNIX files, which can only span
the size of a single disk volume
but also addressing files much
larger than the physical disk.
A modular approach is adopted.
Internally, the kernel invokes
a security policy module for
handling the application’s
system call. This module interrogates
a policy database on a user-mode
program.
