MAKALAH SITEM OPERASI
SINKRONISASI
OLEH :
Nama :
NADIYA SAFITRI
Npm : 19316014
Kelas : TK
19B
UNIVERSITAS
TEKNOKRAT INDONESIA
FAKULTAS
TEKNIK DAN ILMU KOMPUTER
TAHUN PELAJARAN
2020/2021
KATA
PENGANTAR
Puji syukur kehadirat ALLAH SWT yang
telah memberikan rahmat dan hidayah-Nya. Dengan rahmat dan hidayah-Nya,
Alhamdulillah Makalah yang berjudul “PROCESS SYNCHRONIZATION” ini dapat terselesaikan dangan tepat waktu.
Makalah ini kami buat untuk memenuhi tugas dari mata kuliah Sistem Operasi.
Terima
kasih juga kepada Bapak dosen Pembimbing Sistem Operasi yang telah memberi kami
arahan untuk menyelesaikan tugas pembuatan makalah ini.
Kami berharap kepada semua pihak dengan segala kritik dan saran yang
bersifat membangun, sangat kami harapkan untuk dimasa yang akan datang agar
bisa menyempurnakan makalah ini, sebab makalah ini masih banyak kekurangannya.
Bandar
Lampung , 29 Oktober 2020
DAFTAR ISI
KATAPENGANTAR………...................................................................................................i
DAFTARISI.............................................................................................................................ii
BAB I PENDAHULUAN
1.1
Latar
Belakang...............................................................................................................4
1.2 Rumusan Masalah................................................................................................................4
1.3 Tujuan..................................................................................................................................4
BAB II PEMBAHASAN
2.1 Sinkronisasi Proses.............................................................................................................5
2.1.1
Sistem Shared-Memory.......................................................................................6
2.1.2 Sistem Message-Passing......................................................................................7
2.2 Tujuan
Sinkronisasi..............................................................................................................7
2.2.1 Sinkronisasi............................................................................................................7
2.3 Masalah dalam Sinkronisasi Beserta Solusinya
2.3.1
Race
Condition......................................................................................................9
2.3.2
Solusi
Algoritma I.................................................................................................10
2.3.3
Solusi
Algoritma II................................................................................................11
2.3.4
Solusi
Banyak Proses (Algoritma Bakery) ...........................................................12
2.3.5
Transaksi
Atomik...................................................................................................13
2.3.6
Bounded
Buffer.....................................................................................................14
2.3.7 Readers/Writers......................................................................................................14
2.3.8
Makan
Malam Para Philosoper...............................................................................15
2.3.9
Critical
Region........................................................................................................16
2.3.10 Monitor.................................................................................................................18
PENUTUP
Kesimpulan.....................................................................................................................20
Daftar Pustaka.................................................................................................................20
BAB I
PENDAHULUAN
1.1 LATAR BELAKANG
Sinkornisasi di perlukan untuk menghindari terjadinyaketidakkonsistenan
data akibat adanya akses secara konkuren.Proses-Proses tersebut disebut
konkuren jika Proses itu ada dan berjalan pada waktu yang bersamaan.
istilah Sinkronisasi sering
terdengar ketika kita menggunakan alat elektronik. Sinkronisasi sendiri
berasal dari bagian sistem operasi.Sistem operasi adalah perangkat lunak sistem
yang bertugas untuk melakukan kontrol dan manajemen perangkat keras serta
operasi-operasi dasar sistem, termasuk menjalankan perangkat lunak aplikasi
seperti program-program pengolah kata dan peramban web.
Jadi, agar sinkronisasi bisa berjalan, sangat di butuhkan yang namanya sistem
operasi.Dalam kehidupan sehari-hari tanpa di sadari, kita sering melakukan
sinkronisasi dalam berbagai hal.Mulai pada saat menggunakan smartphone,
komputer dan lain sebagainya.
1.2 RUMUSAN MASALAH
1. Apa pengertian dari Sinkronisasi ?
2. Apa Tujuan Sinkronisasi ?
3. Apa saja masalah Sinkronisasi dan solusinya ?
1.3 TUJUAN
1. Mengetahui apa itu Sinkronisasi.
2. Mengetahui tujuan Sinkronisasi.
3. Mengetahui Masalah dalam
Sinkronisasi dan solusinya.
BAB II
PEMBAHASAN
SINKRONISASI
PROSES
Komunikasi
Interproses Proses yang bersifat simultan (concurrent) yang dijalankan pada
sistem operasi dapat dibedakan menjadi proses independent dan proses
kooperatif. Suatu proses dikatakan independent apabila proses tersebut tidak
dapat terpengaruh atau dipengaruhi oleh proses lain yang sedang dijalankan pada
sistem. Berarti, semua proses yang tidak membagi data apa pun (baik
sementara/tetap) dengan proses lain adalah independent. Sedangkan proses
kooperatif adalah proses yang dapat dipengaruhi atau pun terpengaruhi oleh
proses lain yang sedang dijalankan dalam sistem. Dengan kata lain, proses
dikatakan kooperatif bila proses dapat membagi datanya dengan proses lain.
Proses kooperatif dapat saja secara langsung membagi alamat logikal ruang (baik
data atau kode) atau mengijinkannya melalui file dan pesan. Proses simultan
dalam berbagi data dapat mengakibatkan data tidak konsisten. Ada empat alasan
untuk penyediaan sebuah lingkungan yang memperbolehkan terjadinya proses
kooperatif:
a. Pembagian informasi. Apabila beberapa pengguna
dapat tertarik pada bagian informasi yang sama (sebagai contoh, sebuah berkas
bersama), kita harus menyediakan sebuah lingkungan yang mengijinkan akses
secara terus menerus ke tipe dari sumber-sumber tersebut.
b. Kecepatan penghitungan/komputasi. Jika kita
menginginkan sebuah tugas khusus untuk menjalankan lebih cepat, kita harus
membagi hal tersebut ke dalam subtask, setiap bagian dari subtask akan
dijalankan secara paralel dengan yang lainnya. Peningkatan kecepatan dapat
dilakukan hanya jika komputer tersebut memiliki elemen-elemen pemrosesan ganda
(seperti CPU atau jalur I/O).
c. Modularitas. Kita mungkin ingin untuk membangun
sebuah sistem pada sebuah model modularmodular, membagi fungsi sistem menjadi
beberapa proses atau thread.
d. Kenyamanan. Bahkan seorang pengguna mungkin
memiliki banyak tugas untuk dikerjakan secara bersamaan pada satu waktu.
Sebagai contoh, seorang pengguna dapat mengedit, mencetak, dan mengkompilasi
secara paralel.
Kerja sama
antar proses membutuhkan suatu mekanisme yang memperbolehkan proses-proses
untuk mengkomunikasikan data dengan yang lain dan me-sinkronisasikan kerja mereka
sehingga tidak ada yang saling menghalangi. Salah satu cara proses dapat saling
berkomunikasi adalah Interprocess Communication (IPC).
Gambar 1 Model komunikasi (a) Message Passing(b)
Shared Memory
Ada dua hubungan dasar antar proses, yang terdiri dari:
a. Shared Memori. Dalam model ini, proses saling
berbagi memori. Untuk menjaga konsistensi data, perlu diatur proses mana yang
dapt mengakses memori pada suatu waktu.
b. Message
Passing. Pada model ini proses berkomunikasi lewat saling mengirimkan pesan.
Sistem
Shared-Memory
Ilustrasi
program di bawah ini sebagai contoh penggunaan memori bersama.
#define BUFFER_SIZE 10
typedef struct { ... }
item;
item
buffer[BUFFER_SIZE];
int in=0,out=0;
void producer(){
item nextp;
while (true){ while(((int+1) %
BUFFER_SIZE)==out); //no operation
buffer[in]=netxp;
in=(in+1) % BUFFER_SIZE;
}
}
void consumer(){
item nextc;
while(true){ while
(in==out); //no operation
nextc=buffer[out];
out=(out+1) % BUFFER_SIZE;
}
}
Pada program
di atas terdapat dua proses, yaitu Produsen dan Konsumen. Keduanya saling
berbagi memori yaitu buffer. Ada dua tipe buffer yang dapat digunakan yaitu unbound
buffer (buffer tidak terbatas) konsumen menunggu item baru terbentuk tetapi
produsen selalu menghasilkan item baru, dan bound buffer (buffer terbatas)
konsumen harus menunggu jika buffer kosong dan produsen harus menunggu jika
buffer penuh.
Sebuah proses produsen membentuk informasi yang
dapat digunakan oleh proses konsumen. Contohnya sebuah program pencetak membuat
banyak karakter yang diterima oleh driver pencetak. Untuk memperbolehkan proses
produsen dan konsumen agar dapat berjalan secara terus menerus, maka harus
disediakan buffer item yang dapat diisi oleh proses produsen dan dikosongkan
oleh proses konsumen. Proses produsen dapat memproduksi sebuah item ketika
konsumen sedang mengkonsumsi item yang lain. Produsen dan konsumen harus dapat
selaras, sehingga konsumen harus menunggu hingga sebuah item telah diproduksi.
Sistem
Message-Passing
Sistem ini menyediakan suatu mekanisme agar
proses-proses dapat berkomunikasi dan mesinkronkan tugas-tugasnya tanpa harus
berbagi pakai ruang alamat yang sama dan terutama digunakan dalam lingkungan
terdistribusi, dimana komunikasi proses terjadi antar komputer yang terhubung
melalui jaringan. Fasilitas yang disediakan terdiri dari dua operasi yaitu send(message)
dan receive(message). Pengiriman pesan ukuran yang tetap maupun
dinamis.
Jika suatu
proses P dan Q berkomunikasi diantaranya harus mengirimkan pesan dan menerima
pesan dari yang lainnya. Beberapa metode hubungan komunikasi antar proses
tersebut diantaranya adalah:
• Komunikasi langsung dan tidak langsung
• Komunikasi
sinkron dan asinkron
• Penyangga
(buffering) otomatis dan eksplisit.
Tujuan Sinkronisasi
Tujuan dari sinkronisasi itu
sendiri ialah untuk menghindari terjadinya inkonsitensi data karena pengaksesan
oleh beberapa proses yang berbeda serta untuk mengatur urutan jalannya
proses-proses sehingga dapat berjalan dengan baik dan sesuai apa yang di harapkan.
Sinkronisasi
Pada umumnya
proses dapat bekerja sendiri (independent process) dan juga dapat bekerja
bersama proses-proses yang lain (cooperating process). Ketika proses saling
bekerjasama (cooperating process) maka proses-proses tersebut akan saling
berbagi data. Pada saat proses-proses berbagi data, ada kemungkinan bahwa data
yang dibagi secara bersama itu akan menjadi tidak konsisten, karena ada
kemungkinan proses-proses tersebut melakukan akses secara bersamaan yang
menyebabkan data tersebut berubah, hal ini disebut dengan Race Condition.
Dalam sebuah sistem yang terdiri dari beberapa
rangkaian cooperating process yang berjalan secara asinkron dan saling berbagi
data, dapat terjadi seperti pada program berikut ini.
int counter = 0;
//Proses yang dilakukan oleh produsen
item nextProduced;
while (1) {
while (counter ==
BUFFER_SIZE) { ... do nothing ... }
buffer[in] = nextProduced;
in = (in + 1) % BUFFER_SIZE; counter++; }
//Proses yang dilakukan oleh konsumen
item nextConsumed;
while (1) {
while (counter == 0) { ... do nothing ... }
nextConsumed = buffer[out] ; out = (out + 1) %
BUFFER_SIZE; counter--;
}
Pada program
produser/konsumer terdapat perintah counter++ dan counter-- yang dapat
diimplementasikan dengan bahasa mesin sebagai berikut:
//counter++(nilai
counter bertambah 1 setiap dieksekusi)
register1 = counter register1 = register1 + 1
counter = register1
//counter--(nilai
counter berkurang 1 setiap dieksekusi)
register2 = counter register2 = register2 - 1
counter = register2
Dapat dilihat
jika perintah dari counter++ dan counter-- dieksekusi secara bersama maka akan
sulit untuk mengetahui nilai dari counter sebenarnya sehingga nilai dari
counter itu akan menjadi tidak konsisten. Marilah kita lihat contoh berikut
ini:
//misalkan nilai awal counter adalah 2
produsen: register1 = counter (register1 = 2)
produsen: register1 =
register1 + 1 (register1 = 3)
konsumen: register2 = counter (register2 = 2)
konsumen: register2 =
register2 - 1 (register2 = 1)
konsumen: counter =
register2 (counter = 1)
produsen: counter =
register1 (counter = 3)
Pada contoh tersebut dapat kita lihat bahwa counter
memiliki dua buah nilai yaitu bernilai tiga (pada saat counter++ dieksekusi)
dan bernilai satu (pada saat counter-- dieksekusi). Hal ini menyebabkan nilai
dari counter tersebut menjadi tidak konsisten. Perhatikan bahwa nilai dari
counter akan bergantung dari perintah terakhir yang dieksekusi. Oleh karena itu
kita membutuhkan sinkronisasi yang merupakan suatu upaya yang dilakukan agar
proses-proses yang saling bekerja bersama-sama dieksekusi secara beraturan demi
mencegah timbulnya suatu keadaan yang disebut dengan Race Condition.
Race
condition merupakan masalah yang dapat terjadi pada beberapa
proses yang memanipulasi suatu data secara konkruen, sehingga data tersebut
tidak sinkron lagi. Nilai akhirnya akan tergantung pada proses mana yang
terakhir dieksekusi. Dalam kenyataannya, suatu proses akan lebih sering
melakukan perhitungan internal dan hal-hal teknis lainnya tanpa ada bahaya Race
Condition di sebagian besaran waktu. Namun beberapa proses
memiliki suatu segmen kode di mana jika segmen
tersebut dieksekusi maka proses-proses tersebut dapat saling mengubah variabel,
meng-update suatu tabel, menulis ke dalam file, dan lain sebagainya. Hal-hal
seperti inilah yang dapat menyebabkan terjadinya Race Condition, dan segmen
kode ini disebut sebagai Critical
Section.
Solusi untuk memecahkan permasalahan critical
section adalah dengan merancang sebuah protokol dimana proses-proses dapat
menggunakannya secara bersama-sama. Setiap proses harus meminta ijin untuk
memasuki critical section-nya. Bagian dari kode yang mengimplementasikan ijin
ini disebut entry section. Akhir
dari critical section itu disebut exit
section. Bagian kode selanjutnya disebut remainder section. Dalam pemecahan tersebut harus memenuhi tiga
persyaratan sebagai berikut:
a. Mutual Exclusion. Jika suatu proses sedang
menjalankan critical section-nya, maka prosesproses lain tidak dapat menjalankan
critical section mereka. Dengan kata lain, tidak ada dua proses yang berada di
critical section pada saat yang bersamaan.
b. Progress. Jika tidak ada proses yang sedang
menjalankan critical section-nya dan ada prosesproses lain yang ingin masuk ke
critical section, maka hanya proses-proses yang sedang berada dalam entry
section saja yang dapat berkompetisi untuk mengerjakan critical section.
c. Bounded waiting. Seandainya ada proses yang
sedang menjalankan critical section, maka proses lain memiliki waktu tunggu
yang ada batasnya untuk menjalankan critical section-nya, sehingga dapat
dipastikan bahwa proses tersebut dapat mengakses critical section-nya (tidak
mengalami starvation: proses seolah-olah berhenti, menunggu request akses ke
critical section diperbolehkan).
Berikut akan di perlihatkan algoritma untuk
pemecahan masalah critical section. Setiap algoritma menggunakan dua proses dan
dianggap berjalan secara concurrent/bersamaan. Ada dua jenis solusi masalah
critical section, yaitu:
1. Solusi Perangkat Lunak. Dengan menggunakan
algoritma-alogoritma yang nilai kebenarannya tidak tergantung pada
asumsi-asumsi lain, selain bahwa setiap proses berjalan pada kecepatan yang
bukan nol.
2. Solusi Perangkat Keras. Tergantung pada beberapa
instruksi mesin tertentu, misalnya dengan me-non-aktifkan interupsi atau dengan
mengunci suatu variabel tertentu.
Solusi
Algoritma I
Gagasan
Algoritma ini adalah memberikan giliran kepada setiap proses untuk memasuki
critical section-nya. Asumsi yang digunakan adalah setiap proses secara
bergantian memasuki critical section-nya. Sebenarnya kedua proses berjalan
secara bersamaan, dan kita tidak dapat memprediksi proses manakah yang akan
berjalan duluan. Misalkan, yang pertama kali dieksekusi adalah baris pertama
pada proses P0, maka turn akan diset menjadi 0, artinya sekarang giliran P0
untuk menggunakan critical section. Lalu, seandainya proses P1 yang dieksekusi,
maka ia akan mengubah turn menjadi 1, artinya sekarang giliran P1 menggunakan
critical section. Lalu P0 akan menunggu karena turn sudah berubah menjadi 1.
Lalu P1 akan memasuki critical section karena turn=1. Setelah P1 selesai, maka
ia akan mengubah turn menjadi 0, artinya P1 memberikan giliran P0 untuk
menggunakan critical section. Selanjutnya P1 akan menunggu di while turn!=1
jika ingin menggunakan critical section lagi. Lalu P0 keluar dari loop, karena
turn sudah menjadi 0, saatnya giliran P0 memasuki critical section. Setelah P0
selesai, P0 akan mengubah turn=1, artinya P0 memberikan giliran P1 untuk
menggunakan critical section. Kejadian ini terus terjadi berulang-ulang.
do{ while(turn!=0);
critical section
turn=1
remainder section
}
while(TRUE);
Proses P0
do{ while(turn!=1);
critical section
turn=0
remainder section
}
while(TRUE);
Proses P1
Permasalahannya terjadi jika suatu proses, misalkan
P0 mendapat giliran, artinya turn=0, setelah selesai menggunakan critical
section, P0 akan mengubah turn menjadi 1, seandainya P1 tidak membutuhkan
critical section, turn akan tetap menjadi 1.
Lalu pada saat P0 membutuhkan akses ke critical
section lagi, ia harus menunggu P1 menggunakan critical section dan mengubah
turn menjadi 0. Akibatnya critical section dalam keadaan tidak dipakai oleh
proses manapun, sedangkan ada proses (P0) yang membutuhkannya. Sampai kapanpun
P1 tidak dapat mengakses critical section hingga P0 menggunakan critical
section, lalu mengubah turn menjadi 0. Kondisi kekosongan dari critical section
ini tidak memenuhi syarat solusi critical section yang kedua yaitu progress.
Analogi Algoritma I seperti kamar mandi dua pintu (pintu depan dan pintu
belakang), ada dua orang yang bergiliran memakai kamar mandi yaitu A dan B.
Kamar mandi adalah critical section. A tidak dapat menggunakan kamar mandi
hingga B menggunakan kamar mandi lalu memberikan giliran kepada A. Begitu juga
sebaliknya.
Solusi
Algoritma II
Masalah yang
terjadi pada algoritma I adalah ketika di entry section terdapat sebuah proses
yang ingin masuk ke critical section, sementara di critical section sendiri
tidak ada proses yang sedang berjalan, tetapi proses yang ada di entry section
tadi tidak bisa masuk ke critical section. Hal ini terjadi karena giliran untuk
memasuki critical section adalah giliran proses yang lain sementara proses
tersebut masih berada di remainder section. Pada algoritma ini terlihat bahwa
setiap proses melihat proses lain, apakah proses lain itu menginginkan critical
section atau tidak. Jika ya, maka proses tersebut akan menunggu proses lain
selesai memakai critical section.
do{
flag0=true
while(flag1);
critical section
flag0=false
remainder section
}while(TRUE);
Proses P0
do{
flag1=true
while(flag0);
critical section
flag1=false
remainder section
}while(TRUE);
Proses P1
Pertama-tama, masing-masing flag di set false.
Kemudian flag0 diset true, menandakan bahwa proses P0 ingin menggunakan
critical section, lalu P0 melihat apakah flag1 true atau false (proses P1
menginginkan critical section atau tidak). Jika ya, maka proses P0 akan
mengijinkan proses P1 menggunakannya dahulu dan P0 menunggu. Setelah selesai,
maka proses P0 bergantian menggunakan critical section tersebut, ditandai
dengan P1 mengeset flag1=false.
Permasalahan muncul ketika, kedua proses secara
bersamaan menginginkan critical section, maka kedua proses akan me-set flag
masing-masing menjadi true. P0 menset flag0=true, P1 menset flag1=true. Lalu P0
akan menunggu P1 selesai menggunakan critical section dengan melihat flag1
apakah masih true. Sedangkan P1 juga akan menunggu P0 selesai menggunakan
critical section dengan melihat apakah flag0 masih true. Akibatnya tidak ada
yang mengakses critical section, sedangkan ada proses (P0 dan P1) yang ingin
mengaksesnya. Sehingga syarat progress tidak terpenuhi. Kondisi ini akan terus
bertahan.
Solusi
Banyak Proses
Algoritma untuk solusi proses ini dinamakan
algoritma bakery (tukang roti) dan berdasarkan algoritma penjadwalan yang biasa
digunakan oleh tukang roti, es krim, registrasi sepeda motor dan sebagainya.
Biasanya algoritma ini digunakan untuk lingkungan terdistribusi, namun untuk
hal ini akan digunakan untuk lingkungan terpusat.
Pada saat
memasuki toko, setiap costumer menerima nomor antrian. Costumer dengan nomor
terkecil akan dilayani terlebih dahulu. Sayang algoritma bakery tidak menjamin
bahwa dua proses tidak akan menerima nomor yang sama. Untuk kasus ini proses
dengan urutan nama yang terendah akan dilayani terlebih dahulu. Sehingga, jika
Pi dan Pj menerima nomor yang sama dan jika i
Struktur data algoritma ini adalah:
BOOL choosing[n]; //n
adalah jumlah proses
int number[n];
Semaphore
Masalah critical section bisa diselesaikan dengan
penggunaan Instruksi Atomik. Akan tetapi, cara tersebut tidak mudah untuk
diterapkan pada masalah yang lebih kompleks, misalnya ada lebih dari dua proses
yang berjalan. Untuk mengatasi hal ini, kita dapat menggunakan alat
sinkronisasi yang dinamakan semaphore. Semaphore S merupakan sebuah variabel
integer yang diakses hanya melalui dua operasi standar atomik yaitu wait dan
signal.
void wait(int s){
while (s<=0){no-op;
}
s=s-1;
}
void signal(s){ s=s+1
}
Berikut ini
merupakan implementasi semaphore untuk mengatasi masalah critical-section.
int mutex=1;
do{
wait(mutex);
critical section
signal(mutex);
remainder section
}while(TRUE);
Transaksi
Atomik
Yang dimaksud dengan transaksi atomik adalah suatu
transaksi yang dilakukan secara keseluruhan atau tidak dilakukan sama sekali.
Sebagai ilustrasi adalah ketika dilakukan transfer dari rekening A ke rekening
B terjadi kegagalan listrik, maka lebih baik tidak dilakukan perubahan terhadap
balance setiap rekening. Disinilah digunakan instruksi atomik.
Keatomikan
(atomicity) merupakan komponen penting dalam menghindari bahaya race condition.
Operasi atomik dijamin hanya ada dua kemungkinan keluaran (contohnya berhasil
atau gagal) dan ketika banyak proses berusaha melakukan operasi atomik dapat
dipastikan hanya satu yang akan berhasil (meskipun semuanya dapat gagal).
Umumnya, keatomikan diimplementasikan dengan
menyediakan mekanisme yang mencatat transaksi mana yang telah dimulai dan
selesai atau dengan membuat salinan data sebelum dilakukan perubahan. Sebagai
contoh banyak database mendukung mekanisme commit-rollback dalam penerapan
transaksi atomik, dimana bila transaksi berhasil maka dilakukan commit tetapi
bila transaksi gagal akan dilakukan rollback ke kondisi awal. Metode ini
biasanya menyimpan perubahan dalam sebuah log. Bila sebuah perubahan berhasil
dilakukan maka akan disimpan dalam log. Bila terjadi kegagalan maka hal
tersebut tidak disimpan dalam log. Bila diperlukan kondisi akan diubah ke
kondisi terakhir dari transaksi yang berhasil.
Pada tingkat hardware diperlukan instruksi seperti
TestAndSet dan operasi increment/decrement. Bila diperlukan maka dapat
dilakukan pencegahan pelayanan interupsi yang terjadi ketika transaksi
dijalankan dimana transaksi tersebut harus selesai dijalankan barulah interupsi
dilayani.
Masalah Umum Sinkronisasi Secara garis besar ada
tiga masalah umum yang berkaitan dengan sinkronisasi yang dapat diselesaikan
dengan menggunakan semaphore, ketiga masalah itu adalah:
1. Masalah
Bounded Buffer (Producer/Consumer)
2. Masalah
Readers/Writers
3. Masalah Dining Philosophers
Bounded Buffer
Yang dimaksud
dengan bounded buffer adalah suatu struktur data untuk menampung (buffer) suatu
nilai dengan kapasitas tertentu (bounded). Bounded buffer mampu menyimpan
beberapa nilai dan mengeluarkannya kembali ketika diperlukan. Contoh dari
penggunaan bounded buffer adalah pada proses produsen-konsumen. Produsen akan
menghasilkan suatu barang dan konsumen akan mengkonsumsi barang yang dihasilkan
oleh produsen. Setelah menghasilkan suatu barang, produsen akan menaruh barang
itu di bounded buffer. Jika konsumen membutuhkan suatu barang, maka dia akan
mengambil dari bounded buffer. Jadi produsen dan konsumen ini akan mengakses
bounded buffer yang sama.
Yang menjadi
masalah adalah bagaimana jika dua proses berbeda, yaitu produsen dan konsumen,
berusaha mengakses buffer tersebut dalam waktu bersamaan. Kedua proses akan
berlomba untuk memasuki critical section.
Readers/Writers
Salah satu
dari sekian banyak permasalahan sinkronisasi yang sering terjadi di dunia
nyata, yaitu ketika ada dua jenis proses readers dan writers saling berbagi
(shared) data dan mengakses database secara paralel. Proses yang pertama (reader)
bertugas untuk membaca data, sedangkan proses kedua bertugas untuk menulis data
baru/mengupdate nilai dalam data (writer).
Solusinya adalah menjadikan proses dapat dijalankan
dalam keadaan terpisah/terisolasi dari proses lain. Untuk menghindari gangguan
dalam perubahan data, writer harus mempunyai kemampuan mengakses data secara
eksklusif.
Kondisi berikut harus dipenuhi oleh readers dan
writers:
a. Maksimal hanya ada satu writer yang mengubah
data. Jika suatu writer sedang mengubah data, maka tidak ada satupun reader
yang diperbolehkan untuk membaca data.
b. Dalam suatu waktu diperbolehkan lebih dari satu
reader membaca data. Ketika data sedang dibaca, tidak ada writer yang boleh
mengubah data.
Dalam memecahkan masalah Readers-Writers haruslah
memenuhi kondisi berikut:
• Readers yang baru tiba mendapat prioritas yang
lebih tinggi daripada writers yang sedang menunggu.
• Jika ada
lebih dari satu reader yang sedang berada dalam critical section, maka reader
yang lain diijinkan untuk memasuki critical section juga.
• Writer yang sedang menunggu dapat mengakses data
hanya bila tidak ada writers yang sedang berada di dalam sistem.
• Ketika
writers sedang dijalankan oleh sistem, semua readers yang akan menunggu
mempunyai prioritas yang lebih tinggi untuk dijalankan daripada writers yang
sedang mengantri. Akan tetapi, dari solusi ini masih timbul permasalahan baru.
yaitu ketika readers terus menerus datang, writers tidak akan mendapatkan
giliran untuk mengakses data (starvation).
Makan
Malam Para Philosoper
Anggap ada lima philosoper yang menghabiskan
hidupnya hanya berpikir dan makan. Para philosoper tersebut bertemu di meja
makan yang berbentuk lingkaran dan dikelilingi dengan lima kursi untuk tiaptiap
philosoper tersebut. Di tengah meja diletakkan sebakul nasi dan lima buah
batang sumpit seperti pada gambar. Ketika seorang philosoper berpikir, dia
tidak dapat berinteraksi dengan rekannya. Dari waktu ke waktu, philosoper lapar
dan mecoba mengambil dua batang sumpit yang berada di dekatnya yaitu sebatang
sumpit di antara sebelah kirinya (sebelah kanan rekannya) dan sebelah kanannya
(sebelah kiri rekannya). Philosoper hanya boleh mengambil satu batang sumpit
setaip waktu, dan tidak dapat mengambil sumpit tersebut jika sedang digunakan
oleh rekannya yang lain. Ketika lapar philosoper akan mengambil dua batang
sumpit secara bersamaan, dan makan tanpa melepas sumpitsumpit tersebut. Jika
sudah selesai dia meletakkan kedua sumpit tersebut lalu berpikir lagi dan
seterusnya.
Gambar 2 Makan malam para philosoper
Solusi untuk mengatasi permasalahan di atas dengan
menggunakan semaphore agar tidak terjadinya deadlock dan starvation. Setiap
batang sumpit di representasikan dengan semaphore. Seorang philosopher
mengambil sumpit dengan mengeksekusi operasi wait dan melepas sumpit tersebut
dengan operasi signal.
Ada beberapa hal untuk menyakinkan tidak terajadinya
deadlock, yaitu:
• Mengijinkan selebihnya empat philosopher untuk
duduk bersamaan di meja
• Mengijinkan seorang philosopher untuk mengambil
sumpitnya jika dua batang sumpit tersedia
• Gunakan
solusi asimetris, yaitu philosopher yang ganjil mengambil dua batang sumpit di
kanan dan kirinya dan philosopher yang genap dua batang sumpit di kanan dan
kirinya juga.
Critical
Region
Critical region adalah bagian dari program dan
ditetapkan untuk selalu berada dalam keadaan mutual exclusion. Perbedaan
critical region ini dengan mutual exclusion biasa yang dibahas sebelumnya
adalah critical region diimplementasikan oleh kompilator. Keuntungan
menggunakan ini adalah programer tidak perlu lagi mengimplementasikan algoritma
yang rumit untuk mendapatkan mutual exclusion.
Critical region memiliki sebuah komponen boolean
yang menguji apakah bagian dari program boleh masuk kedalam state critical
region atau tidak. Jika nilai boolean ini true maka proses boleh masuk ke
critical region. Jika boolean ini bernilai false bagian yang ini akan dimasukan
kedalam sebuah antrian sampai nilai boolean ini bernilai true.
Dalam critical region dikenal ada 2 antrian: main
queue dan event queue. Main queue berfungsi untuk menampung proses yang akan
memasuki critical region hanya saja critical region masih digunakan oleh proses
lain. Event queue berguna untuk menampung proses yang tidak dapat memasuki
critical region karena nilai boolean-nya bernilai false.
Komstruksi
sinkronisasi critical-region membutuhkan variabel v dari tipe T, dimana akan
berbagi pakai diantara beberapa proses. Deklarasinya yaitu:
var v: shared T;
dan variabel
v hanya dapat diakses di dalam region yang dinyatakan dengan:
region v when B do S;
Maksud dari
pernyataan di atas adalah selama S dieksekusi, tidak ada proses yang dapat
mengakses variabel v. Ekspresi B adalah tipe boolean yang menentukan akses ke
critical region.
var buffer: shared
record
pool: array[0..n-1] of item;
count, in, out:
integer;
end;
Produser memproses masukan item nextp baru ke shared
buffer dengan mengeksekusi:
region buffer when
count < n
do begin
pool[in]:=nextp;
in:=in+1 mod n;
count:=count+1;
end;
Konsumen
memproses keluaran item dari shared buffer dan meletakkannya ke nextc dengan mengeksekusi:
region buffer when count>0
do begin
nextc:=pool[out];
out:=out+1 mod n
count:=count-1;
end;
Implementasi konstruksi conditional-region dengan
semaphore adalah sebagai berikut:
semaphore mutex=1,
delay1=0, delay2=0;
int count1=0, count2=0;
wait(mutex);
while(!B){ count1++;
if (count2>0)
signal(delay2);
else signal(mutex);
wait(delay1); count1--;
count2++;
if (count1>0) signal(delay1);
else signal(delay2);
wait(delay2);
count2=--; } S;
if(count1>0) signal(delay1);
else if(coun2>0)
signal(delay2);
else signal(mutex);
Monitor
Konsep
monitor diperkenalkan pertama kali oleh Hoare (1974) dan Brinch Hansen (1975)
untuk mengatasi beberapa masalah yang timbul ketika memakai semaphore. Monitor
merupakan kumpulan dari prosedur, variabel, dan struktur data dalam satu modul.
Monitor hanya dapat diakses dengan menjalankan fungsinya. Kita tidak dapat
mengambil variabel dari monitor tanpa melalui prosedurnya. Hal ini dilakukan
untuk melindungi variabel dari akses yang tidak sah dan juga mengurangi
terjadinya error.
shared variable
declarations
void bodyP1 (....) {
...... }
void bodyP2 (....) {
...... } .....
void bodyPn (....) {
...... }
void main{
initialization code
}
Konstruksi
monitor memastikan hanya satu proses yang aktif pada suatu waktu. Sehingga
sebenarnya programmer tidak membutuhkan synchronization codes yang disisipkan
secara eksplisit. Akan tetapi konstruksi monitor tidak benar-benar powerfull
untuk modelisasi sebuah skema synchronization, sehingga perlu ditambahkan
mekanisme sinkronisasi tambahan. Mekanisme ini disediakan oleh konstruksi
conditional, seperti deklarasi variabel di bawah ini:
condition x,y;
wait dan signal merupakan operasi-operasi yang dapat
dipanggil dalam variabel kondisi.
Gambar 3 Schematic view monitor
Operasi x.wait menahan proses sampai proses lain
memanggil x.signal. Operasi x.signal melanjutkan proses yang tertahan, jika
tidak ada proses yang tertahan operasi ini tidak mempunyai pengaruh apa-apa.
Misalkan x.signal dipanggil oleh proses P, lalu ada proses Q tertahan dan
diasosiasikan dengan kondisi x. Jelasnya jika proses Q yang tertahan diijinkan
untuk melanjutkan eksekusinya, pensinyalan proses P harus menunggu. Jika tidak
kedua P dan Q akan aktif secara simultan melalui monitor. Ada dua kemungkinan yang
terjadi yaitu:
1. P menunggu
sampai Q meninggalkan monitor atau menunggu untuk kondisi lain
2. Q menunggu sampai Pmeninggalkan monitor atau
menunggu untuk kondisi lain.
Gambar 4 Monitor dengan variabel-variabel kondisi
Monitor merupakan konsep bahasa pemrograman,
sehingga kompilator bertanggung jawab dalam mengkondisikan monitor sebagai
mutual eksklusif. Namun, tidak semua kompilator bisa menerapkannya. Sehingga
meski bahasa pemrograman yang sama mungkin tidak memiliki semaphore, akan
tetapi menambahkan semaphore akan lebih mudah.
PENUTUP
KESIMPULAN
Sinkronisasi adalah proses pengaturan jalannya beberapa proses pada saat
yang bersamaan. Tujuan utama sinkronisasi adalah menghindari terjadinya
inkonsistensi data karena pengaksesan oleh beberapa proses yang berbeda
(mutualexclusion) serta untuk mengatur urutan jalannya proses-proses sehingga
dapat berjalan dengan lancar dan terhindar dari deadlock atau starvation.
Sinkronisasi umumnya dilakukan dengan bantuan perangkat sinkronisasi.Beberapa
perangkat sinkronisasi, yaitu : TestAndSet(), Semafor, dan Monitor.
DAFTAR PUSTAKA
Sumber :
http://imam_muiz.staff.gunadarma.ac.id/Downloads/files/11368/SISTEM+OPERASI-5.pdf
http://rahmadican.blogspot.com/2017/01/makalah-sitem-operasi-sinkronisasi.html
§ Alamat Blog Dosen : https://syaifulahdan.wordpress.com
§ Alamat web Program studi, Fakultas, Universitas : http://ti.ftik.teknokrat.ac.id, http://ftik.teknokrat.ac.id, www.teknokrat.ac.id
§ Nama Mahasiswa : NADIYA
SAFITRI
Tidak ada komentar:
Posting Komentar