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
a. Komunikasi Langsung
Proses-proses yang ingin dikomunikasikan harus memiliki sebuah cara untuk memilih satu dengan
yang lain. Mereka dapat menggunakan komunikasi langsung/tidak langsung. Setiap proses yang ingin
berkomunikasi harus memiliki nama yang bersifat eksplisit baik penerimaan atau pengirim dari
komunikasi tersebut. Dalam konteks ini, pengiriman dan penerimaan pesan secara primitif dapat
dijabarkan sebagai berikut:
• Send (P, message) - mengirim sebuah pesan ke proses P.
• Receive (Q, message) - menerima sebuah pesan dari proses Q.
Sifat-sifat yang dimiliki oleh jaringan komunikasi pada pembataasan ini ialah:
Sebuah jaringan harus didirikan antara kedua proses yang ingin berkomunikasi. Selain itu,
dibutuhkan pengenal-pengenal khusus yang dapat digunakan sebagai pengidentifikasi dalam
proses komunikasi tersebut.
Sebuah jaringan terdiri atas tepat dua proses.
Setiap pesan yang dikirim atau diterima oleh proses harus melalui tepat sebuah jaringan.
Pembahasan ini memperlihatkan sebuah cara simetris dalam pemberian alamat. Oleh karena itu, baik
keduanya yaitu pengirim dan penerima proses harus memberi nama bagi yang lain untuk dapat
berkomunikasi, hanya pengirim yang memberikan nama bagi penerima saja sedangkan penerima
tidak menyediakan nama bagi pengirim. Dalam konteks ini, pengirim dan penerima secara sederhana
dapat dijabarkan sebagai:
• Send (P, message) - mengirim sebuah pesan kepada proses P.
• Receive (ID, message) - menerima sebuah pesan dari semua proses. Variabel ID diatur
sebagai nama dari proses dengan komunikasi.
Kerugian dari skema ini (simetris /asimetris) adalah keterbatasan modularitas, disebabkan oleh hanya
ada paling banyak dua proses yang berkomunikasi dalam satu jaringan. Selain itu, perubahan
pengenal-pengenal dari suatu proses yang digunakan dalam komunikasi dapat mengakibatkan
jaringan yang telah terbentuk harus di-set ulang, karena seluruh referensi ke pengenal yang lama
harus di-set ulang agar komunikasi dapat berjalan dengan baik.
b. Komunikasi Tidak Langsung
Dengan komunikasi tidak langsung, pesan akan dikirimkan pada dan diterima dari/melalui mailbox
(Kotak Surat) atau terminal-terminal, sebuah mailbox dapat dilihat secara abstrak sebagai sebuah
obyek didalam setiap pesan yang dapat ditempatkan dari proses dan dari setiap pesan yang bisa
dipindahkan. Setiap kotak surat memiliki sebuah identifikasi (identitas) yang unik, sebuah proses
dapat berkomunikasi dengan beberapa proses lain melalui sebuah nomor dari mailbox yang berbeda.
Dua proses dapat saling berkomunikasi apabila kedua proses tersebut berbagi pakai mailbox.
Pengirim dan penerima dapat dijabarkan sebagai:
• Send (A, message) - mengirim pesan ke mailbox A.
• Receive (A, message) - menerima pesan dari mailbox A.
Dalam masalah ini, hubungan komunikasi mempunyai sifat sebagai berikut:
Sebuah link dibangun diantara sepasang proses dimana kedua proses tersebut membagi mailbox.
Sebuah link mungkin dapat berasosiasi dengan lebih dari dua proses.
Diantara setiap pasang proses komunikasi, mungkin terdapat link yang berbeda-beda, dimana
setiap link berhubungan pada satu mailbox.
Misalkan terdapat proses P1, P2 dan P3 yang semuanya berbagi pakai mailbox. Proses P1 mengirim
pesan ke A, ketika P2 dan P3 masing-masing mengeksekusi sebuah kiriman dari A. Proses mana
yang akan menerima pesan yang dikirim P1? Jawabannya tergantung dari jalur yang kita pilih:
Mengijinkan sebuah link berasosiasi dengan paling banyak dua proses.
Mengijinkan paling banyak satu proses pada suatu waktu untuk mengeksekusi hasil kiriman
(receive operation).
Mengijinkan sistem untuk memilih secara mutlak proses mana yang akan menerima pesan
(apakah itu P2 atau P3 tetapi tidak keduanya, tidak akan menerima pesan). Sistem mungkin
mengidentifikasi penerima kepada pengirim.
Mailbox mungkin dapat dimiliki oleh sebuah proses atau sistem operasi. Jika mailbox dimiliki oleh
proses, maka kita mendefinisikan antara pemilik (yang hanya dapat menerima pesan melalui mailbox)
dan pengguna dari mailbox (yang hanya dapat mengirim pesan ke mailbox). Selama tiap-tiap mailbox
mempunyai kepemilikan yang unik, maka tidak akan ada kebingungan tentang siapa yang harus
menerima pesan dari mailbox. Ketika proses yang memiliki mailbox tersebut dihentikan, mailbox akan
hilang. Semua proses yang mengirim pesan ke mailbox ini diberi pesan bahwa mailbox tersebut tidak
lagi ada. Dengan kata lain, mempunyai mailbox sendiri yang independent, dan tidak melibatkan
proses yang lain. Sistem operasi harus memiliki mekanisme yang mengijinkan proses untuk
melakukan hal-hal di bawah ini:
Membuat mailbox baru.
Mengirim dan menerima pesan melalui mailbox.
Menghapus mailbox.
Proses yang pertama kali membuat sebuah mailbox secara default akan memiliki mailbox tersebut.
Untuk pertama kali, hanya proses yang membuat mailbox yang dapat berkomunikasi melalui mailbox
tersebut. Meskipun demikian, sebuah mailbox dapat saja di-assign ke proses lain, sehingga beberapa
proses dapat berkomunikasi melalui mailbox tersebut.
Proses komunikasi proses dengan menggunakan mailbox dapat dianalogikan sebagai kegiatan
komunikasi dengan 'papan pesan'. Beberapa proses dapat memiliki sebuah mailbox bersama-sama,
dimana mailbox ini berfungsi sebagai 'tempat penitipan pesan' bagi proses-proses yang
berkomunikasi. Dalam komunikasi jenis ini, proses-proses hanya dapat berkomunikasi dengan proses
lain yang berbagi mailbox yang sama dengan proses tersebut.
c. Sinkronisasi
Komunikasi antara proses membutuhkan place by calls untuk mengirim dan menerima data primitif.
Terdapat desain yang berbeda-beda dalam implementasi setiap primitif. Pengiriman pesan mungkin
dapat diblok (blocking) atau tidak dapat dibloking (nonblocking)-juga dikenal dengan nama sinkron
atau asinkron.
Pengiriman yang diblok: Proses pengiriman di blok sampai pesan diterima oleh proses penerima
(receiving process) atau oleh mailbox.
Pengiriman yang tidak diblok: Proses pengiriman pesan dan mengkalkulasi operasi.
Penerimaan yang diblok: Penerima memblok sampai pesan tersedia.
Penerimaan yang tidak diblok: Penerima mengembalikan pesan valid atau null.
d. Buffering (Penyangga)
Apa pun jenis komunikasinya, langsung atau tidak langsung, penukaran pesan oleh proses
memerlukan antrian sementara. Pada dasarnya, terdapat tiga cara untuk mengimplementasikan
antrian tersebut:
Kapasitas Nol. Antrian mempunyai panjang maksimum 0, sehingga tidak ada penungguan pesan
(message waiting). Dalam kasus ini, pengirim harus memblok sampai penerima menerima pesan.
Kapasitas Terbatas. Antrian mempunyai panjang yang telah ditentukan, paling banyak n pesan
dapat dimasukkan. Jika antrian tidak penuh ketika pesan dikirimkan, pesan yang baru akan
menimpa, dan pengirim pengirim dapat melanjutkan eksekusi tanpa menunggu. Link mempunyai
kapasitas terbatas. Jika link penuh, pengirim harus memblok sampai terdapat ruang pada antrian.
Kapasitas Tidak Terbatas. Antrian mempunyai panjang yang tak terhingga, sehingga semua
pesan dapat menunggu disini. Pengirim tidak akan pernah di blok.
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.
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.
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 Peterson’s/Algoritma III
Idenya berasal dari algoritma I dan II. Algoritma III mengatasi kelemahan pada algoritma I dan II
sehingga progres yang diperlukan untuk mengatasi critical section terpenuhi. Berikut ini code dari
algoritma III:
Kali pertama masing flag diset false, menandakan bahwa proses tersebut tidak ingin menggunakan
critical section. Kemudian ketika ada proses yang menginkan critical section, maka ia akan mengubah
flag (memberikan tanda bahwa ia butuh critical section) lalu proses tersebut memberikan turn kepada
lawannya. Jika lawannya menginginkan critical section dan turn adalah turn lawannya maka ia akan
menunggu.
Misalnya, proses-proses dieksekusi sesuai langkah-langkah berikut, Ketika proses P0 menginginkan
critical section, maka ia me-set flag0=true, lalu P1 juga menginginkan critical section, maka ia akan
me-set flag1=true. Selanjutnya P0 memberikan turn pada P1(turn=1), lalu P1 juga memberikan turn
pada P0 (turn=0). Sehingga P0 dapat memasuki critical section, sedangkan P1 menunggu P0 selesai
mengakses critical section lalu P0 merubah flag0=false. P1 sekarang dapat memasuki critical section,
setelah selesai P1 akan merubah flag1=false, sedangkan turn terakhir bernilai 0. Jika P0 atau P1
selesai mengakses remainder section dan menginginkan critical section maka proses ini akan mirip
seperti diatas tentunya yang lebih dulu memasuki critical section adalah yang lebih dulu memberikan
turn. Jika hanya ada satu proses yang ingin memasuki critical section, maka ia dapat langsung masuk
karena tidak perlu menunggu (karena flag lawannya bernilai false, tidak peduli berapapun nilai turnnya).
Apabila kedua proses P0 dan P1 berjalan secara bersamaan, maka proses yang akan memasuki
critical section lebih dulu adalah proses yang lebih dulu mempersilahkan proses lainnya (yang lebih
dulu mengubah turn menjadi turn untuk proses lawan). Karena turn akan diberikan oleh proses yang
terakhir kali memberikan turn, artinya proses yang terakhir akan menentukan nilai turn (mengubah
turn menjadi turn untuk lawannya).
Syarat progress terpenuhi karena ketika critical section tidak ada yang menggunakan dan ada prosesproses
yang ingin menggunakannya maka dipastikan akan ada yang menggunakan critical section
tersebut.
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<j, maka Pi
akan dilayani terlebih dahulu.
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.
Dalam subrutin ini, proses akan memeriksa harga dari semaphor, apabila harganya 0 atau kurang
maka proses akan menunggu, sebaliknya jika lebih dari 0, maka proses akan mengurangi nilai dari
semaphore tersebut dan menjalankan operasi yang lain. Arti dari harga semaphore dalam kasus ini
adalah hanya boleh satu proses yang dapat melewati subrutin wait pada suatu waktu tertentu, sampai
ada salah satu atau proses itu sendiri yang akan memanggil signal.
Pernyataan "menunggu" sebenarnya masih abstrak. Cara proses menunggu dapat dibagi menjadi
dua:
1. Tipe Spinlock. Dalam tipe Spinlock, proses melakukan Spinlock waiting, yaitu melakukan
iterasi(looping) secara terus menerus tanpa menjalankan perintah apapun. Dengan kata lain,
proses terus berada di running state. Tipe Spinlock, yang biasa disebut busy waiting,
menghabiskan CPU cycle. Pseudocode bisa dilihat di atas. Spinlock waiting berarti proses
tersebut menunggu dengan cara menjalankan perintah-perintah yang tidak ada artinya. Dengan
kata lain proses masih running state di dalam spinlock waiting. Keuntungan spinlock pada
lingkungan multiprocessor adalah, tidak diperlukan context switch. Tetapi spinlock yang biasanya
disebut busy waiting ini menghabiskan cpu cycle karena, daripada proses tersebut melakukan
perintah-perintah yang tidak ada gunanya, sebaiknya dialihkan ke proses lain yang mungkin lebih
membutuhkan untuk mengeksekusi perintah-perintah yang berguna.
2. Tipe Non-Spinlock. Dalam tipe Non-Spinlock, proses akan melakukan Non-Spinlock waiting,
yaitu memblock dirinya sendiri dan secara otomatis masuk ke dalam waiting queue. Di dalam
waiting queue, proses tidak aktif dan menunggu sampai ada proses lain yang membangunkannya
dan membawanya ke ready queue. Berbeda dengan spinlock waiting, non-spinlock waiting,
memanfaatkan fasilitas sistem operasi. Proses yang melakukan non-spinlock waiting akan
memblock dirinya sendiri dan secara otomatis akan membawa proses tersebut ke dalam waiting
queue. Di dalam waiting queue ini proses tidak aktif dan menunggu sampai ada proses lain yang
membangunkan dia sehingga membawanya ke ready queue.
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).
sumber : https://www.google.com/url?sa=t&rct=j&q=&esrc=s&source=web&cd=&ved=2ahUKEwjIyaGj8czvAhU1lEsFHYVSANsQFjACegQIAhAD&url=http%3A%2F%2Fimam_muiz.staff.gunadarma.ac.id%2FDownloads%2Ffiles%2F11368%2FSISTEM%2BOPERASI-5.pdf&usg=AOvVaw0mpBRLrqfTu05k3pHN6oBP
.jpg)
.jpg)
