Operating Systems Structures

The structure of the OS depends mainly on how the various standard components of the operating system are
interconnected and merge into the kernel.

What is a System Structure for an Operating System?

A system structure for an operating system is like the blueprint of how an OS is organized and how its different parts
interact with each other. Because operating systems have complex structures, we want a structure that is easy to
understand so that we can adapt an operating system to meet our specific needs. ( Similar to how we break down larger
problems into smaller, more manageable subproblems, building an operating system in pieces is simpler.) The operating
system is a component of every segment

Types of Operating Systems Structures

Depending on this, we have the following structures in the operating system:

• Simple Structure

• Monolithic Structure

• Micro-Kernel Structure

• Layered Structure

• Modular Structure

• Virtual Machines

1. Simple Structure

It is the most straightforward operating system structure, but it lacks definition and is only appropriate for usage with
tiny and restricted systems. Since the interfaces and degrees of functionality in this structure are clearly defined,
programs are able to access I/O routines, which may result in unauthorized access to I/O procedures.

This organizational structure is used by the MS-DOS operating system:

o There are four layers that make up the MS-DOS operating system, and
each has its own set of features.

o These layers include ROM BIOS device drivers, MS-DOS device drivers,
application programs, and system programs.

o The MS-DOS operating system benefits from layering because each

level can be defined independently and, when necessary, can interact
with one another.

o If the system is built in layers, it will be simpler to design, manage, and

update. Because of this, simple structures can be used to build
constrained systems that are less complex.

o When a user program fails, the operating system as whole crashes.

o Because MS-DOS systems have a low level of abstraction, programs and I/O procedures are visible to end users,
giving them the potential for unwanted access.

Advantages of Simple Structure:

o It is easy to develop as it contains only a few interfaces and levels.

o It executes faster because there are fewer layers between the hardware and applications.

o Direct access to hardware provides faster operations.

o Minimal consumption of system resources as the structure is very simple.

 o Light in weight hence suitable for small or even embedded systems.

Disadvantages of Simple Structure:

o As these components are not distinctly separated, making any change or upgrade in the system is considerably
harder to achieve.

o All things are connected, and therefore, debugging is quite hectic; finding the error is very hard.

o Due to the lack of data abstraction, a security vulnerability is a strong possibility.

o It does not scale well to larger, more complex systems. Adding new features is particularly challenging in this
architecture.

o One failure in one part might bring down the whole system.

2. Monolithic Structure

The Monolithic operating System in which

the kernel acts as a manager by managing all things
like file management, memory management,
device management, and operational processes of
the Operating System.

The kernel is the heart of a computer operating system

(OS). Kernel delivers basic services to all other elements
of the System. It serves as the primary interface between
the Operating System and the hardware.

In monolithic systems, kernels can directly access all the

resources of the operating System like physical
hardware, exp Keyboard, Mouse etc.

The monolithic kernel is another name for the monolithic operating system. Batch processing and time-sharing maximize
the usability of a processor by multiprogramming. The monolithic kernel functions as a virtual machine by working on
top of the Operating System and controlling all hardware components. This is an outdated operating system that was
used in banks to accomplish minor activities such as batch processing and time-sharing, which enables many people at
various terminals to access the Operating System.

Advantages of Monolithic Structure:

o Because everything is packed into one big kernel, there is no need for multi-layer complexities. Hence, the
design and bringing into practice of such a system is relatively easy.

o As long as all the components run in the same memory space, there is no need to have inter-process
communication or to perform context switching between layers; thus, execution is faster.

o Direct access to hardware and little additional-abstraction overhead result in high performance.

o Development can thus be easier as developers have to deal with one codebase only, and no interactions among
various layers or modules need to be considered.

Disadvantages of Monolithic Structure:

o Fault in any single component has the potential to bring down the whole system since there is no isolation
between different parts.

o This can be a hard and unsafe task, as changes in one part of the system may accidentally filter out into another
part.

o Since the components are more interdependent, debugging is also more complex and always requires heavy
testing and testing-related activities.
 o This is an issue where scaling up or adjusting to the latest trends in a system involves significant changes in the
kernel.

3. LAYERED STRUCTURE

An OS can be broken into pieces and retain much more control over the
system. In this structure, the OS is broken into a number of layers (levels).
The bottom layer (layer 0) is the hardware, and the topmost layer (layer
N) is the user interface. These layers are so designed that each layer uses
the functions of the lower-level layers. This simplifies the debugging
process, if lower-level layers are debugged and an error occurs during
debugging, then the error must be on that layer only, as the lower-level
layers have already been debugged. The main disadvantage of this
structure is that at each layer, the data needs to be modified and passed
on which adds overhead to the system. Moreover, careful planning of the
layers is necessary, as a layer can use only lower-level layers. UNIX is an
example of this structure.

The following are some of the key characteristics of a layered operating

system structure:

• Each layer is responsible for a specific set of tasks. This makes it

easier to understand, develop, and maintain the operating system.

• Layers are typically arranged in a hierarchy. This means that each layer can only use the services provided by the
layers below it.

• Layers are independent of each other. This means that a change to one layer should not affect the other layers.

Advantages of Layered Structure:

o Development, maintenance, and understanding are much easier, as every layer is assigned a specific role.

o It can isolate problems in individual layers because testing and debugging would be less demanding.

o Sensitive operations can be confined to specific layers; thus, unauthorized access can be minimized to such
layers because the concerns have been clearly separated.

o Modifying or updating one layer will not affect other independent layers directly; thus, upgrading or fixing could
be done more easily.

o With layers, basic operations can be entrusted to lower layers, and hence, the layers above need not be
concerned with the minute details, thereby reducing the complexity of the overall management.

Disadvantages of Layered Structure:

o The layered approach adds delays due to the fact that data and commands must pass through several layers,
thus slowing down the system in general.

o Designing a properly working layered structure requires forethought and iron discipline for proper interaction
between different layers.

o Layers are generally dependent on lower layers; thus skipping layers and directly accessing the lower-level
functionalities becomes harder, hence reducing flexibility in many systems.

o System performance optimization becomes challenging due to the extra abstractions introduced by the layers,
which harden the tuning of individual parts of the system to make them run more effectively.

o Unless the lower-layer design is lousy or inefficient, the whole system will suffer since the higher layer depends
on them for functionality.