Os06

Sistem Operasi - Sinkronisasi Proses -

S ISTEM O PERASI
- S INKRONISASI P ROSES -

Arya Adhyaksa Waskita

Fakultas Ilmu Komputer
Universitas Pembangunan Nasional Veteran Jakarta

14 April 2012


AGENDA

1 R EVIEW
2 OVERVIEW & O BYEKTIF
3 KONSEP C RITICAL S ECTION
4 C RITICAL S ECTION
5 S INKRONISASI PERANGKAT KERAS
6 S EMAPHORE
7 M ASALAH KLASIK SINKRONISASI
8 M ONITOR

Review

O UTLINE

1 R EVIEW
6 S EMAPHORE
8 M ONITOR

Review

P ERTEMUAN KE -5

Meningkatkan kualitas sistem operasi. Kriteria:
utilitas CPU & throughput (tinggi)
turnaround time, waiting time, response time (rendah)
Multiprogramming & multitasking
memungkinkan banyak proses
perlu penjadwal
Algoritma: FCFS, SJF, RR, multilevel
Penjadwalan pada thread & multiprosesor
homogen
heterogen: simetrik & asimetrik

Overview & Obyektif

O UTLINE

1 R EVIEW
6 S EMAPHORE
8 M ONITOR

Overview & Obyektif

Mempelajari konsep critical section dalam kaitannya dengan konsistensi
data bersama (shared data)
Mempelajari solusi critical section dari sisi hardware maupun software
Mempelajari konsep transaksi atomic dan mekanisme menjamin
atomicity

Konsep Critical Section

O UTLINE

1 R EVIEW
6 S EMAPHORE
8 M ONITOR


L ATAR BELAKANG

Akses ke shared data, dari proses-proses 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: counter pada producer-consumer
producer: menambah counter saat menghasilkan data
consumer: mengurangi counter saat membaca data


I LUSTRASI : Producer

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


I LUSTRASI : Consumer

while (count == 0)
; // do nothing while buffer empty
// remove an item from the buffer
item = buffer[out];
out = (out + 1) % BUFFER.SIZE;
- -count;


A SUMSI

register R1: melakukan operasi biner untuk kondisi pengisian buffer
register R2: melakukan operasi biner untuk kondisi pengambilan isi
buffer
Operasi count++
R1=count
R1=R1 + 1
count=R1
Operasi counter- -
R2=count
R2=R2 - 1
count=R2


K ASUS ( KONDISI race)

Dengan asumsi operasi count++ dan count- -, dimungkinkan terjadi kondisi
berikut (counter=5)
T0: producer execute R1 = count {R1 = 5}
T1: producer execute R1 = R1 + 1 {R1 = 6}
T2: consumer execute R2 = count {R2 = 5}
T3: consumer execute R2 = R2 - 1 {R2 = 4}
T4: producer execute count = R1 {count = 6 }
T5: consumer execute count = R2 {count = 4}


I LUSTRASI

G AMBAR : Kondisi race

Critical Section

O UTLINE

1 R EVIEW
6 S EMAPHORE
8 M ONITOR

Critical Section

B EBERAPA TERMINOLOGI

Mutual exclusion: jika proses Pi sedang berada dalam critical section,
tidak ada proses lain yang boleh mengaksesnya
Critical section: code segment yang harus dieksekusi dengan cara
mutual exclusion
Atomic operation: sebuah operasi yang ketika dijalankan harus
diselesaikan tanpa terbagi (uninterrupted)

Critical Section

I LUSTRASI

G AMBAR : Struktur critical section

Critical Section

S OLUSI P ETERSON

Asumsi:
Instruksi LOAD dan STORE bersifat atomik (tidak dapat diinterupsi)
Menggunakan dua variabel sebagai indikator, jika keduanya sama,
proses boleh masuk ke critical section:
int turn: mengindikasikan proses mana yang akan masuk critical section
boolean ﬂag[2]: ﬂag[i]==true, menunjukkan bahwa proses ke-i siap untuk
masuk ke critical section

Critical Section

A LGORITMA Pi

while (true) {
flag[i] = true;
turn = j;
while (flag[j] && turn == j)
//critical section

flag[i] = false
//remainder section
}

Critical Section

S OLUSI critical section DENGAN lock

shared boolean lock=FALSE; /*shared variable*/
shared double amount, balance; /*shared variable*/
Program for p1 Program for p2
... ...
/*acquire lock*/ /*acquire lock*/
while(lock) {NULL;} while(lock) {NULL;}
lock=true; lock=true;
/*execute critical section*/ /*execute critical section*/
balance=balance+amount; balance=balance+amount;
/*release lock*/ /*release lock*/
lock=false; lock=false;

Sinkronisasi perangkat keras

O UTLINE

1 R EVIEW
6 S EMAPHORE
8 M ONITOR


Beberapa sistem menggunakan perangkat keras untuk mendukung
eksekusi instruksi-instruksi pada critical section
Prosesor tunggal: dapat mencegah interrupt
instruksi-instruksi critical section yang sedang dieksekusi tidak dapat
diinterupsi
tidak eﬁsien pada sistem multiprosesor
Mesin-mesin terkini: menyediakan instruksi khusus yang bersifat atomic
(non-interruptable)
jika ada dua thread yang secara bersama mengeksekusi instruksi
tersebut, perangkat keras akan mengeksekusinya bergiliran


I NSTRUKSI T ESTA ND S ET

D EFINITION

int TestAndSet(int* target) {
int returnval;
returnval=*target;
*target=1;
return returnval;
}


P ENERAPAN T ESTA ND S ET

do {
while(TestAndSet(&lock)) {
/*do nothing*/
}
/*do critical section*/
lock=0;
/*remainder section*/
}while(TRUE)


I NSTRUKSI SWAP

D EFINITION

void swap(boolean* a, boalean* b) {
boolean temp=*a;
*a=*b;
*b=temp;
}


P ENERAPAN SWAP

do {
key TRUE;
while(key==TRUE) {
swap(&lock,&key);
}
lock=FALSE;
}while(TRUE)

Semaphore

O UTLINE

1 R EVIEW
6 S EMAPHORE
8 M ONITOR

Semaphore

KONSEP

Variabel integer
Diakses melalui operasi atomic: acquire dan release, masing
disimbolkan dengan P dan V
Tidak menimbulkan busy waiting (dari looping)
Proses yang akan masuk ke critical section dan mendapati nilai
semaphore negatif dapat memblokir dirinya sendiri dengan berpindah
ke waiting queue (context switch). Setiap semaphore terhubung dengan
sebuah waiting queue.
Proses yang terblokir akan dikembalikan ke kondisi awal dengan
instruksi wakeup, sehingga dapat dipindahkan ke ready queue.
Varian: semaphore biner: nilai semaphore hanya bernilai 0 dan 1
mutex lock

Semaphore

KONSEP

Diakses melalui dua operasi atomic: wait/signal, acquire/release
Kedua operasi atomic tidak dapat dijalankan bersama di semaphore dan
waktu yang sama

wait(S) { signal(S) {
S++;
while(S<=0) { }

/*no operation*/
}
S--;
}

Semaphore

I LUSTRASI : PSEUDOCODE

acquire() {
while(value<=0) {
/*no operation*/
}
value--;
}
release() {
value++;
}

Semaphore

P ENGGUNAAN

Semaphore sem=new Semaphore(1);
sem.acquire();
sem.release();

Semaphore

P ENGGUNAAN
public class Worker implements Runnable {
private Semaphore sem;
public Worker(Semaphore sem) {
this.sem=sem;
}
public void run() {
while(true) {
sem.acquire();
criticalSection();
sem.release();
remainderSection();
}
}
}

Semaphore

P ENGGUNAAN

public class SemaphoreFactory {
public static void main(String args[]) {
Semaphore sem=new Semaphore(1);
Thread[] bees=new Thread[5];
for(int i=0;i<5;i++) {

bees[i]=new Thread(new Worker(sem));
}
for(int i=0;i<5;i++) {
bees[i].start();
}
}
}

Semaphore

P ENGGUNAAN

Semaphore

S EMAPHORE TANPA busy waiting

Setiap Semaphore memiliki hubungan dengan waiting queue:
Setiap entry dalam waiting queue memiliki dua data: value (int) & pointer
ke list berikutnya
Dua operasi terkait Smaphore:
block: menempatkan proses ke waiting queue
wakeup: mengembalikan proses dari waiting queue ke ready queue

Semaphore

P ENERAPAN

wait(S) { signal(S) {
value--; value++;
if(value<=0) {
if(value<0) {
/*ke ready queue*/
/*ke waiting queue*/ wakeup();
block(); }
} }
}

Semaphore

D EADLOCK DAN S TARVATION

Deadlock: dua atau lebih proses menunggu tanpa batas waktu
Starvation: sebuah proses terblokir dalam waiting queue tanpa batas
waktu
Contoh: proses P0 dan P1 dalam interaksi

Masalah klasik sinkronisasi

O UTLINE

1 R EVIEW
6 S EMAPHORE
8 M ONITOR


M ASALAH KLASIK SINKRONISASI

Bounded Buffer (Dijkstra)
Readers Writers (Courtois, Heymans, Parnas)
Dining Philosopher (Dijkstra)


B OUNDED B UFFER

Terdapat N buffer yang masing-masing menyimpan satu item
Semaphore mutex: diinisialisasi menjadi 1
Semaphore full: diinisialisasi menjadi 0
Semaphore empty: diinisialisasi menjadi N


B OUNDED B UFFER


B OUNDED B UFFER : P RODUCER


B OUNDED B UFFER : C ONSUMER


B OUNDED B UFFER : FACTORY


R EADERS -W RITERS

Data set di-shared ke semua proses concurent
Readers: hanya membaca shared data
Writers: membaca dan menulis
Masalah: hanya ada satu proses Writers, tetapi semua proses bisa
sebagai Readers
Shared data:
Data set
Semaphore mutex: diinisiasi ke 1
Semaphore wrt: diinisiasi ke 1
Semaphore readcount: diinisiasi ke 0


P ROSES W RITERS

do {
wait(wrt);
/*writing*/
signal(wrt);
}while(TRUE)


P ROSES R EADERS

do {
wait(mutex);
readcount++;
if(readcount==1) wait(wrt);
signal(mutex);
/*reading*/
wait(mutex);
readcount--;
if(readcount==0) signal(wrt);
signal(mutex);
}while(TRUE)


D INING P HILOSOPERS

G AMBAR : Ilustrasi


P ENERAPAN

do {
wait(chopstick[i]);
wait(chopstick[i+1]%5);
/*makan*/
signal(chopstick[i]);
signal(chopstick[i+1]%5);
/*berpikir*/
}while(TRUE)

Monitor

O UTLINE

1 R EVIEW
6 S EMAPHORE
8 M ONITOR

Monitor

M ONITOR

Mekanisme lain menjamin mutual exclusion
Hanya ada satu proses yang berada dalam monitor

Monitor

I LUSTRASI

G AMBAR : Ilustrasi Monitor

Monitor

K ASUS KHUSUS
Ada antrian khusus untuk kondisi khusus dalam monitor (x,y)
x.wait(): proses ditunda
x.signal(): resume

G AMBAR : Kondisi khusus

Os06

Empfohlen

Empfohlen

Weitere ähnliche Inhalte

Was ist angesagt?

Was ist angesagt? (19)

Ähnlich wie Os06

Ähnlich wie Os06 (20)

Os06