Pendahuluan

 Sistem operasi sebagai mesin semu

(virtual machine)
 Lapisan software di atas hardware
 Membungkus kompleksitas hardware,
mengelola seluruh bagian sistem, dan
memberi interface kpd pemakai
 Sistem operasi sebagai pengelola
sumber daya (resource manager)
 Mengendalikan alokasi prosesor,
memori, dan I/O untuk program-
program yg membutuhkannya
 Penting dlm kondisi multitasking dan
multiuser
 Perkembangan sistem operasi
 Gen I: bekerja utk. sistem tumpukan
(batch system)
 Gen II: multitasking dan timesharing,
spooling
 Gen III: PC - user friendliness,
distributed/network OS, real-time OS
 Gen IV: embedded OS, small-scale OS
Konsep-Konsep Penting
 Proses
 Program yg sedang dieksekusi
 Isu-isu penting: penciptaan, terminasi,
penjadwalan, hak dan privilege
 Terkait dengan sumber daya
(prosesor, memori, I/O) dan pemakai
(pemilik proses)
 File
 Sistem file sbg abstraksi model
pengorganisasian (data, proses, I/O)
 Menggunakan konsep direktori
• Bertingkat
• Nama jalur (path name) untuk menunjuk ke
suatu file
 Sebagai alat pengorganisasian data:
• Mekanisme proteksi secara ekstensif
• Pemanggilan sistem (system call) untuk
manipulasi file
 Untuk pemodelan struktur proses:
• Proses sebagai “data”
• Dalam Linux: direktori /proc
 Abstraksi I/O
• Agar sejalan dengan abstraksi pengorgani-
sasian data dan proses
• Dalam Unix: direktori /dev - file-file khusus
Konsep-Konsep Penting
 Input/Output
 Keragaman hardware I/O
• Perlu abstraksi untuk menyembunyikan
kompleksitas teknis  pendekatan
keseragaman
 Penggunaan
• Efektif (semua permintaan dapat terlayani)
• Efisien (menggunakan resource sehemat
mungkin)
 Arsitektur sistem operasi
 Monolitik
• Tidak berstruktur, semua dikemas menjadi
satu kesatuan
 Modular
• Kernel sebagai inti
• Modul-modul mengimplementasikan layanan
• Prinsip as-needed (hanya modul-modul yg
diperlukan saja yg terpasang)
 Client-server, terdistribusi
• Dalam lingkungan jaringan, untuk
embedded systems dengan resource yg
sangat terbatas
• Menggunakan model service-based
Proses
 Abstraksi ttg. eksekusi program
 Program counter, register, variabel,
CPU
 Menunjukkan aktivitas
• Program
• Input
• Output
• State: running, ready, blocked
 Satu prosesor bisa dipakai bersama
oleh bbrp proses, dng memanfaatkan
algoritma penjadwalan yg menentukan
pelayanan thdp proses-proses tsb.
 Semua yg terjadi dlm komputer
adalah proses!
 Hirarki proses: sebuah proses dpt
melahirkan proses lain melalui fork()
 Dalam Linux: init  login  shell  …
(coba perintah ps -AH)
 Bagaimana mengelola proses ?
 Tabel proses: state, PC, stack pointer,
alokasi memori, file-file yg terbuka, …
 Mekanisme penanganan interupsi
• Vektor interupsi
• Rutin penanganan interupsi
Komunikasi Antar Proses
 Dalam banyak situasi, proses-proses perlu
saling berinteraksi
 Konsep pemipaan (piping), daemon proses
 Sering melalui media penyimpanan:
memori dan file  sharing
 Problem dlm interaksi antar proses
 Race condition: 2 proses menggunakan
resource yg sama, hasil akhirnya
tergantung pd eksekusi dilakukan
 Deadlock: 2 proses saling menunggu
akibat masing-masing memerlukan
resource yg dikuasai oleh proses satunya
 Bgmn mengatasi problem tsb ?
 Race condition  mutual exclusion
• Jika ada satu proses yg sedang menggunakan
shared memori atau file, tidak boleh ada proses
lain yang melakukan hal yang sama
• Konsep critical section
 Deadlock
• Membiarkan saja
• Mendeteksi dan memulihkan
• Mencegah dng cara mencegah kondisi-kondisi
prasyaratnya
• Menghindari dng cara mengatur alokasi resource
Mengatasi Race
Condition
 Mutual exclusion dng busy waiting
 Mematikan mekanisme interupsi
• Memberi hak pada user utk memodifikasi
mekanisme interupsi
• Sangat berpotensi mengganggu sistem
• Tidak efektif untuk sistem multiprocessor
 Variabel kunci
• Variabel penanda:1-sibuk, 0-kosong
• Masih berpotensi terjadi race condition
 Penggiliran secara ketat
• Penggiliran utk masuk ke critical section
• Mekanisme busy waiting
• Tidak cocok utk 2 proses yg sangat berbeda waktu
eksekusinya
 Algoritma Peterson
• Menggabungkan mekanisme kunci dan penggiliran
– lihat kode program
• Untuk 2 proses yg masuk pd saat yg hampir
bersamaan, berpotensi utk melakukan hal yg
“terbalik” (meskipun masih dpt mencegah
terjadinya race condition)
 Secara umum:
• Jika sebuah proses ingin memasuki critical region,
ia akan memeriksa apakah ia diijinkan. Jika tidak,
ia akan menunggu (looping aktif) sampai ijin
diberikan
• Looping memakan resource CPU
• Tergantung skema penjadwalan proses, looping
dan busy waiting dapat menyebabkan kemacetan
pada semua proses yang terlibat
Mengatasi Race
Condition
 Sleep and wakeup
 Sleep: system call yg menyebabkan
pemanggilnya masuk ke state blocked
 Wakeup: system call yg membangun-
kan proses yg sedang blocked
(disebutkan sbg parameter)
 Skenario dengan problem bounded
buffer (producer-consumer) – lihat
kode program
 Semaphore (Dijkstra, 1965)
 Semaphore: variabel berisi nilai dan
berasosiasi dengan list proses-proses
yg sedang tidak aktif (sleep)
 Operasi DOWN dan UP
• DOWN: utk menguasai akses ke resource
• UP: utk membebaskan resource
Semaphore dan Monitor
#define N 100
typedef int semaphore; Listing problem producer-consumer
semaphore mutex= 1; dengan semaphore
semaphore empty = N;
semaphore full = 0;

producer() { consumer() {
int item; int item;

while (TRUE) { while (TRUE) {

produce_item(&item); down(full);
down(empty); down(mutex);
down(mutex); remove_item(&item);
enter_item(item); up(mutex);
up(mutex); up(empty);
up(full); consume_item(item);
} }
} }

empty  menghitung jumlah slot kosong

full  menghitung jumlah slot yang terisi
mutex  mencegah producer dan consumer mengakses buffer scr bersamaan

 Monitor
 Primitif sinkronisasi tingkat tinggi (pd aras
bhs pemrograman)
 Monitor: data, prosedur, variabel dlm
sebuah konstruksi khusus
 Hanya ada satu proses aktif dlm sebuah
monitor pd satu saat ttt
 Implementasi mekanisme oleh kompiler
bahasa pemrograman
 Penggunaan operasi WAIT dan SIGNAL
 Semaphore dan Monitor
monitor ProducerConsumer procedure producer;
condition full, empty; begin
integer count; while true do
begin
procedure enter; produce_item;
begin ProducerConsumer.enter;
if count = N then wait(full); end;
enter_item; end;
count := count + 1;
if count = 1 then signal(empty); procedure consumer;
end; begin
while true do
procedure remove; begin
begin ProducerConsumer.remove;
if count = 0 then wait(empty); consume_item;
remove_item; end;
count := count - 1; end;
if count = N-1 then signal(full);
end;
count := 0;
end monitor;

 Problem Dining Philosopher

 Problem klasik dlm sinkronisasi proses
(Dijkstra, 1965)
 n buah proses, m resources (m > n),
maksimisasi paralelisme
 Dapat dipecahkan dengan semaphore
(lihat contoh kode)
Dining Philosopher
#define N
#define LEFT (i-1)%N
#define RIGHT (i+1)%N
#define THINKING 0
#define HUNGRY 1
#define EATING 2
typedef int semaphore;
int state[N];
semaphore mutex= 1;
semaphore s[N];

philosopher(int i) {
while (TRUE) {
think();
take_forks(i);
eat();
put_forks(i);
}
}

take_forks(int i) { put_forks(int i) {
down(mutex); down(mutex);
state[i] = HUNGRY; state[i] = THINKING;
test(i); test(LEFT);
up(mutex); test(RIGHT);
down(s[i]); up(mutex);
} }

test(int i) {
if (state[i] == HUNGRY &&state[LEFT] != EATING&&state[RIGHT] != EATING) {
state[i] = EATING;
up(s[i]);
}
}
Penjadwalan Proses
 Prinsip-prinsip penjadwalan
 Keadilan: tiap proses mendapatkan alokasi
CPU yang adil
 Efisiensi: penggunaan CPU semaksimal
mungkin
 Waktu respons: minimal
 Waktu tunggu: minimal
 Throughput: maksimisasi pemrosesan
proses
 Strategi penjadwalan
 Run to completion
 Preemptive
 Teknik Round Robin
 List proses
 Semua proses memiliki hak yang sama
1. Tiap proses dialokasikan sepotong selang
waktu (quantum) utk eksekusi
2. Jika dalam 1 quantum eksekusi belum
selesai  dikeluarkan dari status aktifnya
(preempted)
3. Selanjutnya proses tsb ditempatkan di
akhir list
4. Eksekusi berlanjut dng proses pd antrian
pertama
Penjadwalan Proses
 Penjadwalan dengan prioritas
 Memasukkan unsur prioritas proses
 Tiap proses memiliki prioritas tertentu,
dan penjadwalannya menurut urutan
prioritasnya
 Sering diimplementasikan dengan
kelas-kelas prioritas dan teknik round
robin
 Prioritas proses diturunkan selama
eksekusi dilakukan  supaya proses
dng prioritas rendah memiliki
kesempatan dieksekusi juga
 Contoh penjadwalan dng prioritas
• Proses dng prioritas pertama diekseskusi
selama 1 quantum, prioritas kedua selama 2
quantum, prioritas ketiga 4 kuantum, dst.
• Setelah eksekusi menghabiskan n quantum
yg dialokasikan, proses diturunkan ke
prioritas berikutnya
• Proses sepanjang 100 quantum memerlukan
7x pergantian (swap) saja
Penjadwalan Proses
 Teknik Pengutamaan Proses
Tercepat
 Cocok untuk batch job dng waktu
eksekusi yg diketahui sebelumnya
 Menempatkan proses-proses pendek
pada urutan awal
 Memperpendek waktu tunggu
 Optimal untuk proses-proses yg sudah
“siap” dieksekusi
 Penjadwalan berbasis pemakai
 Jika ada n pemakai pd satu saat ttt,
maka tiap orang akan menerima 1/n
alokasi CPU
 Perlu informasi:
• Brp banyak waktu CPU yg telah dikonsumsi
seorang pemakai sejak login  x
• Brp lama pemakai ybs login ke sistem  y
 “Jatah” pemakai z = y/n, dan rasio
antara jatah dng kenyataan r = z/x
 Penjadwalan mengikuti nilai r: proses-
proses milik pemakai dengan nilai r yg
lebih rendah dieksekusi dahulu
Deadlock
 Deadlock: sekumpulan proses yg
menunggu event yg hanya bisa
dimunculkan oleh salah satu dr
proses anggota
 Tidak ada proses yg bisa berlanjut,
melepaskan resources, atau diaktifkan
kembali
 Berawal dari situasi supply resources
lebih kecil drpd demand
 Empat kondisi pemicu deadlock
 Kondisi mutual exclusion. Sebuah
resource sdg digunakan oleh 1 proses,
atau sdg bebas
 Kondisi hold and wait. Proses-proses
yg sdg memakai resources diijinkan
meminta resources baru
 Kondisi non-preemptive. Resource yg
sdg digunakan hanya bisa dilepaskan
oleh proses yg memakainya (pelepas-
an tdk bisa dipaksa oleh pihak lain)
 Kondisi circular wait. Ada rantai dr 2
atau lebih proses, msg-msg menunggu
resource yg dikuasai proses berikutnya
dalam rantai tsb.
Deadlock
 Pemodelan penggunaan resource
 Menggunakan graf alokasi resource
 A menguasai resource R A R
 A meminta resource R A R
 Dpt digunakan utk analisis deadlock
 Strategi dlm menghadapi deadlock
 Abaikan saja  algoritma “onta” (prinsip
pragmatisme)
 Pendeteksian dan pemulihan
 Pencegahan, dng cara menegasikan
kondisi-kondisi pemicu
 Menghindari, dng cara alokasi resource scr
hati-hati
 Algoritma onta (Ostrich algorithm)
 Pragmatisme, perbandingan antara usaha
utk menghilangkan deadlock dng akibat yg
ditimbulkannya
 Pendeteksian dan pemulihan
 Monitoring request dan release dr
resources, menganalisis graf alokasi
resources utk mendeteksi deadlock
 Rantai deadlock diputus dng
mengorbankan 1 atau lebih proses
Deadlock
 Pencegahan deadlock
 Negasi 4 kondisi pemicu
 Kondisi mutual exclusion ?
• Resource bisa digunakan oleh lebih dr satu
proses
 Kondisi hold and wait ?
• Proses yg sdg menguasai sbh resource tidak
diijinkan utk meminta resource yg lain
• Kebutuhan resource sering bersifat dinamis
• Menyebabkan alokasi resource tdk efisien
 Kondisi non-preemptive ?
• Memungkinkan resource dilepas scr paksa
• Dapat mengacaukan operasi (e.g., printing)
 Kondisi rantai tunggu (circular wait) ?
• Alternatif yg paling mungkin ditempuh
• Dengan penomoran resource, akses
diijinkan dng mengikuti urutan tertentu
 Menghindari deadlock
 Alokasi resource scr hati-hati
 Algoritma banker
• Alokasi resource selalu memperhatikan
kemungkinan ke depan (next state)
• Kebutuhan ke depan satu atau lebih proses
harus selalu dapat dipenuhi oleh resource yg
tersedia saat ini
Sistem File
 Tujuan: memberikan persistence
bagi data
 Kondisi ideal: tidak ada impedance
mismatch antara short-term memory dan
long-term memory
 Krn kondisi ideal tdk bisa tercapai 
muncul abstraksi file
 Bagaimana rancangan sistem file ?
 Manajemen ruang disk
 Ruang sebesar n byte scr kontinyu, atau
m blok yg tidak harus kontinyu
 Alt. I  bgmn jika file berkembang
(bertambah besar) ?
 Alt. II  brp besar ukuran blok ?
• Terlalu besar  boros
• Terlalu kecil  delay saat pembacaan
• Trade off antara efisiensi waktu dan ruang 
512 byte, 1 kb, atau 2 kb
 Bgmn melacak blok-blok bebas ?
• Linked list berisi blok-blok bebas
• Bit map berisi status semua blok (0-bebas, 1-
terpakai)
Sistem File
 Bagaimana menyimpan file ?
 Blok data dirangkai mjd linked-list
• Implementasi akses scr acak mjd mahal
 File Allocation Table (FAT) dr MS-DOS
• Tidak cocok utk disk berukuran besar 
menyita tempat di memory
• Pointer ke semua file disimpan dlm satu
tabel yg sama
 i-Node (digunakan oleh UNIX)
• Tabel berisi info accounting dan proteksi,
diasosiasikan ke sebuah file
• Mampu menangani dinamika file, dan lebih
modular (1 file 1 i-node)
X X EOF 10 2 EOF 4 FREE 5 FREE 8

0 1 2 3 4 5 6 7 8 9 10

File node

No. of links to file

Owner's UID

Owner's GID

File size

Time created

Time last accessed

Time last modif ied

10 disk block numbers

Single indirect

Double indirect

Triple indirect
 Sistem File
 Struktur dan organisasi direktori
 Direktori pada MS-DOS
• Direktori diwujudkan dlm sebuah file
• Tiap entri direktori menunjuk pd satu file
• Tidak ada batas maksimal jumlah file pada
sebuah direktori
 Direktori pada UNIX
• Direktori diwujudkan dlm sebuah file
• Tiap entri merujuk pd satu file
• Info pd tiap entri: nomor i-node dan nama
file

File name Ext. Attr. Reserved Time Date First Size

block
num.
8 byte 3 byte 1b 8 byte 2 byte 2 byte 2 byte 4 byte

block 132 is i-node 26 for block 406 is

Root directory i-node 6 for /usr /usr directory /usr/ast /usr/ast dir.
1 . mode 6 . mode 26 .
1 .. size
times
1 .. size
times
6 ..
4 bin 19 dick 64 grants
7 dev 132 30 eric 406 92 books
14 lib 26 ast 60 mbox
9 etc 45 bal 81 src
6 usr /usr/ast is /usr/ast/mbox
8 tmp /usr is in i-node 26 /usr/ast is in is i-node 60
block 132 block 406
usr: to i-node 6
Sistem File
 Berbagi file (file sharing)
 Dengan mekanisme link
 Problem: update agar terlihat oleh
pihak lain
• Metode langsung: Info blok disk sbg
“atribut” file (di i-node dlm UNIX) yg bisa
dilihat oleh direktori siapapun
• Kelemahan metode langsung: “dirty”
deletion  penghapusan file oleh pemilik
bisa menyisakan i-node file tsb (agar tidak
terjadi situasi yg “menggantung”)
• Symbolic linking: menyisipkan file bertipe
LINK, yg berisi path ke file yg di-share, ke
direktori “tamu”
• Kelemahan symlink: overhead pemrosesan,
krn harus membaca dan memproses path ke
file yg sebenarnya

C's directory B's directory C's directory B's directory

owner = C owner = C owner = C

count = 1 count = 2 count = 1
Sistem File
 Konsistensi sistem file
 Problem inkonsistensi antara data dan
info ttg file (i-node)
 Pemeriksaan konsistensi: blok & file
 Pemeriksaan konsistensi blok
• List untuk blok yg dipakai dlm file
• List untuk blok bebas
• Kedua counter dibandingkan  sebuah nomor
blok hrs berada di salah satu list
 Kemungkinan inkonsistensi blok
• Nomor blok hilang
• Duplikasi nomor blok di list blok bebas
• Duplikasi nomor blok di list blok terpakai
 Pemeriksaan konsistensi file
• Dilakukan pd direktori
• Caranya mirip pemeriksaan konsistensi blok
• Menghasilkan sebuah list berisi info ttg.
banyaknya refcount ke sebuah i-node
• Info ini dibandingkan dng isi field refcount dari
i-node ybs
 Kemungkinan inkonsistensi file
• Counter link terlalu tinggi  file tetap ada
meskipun telah dihapus
• Counter link terlalu rendah  problem
integritas file
Pengaksesan File
 Abstraksi server file sbg interface
 Atomic update
 Perubahan thdp file harus berhasil
atau tidak sama sekali
 Diimplementasikan dng konsep tempat
penyimpanan stabil (stable storage)
• Sebuah drive logikal diimplementasikan dng
dua disk fisis
• Penulisan ke blok logikal n, dituliskan ke
blok n di disk #1, diverifikasi, lalu dituliskan
ke blok n di disk #2 dan diverifikasi
• Error fisis (blok rusak, dsb) bisa diperbaiki
dng cara menyalin data dari salah satu disk
• Crash pd saat menulis disk #1  kembali ke
kondisi asal
• Crash pd saat menuli disk #2  kembali ke
kondisi setelah update
 Concurrency control
 Serializability: update secara bersama-
an menghasilkan situasi yg sama jika
updatenya dilakukan scr sekuensial
 Locking  concurrency control dari sisi
data (file)
Pengaksesan File
 Transaksi
 Atomic update + locking
 Concurrency ditangani oleh file server
 BEGIN TRANSACTION
• Transaction record utk merekam status
transaksi
 END TRANSACTION
• Proses commit utk membuat update mjd
permanen
Client File Server
Mulai transaksi Buat transaction record di stable storage
Baca file A Lock file A
Baca file B Lock file B
Update file A Buat salinan A dan update salinan ini
Update file B Buat salinan B dan update salinan ini
Selesai transaksi Simpan intention list ke stable storage
Tandai transaksi sebagai ‘commited’
Ganti file A dengan salinannya
Ganti file B dengan salinannya
Lepaskan lock A dan B
Acknowledge

 Replikasi
 Mewujudkan konsep fault tolerance
 Menyimpan lebih dari 1 copy file
 Biasanya diterapkan di lingkungan
sistem terdistribusi
Keamanan Sistem File
 Berkaitan dng kehilangan data dan
usaha-usaha penyusupan
 Mekanisme proteksi
 Usaha/biaya sebanding dengan nilai
informasi yg akan dilindungi
 Prinsip-prinsip pengamanan
 Desain sistem hrs bersifat public
• “Security through obscurity” tidak cocok
 Prinsip paranoid
• Kondisi default: tidak ada akses
• Berikan privilege seminimal mungkin
• Autorisasi hrs dilakukan sesaat sbl. aktivitas
yg memerlukan autorisasi tsb dilakukan
 Sistem proteksi hrs sederhana,
seragam, dan mendasar
 Sistem proteksi hrs dpt diterima scr
psikologis
 Beberapa mekanisme pengamanan
 Autorisasi  identifikasi pemakai
 Domain proteksi  lingkup akses
sebuah object
 Access Control List
Manajemen Memori
 Mengapa perlu manajemen memori
 Resource yg sangat berharga
 Parkinson’s law: program cenderung
memenuhi seluruh kapasitas memori
dan menguasainya
 Kemampuan multiprogramming 
beberapa proses berada di memori pd
saat yg sama
 Manajemen memori dengan partisi
tetap
 n buah partisi, ukuran bisa bervariasi,
diset pd saat sistem diaktifkan
 Bgmn jika proses berkembang ?

Partisi 4 Partisi 4

Partisi 3 Partisi 3

Partisi 2 Partisi 2

Partisi 1 Partisi 1
Operating Operating
system system
 Manajemen Memori
 Alokasi memori dengan partisi
variabel
 Bgmn mengalokasikan memori untuk
proses yg berkembang ?
Stack B

Data B

Stack A

Data A
Program B

Program A

Sistem operasi
 Bgmn mengalokasikan memori untuk
proses yg berkembang ?
 Bitmap
 Linked-list
 Buddy system

1111100011111100

P 0 5 H 5 3

P 8 6 H 14 2
Manajemen Memori
 Pelacakan memori bebas dengan
metode bit map
 Faktor pemilihan satuan alokasi mjd
penting
• Satuan kecil  bit map besar
• Satuan besar  ada kemungkinan sisa
memori
 Pelacakan memori bebas dengan
metode linked-list
 Diurutkan berdasar alamat memori
 Implementasi dng double linked-list
 Algoritma alokasi memori
 First fit: mencari daerah memori bebas
(DMB) yg pertama kali ditemukan yg
bisa menampung proses
 Next fit: mirip dng first fit, tapi dng
merekam posisi DMB. Proses pencarian
selanjutnya dimulai dr posisi ini.
 Best fit: mencari di seluruh list DMB yg
paling sesuai dng kebutuhan proses
 Worst fit: mencari di seluruh list DMB
yg paling besar yg tersedia
Manajemen Memori
 Pelacakan memori bebas dengan
metode buddy system
 Berdasar kenyataan bhw komputer
bekerja dng bilangan biner  diguna-
kan utk mempercepat penggabungan
DMB-DMB yg bersebelahan pd saat
sebuah proses selesai dieksekusi (atau
diswap ke disk)
 Diimplementasikan dng list memori
bebas berukuran 1, 2, 4, 8, 16, … byte
 Pengalokasian memori ke proses dila-
kukan dng memecah satu blok memori
bebas mjd 2 bg yg sama besar. Peme-
cahan dilakukan scr rekursif shg dida-
pat blok yg besarnya sesuai kebutuhan
 Keuntungan
• Cepat utk proses pembebasan memori
 Kerugian
• Utilisasi memori yg kurang efisien krn terikat
pd aturan 2n  fragmentasi internal
 Manajemen Memori
 Ilustrasi model buddy system
0 128 256 512 1024

Initial

Req. 70 A

Req. 35 A B

Req. 80 A B C

Return A B C

Req. 60 D B C

Return B D C

Return D C

Return C
Virtual Memory
 Muncul dr kenyataan bhw
kebutuhan memori jauh lebih
tinggi drpd memori yg tersedia
 Usaha utk menyederhanakan
solusi dng cara abstraksi
manajemen memori
 Paging
 Akses ke memori melalui
• Mapping dari virtual address
• Mekanisme “page frame”
 Memory management unit (MMU) sbg
mapper
 Virtual addr space > real addr space
 mapping yg dinamis (bisa berubah-
ubah)
 Mekanisme akses
1. Instruksi program berisi perintah akses ke
memori
2. Alamat memori  virtual address space,
diteruskan ke MMU
3. MMU melakukan mapping ke real address
4. Real address diteruskan ke address bus
 Virtual Memory: Paging
Virtual
address

32K - 36K
12K - 16K

16K - 20K

20K - 24K

28K - 32K

36K - 40K

40K - 44K

44K - 48K

48K - 52K

52K - 56K

56K - 60K

60K - 64K
24K - 28K
4K - 8K

space 8K - 12K
0 - 4K

Virtual
2 1 6 0 4 3 x x x 5 x 7 x x x x
page

Page
frame

Physical
memory
0 - 4K

4K - 8K

8K - 12K

12K - 16K

16K - 20K

20K - 24K

24K - 28K

28K - 32K

address

 Page yg tidak terpetakan akan

menyebabkan page fault
 Jika terjadi page fault
1. SO memilih salah satu page frame yg
tidak banyak diakses & menyimpan
isinya ke disk
2. SO mengambil isi page yg tidak
terpetakan dan menyalinnya ke page
frame yg baru saja di-flush
3. SO mengubah mapping
4. Melanjutkan eksekusi instruksi
Algoritma Pergantian
Page
 Tujuan: minimisasi overhead, shg
hrs dipilih page frame yg tidak
banyak digunakan
 Algoritma Not-Recently-Used
 Bit R (referenced) dan M (modified)
• R diset bila sebuah page direferensikan
• M diset bila ada modifikasi thdp isi page
 Pertama kali sebuah proses dimulai, R
dan M direset.
 Scr periodis (mis: tiap clock interrupt),
bit R direset
 Ada 4 kemungkinan kelas:
• K1: tidak direferensi, tidak dimodifikasi
• K2: tidak direferensi, dimodifikasi
• K3: direferensi, tidak dimodifikasi
• K4: direferensi, dimodifikasi
 Jika ada page fault, SO akan memilih
sebuah page dr kelas terendah yg
tidak kosong
• Contoh: lebih baik memilih (utk dibuang)
page yg dimodifikasi tp tidak direferensi dlm
waktu yg cukup lama (K2), drpd page yg
tdk dimodifikasi tp sering digunakan (K3)
Algoritma Pergantian
Page
 Algoritma FIFO
 Page yang paling awal akan dibuang
pd saat terjadi page fault
 Perlu list utk merekam info ttg “umur”
page
 Algoritma FIFO sering dikombinasikan
dng bit R dan M utk meminimisasi
overhead akibat dibuangnya page yg
sering direferensi
 Algoritma Least-Recently-Used
 Asumsi: sebuah page yg banyak
digunakan pd bbrp instruksi terakhir
akan tetap banyak digunakan dlm bbrp
instruksi berikut, dmk pula sebaliknya
 Pilih page yg tidak direferensikan dlm
jangka waktu yg paling lama
 LRU mahal krn harus memonitor status
tiap page  perlu bantuan hardware
khusus atau simulasi software utk
mencatat status referensinya (bit R)