Embed Size (px)
DESCRIPTION
Sistem Operasi
Citation preview
SISTEM OPERASI
Mutual Exclusion Dan Deadlock
Oleh:
Nur Annisa D.A.P 12.5.00172
Nidia Aisyiyah 12.5.00171
Kurnia Matha. H 12.5.00157
Wahyu Ernawati 12.5.00188
Yuniana Arif Z 12.5.00196
SEKOLAH TINGGI MANAJEMEN INFORMATIKA DAN KOMPUTER
STMIK SINAR NUSANTARA
SURAKARTA
2013
Mutual Exclusion
Pentingnya Mutual Exclusion
Mutual Exclusion adalah persoalan untuk menjamin hanya satu proses yang mengakses
sumber daya pada suatu interval waktu tertentu. Pentingnya mutual exclusion dapat
dilihat pada dua ilustrasi berikut ini :
Ilustrasi eksekusi Daemon Printer
Adalah proses penjadwalan dan pengendalian untuk mencetak berkas – berkas
di printer sehingga menjadikan seolah-olah printer dapat digunakan secara
simultan oleh proses-proses. Daemon untuk printer mempunyai ruang
penyimpanan di harddisk (spooler) untuk menyimpan berkas-berkas yang akan
dicetak. Direktori spooler itu terbagi dalam sejumlah slot. Slot berisi satu
berkas yang akan dicetak. Terdapat variable in yang menunjuk slot bebas di
ruang harddisk yang dipakai untuk menyimpan berkas yang hendak dicetak.
Perhatikan program berikut ini :
Gambar 1.1
Skenario yang membuat situasi kacau
Misal proses A dan B ingin mencetak berkas, variable in bernilai 9. Skenario
berikut dapat terjadi, digambar pa gambar dibawah.
Gambar 1.2
Skenario
Proses A membaca variable in bernilai 9. Belum sempat A menyelesaikan
proses, pedjadwalan proses B berjalan. Proses B yang juga ini mencetak segera
membaca variable in, variable in masih bernilai 9. Proses B dapat
menyelesaikan prosesnya.
Pada contoh di atas terdapat kondisi yakni dua proses atau lebih sedang
membaca atau menulis data dengan hasil akhir bergantung jalannya proses-
proses. Kondisi yang tidak dapat diprediksikan hasilnya, bergantung pada
jalannya proses-proses yang bersaing disebut kondisi pacu. Kondisi pacu harus
dihilangkan agar hasil dapat diprediksi dan tidak bergantung jalannya proses-
proses itu.
Pokok penyelesain penghilangan kondisi pacu adalah system harus mencegah
lebih dari satu proses membaca atau menulis data bersama disaat bersamaan.
Persoalan mutul exclusion adalah menjamin hanya satu proses yang sedang
menggunakan sumber daya secara bersamaan. Bagian program yang sedang
mengakses sumber daya yang dipakai bersamaan dapat menimbulkan kondisi
pacu disebut critical section/region.
Untuk mengatasi kondisi pacu harus dijamin tidak terjadi dua proses atau lebih
memasukki critical section yang sama secara bersamaan. Penyelesaian mutual
exclusion merupakan landasan pemrosesan konkuren.
Ilustrasi Aplikasi Tabungan
Misalnya : Rekening A berisi Rp 1.000.000,- yang terdaftar di kantor cabang di
Bandung. Pada suatu saat program aplikasi kantor cabang di Jakarta melayani
penyetoran Rp 3.000.000,- ke rekening A. Program aplikasi membaca saldo
akhir rekening A. Pada waktu hampir bersamaan, di kantor cabang Bandung
juga terjadi transaksi penyetoran Rp 5.000.000 ke rekening A. Program aplikasi
di Bandung memebaca saldo masih Rp 1.000.000.
o Kriteria Penyelesaian Mutual-Exclusion
Kemampuan menjamin mutual exclusion harus memenuhi kriteria-kriteria berikut :
1. Mutual exclusion harus dijamin.
2. Hanya ada satu proses yang diizinkan masuk critical section.
3. Proses yang berada di noncritical section, dilarang mem-block proses-proses lain
yang ingin masuk.
4. Tidak boleh terdapat deadlock atau startvation.
5. Ketika tidak ada proses di critical section maka proses yang ingin masuk critical
section harus diizinkan masuk tanpa waktu tunda.
6. Tidak ada asumsi mengenai kecepatan relative proses.
Kriteria 1 merupakan kriteria pokok yang harus dipenuhi. Metode yang melanggar
kriteria 1 sama sekali tidak dapat digunakan.
Metode –metode Penjamin Mutual Exclusion
a. Metode naïf, metode ini dipelajari untuk memperoleh gambaran mekanisme
penjamin mutual exclusion lebih jelas.
Metode Variabel Lock Sederhana
Metode ini meniru mekanisme penguncian pintu bahwa kunci pintu diganti
variable lock. Variable lock bernilai 0 berarti pintu tidak terkunci, bernilai 1
berarti pintu terkunci. Metode ini gagal karena pengambilan kunci (variable
lock) tidak sama dengan pengmabilan kunci pintu.
Mekanisme yang Diusulkan sebagai Berikut :
Ketika proses hendak masuk critical section, proses lebih dulu memeriksa variable
lock dengan ketentuan sebagai berikut :
Variable lock bernilai 0, proses menge-set variable lock menjadi 1.
Variable lock bernilai 1, proses menunggu sampai nilai variable lock menjadi nol.
Gambar 1.3
Skenario yang memebuat situasi kacau
Metode ini menjamin proses tidak memasuki critical section yang telah dimasuki proses
lain. Saat proses A telah membaca variable lock dan sebelum men-set variable lock
menjadi 1, penjadwal dapat menjadwalkan proses B. Proses B pun membaca variable lock
yang masih bernilai 0 dan masuk critical section, kemudian menggilir A lagi.
Gambar 2.4
Variable lock bernilai 0 maka proses A pun segera masuk critical section yang juga
sedang dimasuki B. secara bersamaan A dan B masuk critical section yang sama. Kriteria
1 terlanggar, metode ini gagal.
Metode untuk situasi Tertentu
Metode bergantian secara ketat
Dapat menggilir proses-prose yang hendak masuk critical secara bergantian terus
menerus
Gambar 2.5
Variable turn(giliaran)
Mencatat (nomor) proses yang sedang masuk criticl section. Diinisialisasi 0.
Skenario yang terjadi adalah
- Proses 0, mememriksa variable trun, bernilai 0 dan segera memasuki critical
section.
- Proses 1, menemukan variable turn brnilai 0, melakukan loop memeriksa variable
trun terus-menerus, memeriksa apakah trun telah bernilai 1.
Busy Waiting
Kondisi memeriksa variable terus-menerus, menunggu sampai suatu nilai muncul
disebut busy waiting. Hanya kalau selang waktu terus menunggu singkat maka metode
dengan busy waiting dapat digunakan.
Skenario yang membuat situasi kacau
Misalnya proses 0 adalah proses cepat, proses 1 adalah proses lambat.
Gambar 1.6
Skenario pelanggaran adalah
Proses 0 meninggalkan critical_section, men-set turn 1, mengijinkan proses 1
memasuki critical_section.
Proses 1 mengakhiri critical_section dengan cepat maka keduanya berada di
noncritical_section dengan variable turn bernliai 0.
Proses 0 kembali memasuki critical_section dengan cepat dan segera memasuki
noncritical_section maka variable turn bernilai 1.
Proses 0 hendak kembali memasuki critical_section tapi variable turn berniali 1
Proses 1 di non_critical_section memblock proses 0 sehingga tidak dapat memasuki
critical_section. Metode ini masih dapat digunakan selama diketahui memang proses-
proses harus secara bergantian memasuki critical section. Cirri-ciri ini adalah untuk
aplikasi batch sekuen seperti pada kompilator seperti pada kompilator dengan banyak
pass.
Metode dengan busy waiting
Dibagian ini kita akan melihat bermacam-macam cara untuk mencapai mutual
exclusion, sehingga ketika sebuah proses sedang memutakhirkan memori yang digunakan
bersama-sama di dalam critical regionnya, tidak akan ada proses lain masuk kedalam
critical regionnya dan membuat masalah.
Disabling Interrupts
Cara yang paling sederhana adalah dengan mentidurkan seluruh interrupts tepat
sesudah masuk kedalam critical regionnya dan mengaktifkannya sesaat sebelum
meninggalkannya. Tanpa interupt aktif maka clock interupt juga tidak akan terjadi. CPU
hanya berpindah dari proses ke proses jika ada interupt clock ataupun lainnya. Jika
interupt dimatikan maka CPU tidak akan berpindah ke proses lainnya. Sehingga jika
sebuah proses telah mematikan interupt maka ia akan dapat melakukan perubahan pada
memori bersama tanpa kuatir proses lain akan mengintervensi.
Pendekatan ini artinya memberikan kemampuan kepada pengguna untuk
menentukan kapan interupt akan diaktifkan atau dinonaktifkan. Pendekatan ini dapat
menyebabkan sebuah aplikasi akan menguasai CPU time. Kalau prosesornya banyak,
akan mengakibatkan prosesor yang melayani aplikasi tersebut akan terkunci, sementara
yang lainnya akan tetap berjalan dan dapat menggunakan memory bersama. Pada
kenyataannya kernel memerlukan kemampuan untuk mematikan interrupt untuk beberapa
instruksi sementara ia melakukan update terhadap beberapa variable. The conclusion is:
disabling interrupts is often a useful technique within the operating system itself but is
not appropriate as a general mutual exclusion mechanism for user processes.
Lock Variables
Cara kedua adalah dengan menggunakan pemecahan secara software. Sebagai contoh
kita akan menggunakan sebuah variable lock :
1. Awalnya berinilai 0.
2. Ketika sebuah proses ingin memasuki critical regionnya, maka akan menguji lock. :
1. Jika lock bernilai 0, maka ia akan merubahnya menjadi 1 dan masuk kedalam
critical region.
2. Jika lock bernilai 1, maka proses tinggal menunggu menjadi 0.
3. Artinya jika bernilai 0 maka tidak ada proses yang berada didalam critical region,
dan 1 artinya ada proses didalam critical region.
3. Permasalahan yang muncul adalah jika ada dua proses membaca variable tersebut sebagai
0 dan kemudian secara bersamaan menggantinya menjadi, maka kedua proses dapat
berada dalam critical region secara bersama-sama.
4. Jika kita membaca lock value terlebih dahulu, dan memeriksanya kembali tepat sebelum
menulis nilai, amak tetap saja tidak akan membantu. Race conditions terjadi jika proses
kedua memodifikasi nilai lock tepat setelah proses pertama melakukan check kedua.
Strict Alternation
Pendekatan ketiga adalah dengan menggunakan strict alternation. Pada gambar Fig. 2-
20, turn, awalnya bernilai 0, digunakan untuk menjejaki siapa yang memperoleh giliran
untuk masuk ke critical region dan memeriksa atau memutakhirkan shared memory.
Awalnya proses 0 memeriksa turn, ternyata bernilai 0, dan masuk ke critical region.
Proses 1 juga menemukan turn juga bernilai 0 dan memeriksa kapankah bernilai 1. Secar
terus menerus menguji variable sampai nilainya berubah : busy waiting. It should
usually be avoided, since it wastes CPU time. Only when there is a reasonable
expectation that the wait will be short is busy waiting used. lock yang menggunakan
busy waiting disebut spin lock.
Figure 2-20. A proposed solution to the critical region problem. (a) Process 0. (b)
Process 1. In both cases, be sure to note the semicolons terminating the while
statements.
Ketika proses 0 leaves meninggalkan critical region, ia merubah nilai turn menjadi 1,
untuk
memungkinkan proses 1 masuk ke critical region. Umpamakan bahwa proses 1
menyelesaikan critical regionnya dengan cepat, maka kedua proses akan berada didalam
noncritical regions, dengan nilai turn : 0. Selanjutnya process 0 menjalankan loopnya
dengan segera dan keluar dari critical regionnya dan turn bernilai 1. Sekarang kedua
proses berada diluar critical regions. Mendadak proses 0 menyelesaikan noncritical
region dan kembali ke awal loop. Tetapi tidak diijinkan untuk masuk ke critical region
sekarang, karena turn bernilai 1 dan proses 1 sibuk dengan noncritical regionnya. Maka
proses 0 akan menjalankan loop untuk menunggu giliran sampai proses 1 merubah nilai
turn menjadi 0. Put differently, taking turns is not a good idea when one of the processes
is much slower than the other.
Situasi ini melanggar aturan 3 : process 0 di block oleh proses yang sedang tidak didalam
critical regionnya. This solution requires that the two processes strictly alternate in
entering their critical regions, it is not really a serious candidate as a solution because it
violates condition 3. Dengan mengkombinasikan lock variable dan warning variables
serta bergiliran. T. Dekker (Dijkstra, 1965), adalah orang pertama yang membuat
pemecahan software untuk mutual exclusion tanpa strict alternation.
1981, G.L. Peterson menemukan cara yang lebih sederhana lagi. Algoritmanya
menggunakan dua fungsi dalam bahasa C
#define FALSE 0
#define TRUE 1
#define N 2 /* number of processes */
int turn; /* whose turn is it? */
int interested[N]; /* all values initially 0 (FALSE) */
void enter_region(int process) /* process is 0 or 1 */
{
int other; /* number of the other process */
/* the opposite of process */
interested[process] = TRUE; /* show that you are interested */
turn = process; /* set flag */
while (turn == process && interested[other] == TRUE) /* null statement */;
}
void leave_region (int process) /* process, who is leaving */
{
interested[process] = FALSE; /* indicate departure from critical region */
}
Figure 2-21
1. Sebelum masuk critical region, setiap proses memanggil enter_region dengan nomor
proses, 0 atau 1, sebagai parameternya.
2. Lalu proses akan menunggu, jika perlu sampai aman untuk masuk.
3. Setelah selesai dengan shared variables, proses akan memanggil leave_region untuk
memberitahu bahwa ia telah selesai dan mengijinkan proses lain untuk masuk.
Cara bekerjanya adalah sebagai berikut :
1. Dua buah proses tidak berada dalam critical region.
2. Process 0 memanggil enter_region. Ia merubah elemen arraynya dan merubah nilainya
menjadi 0.
3. Karena process 1 tidak akan bekerja maka enter_region akan segera kembali.
4. Jika proses 1 sekarang memanggil enter_region, ia akan menunggu sampai interested[0]
menjadi FALSE : event yang hanya terjadi jika proses 0 memanggil leave_region untuk
keluar dari critical region.
Jika kedua buah proses masuk secara simultan maka :
1. Kedua-duanya akan menyimpan nomor prosesnya kedalam turn. Yang terakhir yang akan
disimpan, yang pertama akan ditimpa.
2. Jika process 1 menyimpan terakhir maka turn bernilai 1. Jika kedua proses masuk kedalam
while, process 0 akan berjalan 0 kali dan masuk ke critical region. Process 1 loops dan
tidak masuk critical region sampai process 0 keluar dari critical region.
The TSL Instruction
Sekarang kita akan melihat cara mencapai mutex dengan hardware. Komputer memiliki
instruksi : TSL RX,LOCK (Test and Set Lock). Cara bekerjanya adalah sebagai berikut :
1. Membaca isi memory word lalu diletakkan kedalam register RX dan menyimpan nilai
nonzero memory address lock. Operasi membaca dan menyimpan merupakan satu
kesatuan. Prosesor lain tidak akan dapat menggunakan memory word sampai instruksinya
selesai. CPU yang melakukan TSL mengunci memory bus sehingga CPU yang lain tidak
dapat menggunakan memory sampai selesai.
2. TSL menggunakan shared variable, lock, untuk koordinasi access ke shared memory.
Ketika lock, setiap proses dapat dibuat bernilai 1 dengan instruksi TSL lalu
3. dilanjutkan dengan membaca dan menulisi shared memory. Ketika selesai process
mengunci lock ke 0 dengan menggunakan move instruction.
TSL REGISTER,LOCK | copy lock to register and set lock to 1
CMP REGISTER,#0 | was lock zero?
JNE enter_region | if it was non zero, lock was set, so loop
RET | return to caller; critical region entered
leave_region:
MOVE LOCK,#0 | store a 0 in lock
RET | return to caller
Figure 2-22. Entering and leaving a critical region using the TSL instruction.
1. Before entering its critical region, a process calls enter_region, which does busy waiting
until the lock is free.
2. Then it acquires the lock and returns. After the critical region the process calls
leave_region, which stores a 0 in lock.
3. As with all solutions based on critical regions, the processes must call enter_region and
leave_region at the correct times for the method to work.
4. If a process cheats, the mutual exclusion will fail.
Sleep and Wakeup
Kedua cara Peterson dan TSL dapat berjalan dengan benar, tetapi memerlukan busy waiting.
Permasalahannya :
1. Pemborosan CPU time,
2. Jika sebuah komputer memiliki 2 buah proses H, (prioritas utama) dan L prioritas rend
Aturannya : H berjalan jika dalam keadaan ready. Pada satu waktu dimana L pada criti
regionnya, H berada dalam keadaan ready to run (operasi I/Onya selesai). H sekarang
menunggu, tetapi karena L tidak pernah dijadwalkan ketika H berjalan, L tidak
pernah memperoleh kesempatan untuk untuk meninggalkan critical region, maka H
akan loops selamanya. Situasi ini disebut sebagai priority inversion problem.
Bagaimana kalau menggunakan block ? Caranya adalah pasangan sleep dan wakeup :
1. Sleep adalah sebuah system call yang menyebabkan caller to block, ditunda
berjalannyasampai proses yang lain wake (membangunkannya) .
2. Wakeup call memiliki hanya satu parameter : proses yang akan dibangunkan.
3. Atau alternativenya sleep dan wakeup masing-masing memiliki satu one parameter :
memory address yang digunakan untuk mencocokkan sleeps dan wakeups.
The Producer-Consumer Problem
Sebagai contoh bagaimana wake dan sleep digunakan mari kita lihat producer
consumer (aka bounded-buffer problem). Dua proses menggunakan buffer yang sama. :
Salah satunya, producer, meletakkan informasi kedalam buffer, dan yang lain,
consumer, mengambilnya takes it out. Juga mungkin bahwa sistem terdiri dari m
producers and n consumers, tetapi untuk pembahasan ini kita hanya akan menggunakan
satu produsen dan satu konsumePermasalahan yang timbul adalah producer akan
meletakkan data baru didalam bu
sudah penuh. Pemecahannya adalah sleep, dan wake jika consumer sudah mengambil
satu data. Jika consumer ingin mengambil satu data dari dalam buffer dan melihat bahwa
buffmaka ia akan tidur (sleep) sampai producer meletakkan data didalam buffer
danmembangunkannya (wakes it up).
Pendekatan ini ternyata membawa permasalahan race conditions. : Untuk menjejaki
jumlah item didalam buffer, kita memerlukan variable count. Jika maksimum data
didalam buffer N, maka producer akan menguki apakah count b. Jika ya producer tidur,
jika tidak producer akan menambah data dan menambah count. Demikian juga dengan
consumer : pertama-tama melihat apakah count 0. Jika ya sleep, Jika tidak 0, maka data
diambil, dan mengurangi nilai counter. Setiap pro menguji apakah yang lain harus
dibangunkan.
#define N 100 /* number of slots in the buffer */
int count = 0; /* number of items in the buffer */
void producer (void)
{
int item;
while (TRUE) { /* repeat forever */
item = produce_item(); /* generate next item */
if (count == N) sleep(); /* if buffer is full, go to sleep */
insert_item(item); /* put item in buffer */
count = count + 1; /* increment count of items in buffer */
if (count == 1) wakeup(consumer); /* was buffer empty? */
}
}
void consumer(void)
{
int item;
while (TRUE) { /* repeat forever */
if (count == 0) sleep(); /* if buffer is empty, got to sleep */
item = remove_item(); /* take item out of buffer */
count = count
t
consume_item(item); /* print item */
}
}
Source code producer-consumer : fatal race condition.
Inti dasarnya adalah : wakeup yang dikirimkan ke proses yang belum tidur akan hilang
Perbaikannya adalah dengan merubah aturan : menambahkan : wakeup waiting bit.
Ketika sebuah wakeup signal dikirimkan ke proses yang masih aktif, nilai bit ini di set.
Selanjutnya ketika process mencoba untuk tidur, dan wakeup waiting bit bernilai on, akan
dijadikan off, tetapi proses akan tetap berjalam (the process will stay awake). The wakeup
waiting bit is a piggy bank for wakeup signals.
Meskipun wakeup waiting bit kelihatannya sederhana tetapi menyimpan permasalahan
tersendiri.
Semaphores
Semaphore adalah sistem sinyal yang digunakan untuk berkomunikasi secara visual.
Dalam software, semafor adalah sebuah variabel bertipe integer yang selain saat
inisialisasi, hanya dapat diakses melalui dua operasi standar, yaitu increment dan
decrement. Semafor digunakan untuk menyelesaikan masalah sinkronisasi secara umum.
Berdasarkan jenisnya, semafor hanya bisa memiliki nilai 1 atau 0, atau lebih dari sama
dengan 0. Konsep semafor pertama kali diajukan idenya oleh Edsger Dijkstra pada tahun
1967. Operasi standar pada semafor (dalam bahasa pemrograman C) :
void kunci(int sem_value) {
while(sem_value <= 0);
sem_value--;
}
void buka(int sem_value) {
sem_value++;
}
Nama asli dari operasi tersebut sebenarnya adalah Proberen (test) dan Verhogen
(increment). Namun, sebutan untuk 2 method ini sangat beragam, antara lain sering
dikenal dengan nama : release dan acquire, P dan V , serta kunci dan buka. Dalam buku
ini akan digunakan istilah buka dan kunci. Fungsi wait dipanggil ketika thread akan
memasuki critical section-nya atau ketika thread akan memakai resource yang tersedia.
Jika sem_value kurang dari atau sama dengan 0, thread tersebut harus menunggu sampai
thread lain memanggil fungsi buka. Fungsi buka dipanggil ketika thread meningggalkan
critical section-nya atau ketika melepaskan resource yang telah digunakannya. Tentu saja
kedua operasi tersebut harus bersifat atomik karena sem_value dapat diakses oleh
beberapa proses (shared resource).
Semafor memiliki dua jenis, yaitu:
1. Binary semaphore. Semafor ini hanya memiliki nilai 1 atau 0. Sering juga disebut sebagai
semafor primitif
2. Counting semaphore. Semafor ini memiliki nilai 0, 1, serta integer lainnya.
3. Banyak sistem operasi yang tidak secara langsung mengimplementasikan semafor ini,
tetapi dengan memanfaatkan binary semaphore
Fungsi Semafor
Seperti telah disebutkan sebelumnya, semafor berfungsi untuk menangani masalah
sinkronisasi secara umum, yaitu: Mutual Exclusion. Sesuai dengan prinsip mutual
exclusion, jika suatu thread sedang berada dalam critical section-nya, thread lain harus
menunggu thread tersebut keluar dari critical section-nyasebelum dapat memasuki critical
section-nya sendiri. Di sinilah semafor digunakan, thread yang akan memasuki critical
section-nya akan memanggil fungsi kunci terlebih dahulu. Jika tidak ada thread lain yang
sedang berada dalam critical section, thread ini akan memasuki critical section-nya. Jika
terdapat thread lain yang sedang berada dalam critical section-nya, thread ini harus
menunggu.Setelah thread keluar dari critical section-nya, thread tersebut akan memanggil
fungsi buka sehingga sem_value akan naik menjadi lebih dari 0, dan satu (dari beberapa)
thread yang sedang menunggu akan mendapatkan giliran untuk memasuki critical section-
nya. Sebagai contoh, misalnya terdapat dua buah thread yang sedang berjalan bersamaan:
thread A: thread B:
count = count + 1; count = count + 1;
Thread A dan B mengakses variabel yang sama, yaitu count sehingga thread A dan B
harus berjalan satu-satu. Untuk itu digunakan semafor mutex yang berupa binary
semaphore dengan nilai awal 1.
thread A: thread B:
kunci(mutex); kunci(mutex);
count = count + 1; count = count + 1;
buka(mutex); buka(mutex);
Thread manapun yang mengeksekusi kunci terlebih dahulu akan jalan terus, sedangkan
thread yang tiba belakangan akan menunggu sampai thread yang sudah berjalan terlebih
dahulu mengeksekusi buka, setelah itu kedua thread berjalan lagi dengan normal.
Resource Controller.
Bayangkan sebuah restoran yang setiap malamnya ramai dikunjungi pelanggan. Kapasitas
restoran terbatas, tetapi pemilik restoran memiliki kebijakan bahwa semua pengunjung
yang datang akan mendapatkan kesempatan untuk makan, dengan konsekuensi yaitu
pelanggan harus sabar menunggu gilirannya.
Oleh karena itu, dikerahkanlah pegawai restoran untuk menahan tamu di luar jika
restoran penuh lalu mempersilahkan tamu masuk jika tempat telah tersedia. Dari analogi
di atas, pelanggan adalah thread, kapasitas restoran adalah resource, dan pegawai restoran
adalah semafor. Semafor menyimpan banyaknya resource yang tersedia.
Saat thread ingin memakai resource ia akan memanggil fungsi kunci. Jika resource masih
tersedia, thread bisa langsung menggunakannya, sebaliknya jika semua resource sedang
dipakai, thread tersebut harus menunggu. Setelah resource selesai dipakai thread akan
memanggil fungsi buka sehingga resource yang bebas bertambah. Contohnya dapat kita
lihat pada kasus berikut:
Terdapat tiga buah thread yang berjalan bersamaan. Resource yang tersedia hanya cukup
untuk dua buah thread.
thread A: thread B: thread C:
//critical section //critical section //critical section
Tentu saja harus diatur agar pada suatu saat hanya ada dua buah thread yang berada pada
critical section-nya. Hal ini dilakukan dengan menggunakan semafor multiplex yaitu
sebuah counting semaphore dengan nilai awal sama dengan jumlah resource yang tersedia
yaitu dua.
thread A: thread B: thread C:
kunci(multiplex); kunci(multiplex); kunci(multiplex);
//critical section //critical section //critical section
buka(multiplex); buka(multiplex); buka(multiplex);
Jika dua buah thread sedang berada dalam critical section, thread berikutnya yang akan
memasuki critical section harus menunggu kedua thread tersebut selesai untuk dapat
memasuki critical section-nya.
Sinkronisasi Antar-Proses. Ada kalanya suatu thread memerlukan resource yang
dihasilkan oleh thread lainnya. Oleh karena itu dibutuhkan suatu mekanisme untuk
mengatur urutan eksekusi thread. Mekanisme ini dilakukan dengan memanfaatkan
semafor. Sebagai contoh, misalnya terdapat dua buah thread yang sedang berjalan
bersamaan:
thread A: thread B:
count = count + 1; count = count * 2;
Nilai awal dari variabel count adalah 5, nilai akhir yang diinginkan adalah 12, oleh karena
itu thread A harus dieksekusi sebelum thread B. Agar hal ini dapat terjadi dibutuhkan
suatu semafor
mutex yang merupakan sebuah binary semaphore dengan nilai awal 0.
thread A: thread B:
count = count + 1; kunci(mutex);
buka(mutex); count = count * 2;
Thread B akan menunggu sampai eksekusi thread A selesai sebelum melanjutkan. Jika
kita cermati fungsi kunci, thread akan terus berada dalam waiting loop sampai sem_value
naik lebih dari 0. Padahal, di dalam loop tersebut thread tidak melakukan tugas apa-apa.
Inilah yang disebut dengan busy waiting (semafor jenis ini disebut dengan semafor
spinlock). Hal ini tentu saja akan berakibat buruk terhadap kinerja CPU, karena loop
tersebut membutuhkan CPU cycle, sementara loop tersebut tidak menghasilkan apa-apa,
jadi sama saja dengan menyia-nyiakan CPU cycle. Untuk mengatasi hal ini, dibuatlah
modifikasi dari semafor, yaitu dengan menambahkan waiting queue pada masing-masing
semafor. Tujuannya adalah agar thread yang harus menunggu dipindahkan ke waiting
queue dan kegiatannya dihentikan sementara.
Ketika thread keluar dari critical section-nya, thread tersebut akan memanggil fungsi buka
yang akan mengeluarkan satu (dari beberapa) thread yang berada dalam waiting queue
lalu membangunkannya untuk kemudian memasuki critical section-nya.
Struktur semafor ini menjadi (masih dalam bahasa C):
void buka(int sem_value) {
sem_value++;
if(sem_value <= 0)
{
/*keluarkan satu thread dari waiting queue*/
/*aktifkan thread tersebut*/
}
}
void kunci(int sem_value)
{
sem_value--;
if(sem_value < 0)
{
/*masukkan thread ke dalam waiting queue*/
/*blok thread tersebut*/
}
}
Berbeda dengan semafor yang biasa, pada semafor yang telah dimodifikasi ini sem_value
bisa menjadi negatif. Jika kita renungkan maknanya, ternyata ketika semafor bernilai
negatif, nilai tersebut melambangkan banyaknya thread yang berada pada waiting queue
semafor tersebut.
Keuntungan menggunakan semafor:
1. Dari segi programming, penanganan masalah sinkronisasi dengan semafor
umumnya rapi dan teratur, sehingga mudah untuk dibuktikan kebenarannya
2. Semafor diimplementasikan dalam hard code sehingga penggunaannya
bersifat portabel.
Metode dengan dukungan perangkat keras
1. Metode pematian interupsi
cara pematian interupsi mengakibatkan
pemroses tidak dapat beralih ke proses lain karena interupsi clock dimatikan sehingga
penjadwal pun tidak diekseskusi.
proses dapat memakai memori bersama tanpa takut intervensi proses lain.
kelemahan utama
bila proses yang mematikan interupsi mengalami gangguan maka proses tidak akan
pernah menghidupkan interupsi kembali.
jika terdapat dua pemroses atau lebih, mematikan interupsi hanya berpengaruh pada
pemroses yang mengeksekusi intruksi itu.
pemroses-pemroses lain masih bebas memasuki critical section yang sedang dimasuki
proses lain. teknik ini tidak dapat diterapkan pada sistem multiprocessor.
Teknik mematikan interupsi dapat digunakan untuk proses-proses kernel yang sangat kritis
yang tidak boleh diintervensi proses lain seperti saat memodifikasi PCB.
Pemroses Intel mendukung mekanisme ini dengan menyediakan intruksi sebagai berikut:
cli - mematikan interupsi
sti - mengaktifkan kembali interupsi
2. Metode dengan intruksi Test and Set Lock
Pemroses-pemroses yang memakai memori bersama maka pengaksesan terhadap suatu
memori dijaga pada tingkat perangkat keras
agar pemroses lain tidak boleh mengakses suatu lokasi yang sama di saat yang sama.
Perancang perangkat keras menyediakan intruksi-intruksi atomik yang tidak dapat
diinterupsi, intruksi dilaksanakan sampai selesai. intruksi
ini biasanya dilaksanakan dengan cara mengunci bus sehingga pemroses-pemroses lain
tidak dapat menggunakan bus. Beragam intruksi
disediakan perancang pemroses guna membantu implementasi mutual exclusion. intruksi-
intruksi itu adalah:
tsl(test set and lock)
tas atau ts(test and set),digunakan IBM S/360,keluarga Motorola M68000,dan lain-lain.
cs(compare and set),digunakan IBM 370 Series
xchg(exchange),digunakan Intel x86
dan sebagainya
Intruksi ini membaca isi memori ke register dan kemudian menyimpan nilai bukan nol
ke alamat memori itu. tidak ada pemroses lain yang dapat
mengakses memori itu sampai intruksi berakhir. Pemroses yang mengeksekusi intruksi tsl
mengunci bus memori, mencegah pemroses-pemroses lain
mengakses memori.
Dengan intruksi tsl, kita dapat menggunakan flag untuk koordinasi pengaksesan ke
memori bersama. Ketika flag bernilai 0, proses boleh menge-set-nya
menjadi 1 menggunakan intruksi tsl dan kemudian maasuk critical section. Ketika telah
selesai dengan critical region, proses menge-set flag dengan 0.
Dengan adanya intruksi ini maka dapat dibuat prosedur
Prosedur Tsl_to_critical_section
Prosedur Tsl_leave_critical_section
Gambar 1.7
3. Metode dengan intruksi Exchange (XCHG)
Intruksi dapat digunakan untuk implementasi mutual exclusion. Dengan intruksi xchg tersebut
dapat dibuat
Prosedur Xchg_to_critical_section
Prosedur Xchg_leave_critical_section
Sebelum mengeksekusi seluruh proses maka flag diinisialisasi dengan nilai 0. Proses sebelum
masuk critical_section, proses menge-set dengan kunci (key)
proses itu sebagai 1 kemudian memanggil xchg_to_enter_section. Proses melakukan busy
waiting sampai terbebas. Selesai dengan critical section, proses
memanggil xchg_leave_critical_section menukarkan nilai 0 ke flag agar proses lain dapat
memasuki critical section itu.
Karakteristik Pendekatan dengan Intruksi Mesin
Penggunaan instruksi mesin untuk memaksakan mutual exclusion mempunyai keunggulan
dan kelemahan.
Keunggulan:
sederhana dan mudah diverifikasi
dapat diterapkan ke sembarang jumlah proses
dapat digunakan untuk mendukung banyak critical region
Kelemahan:
merupakan metode dengan busy waiting, sangat tidak efisien. Selagi proses menunggu
memasuki critical region, proses berlanjut mengkonsumsi waktu pemroses.
adanya busy waiting memungkinkan deadlock dan startvation.
Dampak Adanya Busy Waiting
Busy waiting mempunyai keterbatasan yaitu tidak dapat diterapkan pada sistem dengan
penjadwalan berprioritas. Metode dengan busy waiting dapat menimbulkan deadlock.
Aturan penjadwalan berprioritas selalu menjadwalkan proses-proses berprioritas lebih tinggi
di antrian proses Ready
Misalnya terdapat dua proses,
1. Proses H berprioritas tinggi
2. Proses L berprioritas rendah
Metode dengan Semaphore
Semaphore mempunyai dua properti, yaitu:
1. Semaphore dapat diinisialisasi dengan nilai bukan negatif
2. Terdapat dua operasi terhadap semaphore yaitu Down dan Up.
Operasi Down
Operasi ini menurunkan nilai semaphore. Jika nikai semaphore menjadi bukan positif maka
proses yang mengeksekusinya di-block.
operasi down adalah atomik yang tidak dapat diinterupsi sebelum selesai. Menurunkan nilai,
memeriksa nilai, menempatkan proses pada antrian dan mem-block sebagai interupsi tunggal.
Operasi UP
Operasi menaikkan nilai semaphore, memindahkan dari antrian dan menempatkan satu proses
ke senarai Ready tidak dapat diinterupsi.
Mutual Exclusion dengan semaphore
Adanya semaphore mempermudah persoalan mutual exclusion. Sebelum masuk critical
section, proses melakukan Down. Bila berhasil maka proses masuk critical section. Bila tidak
berhasil
maka proses di-block pada semaphore itu. Proses yang berada di critical section keluar dan
melakukan operasi UP dan menjadikan proses yang di-block menjadi Ready dan berlanjut
sehingga operasi Down-nya berhasil.
Implementasi Semaphore
Operasi UP dan Down adalah primitif atomik. Beragam skema dapat diterapkan untuk
implementasi Up dan Down.
Skema implementasi dapat dilakukan secara perangkat lunak atau dengan dukungan
perangkat keras.
DEADLOCK
Sekumpulan proses berkondisi deadlock bila setiap proses yang berada di kumpulan
itu menunggu suatu kejadian yang hanya dapat dilakukan proses lain yang juga berada di
kumpulan itu. Sehingga proses-proses menunggu kejadian yang tidak akan pernah terjadi.
Deadlock terjadi ketika proses-proses mengakses sumber daya secara ekslusif. Semua
deadlock yang terjadi melibatkan persaingan untuk memperoleh sumber daya ekslusif oleh
dua proses atau lebih. Seperti pada system pengendalian proses waktu nyata, maka harus
membayar semua kemahalan karena keberadaan deadlock akan mengakibatkan kekacauan
system.
1. Model Deadlock
Urutan kejadian operasi perangkat masukan/keluaran adalah
Meminta (request) : meminta layanan perangkat masukan/keluaran.
Memakai (use) : memakai perangkat masukan/keluaran.
Melepaskan (release) : melepaskan pemakaian perangkat masukan/keluaran.
Model deadlock dua proses dan dua sumber daya. Deadlock dapat digambarkan
sebagai graph. Misalnya Dua proses p0 dan p1, Dua sumber daya R0 dan R1.
GAMBAR 7.1
P0 meminta sumber daya R0, ditandai dengan busur berarah dari proses p0 ke
sumber daya R0. Sumber daya R1 dialokasikan ke p0 ditandai busur berarah dari
sumber daya R1 ke proses p1.
Skenario yang menimbulkan deadlock :
P0 dialokasikan R0
P1 dialokasikan R1, kemudian
P0 sambil masih menggenggam R0, meminta R1.
P1 sambil masih menggenggam R1, meminta R0.
Kejadian ini mengakibatkan deadlock karena sama-sama proses P0 dan P1 akan saling
menunggu. Graph deadlock ini digambarkan sebagai graph melingkar. Terjadinya deadlock
ditandai munculnya graph melingkar.
GAMBAR 7.2
Deadlock tidak hanya terjadi pada satu atau dua proses saja namun juga melibatkan
lebih dari dua proses.
A. Syarat-syarat Terjadinya Deadlock
1. Mutual Exclusion
Sumber daya diberikan tepat satu proses.
2. Kondisi Genggam Dan Tunggu
Proses-proses yang menggenggam sumber daya, menunggu sumber daya baru.
3. Kondisi Non-Preemption
Sumber daya harus secara eksplisit dilepaskan dari proses yang menggenggamnya
tanpa paksa.
4. Kondisi Menunggu secara Sirkuler
Harus ada rantai sirkuler dari dua proses atau lebih, masing-masing menunggu
sumber daya yang digenggam oleh anggota berikutnya pada rantai itu.
B. Metode-metode Mengatasi Deadlock
Metode untuk mengatasi deadlock dikelompokkan menjadi tiga, yakni :
1. Metode Pencegahan (Deadlock Prevention)
Pencegahan merupakan solusi yang bersih dipandang dari sisi tercegahnya
deadlock. Dan metode inilah yang paling banyak dipakai. Namun, metode ini
sering menghasilkan penggunaan sumber daya yang buruk.
2. Metode Penghindaran (Deadlock Avoidance)
Sistem operasi akan memeriksa semua permintaan sumber dayasecara hati-
hati. Jika system operasi mengetahui bahwa alokasi sumber daya menimbulkan
risiko deadlock,maka system operasi akan menolak pengaksesan itu. Dengan
demikian menghindari terjadinya deadlock.
3. Metode Deteksi dan Pemulihan dari Deadlock (Deadlock detection and
recovery)
Tujuan dari metode ini adalah memeriksa apakah telah terjadi deadlock dan
menentukan proses-proses dan sumber daya-sumber daya yang terlibat
deadlock secara presisi. Setelah dapat ditentukan, system dipulihkan dari
deadlock dengan metode pemulihan sehingga system beroperasi kembali.
C. Pencegahan Deadlock
Strategi-strategi untuk meniadakan terjadinya deadlock :
Tiap proses harus meminta semua sumber daya yang diperlukan dan tidak
berlanjut sampai semuanya diberikan.
Jika proses telah memegang sumber daya tertentu, maka untuk permintaan
berikutnya harus melepas dulu sumber daya yang dipegangnya. Jika
diperlukan, proses meminta kembali sekaligus dengan sumber daya yang baru.
Memberi pengurutan linear terhadap tipe-tipe sumber daya. Jika proses telah
dialokasikan suatu tipe data, maka proses hanya boleh meminta sumber daya-
sumber daya pada urutan berikutnya.
C.1 Meniadakan Mutual Exclusion
Deadlock disebabkan terdapatnya pengaksesan eksklusif terhadap sumber daya. Cara
untuk mengakali pengaksesan eksklusif adalah melakukan spooling perangkat-perangkat yang
harus didedikasikan ke suatu proses. Hanya dengan spooling permintaan-permintaan itu
diantrikan di harddisk dan akan dilayani satu per satu.
Terdapat masalah terhadap teknik ini adalah
Tidak semua sumber daya eksklusif dapat di-spooling.
Kompetisi terhadap ruang harddisk untuk spooling dapat menuntun ke
deadlock. Abstraksi ini berarti kembali menjadi kondisi yang mengharuskan
mutual exclusion namun mutual exclusion menjadi di level lebih bawah yaitu
level suatu lokasi memori bukan lagi satu perangkat.
Mutual exclution benar-benar tidak dapat dihindari, hanya mampu diperkecil lama
waktu berlangsungnya.
C.2 Meniadakan Syarat Hold and Wait
Metode untuk meniadakan syarat hold and wait dapat dilakukan dengan cara:
1. Mengalokasikan semua sumber daya atau tidak sama sekali
Proses hanya dilayani permintaanya bila semua sumber daya yang diperlukan tersedia.
Teknik ini berbasis pada kaidah memperoleh semua atau tidak sama sekali.
Jika semua sumber daya tersedia,proses dialokasikan semua sumber daya yang
diperlukannya berjalan sampai selesai.
Jika tidak tersedia sedikitnya satu sumber daya maka proses harus menunggu
sampai semua sumber daya yang diperlukannya tersedia untuk dialokasikan
padanya.
Masalah :
Sukar mengetahui lebih dulu semuasumber daya yang diperlukan suatu proses
karena diawal proses tidak diketahui berapa sumber daya yang akan
diperlukan.
Cara ini dapat mengakibatkan penggunaan sumber daya yang tidak efisien.
2. Hold and Release
Yaitu setiap kali terjadi permintaan suatu sumebr daya maka proses harus melepas
sumber daya lain yang telah digunakan. Pada satu saat,hanya satu sumberyang
dialokasikan.
Masalah :
Teknik ini tidak mungkin, sebab terdapat proses yang mensyaratkan harus memegang
beberapa sumber daya sekaligus untuk melanjutkan eksekusinya.
C.3 Meniadakan Non-preemption
Peniadaan non-preemption mencegah proses-proses lain harus menunggu. Seluruh
proses menjadi preemption agar tidak ada kejadian saling menunggu.
C.4 Meniadakan Menunggu Sirkular
Kondisi inidapatditiadakan dngan bermacamcara, antara lain :
Proses hanya dibolehkanmenggenggam satu sumber daya pada satu saat telah
dibahas
Teknik ini tidak dimungkinkan karena terdapat proses yang mengharuskan
memegang lebih darisatu sumber daya pada saat yang sama untuk menyelesaikan
prosesnya.
Penomoran global semua sumber daya.
Proses dapat meminta proses kapanpun tapi permintaan harus dibuat berurut secara
numerik. Cara ini tidak akan menimbulkan siklus.
C.5 Penghindaran Deadlock
Gagasan dasar penghindaran deadlock adalah hanya member akses ke permintaan
sumber daya yang tidak mungkin menimbulkan deadlock. Strategi ini biasanya
diimplementasikan dengan pengalokasi sumber daya memeriksa dampak-dampak pemberian
akses ke suatu permintaan.
Jika pemberian akses sumber daya tidak mungkin menuju deadlock, sumber daya
diberikan ke peminta.
Jika memungkinkan timbulnya deadlock, proses yang meminta di-suspend sampai
suatu waktu permintaannya aman diberikan.
Agar dapat mengevaluasi safe-nya state system individu, penghindaran deadlock
mengharuskan semua proses menyatakan jumlah kebutuhan sumberdaya maksimum sebelum
eksekusi. Begitu eksekusi dimulai, tiap proses meminta sumber daya saat diperlukan sampai
batas maksimum yang dinyatakan di awal. Proses-proses yang menyatakan kebutuhan sumber
daya melebihi kapasitas total system tidak dapat dieksekusi.
Pengalokasi sumber daya mencatat jumlah sumber daya teralokasi dan jumlah sumber
daya masing-masing tipe, serta mencatatjumlah sumber daya tersisa yang diklaim tapi belum
diminta proses. Proses yang memintasumber daya yang tidak tersedia harus menunggu
sementara. Jika sumber daya yang diminta tersedia, pengalokasi sumber daya memeriksa
apakah pemberian dapat menuntun ke deadlock, dengan memeriksa apakah proses-proses
yang telah aktif dapat selesai.
a. State Selamat dan State Tak Selamat
State dinyatakan sebagaistate selamat (safe state) jika tidak deadlock dan terdapat cara
untuk memenuhi semua permintaan yang ditunda tanpa menghasilkan deadlock dengan
menjalankan proses-proses secara hati-hati mengikuti suatu urutan tertentu.
Contoh :
Pada sistem dengan 10 sumber daya setipe, proses A memerlukan sumber daya
maksimum sebanyak 10, sedang saat ini menggenggam 2. Proses B memerlukan sumber daya
maksimum sebanyak 7 sedang saat ini menggenggam 3 sumber daya.masih tersedia 4 sumber
daya.
GAMBAR 7.3
Pada gambar tersebut dinyatakan sebagai safe karena terdapat barisan pengalokasian
yang dapat memungkinkan semua proses selesai. Dengan penjadwalan secara hati-hati,
system dapat terhindarkan dari deadlock. Barisan tersebut adalah :
Langkah 1 : Alokasikan empat sumber daya ke proses C, sehingga sumber daya tersedia
tinggal 1 dan nantikan sampai proses C berakhir.
Maka setelah proses C selesai menjadi
Langkah 2: Alokasikan lima sumber daya ke proses B, nantikan proses B sampai berakhir.
Maka setelah proses B selesai menjadi
Langkah 3: Alokasikan delapan sumber daya ke proses A , nantikan proses A samapi
berakhir.
Maka setelah proses A selesai menjadi
Maka ketiga proses tersebut dengan penjadwalan hati-hati dapat menyelesaikan proses
mereka dengan sempurna.
State Tak Selamat (unsafe state )
State dinyatakan sebagai state tak selamat jika tidak terdapat cara untuk memenuhi semua
permintaan yang saat ini ditunda dengan menjalankan proses-proses dengan suatu urutan.
Contoh:
Gambar di bawah ini adalah seperti gambar 7-2 menunjukkan state selamat. State ini dapat
berubah menjadi state tak selamat bila alokasi sumber daya tak terkendali.
State tersebut dapat menjadi state tak selamat apabila
- Dua permintaan sumber daya oleh proses A dilayani,kemudian
- Permintaan satu sumber daya oleh proses B dilayani
Maka state menjadi
State ini pada gambar 7-4 adalah state tak selamat, pada state ini tidak terdapat barisan
pengalokasian yang dapat membuat semua proses selesai.
Langkah 1 : Alokasikan satu sumber daya ke proses B, sehingga sumber daya tersedia tinggal
1 dan nantikan sampai proses B berakhir.
Maka setelah proses B selesai menjadi
Saat ini hanya tersedia tiga sumber daya sementara dua proses yang sedang aktif masinmasing
membutuhkan enam dan empat sumber daya.
Algoritma Banker oleh Disjkstra
Algoritma ini disebut algoritma Banker karena memodelkan banker di kota kecil yang
berurusan dengan sekumpulan nasabah yang memohon kredit. Pada Algoritma Banker
ini, kondisi mutual exclusion, hold-and-wait, dan no-preemption diijinkan dan
proses-proses melakukan klaim penggunaan eksklusif sumber daya-sumber dayayang
diperlukan. Proses-proses diijinkan menggenggam sumber daya sambil meminta dan
menunggu sumber daya lain serta sumber daya itu tidak diijinkan dipreempt proses
lain.
Sistem hanya memberikan permintaan yang menghasilkan state selamat. Permintaan
proses yang akan menghasilkan state tak selamat secara berulang ditolak sampai
permintaan dapat dipenuhi. Tentunya karena system selalu memelihara agar dalam
state safe, cepat atau lambat (yaitu dalam waktu yang berhingga) semua permintaan
data dipenuhi dan semua proses dapat berakhir. Implementasi algoritma ini dijelaskan
secara rinci pada buku Stallings [STA-95].
Kelemahan Algoritma Banker
Kelemahan algoritma banker adalah sebagai berikut: [TAN-92,STA-95,DEI-90]
1. Proses-proses jarang mengetahui di awal proses jumlah maksimum sumber daya
yang akan diperlukan.
2. Jumlah proses tidak tetap secara dinamis beragam begitu pemakai-pemakai baru
login dan logout.
3. Sumber daya yang dihitung sebagai tersedia data saja tiba-tiba ditanggalkan
sehingga sebenarnya menjadi tidak tersedia.
4. Proses-proses harus independen , yaitu urutan proses-proses dieksekusi tidak
dibatasi kebutuhan sinkronisasi antarproses.
5. Algoritma menghendaki meberikan semua permintaan selama waktu yang
berhingga.
6. Algoritma menghendaki client-client mengembalikan sumber daya setelah suatu
waktu yang berhingga.
DETEKSI DAN PEMULIHAN DEADLOCK
Deteksi Adanya Deadlock
Deteksi deadlock adalah teknik untuk menentukan apakah deadlock terjadi serta
mengidentifikasi proses-proses dan sumber daya-sumber daya yang terlibat deadlock.
Umumnya algoritma-algoritma deteksi yang digunakan adalah menentukan
keberadaan menunggu sirkular (circular wait). Penggunaan algoritma deteksi
deadlock melibatkan overhead pada saat berjalan karena secara periodik dijalankan
untuk mendeteksi menunggu sirkular. Sembarang algoritma pendeteksian siklus pada
graph berarah dapat digunakan.
Pemulihan dari Deadlock
Begitu system terdapat deadlock , deadlock harus diputuskan dengan menghilangkan
suatu syarat perlu atau lebih. Biasanya beberapa proses akan kehilangan sebagian atau
semua kerja yang telah dilakukan. Hal ini merupakan ongkos yang harus dibayar
dibanding terjadinya deadlock yang berarti semua proses tidak menghasilkan apapun.
Pemulihan dari deadlock dirumitkan oleh faktor-faktor berikut :
1. Belum tentu dapat menetukan adanya deadlock secepatnya.
2. Kebanyakan system tidak memiliki fasilitas atau mempunyai fasilitas-fasilitas
buruk untuk men-suspend proses, menghilangkan dari system dan me-resume
roses lain waktu. Pada system nyata yang harus berfungsi terus menerus , proses-
proses tidak data di-suspend dan di-resume.
3. Bahkan jika terdapat kemampuan suspend dan resume yang efektif
Kemampuan ini melibatkan sejumlah overhead berarti dan memerlukan perhatian
operator yang berkemampuan tinggi.
4. Pemulihan memerlukan sejumlah kerja yang berarti.
Pada system operasi dengan hanya tiga state dasar ( Running, Ready , Blocked ),
maka tidak ada cara lain kecuali dilakukan penyingkiran terhadap proses itu. Proses
benar-benar hilang dari memori dan harus dimuat kembali.
Teknik pemulihan yang biasa digunakan adalah menghilangkan (dengan suspend atau
kill) proses-proses dari system dan pengklaiman kembali (reclaim) sumber daya-
sumber daya yang dipegang proses-proses itu. Proses yang dihilagkan biasanya akan
cacat , tapi proses-proses lain dapat menyelesaikan prosesnya. Kadang perlu
menyingkirkan beberapa proses sampai tidak terjadi deadlock (yaitu tidak membentuk
siklus). Istilah “pemulihan” sebenarnya kurang berarti di sini karena yang terjadi
sesungguhnya adalah penyingkiran beberapa proses “untuk memberi manfaat”
prosesproses lain.
Pendekatan berikut dapat dilakukan pemulihan deadlock. Pendekatan-pendekatan
dituliskan terurut kecanggihan penyelesaiannya.[STA-95]
1. Abaikan (singkirkan) semua proses yang terlibat deadlock. Teknin merupakan cara
mudah dan solusi yang paling sering dipilih.
2. Backup semua proses yang terlibat deadlock ke suatu checkpoint yang
didefinisikan sebelumnya dan dijalankan kembali semua prose situ.
3. Secara berurutan abaikan proses-proses samapi deadlock tidak ada lagi. Urutan
proses yang dipilih untuk disingkirkan berdasar criteria ongkos minimum.
4. Secara berurutan preempt sumber daya-sumber daya smapai tidaka ada deadlock
lagi. Sebagaimana item 3, pemilihan berdasar ongkos yang digunakan dan
algoritma deteksi harus dijalankan setelah tiap preempt.
Untuk item 3 dan 4 kriteria pemilihan proses yang akan disingkirkan atau di-suspend
adalah dengan criteria-kriteria sebagai berikut :
1. Waktu pemrosesan yang telah dijalankan paling kecil
2. Jumlah baris keluaran yang diproduksi paling kecil.
3. Mempunyai estimasi sisa waktu eksekusi terbesar.
4. Jumlah total sumber daya terkecil yang telah dialokasikan.
5. Prioritas terkecil.
Strategi penanggulangan deadlock terpadu
Masing-masing teknik mempunyai keunggulan dan kelemahan , maka daripada
berusaha merancang fasilitas system operasi dengan satu strategi penanggulangan
deadlock maka lebih efisien menggunakan strategi-strategi berbeda untuk situasi
berbeda. Silberschatz [SIL-94] menyarankan satu pendekatan teradu, yaitu
- Kelompokkan sumber daya-sumber daya menjadi sejumlah kelas sumber daya.
- Gunakan strategi pengurutan linear seperti yang didefinisikan pada pencegahan
menunggu sirkular.
- Dalam satu kelas sumber daya , gunakan algoritma yang paling cocok untuk kelas-
kelas sumber daya.
