Makalah Virtual Memori
-
Upload
rizuan-munanda -
Category
Documents
-
view
853 -
download
48
description
Transcript of Makalah Virtual Memori
MAKALAH VIRTUAL MEMORI
(ALGORITMA PAGE REPLACEMENT,ALOKASI FRAME TRHASHING DAN MODEL WORKING
SET)
DI
S
U
S
U
N
OLEH:
KELOMPOK : 8
Nama Anggota : 1. Zulfa Hardianti (100411044)
2, Yenni Zulfarahmi(100411043)
Kelas : I2
Dosen Pembimbing : Sila Abdullah Syakri, ST,MT
POLITEKNIK NEGERI LHOKSEUMAWE
2012
1 ABSTRAK
Pada dasarnya pelaksanaan manajemen memori mengharuskan semua
proses mempunyai alokasi tersendiri di dalam memori fisik. Hal ini selalu menjadi
masalah pada memori yang mempunyai kapasitas terbatas dan dapat menurunkan
optimisasi utilitas dati memori utama.
Memori virtual menyediakan ruang yang lebih besar daripada kapasitas
memori itu sendiri sehingga dapat menampung program yang lebih besar daripada
kapasitas memori yang sebenarnya. Implementasi memori virtual menggunakan
page replacement dan alokasi frame dapat menyebabkan page fault. Jika terlalu
banyak page fault maka dapat terjadi trhashing yang dapat menurunkan utilitas
CPU. Hal ini dapat diatasi dengan working set.
2 DAFTAR ISI
1
1 ABSTRAK.......................................................................................................1
2 DAFTAR ISI...................................................................................................2
3 PENDAHULUAN...........................................................................................4
3.1 Latar Belakang.........................................................................................4
3.2 Rumusan Masalah....................................................................................5
3.3 Metode Penulisan.....................................................................................5
3.4 Hasil Yang Diharapkan............................................................................6
4 TEORI.............................................................................................................7
4.1 Pengertian................................................................................................7
4.2 Algoritma Page Replacement.................................................................104.2.1 Algoritma Penggantian Page Acak.....................................................124.2.2 Algoritma FIFO..................................................................................124.2.3 Algoritma Optimal.............................................................................144.2.4 Algoritma Least Recently Use (LRU)................................................144.2.5 Algoritma Perkiraan LRU..................................................................164.2.6 Algoritma NRU (Not Recently Used)................................................204.2.7 Algoritma Counting............................................................................214.2.8 Algoritma Page Buffering..................................................................21
4.3 ALOKASI FRAME...............................................................................224.3.1 Jumlah Frame Minimum....................................................................224.3.2 Algoritma Alokasi..............................................................................23
4.3.2.1 Algoritma Fixed Allocation.........................................................234.3.2.2 Algoritma Priority Allocation.....................................................23
4.3.3 Alokasi Global dan Alokasi Lokal.....................................................24
4.4 THRASHING........................................................................................244.4.1 Penyebab Trhashing...........................................................................254.4.2 Membatasi Efek Trhashing.................................................................264.4.3 Model Working Set............................................................................274.4.4 Frekuensi Kesalahan Halaman...........................................................29
5 KESIMPULAN.............................................................................................31
DAFTAR GAMBAR
2
Gambar 4-1 Memory virtual lebih besar daripada memori fisik.............................9
Gambar 4-2 Grafik jumlah page fault terhadap jumlah frame...............................11
Gambar 4-3 Algoritma page replacement FIFO....................................................12
Gambar 4-4 Belady’s anomaly..............................................................................13
Gambar 4-5 Algoritma page replacement optimal.................................................14
Gambar 4-6 Algoritma page replacement LRU.....................................................15
Gambar 4-7 Implementasi LRU menggunakan stack............................................16
Gambar 4-8 Thrashing...........................................................................................25
Gambar 4-9 Jumlah Frame.....................................................................................29
3 PENDAHULUAN
3.1 Latar Belakang
Selama bertahun-tahun,pelaksanaan manajemen memori pada intinya adalah
dengan menempatkan semua bagian proses yang akan dijalankan ke dalam
3
memori sebelum proses dapat mulai dieksekusi. Dengan demikian semua bagian
proses tersebut harus memiliki alokasi sendiri di dalam memori fisik.
Pada kenyataannya tidak semua bagian dari program tersebut akan diproses,
misalnya:
Program mempunyai kode untuk menangani kondisi error yang tidak
biasa. Karena error-error ini jarang terjadi, kode ini hampir tidak pernah
dieksekusi.
Array, list, dan tabel dialokasikan lebih dari kapasitas memori yang
diperlukan.
Pilihan dan gambaran program jarang digunakan
Pada kasus dimana keseluruhan program dibutuhkan, mungkin tidak
semua diperlukan pada saat yang sama.
Ada pernyatan-pernyataan atau pilihan yang hanya akan dieksekusi jika
kondisi tertentu dipenuhi
Pada memori berkapasitas besar, hal-hal ini tidak akan menjadi masalah.
Namun pada memori dengan kapasitas yang sangat terbatas, hal ini akan
menurunkan optimisasi utilitas dari ruang memori fisik(memori utama).
Setiap program yang dijalankan harus berada di memori. Memori
merupakan suatu tempat penyimpanan utama(primary storage) yang bersifat
sementara(volatile). Ukuran memori yang terbatas dapat menimbulkan massalah
bagaimana menempatkan program yang berukuran lebih besar dari ukuran
memori fisik(memori utama) dan masalah penerapan multiprogramming yang
membutuhkan tempat yang lebih besar di memori.
Salah satu cara untuk mengatasinya adalah dengan overlay dan dynemic
loading. Namun hal ini menimbulkan masalah baru karena implementasinya yang
rumit dan penulisan program yang akan memakan tempat di memori. Tujuan
semula untuk menghemat memori bisa jadi malah tidak tercapai apabila program
untuk overlay dan dynamic loading malah lebih besar daripada program yang
4
sebenarnya ingin dieksekusi. Maka sebagai solusi untuk masalah-masalah ini
digunkanlah konsep memori virtual.
Kemampuan mengeksekusi program hanya pada beberapa bagian dari
memori mempunyai beberapa keuntungan yaitu:
Program tidak terbatas jumlah memori fisik yang tersedia sehingga
user dapat menulis program untuk ruang alamat virtual yang sangat
besar yanga berarti menyederhanakan programming task.
Karena setiap program user dapat menggunakan memori fisik yang
lebih kecil, pada waktu yang sama dapat menjalankan lebih banyak
program.
I/O yang lebih sedikit diperlukan untuk load atau swap program user
ke memori, sehingga setiap program user dapat berjalan lebih cepat.
3.2 Rumusan Masalah
1. Implementasi memori virtual
2. Algoritma page replacement
3. Penyebab dan pencegahan trhashing
3.3 Metode Penulisan
Penulis mempergunakan metode observasi dan kepustakaan.
Cara-cara yang digunakan pada penelitian ini adalah : Studi Pustaka. Dalam
metode ini penulis membaca buku-buku yang berkaitan dengan penulisan makalah
ini dan artikel yang berhubungan.
3.4 Hasil Yang Diharapkan
Dengan adanya memori virtual diharapkan programmer dapat membuat
program dengan lebih leluasa tanpa mengkhawatirkan kapasitas memori yang
terbatas.
5
4 TEORI
4.1 Pengertian
Memori virtual adalah suatu teknik yang memisahkan antara memori logis
dan memori fisiknya. Teknik ini menyembunyikan aspek-aspek fisik memori dari
pengguna dengan menjadikan memori sebagai lokasi alamat virtual berupa byte
yang tidak terbatas dan menaruh beberapa bagian dari memori virtual yang berada
6
di memori logis. Teknik ini mengizinkan program untuk dieksekusi tanpa seluruh
bagian program perlu ikut masuk ke dalam memori.
Berbeda dengan keterbatasan yang dimiliki oleh memori fisik, memori
virtual dapat menampung program dalam skala besar, melebihi daya tampung dari
memori fisik yang tersedia.
Prinsip dari memori virtual yang patut diingat adalah bahwa: “Kecepatan
maksimum eksekusi proses di memori virtual dapat sama, tetapi tidak pernah
melampaui kecepatan eksekusi proses yang sama di sistem tanpa menggunakan
memori virtual.”
Konsep memori virtual pertama kali dikemukakan Fotheringham pada tahun
1961 pada sistem komputer Atlas di Universitas Manchester, Inggris (Hariyanto,
Bambang : 2001).
Sebagaimana dikatakan di atas bahwa hanya sebagian dari program yang
diletakkan di memori fisik. Hal ini memberikan keuntungan:
Berkurangnya proses I/O yang dibutuhkan (lalu lintas I/O menjadi
rendah). Misalnya untuk program butuh membaca dari disk dan
memasukkan dalam memory setiap kali diakses.
Ruang menjadi lebih leluasa karena berkurangnya memori fisik yang
digunakan. Contoh, untuk program 10 MB tidak seluruh bagian
dimasukkan dalam memori fisik. Pesan-pesan error hanya dimasukkan jika
terjadi error.
Meningkatnya respon, karena menurunnya beban I/O dan memori.
Bertambahnya jumlah pengguna yang dapat dilayani. Ruang memori yang
masih tersedia luas memungkinkan komputer untuk menerima lebih
banyak permintaan dari pengguna .
Gagasan utama dari memori virtual adalah ukuran gabungan program, data
dan stack melampaui jumlah memori fisik yang tersedia. Sistem operasi
7
menyimpan bagian-bagian proses yang sedang digunakan di memori fisik
( memori utama ) dan sisanya diletakkan di disk. Begitu bagian yang berada di
disk diperlukan, maka bagian di memori yang tidak diperlukan akan dikeluarkan
dari memori fisik ( swap-out ) dan diganti ( swap-in ) oleh bagian disk yang
diperlukan itu.
Menyediakan memori virtual yang sangat besar diperuntukkan untuk
programmer bila tersedia memori fisik yang lebih kecil. Programmer tidak perlu
khawatir jumlah memori fisik yang tersedia, sehingga dapat berkonsentrasi pada
permasalahan pemrograman.
Gambar 4-1 Memory virtual lebih besar daripada memori fisik
8
Pada Gambar 2.1 diatas ditunjukkan ruang sebuah memori virtual yang
dibagi menjadi bagian-bagian yang sama dan diidentifikasikan dengan nomor
virtual pages. Memori fisik dibagi menjadi page frames yang berukuran sama dan
diidentifikasikan dengan nomor page frames. Bingkai (frame) menyimpan data
dari halaman. Atau memori virtual memetakan nomor virtual pages ke nomor
page frames. Mapping (pemetaan) menyebabkan halaman virtual hanya dapat
mempunyai satu lokasi alamat fisik.
Dalam sistem paging, jika sebuah ruang diperlukan untuk proses dan
halaman yang bersangkutan tidak sedang digunakan, maka halaman dari proses
akan mengalami paged out (disimpan ke dalam disk) atau swap out, memori akan
kosong untuk halaman aktif yang lain. Halaman yang dipindah dari disk ke
memori ketika diperlukan dinamakan paged in (dikembalikan ke memori) atau
swap in. Ketika sebuah item dapat mengalami paging, maka item tersebut
termasuk dalam item yang menempati ruang virtual, yang diakses dengan alamat
virtual dan ruangan yang ada dialokasikan untuk informasi petaan. Sistem operasi
mengalokasikan alamat dari item tersebut hanya ketika item tersebut mengalami
paging in.
Memori virtual biasanya diimplementasikan menggunakan demand paging
atau demand segmentation. Tetapi algoritma segment replacement lebih kompleks
daripada algoritma place replacement karena segment mempunyai ukuran yang
bervariasi.
4.2 Algoritma Page ReplacementTerdapat beberapa algoritma page replacement, setiap sistem operasi
mempunyai skema yang unik. Algoritma yang terbaik adalah yang memiliki
tingkat kesalahan halaman terendah. Selama jumlah frame meningkat, jumlah
kesalahan halaman akan menurun. Peningkatan jumlah frame dapat terjadi jika
memori fisik diperbesar.
Algoritma page replacement secara umum diinginkan mempunyai rata-rata
page fault terendah. Algoritma dievaluasi dengan menjalankan pada string
9
tertentu dari memori reference dan menghitung jumlah page fault. String yang
mengacu ke memori disebut reference string (string acuan). String acuan
dibangkitkan secara random atau dengan menelusuri sistem dan menyimpan
alamat dari memori acuan. Misalnya jika ditelusuri proses tertentu, disimpan
alamat berikut:
0100, 0432, 0101, 0612, 0102, 0103, 0104,
0101, 0611, 0102, 0103, 0104, 0101, 0610,
0102, 0103, 0104, 0101, 0609, 0102, 0105
Dimana 100 byte per page direduksi ke string acuan:
1, 4, 1, 6, 1, 6, 1, 6, 1, 6, 1
Untuk menentukan jumlah page fault untuk string acuan dan algoritma page
replacement tertentu, harus diketahui jumlah page frame yang tersedia. Semakin
tinggi jumlah frame, semakin rendah jumlah page fault. Hal ini dapat dilihat
dengan grafik pada Gambar 2.2
Gambar 4-2 Grafik jumlah page fault terhadap jumlah frame
10
Terdapat beberapa algoritma page replacement antara lain algoritma first in
first out (FIFO) , optimal dan least recently use (LRU). Pada sub bab berikut akan
diilustrasikan algoritma page replacement tersebut dengan menggunakan string
acuan
7, 0, 1, 2, 0, 3, 0, 4, 2, 3, 0, 3, 2, 1, 2, 0, 1, 7, 0, 1
Page replacement diimplementasikan dalam algoritma yang bertujuan
untuk menghasilkan tingkat kesalahan halaman terendah. Pemilihan halaman yang
akan diganti dalam penggunaan algoritma-algoritma tersebut bisa dilakukan
dengan berbagai cara, seperti dengan memilih secara acak, memilih dengan
berdasarkan pada penggunaan, umur halaman, dan lain sebagainya. Pemilihan
algoritma yang kurang tepat dapat menyebabkan peningkatan tingkat kesalahan
halaman sehingga proses akan berjalan lebih lambat.
4.2.1 Algoritma Penggantian Page Acak
Setiap terjadi page fault, page yang diganti dipilih secara acak. Teknik ini
tidak memakai informasi apapun dalam menentukan page yang diganti. Semua
page di memori utama mempunyai bobot sama untuk dipilih. Teknik ini dapat
memilih sembarang page, termasuk page yang sedang diacu (page yang
seharusnya tidak diganti, pilihan terburuk). Teknik ini sangat buruk, percobaan
menunjukkan algoritma acak menimbulkan rate terjadinya page fault yang sangat
tinggi.
4.2.2 Algoritma FIFO
Algoritma FIFO merupakan algoritma paling sederhana. Algoritma FIFO
diasosiasikan dengan sebuah page bila page tersebut dibawa ke memori. Bila ada
suatu page yang akan ditempatkan, maka posisi page yang paling lama akan
digantikan. Algoritma ini tidak perlu menyimpan waktu pada saat sebuah page
dibawa ke memori. Ilustrasi algoritma FIFO dapat dilihat pada Gambar 2.3
11
Gambar 4-3 Algoritma page replacement FIFO
Implementasi algoritma FIFO dilakukan dengan menggunakan antrian
untuk menandakan halaman yang sedang berada di dalam memori. Setiap halaman
baru yang diakses diletakkan di bagian belakang (ekor) dari antrian. Apabila
antrian telah penuh dan ada halaman yang baru diakses maka halaman yang
berada di bagian depan (kepala) dari antrian akan diganti.
Kelemahan dari algoritma FIFO adalah kinerjanya yang tidak selalu baik.
Hal ini disebabkan karena ada kemungkinan halaman yang baru saja keluar dari
memori ternyata dibutuhkan kembali. Di samping itu dalam beberapa kasus,
tingkat kesalahan halaman justru bertambah seiring dengan meningkatnya jumlah
frame, yang dikenal dengan nama anomali Belady.Sebagai contoh, jika
menggunakan string acuan:
1, 2, 3, 4, 1, 2, 5, 1, 2, 5, 1, 2, 3, 4, 5
Dengan algoritma FIFO terjadi Belady’s anomaly seperti Gambar 2.4
12
Gambar 4-4 Belady’s anomaly
4.2.3 Algoritma Optimal
Algoritma optimal merupakan hasil penemuan dari Belady’s anomaly.
Algoritma optimal pada prinsipnya akan mengganti halaman yang tidak akan
digunakan untuk jangka waktu yang paling lama. Kelebihannya antara lain dapat
menghindari terjadinya anomali Belady dan juga memiliki tingkat kesalahan
halaman yang terendah diantara algoritma-algoritma pemindahan halaman yang
lain. Algoritma ini menjamin rata-rata page fault terendah untuk jumlah frame
tetap. Meski pun tampaknya mudah untuk dijelaskan, tetapi algoritma ini sulit atau
hampir tidak mungkin untuk diimplementasikan karena sistem operasi harus dapat
mengetahui halaman-halaman mana saja yang akan diakses berikutnya, padahal
sistem operasi tidak dapat mengetahui halaman yang muncul di waktu yang akan
datang. Ilustrasi dari algoritma optimal dapat dilihat pada Gambar 2.5
13
Gambar 4-5 Algoritma page replacement optimal
4.2.4 Algoritma Least Recently Use (LRU)
Algoritma LRU merupakan perpaduan dari algoritma FIFO dan optimal.
Prinsip dari agoritma LRU adalah mengganti page yang sudah tidak digunakan
untuk periode waktu terlama. Ilustrasi algoritma LRU dapat dilihat pada Gambar
2.6
Gambar 4-6 Algoritma page replacement LRU
Untuk mengimplementasikan algoritma LRU, digunakan dua model, yaitu:
Counter
Cara ini dilakukan dengan menggunakan counter atau logical clock. Setiap
halaman memiliki nilaiyang pada awalnya diinisialisasi dengan 0. Ketika
mengakses ke suatu halaman baru, nilai pada clock di halaman tersebut
akan bertambah 1. Untuk melakukan hal itu dibutuhkan extra write ke
memori. Halaman yang diganti adalah halaman yang memiliki nilai clock
14
terkecil. Kekurangan dari cara ini adalah hanya sedikit sekali mesin yang
mendukung hardware counter.
Stack
Cara ini dilakukan dengan menggunakan stack yang menandakan
halaman-halaman yang berada dimemori. Setiap kali suatu halaman
diakses, akan diletakkan di bagian paling atas stack. Apabila ada halaman
yang perlu diganti, maka halaman yang berada di bagian paling bawah
stack akan diganti sehingga setiap kali halaman baru diakses tidak perlu
mencari kembali halaman yang akan diganti. Dibandingkan
pengimplementasian dengan counter, cost untuk mengimplementasikan
algoritma LRU dengan menggunakan stack akan lebih mahal karena isi
stack harus di-update setiap kali mengakses halaman.
Gambar 4-7 Implementasi LRU menggunakan stack
4.2.5 Algoritma Perkiraan LRU
Pada dasarnya algoritma perkiraan LRU memiliki prinsip yang sama dengan
algoritma LRU, yaitu halaman yang diganti adalah halaman yang tidak digunakan
dalam jangka waktu terlama, hanya saja dilakukan modifikasi pada algoritma ini
untuk mendapatkan hasil yang lebih baik. Perbedaannya dengan algoritma LRU
15
terletak pada penggunaan bit acuan. Setiap halaman yang berbeda memiliki bit
acuan. Pada awalnya bit acuan diinisialisasikan oleh perangkat keras dengan nilai
0. Nilainya akan berubah menjadi 1 bila dilakukan akses ke halaman tersebut.
Ada beberapa cara untuk mengimplementasikan algoritma ini, yaitu:
Algoritma NFU (Not Frequently Used)
Pada prinsipnya algoritma LRU dapat diimplementasikan, jika ada mesin
yang menyediakan hardware counter atau stack seperti yang digunakan
pada LRU. Pendekatan lainnya adalah dengan mengimplementasikannya
pada software. Salah satu solusinya disebut algoritma NFU (Not
Frequently Used).
Seperti LRU, NFU juga menggunakan counter tapi counter ini
diimplementasikan pada software. Setiap halaman memiliki counter, yang
diinisiasi dengan nol. Pada setiap clock interval, semua halaman yang
pernah diakses pada interval tersebut akan ditambah nilai counter-nya
dengan bit R, yang bernilai 0 atau 1. Maka, halaman dengan nilai counter
terendah akan diganti.
Kelemahan NFU adalah NFU menyimpan informasi tentang sering-
tidaknya sebuah halaman diakses tanpa mempertimbangkan rentang waktu
penggunaan. Jadi, halaman yang sering diakses pada pass pertama akan
dianggap sebagai halaman yang sangat dibutuhkan pada pass kedua,
walaupun halaman tersebut tidak lagi dibutuhkan pada pass kedua karena
nilai counter-nya tinggi. Hal ini dapatmengurangi kinerja algoritma
ini.Setiap halaman akan memiliki bit acuan yang terdiri dari 8 bit byte
sebagai penanda. Pada awalnya semua bit nilainya 0, contohnya :
00000000. Setiap selang beberapa waktu, pencatat waktu melakukan
interupsi kepada sistem operasi, kemudian sistem operasi menggeser 1 bit
ke kanan dengan bit yang paling kiri adalah nilai dari bit acuan, yaitu bila
halaman tersebut diakses nilainya 1 dan bila tidak diakses nilainya 0. Jadi
16
halaman yang selalu digunakan pada setiap periode akan memiliki nilai
11111111. Halaman yang diganti adalah halaman yang memiliki nilai
terkecil.
Algoritma Aging
Algoritma Aging adalah turunan dari NFU yang mempertimbangkan
rentang waktu penggunaan suatu halaman. Tidak seperti NFU yang hanya
menambahkan bit R pada counter, algoritma ini menggeser bit counter ke
kanan (dibagi 2) dan menambahkan bit R di paling kiri bit counter.
Halaman yang akan diganti adalah halaman yang memiliki nilai counter
terendah. Contoh, jika suatu halaman diakses pada interval pertama, tidak
diakses dalam dua interval selanjutnya, diakses pada dua interval
berikutnya, tidak diakses dalam interval berikutnya, dan seterusnya, maka
bit R dari halaman itu: 1, 0, 0, 1, 1, 0, .... Dengan demikian counter-nya
akan menjadi: 10000000, 01000000, 00100000, 10010000, 11001000,
01100100, ...
Algoritma ini menjamin bahwa halaman yang paling baru diakses,
walaupun tidak sering diakses, memiliki prioritas lebih tinggi dibanding
halaman yang sering diakses sebelumnya. Yang perlu diketahui, aging
dapat menyimpan informasi pengaksesan halaman sampai 16 atau 32
interval sebelumnya. Hal ini sangat membantu dalam memutuskan
halaman mana yang akan diganti. Dengan demikian, aging menawarkan
kinerja yang mendekati optimal dengan harga yang cukup rendah.
Algoritma Second-Chance
Algoritma ini adalah modifikasi dari FIFO yang, seperti namanya,
memberikan kesempatan kedua bagi suatu halaman untuk tetap berada di
dalam memori karena halaman yang sudah lama berada di memori
mungkin saja adalah halaman yang sering digunakan dan akan digunakan
lagi. Kesempatan kedua itu direalisasikan dengan adanya bit acuan yang
di-set untuk suatu halaman. Penempatan halaman pada antrian sama
seperti pada FIFO, halaman yang lebih dulu diakses berada di depan
17
antrian dan yang baru saja diakses berada di belakang antrian. Ketika
terjadi kesalahan halaman, algoritma ini tidak langsung mengganti
halaman di depan antrian tapi terlebih dahulu memeriksa bit acuannya.
Jika bit acuan = 0, halaman tersebut akan langsung diganti. Jika bit acuan
= 1, halaman tersebut akan dipindahkan ke akhir antrian dan bit acuannya
diubah menjadi 0, kemudian mengulangi proses ini untuk halaman yang
sekarang berada di depan antrian.
Algoritma ini dapat terdegenerasi menjadi FIFO ketika semua bit acuan di-
set 1. Ketika halaman pertama kembali berada di awal antrian, bit acuan
pada semua halaman sudah diubah menjadi 0, sehingga halaman pertama
langsung diganti dengan halaman baru. Proses pemindahan halaman yang
diberi kesempatan kedua akan membuat algoritma menjadi tidak efisien
karena harus terus memindahkan halaman dalam antrian. Untuk mengatasi
masalah ini, digunakan antrian berbentuk lingkaran yang dijelaskan pada
algoritma di bawah ini.
Pengimplementasian algoritma ini dilakukan dengan menyimpan halaman
pada sebuah linked-list dan halaman-halaman tersebut diurutkan
berdasarkan waktu ketika halaman tersebut tiba di memori yang berarti
menggunakan juga prinsip algoritma FIFO disamping menggunakan
algoritma LRU. Apabila nilai bit acuan-nya 0, halaman dapat diganti. Dan
apabila nilai bit acuan-nya 1, halaman tidak diganti tetapi bit acuan diubah
menjadi 0 dan dilakukan pencarian kembali.
Algoritma Clock (Algoritma Second Chance yang diperbaiki)
Meskipun algoritma second-chance sudah cukup baik, namun pada
kenyataannya penggunaan algortima tersebut tidak efisien. Algoritma
clock adalah penyempurnaan dari algoritma tersebut. Seperti yang
disebutkan di atas, algoritma Clock Halaman (atau Clock saja)
menggunakan prinsip Second-Chance tapi dengan antrian yang berbentuk
melingkar. Pada antrian ini terdapat pointer yang menunjuk ke halaman
yang paling lama berada di antrian. Ketika terjadi kesalahan halaman,
18
halaman yang ditunjuk oleh pointer akan diperiksa bit acuannya seperti
pada Second-Chance. Jika bit acuan = 0, halaman tersebut akan langsung
diganti. Jika bit acuan = 1, bit acuannya diubah menjadi 0 dan pointer akan
bergerak searah jarum jam ke halaman yang berada di sebelahnya.
Penggunaan antrian berbentuk melingkar menyebabkan halaman tidak
perlu dipindahkan setiap saat, yang bergerak cukup pointer saja. Meski
pun algoritma second-chance sudah cukup baik, namun pada kenyataannya
penggunaan algortima tersebut tidak efisien. Algoritma clock adalah
penyempurnaan dari algoritma tersebut. Pada prinsipnya kedua algoritma
tersebut sama, hanya terletak perbedaan pada pengimplementasiannya
saja. Algortima ini menggunakan antrian melingkar yang berbentuk seperti
jam dengan sebuah penunjuk yang akan berjalan melingkar mencari
halaman untuk diganti.
Pada prinsipnya kedua algoritma tersebut sama, hanya terletak perbedaan
pada pengimplementasiannya saja. Algoritma ini digunakan dalam skema
manajemen memori virtul Macintosh
4.2.6 Algoritma NRU (Not Recently Used)
Dalam algoritma ini terdapat bit acuan dan bit modifikasi yang akan di-
update setiap kali mengakses halaman.Algoritma NRU mudah untuk dimengerti,
efisien, dan memiliki kinerja yang cukup baik. Algoritma ini mempertimbangkan
2 hal sekaligus, yaitu bit acuan dan bit modifikasi. Ketika terjadi kesalahan
halaman, sistem operasi memeriksa semua halaman dan membagi halaman-
halaman tersebut ke dalam 4 kelas:
o Kelas 1: Tidak digunakan dan tidak dimodifikasi, bit terbaik untuk
dipindahkan.
o Kelas 2: Tidak digunakan tapi dimodifikasi, tidak terlalu baik
untuk dipindahkan karena halaman ini perlu ditulis sebelum
dipindahkan.
19
o Kelas 3: Digunakan tapi tidak dimodifikasi, ada kemungkinan
halaman ini akan segera digunakan lagi.
o Kelas 4: Digunakan dan dimodifikasi, halaman ini mungkin akan
segera digunakan lagi dan halaman ini perlu ditulis ke disk
sebelum dipindahkan.
Halaman yang akan diganti adalah halaman dari kelas yang paling rendah.
Jika terdapat lebih dari satu kelas terendah yang sama, maka sistem operasi akan
memilih secara acak
4.2.7 Algoritma Counting
Dilakukan dengan menyimpan pencacah dari nomor acuan yang sudah
dibuat untuk masing-masing halaman. Penggunaan algoritma ini memiliki
kekurangan yaitu lebih mahal. Algoritma Counting dapat dikembangkan menjadi
2 skema dibawah ini:
Algoritma LFU (Least Frequently Used)
Halaman yang diganti adalah halaman yang paling sedikit dipakai (nilai
pencacah terkecil) dengan alasan bahwa halaman yang digunakan secara
aktif akan memiliki nilai acuan yang besar.
Algoritma MFU (Most Frequently Used)
Halaman yang diganti adalah halaman yang paling sering dipakai (nilai
pencacah terbesar) dengan alasan bahwa halaman dengan nilai terkecil
mungkin baru saja dimasukkan dan baru digunakan
4.2.8 Algoritma Page Buffering
Pada algoritma ini, sistem menyimpan pool dari frame yang kosong dan
dijadikan sebagai buffer. Prosedur ini memungkinkan suatu proses mengulang
dari awal secepat mungkin, tanpa perlu menunggu halaman yang akan
20
dipindahkan untuk ditulis ke disk karena frame-nya telah ditambahkan ke dalam
pool frame kosong.
Kelebihan algoritma ini adalah dapat membuat proses lebih cepat
dikembalikan ke status ready queue, namun akan terjadi penurunan kinerja karena
sedikit sekali halaman yang digunakan sehingga halaman lain yang tidak
digunakan menjadi sia-sia (utilitas sistem rendah).
Teknik seperti ini digunakan dalam sistem VAX/ VMS, dengan algoritma
FIFO. Ketika algoritma FIFO melakukan kesalahan dengan memindahkan
halaman yang masih digunakan secra aktif, halaman tersebut akan dengan cepat
diambil kembali dari penyangga frame-kosong, untuk melakukan hal tersebut
tidak ada I/O yang dibutuhkan. Metode ini diperlukan olehVAX karena versi
terbaru dariVAX tidak mengimplementasikan bit acuan secara tepat.
4.3 ALOKASI FRAME
Hal yang mendasari strategi alokasi frame yang menyangkut memori virtual
adalah bagaimana membagi memori yang bebas untuk beberapa proses yang
sedang dikerjakan.
Alokasi frame berhubungan dengan mekanisme alokasi sejumlah memori
bebas yang tetap diantara beberapa proses. Meskipun terdapat beberapa variasi
pengalokasian frame bebas ke beberapa proses, tetapi strategi dasar jelas yaitu :
proses user dialokasikan untuk sembarang frame bebas.
4.3.1 Jumlah Frame Minimum
Jumlah minimum frame per proses ditentukan oleh arsitektur dimana jumlah
maksimum tergantung jumlah memori fisik yang tersedia. Jumlah minimum frame
ditentukan oleh arsitektur instruction-set. Bila terjadi page fault sebelum eksekusi
instruksi selesai, instruksi harus di-restart. Sehingga tersedia frame yang cukup
untuk membawa semua page yang berbeda dimana sembarang instruksi dapat
mengacu.
Misalnya mikrokomputer menggunakan memori 128K yang dikomposisikan
dengan page ukuran 1K, maka terbentuk 128 frame. Jika sistem operasi
21
menggunakan 35K, maka 93 frame sisa digunakan program user. Bila suatu
program menyebabkan page fault sebanyak 93 kali, maka menempati 93 frame
bebas tersebut. Jika terjadi page fault ke 94, dari 93 frame yang terisi harus dipilih
salah satu untuk diganti yang baru. Bila program selesai, 93 frame tersebut
dibebaskan kembali.
Kesimpulannya, jumlah minimum frame yang dibutuhkan per proses
tergantung dari arsitektur komputer tersebut, sementara jumlah maksimumnya
ditentukan oleh jumlah memori fisik yang tersedia. Di antara kedua jumlah
tersebut, kita punya pilihan yang besar untuk alokasi frame.
4.3.2 Algoritma Alokasi
4.3.2.1 Algoritma Fixed Allocation
Terdapat 2 bentuk algoritma fixed allocation yaitu equal allocation dan
proportional allocation. Pada equal allocation, jika terdapat m frame dan n
proses, maka setiap proses dialokasikan sejumlah frame yang sama (m/n frame).
Pada proportional allocation setiap proses dialokasikan secara proporsional
berdasarkan ukurannya. Jika ukuran virtual memori untuk proses pi adalah si dan
total jumlah frame yang tersedia m, maka frame ke ai dapat dialokasikan ke
proses pi sama dengan :
ai=si/S x m
Dimana S = Σsi. Contohnya :
m=64
s1=10
s2=127
a1=10
137x64≈5
a2=127137
x64≈59
22
4.3.2.2 Algoritma Priority Allocation
Algoritma priority allocation merupakan algoritma pengalokasian dengan
memberikan jumlah bingkai sesuai dengan prioritas proses tersebut.
Pendekatannya mirip dengan proportional allocation, perbandingan frame-nya
tidak tergantung ukuran relatif dari proses, melainkan lebih pada prioritas proses
atau kombinasi ukuran dan prioritas. Jika suatu proses mengalami page fault maka
proses tersebut akan menggantinya dengan salah satu frame yang dimiliki proses
tersebut atau menggantinya dengan frame dari proses yang prioritasnya lebih
rendah.
Dengan kedua algoritma di atas, tetap saja alokasi untuk tiap proses bisa
bervariasi berdasarkan derajat multiprogrammingnya. Jika multiprogrammingnya
meningkat maka setiap proses akan kehilangan beberapa frame yang akan
digunakan untuk menyediakan memori untuk proses lain. Sedangkan jika derajat
multiprogramming-nya menurun, frame yang sudah dialokasikan bisa disebar ke
proses-proses lainnya.
4.3.3 Alokasi Global dan Alokasi Lokal
Page replacement adalah faktor terpenting lain yang harus dipertimbangkan
dalam alokasi frame. Pada multiple process yang berkompentisi mendapatkan
frame, algoritma page replacement dikelompokkan dalam 2 kategori yaitu global
replacement dan local replacement.
Global replacement mengijinkan suatu proses untuk menyeleksi suatu frame
yang akan dipindah dari sejumlah frame, meskipun frame tersebut sedang
dialokasikan ke proses yang lain. Pada local replacement, jumlah frame yang
dialokasikan untuk proses tidak berubah. Setiap proses dapat memilih dari frame-
frame yang dialokasikan untuknya.
Permasalahan pada global replacement adalah proses tidak dapat
mengontrol rata-rata page fault. Sejumlah page pada memori untuk sebuah proses
tidak hanya tergantung pada perilaku paging untuk proses tersebut, tetapi juga
perilaku paging untuk proses yang lain. Bagaimanapun, karena algoritma global
23
replacement menghasilkan throughput yang lebih besar, metode ini sering
digunakan.
4.4 THRASHING
Kegiatan aktifitas paging yang tinggi disebut thrashing. Sebuah proses
mengalami thrashing jika menghabiskan lebih banyak waktu untuk paging
daripada eksekusi. Efek thrashing dapat dibatasi dengan menggunakan algoritma
local (priority) replacement.
Misalnya sembarang proses tidak mempunyai frame yang cukup. Meskipun
secara teknis dapat mengurangi jumlah frame yang dialokasikan sampai
minimum, terdapat sejumlah page yang sedang aktif digunakan. Jika suatu proses
tidak memiliki jumlah frame yang cukup, maka sering terjadi page fault. Sehingga
harus mengganti beberapa page. Tetapi karena semua page sedang digunakan,
harus mengganti page yang tidak digunakan lagi kemudian. Konsekuensinya,
sering terjadi page fault lagi dan lagi. Proses berlanjut page fault, mengganti page
untuk page fault dan seterusnya.
4.4.1 Penyebab Trhashing
Penyebab dari thrashing adalah utilisasi CPU yang rendah. Jika utilisasi
CPU terlalu rendah, kita menambahkan derajat dari multiprogramming dengan
menambahkan proses baru ke sistem. Sejalan dengan bertambahnya derajat dari
multiprogramming, utilisasi CPU juga bertambah dengan lebih lambat sampai
maksimumnya dicapai. Jika derajat dari multiprogramming ditambah terus
menerus, utilisasi CPU akan berkurang dengan drastis dan terjadi thrashing.
Untuk menambah utilisasi CPU dan menghentikan thrashing, kita harus
mengurangi derajat dari multiprogramming.
Grafik terjadinya proses thrashing pada sistem multiprogramming dapat
dilihat pada Gambar 2.8
24
Gambar 4-8 Thrashing
Utilitas dari CPU selalu diharapkan tinggi hingga mendekati 100%. Jika
proses yang dikerjakan CPU hanya sedikit, maka kita tidak bisa menjaga agar
CPU sibuk. Utilitas dari CPU bisa ditingkatkan dengan meningkatkan jumlah
proses. Jika Utilitas CPU rendah, maka sistem akan menambah derajat dari
multiprogramming yang berarti menambah jumlah proses yang sedang berjalan.
Pada titik tertentu, menambah jumlah proses justru akan menyebabkan utilitas
CPU turun drastis dikarenakan proses-proses yang baru tidak mempunya memori
yang cukup untuk berjalan secara efisien. Pada titik ini terjadi aktifitas
penghalamanan yang tinggi yang akan menyebabkan thrashing.
Ketika sistem mendeteksi bahwa utilitas CPU menurun dengan
bertambahnya proses, maka sistem meningkatkan lagi derajat dari
multiprogramming. Proses- proses yang baru berusaha merebut frame-frame yang
telah dialokasikan untuk proses yang sedang berjalan. Hal ini mengakibatkan
kesalahan halaman meningkat tajam. Utilitas CPU akan menurun dengan sangat
drastis diakibatkan oleh sistem yang terus menerus menambah derajat
multiprogramming.
25
4.4.2 Membatasi Efek Trhashing
Efek dari thrashing dapat dibatasi dengan algoritma pergantian lokal atau
prioritas. Dengan pergantian lokal, jika satu proses mulai thrashing, proses
tersebut dapat mengambil frame dari proses yang lain dan menyebabkan proses
itu tidak langsung thrashing. Jika proses mulai thrashing, proses itu akan berada
pada antrian untuk melakukan penghalamanan yang mana hal ini memakan
banyak waktu. Rata-rata waktu layanan untuk kesalahan halaman akan bertambah
seiring dengan makin panjangnya rata-rata antrian untuk melakukan
penghalamanan. Maka, waktu akses efektif akan bertambah walau pun untuk
suatu proses yang tidak thrashing.
Salah satu cara untuk menghindari thrashing, kita harus menyediakan
sebanyak mungkin frame sesuai dengan kebutuhan suatu proses. Cara untuk
mengetahui berapa frame yang dibutuhkan salah satunya adalah dengan strategi
Working Set.
Selama satu proses di eksekusi, model lokalitas berpindah dari satu lokalitas
satu ke lokalitas lainnnya. Lokalitas adalah kumpulan halaman yang aktif
digunakan bersama. Suatu program pada umumnya dibuat pada beberapa lokalitas
sehingga ada kemungkinan terjadi overlap. Thrashing dapat muncul bila ukuran
lokalitas lebih besar dari ukuran memori total.
4.4.3 Model Working Set
Strategi Working set dimulai dengan melihat berapa banyak frame yang
sesungguhnya digunakan oleh suatu proses. Working set model mengatakan
bahwa sistem hanya akan berjalan secara efisien jika masing-masing proses
diberikan jumlah halaman frame yang cukup. Jika jumlah frame tidak cukup
untuk menampung semua proses yang ada, maka akan lebih baik untuk
menghentikan satu proses dan memberikan halamannya untuk proses yang lain.
26
Working set model merupakan model lokalitas dari suatu eksekusi proses.
Model ini menggunakan parameter (delta) untuk mendefinisikan working set
window. Untuk menentukan halaman yang dituju, yang paling sering muncul.
Kumpulan dari halaman dengan halaman yang dituju yang paling sering muncul
disebut working set. Working set adalah pendekatan dari program lokalitas.
Contoh :
Keakuratan working set tergantung pada pemilihan .
1. Jika terlalu kecil, tidak akan dapat mewakilkan keseluruhan dari
lokalitas.
2. Jika terlalu besar, akan menyebabkan overlap beberapa lokalitas.
3. Jika tidak terbatas, working set adalah kumpulan page sepanjang
eksekusi program.
Jika kita menghitung ukuran dari Working Set, WWSi, untuk setiap proses
pada sistem, kita hitung dengan D = WSSi, dimana D merupakan total demand
untuk frame.
Jika total perminataan lebih dari total banyaknya frame yang tersedia (D >
m), thrashing dapat terjadi karena beberapa proses akan tidak memiliki frame
yang cukup. Jika hal tersebut terjadi, dilakukan satu pengeblokan dari proses-
proses yang sedang berjalan.
Strategi Working Set menangani thrashing dengan tetap mempertahankan
derajat dari multiprogramming setinggi mungkin.
Contoh : = 1000 referensi, Penghitung interupsi setiap 5000 referensi.
Ketika kita mendapat interupsi, kita menyalin dan menghapus nilai bit
referensi dari setiap halaman. Jika kesalahan halaman muncul, kita dapat
menentukan bit referensi sekarang dan 2 pada bit memori untuk memutuskan
27
apakah halaman itu digunakan dengan 10000 ke 15000 referensi terakhir. Jika
digunakan, paling sedikit satu dari bit-bit ini akan aktif. Jika tidak digunakan, bit
ini akan menjadi tidak aktif. Halaman yang memiliki paling sedikit 1 bit aktif,
akan berada di working-set. Hal ini tidaklah sepenuhnya akurat karena kita tidak
dapat memberitahukan dimana pada interval 5000 tersebut, referensi muncul. Kita
dapat mengurangi ketidakpastian dengan menambahkan sejarah bit kita dan
frekuensi dari interupsi.
Contoh: 20 bit dan interupsi setiap 1500 referensi.
4.4.4 Frekuensi Kesalahan Halaman
Working-set dapat berguna untuk prepaging, tetapi kurang dapat
mengontrol thrashing. Strategi menggunakan frekuensi kesalahan halaman
mengambil pendekatan yang lebih langsung.
Thrashing memiliki kecepatan kasalahan halaman yang tinggi. Kita ingin
mengontrolnya. Ketika terlalu tinggi, kita mengetahui bahwa proses
membutuhkan frame lebih. Sama juga, jika terlalu rendah, maka proses mungkin
memiliki terlalu banyak frame. Kita dapat menentukan batas atas dan bawah pada
kecepatan kesalahan halaman seperti terlihat pada Gambar 2.9
28
Gambar 4-9 Jumlah Frame
Jika kecepatan kesalahan halaman yang sesungguhnya melampaui batas
atas, kita mengalokasikan frame lain ke proses tersebut, sedangkan jika kecepatan
kesalahan halaman di bawah batas bawah, kita pindahkan frame dari proses
tersebut. Maka kita dapat secara langsung mengukur dan mengontrol kecepatan
kesalahan halaman untuk mencegah thrashing.
29
5 KESIMPULAN
Memori virtual adalah suatu teknik yang memisahkan memori logis dan
memori fisiknya. Hal ini dilakukan untuk menambah kapasitas memori utama
sehingga dapat menampung lebih banyak program.
Memori virtual diimplementasikan dengan beberapa cara. Salah satunya
adalah page replacement. Page replacement adalah pergantian halaman untuk
menangani page fault yang terjadi. Ada beberapa algoritma page replacement
yang digunakan. Sebagian besar diantaranya merupakan perbaikan dari algoritma
sebelumnya. Page fault yang terlalu banyak dapat menyebabkan trhashing yang
dapat menurunkan utilitas CPU.
30
DAFTAR PUSTAKA
Buku Sistem Operasi (Bahan Kuliah IKI-20230), Gabungan Kelompok Kerja 21-
28 Semester Genap 2002/2003
Avi Silberschatz, Peter Galvin, dan Greg Gagne, 2000, Applied Operating
Systems: First Edition, John Wiley & Sons.
Silberschatz, Galvin, Gagne. 2002. Operating System Concepts : 6th ed. John
Wiley & Sons
31
Tanenbaum,Andrew S. Woodhull, Albert S. 1997. Operating Systems Design and
Implementation: Second Edition. Prentice Hall.
[Silberschatz2005] Avi Silberschatz, Peter Galvin, dan Grag Gagne. 2005. Operating Systems Concepts. Seventh Edition. John Wiley & Sons.
[Tanenbaum1997] Andrew S Tanenbaum dan Albert S Woodhull. 1997. Operating Systems Design and Implementation. Second Edition. Prentice-Hall.
[WEBAmirSch2000] Yair Amir dan Theo Schlossnagle. 2000. Operating Systems 00.418: Memory Management http://www.cs.jhu.edu/ ~yairamir/ cs418/ os5/ . Diakses 18 Mret 2012.
[WEBCACMF1961] John Fotheringham. “ Dynamic Storage Allocation in the Atlas Computer Including an Automatic Use of a Backing Store http://www.eecs.harvard.edu/ cs261/ papers/ frother61.pdf ”. Diakses 29 Juni 2006. Communications of the ACM . 4. 5 Maret 2012
[WEBFunkhouser2002] Thomas Funkhouser. 2002. Computer Science 217 Introduction to Programming Systems: Memory Paging http://www.cs.princeton.edu/ courses/ archive / spring02/ cs217/ lectures/ paging.pdf . Diakses 28 Februari 2012.
[WEBGottlieb2000] Allan Gottlieb. 2000. Operating Systems: Page tables http://allan.ultra.nyu.edu/ ~gottlieb/ courses/ 1999-00-spring/ os/ lecture-11.html . Diakses 29 februari 2012.
[WEBHP1997] Hewlett-Packard Company. 1997. HP-UX Memory Management Overview of Demand Paging http://docs.hp.com/en/5965-4641/ch01s10.html . Diakses 1 Maret 2012
[WEBJupiter2004] Jupitermedia Corporation. 2004. Virtual Memory http://www.webopedia.com/ TERM/ v/ virtual_memory.html . Diakses 1 Maret 2012
[WEBOCWEmer2005] Joel Emer dan Massachusetts Institute of Technology. 2005. OCW Computer System Architecture Fall 2005 Virtual Memory Basics http://ocw.mit.edu/ NR/ rdonlyres/ Electrical -Engineering -and -Computer -Science/ 6 -823Computer -System -ArchitectureSpring2002/ C63EC0D0 -0499 -474F -BCDA -A6868A6827C4/ 0/ lecture09.pdf . Diakses 1 Maret 2012
[WEBRegehr2002] John Regehr dan University of Utah. 2002. CS 5460 Operating Systems Demand Halamand Virtual Memory http://www.cs.utah.edu/ classes/ cs5460-regehr/ lecs/ demand_paging.pdf . Diakses 1 Maret 2012.
32
[WEBSolomon2004] Marvin Solomon. 2004. CS 537 Introduction to Operating Systems: Lecture Notes Part 7 http://www.cs.wisc.edu/ ~solomon/ cs537/ paging.html . Diakses 29 Februari 2012
[WEBKUSJOKO2004] Kuspriyanto dan Putut Joko Wibowo. 2004. Desain Memori Virtual Pada Mikroarsitektur PowerPC, MIPS, Dan X86 http://www.geocities.com/transmisi_eeundip/kuspriyanto.pdf . Diakses 2 Maret 2012
http://limited.vlsm.org/v01/os/BahanKuliah/ppt/index.html
http://css.uni.edu
allan.ultra.nyu.edu/~gottlieb/courses/ 1999-00-spring/os/lecture-11.html
http://www.cs.wisc.edu/~solomon/cs537/paging.html
http://www.cs.princeton.edu/courses/archive/spring02/cs217/lectures/paging.pdf
http://cwx.prenhall.com/bookbind/pubbooks/tanenbaum/chapter0/deluxe.html
http://www.cs.jhu.edu/~yairamir/cs418/os5/
33