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

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