SanzSkuy at 02:56, 22 August 2026

2026-08-22T02:56:42Z

← Older revision		Revision as of 02:56, 22 August 2026
Line 1:		Line 1:
	~~Catatan dari '''CS:APP''' (''Computer Systems: A Programmer's Perspective'') §1.7.1 — tentang ''process'', abstraksi OS untuk program yang sedang berjalan.~~

	~~Lanjutan dari [[Operating System Mengelola Hardware]].~~

	__TOC__		__TOC__

SanzSkuy at 02:56, 22 August 2026

2026-08-22T02:56:23Z

← Older revision		Revision as of 02:56, 22 August 2026
Line 42:		Line 42:
	* '''Multi-core modern''' → beberapa program bisa jalan '''benar-benar simultan''', satu di tiap core.		* '''Multi-core modern''' → beberapa program bisa jalan '''benar-benar simultan''', satu di tiap core.

	{{~~Note~~\|Bedakan ''concurrent'' (selang-seling, bisa di satu CPU) dan ''parallel'' (benar-benar bersamaan, butuh lebih dari satu core). Diskusi multiprocessor dilanjut di §1.9.2.}}		{{Catatan\|Bedakan ''concurrent'' (selang-seling, bisa di satu CPU) dan ''parallel'' (benar-benar bersamaan, butuh lebih dari satu core). Diskusi multiprocessor dilanjut di §1.9.2.}}

	Mekanisme yang bikin selang-seling ini terjadi namanya '''context switching'''.		Mekanisme yang bikin selang-seling ini terjadi namanya '''context switching'''.

SanzSkuy: Created page with "Catatan dari '''CS:APP''' (''Computer Systems: A Programmer's Perspective'') §1.7.1 — tentang ''process'', abstraksi OS untuk program yang sedang berjalan. Lanjutan dari Operating System Mengelola Hardware. TOC == Ilusi yang dijual process == Waktu program kayak `hello` jalan di sistem modern, OS menyediakan '''ilusi bahwa program itu satu-satunya yang jalan di mesin'''. Spesifiknya, ada tiga ilusi yang dijual sekaligus: # Program seolah punya..."

2026-08-22T02:56:03Z

Created page with "Catatan dari '''CS:APP''' (''Computer Systems: A Programmer's Perspective'') §1.7.1 — tentang ''process'', abstraksi OS untuk program yang sedang berjalan. Lanjutan dari Operating System Mengelola Hardware. __TOC__ == Ilusi yang dijual process == Waktu program kayak <code>hello</code> jalan di sistem modern, OS menyediakan '''ilusi bahwa program itu satu-satunya yang jalan di mesin'''. Spesifiknya, ada tiga ilusi yang dijual sekaligus: # Program seolah punya..."

New page

Catatan dari '''CS:APP''' (''Computer Systems: A Programmer's Perspective'') §1.7.1 — tentang ''process'', abstraksi OS untuk program yang sedang berjalan.

Lanjutan dari [[Operating System Mengelola Hardware]].

__TOC__

== Ilusi yang dijual process ==

Waktu program kayak <code>hello</code> jalan di sistem modern, OS menyediakan '''ilusi bahwa program itu satu-satunya yang jalan di mesin'''. Spesifiknya, ada tiga ilusi yang dijual sekaligus:

# Program seolah punya '''akses eksklusif''' ke processor, main memory, dan I/O devices.
# Processor seolah mengeksekusi instruksi program itu '''satu per satu tanpa interupsi'''.
# Code dan data program itu seolah '''satu-satunya objek''' di memory sistem.

Ketiganya bohong. Tapi bohongnya konsisten dan rapi, jadi kita bisa nulis program tanpa mikirin ada 300 proses lain yang lagi rebutan CPU yang sama.

CS:APP nyebut ide ini sebagai salah satu gagasan '''paling penting dan paling sukses''' dalam ilmu komputer — dan itu bukan lebay.

== Definisi ==

'''Process''' adalah abstraksi operating system untuk sebuah ''program yang sedang berjalan''.

Bedakan baik-baik:

{| class="wikitable"
! Program !! Process
|-
| Entitas pasif — sekumpulan byte di disk || Entitas aktif — program yang lagi dieksekusi
|-
| Satu file bisa dijalankan berkali-kali || Tiap eksekusi = process terpisah dengan konteks sendiri
|}

== Concurrency ==

Beberapa process bisa jalan '''concurrently''' di sistem yang sama, dan masing-masing tetap merasa punya hardware sendirian.

Yang dimaksud ''concurrently'' di sini: '''instruksi dari satu process diselang-seling (''interleaved'') dengan instruksi process lain'''.

Di kebanyakan sistem, jumlah process yang mau jalan '''lebih banyak''' daripada jumlah CPU yang tersedia. Jadi:

* '''Sistem tradisional''' (single CPU) → cuma bisa eksekusi satu program pada satu waktu, tapi bisa ''tampak'' concurrent dengan cara CPU-nya gantian antar process.
* '''Multi-core modern''' → beberapa program bisa jalan '''benar-benar simultan''', satu di tiap core.

{{Note|Bedakan ''concurrent'' (selang-seling, bisa di satu CPU) dan ''parallel'' (benar-benar bersamaan, butuh lebih dari satu core). Diskusi multiprocessor dilanjut di §1.9.2.}}

Mekanisme yang bikin selang-seling ini terjadi namanya '''context switching'''.

== Context dan context switch ==

=== Apa itu context ===

OS melacak semua informasi state yang dibutuhkan sebuah process supaya bisa jalan. Kumpulan state ini disebut '''context''', isinya antara lain:

* nilai '''PC''' (program counter) saat ini
* isi '''register file'''
* isi '''main memory''' milik process itu

=== Mekanisme switch ===

Di sistem uniprocessor, pada satu titik waktu CPU cuma bisa mengeksekusi kode dari '''satu''' process. Waktu OS memutuskan untuk memindahkan kontrol dari process sekarang ke process baru, dia melakukan '''context switch''' dengan tiga langkah:

# '''Save''' — simpan context process yang sedang jalan
# '''Restore''' — pulihkan context process yang baru
# '''Transfer''' — serahkan kontrol ke process baru

Process yang baru itu lanjut '''persis dari titik terakhir dia berhenti'''. Dari sudut pandang si process, nggak ada yang terjadi — dia nggak sadar sempat "dibekukan" entah berapa lama.

=== Alur pada Figure 1.12 ===

<pre>
Time Process A Process B
| --------- ---------
| user code
| |
read --> +----> kernel code ---------------+ } context switch
| v
| user code
| |
disk +-------- kernel code <-----------+ } context switch
interrupt v
| user code (return from read)
v |
</pre>

Yang wajib diperhatiin dari diagram ini:

* '''Switch selalu lewat kernel code.''' Nggak pernah ada lompatan langsung dari user code A ke user code B. Polanya selalu: user code → kernel → user code process lain.
* '''Dua pemicu switch di gambar itu beda sifat:'''
** <code>read</code> → ''voluntary''. Process A sendiri yang manggil system call. Karena dia bakal nunggu disk (lambat banget dibanding CPU), OS mendingan kasih CPU ke B daripada nganggur.
** ''Disk interrupt'' → ''involuntary'', datang dari luar. Process B lagi jalan normal terus dipotong karena data yang ditunggu A udah siap.
* '''"Return from read" itu terjadi jauh setelah <code>read</code> dipanggil.''' Dari sisi A, satu pemanggilan fungsi. Dari sisi mesin, di antaranya ada seluruh eksekusi B.

== Skenario hello ==

Ada dua process concurrent dalam contoh ini: '''shell''' dan '''hello'''.

# Awalnya shell jalan sendirian, nunggu input di command line.
# Kita minta shell menjalankan <code>hello</code>.
# Shell memenuhi permintaan itu dengan memanggil fungsi khusus bernama '''system call''', yang menyerahkan kontrol ke OS.
# OS '''menyimpan context shell''', '''membuat process <code>hello</code> baru''' beserta context-nya, lalu menyerahkan kontrol ke process baru itu.
# Setelah <code>hello</code> selesai, OS '''memulihkan context shell''' dan mengembalikan kontrol ke situ.
# Shell balik nunggu input berikutnya.

== Kernel ==

Transisi dari satu process ke process lain diatur oleh '''kernel''' — bagian dari kode operating system yang '''selalu resident di memory'''.

Waktu program aplikasi butuh tindakan dari OS (misalnya baca atau tulis file), dia mengeksekusi instruksi '''system call''' khusus yang mentransfer kontrol ke kernel. Kernel melakukan operasi yang diminta, lalu balik lagi ke program aplikasi.

{{Warning|'''Kernel bukan process yang terpisah.''' Ini miskonsepsi paling umum di bab ini. Kernel adalah kumpulan '''kode dan struktur data''' yang dipakai sistem untuk mengelola semua process. Jangan cari "process kernel" di output <code>ps</code> — konsepnya memang bukan itu.}}

== Kerja sama hardware dan software ==

Mengimplementasikan abstraksi process butuh '''kerja sama erat antara hardware level rendah dan software operating system'''. OS sendiri nggak bisa; dia butuh dukungan hardware seperti:

* privilege level (user mode / kernel mode) untuk proteksi
* timer interrupt supaya OS bisa merebut kembali CPU dari process yang nggak mau berhenti
* MMU untuk isolasi ruang alamat

Detail cara kerjanya, dan cara aplikasi membuat serta mengendalikan process-nya sendiri, dibahas di '''Bab 8'''.

== Catatan untuk kerja systems ==

Beberapa implikasi praktis yang nyambung ke performance:

* '''"Context termasuk isi main memory" itu benar secara konseptual, tapi implementasinya nggak menyalin RAM.''' Yang benar-benar diganti waktu switch cuma pointer ke page table (di x86: register CR3). Kalau context switch beneran nyalin seluruh memory, sistem modern nggak akan pernah bisa jalan.
* '''Biaya context switch bukan cuma save/restore register.''' Yang sering lebih mahal adalah efek tidak langsungnya: cache jadi dingin, TLB ke-flush, branch predictor kehilangan sejarahnya. Direct cost bisa ratusan nanodetik, indirect cost bisa jauh lebih besar.
* '''Ini alasan CPU pinning penting di HPC.''' Kalau thread dibiarkan pindah-pindah core, dia kehilangan cache lokalitas dan bisa nyebrang NUMA node. Makanya ada <code>taskset</code>, <code>numactl</code>, atau <code>OMP_PROC_BIND</code>.
* '''Voluntary vs involuntary switch bisa diukur.''' Di Linux lihat <code>/proc/[pid]/status</code> pada baris <code>voluntary_ctxt_switches</code> dan <code>nonvoluntary_ctxt_switches</code>, atau pakai <code>perf stat</code>. Rasio yang aneh sering jadi petunjuk masalah: involuntary tinggi = rebutan CPU, voluntary tinggi = banyak nunggu I/O atau lock.
* '''Async I/O ada supaya switch-nya bisa dihindari.''' Pola <code>read</code> yang blocking di Figure 1.12 itu persis masalah yang mau diselesaikan <code>epoll</code>, <code>io_uring</code>, dan model async lainnya — satu thread bisa ngurus banyak operasi I/O tanpa harus di-switch tiap kali nunggu.

== Istilah kunci ==

; Process
: Abstraksi OS untuk sebuah program yang sedang berjalan.
; Concurrent
: Instruksi beberapa process saling diselang-seling (belum tentu benar-benar bersamaan).
; Context
: Seluruh state yang dibutuhkan process untuk jalan — PC, register file, isi memory.
; Context switch
: Mekanisme menyimpan context process lama, memulihkan context process baru, lalu menyerahkan kontrol.
; System call
: Instruksi khusus yang menyerahkan kontrol dari aplikasi ke kernel.
; Kernel
: Bagian kode OS yang selalu resident di memory; kumpulan kode dan struktur data untuk mengelola semua process. Bukan sebuah process.

== Lihat juga ==

* [[OS Manages Hardware]]
* [[Virtual Memory]]
* [[System Call]]
* [[Thread]]
* [[CS:APP]]

[[Category:Computer Systems]]
[[Category:Operating System]]
[[Category:CS:APP]]

Process - Revision history

SanzSkuy at 02:56, 22 August 2026

SanzSkuy at 02:56, 22 August 2026