Transcript pertemuan7 Sinkronisasi Proses

“Sinkronisasi Proses”



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
#define BUFFER_SIZE 10
typedef struct {
. . .
} item;
item buffer[BUFFER_SIZE];
int in = 0;
int out = 0;
int counter = 0;
while (true) {
}
/* produce an item and put in
nextProduced */
while (count == BUFFER_SIZE){
} // do nothing
buffer [in] = nextProduced;
in = (in + 1) % BUFFER_SIZE;
count++;
while (true) {
while (count == 0){
} // do nothing
nextConsumed = buffer[out];
out = (out + 1) % BUFFER_SIZE;
count--;
/* consume the item in nextConsumed
}

The statements
counter++;
counter--;
must be performed atomically.

Atomic operation means an operation that
completes in its entirety without
interruption.

Perintah “count++” diimplementasikan pada bahasa mesin:

Perintah “count--” diimplementasikan pada bahasa mesin:



◦ register1 = counter
◦ register1 = register1 + 1
◦ counter = register1
◦ 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

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: 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


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.

Mutual Exclusion

Terjadi kemajuan (Progress)

Ada batas waktu tunggu (Bounded Waiting)
◦ Tidak ada dua proses yang berada di critical section pada
saat yang bersamaan.
◦ 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.
◦ 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.

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



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.



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.

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…

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!
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.
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



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
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

Kelebihan:

Kekurangan:
◦ Dapat diaplikasikan ke beberapa prosesor,
dengan sharing memory
◦ Simpel dan mudah diverifikasi
◦ Dapat digunakan untuk banyak critical section
◦ 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







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


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


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

Windows

Java
◦ Fungsi yg dipakai adalah CreateSemaphore
◦ Biasanya digunakan untuk membatasi jumlah
thread yang memakai suatu resource secara
bersamaan
◦ Semafor di Java™ bersifat transparan oleh
programmer
 Java™ menyembunyikan Semafor dibalik konsep monitor
 Reserved Word yang dipakai Java™ adalah synchronized



Bounded-Buffer Problem
Readers and Writers Problem
Dining-Philosophers Problem



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.

Semafor mutex

Semafor full

Semafor empty
◦ Menyediakan mutual exclusion untuk mengakses
buffer
◦ Inisialisasi dengan nilai 1
◦ Menyatakan jumlah buffer yang sudah terisi
◦ Inisialisasi dengan nilai 0
◦ Menyatakan jumlah buffer yang kosong
◦ Inisialisasi dengan nilai n (jumlah buffer)

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




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

The structure of a writer process
while (true) {
wait (wrt) ;
//
}
writing is performed
signal (wrt) ;

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) ;


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
 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

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!






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