Anda di halaman 1dari 5

Masalah-masalah Klafikasi Komunikasi

Antar Proses

1. Dining Philosophers Problem


Filosofi Masalah Makan Malam (The Dining Philosophers problem) adalah suatu
masalah klasik yang biasanya dinyatakan dalam istilah terminologi non-OS. Ada filosofi
N duduk mengelilingi sebuah meja bundar memakan spaghetti dan membahas filsafat.
Masalahnya adalah bahwa setiap filsuf membutuhkan 2 garpu untuk makan, dan hanya
ada N garpu, satu diantara setiap 2 filsuf. Desain algoritma bahwa para filsuf yang dapat
mengikuti kejadian itu menjamin bahwa tidak ada yang kelaparan selama setiap filsuf
akhirnya berhenti makan, dan sedemikian rupa sehingga jumlah maksimum filsuf bisa
makan sekaligus.

*Diketahui:
– spaghetti (Data)
–Sebuah meja bundar
–N filsuf duduk melingkar di meja bundar
–Antara dua filsuf terdapat sebuah garpu
-Didepan setiap filsuf terdapat semangkuk
spaghetti
*Setiap filsuf hanya dapat berada pada salah satu kondisi
berikut:
–Berpikir
–Lapar
–Makan
Masalah yang terjadi :
-Deadlock : Semua filsuf ingin makan dan telah memegang garpu
Kondisi:
* Mutual Exclusion : Suatu kondisi dimana setiap sumber daya diberikan tepat pada
satu proses pada suatu waktu.
* Hold and Wait : Kondisi yang menyatakan proses-proses yang sedang memakai
suatu sumber daya dapat meminta sumber daya yang lain.
* No Preemption : Kondisi dimana suatu sumber daya yang sedang berada pada
suatu proses tidak dapat diambil secara paksa dari proses
tersebut,sampai proses itu melepaskannya.
* Circular Wait : Kondisi yang menyatakan bahwa adanya rantai saling meminta
sumber daya yang dimiliki oleh suatu proses oleh proses lainnya.

-Starvation : Ada filsuf yang kelaparan dalam waktu yang lama


Kondisi:
Waiting : suatu proses meninggalkan critical section dan lebih dari satu
proses menunggu (waiting).
Time Push Away : Beberapa proses dapat ditolak aksenya dalam waktu tak terbatas.

Berikut ini algoritma Dining Philosophers Problem :

Philosopher i:
While (true) {
wait (garpu [i] ); //kanan
wait (garpu [ (i + 1) % 5] ); //kiri
...
//makan
...
eatsignal (garpu [i] ); //kanan
signal (garpu [ (i + 1) % 5] ); //kiri
...
//berpikir
...
}

Motif:
- Operasi wait(S) dan signal(S) tersebar pada code program => manipulasi
langsung struktur data semaphore
- Bagaimana jika terdapat bantuan dari lingkungan HLL (programming) untuk
sinkronisasi ?
- Pemrograman tingkat tinggi disediakan sintaks-sintaks khusus untuk menjamin
sinkronisasi antar proses, thread.

Solusi:
Dilakukan operasi Semaphore, dengan sifat :

1. Semaphore dapat diinisialisasi dengan nilai non- negatif.


2. Terdapat dua operasi terhadap semaphore, yaitu Down dan Up. Usulan asli yang
disampaikan Djikstra adalah operasi P dan V.

a. Operasi Down
* Operasi ini menurunkan nilai semaphore, jika nilai semaphore menjadi non-positif
maka proses yang mengeksekusinya diblocked.
* Ilustrasi Block :
Type Semaphore = Integer,
Procedure Down(Var: semaphore);
Begin
s := s-1; if s <= 0 Then Begin
‘Tempatkan antrian pada antrian untuk semaphore s Proses
diblocked
End;
End.
* Operasi Down adalah atomic, tak dapat diinterupsi sebelum diselesaikan.
Menurunkan nilai, memeriksa nilai, menempatkan proses pada antrian dan
memblocked sebagai instruksi tunggal. Sejak dimulai, tak ada proses alain yang
dapat mengakses semaphore sampai operasi selesai atau diblocked.
b. Ope rasi Up
* Operasi Up menakkan nilai semaphore. Jika satu proses atau lebih diblocked pada
semaphore itu tak dapat menyelesaikan operasi Down, maka salah satu dipilih oleh
system dan menyelesaikan operasi Down- nya. Urutan proses yang dipilih tidak
ditentukan oleh Djikstra, dapat dipilih secara acak.
* Block :
Type Semaphore = Integer,
Procedure Down(Var: semaphore);
Begin
s := s + 1; if s <= 0 Then
Begin
‘Pindahkan satu proses P dari antrian untuk semaphore s Tempatkan proses P di
senarai ready
End;
End.

Program (solusi mengatasi Deadlock):


#define N 100 /* Number of free slots */
semaphore mutex = 1;
semaphore empty = N;
semaphore full = 0;
void producer() {
item i;
while (1) {
i = produce_item();
P(mutex);
P(empty);
insert_new_item(i);
V(mutex);
V(full);
}
}
void consumer() {
item i;
while(1) {
P(full);
P(mutex);
i = get_next_item();
V(mutex);
V(empty);
consume_item(i);
}
}

Kelemahan Semaphore:
-Termasuk Low Level
-Kesulitan dalam pemeliharaannya, karena tersebar dalam seluruh program.
-Menghapus wait => dapat terjadi non- mutual exclusion.
-Menghapus signal => dapat terjadi deadlock
-Error yang terjadi sulit untuk dideteksi

2. Readers-writers Proble ms
Readers-writers adalah salah satu masalah klasik dalam proses sinkronisasi. Masalah ini
timbul ketika ada dua proses atau lebih berbagi data yang sama. Data yang dimaksud
disini bisa berbentuk buffer, file, atau objek dari suatu program. Sebagian proses
bermaksud untuk membaca data tersebut, yang kemudian disebut reader(s). Sebagian
proses mempunyai kemampuan untuk mengubah isi dari data tersebut, sehingga disebut
writer(s).

Tujuan: data tidak korup dan inkonsisten

Kondisi:
–Proses-proses pembaca dapat membaca sumber daya secara simultan
–Hanya boleh ada satu penulis menulis pada setiap saat
–Bila ada yang menulis, tidak boleh ada yang membaca

Masalah yang terjadi :


-Jika beberapa readers membaca data pada saat yang sama, maka tidak akan terjadi
masalah.
-Masalah akan timbul ketika sebuah writer mengakses data bersamaan dengan proses
yang lain, apalagi dengan reader(s). Data yang diakses tidak akan memberikan hasil
sebagaimana mestinya.

Solusi :
a. Pembaca diprioritaskan :
- Reader tidak akan menunggu reader(s) lain yang sedang membaca, walaupun ada
writer yang sedang menunggu.
- Dengan kata lain, jika ada reader yang datang ketika reader lain sedang membaca
dan sebuah writer sedang menunggu, maka reader yang baru datang tersebut akan
langsung mendapat giliran untuk membaca. Writer akan ditunda pengerjaannya.
b. Penulis Diprioritaskan :
Di mana suatu writer sedang dijalankan oleh sistem, maka tidak boleh ada reader
yang memulai untuk membaca data.
c. Kedua Jenis Proses Mempunyai Prioritas yang Sama :
Tidak ada prioritas khusus yang diberikan kepada kedua jenis proses.

Algoritma:
* Writers Process:
wait(wrt);

‘melakukan penulisan

signal(wrt);

* Readers Process:
wait(mutex);
readcount++;
if (readcount == 1)
wait(rt);
signal(mutex);

reading is performed

wait(mutex);
readcount--;
if (readcount == 0)
signal(wrt);
signal(mutex):

Kelemahan solusi:

a. Karena reader yang terus didahulukan, maka kemungkinan writer(s) akan mengalami
starvation.

b. Karena writer yang terus didahulukan, maka kemungkinanreader(s) akan mengalami


starvation.

By: Rahmad N Hutagalung, ST