Layered vs monolithic OS structure

Answer: Yes. In terms of design, simplicity and maintenance, a layered structure is better than a monolithic one; the price is some loss of speed.

Idea of the layered structure

The OS is divided into a number of layers (levels). In the general model, layer 0 is the hardware and the highest layer is the user interface. Each layer uses only the services of the layers below it and provides services to the layer above.

Example: the THE operating system (Dijkstra)

 Layer 5: The operator
 Layer 4: User programs
 Layer 3: Input/output management (buffering)
 Layer 2: Operator-process (console) communication
 Layer 1: Memory and drum management
 Layer 0: Processor allocation and multiprogramming
          (process switching, semaphores)
 ------------------------------------------------
          Hardware

Layer 0 provides processes and semaphores, so layer 1 need not worry about CPU sharing. Layer 1 moves pages between memory and the drum, so layers above it need not care whether their pages are in memory. Layer 2 gives each process its own operator console, layer 3 gives abstract I/O devices instead of real ones, and layer 4 runs the user programs on top of all this.

Why layered is better

• Modularity and simplicity: each layer has a small, well-defined job.
• Easy debugging and verification: test the lowest layer first; once it works, assume it is correct while testing the next layer. An error is therefore located in the layer being tested.
• Information hiding: a layer need not know how lower layers are implemented, so a layer can be rewritten without disturbing the others.
• Easy maintenance and extension of the system.

Why monolithic is still used (limitations of layering)

• Careful layer definition is hard, because a layer can use only lower layers, so the order must be planned. For example, the backing-store driver must be below the memory manager (which uses it), but the driver also needs the CPU scheduler to block while waiting for I/O, and the scheduler may itself need the driver to swap process information, so the right order is not obvious.
• Lower efficiency: a request passes through many layers, each adding overhead and parameter passing, so system calls are slower.
• Too many layers may lead to redundancy.

Conclusion: for correctness and maintainability, layering wins. Practical systems (modern UNIX, Windows NT) combine a few layers with monolithic ideas as a compromise.