Makalah Virtual Memori

47
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 : I 2 Dosen Pembimbing : Sila Abdullah Syakri, ST,MT POLITEKNIK NEGERI LHOKSEUMAWE 2012

description

ww

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