Sistem Operasi 6 Process Synchronization Mengapa Sinkronisasi Sinkronisasi

Sistem Operasi 6 “Process Synchronization”

Mengapa Sinkronisasi • Sinkronisasi diperlukan untuk menghindari terjadinya ketidakkonsistenan data akibat adanya akses data secara konkuren • Diperlukan adanya suatu mekanisme untuk memastikan urutan / giliran pengaksesan suatu data yang saling bekerjasama sehingga terjadi sinkronisasi • If we don’t make process synchronization: – Race Condition

Review: Producer and Consumer #define BUFFER_SIZE 10 typedef struct {. . . } item; item buffer[BUFFER_SIZE]; int in = 0; int out = 0; int counter = 0;

while (true) { } Producer /* produce an item and put in next. Produced */ while (count == BUFFER_SIZE){ } // do nothing buffer [in] = next. Produced; in = (in + 1) % BUFFER_SIZE; count++;

Consumer while (true) { while (count == 0){ } // do nothing next. Consumed = buffer[out]; out = (out + 1) % BUFFER_SIZE; count--; /* consume the item in next. Consumed }

Atomic Process • The statements counter++; counter--; must be performed atomically. • Atomic operation means an operation that completes in its entirety without interruption.

Bounded-Buffer • Perintah “count++” diimplementasikan pada bahasa mesin: – register 1 = counter – register 1 = register 1 + 1 – counter = register 1 • Perintah “count--” diimplementasikan pada bahasa mesin: – register 2 = counter – register 2 = register 2 – 1 – counter = register 2 • Jika kedua perintah tersebut berusaha mengakses nilai counter secara konkuren, maka dapat terjadi kesalahan pada nilai counter karena sifat bahasa mesin yang menggunakan register untuk mengupdate nilai counter • Kesalahan nilai akhir counter dapat terjadi, tergantung dari penjadwalan yang dilakukan terhadap proses yang dilakukan oleh produsen dan konsumen. • Dengan kata lain, masalah tersebut belum tentu terjadi, tapi dapat terjadi

Misalnya • Consider this execution interleaving with “count = 5” initially: t 0: producer execute register 1 = count {register 1 = 5} t 1: producer execute register 1 = register 1 + 1 {register 1 = 6} t 2: consumer execute register 2 = count {register 2 = 5} t 3: consumer execute register 2 = register 2 - 1 {register 2 = 4} t 4: producer execute count = register 1 {count = 6 } t 5: consumer execute count = register 2 {count = 4}

Race Condition • Race condition: situasi dimana beberapa proses mengakses dan memanipulasi suatu data secara konkuren. – Nilai akhir dari data tersebut tergantung dari proses mana yang terakhir mengubah data • Untuk menghindari terjadinya situasi tersebut, semua proses yang dapat mengakses suatu data tertentu harus disinkronisasi

Critical Section • Lebih dari satu proses berlomba-lomba pada saat yang sama untuk menggunakan data yang sama. • Setiap proses memiliki segmen kode yang digunakan untuk mengakses data yang digunakan secara bersama-sama. – Segmen kode tersebut disebut critical section. • Masalahnya: menjamin bahwa jika suatu proses sedang menjalankan critical section, maka proses lain tidak boleh masuk ke dalam critical section tersebut.

Solusi masalah critical section • Mutual Exclusion – Tidak ada dua proses yang berada di critical section pada saat yang bersamaan. • Terjadi kemajuan (Progress) – Jika tidak ada proses yang sedang berada di critical section, maka proses lain yang ingin menjalankan critical section dapat masuk ke dalam critical section tersebut. • Ada batas waktu tunggu (Bounded Waiting) – Tidak ada proses yang menunggu selama-lamanya untuk masuk ke dalam critical section – Assume that each process executes at a nonzero speed – Tidak ada asumsi lain mengenai kecepatan relatif setiap proses ataupun jumlah CPU.

Implementasi solusi • Solusi perangkat lunak – Dengan menggunakan algoritma-algoritma yang nilai kebenarannya tidak tergantung pada asumsi-asumsi lain, selain bahwa setiap proses berjalan pada kecepatan yang bukan nol • Solusi perangkat keras – Tergantung pada beberapa instruksi mesin tertentu, misalnya dengan me-non-aktifkan interuppt atau dengan mengunci (lock) suatu variabel tertentu

Implementasi software dan asumsinya • Misal hanya ada dua proses, yaitu P 0 dan P 1. • Struktur umum dari proses Pi (proses yang lain: Pj) • Proses-proses tersebut boleh berbagi beberapa variabel yang sama untuk mensinkronisasikan apa yang akan dilakukan oleh setiap proses tersebut.

Algoritma 1 • Variabel yang digunakan bersama: • – int turn; //pada awalnya turn = 0 – turn = i; //Pi dapat masuk ke critical section Untuk proses Pi • If P 0 ingin akses critical section turn diset ke 0, if P 1 juga akses, turn diset ke 1 Mutual exclusion but not progress nor bounded buffer If P 0 selesai menggunakan critical section, turn diset ke 1, tapi P 1 tidak ingin masuk ke critical section, jadi turn tidak akan diset ke 0.

Algoritma 2 • Variabel yang digunakan bersama: – boolean flag[2]; • pada awalnya flag [0] = flag [1] = false – flag [i] = true; //Pi dapat masuk ke critical section If P 0 mengakses critical section P 0 mengeset flag[0] ke True. Sementara P 1 masih menggunakan critical section, P 0 akan menunggu. If P 0 finish, P 0 akan set flag[0] ke false. Mutual exclusion but not progress nor bounded buffer Tapi jika P 0 & P 1 ingin akses ke critical section secara konkuren, keduanya akan set flag[0] & flag[1] ke true, dan semua proses menunggu terus…

Peterson’s Algorithm • The two processes share two variables: – int turn; – Boolean flag[2]; • The variable turn indicates whose turn it is to enter the critical section. • The flag array is used to indicate if a process is ready to enter the critical section. flag[i] = true implies that process Pi is ready!

Algorithm for Process Pi while (true) { flag[i] = TRUE; turn = j; while ( flag[j] && turn == j); CRITICAL SECTION flag[i] = FALSE; REMAINDER SECTION } Mutual exclusion, progress, and bounded buffer! If P 0 want to access critical section, P 0 will set flag[0] to true and turn to P 1.

Bakery Algorithm Critical section for: n processes • Sebelum memasuki critical section, setiap proses menerima sebuah nomor. • Yang memegang ID terkecil yang dilayani dahulu. • Skema penomoran selalu naik secara berurut, contoh: 1, 2, 2, 2, 3, 3, 4, 5… • Diperkenalkan pertama kali oleh Leslie Lamport. • Data yang digunakan bersama – boolean choosing [n]; – int number [n]; • Struktur data diinisialisi awal ke false dan 0. • (a, b) < (c, d) jika a < c atau jika a = c dan b < d

Bakery Algorithm

Sinkronisasi Hardware • Metode dalam sinkronisasi hardware – Processor Synchronous ( Disable Interrupt ) – Memory Synchronous ( Instruksi Test-And-Set ) • Interrupt used in Round Robin Algorithm, with quantum time • Processor synchronous – Dengan mendisable interupsi (interrupt) – Dalam lingkungan multiprocessor: • Hanya satu processor bisa didisable interruptnya • Memory synchronous – Instruksi Test-And-Set – Dalam lingkungan multiprocessor: • Bisa dilakukan • Semua processor tidak dapat memakai resource karena proteksi dilakukan di memory – Instruksi harus bersifat atomik

cek. And. Set dengan Java

Mutual Exclusion: Swap Hardware. Data lock = new Hardware. Data(false); // a shared lock Hardware. Data key = new Hardware. Data(true); // my key while (true) { key. set(true); // my key is now true do { lock. swap(key); // my key got lock’s content. 1 st Process 2 nd Process key true false I got it! 1 st swap 2 nd swap } while (key. get() == true); // this means lock was true locked! critical. Section( ); // now in critical section code lock. set(false); non. Critical. Section( ); // out of critical section } Lock false true

Mutual Exclusion: Memory synchronous • Kelebihan: – Dapat diaplikasikan ke beberapa prosesor, dengan sharing memory – Simpel dan mudah diverifikasi – Dapat digunakan untuk banyak critical section • Kekurangan: – Busy-waiting memakan processor time yang besar – Mungkin terjadi starvation – Deadlock • Jika low priority process mendapat critical region dan higher priority process butuh juga, higher priority process akan mendapat processor dan low priority process akan menunggu

Semaphore • Invented by Djikstra (1960) • Semaphore S – integer variable untuk menghitung berapa banyak proses yang aktif atau pasif • Semaphore digunakan untuk memberi sinyal • Jika proses menunggu sinyal, maka dia akan ditunda sampai sinyal yg ditunggu tersebut terkirim • Operasi: wait dan signal • Wait dan signal operations tidak dapat diinterupt • Queue digunakan untuk menahan proses yang sedang menunggu semaphore

Semaphore • Two standard operations modify S: wait() and signal() – Originally called P() and V() • Can only be accessed via two indivisible (atomic) operations – wait (S) { while S <= 0 ; // no-op S--; } jika s < 0 akan menunggu, lalu menjalankan proses lain – signal (S) { S++; } memberikan kesempatan bagi para proses untuk berkompetisi mendapatkan semafore

Semaphore: Wait - Spinlock

Semaphore: Wait – non spinlock

Semaphore: Signal

Implementasi Semafore • Untuk sinkronisasi antar proses: • Misal: – Inisialisasi: semafore = 0 Proses 1 56 Print “ 1” 57 Signal(S) Proses 2 17 Wait(S) 18 Print “ 2” Pasti output selalu 1 dan 2, walaupun Proses 2 duluan

Implementasi Semaphore • Windows – Fungsi yg dipakai adalah Create. Semaphore – Biasanya digunakan untuk membatasi jumlah thread yang memakai suatu resource secara bersamaan • Java – Semafor di Java™ bersifat transparan oleh programmer • Java™ menyembunyikan Semafor dibalik konsep monitor • Reserved Word yang dipakai Java™ adalah synchronized

Classical Problems of Synchronization • Bounded-Buffer Problem • Readers and Writers Problem • Dining-Philosophers Problem

Bounded Buffer • Pengertian: tempat penampung data yang ukurannya terbatas • Contoh: proses produsen dan konsumen • Masalah produsen-konsumen – Produsen menaruh data pada buffer. Jika buffer tersebut sudah terisi penuh, maka produsen tidak melakukan apa-apa dan menunggu sampai konsumen mengosongkan isi buffer. – Konsumen mengambil data dari buffer. Jika buffer tersebut kosong, maka konsumen tidak melakukan apa-apa dan menunggu sampai buffer tersebut diisi oleh produsen.

Penyelesaian dgn Semaphore • Semafor mutex – Menyediakan mutual exclusion untuk mengakses buffer – Inisialisasi dengan nilai 1 • Semafor full – Menyatakan jumlah buffer yang sudah terisi – Inisialisasi dengan nilai 0 • Semafor empty – Menyatakan jumlah buffer yang kosong – Inisialisasi dengan nilai n (jumlah buffer)

Bounded Buffer Producer • Init => full = 0, empty = n, mutex = 1

Bounded Buffer Consumer

The Readers-Writers Problem • Multiple readers or a single writer can use DB. writer X reader writer X X writer reader

Reader & Writers • Diketahui dua macam proses: – Pembaca (reader) – Penulis (writer) • Kedua jenis proses berbagi sumber daya penyimpanan yang sama, Misal: Basis data • Tujuan: data tidak korup. • Kondisi: – Proses-proses pembaca dapat membaca sumber daya secara simultan – Hanya boleh ada satu penulis menulis pada setiap saat – Bila ada yang menulis, tidak boleh ada yang membaca

Shared Data • Data set • Semaphore mutex initialized to 1, tanda mutual exclusion • Semaphore wrt initialized to 1, tanda untuk menulis • Integer readcount initialized to 0, tanda untuk membaca

Readers-Writers • The structure of a writer process while (true) { wait (wrt) ; // writing is performed signal (wrt) ; }

Readers-Writers • The structure of a reader process while (true) { wait (mutex) ; readcount ++ ; if (readcount == 1) wait (wrt) ; signal (mutex) // reading is performed } wait (mutex) ; readcount - - ; if (readcount == 0) signal (wrt) ; signal (mutex) ;

Dining Philosopher • Diketahui: – Mie (Data) – Sebuah meja bundar – N filsuf duduk melingkar di meja bundar – Antara dua filsuf terdapat sebuah sumpit – Didepan setiap filsuf terdapat semangkuk mie • Setiap filsuf hanya dapat berada pada salah satu kondisi berikut: – Berpikir – Lapar – Makan

Dining Philosopher • Shared data – Bowl of rice (data set) – Semaphore chopstick [5] initialized to 1 • Dua hal yang harus diperhatikan: – Deadlock: Semua filsuf ingin makan dan telah memegang sumpit – Starvation: Ada filsuf yang kelaparan dalam waktu yang lama

The Structure of Philosopher i n Philosopher I While (true) { wait ( chopstick[i] ); //kanan wait ( chop. Stick[ (i + 1) % 5] ); //kiri // eat signal ( chopstick[i] ); //kanan signal (chopstick[ (i + 1) % 5] ); //kiri Waiting Picked up // think } A deadlock occurs!

Kelemahan Semaphore • Termasuk Low Level • Kesulitan dalam pemeliharaannya, karena tersebar dalam seluruh program. • Menghapus wait => dapat terjadi nonmutual exclusion. • Menghapus signal => dapat terjadi deadlock • Error yang terjadi sulit untuk dideteksi • Lebih baik menggunakan high level construct

System Model • Assures that operations happen as a single logical unit of work, in its entirety, or not at all • Challenge is assuring atomicity despite computer system failures • Transaction - collection of instructions or operations that performs single logical function – Here we are concerned with changes to stable storage – disk – Transaction is series of read and write operations – Terminated by commit (transaction successful) or abort (transaction failed) operation – Aborted transaction must be rolled back to undo any changes it performed

Types of Storage Media • Volatile storage – information stored here does not survive system crashes – Example: main memory, cache • Nonvolatile storage – information usually survives crashes – Example: disk and tape • Stable storage – information never lost – Not actually possible, so approximated via replication or RAID to devices with independent failure modes

Log-Based Recovery • Record to stable storage information about all modifications by a transaction • Most common is write-ahead logging – Log on stable storage, each log record describes single transaction write operation, including • • Transaction name Data item name Old value New value – <Ti starts> written to log when transaction Ti starts – <Ti commits> written when Ti commits

Log-Based Recovery Algorithm • Using the log, system can handle any volatile memory errors – Undo(Ti) restores value of all data updated by Ti – Redo(Ti) sets values of all data in transaction Ti to new values • Undo(Ti) and redo(Ti) must be idempotent – Multiple executions must have the same result as one execution • If system fails, restore state of all updated data via log – If log contains <Ti starts> without <Ti commits>, undo(Ti) – If log contains <Ti starts> and <Ti commits>, redo(Ti)

Checkpoints • Log could become long, and recovery could take long • Checkpoints shorten log and recovery time. • Checkpoint scheme: 1. Output all log records currently in volatile storage to stable storage 2. Output all modified data from volatile to stable storage 3. Output a log record <checkpoint> to the log on stable storage

NEXT • Deadlock