Bab 6: Sinkronisasi Proses. Latar Belakang

Transkripsi

1 Bab 6: Sinkronisasi Proses Latar Belakang Permasalahan Critical-Section Hardware Sinkronisasi Semaphores Permasalahan Klasik Sinkronisasi Sinkronisasi pada Solaris 2 dan Windows Latar Belakang Akses yang konkuren pada shared data kemungkinan menghasilkan inkonsistensi Mempertahankan konsistensi data membutuhkan mekanisme untuk mejamin eksekusi yang teratur pada proses yang saling bekerjasama (cooperating processes). Solusi Shared-memory untuk permasalahan boundedbuffer memungkinkan terdapat n 1 item dalam buffer pada waktu yang sama. Sebuah solusi, dimana semua buffer N digunakan bukan sesuatu yang sederhana Misalnya kita memodifikasi kode program produsenkonsumen dengan menambahkan variabel counter, diinisialisasi ke 0 dan bertambah setiap kali item baru ditambahkan ke buffer 7.2 1

2 Bounded-Buffer Shared data #define BUFFER_SIZE 10 typedef struct {... } item; item buffer[buffer_size]; int in = 0; int out = 0; int counter = 0; 7.3 Bounded-Buffer Proses Produser item nextproduced; while (1) { while (counter == BUFFER_SIZE) ; /* do nothing */ buffer[in] = nextproduced; in = (in + 1) % BUFFER_SIZE; counter++; } 7.4 2

3 Bounded-Buffer Proses Konsumer item nextconsumed; while (1) { while (counter == 0) ; /* do nothing */ nextconsumed = buffer[out]; out = (out + 1) % BUFFER_SIZE; counter--; } 7.5 Bounded Buffer Pernyataan counter++; counter--; harus dilakukan secara atomik Operasi atomik maksudnya operasi yang menyelesaikan pekerjaannya tanpa interupsi 7.6 3

4 Bounded Buffer Pernyataan counter++ apabila diimplementasikan dalam bahasa mesin sbb: register1 = counter register1 = register1 + 1 counter = register1 Pernyataan counter-- diimplementasikan sbb: register2 = counter register2 = register2 1 counter = register2 7.7 Bounded Buffer Jika baik produser dan konsumer melakukan update buffer secara konkuren (bersamaan), pernyataan bahasa assembly tersebut akan disisipkan Penyisipan tergantung bagaimana proses produser dan konsumer dijadwalkan 7.8 4

5 Bounded Buffer Misalkan counter diinisialisasi 5. Sebuah pernyataan penyisipan sbb: produser: register1 = counter (register1 = 5) produser: register1 = register1 + 1 (register1 = 6) konsumer: register2 = counter (register2 = 5) konsumer: register2 = register2 1 (register2 = 4) produser: counter = register1 (counter = 6) konsumer: counter = register2 (counter = 4) Nilai counter dapat bernilai 4 atau 6, dimana hasil yang benar seharusnya 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

6 Permasalahan Critical-Section n proses semua berkompetisi menggunakan shared data Setiap proses mempunyai segmen kode yang disebut critical section, dimana shared data diakses. Permasalahan menjamin ketika satu proses menjalankan critical section nya, tidak ada proses lain yang mengeksekusi critical section nya Solusi Permasalahan Critical- Section 1. Mutual Exclusion. Jika proses P i mengekseskusi critical section nya, maka tidak ada proses lain yang dapat mengeksekusi critical section nya. 2. Progress. Jika tidak ada proses yang mengeksekusi critical section nya dan terdapat beberapa proses yang akan memasuki critical section, maka pemilihan proses yang akan memasuki critical section berikutnya tidak dapat ditunda tanpa batas 3. Bounded Waiting. Ada batasan waktu tunggu ketika proses diizinkan untuk memasuki critical section setelah proses membuat permintaan untuk memasuki critical section dan sebelum permintaan yang diberikan. Diasumsikan setiap proses dieksekusi dengan kecepatan lebih dari 0 Tidak ada asumsi mengenai kecepatan relatif proses n

7 Cara Penyelesaian Hanya ada 2 proses, P 0 dan P 1 Struktur umum dari proses P i (proses lain P j ) do { entry section critical section exit section reminder section } while (1); Proses mungkin menggunakan variabel umum yang sama untuk sinkronisasi aksinya 7.13 Algoritma 1 Shared variable: int turn; initially turn = 0 turn = ip i can enter its critical section Proses P i do { while (turn!= i) ; critical section turn = j; reminder section } while (1); Memenuhi mutual exclusion, tetapi tidak memenuhi progress

8 Algoritma 2 Shared variable: boolean flag[2]; initially flag [0] = flag [1] = false. flag [i] = truepp i ready to enter its critical section Proses P i do { flag[i] := true; while (flag[j]) ; critical section flag [i] = false; remainder section } while (1); Memenuhi mutual exclusion, tetapi tidak memenuhi progress Algoritma 3 (Peterson) Mengkombinasikan shared variable dari algoritma 1 dan 2. Proses P i do { flag [i]:= true; turn = j; while (flag [j] and turn = j) ; critical section flag [i] = false; remainder section } while (1); Memenuhi tiga hal untuk pemecahan permasalahan critical-section untuk 2 proses

9 Algoritma Bakery Critical section untuk n proses Sebelum masuk ke critical section, proses menerima nomor. Pemegang nomor terkecil memasuki critical section. Jika proses P i dan P j menerima nomor yang sama, jika i < j, maka P i dilayani dahulu; apabila sebaliknya P j dilayani dahulu. Skema penomoran menggunakan nomor urut; misalnya 1,2,3,3,3,3,4, Algoritma Bakery Notasi < lexicographical order (ticket #, process id #) (a,b) < (c,d) jika a < c atau jika a = c dan b < d max (a 0,, a n-1 ) adalah sebuah nilai, k, dimana k a i for i - 0,, n 1 Shared data boolean choosing[n]; int number[n]; Struktur data diinisialisasi false dan

10 Algoritma Bakery do { choosing[i] = true; number[i] = max(number[0], number[1],, number [n 1])+1; choosing[i] = false; for (j = 0; j < n; j++) { while (choosing[j]) ; while ((number[j]!= 0) && (number[j],j < number[i],i)) ; } critical section number[i] = 0; remainder section } while (1); 7.19 Hardware Sinkronisasi Test and set memodifikasi nilai secara atomik. boolean TestAndSet(boolean &target) { boolean rv = target; target = true; } return rv;

11 Mutual Exclusion dengan Testand-Set Shared data: boolean lock = false; Proses P i do { while (TestAndSet(lock)) ; critical section lock = false; remainder section } 7.21 Hardware Sinkronisasi Secara atomik menukar 2 variabel. void Swap(boolean &a, boolean &b) { boolean temp = a; a = b; b = temp; }

12 Mutual Exclusion dengan Swap Shared data (diinisialisasi false): boolean lock; boolean waiting[n]; Proses P i do { key = true; while (key == true) Swap(lock,key); critical section lock = false; remainder section } 7.23 Semaphores Adalah perangkat sinkorinisasi yang tidak memerlukan busy waiting. Semaphore S variabel integer Hanya dapat diakses melalui 2 operasi atomik wait (S): while S 0 do no-op; S--; signal (S): S++;

13 Critical Section dari n Proses Shared data: semaphore mutex; //diinisialisasi mutex = 1 Proses Pi: do { wait(mutex); critical section signal(mutex); remainder section } while (1); 7.25 Implementasi Semaphore Tentukan semaphore sebagai typedef struct { int value; struct process *L; } semaphore; Diasumsikan 2 operasi sederhana: block menghentikan sementara (suspend) proses yang memanggil wakeup(p) melanjutkan (resume) eksekusi dari proses P yang di-blok

14 Implementasi Operasi Semaphore didefinisikan wait(s): S.value--; if (S.value < 0) { tambah proses ke S.L; block; } signal(s): S.value++; if (S.value <= 0) { menghapus proses P dari S.L; wakeup(p); } 7.27 Semaphore sebagai Perangkat Sinkronisasi Umum Eksekusi B oleh P j hanya setelah A dieksekusi pada P i Gunakan semaphore flag yang diinisialisasi 0 Kode: P i A signal(flag) P j wait(flag) B

15 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 P 0 P 1 wait(s); wait(q); wait(q); wait(s); signal(s); signal(q); signal(q) signal(s); Starvation blok yang tidak pasti. Sebuah proses mungkin tidak pernah dihapus dari antrian semaphore yang dihentikan sementara (suspend) 7.29 Dua Jenis Semaphores Counting semaphore nilai integer dapat berkisar melalui domain tak terbatas. Binary semaphore nilai integer dapat mempunyai jangkauan 0 dan 1; lebih sederhana untuk diimplementasikan Dapat mengimplementasikan counting semaphore S sebagai binary semaphore

16 Implementasi S sebagai Binary Semaphore Struktur Data: Inisialisasi: binary-semaphore S1, S2; int C: S1 = 1 S2 = 0 C = nilai awal dari semaphore S 7.31 Implementasi S Operasi wait Operasi signal wait(s1); C--; if (C < 0) { signal(s1); wait(s2); } signal(s1); wait(s1); C ++; if (C <= 0) signal(s2); else signal(s1);

17 Permasalahan Klasik Sinkronisasi Permasalahan Bounded-Buffer Permasalahan Readers and Writers Permasalahan Dining-Philosophers 7.33 Permasalahan Bounded-Buffer Shared data semaphore full, empty, mutex; Inisialisasi: full = 0, empty = n, mutex =

18 Permasalahan Bounded-Buffer Proses Produser do { memproduksi item pada nextp wait(empty); wait(mutex); tambahkan nextp ke buffer signal(mutex); signal(full); } while (1); 7.35 Permasalahan Bounded-Buffer Proses Konsumer do { wait(full) wait(mutex); mengambil item dari buffer ke nextc signal(mutex); signal(empty); mengkonsumsi item pada nextc } while (1);

19 Permasalahan Readers-Writers Shared data semaphore mutex, wrt; Inisialisasi mutex = 1, wrt = 1, readcount = Permasalahan Readers-Writers Proses Writer wait(wrt); menulis signal(wrt);

20 Permasalahan Readers-Writers Proses Reader wait(mutex); readcount++; if (readcount == 1) wait(wrt); signal(mutex); membaca wait(mutex); readcount--; if (readcount == 0) signal(wrt); signal(mutex): 7.39 Permasalahan Dining- Philosophers Shared data semaphore chopstick[5]; Inisialisasi semua nilai dg

21 Permasalahan Dining- Philosophers Philosopher i: do { wait(chopstick[i]) wait(chopstick[(i+1) % 5]) makan signal(chopstick[i]); signal(chopstick[(i+1) % 5]); berfikir } while (1); 7.41 Sinkronisasi Solaris 2 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

22 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