Sistem Operasi
“Process
Synchronization”
Mengapa Sinkronisasi
• Sinkronisasi diperlukan untuk menghindari
terjadinya inkonsistensi data akibat
adanya akses data secara konkuren
(bersamaan)
• 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;
Producer
while (true) {
}
/* produce an item and put in
nextProduced */
while (count == BUFFER_SIZE){
} // do nothing
buffer [in] = nextProduced;
in = (in + 1) % BUFFER_SIZE;
count++;
Consumer
while (true) {
while (count == 0){
} // do nothing
nextConsumed = buffer[out];
out = (out + 1) % BUFFER_SIZE;
count--;
/* consume the item in nextConsumed
}
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:
– register1 = counter
– register1 = register1 + 1
– counter = register1
• Perintah “count--” diimplementasikan pada bahasa mesin:
– register2 = counter
– register2 = register2 – 1
– counter = register2
• 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:
t0: producer execute register1 = count
{register1 = 5}
t1: producer execute register1 = register1 + 1 {register1 = 6}
t2: consumer execute register2 = count
{register2 = 5}
t3: consumer execute register2 = register2 - 1 {register2 = 4}
t4: producer execute count = register1 {count = 6 }
t5: consumer execute count = register2 {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 P0 dan P1.
• 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 P0 ingin akses critical section turn diset ke 0, if P1 juga akses,
turn diset ke 1
Mutual exclusion but not progress nor bounded buffer
If P0 selesai menggunakan critical section, turn diset ke 1, tapi P1
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 P0 mengakses critical section P0 mengeset flag[0] ke True.
Sementara P1 masih menggunakan critical section, P0 akan
menunggu. If P0 finish, P0 akan set flag[0] ke false.
Mutual exclusion but not progress nor bounded buffer
Tapi jika P0 & P1 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 P0 want to access critical section, P0 will set flag[0] to
true and turn to P1.
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
cekAndSet dengan Java
Mutual Exclusion: Swap
HardwareData lock = new HardwareData(false); // a
shared lock
HardwareData key = new HardwareData(true); // my key
while (true) {
key.set(true); // my key is now true
do {
lock.swap(key);
// my key got lock’s content.
1st Process
2nd Process
key
true
key
true
false
I got it!
1st swap
2nd swap
} while (key.get() == true); // this means lock
was true locked!
criticalSection( ); // now in critical section code
lock.set(false);
nonCriticalSection( ); // 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
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 CreateSemaphore
– 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
reader
writer
reader
reader
writer
X
X
writer
reader
reader
reader
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

Philosopher I
While (true) {
wait ( chopstick[i] ); //kanan
wait ( chopStick[ (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