Anda di halaman 1dari 34

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 Dosen Pembimbing : I2 : Sila Abdullah Syakri, ST,MT

POLITEKNIK NEGERI LHOKSEUMAWE 2012

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
1 2 3

DAFTAR ISI

ABSTRAK .......................................................................................................1 DAFTAR ISI ...................................................................................................2 PENDAHULUAN ...........................................................................................4 3.1 3.2 3.3 3.4 Latar Belakang ......................................................................................... 4 Rumusan Masalah .................................................................................... 5 Metode Penulisan ..................................................................................... 5 Hasil Yang Diharapkan ............................................................................ 6

TEORI .............................................................................................................7 4.1 Pengertian ................................................................................................. 7

4.2 Algoritma Page Replacement ................................................................. 10 4.2.1 Algoritma Penggantian Page Acak ..................................................... 12 4.2.2 Algoritma FIFO .................................................................................. 12 4.2.3 Algoritma Optimal .............................................................................. 14 4.2.4 Algoritma Least Recently Use (LRU) ................................................ 14 4.2.5 Algoritma Perkiraan LRU ................................................................... 16 4.2.6 Algoritma NRU (Not Recently Used) ................................................ 20 4.2.7 Algoritma Counting ............................................................................ 21 4.2.8 Algoritma Page Buffering ................................................................... 21 4.3 ALOKASI FRAME ................................................................................ 22 4.3.1 Jumlah Frame Minimum ..................................................................... 22 4.3.2 Algoritma Alokasi............................................................................... 23 4.3.2.1 Algoritma Fixed Allocation......................................................... 23 4.3.2.2 Algoritma Priority Allocation ..................................................... 23 4.3.3 Alokasi Global dan Alokasi Lokal...................................................... 24 4.4 THRASHING ......................................................................................... 24 4.4.1 Penyebab Trhashing ............................................................................ 25 4.4.2 Membatasi Efek Trhashing ................................................................. 26 4.4.3 Model Working Set ............................................................................. 27 4.4.4 Frekuensi Kesalahan Halaman............................................................ 29 5 KESIMPULAN .............................................................................................31

DAFTAR GAMBAR

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 Beladys 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 3.1 Latar Belakang

PENDAHULUAN

Selama bertahun-tahun,pelaksanaan manajemen memori pada intinya adalah dengan menempatkan semua bagian proses yang akan dijalankan ke dalam 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 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.

4 4.1 Pengertian

TEORI

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 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.
7

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 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

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 Replacement


Terdapat 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 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,

10

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

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

11

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

Gambar 4-3 Algoritma page replacement FIFO

12

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 Beladys anomaly seperti Gambar 2.4

Gambar 4-4 Beladys anomaly

13

4.2.3 Algoritma Optimal


Algoritma optimal merupakan hasil penemuan dari Beladys 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

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

14

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 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

15

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 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

16

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 seringtidaknya 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 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

17

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 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 diset 1. Ketika halaman pertama kembali berada di awal antrian, bit acuan pada semua halaman sudah diubah menjadi 0, sehingga halaman pertama

18

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, 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

19

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 diupdate 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 halamanhalaman tersebut ke dalam 4 kelas:
o

Kelas 1: Tidak digunakan dan tidak dimodifikasi, bit terbaik untuk dipindahkan.

Kelas 2: Tidak digunakan tapi dimodifikasi, tidak terlalu baik untuk dipindahkan karena halaman ini perlu ditulis sebelum dipindahkan.

Kelas 3: Digunakan tapi tidak dimodifikasi, ada kemungkinan halaman ini akan segera digunakan lagi.

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

20

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 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
21

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 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.

22

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= a2= x645 x6459

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

23

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 frameframe 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 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

24

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

Gambar 4-8 Thrashing

25

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 bertambahnya sistem mendeteksi maka bahwa sistem utilitas CPU menurun lagi dengan dari

proses,

meningkatkan

derajat

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.

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

26

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. 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.

27

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 prosesproses 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 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.

28

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

Gambar 4-9 Jumlah Frame

29

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.

30

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.

31

DAFTAR PUSTAKA

Buku Sistem Operasi (Bahan Kuliah IKI-20230), Gabungan Kelompok Kerja 2128 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 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.

32

[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. [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