[OS Concepts] 01. What is an Operating System

What is an Operating System

An operating system (OS) is software that manages computer hardware and provides an execution environment for application programs. It acts as an intermediary between the user and the hardware.

Four Components of a Computer System

A computer system consists of four major components.

Hardware: Provides basic resources such as CPU, memory, and I/O devices
Operating System: Controls hardware and coordinates resources among application programs
Application Programs: Word processors, compilers, web browsers, etc., that solve user problems
Users: People, other machines, or other computers

Roles of the Operating System

An operating system can be defined from two perspectives.

Resource Allocator: Manager of all resources including CPU time, memory space, storage devices, and I/O devices
Control Program: Controls program execution to prevent errors and improper use

In a more universal definition, the operating system is the one program running at all times on the computer, called the kernel.

Computer System Organization

Interrupts

An interrupt is a mechanism for hardware to notify the CPU that an event has occurred. When an I/O device completes an operation, it sends a signal to the CPU through an interrupt.

[Interrupt Handling Process]

1. I/O device completes operation
2. Device controller raises interrupt signal
         |
         v
3. CPU suspends current operation
4. Saves current state (PC, registers) to stack
         |
         v
5. Looks up ISR address through interrupt vector
6. Executes ISR (Interrupt Service Routine)
         |
         v
7. Restores saved state
8. Resumes interrupted operation

The types of interrupts are as follows.

Hardware Interrupts: Triggered by I/O devices, timers, etc.
Software Interrupts (Traps): Triggered by errors (division by zero) or system calls

// Interrupt vector table conceptual diagram
// Stores ISR addresses corresponding to each interrupt number

typedef void (*isr_handler_t)(void);

isr_handler_t interrupt_vector_table[256];

// Interrupt number 0: Division by zero exception
// Interrupt number 1: Debug exception
// Interrupt number 14: Page fault
// ...
// Interrupt numbers 32~255: User-defined (I/O devices, etc.)

void handle_interrupt(int interrupt_number) {
    // Find and execute handler from interrupt vector
    isr_handler_t handler = interrupt_vector_table[interrupt_number];
    if (handler != NULL) {
        handler();
    }
}

Storage Device Hierarchy

Storage devices form a hierarchy based on speed, cost, and volatility.

[Storage Device Hierarchy]

      Fast / Expensive / Small
        +-----------+
        | Registers  |    < 1ns
        +-----------+
        | Cache (L1) |    ~1ns
        +-----------+
        | Cache (L2) |    ~4ns
        +-----------+
        | Cache (L3) |    ~10ns
        +-----------+
        | Main Memory|    ~100ns     (Volatile)
        +-----------+
        |   SSD     |    ~100us     (Non-volatile)
        +-----------+
        |   HDD     |    ~10ms
        +-----------+
      Slow / Cheap / Large

Caching is a technique that temporarily copies data from slower storage to faster storage. When the same data is accessed again, it is read from the faster storage, improving performance.

I/O Structure

I/O operations are performed through interactions between the CPU and device controllers.

Programmed I/O: CPU directly transfers data byte by byte (inefficient)
Interrupt-driven I/O: Device notifies CPU via interrupt when ready
DMA (Direct Memory Access): For bulk data transfers, device controller accesses memory directly without CPU intervention

[DMA Operation Process]

CPU                     DMA Controller          Memory
 |                           |                   |
 |-- DMA transfer request -->|                   |
 |   (source, dest, size)    |                   |
 |                           |--- Data transfer ->|
 |                           |--- Data transfer ->|
 |                           |--- Data transfer ->|
 |<-- Transfer complete int -|                   |
 |                           |                   |

Computer System Architecture

Multiprocessor Systems

Most modern computers are multiprocessor systems. The advantages are as follows.

Increased Throughput: N processors improve processing speed (but not by N times)
Economy of Scale: More cost-effective than multiple single-processor systems
Increased Reliability: If one fails, the overall system continues to operate (graceful degradation)

There are two types of multiprocessor systems.

Asymmetric Multiprocessing (AMP): One master processor controls the system, and the rest follow instructions
Symmetric Multiprocessing (SMP): Each processor performs OS functions on an equal basis

[SMP Architecture]

  CPU 0        CPU 1        CPU 2
 [Registers]  [Registers]  [Registers]
 [Cache]      [Cache]      [Cache]
    |             |             |
    +------+------+------+------+
           |             |
      [Shared Memory]  [I/O System]

Multicore Systems

A multicore processor contains multiple cores on a single chip. Since they communicate within the same chip, it is faster than communication between separate processors and consumes less power.

[Multicore Processor Structure]

+--------------------------------------+
|           Single CPU Chip            |
|  +--------+  +--------+  +--------+ |
|  | Core 0  |  | Core 1  |  | Core 2  | |
|  |[L1Cache]|  |[L1Cache]|  |[L1Cache]| |
|  +--------+  +--------+  +--------+ |
|         +----------+                  |
|         | L2 Cache  |                  |
|         +----------+                  |
+--------------------------------------+
              |
         [Main Memory]

NUMA (Non-Uniform Memory Access)

When the number of CPUs increases, the system bus becomes a bottleneck. NUMA solves this problem by providing each CPU with its own local memory.

[NUMA Architecture]

+------------------+    Interconnect    +------------------+
|     Node 0       |<================>|     Node 1       |
| CPU 0  CPU 1    |                   | CPU 2  CPU 3    |
| [Local Memory 0] |                   | [Local Memory 1] |
+------------------+                   +------------------+

Local memory access: Fast (~100ns)
Remote memory access: Slow (~300ns)

Operating System Operations

Dual-Mode Operation

The OS must protect the system from erroneous user program behavior. To this end, it provides two execution modes.

User Mode: Application program execution. Privileged instructions cannot be executed
Kernel Mode: OS code execution. All instructions can be executed

[Mode Transition Process]

User Mode                            Kernel Mode
    |                                   |
    |-- System call invocation -------->|
    |   (trap occurs, mode bit 0)       |
    |                                   |-- System call processing
    |                                   |
    |<-- System call return ------------|
    |   (mode bit restored to 1)        |
    |                                   |

// System call example: File read
// Calling read() from a user program

#include <unistd.h>
#include <fcntl.h>
#include <stdio.h>

int main() {
    char buffer[1024];

    // open() transitions to kernel mode via system call
    int fd = open("data.txt", O_RDONLY);

    // read() is also a system call - kernel performs I/O
    ssize_t bytes = read(fd, buffer, sizeof(buffer));

    printf("Bytes read: %zd\n", bytes);
    close(fd);
    return 0;
}

Timer

A timer prevents a program from monopolizing the CPU. After a set period, it generates an interrupt to return control to the OS.

Fixed timer: Generates interrupts at regular intervals
Variable timer: Implemented with a fixed clock + counter. Generates an interrupt when the counter reaches 0

Resource Management

Process Management

A process is a program in execution. The OS performs the following tasks.

Process creation and deletion
Process suspension and resumption
Providing process synchronization mechanisms
Providing inter-process communication (IPC) mechanisms
Providing deadlock handling mechanisms

Memory Management

Main memory is the only large storage directly accessible by the CPU. The OS manages the following.

Tracks which parts of memory are in use and by whom
Decides which processes and data to load into and remove from memory
Allocates and deallocates memory space as needed

Storage Management

The OS abstracts the physical characteristics of storage devices to provide the logical concept of files.

File System Management: File creation/deletion, directory management, access control
Mass Storage Management: Disk scheduling, free space management, storage allocation
Caching: Keeping frequently accessed data in faster storage

I/O Subsystem

The OS I/O subsystem hides the differences between hardware devices.

Buffering: Temporarily stores data during transfer
Caching: Maintains copies of frequently used data
Spooling: Stores output for devices like printers in a queue

Protection and Security

Protection: Mechanisms for controlling process/user access to resources defined by the OS
Security: Defense against external or internal attacks. Includes authentication, authorization, auditing, etc.

Each user is assigned a unique ID (UID), and group-level access control is also possible through group IDs (GID). Privilege escalation is a mechanism for temporarily gaining higher privileges, implemented in Unix through the setuid bit.

Summary

[Operating System Key Concepts Summary]

+------------------------------------------+
|          Application Programs             |
+------------------------------------------+
|       Operating System (Kernel)           |
|  +------+ +--------+ +--------+ +------+ |
|  |Process| |Memory  | |File    | |I/O   | |
|  |Mgmt   | |Mgmt    | |System  | |Mgmt  | |
|  +------+ +--------+ +--------+ +------+ |
+------------------------------------------+
|              Hardware                     |
|  CPU / Memory / Disk / I/O Devices       |
+------------------------------------------+

The operating system is essential software that manages resources between hardware and users, provides a program execution environment, and protects the system. It leverages hardware support such as dual-mode operation, interrupts, and timers to ensure safe and efficient system operation.