Bab 3: Proses — Sistem Operasi

Mata Kuliah Sistem Operasi · 3 SKS

Bab 3: Proses

Konsep Proses, Penjadwalan Proses, Operasi pada Proses, dan Komunikasi Antarproses (IPC)

Aditya Wikan Mahastama, S.Kom., M.Cs.

Program Studi Informatika · Universitas Kristen Duta Wacana

Berbasis: Silberschatz, Galvin, Gagne — Operating System Concepts, 10th Ed. (Ch. 3), dengan pemutakhiran materi

Capaian Pembelajaran

Setelah sesi ini, mahasiswa mampu

Konsep & Struktur

Menjelaskan komponen proses, status proses, dan isi Process Control Block (PCB)

Siklus Hidup Proses

Menjelaskan pembuatan dan terminasi proses melalui fork(), exec(), wait(), exit()

Komunikasi Antarproses

Membandingkan shared memory dan message passing, serta merancang solusi producer-consumer

Client-Server & Modern

Menjelaskan socket, RPC, serta konsep modern seperti container dan namespace

Bab 3 · Proses — 2 / 34

Garis Besar Materi (150 menit)

01

Konsep proses, proses dalam memori, dan status proses

02

Process Control Block (PCB) dan representasi proses di Linux

03

Penjadwalan proses, antrian, dan context switch

04

Operasi pada proses: pembuatan (fork/exec) dan terminasi

05

Komunikasi antarproses (IPC): shared memory & message passing

06

Studi kasus producer-consumer dan race condition

07

Komunikasi client-server: socket dan RPC

08

Pemutakhiran: container, namespace, dan IPC modern

Bab 3 · Proses — 3 / 34

Apa itu Proses?

Definisi

Proses adalah sebuah program yang sedang dieksekusi. Eksekusinya berjalan secara sekuensial — tidak ada eksekusi paralel pada satu proses tunggal.

Program bersifat pasif (file di disk), sedangkan proses bersifat aktif (dimuat ke memori dan dieksekusi CPU).

Lima komponen proses

Text section

Kode program

Program counter

Aktivitas berjalan & register

Stack

Parameter, alamat kembali, variabel lokal

Data section

Variabel global

Heap

Memori alokasi dinamis saat runtime

Bab 3 · Proses — 4 / 34

Proses dalam Memori

Stack

tumbuh ↓ / ↑ sesuai kebutuhan

Heap

Data

Text

alamat tinggi

alamat rendah

Text — kode program, tetap (read-only), berada di alamat rendah

Data — variabel global, ukuran tetap saat dimuat

Heap — alokasi dinamis (malloc/new), tumbuh ke alamat tinggi

Stack — frame fungsi, tumbuh ke alamat rendah saat pemanggilan fungsi

Ruang kosong antara heap dan stack mencegah keduanya bertumpukan (overflow)

Bab 3 · Proses — 5 / 34

Status Proses

Selama eksekusinya, proses berpindah-pindah di antara lima status berikut

New

Proses baru sedang dibuat

Ready

Menunggu dialokasikan ke prosesor

Running

Instruksi sedang dieksekusi CPU

Waiting

Menunggu suatu peristiwa terjadi (misal I/O)

Terminated

Eksekusi proses telah selesai

Bab 3 · Proses — 6 / 34

Diagram Transisi Status Proses

new

ready

running

terminated

waiting

admitted

scheduler dispatch

interrupt

exit

I/O atau menunggu event

I/O atau event selesai

Bab 3 · Proses — 7 / 34

Process Control Block (PCB)

Juga disebut task control block — menyimpan seluruh informasi terkait satu proses

Status proses

Nomor proses (PID)

Program counter

Register CPU

Batas memori

Daftar berkas terbuka

Informasi penjadwalan CPU — prioritas, pointer antrian penjadwalan

Informasi manajemen memori — memori yang dialokasikan ke proses

Informasi akuntansi — waktu CPU terpakai, waktu berjalan, batas waktu

Informasi status I/O — perangkat I/O yang dialokasikan ke proses

Bab 3 · Proses — 8 / 34

Sekilas — akan dibahas lengkap di Bab 4

Dari Satu Alur ke Banyak Alur: Thread

Selama ini

Satu proses memiliki satu program counter — hanya satu alur eksekusi (single thread of execution)

Gagasan thread

Satu proses memiliki beberapa program counter — beberapa lokasi kode dapat berjalan sekaligus (multiple threads of control)

Konsekuensi pada PCB

PCB harus menyimpan detail setiap thread, termasuk beberapa program counter sekaligus

Bab 3 · Proses — 9 / 34

Representasi Proses di Linux

Setiap proses direpresentasikan oleh struktur C task_struct

pid_t pid;

// process identifier

long state;

// state of the process

unsigned int time_slice;

// scheduling information

struct task_struct *parent;

// this process's parent

struct list_head children;

// this process's children

struct files_struct *files;

// list of open files

struct mm_struct *mm;

// address space of this process

Setiap task_struct terhubung ke induk (parent) dan anak (children) — membentuk struktur pohon proses

Semua task_struct tersimpan dalam linked list di kernel

Pointer current selalu menunjuk task_struct yang sedang dieksekusi CPU

Bab 3 · Proses — 10 / 34

Penjadwalan Proses

Process scheduler

Memilih proses mana yang akan dijalankan berikutnya pada suatu core CPU

Tujuan: memaksimalkan pemakaian CPU dan menukar proses secepat mungkin ke CPU

Ready queue

Kumpulan proses di memori utama yang siap dan menunggu eksekusi

Wait queue

Kumpulan proses yang menunggu suatu peristiwa (misalnya operasi I/O)

Migrasi

Proses berpindah-pindah di antara berbagai antrian sepanjang siklus hidupnya

Bab 3 · Proses — 11 / 34

Antrian Ready dan Wait: Linked List PCB

Ready Queue

head

tail

PCB 7

registers …

PCB 2

registers …

tail menunjuk kembali ke head — antrian melingkar

Wait Queue

head

tail

PCB 3

PCB 14

PCB 6

Bab 3 · Proses — 12 / 34

Context Switch

Terjadi saat CPU berpindah dari satu proses ke proses lain. Sistem harus menyimpan status proses lama ke PCB-nya, lalu memuat status proses baru dari PCB-nya.

Proses P0

executing → idle

interrupt / system call

simpan status → PCB0

… overhead murni …

muat status ← PCB1

lanjutkan proses P1

Proses P1

idle → executing

Waktu context switch adalah overhead murni — tidak ada pekerjaan berguna yang dilakukan selama perpindahan

Semakin kompleks OS dan PCB, semakin lama context switch berlangsung

Bab 3 · Proses — 13 / 34

Multitasking pada Sistem Mobile

iOS

Karena keterbatasan layar dan antarmuka, hanya ada satu foreground process yang dikendalikan pengguna

Proses lain berjalan sebagai background process dengan batasan: tugas singkat, menerima notifikasi, atau tugas khusus jangka panjang (contoh: pemutaran audio)

Android

Menjalankan proses foreground dan background dengan batasan yang lebih longgar

Proses background menggunakan service untuk menjalankan tugas — service tetap berjalan walau proses induk disuspend, tanpa antarmuka pengguna, dan hemat memori

Bab 3 · Proses — 14 / 34

Bagian Baru

Operasi pada Proses

Pembuatan proses (process creation)

Terminasi proses (process termination)

Bab 3 · Proses — 15 / 34

Pembuatan Proses

Proses parent membuat proses children, yang pada gilirannya dapat membuat proses lain — membentuk sebuah pohon proses. Proses diidentifikasi melalui process identifier (PID).

Opsi berbagi sumber daya

Parent dan child berbagi semua sumber daya

Child berbagi sebagian sumber daya milik parent

Parent dan child tidak berbagi sumber daya sama sekali

Opsi eksekusi

Parent dan child berjalan bersamaan (concurrently)

Parent menunggu (wait) sampai child selesai

Ruang alamat (address space)

Child dapat menduplikasi parent, atau memuat program baru

Bab 3 · Proses — 16 / 34

Contoh UNIX: fork(), exec(), wait()

#include <sys/types.h>

#include <unistd.h>

int main() {

  pid_t pid;

  pid = fork();

  if (pid < 0) {

    // fork gagal

  } else if (pid == 0) {

    execlp("/bin/ls","ls",NULL);

  } else {

    wait(NULL);

    printf("Child Complete");

}

}

fork()

Membuat proses baru (child) yang identik dengan parent

exec()

Menggantikan ruang memori proses dengan program baru

wait()

Parent menunggu hingga child selesai (terminate)

pid == 0 menandakan kode child; pid > 0 menandakan kode parent

Bab 3 · Proses — 17 / 34

Pohon Proses pada Linux

systemd

pid = 1

logind

pid = 8415

python

pid = 2808

sshd

pid = 3028

bash

pid = 8416

sshd

pid = 3610

ps

vim

tcsh

Bab 3 · Proses — 18 / 34

Terminasi Proses

exit()

Proses meminta OS menghapusnya setelah instruksi terakhir; status dikembalikan ke parent melalui wait(); sumber daya didealokasi

abort()

Parent menghentikan child: child melampaui sumber daya, tugasnya tidak lagi diperlukan, atau parent sendiri berakhir

Cascading termination

Bila sebuah proses berakhir, seluruh anak dan cucunya juga diterminasi oleh OS

pid = wait(&status);

Zombie process

Proses child sudah berakhir tetapi parent belum memanggil wait()

Orphan process

Proses parent berakhir tanpa memanggil wait() terhadap child-nya

Bab 3 · Proses — 19 / 34

Hierarki Kepentingan Proses Android

OS mobile sering perlu menghentikan proses untuk memulihkan sumber daya (memori). Android memulai dari yang paling tidak penting.

Foreground process

Paling penting — sedang berinteraksi dengan pengguna

Visible process

Terlihat pengguna namun tidak difokuskan

Service process

Menjalankan layanan latar belakang

Background process

Tidak terlihat, tidak sedang digunakan

Empty process

Paling tidak penting — pertama kali diterminasi

Bab 3 · Proses — 20 / 34

Studi Kasus: Arsitektur Multiproses Chrome

Banyak browser lama berjalan sebagai satu proses tunggal — bila satu situs bermasalah, seluruh browser dapat hang atau crash. Chrome menggunakan tiga jenis proses:

Browser process

Mengelola antarmuka pengguna, disk, dan I/O jaringan

Renderer process

Merender halaman web (HTML, JavaScript); satu renderer baru untuk setiap situs; berjalan dalam sandbox untuk membatasi dampak eksploitasi keamanan

Plug-in process

Satu proses terpisah untuk setiap jenis plug-in yang digunakan

Setiap tab pada dasarnya adalah proses yang terpisah

Bab 3 · Proses — 21 / 34

Bagian Baru

Komunikasi Antarproses (IPC)

Proses dapat bersifat independen atau cooperating. Proses cooperating dapat memengaruhi atau dipengaruhi proses lain, termasuk berbagi data.

Berbagi informasi

Mempercepat komputasi

Modularitas

Kenyamanan (convenience)

Bab 3 · Proses — 22 / 34

Dua Model Komunikasi

(a) Shared Memory

Proses A dan B membaca & menulis ke area memori bersama. Komunikasi dikendalikan sepenuhnya oleh proses pengguna, bukan OS.

(b) Message Passing

Proses bertukar pesan melalui kernel, tanpa berbagi variabel — melalui operasi send() dan receive().

Bab 3 · Proses — 23 / 34

Studi Kasus: Producer-Consumer

Producer

Consumer

Buffer — ruang bersama tempat item produksi menunggu untuk dikonsumsi

Unbounded buffer

Tidak ada batas praktis pada ukuran buffer — producer tidak pernah menunggu; consumer menunggu jika buffer kosong

Bounded buffer

Ukuran buffer tetap — producer menunggu jika buffer penuh; consumer menunggu jika buffer kosong

Bab 3 · Proses — 24 / 34

Solusi Bounded-Buffer via Shared Memory

#define BUFFER_SIZE 10

typedef struct { ... } item;

item buffer[BUFFER_SIZE];

int in = 0, out = 0;

// Producer

while (true) {

  while ((in+1)%SIZE == out)

    ; // tunggu, buffer penuh

  buffer[in] = next_produced;

  in = (in+1) % BUFFER_SIZE;

}

in menunjuk slot kosong berikutnya untuk diisi; out menunjuk slot terisi berikutnya untuk diambil

Consumer menunggu selama in == out (buffer kosong), lalu mengambil buffer[out]

Solusi ini benar, namun hanya dapat memanfaatkan BUFFER_SIZE − 1 elemen — satu slot dikorbankan untuk membedakan kondisi penuh dan kosong

Bab 3 · Proses — 25 / 34

Race Condition

Jika ingin mengisi seluruh buffer, ditambahkan variabel counter (bertambah oleh producer, berkurang oleh consumer). counter++ dan counter−− masing-masing menjadi tiga instruksi mesin.

Langkah

Instruksi

Hasil register / counter

S0

producer: register1 = counter

register1 = 5

S1

producer: register1 = register1 + 1

register1 = 6

S2

consumer: register2 = counter

register2 = 5

S3

consumer: register2 = register2 − 1

register2 = 4

S4

producer: counter = register1

counter = 6

S5

consumer: counter = register2

counter = 4

Nilai akhir counter = 4, padahal seharusnya tetap 5 (satu item ditambah, satu diambil) — hasil bergantung pada urutan eksekusi (interleaving)

Solusi bounded-buffer sebelumnya (tanpa counter) tidak mengalami race condition ini — dibahas tuntas pada Bab 6–7 (Sinkronisasi)

Bab 3 · Proses — 26 / 34

Message Passing: send() dan receive()

Komunikasi Langsung (Direct)

send(P, message)

receive(Q, message)

Proses harus saling menyebut nama secara eksplisit. Link terbentuk otomatis, tepat satu link untuk setiap pasangan proses, umumnya dua arah

Komunikasi Tak Langsung (Indirect)

send(A, message)

receive(A, message)

Pesan dikirim/diterima melalui mailbox (port). Link terbentuk hanya jika proses berbagi mailbox yang sama; satu mailbox dapat dipakai banyak proses

Jika beberapa proses menerima dari mailbox yang sama: batasi link ke dua proses, hanya satu proses boleh receive() pada satu waktu, atau sistem memilih penerima secara acak dan memberitahu pengirim

Bab 3 · Proses — 27 / 34

Sinkronisasi dan Buffering Pesan

Blocking (Synchronous)

send: pengirim diblokir sampai pesan diterima
receive: penerima diblokir sampai pesan tersedia

Jika keduanya blocking → disebut rendezvous

Non-blocking (Asynchronous)

send: pengirim mengirim lalu langsung melanjutkan
receive: menerima pesan valid, atau pesan null

Tiga cara implementasi antrian pesan (buffering)

Zero capacity

Tidak ada pesan diantrekan; pengirim harus menunggu penerima (rendezvous)

Bounded capacity

Panjang antrian terbatas (n pesan); pengirim menunggu jika link penuh

Unbounded capacity

Panjang antrian tak terbatas; pengirim tidak pernah menunggu

Bab 3 · Proses — 28 / 34

Contoh Nyata: POSIX Shared Memory

// Producer

shm_fd = shm_open(name,

  O_CREAT | O_RDWR, 0666);

ftruncate(shm_fd, SIZE);

ptr = mmap(0, SIZE,

  PROT_WRITE, MAP_SHARED,

  shm_fd, 0);

sprintf(ptr, "%s", message);

// Consumer

shm_fd = shm_open(name,

  O_RDONLY, 0666);

ptr = mmap(0, SIZE,

  PROT_READ, MAP_SHARED,

  shm_fd, 0);

printf("%s", (char *)ptr);

shm_unlink(name);

shm_open membuat/membuka segmen memori bersama

ftruncate menetapkan ukuran segmen

mmap memetakan segmen ke ruang alamat proses

Bab 3 · Proses — 29 / 34

Komunikasi pada Sistem Client-Server

Socket

Titik akhir (endpoint) komunikasi — gabungan alamat IP dan port

161.25.19.8:80

Port < 1024 bersifat well known untuk layanan standar; 127.0.0.1 adalah alamat loopback

Remote Procedure Call (RPC)

Mengabstraksi pemanggilan prosedur antarproses pada sistem berbeda melalui jaringan

Stub di sisi client mem-package (marshal) parameter; stub di sisi server membongkarnya dan menjalankan prosedur

Layanan matchmaker/rendezvous mempertemukan client dan server

Bab 3 · Proses — 30 / 34

Pemutakhiran Materi — Melampaui Buku Tahun 2018

Proses & IPC di Era Container

Namespace Linux

Memperluas isolasi proses klasik: PID, network, mount, dan user namespace membuat sekumpulan proses melihat "pohon proses"-nya sendiri — dasar dari container

cgroups (v2)

Melengkapi PCB dengan pembatasan kolektif: CPU, memori, dan I/O untuk sekelompok proses — dasar penjatahan resource pada Docker/Kubernetes

Container & Pod

Container = proses (atau grup proses) dengan namespace & cgroup sendiri, bukan mesin virtual; satu Pod Kubernetes dapat berbagi network namespace antar container

IPC & RPC Modern

gRPC (RPC berbasis Protocol Buffers) menggantikan RPC klasik; message broker seperti RabbitMQ & Apache Kafka mengimplementasikan message passing berskala besar dan tahan gangguan

Bab 3 · Proses — 31 / 34

Rangkuman

Proses = program yang dieksekusi, terdiri dari text, data, heap, dan stack; melewati status new→ready→running→waiting→terminated

PCB menyimpan seluruh informasi proses; context switch memindahkan PCB masuk-keluar CPU sebagai overhead murni

fork()/exec()/wait()/exit() membentuk siklus pembuatan hingga terminasi proses, termasuk zombie & orphan

IPC memungkinkan proses cooperating berbagi data melalui shared memory atau message passing

Producer-consumer memperlihatkan pentingnya sinkronisasi; race condition muncul jika akses variabel bersama tidak terkendali

Socket & RPC memperluas IPC melintasi jaringan; container/namespace memperluas konsep proses ke era cloud

Bab 3 · Proses — 32 / 34

Referensi & Tugas Latihan

Referensi

Silberschatz, A., Galvin, P. B., & Gagne, G. (2018). Operating System Concepts (10th ed.), Chapter 3: Processes. Wiley.

Dokumentasi Linux: man pages fork(2), execve(2), wait(2), namespaces(7), cgroups(7)

Materi pemutakhiran: dokumentasi resmi Docker, Kubernetes, dan gRPC

Tugas Latihan

1. Tulis program C dengan fork() yang membuat child menjalankan perintah shell, lalu parent menunggu dengan wait()

2. Implementasikan bounded-buffer producer-consumer dengan POSIX shared memory

3. Jelaskan bagaimana namespace & cgroups Linux merealisasikan konsep PCB pada container Docker

Bab 3 · Proses — 33 / 34

Tanya Jawab

Pertanyaan, diskusi, dan studi kasus tambahan mengenai proses dan komunikasi antarproses

Aditya Wikan Mahastama, S.Kom., M.Cs.

Program Studi Informatika · Universitas Kristen Duta Wacana

Bab 3 · Proses — 34 / 34