flamboyanes.files.wordpress.com file · web viewproses-proses yang mengalami kongkuren dapat...

1 1 KONGKURENSI

Pengertian kongkurensi

Kondisi dimana pada saat yang bersamaan terdapat lebih dari satu proses disebut dengan kongkurensi (proses-proses yang kongkuren) Proses-proses yang mengalami kongkuren dapat berdiri sendiri (independen) atau dapat saling berinteraksi sehingga membutuhkan sinkronisasi atau koordinasi proses yang baikUntuk penanganan kongkuren bahasa pemograman saat ini telah memiliki mekanisme kongkurensi dimana dalam penerapannya perlu dukungan sistem operasi dimana bahasa berada

Kesulitan-kesulitan dalam kongkurensi

Kecepatan proses pada sistem dipengaruhi oleh

a Aktivitas-aktivitas proses-proses lainb Cara sistem operasi menangani interupsic Kebijaksanaan penjadwalan yang dilakukan oleh sistem operasi Beberapa kesulitan yang muncul a Pemakaian bersama sumber daya global Apabila terdapat dua proses yang menggunakan variabel global yang sama serta keduanya membaca dan menulis ke variabel itumaka urutan terjadinya pembacaan dan penulisan terhadap variabel itu menjadi kritis

b Pengelolaan alokasi sumber daya agar optimal Apabila proses A meminta suatu kanal masukankeluaran tertentu dan dipenuhi kemudian terjadi proses A di suspend sebelum menggunakan kanal tersebut Jika sistem operasi mengunci kanal (tidak memperbolehkan atau mencegah proses lain untuk menggunakannya) maka tindakan tersebut menghasilkan inefisiensi

c Pencarian kesalahan pemrograman Pencarian kesalahan pada pemograman kongkuren lebih sulit dibanding pencarian kesalahan pada program-program sekuen

Pada dasarnya penyelesaian masalah kongkurensi terbagi menjadi dua yaitu a Mengasumsikan adanya memori yang digunakan bersamab Tidak mengasumsikan adanya memori yang digunakan bersama

Adanya memori bersama lebih mempermudah penyelesaian masalah kongkurensi Metode penyelesaian ini dapat dipakai untuk sistem singleprocessor ataupun multiprocessor yang mempunyai memori bersama Penyelesaian ini tidak dapat digunakan untuk multiprocessor tanpa memori bersama ataupun untuk sistem tersebar

Penanganan kongkurensi adalah dengan a Mengetahui proses-proses yang aktif Sistem operasi mengelola senarai proses di sistem operasi Senarai ini berupa senarai PCB proses Senarai berjumlah sesuai jumlah state yang diimplementasikan sistem operasi

b Mengatur alokasi dan dealokasi beragam sumber daya untuk tiap proses yang aktif

Sumber daya yang harus dikelola antara lain middot Waktu pemrosesmiddot Memori middot Berkas-berkas (file) middot Peralatan masukankeluaran middot Dan sebagainyac Proteksi data dan sumber daya fisik proses Proteksi data dan sumber daya fisik masing-masing proses dari gangguan (interfensi) proses-proses lain

d Hasil-hasil proses harus independen Hasil-hasil proses harus independen terhadap kecepatan relatif proses- proses lain dimana eksekusi dilakukan

Proses yang kongkuren ini mempunyai beberapa masalah yang harus diselesaikan

yaitu

Mutual exclusion (pengeluaran timbal balik)

Merupakan kondisi dimana terdapat sumber daya yang tidak dapat dipakaibersama pada waktu yang bersamaan (misalnya printer disk drive) Kondisidemikian disebut sumber daya kritis dan bagian program yang menggunakan sumber daya kritis disebut critical region section Hanya satu program pada satu saat yang diijinkan masuk ke critical region Pemrogram tidak dapat bergantung pada sistem operasi untuk memahami dan memaksakan batasan ini karena maksud program tidak dapat diketahui oleh sistem operasi Hanya saja sistem operasi menyediakan layanan (system call) yang bertujuan untuk mencegah proseslain masuk ke critical section yang sedang digunakan proses tertentuPemrograman harus menspesifikasikan bagian-bagian critical section sehingga sistem operasi akan menjaganya Pentingnya mutual exclusion adalah jaminan hanya satu proses yang mengakses sumber daya pada suatu interval waktu Pemaksaan atau pelanggaran mutual exclusion menimbulkan

a Deadlock

b Starvation

Deadlock (buntu)

Deadlock merupakan kondisi terparah karena banyak proses dapat terlibat dan semuanya tidak dapat mengakhiri prosesnya secara benar

Ilustasi deadlock misalnya

middot Terdapat dua proses yaitu P1 dan P2 dan dua sumber daya kritis yaitu R1 dan R2

middot Proses P1 dan P2 harus mengakses kedua sumber daya tersebut dengan kondisi ini terjadi R1 diberikan ke P1 sedangkan R2 diberikan ke P2

Karena untuk melanjutkan eksekusi memerlukan kedua sumber daya sekaligus maka kedua proses akan saling menunggu sumber daya lain selamanya Tak ada proses yang dapat melepaskan sumber daya yang telah dipegangnya karena menunggu sumber daya lain yang tak pernah diperolehnya Kedua proses dalam kondisi deadlock yang tidak dapat membuat kemajuan apapun dan deadlock merupakan kondisi terparah karena dapat melibatkan banyak proses dan semuanya tidak dapat mengakhiri prosesnya secara benar

Starvation(kelaparan)

Starvation adalah keadaan dimana pemberian akses bergantian terus-menerus dan ada suatu proses yang tidak mendapatkan gilirannya


middot Terdapat tiga proses yaitu P1 P2 dan P3

middot P1 P2 dan P3 memerlukan pengaksesan sumber daya R secara periodik Skenario berikut terjadi

middot P1 sedang diberi sumber daya R sedangkan P2 dan P3 diblocked menunggu sumberdaya R

middot Ketika P1 keluar dari critical section maka P2 dan P3 diijinkan mengakses R

middot Asumsi P3 diberi hak akses kemudian setelah selesai hak akses kembali diberikan ke P1 yang saat itu kembali membutuhkan sumber daya R

Jika pemberian hak akses bergantian terus-menerus antara P1 dan P3 maka P2 tidak pernah memperoleh pengaksesan sumber daya R Dalam kondisi ini memang tidak terjadi deadlock hanya saja P2 mengalami starvation (tidak ada kesempatan untuk dilayani)

Sinkronisasi

Sinkronisasi adalah proses pengaturan jalannya beberapa proses pada saat yang bersamaan tujuan utama sinkronisasi adalah menghindari terjadinya inkonsitensi data karena pengaksesan oleh beberapa proses yang berbeda (mutual exclusion) serta untuk mengatur urutan jalannya proses-proses sehingga dapat berjalan dengan lancar dan terhindar dari deadlock dan starvation Sinkronisasi umumnya dilakukan dengan bantuan perangkat sinkronisasi Penyelesaian terhadap masalah ini sangat penting karena perkembangan teknologi sistem komputer menuju ke sistem multiprocessing terdistribusi dan paralel yang mengharuskan adanya proses-proses kongkuren

Masalah kongkurensi dapat terjadi pada a Banyak aplikasiMultiprogramming memungkinkan banyak proses sekaligus dijalankan Proses-proses dapat berasal dari aplikasi-aplikasi berbeda Pada sistem sistem multiprogramming bisa terdapat banyak aplikasi sekaligus yang dijalankan di sistem komputer

b Strukturisasi sebuah aplikasi yang terdiri dari kumpulan prosesPerluasan prinsip perancangan modular dan pemograman terstruktur adalah suatu aplikasi dapat secara efektif diimplementasikan sebagai kumpulan proses Dengan sekumpulan proses maka tiap proses menyediakan satu layanan spesifik tertentu

c Strukturisasi sebuah prosesSaat ini untuk peningkatan kinerja maka satu proses dapat memiliki banyak thread yang independen Thread-thread tersebut harus dapat bekerjasama untuk mencapai tujuan proses Strukturisasi satu aplikasi dapat dilakukan dengan banyak proses atau banyak thread Sistem operasi modern telah mendukung banyak thread yang berkinerja lebih bagus dibanding proses dalam kondisilingkungan yang lebih terkendali

Contoh Suatu word processor antara lain mempunyai kemampuan a Menerima masukan dari keyboardb Menerima masukan dari mouse atau perangkat penunjuk yang lain (asinkron)c Pemisahan kata-katad Memformat baris menjadi rata kanan kiri atau kanan-kiri

Aplikasi ini dapat diterapkan dengan banyak proses atau thread yang masing-masing mempunyai tugas tertentu Dengan demikian saat dilakukan penataan tampilan di layar aplikasi sekaligus dapat menerima masukan dari mouse yang segera akan diteruskan ke aplikasi untuk mendapat perhatian

d Strukturisasi sistem operasiKeunggulan strukturisasi dapat diterapkan ke pemrograman sistem Beberapa sistem operasi aktual yang dipasarkan dan yang sedang dalam riset telah diimplementasikan sebagai kumpulan proses Sistem operasi bermodelkan clientserverPada sistem dengan banyak proses kongkuren terdapat tiga kategori interaksi yaitu

a Proses-proses saling tidak peduli (independen) Proses-proses ini tidak dimaksudkan untuk bekerja bersama untuk mencapai tujuan tertentu Pada multiprogramming dengan proses-proses independen dapat berupa batch atau sesi interaktif atau campuan keduanya Meski proses-proses tidak bekerja bersama sistem operasi perlu mengatur persaingan diantara proses-proses itu dalam memperoleh sumber daya yang terbatas

Contoh Terdapat dua aplikasi yang berusaha mengakses printer yang sama bila kedua aplikasi benar-benar mengakses printer yang sama secara bersamaan maka kedua proses akan memperoleh hasil yang tak dikehendakiSistem operasi harus mengatur pengaksesan-pengaksesan sumber daya agar tidak menyebabkan hasil yang tidak dikehendaki

b Proses-proses saling mempedulikan secara tidak langsungDimana proses-proses tidak perlu saling mempedulikan identitas proses-proses lain tapi sama-sama mengakses objek tertentu seperti buffer masukankeluaran Proses-proses itu perlu bekerja sama (cooperation) dalam memakai bersama objek tertentu

c Proses-proses saling mempedulikan secara langsung

Proses-proses dapat saling berkomunikasi dan dirancang bekerja sama untuk suatu aktivitas

Interaksi antara proses-proses dan masalah-masalah yang harus diatasi dapat dilihat dalam tabel berikut Derajat kepedulian

Hubungan

Akibat satu proses terhadap lainnya

Masalah pengendalian yang dilakukan

Proses tak peduli

Persaingan middot Hasil satu proses Independen terhadap aksi proses lain

middot Pewaktuan proses dapat berdampak pada proses lain

middot Mutual exclusionmiddot Deadlockmiddot Starvation

Proses secara tidak langsung peduli terhadap proses lain yaitu objek yang dipakai bersama

Kerjasama dengan pemakaian bersama

middot Hasil-hasil satu proses dapat bergantung pada informasi yang diperoleh dari proses lainmiddot Pewaktuan proses dapat berdampak pada proses lain

middot Mutual exclusionmiddot Deadlockmiddot Starvationmiddot Koherensi data

Proses secara langsung peduli terhadap proses lain (tersedia primitif-primitif untuk proses tersebut

Kerjasama dengan komunikasi


middot Deadlockmiddot Starvation

Persaingan diantara proses-proses untuk sumber daya

Sebuah proses membutuhkan beberapa sumber daya untuk menyelesaikan tugasnya alokasi sumber daya tersebut dikelola oleh Sistem Operasi Umpamanya waktu CPU memori berkas-berkas dan perangkat-perangkat MK (mauskankeluaran) Ketika Proses tersebut berhenti dijalankan system operasi akan mendapatkan kembali semua sumberdaya yang bisa digunakan kembali Proses berstate running menjadi blocked karena sumbar daya yang diminta belum tersedia atau meminta layanan perangkat masukankeluaran sehingga menunggu kejadian muncul Proses menunggu kejadian alokasi sumber daya atau selesainya layanan perangkat masukankeluaran (event wait)

Proses-proses kongkuren berkompetisi ketika proses-proses bersaing menggunakan sumber daya yang sama Dua proses atau lebih perlu mengakses sumber daya yang sama pada suatu saat Masing-masing proses tidak peduli keberadaan proses-proses lain dan masing-masing proses

tidak dipengaruhi proses-proses lain Pada proses-proses berkompetisi ini tidak ada pertukaran informasi antara proses-proses itu Eksekusi satu proses dapat berpengaruh terhadap kelakuan proses-proses yang berkompetisi Jika dua proses ingin mengakses satu sumber daya tunggal maka sistem operasi mengalokasikan untuk salah satu proses dan mengharuskan proses lain menunggu Proses yang ditolak pengaksesan menjadi melambatKasus ekstrim yang dapat terjadi adalah proses di-blocked terus-menerus sehingga tak pernah mengakses sumber daya Proses tak pernah dapat berakhir dengan suskses Kondisi tidak pernah dapat kesempatan dialokasikan sumber daya disebut startvation Sistem operasi harus menghindarkan terjadinya kondisi ini Persaingan proses-proses untuk memperoleh sumber daya menimbulkan tiga masalah

1 Mutual exclusion

2 Deadlock

3 Startvation

Pengendalian persaingan melibatkan sistem operasi yang bertugas mengalokasikan sumber daya Proses-proses itu sendiri harus menyatakan keperluan mutual exclusion (diprogram oleh pemrogram menggunakan system call yang disediakan sistem operasi) dan sistem operasi menangani agar tidak terlanggar kondisi mutual exclusion serta tidak terjadi deadlock dan startvation

Kerjasama diantara proses-proses dengan pemakaian bersama

Dalam kasus kerjasama pemakaian sumber daya bersama meliputi proses-proses yang saling berinteraksi tanpa dinyatakan secara eksplisitContoh Banyak proses mengakses variabel atau berkas yang dipakai bersama Proses-proses dapat menggunakan dan memperbarui data yang dipakai bersama tanpa peduli proses-proses lain Proses mengetahui bahwa proses-proses lain dapat juga mengakses data yang sama Proses-proes harus bekerja sama untuk menjamin integritas data yang dipakai bersama tersebut

Kerjasama diantara proses-proses dalam pemakaian bersama mempunyai masalah

middot Mutual exclusion

middot Deadlock

middot Startvation

Karena data disimpan pada suatu sumber daya (peralatan memori) maka terdapat masalah pengendalian mutual exclusion deadlock dan startvationPerbedaannya adalah item-item data dapat diakses dengan dua mode yaitu

1 Operasi pembacaan dan penulisan harus mutually exclusive (yaitu benar-benar hanya satu proses yang berada di critical section)

2 Operasi penulisan saja yang harus mutually exclusivePada situasi ini masalah baru muncul yaitu mengenai koherensi data Critical section digunakan untuk menjamin integritas data

Kerjasama diantara proses-proses dengan komunikasi

Pada kasus persaingan proses-proses memakai sumber daya tanpa peduli proses-proses lain Pada kasus kedua proses-proses memakai bersama nilai dan meski masing-masing proses tidak secara eksplisit peduli proses-proses lain Tapi proses-proses peduli untuk menjaga integritas dataKetika proses-proses bekerja sama dengan komunikasi beragam proses berpartisipasi dalam suatu usaha dengan menghubungkan semua proses Komunikasi menyediakan cara untuk sinkronisasi atau koordinasi beragam aktivitasKomunikasi dicirikan dengan berisi pesan-pesan dengan suatu urutan Primitif untuk mengirim dan menerima pesan disediakan sebagai bagian bahasa pemrograman atau disediakan kernel sistem operasiKarena tak ada sesuatu yang dipakai bersama diantara proses-proses itu dalam melewatkan pesan-pesan tak ada masalah mutual exclusion Tetapi masalah deadlock dan startvation dapat muncul

1 2 MUTUAL EXCLUSION

Mutual exclusion adalah jaminan hanya satu proses yang mengakses sumber daya pada satu interval waktu tertentu Sumber daya yang tidak dapat dipakai bersama pada saat bersamaan

Sering terjadi pada peralatan pencetakan (printer) Daemon printer adalah proses yang melakukan penjadwalan dan pengendalian pencetakan berkas-berkas di printer Ruang disk ini disebut direktori spooler Direktori spooler membagi disk menjadi sejumlah slot Slot-slot diisi berkas yang akan dicetak Terdapat variabel in yang menunjuk slot bebas pada ruang disk yang akan dipakai untuk menyimpan berkas yang ingin dijadwalkan untuk dicetak Bagian program yang sedang mengakses memory atau sumber daya yang dipakai bersama disebut critical section Jika proses pada critical section memblokir proses-proses lain dalam antrian maka akan terjadi startvation dan deadlock

Kesuksesan proses-proses konkurensi memerlukan pendefinisian critical section dan memaksakan mutual exclusion di antara proses-proses konkuren yang sedang berjalan Pemaksaan mutual exclusion merupakan landasan pemrosesan konkuren Fasilitas atau kemampuan menyediakan dukungan mutual exclusion harus memenuhi kriteria sbb

Mutual exclusion harus dijamin bahwa tidak ada proses lain kecuali dirinya sendiri Di sini terjadi proses tunggal

Proses yang berada di noncritical section dilarang mem-blocked proses-proses lain yang ingin masuk critical section Hal ini bisa terjadi startvation

Harus dijamin bhwa proses yang ingin masuk critical section tidak menunggu selama waktu yang tak terhingga Ini bisa mengakibatkan masalah deadlock dan antrian proses bertambah panjang

Ketika tidak ada proses pada critical section maka proses yang ingin masuk critical section harus ijinkan masuk tanpa waktu tunda

Tidak ada asumsi mengenai kecepatan relatif proses atau jumlah yang ada

Proses hanya tinggal pada critical section selama satu waktu yang berhingga

Beberapa metode yang diusulkan untuk menjamin Mutual Exclusion antara lain

- Metode Variable Lock

Locking adalah salah satu mekanisasi pengontrol konkuren Konsep dasar pada saat suatu transaksi memerlukan jaminan kalau record yang diinginkan tidak akan berubah secara mendadak maka diperlukan kunci untuk record tersebut Fungsi kunci (lock) adalah menjaga record tersebut agar tidak dimodifikasi transaksi lain

Cara kerja dari kunci

1 Pertama kita asumsikan terdapat 2 macam kunci

- Kunci X kunci yang eksklusif

- Kunci S kunci yang digunakan bersama-sama

1 Jika transaksi A menggunakan kunci X pada record R maka permintaan dari transaksi B untuk suatu kunci pada R ditunda dan B harus menungggu sampai A melepaskan kunci tersebut

2 Jika transaksi A menggunakan kunci S pada record R maka 3 Bila transaksi B ingin menggunakan kunci X maka B harus menunggu sampai A

melepaskan kunci tersebut4 Bila transaksi B ingin menggunakan kunci S maka B dapat menggunakan kunci S

bersama A

Tabel Kunci

1 Bila suatu transaksi hanya melakukan pembacaan saja secara otomatis ia memerlukan kunci S 1048774 baca (S)

Bila transaksi tersebut ingin memodifikasi record maka secara otomatis ia memerlukan kunci X 1048774 memodifikasi (X)

Bila transaksi tersebut sudah menggunakan kunci S setelah itu ia akan memodifikasi record maka kunci S akan dinaikan ke level kunci X

1 Kunci X dan kunci S akan dilepaskan pada saat synchpoint (synchronization point) Synchpoint menyatakan akhir dari suatu transaksi dimana basis data berada pada state yang konsisten Bila synchpoint ditetapkan maka

Semua modifikasi program menjalankan operasi commit atau rollback Semua kunci dari record dilepaskan

Metode ini sederhana ketika proses masuk critical section lebih dahulu memeriksa variable lock

Jika variable lock bernilai 0 proses men-set variable locknya menjadi 1 kemudian masuk ke dalam critical section

Jika variable lock bernilai 1 maka proses menunggu sampai nilai variable lock nya menjadi 0

Metode ini tidak menjamin proses tidak masuk critical section yang telah dimasuki proses lain

Metode bergantian secara ketat

Metode ini mengasumsikan dapat mengalir masuk critical section secara bergantian terus-menerus Metode ini melakukan refleksi terhadap variabel yang berfungsi untuk memenuhi critical section

Critical Section

Critical Section adalah sebuah segmen kode di mana sebuah proses yang mana sumber daya bersama diakses Terdiri dari

Entry Section kode yang digunakan untuk masuk ke dalam critical section

Critical Section Kode di mana hanya ada satu proses yang dapat dieksekusi pada satu waktu

Exit Section akhir dari critical section mengizinkan proses lain

Remainder Section kode istirahat setelah masuk ke critical section

Critical section harus melakukan ketiga aturan berikut

Solusi ldquocritical section problemrdquo harus memenuhi

1 1 Mutual Exclusion Jika proses Pi sedang ldquoeksekusirdquo pada bagian ldquocritical sectionrdquo (dari proses Pi) maka tidak ada proses proses lain dapat ldquoeksekusirdquo pada bagian critical section dari proses-proses tersebut

2 2 Progress Jika tidak ada proses sedang eksekusi pada critical section-nya dan jika terdapat lebih dari satu proses lain yang ingin masuk ke critical section maka pemilihan siapa yang berhak masuk ke critical section tidak dapat ditunda tanpa terbatas

3 3 Bounded Waiting Terdapat batasan berapa lama suatu proses harus menunggu giliran untuk mengakses ldquocritical sectionrdquo ndash jika seandainya proses lain yang diberikan hak akses ke critical section

Menjamin proses dapat mengakses ke ldquocritical sectionrdquo (tidak mengalami starvation proses se-olah berhenti menunggu request akses ke critical section diperbolehkan)

Tidak ada asumsi mengenai kecepatan eksekusi proses proses n tersebut

Ketika proses hendak masuk critical selection proses lebih dulu memeriksa variable lock dengan ketentuan sebagai berikut

bull Jika variable lock bernilai 0 proses meng-set variable lock menjadi 1 dan segera masuk critical section

bull Jika variable lock bernilai 1 proses menunggu sampai nilai variable lock menjadi nol (situasi ini berarti sedang terdapat proses lain di critical section)

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

Metode Penyelesaian Masalah Mutual Exclusion

Ada beberapa metode penyelesaian masalah mutual exclusion antara lain

1 a Sinkronisasi

Algoritma 1

Pada bagian ini akan dibatasi pada aplikasi ke 2 proses yaitu Pi dan Pj atau P0dan P1

Secara umum jika ada proses Pimaka akan digunakan proses Pj sebagai proses lainnya dengan j=1-i Ada beberapa algoritma penyelesaian mutual exclusion dengan menggunakan sinkronisasi yakni

Kedua proses akan berbagi suatu variabel bertipe integer yaitu turn yang diinisialisaikan dengan 0 (atau 1) Jika turn=0 maka proses P0 diijinkan untuk

mengeksekusi critical section Struktur P0 terlihat pada gambar dibawah ini

repeat

while turn ne0 do

critical section

turn = 1

remainder section

until false

Solusi ini sudah menunjukkan adanya mutual exclusion karena pada suatu saat hanya ada satu proses yang masuk critical section Namun belum menunjukkan adanya progress dan bounded waiting Sebagai contoh

Jika P0 meninggalkan critical section maka nilai turn=1 yang berarti bahwa P1 siap untuk masuk ke critical section

P1 selesai menggunakan critical section dengan cepat maka baik P1 maupun P0 beradapada remainder section dengan nilai turn=0

P0 kembali menggunakan critical section dengan cepat dan segera masuk ke remainder section dengan nilai turn=1

P0 hendak kembali menggunakan critical section namun nilai turn=1Terlihat bahwa P1 yang berada pada remainder section memblok P0 sehingga tidak dapat memasuki critical section Hal ini menentang progress yaitu proses diblok oleh proses yang tidak berada di critical section

Algoritma 2

Masalah pada algoritma-1 tidak memberika cukup informasi mengenai status proses Hanya mempertimbangkan yang masuk critical section Untuk mengatasi masalah ini variabel ldquoturnrdquo diganti dengan

var flag array [0 1] of boolean

Semua elemen array diinisialisasikan dengan false Jika flag[0] bernilai true maka nilai itu akan mengindikasikan bahwa P0 siap memasuki critical section Struktur P0 terlihat pada gambar dibawah ini

repeat

flag[0]=true

while flag[1] do

critical section

flag[0]

remainder section

until false

Pada algoritma ini proses P0 pertama kali menetapkan flag[i] = true nilai ini

mengindikasikan bahwa P0 siap memasuki critical section Kemudian P0 mengecek untuk menyakinkan P1 tidak akan memasuki tidak kan memasuki critical section Jika P1 juga telah memasuki critical section maka P0 harus menunggu sampai P1 tidak membutuhkan critical

section lagi (sampai flag[1] =false) Secepatnya P0 memasuki critical section Pada exit section P0 akan mengeset flag[0] menjadi false hal ini mengijinkan proses la in (jika sedang menunggu) untuk memasuki critical sectionPada solusi ini kondisi mutual exclusion telah dipenuhi Namun progress belum juga dipenuhi Untuk menggambarkan hal tersebut dapat dilihat

T0 P0 menetapkan flag[0] = true


Sekarang P0 dan P1 bersama-sama ada di statement while

Algoritma ndash3 (Peterson)

Algoritma ketiga ini diperkenalkan oleh peterson Pada dasarnya algoritma ini merupakan kombinasi antara algoritma ndash1 dan algoritma-2 Proses ini membutuhkan 2 variabel yaitu

Var Flag array [0 1] of boolean

Turn 0 1

Nilai awal flag[0] = flag = false dan nilai turn (0 atau 1) Struktur proses P1 seperti terlihat pada gambar dibawah ini

repeat

flag[0]=true

turn=1

while (flag[1] and turn=1) do

critical section

flag[0]

remainder section

until false

Untuk masuk ke critical section proses P0 mengeset flag[0] = true dan melihat apakah ada proses lain yang mencoba masuk critical section (turn=1)

Algoritma Bakery

Critical section untuk n proses

Sebelum masuk ke critical section Proses mendapatkan nomor Yang memiliki nomor paling kecil lebih dahulu memasuki critical section Jika proses Pi dan Pj menerima nomor jika iltj maka Pi lebih dahulu masuk critical section sebaliknya Pj yang lebih dahulu masuk critical section skema penomoran selalu membangkitkan angka yang meningkat seperti 123456 hellip

shared data

var choosing array[0n-1] of boolean

number array[0n-1] of integer

Struktur data diinisialisaikan dengan false dengan nilai 0 Struktur proses P1 seperti terlihat pada gambar dibawah ini

repeat

choosing[i]=true

number[i]=max(number[0] number[1] hellip number[n-1])+1

choosing[i]=false

for j= 0 to n-1

do begin

while choosing[j] do no_op

while number[j] 0

and (number[j]j) lt (number[i]i) do no_op

end

critical section

number[i]=0

remainder section

until false

Algoritma Dekker

Algoritma ini diperkenalkan oleh Dekker seorang matematikawan dari Belanda Algoritma ini memiliki ciri-ciri khusus sebagai berikut

Tidak memerlukan instruksi-instruksi perangkat keras khusus

Proses yang beroperasi di remainder section tidak dapat mencegah proses lain yang ingin masuk critical section

Proses yang ingin masuk critical section akan segera memasuki kawasan tersebut jika dimungkinkan

bool Fail = false

int share = 6

int x = 0

int y = 0

bool z = true

chan q_0_1 = [0] of bit


proctype A()

bool dapat_dishare = true

do

atomic

z -gt

x = 10

atomic

dapat_dishare -gt

q_0_10

share = share+1

dapat_dishare = false

q_0_11

atomic

dapat_dishare -gt

q_0_20

dapat_dishare = true

q_0_21

od

proctype B()

bool dapat_dishare = false

do

atomic

z -gt

y = 11

atomic

dapat_dishare -gt

q_0_20

share = share-1


q_0_21

atomic

dapat_dishare -gt

q_0_10


q_0_11

od

init

atomic

run A()

run B()

1 b Semaphore

Model semaphore secara umum untuk penyelesaian mutual exclusion adalah sebagai berikut

mtype = idle masuk critical keluar

define state mtype

bool Fail = false

bool semaphore = false

proctype USER_0()

state user_state = idle

do

atomic

user_state==idle -gt

if

user_state = idle

user_state = masuk

fi

atomic

((user_state==masuk)ampamp(semaphore)) -gt

user_state = critical

semaphore = true

atomic


user_state = masuk

atomic

user_state==critical -gt

if


user_state = keluar

fi

atomic

user_state==keluar -gt

user_state = idle

semaphore = false

od

proctype USER_1()


do

atomic


if

user_state = idle

user_state = masuk

fi

atomic



semaphore = true

atomic


user_state = masuk

atomic


if


user_state = keluar

fi

atomic


user_state = idle

semaphore = false

od

init

atomic

run USER_0()

run USER_1()

1 3 SINKRONISASI

Pengertian Sinkronisasi

Sinkronisasi adalah Komunikasi antara proses yang membutuhkan place by calls untuk mengirim dan menerima data primitive Terdapat rancangan yang berbeda-beda dalam implementasi setiap primitive Pengiriman pesan mungkin dapat diblok (blocking) atau tidak dapat dibloking (nonblocking) ndash juga dikenal dengan nama sinkron atau asinkron

Kasus Produsen-Konsumer

Dua proses berbagi sebuah buffer dengan ukuran yang tetap Salah satunya produser meletakkan informasi ke buffer yang lainnya Konsumen mengambil informasi dari buffer Ini juga dapat digeneralisasi untuk masalah yang memiliki m buah produsen dan n buah konsumen tetapi kita hanya akan memfokuskan kasus dengan satu produsen dan satu konsumen karena diasumsikan dapat menyederhanakan solusi

Masalah akan timbul ketika produsen ingin menaruh barang yang baru tetapi buffer sudah penuh Solusi untuk produsen adalah istirahat (sleep) dan akan dibangunkan ketika konsumen telah mengambil satu atau lebih barang dari buffer Biasanya jika konsumen ingin mengambil barang dari buffer dan melihat bahwa buffer sedang kosong maka konsumen istirahat (sleep) sampai produsen meletakkan barang pada buffer dan membangunkan (wake up) consumer

Pendekatan seperti ini terdengar cukup sederhana tetapi hal ini dapat menggiring kita ke jenis masalah yang sama seperti race condition dengan spooler direktori

Untuk mengetahui jumlah barang di buffer kita membutuhkan sebuah variabel kita namakan count Jika jumlah maksimum dairi barang yang dapat ditampung buffer adalah N kode produser pertama kali akan mencoba untuk mengetahui apakah nilai count sama dengan nilai N Jika itu terjadi maka produsen akan istirahat (sleep) tetapi jika nilai count tidak sama dengan N produsen akan terus menambahkan barang dan menaikkan nilai count

Sekarang mari kita kembali ke permasalahan race condition Ini dapat terjadi karena akses ke count tidak dipaksakan Situasi seperti itu mungkin dapat terjadi Buffer sedang kosong dan konsumen baru saja membaca count untuk melihat apakah count bernilai 0 Pada saat itu penjadual memutuskan untuk mengentikan proses konsumen sementara dan menjalakan produsen Produsen memasukkan barang ke buffer menaikkan nilai count dan memberitahukan bahwa count sekarang bernilai 1 Pemikiran bahwa count baru saja bernilai 0 sehingga konsumen harus istirahat (sleep) Produsen memanggil fungsi wake up untuk membangkitkan konsumen

Sayangnya konsumen secara logika belum istirahat Jadi sinyal untuk membangkitkan konsumen tidak dapat ditangkap oleh konsumen Ketika konsumen bekerja berikutnya konsumen akan memeriksa nilai count yang dibaca sebelumnya dan mendapatkan nilai 0

kemudian konsumen istirahat (sleep) lagi Cepat atau lambat produsen akan mengisi buffer dan juga pergi istirahat (sleep) Keduanya akan istirahat selamanya

Inti permasalahannya disini adalah pesan untuk membangkitkan sebuah proses tidak tersampaikan Jika pesan sinyal ini tersampaikan dengan baik segalanya akan berjalan lancar

Call Sleep And Call Wake Up

- Proses yang belum mendapat giliran sebaiknya ldquotidurrdquo dahulu dan akan dibangunkan (WAKE UP) jika gilirannya tiba

- Proses yang sedang SLEEP tidak mengunakan waktu CPU sama sekali

- Contoh producer ndash consumer

- Producer ingin memasukkan item sedang buffer telah penuh (ldquotidurrdquo dahulu)

- Producer akan dibangunkan setelah consumer me ldquoremoverdquo sebuah item

- Consumer akan tidur bila isi buffer adalah empty

- Consumer bangun bila buffer telah berisi sebuah item

- Consumer dan producer bekerja secara independen (bergantung jatah waktu CPU)

- Buffer agrave sebagai Critical Section

- Race Condition bagaimana terjadinya

- Akses ke count ldquounconstrainedrdquo

- Ada interrupt (karena jatah CPU habis) pada consumer yaitu pada saat if (count=0) agrave hingga C amp P agrave sleep

Kesimpulan

Konkurensi

Kondisi dimana pada saat yang bersamaan terdapat lebih dari satu proses disebut dengan kongkurensi (proses-proses yang kongkuren) Proses-proses yang mengalami kongkuren dapat berdiri sendiri (independen) atau dapat saling berinteraksi sehingga membutuhkan sinkronisasi atau koordinasi proses yang baik

Prinsip-prinsip konkurensi

Alokasi waktu pemroses untuk proses-proses

Pemakaian bersama dan persaingan untuk mendapatkan sumber daya Komunikasi antarproses Sinkronisasi aktivitas banyak proses

Kesulitan yang diakibatkan konkurensi

Pemakaian bersama sumber daya global Pengelolaan alokasi sumber daya agar optimal Pencarian kesalahan pemrograman

Yang dilakukan So dengan adanya konkurensi

Mengetahui Proses-proses yang Aktif Alokasi dan Dealokasi Beragam Sumber Daya untk Tiap Proses yang Aktif Proteksi Sata dan Sumber Daya Fisik Hasil-hasil Proses Harus Independen

Masalah-masalah yang timbul akibat persaingan untuk mendapatkan sumber daya Mutual ExclusionDeadlock dan Starvation

Kerjasama antar proses-proses dengan pemakaian bersama Dalam kasus kerjasama pemakaian sumber daya bersama meliputi proses-proses yang saling berinteraksi tanpa dinyatakan secara eksplisitKerjasama diantara proses-proses dengan komunikasiPada kasus persaingan proses-proses memakai sumber daya tanpa peduli proses-proses lain

Mutual Exclusion


mutual exclusion merupakan landasan pemrosesan konkuren Fasilitas atau kemampuan menyediakan dukungan mutual exclusion harus memenuhi kriteria sbb







Solusi Masalah Critical Section

Mencakup pemakaian secara ldquoexclusiverdquo dari shared variable tersebut Menjamin proses lain dapat menggunakan shared variable tersebut


1 Mutual Exclusion Jika proses Pi sedang ldquoeksekusirdquo pada bagian ldquocritical sectionrdquo (dari proses Pi) maka tidak ada proses proses lain dapat ldquoeksekusirdquo pada bagian critical section dari proses-proses tersebut

2 Progress Jika tidak ada proses sedang eksekusi pada critical section-nya dan jika terdapat lebih dari satu proses lain yang ingin masuk ke critical section maka pemilihan siapa yang berhak masuk ke critical section tidak dapat ditunda tanpa terbatas

3 Bounded Waiting Terdapat batasan berapa lama suatu proses harus menunggu giliran untuk mengakses ldquocritical sectionrdquo ndash jika seandainya proses lain yang diberikan hak akses ke critical section







Metode-metode penyelesaian mutual exclusion

1 Sinkronisasi algoritma1 algoritma 2 algoritma Peterson algoritma bakery algoritma dekker

2 Semaphore

Sinkronisasi

Sinkronisasi adalah Komunikasi antara proses yang membutuhkan place by calls untuk mengirim dan menerima data primitive Terdapat rancangan yang berbeda-beda dalam implementasi setiap primitive Pengiriman pesan mungkin dapat diblok (blocking) atau tidak

dapat dibloking (nonblocking) ndash juga dikenal dengan nama sinkron atau asinkronCall Sleep And Call Wake Up













DAFTAR PUSTAKA

Sistem Operasi SP Hariningsih Penerbit Graha Ilmu 2003

Operating Systemsldquo Englewood Cliffs New Jersey Prentice-Hall Inc 1992 Tanenbaum Andrew S ldquoModern

httpiwansantosafileswordpresscom200904makalah-konkurensi-2doc

httpkur2003ifitbacidfileCN-IF3191-IPCpdf

httphusniits-sbyeduproses1ppt

httpatitstaffgunadarmaacidDownloadsfiles653203+Manajemen+Prosesdoc

httpwwwdwiantorocomdocumentsOS_13_Kongkurensipdf

httpkuliahdinusacidikaso5html

httpkulinoninehubcomfilephp1nhrestore5kongkurensippt

httphery_hstaffgunadarmaacidDownloadsfiles1163SisOpppt


Sumber daya yang harus dikelola antara lain middot Waktu pemrosesmiddot Memori middot Berkas-berkas (file) middot Peralatan masukankeluaran middot Dan sebagainyac Proteksi data dan sumber daya fisik proses Proteksi data dan sumber daya fisik masing-masing proses dari gangguan (interfensi) proses-proses lain

d Hasil-hasil proses harus independen Hasil-hasil proses harus independen terhadap kecepatan relatif proses- proses lain dimana eksekusi dilakukan

Proses yang kongkuren ini mempunyai beberapa masalah yang harus diselesaikan

yaitu

Mutual exclusion (pengeluaran timbal balik)

Merupakan kondisi dimana terdapat sumber daya yang tidak dapat dipakaibersama pada waktu yang bersamaan (misalnya printer disk drive) Kondisidemikian disebut sumber daya kritis dan bagian program yang menggunakan sumber daya kritis disebut critical region section Hanya satu program pada satu saat yang diijinkan masuk ke critical region Pemrogram tidak dapat bergantung pada sistem operasi untuk memahami dan memaksakan batasan ini karena maksud program tidak dapat diketahui oleh sistem operasi Hanya saja sistem operasi menyediakan layanan (system call) yang bertujuan untuk mencegah proseslain masuk ke critical section yang sedang digunakan proses tertentuPemrograman harus menspesifikasikan bagian-bagian critical section sehingga sistem operasi akan menjaganya Pentingnya mutual exclusion adalah jaminan hanya satu proses yang mengakses sumber daya pada suatu interval waktu Pemaksaan atau pelanggaran mutual exclusion menimbulkan

a Deadlock

b Starvation

Deadlock (buntu)

Deadlock merupakan kondisi terparah karena banyak proses dapat terlibat dan semuanya tidak dapat mengakhiri prosesnya secara benar


middot Terdapat dua proses yaitu P1 dan P2 dan dua sumber daya kritis yaitu R1 dan R2

middot Proses P1 dan P2 harus mengakses kedua sumber daya tersebut dengan kondisi ini terjadi R1 diberikan ke P1 sedangkan R2 diberikan ke P2











Sinkronisasi














Hubungan



Proses tak peduli
















1 Mutual exclusion

2 Deadlock

3 Startvation






middot Deadlock

middot Startvation


























bersama A

Tabel Kunci












Critical Section



















1 a Sinkronisasi

Algoritma 1





repeat

while turn ne0 do

critical section

turn = 1

remainder section

until false






Algoritma 2




repeat

flag[0]=true

while flag[1] do

critical section

flag[0]

remainder section

until false










Turn 0 1


repeat

flag[0]=true

turn=1


critical section

flag[0]

remainder section

until false


Algoritma Bakery



shared data




repeat

choosing[i]=true


choosing[i]=false

for j= 0 to n-1

do begin


while number[j] 0


end

critical section

number[i]=0

remainder section

until false

Algoritma Dekker





bool Fail = false

int share = 6

int x = 0

int y = 0

bool z = true



proctype A()


do

atomic

z -gt

x = 10

atomic

dapat_dishare -gt

q_0_10

share = share+1


q_0_11

atomic

dapat_dishare -gt

q_0_20


q_0_21

od

proctype B()


do

atomic

z -gt

y = 11

atomic

dapat_dishare -gt

q_0_20

share = share-1


q_0_21

atomic

dapat_dishare -gt

q_0_10


q_0_11

od

init

atomic

run A()

run B()

1 b Semaphore



define state mtype

bool Fail = false


proctype USER_0()


do

atomic


if

user_state = idle

user_state = masuk

fi

atomic



semaphore = true

atomic


user_state = masuk

atomic


if


user_state = keluar

fi

atomic


user_state = idle

semaphore = false

od

proctype USER_1()


do

atomic


if

user_state = idle

user_state = masuk

fi

atomic



semaphore = true

atomic


user_state = masuk

atomic


if


user_state = keluar

fi

atomic


user_state = idle

semaphore = false

od

init

atomic

run USER_0()

run USER_1()

1 3 SINKRONISASI

























Kesimpulan

Konkurensi











Mutual Exclusion























2 Semaphore

Sinkronisasi















DAFTAR PUSTAKA






















Sinkronisasi














Hubungan



Proses tak peduli
















1 Mutual exclusion

2 Deadlock

3 Startvation






middot Deadlock

middot Startvation


























bersama A

Tabel Kunci












Critical Section



















1 a Sinkronisasi

Algoritma 1





repeat

while turn ne0 do

critical section

turn = 1

remainder section

until false






Algoritma 2




repeat

flag[0]=true

while flag[1] do

critical section

flag[0]

remainder section

until false










Turn 0 1


repeat

flag[0]=true

turn=1


critical section

flag[0]

remainder section

until false


Algoritma Bakery



shared data




repeat

choosing[i]=true


choosing[i]=false

for j= 0 to n-1

do begin


while number[j] 0


end

critical section

number[i]=0

remainder section

until false

Algoritma Dekker





bool Fail = false

int share = 6

int x = 0

int y = 0

bool z = true



proctype A()


do

atomic

z -gt

x = 10

atomic

dapat_dishare -gt

q_0_10

share = share+1


q_0_11

atomic

dapat_dishare -gt

q_0_20


q_0_21

od

proctype B()


do

atomic

z -gt

y = 11

atomic

dapat_dishare -gt

q_0_20

share = share-1


q_0_21

atomic

dapat_dishare -gt

q_0_10


q_0_11

od

init

atomic

run A()

run B()

1 b Semaphore



define state mtype

bool Fail = false


proctype USER_0()


do

atomic


if

user_state = idle

user_state = masuk

fi

atomic



semaphore = true

atomic


user_state = masuk

atomic


if


user_state = keluar

fi

atomic


user_state = idle

semaphore = false

od

proctype USER_1()


do

atomic


if

user_state = idle

user_state = masuk

fi

atomic



semaphore = true

atomic


user_state = masuk

atomic


if


user_state = keluar

fi

atomic


user_state = idle

semaphore = false

od

init

atomic

run USER_0()

run USER_1()

1 3 SINKRONISASI

























Kesimpulan

Konkurensi











Mutual Exclusion























2 Semaphore

Sinkronisasi















DAFTAR PUSTAKA























Hubungan



Proses tak peduli
















1 Mutual exclusion

2 Deadlock

3 Startvation






middot Deadlock

middot Startvation


























bersama A

Tabel Kunci












Critical Section



















1 a Sinkronisasi

Algoritma 1





repeat

while turn ne0 do

critical section

turn = 1

remainder section

until false






Algoritma 2




repeat

flag[0]=true

while flag[1] do

critical section

flag[0]

remainder section

until false










Turn 0 1


repeat

flag[0]=true

turn=1


critical section

flag[0]

remainder section

until false


Algoritma Bakery



shared data




repeat

choosing[i]=true


choosing[i]=false

for j= 0 to n-1

do begin


while number[j] 0


end

critical section

number[i]=0

remainder section

until false

Algoritma Dekker





bool Fail = false

int share = 6

int x = 0

int y = 0

bool z = true



proctype A()


do

atomic

z -gt

x = 10

atomic

dapat_dishare -gt

q_0_10

share = share+1


q_0_11

atomic

dapat_dishare -gt

q_0_20


q_0_21

od

proctype B()


do

atomic

z -gt

y = 11

atomic

dapat_dishare -gt

q_0_20

share = share-1


q_0_21

atomic

dapat_dishare -gt

q_0_10


q_0_11

od

init

atomic

run A()

run B()

1 b Semaphore



define state mtype

bool Fail = false


proctype USER_0()


do

atomic


if

user_state = idle

user_state = masuk

fi

atomic



semaphore = true

atomic


user_state = masuk

atomic


if


user_state = keluar

fi

atomic


user_state = idle

semaphore = false

od

proctype USER_1()


do

atomic


if

user_state = idle

user_state = masuk

fi

atomic



semaphore = true

atomic


user_state = masuk

atomic


if


user_state = keluar

fi

atomic


user_state = idle

semaphore = false

od

init

atomic

run USER_0()

run USER_1()

1 3 SINKRONISASI

























Kesimpulan

Konkurensi











Mutual Exclusion























2 Semaphore

Sinkronisasi















DAFTAR PUSTAKA













1 Mutual exclusion

2 Deadlock

3 Startvation






middot Deadlock

middot Startvation


























bersama A

Tabel Kunci












Critical Section



















1 a Sinkronisasi

Algoritma 1





repeat

while turn ne0 do

critical section

turn = 1

remainder section

until false






Algoritma 2




repeat

flag[0]=true

while flag[1] do

critical section

flag[0]

remainder section

until false










Turn 0 1


repeat

flag[0]=true

turn=1


critical section

flag[0]

remainder section

until false


Algoritma Bakery



shared data




repeat

choosing[i]=true


choosing[i]=false

for j= 0 to n-1

do begin


while number[j] 0


end

critical section

number[i]=0

remainder section

until false

Algoritma Dekker





bool Fail = false

int share = 6

int x = 0

int y = 0

bool z = true



proctype A()


do

atomic

z -gt

x = 10

atomic

dapat_dishare -gt

q_0_10

share = share+1


q_0_11

atomic

dapat_dishare -gt

q_0_20


q_0_21

od

proctype B()


do

atomic

z -gt

y = 11

atomic

dapat_dishare -gt

q_0_20

share = share-1


q_0_21

atomic

dapat_dishare -gt

q_0_10


q_0_11

od

init

atomic

run A()

run B()

1 b Semaphore



define state mtype

bool Fail = false


proctype USER_0()


do

atomic


if

user_state = idle

user_state = masuk

fi

atomic



semaphore = true

atomic


user_state = masuk

atomic


if


user_state = keluar

fi

atomic


user_state = idle

semaphore = false

od

proctype USER_1()


do

atomic


if

user_state = idle

user_state = masuk

fi

atomic



semaphore = true

atomic


user_state = masuk

atomic


if


user_state = keluar

fi

atomic


user_state = idle

semaphore = false

od

init

atomic

run USER_0()

run USER_1()

1 3 SINKRONISASI

























Kesimpulan

Konkurensi











Mutual Exclusion























2 Semaphore

Sinkronisasi















DAFTAR PUSTAKA



































bersama A

Tabel Kunci












Critical Section



















1 a Sinkronisasi

Algoritma 1





repeat

while turn ne0 do

critical section

turn = 1

remainder section

until false






Algoritma 2




repeat

flag[0]=true

while flag[1] do

critical section

flag[0]

remainder section

until false










Turn 0 1


repeat

flag[0]=true

turn=1


critical section

flag[0]

remainder section

until false


Algoritma Bakery



shared data




repeat

choosing[i]=true


choosing[i]=false

for j= 0 to n-1

do begin


while number[j] 0


end

critical section

number[i]=0

remainder section

until false

Algoritma Dekker





bool Fail = false

int share = 6

int x = 0

int y = 0

bool z = true



proctype A()


do

atomic

z -gt

x = 10

atomic

dapat_dishare -gt

q_0_10

share = share+1


q_0_11

atomic

dapat_dishare -gt

q_0_20


q_0_21

od

proctype B()


do

atomic

z -gt

y = 11

atomic

dapat_dishare -gt

q_0_20

share = share-1


q_0_21

atomic

dapat_dishare -gt

q_0_10


q_0_11

od

init

atomic

run A()

run B()

1 b Semaphore



define state mtype

bool Fail = false


proctype USER_0()


do

atomic


if

user_state = idle

user_state = masuk

fi

atomic



semaphore = true

atomic


user_state = masuk

atomic


if


user_state = keluar

fi

atomic


user_state = idle

semaphore = false

od

proctype USER_1()


do

atomic


if

user_state = idle

user_state = masuk

fi

atomic



semaphore = true

atomic


user_state = masuk

atomic


if


user_state = keluar

fi

atomic


user_state = idle

semaphore = false

od

init

atomic

run USER_0()

run USER_1()

1 3 SINKRONISASI

























Kesimpulan

Konkurensi











Mutual Exclusion























2 Semaphore

Sinkronisasi















DAFTAR PUSTAKA


















Critical Section



















1 a Sinkronisasi

Algoritma 1





repeat

while turn ne0 do

critical section

turn = 1

remainder section

until false






Algoritma 2




repeat

flag[0]=true

while flag[1] do

critical section

flag[0]

remainder section

until false










Turn 0 1


repeat

flag[0]=true

turn=1


critical section

flag[0]

remainder section

until false


Algoritma Bakery



shared data




repeat

choosing[i]=true


choosing[i]=false

for j= 0 to n-1

do begin


while number[j] 0


end

critical section

number[i]=0

remainder section

until false

Algoritma Dekker





bool Fail = false

int share = 6

int x = 0

int y = 0

bool z = true



proctype A()


do

atomic

z -gt

x = 10

atomic

dapat_dishare -gt

q_0_10

share = share+1


q_0_11

atomic

dapat_dishare -gt

q_0_20


q_0_21

od

proctype B()


do

atomic

z -gt

y = 11

atomic

dapat_dishare -gt

q_0_20

share = share-1


q_0_21

atomic

dapat_dishare -gt

q_0_10


q_0_11

od

init

atomic

run A()

run B()

1 b Semaphore



define state mtype

bool Fail = false


proctype USER_0()


do

atomic


if

user_state = idle

user_state = masuk

fi

atomic



semaphore = true

atomic


user_state = masuk

atomic


if


user_state = keluar

fi

atomic


user_state = idle

semaphore = false

od

proctype USER_1()


do

atomic


if

user_state = idle

user_state = masuk

fi

atomic



semaphore = true

atomic


user_state = masuk

atomic


if


user_state = keluar

fi

atomic


user_state = idle

semaphore = false

od

init

atomic

run USER_0()

run USER_1()

1 3 SINKRONISASI

























Kesimpulan

Konkurensi











Mutual Exclusion























2 Semaphore

Sinkronisasi















DAFTAR PUSTAKA


















1 a Sinkronisasi

Algoritma 1





repeat

while turn ne0 do

critical section

turn = 1

remainder section

until false






Algoritma 2




repeat

flag[0]=true

while flag[1] do

critical section

flag[0]

remainder section

until false










Turn 0 1


repeat

flag[0]=true

turn=1


critical section

flag[0]

remainder section

until false


Algoritma Bakery



shared data




repeat

choosing[i]=true


choosing[i]=false

for j= 0 to n-1

do begin


while number[j] 0


end

critical section

number[i]=0

remainder section

until false

Algoritma Dekker





bool Fail = false

int share = 6

int x = 0

int y = 0

bool z = true



proctype A()


do

atomic

z -gt

x = 10

atomic

dapat_dishare -gt

q_0_10

share = share+1


q_0_11

atomic

dapat_dishare -gt

q_0_20


q_0_21

od

proctype B()


do

atomic

z -gt

y = 11

atomic

dapat_dishare -gt

q_0_20

share = share-1


q_0_21

atomic

dapat_dishare -gt

q_0_10


q_0_11

od

init

atomic

run A()

run B()

1 b Semaphore



define state mtype

bool Fail = false


proctype USER_0()


do

atomic


if

user_state = idle

user_state = masuk

fi

atomic



semaphore = true

atomic


user_state = masuk

atomic


if


user_state = keluar

fi

atomic


user_state = idle

semaphore = false

od

proctype USER_1()


do

atomic


if

user_state = idle

user_state = masuk

fi

atomic



semaphore = true

atomic


user_state = masuk

atomic


if


user_state = keluar

fi

atomic


user_state = idle

semaphore = false

od

init

atomic

run USER_0()

run USER_1()

1 3 SINKRONISASI

























Kesimpulan

Konkurensi











Mutual Exclusion























2 Semaphore

Sinkronisasi















DAFTAR PUSTAKA

















Algoritma 2




repeat

flag[0]=true

while flag[1] do

critical section

flag[0]

remainder section

until false










Turn 0 1


repeat

flag[0]=true

turn=1


critical section

flag[0]

remainder section

until false


Algoritma Bakery



shared data




repeat

choosing[i]=true


choosing[i]=false

for j= 0 to n-1

do begin


while number[j] 0


end

critical section

number[i]=0

remainder section

until false

Algoritma Dekker





bool Fail = false

int share = 6

int x = 0

int y = 0

bool z = true



proctype A()


do

atomic

z -gt

x = 10

atomic

dapat_dishare -gt

q_0_10

share = share+1


q_0_11

atomic

dapat_dishare -gt

q_0_20


q_0_21

od

proctype B()


do

atomic

z -gt

y = 11

atomic

dapat_dishare -gt

q_0_20

share = share-1


q_0_21

atomic

dapat_dishare -gt

q_0_10


q_0_11

od

init

atomic

run A()

run B()

1 b Semaphore



define state mtype

bool Fail = false


proctype USER_0()


do

atomic


if

user_state = idle

user_state = masuk

fi

atomic



semaphore = true

atomic


user_state = masuk

atomic


if


user_state = keluar

fi

atomic


user_state = idle

semaphore = false

od

proctype USER_1()


do

atomic


if

user_state = idle

user_state = masuk

fi

atomic



semaphore = true

atomic


user_state = masuk

atomic


if


user_state = keluar

fi

atomic


user_state = idle

semaphore = false

od

init

atomic

run USER_0()

run USER_1()

1 3 SINKRONISASI

























Kesimpulan

Konkurensi











Mutual Exclusion























2 Semaphore

Sinkronisasi















DAFTAR PUSTAKA



















Turn 0 1


repeat

flag[0]=true

turn=1


critical section

flag[0]

remainder section

until false


Algoritma Bakery



shared data




repeat

choosing[i]=true


choosing[i]=false

for j= 0 to n-1

do begin


while number[j] 0


end

critical section

number[i]=0

remainder section

until false

Algoritma Dekker





bool Fail = false

int share = 6

int x = 0

int y = 0

bool z = true



proctype A()


do

atomic

z -gt

x = 10

atomic

dapat_dishare -gt

q_0_10

share = share+1


q_0_11

atomic

dapat_dishare -gt

q_0_20


q_0_21

od

proctype B()


do

atomic

z -gt

y = 11

atomic

dapat_dishare -gt

q_0_20

share = share-1


q_0_21

atomic

dapat_dishare -gt

q_0_10


q_0_11

od

init

atomic

run A()

run B()

1 b Semaphore



define state mtype

bool Fail = false


proctype USER_0()


do

atomic


if

user_state = idle

user_state = masuk

fi

atomic



semaphore = true

atomic


user_state = masuk

atomic


if


user_state = keluar

fi

atomic


user_state = idle

semaphore = false

od

proctype USER_1()


do

atomic


if

user_state = idle

user_state = masuk

fi

atomic



semaphore = true

atomic


user_state = masuk

atomic


if


user_state = keluar

fi

atomic


user_state = idle

semaphore = false

od

init

atomic

run USER_0()

run USER_1()

1 3 SINKRONISASI

























Kesimpulan

Konkurensi











Mutual Exclusion























2 Semaphore

Sinkronisasi















DAFTAR PUSTAKA













shared data




repeat

choosing[i]=true


choosing[i]=false

for j= 0 to n-1

do begin


while number[j] 0


end

critical section

number[i]=0

remainder section

until false

Algoritma Dekker





bool Fail = false

int share = 6

int x = 0

int y = 0

bool z = true



proctype A()


do

atomic

z -gt

x = 10

atomic

dapat_dishare -gt

q_0_10

share = share+1


q_0_11

atomic

dapat_dishare -gt

q_0_20


q_0_21

od

proctype B()


do

atomic

z -gt

y = 11

atomic

dapat_dishare -gt

q_0_20

share = share-1


q_0_21

atomic

dapat_dishare -gt

q_0_10


q_0_11

od

init

atomic

run A()

run B()

1 b Semaphore



define state mtype

bool Fail = false


proctype USER_0()


do

atomic


if

user_state = idle

user_state = masuk

fi

atomic



semaphore = true

atomic


user_state = masuk

atomic


if


user_state = keluar

fi

atomic


user_state = idle

semaphore = false

od

proctype USER_1()


do

atomic


if

user_state = idle

user_state = masuk

fi

atomic



semaphore = true

atomic


user_state = masuk

atomic


if


user_state = keluar

fi

atomic


user_state = idle

semaphore = false

od

init

atomic

run USER_0()

run USER_1()

1 3 SINKRONISASI

























Kesimpulan

Konkurensi











Mutual Exclusion























2 Semaphore

Sinkronisasi















DAFTAR PUSTAKA















bool Fail = false

int share = 6

int x = 0

int y = 0

bool z = true



proctype A()


do

atomic

z -gt

x = 10

atomic

dapat_dishare -gt

q_0_10

share = share+1


q_0_11

atomic

dapat_dishare -gt

q_0_20


q_0_21

od

proctype B()


do

atomic

z -gt

y = 11

atomic

dapat_dishare -gt

q_0_20

share = share-1


q_0_21

atomic

dapat_dishare -gt

q_0_10


q_0_11

od

init

atomic

run A()

run B()

1 b Semaphore



define state mtype

bool Fail = false


proctype USER_0()


do

atomic


if

user_state = idle

user_state = masuk

fi

atomic



semaphore = true

atomic


user_state = masuk

atomic


if


user_state = keluar

fi

atomic


user_state = idle

semaphore = false

od

proctype USER_1()


do

atomic


if

user_state = idle

user_state = masuk

fi

atomic



semaphore = true

atomic


user_state = masuk

atomic


if


user_state = keluar

fi

atomic


user_state = idle

semaphore = false

od

init

atomic

run USER_0()

run USER_1()

1 3 SINKRONISASI

























Kesimpulan

Konkurensi











Mutual Exclusion























2 Semaphore

Sinkronisasi















DAFTAR PUSTAKA












q_0_11

atomic

dapat_dishare -gt

q_0_20


q_0_21

od

proctype B()


do

atomic

z -gt

y = 11

atomic

dapat_dishare -gt

q_0_20

share = share-1


q_0_21

atomic

dapat_dishare -gt

q_0_10


q_0_11

od

init

atomic

run A()

run B()

1 b Semaphore



define state mtype

bool Fail = false


proctype USER_0()


do

atomic


if

user_state = idle

user_state = masuk

fi

atomic



semaphore = true

atomic


user_state = masuk

atomic


if


user_state = keluar

fi

atomic


user_state = idle

semaphore = false

od

proctype USER_1()


do

atomic


if

user_state = idle

user_state = masuk

fi

atomic



semaphore = true

atomic


user_state = masuk

atomic


if


user_state = keluar

fi

atomic


user_state = idle

semaphore = false

od

init

atomic

run USER_0()

run USER_1()

1 3 SINKRONISASI

























Kesimpulan

Konkurensi











Mutual Exclusion























2 Semaphore

Sinkronisasi















DAFTAR PUSTAKA












atomic

dapat_dishare -gt

q_0_10


q_0_11

od

init

atomic

run A()

run B()

1 b Semaphore



define state mtype

bool Fail = false


proctype USER_0()


do

atomic


if

user_state = idle

user_state = masuk

fi

atomic



semaphore = true

atomic


user_state = masuk

atomic


if


user_state = keluar

fi

atomic


user_state = idle

semaphore = false

od

proctype USER_1()


do

atomic


if

user_state = idle

user_state = masuk

fi

atomic



semaphore = true

atomic


user_state = masuk

atomic


if


user_state = keluar

fi

atomic


user_state = idle

semaphore = false

od

init

atomic

run USER_0()

run USER_1()

1 3 SINKRONISASI

























Kesimpulan

Konkurensi











Mutual Exclusion























2 Semaphore

Sinkronisasi















DAFTAR PUSTAKA












do

atomic


if

user_state = idle

user_state = masuk

fi

atomic



semaphore = true

atomic


user_state = masuk

atomic


if


user_state = keluar

fi

atomic


user_state = idle

semaphore = false

od

proctype USER_1()


do

atomic


if

user_state = idle

user_state = masuk

fi

atomic



semaphore = true

atomic


user_state = masuk

atomic


if


user_state = keluar

fi

atomic


user_state = idle

semaphore = false

od

init

atomic

run USER_0()

run USER_1()

1 3 SINKRONISASI

























Kesimpulan

Konkurensi











Mutual Exclusion























2 Semaphore

Sinkronisasi















DAFTAR PUSTAKA












atomic


user_state = idle

semaphore = false

od

proctype USER_1()


do

atomic


if

user_state = idle

user_state = masuk

fi

atomic



semaphore = true

atomic


user_state = masuk

atomic


if


user_state = keluar

fi

atomic


user_state = idle

semaphore = false

od

init

atomic

run USER_0()

run USER_1()

1 3 SINKRONISASI

























Kesimpulan

Konkurensi











Mutual Exclusion























2 Semaphore

Sinkronisasi















DAFTAR PUSTAKA












atomic


user_state = masuk

atomic


if


user_state = keluar

fi

atomic


user_state = idle

semaphore = false

od

init

atomic

run USER_0()

run USER_1()

1 3 SINKRONISASI

























Kesimpulan

Konkurensi











Mutual Exclusion























2 Semaphore

Sinkronisasi















DAFTAR PUSTAKA












1 3 SINKRONISASI

























Kesimpulan

Konkurensi











Mutual Exclusion























2 Semaphore

Sinkronisasi















DAFTAR PUSTAKA



























Kesimpulan

Konkurensi











Mutual Exclusion























2 Semaphore

Sinkronisasi















DAFTAR PUSTAKA



















Mutual Exclusion























2 Semaphore

Sinkronisasi















DAFTAR PUSTAKA

























2 Semaphore

Sinkronisasi















DAFTAR PUSTAKA

























DAFTAR PUSTAKA












flamboyanes.files.wordpress.com file · web viewproses-proses yang mengalami kongkuren dapat...

Documents