Ok, pertemuan kali ini adalah pertemuan yang tidak biasa, karena kita akan membahas 2 bab sekaligus >_< sungguh ini bab yg cukup memakan waktu :v
Pada sesi kali ini kita akan belajar tentang concurrency.
Concurrency ?
concurrency adalah beberapa proses yang berbeda instruksi tetapi berbagi resource yang sama.
Prosesnya saling berkomunikasi, sharing resource, saling sinkronisasi untuk prosesnya.
Tujuan Concurrency ?
- agar bisa terjadi penyampaian informasi untuk 2 proses
- agar 2 proses / lebih tidak bertabrakan
- agar bisa dilakukan sequencing sesuai kebutuhan bila terdapat dependency/ keterbergantungan
Masalah apa saja tanpa Concurrency ?
- ketika ada 2 proses yang melakukan read and write pada variable global yang sama, maka tanpa concurrency sangatlah tidak mungkin
- ketika ada proses yang lebih membutuhkan resource dari proses yang lainnya, bagaimana bisa mensuspendnya sementara agar resource dapat dipakai oleh proses paling membutuhkan.
- kesalahan saat pengcodingan karena hasil tidak terbatas / non deterministik.
Race Condition = kondisi dimana ada 2 proses / lebih yang membaca / write shared data / memory pada saat yang bersamaan. (saling berebut)
O/S Concern :
- tracking proses yang aktif
- alokasi & dealokasi Sumber Daya (waktu processor, memory, File, I/O Device)
- Proteksi data dan Sumber Daya
- Hasil Proses harus Independen / tidak bergantung pada kecepatan eksekusi dari concurrency yang lain.
Critical Region / Section = tempat shared memory diakses.
Persaingan Antar Resource
- Mutual Exclusion = sistem yang mencegahan terjadinya 2 proses mengakses Sumber Daya yang sedang dipakai pada waktu yang yang sama. (memakai Critical region).
- Hanya ada 1 program yang diijinkan saat dalam critical region
- cth : penggunaan printer untuk printing
- Deadlock = terjadi karena concurrency
- cth deadlock : P1 memakai R1 dan ingin R2 , P2 memakai R2 dan ingin R1 , karena ini P1 dan P2 saling menunggu (deadlock)
- Starvation = terjadi ketika ada resource yang sangat dibutuhkan 2 proses tetapi 1 proses sangat membutuhkan karena waktu prosesnya terbatas
- cth starvation : P1,P2,P3 ingin R1
- P1 selesai memakai R1, lanjut P2 memakai R1
- ditengah P1 butuh R1 lagi,
- Ketika P1 dapat R1, P3 bisa tidak berjalan karena tdk sempat dapat R1
Kerjasama Antar Proses :
- Sharing = write harus mutual exclusive , critical Region dipakai untuk beri integritas.
- Komunikasi = message dilewatkan, kemungkinan deadlock (karena saling menunggu), kemungkinan starvation (karena dua proses berjalan , yang proses ketiga diabaikan / menunggu message).
Mutual Exclusion dengan Busy Waiting : (untuk mencapai Mutual Exclusion)
- disabling Interrupt
- proses berjalan hingga minta layanan OS atau hingga di interrupt
- Lock variables
- variable awal di set ke 0, jika lock = 1 baru boleh masuk ke Critical region
- masalah yg di alami = Race condition.
- Strict alternation
- untuk strict restriction adalah sistem swap flag , jadi dia memakai sistem on/off untuk turnnya
- jadi P1 mendapat turn 0 lalu looping dan mendapat turn 1, lalu ketika P0 meninggalkan critical region di set turn P0 menjadi 1, maka P1 masuk ke Critical Region dan P1 mendapat turn 0 sebelum meninggalkan,
- dan begitu seterusnya, P1 akan di looping hingga mendapat turn 1 lagi sebelum ke critical region, (begitu pula untuk P0)
- Peterson's solution
- semua value di set ke 0, P0 set turn = 0 , p0 memasuki critical region.
- P1 call enter_region untuk masuk ke critical region
- P1 menunggu interested(0) = FALSE (terjadi bila P0 call leave_region)
- masalah yg terjadi :
- klo ada 2 value call enter_region di waktu yg sama, maka yg pertama kali merequest akan tertimpa oleh data yang kedua.
- kadang proses yang jalan terus, dan ketika sampai di while P0 tidak terjadi looping, tetapi langsung masuk ke critical region, dan P1 harus tetap menunggu.
- The TSL instruction
- butuh H/W yakni register
- instruksi : TSL,RX,LOCK
Kelemahan Peterson dan TSL : menggunakan busy waiting, jadi menghabiskan waiting time CPU.
sleep() = system call yang membuat proses suspended
wakeup() = system call yang membuat proses ready
Semaphore = variable khusus yang meiliki nilai integer yang berguna untuk signal
jika proses wait signal, maka suspended sampai signal sended.
wait signal dan signal tidak bisa di interrupt.
diperlukan queue untuk simpan proses yang waiting untuk semaphore.
- wait signal = -1 semaphore value
- operation signal = +1 semaphore value
Semaphore mutex = untuk menjamin 1 proses yang mengakses buffer pada satu waktu dan kevariable lain yang terlibat.
semaphore full dan empty = untuk sinkronisasi, apa akan terjadi / tidak akan terjadi.
=======
Mutex = variable yang bernilai kondisi khusus dari 2 keadaan.
berguna jika tidak butuh perhitungan semaphore
cocok dan efisien untuk :
- mengatur ME pada shared resource
- paket thread yang diimplementasikan pada user space.
Mutex_lock = tidak bisa masuk critical region
Mutex_unlock = bisa masuk critical region
Mutex dalam pthread :
Pthread_cond_init = Kreasi variabel kondisi
Pthread_cond_destroy = Menghapus variabel kondisi
Pthread_cond_wait = Block menunggu untuk signal
Pthread_cond_signal = Signal ke thread lain dan membangunkannya
Pthread_cond_broadcast = Signal multipel thread dan membangunkan semuanya
Kelemahan semaphore :
- operasi down sebelum meletakan item ke buffer
- bisa terjadi deadlock karena sistem yang berhenti / halt
- kesalahan kecil bisa berakibat system halt
Monitor = program yang mengendalikan akses data yang di share
Kegunaan :
- proteksi data dari akses nonstruktural
- mendukung sinkronisasi yang concurrent jadi jaminan mutual exclusion
- sharing struktur data
Penerapan ME pada Monitor :
- memakai binary semaphore
- monitor memonitor kondisi Critical region jadi tidak ada 2 proses yang berjalan pada saat yang sama.
- Monitor menyediakan cara mudah untuk capai ME, (diperlukan block proses)
Mutual Exclusion pada Monitor :
- hanya 1 proses yang dieksekusi pada waktu yg sama
- jika ada yg menerobos masuk maka akan di block
variable kondisi diberikan kepada monitor (proses wait) sementara.
- wait(x); //mensuspend hingga proses lain selesai
- signal(x) // menyelesaikan proses yang disupend
Perbedaan wait/signal dan sleep/wakeup
- sleep/wakeup = menidurkan dan mereadykan proses
Kekurangan Monitor :
- hanya konsep, harus mengenal banyak bahasa code
- memaksa aturan ME
- tidak mengenal semaphore
- sistem terdistribusi tidak dapat diterapkan
Kesimpulan
- Monitor untuk menghindari Race Condition
- Monitor = level yang rendah
Message Passing
- pakai 2 primitif :
- primitif = system call dari bahasa pemrograman
- jika tidak ada message yang tersedia maka receiver akan di block sampai message datang
- Berguna untuk single dan multi processor dan sistem terdistribusi
- tidak perlu sharing address
- penerima dapat memilih receive or block
- merupakan many to many
- message dikirm ke area mailbox
- blocked full jika mailbox penuh
- ada reply / feedback nahwa message diterima
- bisa sinkron dan asinkron
- bisa positif dan negatif
Mailbox = mekanisme buffer, jika penuh maka message akan ditunda sampai message kosong / dihapus.
Rendezvous = tidak ada mekanisme buffer, jika send jalan sebelum receive maka send akan di block sampai receive terjadi, jika receive duluan maka akan di block hingga send terjadi.
Isu mesage passing :
- Message Lost = hilang , maka sender terpaksa kirim ulang
- Acknowledgement = mesage diterima, acknowledgement hilang, jadi untuk bedain message yg sama maka diberikan deretan bilangan khusus
- Domains = memberi nama pada proses saat operasi,harus unik
- Authentication = cara verifikasi ke server dan enrcrypt message
- Performance = pengkopian message dari proses ke proses lebih lambat dibanding operasi semaphore, jadi ukuran message dibatasi
--------------------------------------------------------------------------------------------------------------------------
1601210682 - Anthony Kalyana
binus.ac.id
www.skyconnectiva.com
My PC Test Specs :
