SisOp

Pendahuluan

Sistem operasi sebagai mesin semu
(virtual machine)



Sistem operasi sebagai pengelola
sumber daya (resource manager)



Lapisan software di atas hardware
Membungkus kompleksitas hardware,
mengelola seluruh bagian sistem, dan
memberi interface kpd pemakai
Mengendalikan alokasi prosesor,
memori, dan I/O untuk programprogram 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
•
•
•
•


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!



Program
Input
Output
State: running, ready, blocked
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



Problem dlm interaksi antar proses



Konsep pemipaan (piping), daemon proses
Sering melalui media penyimpanan:
memori dan file  sharing
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 membangunkan 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;
semaphore mutex = 1;
semaphore empty = N;
semaphore full = 0;
producer() {
int item;
Listing problem producer-consumer
dengan semaphore
consumer() {
int item;
while (TRUE) {
produce_item(&item);
down(empty);
down(mutex);
enter_item(item);
up(mutex);
up(full);
}
}
while (TRUE) {
down(full);
down(mutex);
remove_item(&item);
up(mutex);
up(empty);
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
condition full, empty;
integer count;
procedure enter;
begin
if count = N then wait(full);
enter_item;
count := count + 1;
if count = 1 then signal(empty);
end;
procedure remove;
begin
if count = 0 then wait(empty);
remove_item;
count := count - 1;
if count = N-1 then signal(full);
end;
count := 0;
end monitor;

procedure producer;
begin
while true do
begin
produce_item;
ProducerConsumer.enter;
end;
end;
procedure consumer;
begin
while true do
begin
ProducerConsumer.remove;
consume_item;
end;
end;
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
# define RIGHT
# define THINKING
# define HUNGRY
# define EATING
typedef int semaphore;
int state[N];
semaphore mutex = 1;
semaphore s[N];
(i-1)%N
(i+1)%N
0
1
2
philosopher(int i) {
while (TRUE) {
think();
take_forks(i);
eat();
put_forks(i);
}
}
take_forks(int i) {
down(mutex);
state[i] = HUNGRY;
test(i);
up(mutex);
down(s[i]);
}
put_forks(int i) {
down(mutex);
state[i] = THINKING;
test(LEFT);
test(RIGHT);
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






Strategi penjadwalan



Keadilan: tiap proses mendapatkan alokasi
CPU yang adil
Efisiensi: penggunaan CPU semaksimal
mungkin
Waktu respons: minimal
Waktu tunggu: minimal
Throughput: maksimisasi pemrosesan
proses
Run to completion
Preemptive
Teknik Round Robin


1.
2.
List proses
Semua proses memiliki hak yang sama
Tiap proses dialokasikan sepotong selang
waktu (quantum) utk eksekusi
Jika dalam 1 quantum eksekusi belum
selesai  dikeluarkan dari status aktifnya
(preempted)
3.
4.
Selanjutnya proses tsb ditempatkan di
akhir list
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: prosesproses 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 (pelepasan 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





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)


Menggunakan graf alokasi resource
A menguasai resource R A
R
A meminta resource R
A
R
Dpt digunakan utk analisis deadlock
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 modified
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
8 byte
3 byte
1b
8 byte
2 byte
2 byte
Root directory
1
1
4
7
14
9
6
8
.
..
bin
dev
lib
etc
usr
tmp
usr: to i-node 6
i-node 6 for /usr
mode
size
times
132
/usr is in
block 132
block 132 is
/usr directory
6
1
19
30
26
45
.
..
dick
eric
ast
bal
/usr/ast is
i-node 26
i-node 26 for
/usr/ast
mode
size
times
406
/usr/ast is in
block 406
First
block
num.
2 byte
Size
4 byte
block 406 is
/usr/ast dir.
26
6
64
92
60
81
.
..
grants
books
mbox
src
/usr/ast/mbox
is i-node 60
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
owner = C
count = 1
B's directory
C's directory
owner = C
count = 2
B's directory
owner = C
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 bersamaan 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
Mulai transaksi
Baca file A
Baca file B
Update file A
Update file B
Selesai transaksi

File Server
Buat transaction record di stable storage
Lock file A
Lock file B
Buat salinan A dan update salinan ini
Buat salinan B dan update salinan ini
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
system
Operating
system
Manajemen Memori
Alokasi memori dengan partisi
variabel

Bgmn mengalokasikan memori untuk
proses yg berkembang ?
 Bitmap
 Linked-list
 Buddy system
Program A
Data A
Stack A
Data B
Sistem operasi
Bgmn mengalokasikan memori untuk
proses yg berkembang ?
Program B

Stack B

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  digunakan 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 dilakukan dng memecah satu blok memori
bebas mjd 2 bg yg sama besar. Pemecahan dilakukan scr rekursif shg didapat blok yg besarnya sesuai kebutuhan
Keuntungan
• Cepat utk proses pembebasan memori

Kerugian
• Utilisasi memori yg kurang efisien krn terikat
n
pd aturan 2  fragmentasi internal
Manajemen Memori
Ilustrasi model buddy system

0
128
256
512
Initial
Req. 70
A
Req. 35
A
B
Req. 80
A
B
C
B
C
B
C
Return A
Req. 60
D
Return B
D
Return D
Return C
C
C
1024
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 berubahubah)
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
8K - 12K
12K - 16K
16K - 20K
20K - 24K
24K - 28K
28K - 32K
32K - 36K
36K - 40K
40K - 44K
44K - 48K
48K - 52K
52K - 56K
56K - 60K
60K - 64K
6
0
4
3
x
x
x
5
x
7
x
x
x
x
8K - 12K
12K - 16K
16K - 20K
20K - 24K
24K - 28K
28K - 32K
2
4K - 8K
1
0 - 4K
Virtual
page
0 - 4K
Virtual
address
space
4K - 8K
Virtual Memory: Paging
Page
frame
Physical
memory
address


Page yg tidak terpetakan akan
menyebabkan page fault
Jika terjadi page fault
1.
2.
3.
4.
SO memilih salah satu page frame yg
tidak banyak diakses & menyimpan
isinya ke disk
SO mengambil isi page yg tidak
terpetakan dan menyalinnya ke page
frame yg baru saja di-flush
SO mengubah mapping
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)