Sinkronisasi Proses.

Presentasi berjudul: "Sinkronisasi Proses."— Transcript presentasi:

1 Sinkronisasi Proses

2 Materi Latar Belakang Masalah Critical Section Problem Peterson's Solution Sinkronisasi dengan Hardware Mutex Semaphore Problem Klasik Sinkronisasi Monitor Contoh pada Sistem Operasi Solusi Alternatif

3 Latar Belakang Masalah

4 Latar Belakang Beberapa process/thread dapat bekerjasama (cooperating) dan berbagi (sharing) data Masalah : Akses bersamaan pada shared data kemungkinan menghasilkan inkonsistensi data Contoh : bounded-buffer producer consumer Producer : memproduksi data dan dimasukkan ke buffer Consumer : mengonsumsi/mengambil data dari buffer Kapasitas buffer dibatasi Ada variabel counter pencatat jumlah data sekarang. Counter bernilai awal = 0 bertambah ketika data diproduksi (Producer) berkurang jika data dikonsumsi (Consumer)

5 Producer Consumer Shared Data Producer(P) Consumer(C)
counter : variabel pencatat jumlah data sekarang buffer[] : penampung data BUFFER_SIZE : jumlah maksimal buffer Producer(P) while (true) { // Jika yg diproduksi = batas, do nothing while (counter == BUFFER_SIZE); // Produksi data dan masukkan buffer buffer [in] = nextProduced; in = (in + 1) % BUFFER_SIZE; // Tambah counter dengan 1 counter++; } Consumer(C) while (true) { // Jika yang dikonsumsi = 0, do nothing while (counter == 0); // Konsumsi data nextConsumed = buffer[out]; out = (out + 1) % BUFFER_SIZE; // Kurangi counter dengan 1 counter--; } Q : Jika counter = 5, berapa nilai counter setelah satu kali iterasi secara concurrent ?

6 Nilai Counter counter++ dapat diimplementasikan dalam bahasa mesin sbb : registera = counter registera = registera + 1 counter = registera counter-- dapat diimplementasikan dalam bahasa mesin sbb : registerb = counter registerb = registerb - 1 counter = registerb Jika “counter = 5” dan producer-consumer dieksekusi secara concurrent maka urutan eksekusinya bisa jadi : Producer eksekusi : registera = counter {registera = 5} Producer eksekusi : registera = registera + 1 {registera = 6} Consumer eksekusi : registerb = counter {registerb = 5} Consumer eksekusi : registerb = registerb - 1 {registerb = 4} Producer eksekusi : counter = registera {counter = 6 } Consumer eksekusi : counter = registerb {counter = 4} Nilai counter dapat bernilai 4 atau 6. Padahal seharusnya 5 Problem : race condition

7 Problem : Race Condition
Race condition: Situasi dimana beberapa proses mengakses dan memanipulasi shared data secara bersamaan. Nilai akhir dari shared data tergantung proses yang diselesaikan paling akhir. Untuk mencegah race condition, proses konkuren harus di- sinkronisasi

8 Critical Section Problem

9 Critical Section Problem
Sebagai gambaran, sebuah sistem mempunyai n process yang saling berbagi shared data Setiap proses punya segmen kode yang disebut critical section, dimana shared data diakses. Contoh : ketika producer/consumer mengakses variabel counter

10 Solusi Critical Section Problem
Mutual Exclusion Jika suatu proses sedang menjalankan critical section-nya, maka proses-proses lain tidak dapat menjalankan critical section mereka. tidak ada dua proses yang berada dicritical section pada saat yang bersamaan. 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.

11 Solusi Critical Section Problem
Ada batas waktu tunggu (bounded waiting) Jika 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 lain tersebut dapat mengakses critical section-nya.

12 Algoritma Turn Hanya proses yang mempunyai ID yang sama dengan ID giliran (Turn) yang boleh masuk ke critical sectionnya

13 Algoritma Flag Setiap proses berusaha untuk mengecek state (keadaan) proses yg lain. Jika proses lain sedang berada di critical sectionnya, maka dia akan menunggu sampai proses lain tersebut keluar dari state critical sectionnya.

14 Peterson's Solution

15 Peterson's Solution Solusi sederhana sinkronisasi dua process
Contoh : Process Pi dan Pj Asumsi : instruksi LOAD dan STORE bersifat atomik (tidak bisa diinterupsi) Dua process berbagi variabel : int turn Array boolean flag[2] Variabel turn menunjukkan process mana yang masuk critical section Array flag menunjukkan bahwa sebuah process siap mengeksekusi critical section. flag[i] = true menunjukkan process Pi siap

16 Peterson's Solution untuk Process Pi
do { // Process Pi siap eksekusi, ganti giliran eksekusi ke Pj flag[i] = TRUE; turn = j; // Jika giliran Pi eksekusi critical section, Pj Do Nothing while (flag[j] && turn == j); critical section Pi flag[i] = FALSE; remainder section Pj } while (TRUE); Memenuhi 3 syarat : Mutual exclusion Progress Bounded waiting

17 Algoritma Bakery Algoritma ini digunakan untuk memecahkan masalah critical section untuk n buah proses, yang diilustrasikan dengan n buah pelanggan. Ketika memasuki toko, setiap pelanggan menerima sebuah nomor. tukang roti tidak dapat menjamin bahwa dua pelanggan tidak akan menerima nomor yang sama. dua proses menerima nomor yang sama, maka proses dengan nomor ID terkecil yang akan dilayani dahulu. Pi dan Pj menerima nomor yang sama dan i < j, maka Pi dilayani dahulu.

18 Sinkronisasi dengan Hardware

19 Sinkronisasi dengan Hardware
Banyak sistem menyediakan dukungan hardware untuk menangani critical section code Melakukan locking : memproteksi critical section dengan lock.

20 Solusi Critical Section dengan Locking
do { acquire lock critical section release lock remainder section } while (TRUE);

21 Sinkronisasi dengan Hardware
Pada single-processor Disable interrupt Code yang sedang dieksekusi tidak akan mengalami preemption (ada interrupt Jika ada proses baru yang prioritasnya lebih tinggi, proses yang terdapat pada CPU dihilangkan) TIDAK efisien untuk multiprocessor : pesan akan disebar ke semua processor Modern-computer Menyediakan instruksi hardware khusus yang atomik (tidak bisa diiterupsi) Dua pendekatan : Test and set Swap content of two memory words

22 Solusi Critical Section dengan TestAndSet
Shared boolean variable lock, initialized to FALSE Solution: do { // Do nothing jika lock = true while ( TestAndSet (&lock )); critical section lock = FALSE; // reset lock to false remainder section } while (TRUE); boolean TestAndSet (boolean *lock) { boolean rv = *lock; // set lock = TRUE, lock the execution *lock = TRUE; // return previous lock status return rv: }

23 Instruksi TestAndSet Definisi: Misal ada process Pi dan Pj
boolean TestAndSet (boolean *lock) { boolean rv = *lock; // set lock = TRUE, means lock the execution *lock = TRUE; // return previous lock status return rv: } Misal ada process Pi dan Pj Pi panggil TestAndSet saat parameter lock = False Return value = False, process Pi bisa akses critical section-nya Pj tidak bisa akses critical sectionnya karena lock=True oleh Pi Pi panggil TestAndSet saat parameter lock = True Return value = True, process Pi tidak bisa akses critical section-nya (Do Nothing) Pi tidak bisa akses critical sectionnya karena sebelumnya lock=True oleh Pj

24 Solusi Critical Section dengan Swap
Shared Boolean variable lock initialized to FALSE; Setiap process punya local variable key Solution: do { key = TRUE; while ( key == TRUE) Swap (&lock, &key ); // critical section lock = FALSE; // remainder section } while (TRUE); void Swap (boolean *lock, boolean *key) { boolean temp = *lock; // Swap content *lock = *key; *key = temp; }

25 Instruksi Swap Definisi: void Swap (boolean *lock, boolean *key) { }
boolean temp = *lock; // Swap content *lock = *key; *key = temp; } Misal ada process Pi dan Pj Pi panggil Swap saat parameter lock = False, key=True key = False, process Pi bisa akses critical section-nya Pj tidak bisa akses critical sectionnya karena lock=True oleh Pi Pi panggil Swap saat parameter lock = True, key=True, key = True, process Pi tidak bisa akses critical section-nya (Do Nothing) Pi tidak bisa akses critical sectionnya karena sebelumnya lock=True oleh Pj

26 Bounded-waiting Mutual Exclusion with TestandSet()
do { waiting[i] = true; key = true; while (waiting[i] && key) key = test and set(&lock); waiting[i] = false; /* critical section */ j = (i + 1) % n; while ((j != i) && !waiting[j]) j = (j + 1) % n; if (j == i) lock = false; else waiting[j] = false; /* remainder section */ } while (true);

27 Mutex Locks

28 Mutex Lock Sinkronisasi dengan hardware terlalu kompleks bagi programmer Desainer OS menyediakan software tool untuk critical-section problem Tools paling sederhana adalah mutex (mutually exclusion) Mutex lock biasanya diimplementasi dengan salah satu mekanisme sinkronisasi dengan hardware Mutex menyediakan 2 fungsi dasar : acquire lock : mengunci critical section release lock : melepas kunci

29 Acquire dan release menggunakan shared variable available
Acquire lock acquire() { while (!available); /* busy wait */ available = false; } Release lock release() { available = true; Solusi dengan mutex do { acquire lock critical section release lock remainder section } while (true);

30 Question Apa kelemahan mutex dan sinkronisasi dengan hardware?

31 Apa kelemahan mutex dan sinkronisasi dengan hardware?
Answer Apa kelemahan mutex dan sinkronisasi dengan hardware? Pada saat suatu critical section di lock oleh satu process, maka proses lain melakukan busy waiting. Busy waiting : menunggu dengan cara looping terus menerus sampai lock-nya dilepas. Disebut juga dengan spinlock karena proses lain melakukan "berputar" ketika menunggu Busy waiting menghabiskan siklus pemrosesan CPU yang seharusnya bisa dimanfaatkan secara produktif oleh proses lain.

32 Semaphore

33 Semaphore Perangkat sinkronisasi yang tidak memerlukan busy waiting.
Semaphore S – shared integer variable S hanya bisa diakses dengan 2 operasi atomik : wait dan signal wait : cek S dan mengurangi S dengan 1 wait (S) { while S <= 0; // no-op S--; } signal : menambah S dengan 1 signal (S) { S++;

34 Binary semaphore – nilai integer S dapat mempunyai jangkauan 0 atau 1
Dua Jenis Semaphore Counting semaphore – nilai integer S dapat berkisar melalui domain tak terbatas. Biasanya nilai S diinisiasi sebanyak resource yang dibagi Jika S=0, maka semua resource sedang dipakai Binary semaphore – nilai integer S dapat mempunyai jangkauan 0 atau 1 Lebih sederhana untuk diimplementasikan

35 Critical Section dengan Semaphore
Shared data: semaphore S; //diinisialisasi S = 1 Process Pi: do { wait(S); critical section signal(S); remainder section } while (1);

36 Implementasi Semaphore
Untuk menghindari busy waiting, process yang menunggu akses critical-section harus dihentikan sementara. Ada dua operasi sederhana yang terlibat : block : menghentikan sementara (suspend) proses yang memanggil wakeup(P) : melanjutkan (resume) eksekusi dari proses P yang di-blok Semaphore tanpa busy waiting butuh struktur data untuk menyimpan process yang sedang suspend. typedef struct { int value; struct process *Q; } semaphore;

37 Implementasi Semaphore
Operasi Semaphore didefinisikan wait(S){ if (S.value <= 0) { Tambah proses ke queue S.Q; block(); } else{ S.value--; signal(S){ Hapus proses P dari queue S.Q; wakeup(P); S.value++; do { wait(S); critical section signal(S); remainder section } while (1);

38 Masalah : Deadlock dan Starvation
Deadlock – dua atau lebih proses menunggu tanpa kepastian suatu event yang dapat disebabkan oleh satu proses yang sedang menunggu. Misalnya S dan Q adalah 2 semaphores yang diinisialisasi 1 Starvation : blocking terus menerus Sebuah proses mungkin tidak pernah dihapus dari antrian semaphore yang dihentikan sementara (suspend)

39 Permasalahan Klasik pada Sinkronisasi

40 Permasalahan Klasik pada Sinkronisasi
Ada beberapa permasalahan klasik dalam sinkronisasi Permasalahan Bounded-Buffer Permasalahan Readers and Writers Permasalahan Dining-Philosophers

41 Permasalahan Bounded-Buffer
N buffers, each can hold one item Shared data semaphore full, empty, mutex; Inisialisasi: full = 0, empty = n, mutex = 1

42 Bounded Buffer untuk Producer
do { ... memproduksi item nextp wait(empty); wait(mutex); tambahkan nextp ke buffer signal(mutex); signal(full); } while (1);

43 Bounded Buffer untuk Consumer
do { ... wait(empty); wait(mutex); mengambil item dari buffer ke nextc signal(mutex); signal(full); mengkonsumsi item pada nextc } while (1);

44 Permasalahan Readers-Writers
Sebuah dataset di-share untuk beberapa proses yang konkuren Readers : hanya membaca dataset Writers : membaca Masalah Ijinkan banyak reader untuk membaca dalam waktu bersamaan Ijinkan hanya satu writer mengakses dalam satu waktu Shared data Data set Semaphore mutex initialized to 1 Semaphore wrt initialized to 1 Integer readcount initialized to 0

45 Proses Writers do { wait (wrt) ; //writing is performed signal (wrt) ;
} while (TRUE);

46 Proses Readers do { wait (mutex) ; readcount ++ ; if (readcount == 1)
wait (wrt) ; signal (mutex) ... // reading is performed readcount - - ; if (readcount == 0) signal (wrt) ; signal (mutex) ; } while (TRUE);

47 Permasalahan Dining-Philosophers
Filosofer menghabiskan hidupnya hanya untuk makan dan berpikir Tidak ada interaksi dengan sebelahnya Setiap filosofer mencoba mengambil 2 chopstick untuk makan nasi dari mangkok Butuh 2 chopstick untuk makan Shared data Bowl of rice (data set) Semaphore chopstick [5] initialized to 1

48 Filosofer i do { wait ( chopstick[i] );
// Makan signal ( chopstick[i] ); signal (chopstick[ (i + 1) % 5] ); // Berpikir } while (TRUE);

49 Monitor

50 Monitor Baca textbook section 5.8 chapter 5

51 Sinkronisasi pada Beberapa OS

52 Sinkronisasi pada Linux
Prior to kernel Version 2.6, disables interrupts to implement short critical sections Version 2.6 and later, fully preemptive Linux provides: semaphores spinlocks reader-writer versions of both On single-cpu system, spinlocks replaced by enabling and disabling kernel preemption

53 Sinkronisasi pada Solaris
Mengimplementasikan beberapa lock kunci untuk mendukung multitasking, multithreading (termasuk thread real-time), dan multiprocessing. Menggunakan adaptive mutexes untuk efisiensi ketika melindungi data dari segmen kode pendek Menggunakan condition variables dan readers-writers locks ketika segmen kode panjang memerlukan akses ke data. Menggunakan turnstiles untuk memesan daftar thread menunggu untuk memperoleh adaptive mutexes atau readers-writers locks

54 Sinkronisasi Windows 2000 Menggunakan interrupt mask untuk melindungi akses ke sumber daya global pada sistem prosesor tunggal. Menggunakan spinlocks pada sistem multiprosessor Juga menyediakan dispatcher object yang dapat bertindak sebagai mutex dan semaphore. Dispatcher object juga dapat menyediakan event. Event bertindak seperti sebuah variabel kondisi.

55 Pendekatan Alternatif

56 Pendekatan Alternatif
Baca textbook section 5.10 chapter 5