Q1a) According to Abraham Silberschatz, an OS “controls and
coordinates the use of the hardware among various application programs
for the various users”. Basically, the operating system sits between
user applications and the underlying hardware, providing a consistent
interface to hardware devices and apportioning those hardware
resources to the applications according to some set of policies.
Q1b) For most users, “operating systems for desktops” means Windows,
so I will concentrate on that platform. 8 years ago, in 1995, Windows
was at version 3.1.
Win3.1 provided a basic graphical shell on top of DOS, the Disk
Operating System, a single-user 16-bit operating system with very
limited multiprogramming capabilities.
By 1997, Windows 95 had appeared. Win95 was a much more advanced
shell, again on top of DOS. This was a later DOS though which
provided more functionality, and the shell could offer more features.
Basic networking, in the form of SLIP/PPP (Serial Line Internet
Protocol and Point to Point Protocol, for modems), TCP/IP (Terminal
Connection Protocol / Internet Protocol), and SMB (Server Message
Block, a standard used by IBM, Microsoft, and others) was included as
well. Windows 95 included some support for 32-bit applications, and
used some 32-bit code internally as well. Windows 98 was an improved
Windows 95, built on DOS 7. Added features included the FAT32
filesystem, enabling support for larger disk drives. Windows ME is
the final stop on the DOS->Windows progression which I will not
discuss unless you specifically request it, as it was a poor
alternative to other Oses available at the time.
Windows 2000, though it did not live up to its original goal of
integrating Microsoft's server OS (Windows NT) and desktop OS
(DOS/Windows), was an improvement on both. Windows 2000 brought
much-improved multiprogramming and memory protection, true multiuser
support, a better driver model, the NTFS filesystem, multiprocessor
support, and other features from the NT codebase.
Finally, we have Windows XP which seems to have achieved Win2000's
goal of integrating desktop and server OSes. The driver model was
again redone and there were other changes, but not nearly as drastic
as the win98->win2000 change.
Q1c) What criteria would you like evaluated?
Primary source:
Operating Systems Concepts, 6th edition. By Silberschatz, Galvin, and
Gayne.
================================================================================
Q2.)what is the main purpose of operating system and which services
are provided by the operating systems to the common computer users?
Although naturally the specifics of operating systems depend on the
system(s) under discussion, some similarities are worthy of mention.
The basic purpose of an operating system is to make computer hardware
more usable to users and application programmers. This is
accomplished primarily by abstracting system interfaces and allocating
system resources to running applications.
A single operating system may run on several different hardware
platforms, and must provide a common interface to the differing
hardware devices they provide. For example, the write() system call
under Solaris operates the exact same way for a programmer, regardless
of the underlying hardware. An IDE hard drive uses the same syscall
as a SCSI hard drive, SCSI tape drive, or network socket. The
operating system abstracts the different protocols involved and the
different performance characteristics (to some degree). This
abstraction allows new devices to be added without disrupting user
applications. For example, an operating system which supports IDE and
SCSI hard drives accessible through fopen(), read(), write(), etc. can
be extended to support Fibre Channel, USB, or Firewire storage simply
by modifying the OS's system calls. User applications need not know
anything about the differences between USB and the IDE and SCSI
devices it was originally intended to run on.
In order to implement the other half of its duties, an operating
system must contain a dispatcher and scheduler. The dispatcher's job,
as its name suggests, is to dispatch new tasks to the CPU. The
scheduler decides when those tasks should be run and for how long. A
further treatment of schedulers will be taken up in Q3.
The other basic requirement for an operating system is that it
apportion, schedule, and restrict access to, as necessary, the
underlying hardware. At minimum, access to the CPU and memory need to
be dealt with. Since a single-processor computer can only run one
thread at a time, the appearance of multiple concurrent processes must
be achieved through some sort of time-sharing mechanism. On hardware
not supporting multiprogramming, the operating system has no way to
reclaim the CPU when it schedules a process to run. Instead, it must
wait for the running application to specifically transfer control back
to the kernel, at which point it may schedule a new process to run.
This scheme is referred to as cooperative multitasking because the
applications must cooperate to share the CPU. Every time a running
process makes a system call such as to access the hard drive, allocate
memory, or the like, the operating system regains control. Typically
a system call is reserved which does nothing at all but transfer
control to the kernel allowing it to schedule a new process to run.
Hardware which supports timers give the operating system a new way to
regain control of the CPU. When the timer goes off the hardware
immediately begins executing in a special section of the kernel called
the interrupt handler. The interrupt handler saves a few CPU
registers into memory, giving itself a place to work, and then decides
which process to run next. A basic CPU scheduling algorithm, called
time sharing, sets up a timer to go off after a fixed time, say 10ms.
The interrupt handler counts these timer interrupts, and when it
reaches some value, such as 100ms, it resets its counter and switches
to the next process in a queue.
An operating system must also manage memory. The simplest memory
management scheme allocates all the memory on the system to the
currently-running application. When one process is being descheduled,
the memory is written out to disk, and the new process' memory is read
from disk to memory. Even with state-of-the-art disks, even a modest
application will require entirely too long to swap in or out of
memory. Slightly more complicated is a scheme where applications are
given a segment of memory, allowing many small applications to take
the place of one larger one in RAM. A major flaw with this system is
that one application can deliberately or inadvertently overwrite
memory belonging to another process or worse to the operating system
itself. The solution to this is protected memory. Access controls
are built into the part of the OS responsible for allocating and
accessing memory. When an application requests memory, a block of RAM
is given to it and a notation made confirming ownership. When the
application tries to use a piece of memory, the ownership table is
consulted and the read or write only succeeds if the application
trying to use the memory actually owns it.
The operating system also controls access to the disk, network, and
other devices. The same concepts of ownership and abstraction apply.
The OS may provide specific system calls such as fopen() to open a
file and read() to read from it. Alternately, using memory-mapped
I/O, the operating system “maps” a given I/O devices to a range of
memory. For example, rather than reading a file byte by byte and
forcing the disk to seek every time, the OS could allow the file to be
mapped to memory starting at 0x13780000. Then the application can use
standard memory-access routines to manipulate the file that has been
assigned to that range of addresses. The same scheme can be used to
control devices such as network cards. The NIC contains a buffer that
is mapped to a memory range, and also contains a few control words
which applications can modify. The card reads its control words
periodically, and acts on the directive(s) put there. For example,
after reading a 16KB buffer, the application could write 0x00001000 to
indicate that the buffer is empty and the NIC should read more data.
To write, the app could fill in the NIC's buffer, and signal a write
using the control word.
Operating systems provide a way for running applications to maintain
useful illusions. Applications can be written as if they were
running, alone, on powerful hardware with simple interfaces. The
operating system makes the necessary translations to allow software to
access hardware interfaces which are typically designed for speed and
efficiency, rather than ease of use. Disparate hardware interfaces
can be unified by a single software interface. By scheduling multiple
applications “at once” the hardware can be more fully utilized while
maintaining the illusion that each application is running by itself.
The operating system can give higher priority to applications that
users want to complete quickly, and lower priority to tasks which will
take a long time anyway or are not time-critical.
================================================================================
Q3.)Describe the four management functions of operating systems.
<< When I studied OSes, we broke out process management and storage
management; other things are managed by the OS, but rather than
discourse on topics you aren't interested in, I would ask you to tell
me what other two categories you would like me to group things into,
and I will write “the other half” of this answer for them. >>
Operating systems must, at a bare minimum, manage the processes that
run on them, and the storage that these applications use.
Applications may contain one or more threads, which are the units the
operating system schedules. A thread is, roughly speaking, an
execution stream and context (contents of memory, processor state,
etc.). In order for a thread to be of any use it must be run on an
available processor. The dispatcher controls mechanisms involved in
running new threads on the CPU, while the dispatcher decides how and
when these threads should be run. Modern operating systems tend to
provide priority queues which control when processes get run. The
highest-priority (or first highest-priority, of there is a tie) is run
after a timer is set to interrupt the process. If a process
interrupts itself by making a system call, the system call is executed
and the process's priority is raised. If the OS regains control
because the timer went off, the running process's priority is lowered.
In both cases, the scheduler then looks for another process to run.
The practical benefit of this scheme is that I/O-bound tasks, such as
interactive tasks waiting for user input, or tasks which make heavy
disk or network usage are given extremely high priority because they
use so little CPU time relative to the wait time they incur for I/O to
complete. Since they so rarely use the CPU and for such a short time,
they can benefit immensely from being given access to the CPU as soon
as they are ready for it. This keeps the I/O devices busy as they are
seldom waiting for the CPU to give them more work to do. CPU-bound
tasks will take a long time regardless of when they use the CPU, so
they are given low priority and are interrupted for brief intervals
when high-priority tasks need to get a little work done before they go
back to sleep. The operating system must also concern itself with
issues of concurrency. That is, suppose one thread asks to write to a
location in memory. The OS sets in motion that memory write, and
switches to a different thread. If that thread reads the same memory
location the first one wrote, what should it read? Should it read the
old value? The new value? That decision must be made by policy, but
it is universally acknowledged that there are wrong answers – the
second thread must not read a combination of the old and new values.
Worse, what happens when two threads try to write to the same location
at the same time? The operating system must provide synchronization
to allow processes to maintain order in situations like these.
The operating system must also control access to storage. Memory
must be managed to allow multiple applications to exist simultaneously
without interfering with each other. Modern OSes provide virtual
memory; that is, a flat address space that starts at 0 and counts up.
The application's memory may be scattered throughout the physical
memory, but as far as the process is concerned, each byte follows
nicely on the heels of the one before it. Virtual memory can be done
by paging, where fixed-size blocks of memory are allocated, or where
variable-size blocks are used. Each of these methods has advantages
and drawbacks beyond the scope of this discussion. However it is
accomplished, the OS must protect itself from modification by user
applications, and also protect individual user processes from each
other. The operating system also provides a file system, a mechanism
for abstracting and using disk space. Much like memory allocation,
disk space can be apportioned in fixed-size or variable-size blocks
both with advantages and disadvantages. Though different features
(small file efficiency, speed, large file efficiency, protection and
access controls, etc.) are a part of different filesystems, the basic
concepts of a file and directory are universal and are provided by the
OS.
================================================================================
The storage allocation paragraph is short because if I go into much
more detail I will uncover such a myriad array of choices that that
section will take pages by itself, but if there is some small part you
would like more detail on, feel free to ask and I'll add it in.
Again, let me know what other two management categories you want, and
how you want me to evaluate the various Windowses. If you would like
information on more than Windows, I have more or less familiarity with
DOS, OS/2, BeOS, MacOS, Linux, and xBSD, and could provide examples
from those operating environments.
Don't hesitate to request a clarification (my preferred way of you
answering my questions, as it will trigger Google to send me an email)
of anything I've written. You're paying for the information, so you
should get what you want.
Thanks for the chance to review!
-Haversian |
