Rahmady Liyantantoliyantanto@gmail.comliyantanto.wordpress.com

Sistem Operasi

D3 Manajemen Informatika Universitas Trunojoyo

Konsep SinkronisasiRace ConditionProblem Critical SectionSemaphore

Seperti yang telah kita ketahui bahwa proses dapat bekerja sendiri (independent process) dan juga dapat bekerja bersama proses-proses yang lain (cooperating process).

Pada umumnya ketika proses saling bekerjasama (cooperating process) maka proses-proses tersebut akan saling berbagi data. Pada saat proses-proses berbagi data, ada kemungkinan bahwa data yang dibagi secara bersama itu akan menjadi tidak konsisten dikarenakan adanya kemungkinan proses-proses tersebut melakukan akses secara bersamaan yang menyebabkan data tersebut berubah, hal ini dikenal dengan istilah Race Condition.

Produser/Konsumer

Pada program produser/konsumer tersebut dapat kita lihat pada baris 12 dan

baris 23 terdapat perintah counter++ dan counter-- yang dapat

diimplementasikan dengan bahasa mesin sebagai berikut:

Counter (1)

Dapat dilihat jika perintah dari counter++ dan counter-- dieksekusi secara

bersama maka akan sulit untuk mengetahui nilai dari counter sebenarnya

sehingga nilai dari counter itu akan menjadi tidak konsisten.

Counter (2)

Dapat dilihat jika perintah dari counter++ dan counter-- dieksekusi secara

bersama maka akan sulit untuk mengetahui nilai dari counter sebenarnya

sehingga nilai dari counter itu akan menjadi tidak konsisten.

•Pada contoh tersebut dapat kita lihat bahwa counter memiliki dua

buah nilai yaitu bernilai tiga (pada saat counter++ dieksekusi) dan bernilai

satu (pada saat counter-- dieksekusi).

•Hal ini menyebabkan nilai dari counter tersebut menjadi tidak

konsisten. Perhatikan bahwa nilai dari counter akan bergantung dari

perintah terakhir yang dieksekusi.

•Oleh karena itu maka kita membutuhkan sinkronisasi yang

merupakan suatu upaya yang dilakukan agar proses-proses yang saling

bekerja bersama-sama dieksekusi secara beraturan demi mencegah

timbulnya suatu keadaan yang disebut dengan Race Condition.

Race condition menyebabkan data tidak sinkron lagi karena nilai akhirnya akan tergantung pada proses mana yang terakhir dieksekusi.

Solusinya adalah Menemukan jalan untuk mencegah lebih dari satu proses melakukan proses tulis atau baca kepada data atau berkas pada saat yang bersamaan.

Dengan kata lain, kita membutuhkan cara yang menjamin jika ada sebuah proses yang menggunakan variabel atau berkas yang sama (digunakan juga oleh proses lain), maka proses lain akan dikeluarkan dari pekerjaan yang sama, proses itu adalah Mutual Exclusion

Biasanya sebuah proses akan sibuk melakukan perhitungan internal dan hal-hal lainnya tanpa ada bahaya yang menuju ke race condition pada sebagian besar waktu. Akan tetapi, beberapa proses memiliki suatu segmen kode dimana jika segmen itu dieksekusi, maka proses-proses itu dapat saling mengubah variabel, mengupdate suatu tabel, menulis ke suatu file, dan lain sebagainya, dan hal ini dapat membawa proses tersebut ke dalam bahaya race condition. Segmen kode yang seperti inilah yang disebut Critical Section.

Mendesain sebuah protokol di mana proses-proses dapat menggunakannya secara bersama-sama. Setiap proses harus 'meminta izin' untuk memasuki critical section-nya.

Bagian dari kode yang mengimplementasikan izin ini disebut entry section. Akhir dari critical section itu disebut exit section. Bagian kode selanjutnya disebut remainder section.

Struktur umum dari proses Pi yang memiliki segmen critical section adalah:

Critical Section (1)

Solusi dari masalah critical section harus memenuhi tiga syarat berikut [Silbeschatz 2004]:

1. Mutual Exclusion.

Jika suatu proses sedang menjalankan critical

section-nya, maka proses-proses lain tidak dapat menjalankan critical section mereka. Dengan kata lain, tidak ada dua proses yang berada di critical

section pada saat yang bersamaan.

2. Terjadi kemajuan (progress).Jika tidak ada proses yang sedang menjalankan critical section-nya dan ada proses-proses lain yang ingin masuk ke critical section, maka hanya proses-proses yang yang sedang berada dalam entry section saja yang dapat berkompetisi untuk mengerjakan critical section.3. Ada batas waktu tunggu (bounded waiting).Jika seandainya ada proses yang sedang menjalankan critical section, maka proses lain memiliki waktu tunggu yang ada batasnya untuk menjalankan critical section-nya, sehingga dapat dipastikan bahwa proses tersebut dapat mengakses critical section-nya (tidak mengalami starvation: proses seolah-olah berhenti, menunggu request akses ke critical section diperbolehkan).

Semaphore adalah pendekatan yang diajukan oleh Djikstra

Prinsipnya dua proses atau lebih dapat bekerjasama dengan menggunakan penanda-penanda sederhana.

Variabel khusus untuk penanda disebut semaphore

Sifat-sifat semaphore Dapat diinisialisasi dengan nilai non-

negatif Terdapat dua operasi : Down (Wait) dan

Up (Signal)Operasi Down dan Up adalah atomic,

tak dapat diinterupsi sebelum diselesaikan.

Operasi ini menurunkan menilai semaphore Jika nilai semaphore menjadi non-positif

maka proses yang mengeksekusinya di-block

Operasi ini menaikkan menilai semaphore Jika satu proses atau lebih di-block pada

semaphore tidak dapat menyelesaikan operasi Down, maka salah satu dipilih oleh sistem dan menyelesaikan operasi Down-nya. Pemilihan proses dilakukan secara acak.

Wait(S) {while S <= 0 do noop; /* busy wait! */S = S – 1; /* S >= 0 */}

Signal (S){S = S + 1;}

Semaphore S memiliki nilai (S.val), dan suatu thread list (S.list).

Wait (S) / Down(S)S.val = S.val - 1If S.val < 0 /* negative value of S.val */

{ add calling thread to S.list; /* is # waiting threads */

block; /* sleep */}

Signal (S) / Up(S)S.val = S.val + 1If S.val <= 0

{ remove a thread T from S.list;

wakeup (T);}

Ada tiga hal yang selalu menjadi masalah pada sinkronisasi : Problem Bounded Buffer Problem Dining Philosopher Problem Sleeping Barber Problem Readers and Writers

Producer and consumerare separate threads

8 Buffers

InP

OutP

Consumer

Producer

Permasalahan : bagaimana jika dua proses Permasalahan : bagaimana jika dua proses berbeda, yaitu produsen dan konsumen, berusaha berbeda, yaitu produsen dan konsumen, berusaha mengakses buffer tersebut dalam waktu mengakses buffer tersebut dalam waktu bersamaan.bersamaan.

thread producer {thread producer {while(1){while(1){ // Produce char c// Produce char c while (count==n) {while (count==n) { no_opno_op }} buf[InP] = cbuf[InP] = c InP = InP + 1 mod nInP = InP + 1 mod n count++count++}}

}}

thread consumer {thread consumer {while(1){while(1){ while (count==0) {while (count==0) { no_opno_op }} c = buf[OutP]c = buf[OutP] OutP = OutP + 1 mod nOutP = OutP + 1 mod n count--count-- // Consume char// Consume char}}

}}

0

1

2

n-1

…

Global variables:Global variables: char buf[n]char buf[n] int InP = 0 // place to addint InP = 0 // place to add int OutP = 0 // place to getint OutP = 0 // place to get int countint count

0 thread producer {0 thread producer {11 while(1){while(1){22 // Produce char c...// Produce char c...33 down(empty_buffs)down(empty_buffs)44 buf[InP] = cbuf[InP] = c55 InP = InP + 1 mod nInP = InP + 1 mod n66 up(full_buffs)up(full_buffs)7 }7 }8 }8 }

0 thread consumer {0 thread consumer {11 while(1){while(1){22 down(full_buffs)down(full_buffs)33 c = buf[OutP]c = buf[OutP]44 OutP = OutP + 1 mod nOutP = OutP + 1 mod n55 up(empty_buffs)up(empty_buffs)66 // Consume char...// Consume char...77 }}8 }8 }

Global variablesGlobal variables semaphore full_buffs = semaphore full_buffs = 00;; semaphore empty_buffs = semaphore empty_buffs = nn;; char buff[n];char buff[n]; int InP, OutP;int InP, OutP;

Lima filosof duduk dalam satu meja Satu garpu terletak diantara masing-

masing filosof Saat makan membutuhkan 2 garpu Bagaimana mencegah deadlock ?

while(TRUE) {while(TRUE) { Think();Think(); Grab first fork;Grab first fork; Grab second fork;Grab second fork; Eat();Eat(); Put down first fork;Put down first fork; Put down second fork;Put down second fork;}}

Each philosopher ismodeled with a thread

#define N 5#define N 5

Philosopher() {Philosopher() { while(TRUE) {while(TRUE) { Think();Think(); take_fork(i);take_fork(i); take_fork((i+1)% N);take_fork((i+1)% N); Eat();Eat(); put_fork(i);put_fork(i); put_fork((i+1)% N);put_fork((i+1)% N); }}}}

// only called with mutex set!// only called with mutex set!

test(int i) {test(int i) { if (state[i] == HUNGRY &&if (state[i] == HUNGRY && state[LEFT] != EATING &&state[LEFT] != EATING && state[RIGHT] != EATING){state[RIGHT] != EATING){ state[i] = EATING;state[i] = EATING; signal(sem[i]);signal(sem[i]); }}}}

int state[N]int state[N]semaphore mutex = 1semaphore mutex = 1semaphore sem[i]semaphore sem[i]

take_forks(int i) {take_forks(int i) { wait(mutex);wait(mutex); state [i] = HUNGRY;state [i] = HUNGRY; test(i);test(i); signal(mutex);signal(mutex); wait(sem[i]);wait(sem[i]);}}

// only called with mutex set!// only called with mutex set!

test(int i) {test(int i) { if (state[i] == HUNGRY &&if (state[i] == HUNGRY && state[LEFT] != EATING &&state[LEFT] != EATING && state[RIGHT] != EATING){state[RIGHT] != EATING){ state[i] = EATING;state[i] = EATING; signal(sem[i]);signal(sem[i]); }}}}

int state[N]int state[N]semaphore mutex = 1semaphore mutex = 1semaphore sem[i]semaphore sem[i]

put_forks(int i) {put_forks(int i) { wait(mutex);wait(mutex); state [i] = THINKING;state [i] = THINKING; test(LEFT);test(LEFT); test(RIGHT);test(RIGHT); signal(mutex);signal(mutex);}}

Barber : Ketika ada orang yang menunggu untuk potong

rambut, letakkan satu orang ke kursi, dan memotong rambut

Jika sudah selesai, pindah ke pelanggan berikutnya Jika tidak ada pelanggan maka tidur, sampai ada

pelanggan yang datang

Customer : Jika tukang potong rambut tidur, bangunkan barber Jika ada orang yang sedang potong rambut, tunggu

barber dengan duduk di kursi tunggu Jika kursi tunggu penuh, tinggalkan toko

Bagaimana kita memodelkan barber dan customer ?

What state variables do we need? Variabel keadaan seperti apa yang kita butuhkan ?

.. dan yang mana di-share ? …. dan bagaimana kita akan memproteksinya ?

Bagaimana membuat barber tidur ? Bagaimana membuat barber bangun ? Bagaimana membuat customer menunggu ? What problems do we need to look out for?

Barber Thread:Barber Thread: while truewhile true Wait(customers)Wait(customers) Lock(lock)Lock(lock) numWaiting = numWaiting-1numWaiting = numWaiting-1 Signal(barbers)Signal(barbers) Unlock(lock)Unlock(lock) CutHair()CutHair() endWhileendWhile

Customer Thread:Customer Thread: Lock(lock)Lock(lock) if numWaiting < CHAIRSif numWaiting < CHAIRS numWaiting = numWaiting+1numWaiting = numWaiting+1 Signal(customers)Signal(customers) Unlock(lock)Unlock(lock) Wait(barbers)Wait(barbers) GetHaircut()GetHaircut() else else -- give up & go home-- give up & go home Unlock(lock)Unlock(lock) endIfendIf

const CHAIRS = 5const CHAIRS = 5var customers: Semaphorevar customers: Semaphore barbers: Semaphorebarbers: Semaphore lock: Mutexlock: Mutex numWaiting: int = 0numWaiting: int = 0

Banyak reader dan writer ingin mengakses suatu database yang sama (masing-masing satu thread)

Banyak reader dapat diproses secara bersamaan

Writer harus di-sinkronisasi dengan reader dan writer yang lain Hanya satu writer pada satu waktu ! Ketika seseorang ingin menulis, harus tidak ada

reader !

Tujuan : Memaksimumkan concurrency. Mencegah starvation.

Bagaimana membuat model readers dan writers ?

Bagaimana variabel keadaan yang kita perlukan ? .. dan yang mana di-share ? …. dan bagaimana kita akan memproteksinya ?

Bagaimana membuat writers menunggu ? Bagaimana membuat writer bangun ? Bagaimana membuat readers menunggu ? Bagaimana membuat readers bangun ?

Reader Thread:Reader Thread:

while truewhile true Lock(mut)Lock(mut) rc = rc + 1rc = rc + 1 if rc == 1if rc == 1 Wait(db)Wait(db) endIfendIf Unlock(mut)Unlock(mut) ... Read shared data...... Read shared data... Lock(mut)Lock(mut) rc = rc - 1rc = rc - 1 if rc == 0if rc == 0 Signal(db)Signal(db) endIfendIf Unlock(mut)Unlock(mut) ... Remainder Section...... Remainder Section... endWhileendWhile

var var mut: Mutex = unlockedmut: Mutex = unlocked db: Semaphore = 1db: Semaphore = 1 rc: int = 0rc: int = 0

Writer Thread:Writer Thread:

while truewhile true ...Remainder Section......Remainder Section... Wait(db)Wait(db) ...Write shared data......Write shared data... Signal(db)Signal(db) endWhileendWhile

Critical section adalah suatu segmen kode yang mengakses data yang digunakan secara bersama-sama. Problema critical section yaitu bagaimana menjamin bahwa jika suatu proses sedang menjalankan critical section, maka proses lain tidak boleh masuk ke dalam critical section tersebut.