Sistem Operasi Sistem Operasi 6666

“Process “Process Synchronization”Synchronization”

Antonius Rachmat C, S.Kom, M.CsAntonius Rachmat C, S.Kom, M.Cs

Paralel ProcessingParalel Processing• Paralel processing is a situation in which

two/more processor operate in unison. – Executing instruction simultaneously

• Benefits: increase reliability & faster processing

• Evolution:• Evolution:– Job level: each job has its own processor and

all processes and threads are run by the same processor

– Process level: unrelated process, are assigned to any available processor

– Thread level: threads are assigned to avaliable processor

Mengapa SinkronisasiMengapa Sinkronisasi• Sinkronisasi diperlukan untuk menghindari

terjadinya ketidak konsistenan dataakibat adanya akses data secara konkuren

• Diperlukan adanya suatu mekanisme untuk memastikan urutan / giliran

• Diperlukan adanya suatu mekanisme untuk memastikan urutan / giliranpengaksesan suatu data yang saling bekerjasama sehingga terjadi sinkronisasi

• If we don’t make process synchronization:– Race Condition

Producer and ConsumerProducer and Consumer

#define BUFFER_SIZE 10

typedef struct {

. . .

} item;} item;

item buffer[BUFFER_SIZE];

int in = 0;

int out = 0;

int counter = 0;

Producer Producer while (true) {

/* produce an item and put in nextProduced */while (count == BUFFER_SIZE){} // do nothingbuffer [in] = nextProduced;buffer [in] = nextProduced;in = (in + 1) % BUFFER_SIZE;count++;

}

ConsumerConsumer

while (true) {

while (count == 0){

} // do nothing

nextConsumed = buffer[out];nextConsumed = buffer[out];

out = (out + 1) % BUFFER_SIZE;

count--;

/* consume the item in nextConsumed

}

Atomic ProcessAtomic Process

• The statements

counter++;counter--;

must be performed atomically.

• Atomic operation means an operation that completes in its entirety without interruption.

BoundedBounded--BufferBuffer• 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– 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, tergantungdari penjadwalan yang dilakukan terhadap proses yang dilakukan oleh produsen dan konsumen.

• Dengan kata lain, masalah tersebut belum tentu terjadi, tapi dapat terjadi

MisalnyaMisalnya

• Consider this execution interleaving with “count = 5” initially:

t0: producer execute register1 = count {register1 = 5}

t1: producer execute register1 = register1 + 1 {register1 = 6} 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 ConditionRace 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 dataproses mana yang terakhir mengubah data

• Untuk menghindari terjadinya situasi tersebut, semua proses yang dapat mengakses suatu data tertentu harus disinkronisasi

Critical SectionCritical 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.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 Solusi masalah critical sectionsection

• 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 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 solusiImplementasi solusi

• Solusi perangkat lunak

– Dengan menggunakan algoritma-algoritmayang nilai kebenarannya tidak tergantung pada asumsi-asumsi lain, selain bahwa setiap proses berjalan pada kecepatan yang bukan nolberjalan pada kecepatan yang bukan nol

• Solusi perangkat keras

– Tergantung pada beberapa instruksi mesintertentu, misalnya dengan me-non-aktifkan interuppt atau dengan mengunci (lock) suatu variabel tertentu

Implementasi software dan Implementasi software dan asumsinyaasumsinya

• 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 1Algoritma 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 waitingIf P0 selesai menggunakan critical section, turn diset ke 1, tapi P1 tidak ingin masuk ke critical section, jadi turn tidak akan diset ke 0.

Demo Algoritma 1Demo Algoritma 1

Algoritma 2Algoritma 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 waiting

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…

Demo Algoritma 2Demo Algoritma 2

Peterson’s AlgorithmPeterson’s Algorithm

• The two processes share two variables:– int turn;

–Boolean flag[2];–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 Algorithm for Process PPiiwhile (true) {

flag[i] = TRUE;turn = j;while ( flag[j] && turn == j);

CRITICAL SECTION

flag[i] = FALSE;flag[i] = FALSE;

REMAINDER SECTION

}

Mutual exclusion, progress, and bounded waiting!If P0 want to access critical section, P0 will set flag[0] to true and turn to P1.

Demo PetersonDemo Peterson

Bakery AlgorithmBakery AlgorithmCritical 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, • 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 AlgorithmBakery Algorithm

SinkronisasiSinkronisasi• Metode dalam sinkronisasi hardware

– Processor Synchronous ( Disable Interrupt )– Memory Synchronous ( Instruksi Test-And-Set )

• Processor synchronous– Dengan men-disable interupsi (interrupt)– Dalam lingkungan multiprocessor: – Dalam lingkungan multiprocessor:

• Hanya satu processor bisa didisable interruptnya

• Memory synchronous– Instruksi Test-And-Set dan Semaphore– Dalam lingkungan multiprocessor:

• Bisa dilakukan• Semua processor tidak dapat memakai resource karena proteksi

dilakukan di memory

– Instruksi harus bersifat atomik

TestTestAndSetAndSet dengan Javadengan Java

Kelemahan: bisa terjadi starvation & busy waiting

Mutual Exclusion: Memory Mutual Exclusion: Memory synchronoussynchronous

• Kelebihan:– Dapat diaplikasikan ke beberapa prosesor,

dengan sharing memory– Simpel– Dapat digunakan untuk banyak critical section

• Kekurangan:• Kekurangan:– Busy-waiting memakan processor time yang

besar– Mungkin terjadi starvation – Deadlock (not responding)

• 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

SemaphoreSemaphore• Invented by Djikstra (1960)• Semaphore digunakan untuk memberi

sinyal/tanda• Non negative integer, untuk

melambangkan jumlah resources• Jika proses menunggu sinyal, maka dia

akan ditunda sampai sinyal yg ditunggu • 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

SemaphoreSemaphore• 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; // 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 Semaphore: Wait -- SpinlockSpinlock

Semaphore: Wait Semaphore: Wait –– non non spinlockspinlock

Semaphore: SignalSemaphore: Signal

Contoh SemaphoreContoh Semaphore

Test(s) = if mutex > 0 then mutex = mutex – 1Inc(s) = mutex = mutex + 1

Implementasi SemaphoreImplementasi Semaphore

• Windows– Fungsi yg dipakai adalah CreateSemaphore

– Biasanya digunakan untuk membatasi jumlah thread yang memakai suatu resource secara bersamaanbersamaan

• Java– Semafor di Java™ bersifat transparan oleh

programmer• Java™ menyembunyikan Semafor dibalik konsep

monitor

• Reserved Word yang dipakai Java™ adalah synchronized

Classical Problems of Classical Problems of SynchronizationSynchronization

• Bounded-Buffer Problem

• Readers and Writers Problem

• Dining-Philosophers Problem

Bounded BufferBounded Buffer• Pengertian: tempat penampung data yang

ukurannya terbatas• Contoh: proses produsen dan

konsumen• Masalah produsen-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 Penyelesaian dgn SemaphoreSemaphore

• Semafor mutex– Menyediakan mutual exclusion untuk

mengakses buffer

– Inisialisasi dengan nilai 1

• Semafor full• 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 ProducerBounded Buffer Producer• Init => full = 0, empty = n, mutex = 1

Bounded Buffer ConsumerBounded Buffer Consumer

Contoh Producer & Contoh Producer & ConsumerConsumer

Demo Producer & ConsumerDemo Producer & Consumer

The ReadersThe Readers--Writers Writers ProblemProblem

• Multiple readers or a single writer can use DB.

writer

writer

reader

reader

reader

readerwriter

writer

reader

reader

reader

reader

X XX

Reader & WritersReader & 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 dan inkonsisten• Tujuan: data tidak korup dan inkonsisten

• 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 DataShared Data

• Data set

• Semaphore mutex initialized to 1, tanda mutual exclusion

• Semaphore wrt initialized to 1, tanda • Semaphore wrt initialized to 1, tanda untuk menulis

• Integer readcount initialized to 0, tanda untuk membaca

ReadersReaders--WritersWriters• The structure of a writer process

while (true) {

wait (wrt) ;

// writing is performed// writing is performed

signal (wrt) ;

}

ReadersReaders--WritersWriters• 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) ;

}

Demo Reader & WriterDemo Reader & Writer

Dining PhilosopherDining Philosopher• Diketahui:

– Mie (Data)– Sebuah meja bundar– N filsuf duduk melingkar di meja

bundar– Antara dua filsuf terdapat

sebuah sumpitsebuah sumpit– Didepan setiap filsuf terdapat

semangkuk mie

• Setiap filsuf hanya dapat berada pada salah satu kondisi berikut:– Berpikir– Lapar– Makan

Dining PhilosopherDining Philosopher

• Shared data

–Bowl of rice (data set)

–Semaphore chopstick [5] initialized to 1

• Dua hal yang harus diperhatikan:• 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 iThe Structure of Philosopher i

� Philosopher I

While (true) { wait ( chopstick[i] ); //kananwait ( chopStick[ (i + 1) % 5] ); //kiriwait ( chopStick[ (i + 1) % 5] ); //kiri

// eat

signal ( chopstick[i] ); //kanansignal (chopstick[ (i + 1) % 5] ); //kiri

// think

}

Picked upWaiting

A deadlock occurs!

Demo Dining PhilosopherDemo Dining Philosopher

Kelemahan SemaphoreKelemahan Semaphore

• Termasuk Low Level

• Kesulitan dalam pemeliharaannya, karena tersebar dalam seluruh program.

• Menghapus wait => dapat terjadi non-• Menghapus wait => dapat terjadi non-mutual exclusion.

• Menghapus signal => dapat terjadi deadlock

• Error yang terjadi sulit untuk dideteksi

System ModelSystem 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 • 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 MediaTypes of Storage Media

• Volatile storage – information stored here does not survive system crashes

– Example: main memory, cache

• Nonvolatile storage – information • 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

LogLog--Based RecoveryBased 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, includingincluding• Transaction name• Data item name• Old value• New value

– <Ti starts> written to log when transaction Tistarts

– <Ti commits> written when Ti commits

LogLog--Based Recovery Based Recovery AlgorithmAlgorithm

• 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(T ) and redo(T ) must be idempotent• 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)

CheckpointsCheckpoints

• Log could become long, and recovery could take long

• Checkpoints shorten log and recovery time.

• Checkpoint scheme:• 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

NEXTNEXT

• Deadlock