Loose Ends; Midterm Review

Tom Kelliher, CS 318

Mar. 30, 1998

Announcements:

From last time:

Outline:

Assignment:

Operating System Structures

Definitions:

• Layered System --- A system in which pieces are built on top of other pieces, with hardware as a foundation. A layer make calls exclusively to the layer beneath it.

  Advantages:

  1. Well defined structure.
  2. Modular.
  3. Information Hiding.

  Disadvantages:

  1. Poor performance on ``deep'' calls --- latency.
  2. Difficulty in creating a ``good'' layered design.

• Micro Kernel --- A small executive that provides only necessary functionality to support threads/processes:
  • CPU scheduling.
  • Process primitives: create, destroy, suspend, activate, change priority, etc.
  • IPC.
  • Virtual Memory.
  • Interrupt handlers.
  • Device driver interface.
  Runs in kernel (supervisor) mode. Everything else runs in user mode.

  Advantages:

  1. Only a small amount of code runs in kernel mode.
  2. Easily extended.
  3. System routines work with an abstract machine model --- portability.

  Disadvantages:

  1. System calls require a context switch (slow).
  2. Not easily extended (traditional kernel).

MS-DOS

Weak layering:

Unix

Traditional kernel:

MS Windows NT 4.0

Micro kernel:

THE

A strictly layered system:

Virtual Machines

Lowest software level (between kernel and hardware) provides a virtual machine interface to multiple, independent kernels. IBM VM. Java VM.

1. Support for OS development alongside a production system.
2. Virtual user/monitor mode, real user/monitor mode.
3. How is a disk operation carried out?
4. Virtual Machine is a simulation:
   • Simulate one architecture with another.
   • Efficiency?
5. How are physical devices (a disk) ``virtualized?''
6. Java portability: ``Write once run anywhere.''
7. Java security: the ``sandbox.'' Access to local resources. Security or impediment to application development?
8. Java consistency: same look, feel between platforms?

Mailbox IPC

Resources owned by kernel, allocated to processes.

Messages kept in a queue.

Assume:

1. Only allocating process may execute receive.

2. Any process (including ``owner'') may send.

3. Variable-sized messages.

4. Infinite capacity.

Primitives:

1. int AllocateMB(void)

2. int Send(int mb, char* message)

3. int Receive(int mb, char* message)

4. int FreeMB(int mb)

Example: Process Synchronization

Consider:

Process1()
{
   ...
   S1;
   ...
}

Process2()
{
   ...
   S2;
   ...
}

Example: Tape Drive Allocation and Use

The situation:

Tape allocator process:

initialize();
while (1)
{
   Receive(Tamb, message);
   if (message is a request)

      if (there are enough tape drives)

         for each tape drive being allocated
         {
            fork a handler daemon;
            send daemon mb # in message to requesting process;
            update lists;
         }

      else

         send a rejection message;

   else if (message is a return)
   {
      update lists;
      send an ack message;
   }

   else

      ignore illegal messages;
}

Summary of user process actions:

1. Send request to tape allocator.

2. Receive message back giving mailbox(es) to use in communicating with tape drive(s).

3. Start sending/receiving with tape drive daemon(s).

4. Close tape drives.

5. Send message to tape allocator returning tape drive(s).