Singkronisasi proses

-Peningkatan system operasi.kriteria;

-untilitas cpu&throughput(tinggi)
-turnaround time,waiting time,redpondse time(rendah)

-Multiprogramming&multitasking

-memungkinkan banyak proses
-perlu menjadwal

-Algoritma :FCFS,SJF,RR,multilevel

-Penjadwalan pada thread & multiprosesor

-homogen
-heterogen: simentrik&asimentrik

-Mempelajari kosnsep kritikal section dalam kaitanya  dengan  kosistensi data bersama 
(shared data)

-Mempelajari solusi critical section dari sisi hardware maupun software

-Mempelajari konsep transaksi atomic dan mekanisme menjamin atomicity

-Akses ke shared data,dari proses-peroses yang saling kerja sama ketergantungan ,concurrent,memungkinkan inkonsistensi data

-Merawat konsistensi data membutuhkan mekanisme untuk menjamin eksekusi”terurut” dari -proses-proses yang saling tergantung

-Ilustrasi: couter pada producer-consumer

-Producer: menambah counter saat menghailkan data
   while(count==BUFFER.SIZE)

;//do nothing while buffer full

// add an item to the buffer
buffer[in]=item;
in=(in+1)% BUFFER.SIZE;

++count;

-Consumer: mengurangi counter saat membaca data

While (count==0)

;//do nothing while buffer empty

//remove an item from the buffer

Item=buffer[out];

Out=(out+1)% BUFFER.SIZE;

--count;

Beberapa terminology

-Mutual exclusion:jika proses Pi sedang berada dalam critical section,tidak ada proses lain yang mengaksesnya.

-Critical section: code segment yang harus dieksekusi ddengan cara mutual exclution

-Atomic operation: sebuah oprasi yang ketika dijalankan harus diselesaikan tanpa terbagi(uninterrupted)

Algoritma Pi

While(true){

Flage[i]=true

Turn=j;

While(flag[j]&& turn==j)

//critical selection

Flag[i]=false

//remainder section

}

Sinkronisasi perangkat keras

-Beberapa system menggunakan perangkat keras untuk mendukung eksekusi intruksi-intruksi pada critical section

-Proesor tunggal: dapat mencegah interrupt

-Intruksi-intruksi critical section yang sdang dieksekusi tidak dapat diinterupt

-Tidak efisien pada system multiprosesor

-Mesin-mesin terkini: menyediakan intruksi khusus yang bersifat atomic (non-intrruptable)

-Jika ada dua thread yang secara bersama mengeksekusi intruksi tersebur, perangkat keras akan mengeksekusinya bergiliran

Semaphore tanpa busy waiting

-Setiap Semaphore memiliki hubungan dengan waiting queue:

-setiap entry dalam waiting queue memiliki dua data : value(int)& pointr kelist berikutnya.

-Dua operasi terkait Smaphore:

-Block: menempatkan proses ke waiting queue.

-Wakeup: mengembalikan proses dari waiting queue ke ready queue

Wait(s){

Value--;

If(value<0){

/*ke waiting queue*/

Block();

}

}

Signal(s){

Value++;

If(value<=0){

/*ke ready queue*

Wakeup();

}

}

-Deadlock : dua atau lebih proses menunggu tanpa batas waktu

-Starvation: sebuah proses terblokir dalam waiting queue tanpa batas waktu

Masalah klasik sinkronisasi

-Bounded Buffer(dijkstra)

-Readers Writers(courtois,heymans,parnas)

-Dining Philosopher(dijkstra)

Bounded Buffer

-terhadap N buffer yang masing-masing menyimpan satu item

-Semaphore mutex: diinisialisasi menjadi 1

-Semaphore full: diinisialisasi menjadi 0

-Semaphore empty: siinisialisasi menjadi N

Readers-Writers

-Data set di-shared kesemua proses concurrent

-Readers: hanya membaca shared data

-Writers: membaca dan menulis

-maslah; hanya ada satu proses writers,tetapi semua proses bias sebagai readers

-Shared data;

-data set

-Semaphore mutex:diinisiasi ke 1

-Semaphore wrt:diinisiasi ke 1.

-Semaphore readcount: diinisiasi ke0

Proses Writers

Do{

Wait(wrt);

/*writing*/

Signal(wrt);

}while(TRUE)

Proses Readers

Do{

Wait(mutex);

Readcount++;

If(readcount==1) wait(wrt);

Signal(mutex);

/*reading*/

Wait(mutex);

Readcount--;

If(readcount==0) signal(wrt);

Signal(mutex);

}while(TRUE)