Operating System Types and Architectures

This chapter explores advanced operating system architectures, the mechanism of system calls that bridge user applications and the kernel, and the fundamental classifications of operating systems ranging from batch processors to multi-processing and real-time environments.

1. Advanced Kernel Architectures: Hybrid and Exokernels

While monolithic and microkernels form the foundation of OS design, modern production environments and specialized systems rely on more specialized architectures.

• Hybrid Kernels: These represent the most popular approach in modern mainstream operating systems (such as Windows and macOS variants). They combine performance advantages of monolithic kernels (direct driver execution speed) with the modularity and stability principles of microkernels.
• Exokernels: These kernels take a radically minimalist approach by bypassing traditional abstraction layers and granting untrusted user programs direct access to underlying hardware resources.
• Use Cases: Exokernels are heavily utilized in experimental research and specialized aerospace systems (such as NASA projects) where developers require fine-grained, bespoke control over hardware scheduling, storage allocation, and protection domains without OS intervention.

2. Core Mental Model: What is a System Call?

Real-Life Analogy

Think of a System Call like ordering food at a high-end restaurant or interacting with a secure government office.

• You (the User Application) are sitting at a table and cannot walk directly into the restaurant's kitchen (the Kernel Space) to cook your meal or grab raw ingredients from the refrigerator (the Hardware).
• Instead, you make a formal request through a standardized menu (System Call Interface).
• A specialized staff member (the CPU switching from User Mode to Kernel Mode) takes your request, executes it securely inside the restricted kitchen, and brings back the final output to your table.

User Application (User Mode)
   |
   | 1. Invokes API / System Call (e.g., open(), read())
   v
System Call Interface
   |
   | 2. CPU traps into Kernel Mode
   v
Operating System Kernel (Kernel Mode)
   |
   | 3. Interacts securely with underlying physical devices
   v
Underlying Hardware

Note: A system call serves as the strict programmatic interface between a user-space process and the operating system kernel. Whenever an application requires a privileged operation—such as writing to disk, allocating memory, or opening a network socket—it must issue a system call.

3. Categories of System Calls

To keep the system secure and organized, operating systems group system calls into distinct functional categories. Every operation executed on a computer routes through one of these standard system calls.

4. Introduction to Operating System Classifications

An Operating System functions as an intermediary layer bridging physical hardware and user applications. Depending on the workload constraints, hardware configurations, and interaction requirements, operating systems are classified into distinct structural categories.

The foundational breakdown of OS types covered in modern system design includes:

1. Batch Operating Systems
2. Multi-programming Operating Systems
3. Multi-tasking / Time-Shared Operating Systems
4. Multi-processing Operating Systems
5. Real-Time Operating Systems (RTOS)

5. Batch Operating Systems

In early computing paradigms, human-computer interaction was slow. Batch Operating Systems were designed to maximize CPU utilization by automating job execution without continuous human intervention.

Workflow Mechanics

• Job Collection: Users prepare jobs (punched cards or predefined script files containing data, programs, and control instructions) and submit them to an operator.
• Queueing: The OS groups similar jobs into batches and places them in an execution queue.
• Batch Monitor: A resident monitor program automatically loads the next job into memory from the queue once the preceding job terminates.
• Example: Early mainframe systems like IBM 360.

• Key Constraint: There is no direct user-to-CPU interaction while jobs execute. Computation runs strictly end-to-end based on predefined batch structures.

6. Multi-Programming Operating Systems

As memory capacities expanded, leaving the CPU idle while waiting for slow I/O operations (like reading from disk or printing) became inefficient. Multi-programming solves this by keeping multiple programs loaded in primary memory simultaneously.

• Memory Layout: Several processes reside in RAM concurrently.
• Execution Rule: When the currently running process pauses to wait for an I/O event (e.g., waiting for disk data), the operating system immediately switches the CPU to execute another resident process.
• Goal: Maximize CPU throughput and minimize idle processor cycles. However, multi-programming does not guarantee interactive responsiveness or rapid time-slicing; a process runs until it voluntarily blocks or finishes.

7. Multi-Tasking / Time-Shared Operating Systems

Multi-tasking (or Time-Sharing) is a logical extension of multi-programming designed specifically for interactive computing (e.g., modern Windows, macOS, and Linux desktop distributions).

• The Illusion of Parallelism: Instead of waiting for a process to block on I/O, the CPU allocates tiny time slices (called a Time Quantum, e.g., $10\text{ ms}$) to each active process in rapid rotation.
• Rapid Context Switching: The CPU switches back and forth between processes hundreds of times per second.
• User Experience: Because the switching frequency far exceeds human perceptual thresholds ($100\times$ per second), users experience a smooth illusion that multiple programs are executing simultaneously in parallel.

8. Multi-Processing Operating Systems

While multi-programming and multi-tasking share a single CPU core using scheduling algorithms, Multi-processing utilizes multiple physical CPU cores within a single computer system.

• True Parallelism: Multiple processes execute simultaneously on distinct physical processors or CPU cores (e.g., symmetric multiprocessing or SMP architectures running on Linux).
• Scalability: If a system contains 8 CPU cores, 8 distinct threads or processes can execute absolute machine instructions at the exact same nanosecond.
• Contrast Check:
  • Multi-tasking: One CPU rapidly switching among many tasks (Concurrency).
  • Multi-processing: Multiple CPUs executing distinct tasks at the exact same time (True Parallelism).

9. Tabular Comparison: Multi-programming vs. Multi-tasking vs. Multi-processing

10. Summary and Key Takeaways

• Hybrid and Exokernels: Hybrid kernels blend monolithic performance with microkernel modularity, whereas exokernels offer extreme, unmediated hardware access for specialized research and aerospace projects.
• System Calls as Interfaces: System calls act as the protected bridge allowing user-space applications to invoke privileged kernel operations securely.
• Structured Categories: System calls are systematically classified into Process Control, File Management, Device Management, Information Maintenance, and Communication groups.
• Batch OS Foundations: Batch operating systems queue pre-compiled jobs for sequential execution without interactive user input during computation.
• Maximizing Memory in Multi-programming: Multi-programming loads multiple jobs into RAM concurrently, switching the CPU away from processes stuck waiting for I/O.
• Time-Sharing Time Quanta: Multi-tasking relies on rapid time quantum slicing to create a seamless human illusion of true simultaneous execution.
• True Parallelism in Multi-processing: Multi-processing harnesses multiple physical CPU cores simultaneously to achieve genuine hardware-level parallel computation.