OS Manages Hardware

Catatan dari CS:APP (Computer Systems: A Programmer's Perspective) §1.7 — tentang bagaimana operating system menjadi perantara tunggal antara aplikasi dan hardware.

Kenapa bab ini penting

Balik ke contoh hello. Waktu shell nge-load dan menjalankan program hello, terus hello nge-print pesannya ke layar — nggak ada satu pun dari dua program itu yang nyentuh keyboard, display, disk, atau main memory secara langsung. Semuanya numpang layanan yang disediakan operating system.

Ini bukan detail sepele. Ini fondasi kenapa kita bisa nulis printf("hello\n") tanpa perlu tahu merek monitor atau protokol bus yang dipakai.

Layered view

Model mentalnya: OS itu lapisan software yang disisipkan di antara aplikasi dan hardware.

+-----------------------------------------+
|         Application programs            |  <- Software
+-----------------------------------------+
|          Operating system               |  <- Software
+-----------+--------------+--------------+
| Processor | Main memory  | I/O devices  |  <- Hardware
+-----------+--------------+--------------+

Aturannya keras: semua usaha aplikasi buat memanipulasi hardware harus lewat OS. Nggak ada jalan tikus. Kalau ada program yang mau nulis ke disk, dia harus minta ke OS.

Konsekuensi praktisnya: batas antara aplikasi dan OS itu adalah system call interface. Setiap kali kode kita nyebrang garis itu, ada biaya (mode switch), dan itu jadi salah satu sumber overhead yang paling sering muncul di profiling.

Dua tujuan utama OS

Proteksi — melindungi hardware dari penyalahgunaan

Aplikasi yang runaway (bug, infinite loop, pointer liar) nggak boleh:

• nimpa memory milik proses lain
• monopoli CPU selamanya
• ngerusak state device

Mekanismenya nanti: privilege level (user mode vs kernel mode), MMU + page table buat isolasi memory, timer interrupt buat preemption.

Abstraksi — menyediakan mekanisme yang sederhana dan seragam

Hardware level rendah itu bentuknya beda-beda dan sering liar banget. Register controller SSD beda total sama register UART, beda lagi sama NIC. Kalau tiap aplikasi harus tahu detail tiap device, nulis program jadi mimpi buruk dan nggak portable.

OS nyediain satu antarmuka seragam supaya aplikasi cukup belajar satu cara.

Tiga abstraksi fundamental

OS mencapai dua tujuan di atas lewat tiga abstraksi yang saling bertumpuk:

+------------------------------------ Processes ----------+
|              +-------------------- Virtual memory ------+|
|              |                 +------ Files ----------+||
|  +-----------+-+---------------+--+--------------------+||
|  |  Processor  |   Main memory    |    I/O devices     |||
|  +-------------+------------------+--------------------+||
+---------------------------------------------------------+

Perhatiin cakupan tiap abstraksi — ini bagian yang sering ketuker:

Abstraksi	Hardware yang diabstraksikan
Files	I/O devices
Virtual memory	Main memory + disk I/O devices
Processes	Processor + main memory + I/O devices

Files — abstraksi untuk I/O devices

Semua device dibungkus jadi "urutan byte". Disk, keyboard, terminal, socket jaringan — semuanya bisa dibuka, dibaca, ditulis, ditutup lewat API yang sama. Ini filosofi "everything is a file" yang khas Unix.

Efeknya: program yang nulis ke file bisa di-pipe ke program lain tanpa modifikasi apa pun.

Virtual memory — abstraksi untuk main memory + disk

Tiap proses seolah-olah punya memory sendiri yang utuh dan kontinu, mulai dari alamat 0 sampai batas atas ruang alamat. Padahal fisiknya memory itu dibagi-bagi dan sebagian bisa lagi "nginep" di disk.

Kenapa disk ikut masuk? Karena isi memory bisa di-page out ke disk saat RAM sesak. Jadi virtual memory sebenarnya adalah abstraksi gabungan dari dua tingkat hierarki penyimpanan sekaligus.

Ini juga yang bikin proteksi jadi mungkin: kalau dua proses pakai alamat 0x400000, itu merujuk ke halaman fisik yang beda.

Processes — abstraksi untuk seluruh mesin

Proses adalah ilusi bahwa program kita satu-satunya yang jalan di mesin ini, dengan CPU-nya sendiri, memory-nya sendiri, dan device-nya sendiri.

Padahal aslinya puluhan sampai ratusan proses gantian pakai CPU yang jumlahnya jauh lebih sedikit. OS ngelakuin context switch — nyimpen state satu proses, restore state proses lain — cukup cepat sampai ilusinya nggak ketahuan.

Jadi processes itu abstraksi paling "atas": dia membungkus processor, main memory, dan I/O devices sekaligus.

Cara ngingetnya

Tiga abstraksi itu tersusun kayak boneka matryoshka, makin ke atas makin banyak hardware yang dibungkus:

1. Files → paling sempit, cuma I/O
2. Virtual memory → nambah main memory ke dalamnya
3. Processes → nambah processor, jadi lengkap

Dan dua tujuan (proteksi + antarmuka seragam) itu dicapai lewat tiga abstraksi ini, bukan hal yang terpisah.

Catatan untuk kerja systems

Beberapa hal yang nyambung ke topik performance:

• System call itu nggak gratis. Karena semua akses hardware wajib lewat OS, jalur kritis yang sering nge-hit syscall bakal kena overhead mode switch. Ini alasan kenapa ada teknik kayak batching I/O, io_uring, atau kernel bypass (DPDK, RDMA) di sistem yang butuh throughput tinggi.
• Virtual memory bukan cuma soal kapasitas. Page fault, TLB miss, dan NUMA placement semuanya lahir dari abstraksi ini. Program yang secara aritmetika identik bisa beda performanya berkali-kali lipat cuma gara-gara pola akses memory-nya beda.
• Context switch punya harga. Selain nyimpen register, cache dan TLB ikut "dingin" setelah switch. Ini salah satu alasan kenapa di HPC orang sering nge-pin thread ke core tertentu.

Istilah kunci

Operating system

Lapisan software antara aplikasi dan hardware.

Abstraction

Antarmuka sederhana yang menyembunyikan kompleksitas di bawahnya.

Process

Abstraksi untuk processor, main memory, dan I/O devices.

Virtual memory

Abstraksi untuk main memory dan disk I/O devices.

File

Abstraksi untuk I/O devices, dilihat sebagai urutan byte.

Context switch

Proses menyimpan dan memulihkan state saat CPU berpindah proses.

Lihat juga

• Process
• Threads
• Virtual Memory
• System Call
• Context Switch
• CS:APP