Paralel processing Benefits Job level Process level Thread level

(1)

Sistem Operasi

6

“Process

Synchronization”

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

(2)

Paralel Processing

• Paralel processing is a situation in which

two/more processor operate in unison.

– Executing instruction simultaneously

• Benefits: increase reliability & faster

processing

• 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

(3)

Mengapa Sinkronisasi

• Sinkronisasi diperlukan untuk menghindari

terjadinya ketidak konsistenan data

akibat adanya akses data secara

konkuren

• Diperlukan adanya suatu mekanisme

untuk memastikan urutan / giliran

• Diperlukan adanya suatu mekanisme

untuk memastikan urutan / giliran

pengaksesan suatu data yang saling

bekerjasama sehingga terjadi

sinkronisasi

• If we don’t make process synchronization:

(4)

Producer and Consumer

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

(5)

Producer

while (true) {

/* produce an item and put in nextProduced */ while (count == BUFFER_SIZE){

} // do nothing

buffer [in] = nextProduced; buffer [in] = nextProduced; in = (in + 1) % BUFFER_SIZE;

count++;

(6)

Consumer

while (true) { while (count == 0){ } // do nothing nextConsumed = buffer[out]; nextConsumed = buffer[out];

out = (out + 1) % BUFFER_SIZE;

count--;

/* consume the item in nextConsumed

(7)

Atomic Process

• The statements

counter++;

counter--;

must be performed atomically.

• Atomic operation means an operation that

completes in its entirety without

(8)

Bounded

Bounded--Buffer

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

– 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,

(9)

Misalnya

• 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}

(10)

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 proses mana yang terakhir mengubah data

• Untuk menghindari terjadinya situasi

tersebut, semua proses yang dapat

mengakses suatu data tertentu harus

disinkronisasi

(11)

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.

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.

(12)

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 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.

(13)

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

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

(14)

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.

(15)

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 waiting

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.

(16)

Demo Algoritma 1

(17)

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 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…

(18)

Demo Algoritma 2

(19)

Peterson’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

P

_i

is ready!

(20)

Algorithm for Process

P

_ii

while (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.

(21)

Demo Peterson

(22)

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, • 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.

(23)

Bakery Algorithm

(24)

Sinkronisasi

• 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

(25)

Test

TestAndSet

AndSet dengan Java

dengan Java

(26)

Mutual Exclusion: Memory

synchronous

• Kelebihan:

– Dapat diaplikasikan ke beberapa prosesor, dengan sharing memory

– Simpel

– Dapat digunakan untuk banyak critical section

• 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

(27)

Semaphore

• 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

(28)

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 ; // no-op S--; }

jika s < 0 akan menunggu, lalu menjalankan proses lain

– signal (S) {

S++; }

memberikan kesempatan bagi para proses untuk berkompetisi mendapatkan semafore

(29)

Semaphore: Wait

(30)

Semaphore: Wait

Semaphore: Wait –

– non

non

spinlock

(31)

Semaphore: Signal

(32)

Contoh Semaphore

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

(33)

Implementasi Semaphore

• Windows

– Fungsi yg dipakai adalah CreateSemaphore – Biasanya digunakan untuk membatasi jumlah

thread yang memakai suatu resource secara bersamaan

bersamaan

• Java

– Semafor di Java™ bersifat transparan oleh programmer

• Java™ menyembunyikan Semafor dibalik konsep

monitor

• Reserved Word yang dipakai Java™ adalah

(34)

Classical Problems of

Synchronization

• Bounded-Buffer Problem

• Readers and Writers Problem

• Dining-Philosophers Problem

(35)

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.

(36)

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)

(37)

Bounded Buffer Producer

(38)

Bounded Buffer Consumer

(39)

Contoh Producer &

Consumer

(40)

Demo Producer & Consumer

(41)

The Readers

The Readers--Writers

Writers

Problem

• Multiple readers or a single writer can

use DB.

writer writer reader reader reader reader writer writer reader reader reader reader

X

(42)

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 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

(43)

Shared 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

(44)

Readers

Readers--Writers

Writers

• The structure of a writer process

while (true) { wait (wrt) ; // writing is performed // writing is performed signal (wrt) ; }

(45)

Readers

Readers--Writers

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) ; }

(46)

Demo Reader & Writer

(47)

Dining Philosopher

• Diketahui:

– Mie (Data)

– Sebuah meja bundar

– N filsuf duduk melingkar di meja bundar

– Antara dua filsuf terdapat sebuah sumpit

sebuah sumpit

– Didepan setiap filsuf terdapat semangkuk mie

• Setiap filsuf hanya dapat berada pada salah satu kondisi berikut:

– Berpikir – Lapar – Makan

(48)

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

(49)

The Structure of Philosopher i

Philosopher I

While (true) {

wait ( chopstick[i] ); //kanan

wait ( chopStick[ (i + 1) % 5] ); //kiri wait ( chopStick[ (i + 1) % 5] ); //kiri

// eat

signal ( chopstick[i] ); //kanan

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

}

Picked up Waiting

(50)

Demo Dining Philosopher

(51)

Kelemahan Semaphore

• Termasuk Low Level

• Kesulitan dalam pemeliharaannya, karena

tersebar dalam seluruh program.

• Menghapus wait => dapat terjadi

non-mutual exclusion.

• Menghapus signal => dapat terjadi

deadlock

(52)

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

• 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

(53)

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

(54)

Log

Log--Based Recovery

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

including

• Transaction name • Data item name • Old value

• New value

– <T_i starts> written to log when transaction T_i starts

(55)

Log

Log--Based Recovery

Based Recovery

Algorithm

• Using the log, system can handle any volatile memory errors

– Undo(T_i) restores value of all data updated by T_i

– Redo(T_i) sets values of all data in transaction T_i to new values

• Undo(T ) and redo(T ) must be idempotent

• Undo(T_i) and redo(T_i) 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 <T_i starts> without <T_i commits>,

undo(T_i)

(56)

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

(57)