Session 7 and Session 8 - Concurrency

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 :

send
receive

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