CatatanKuliahRTP

Catatan kuliah Real-Time Programming / Jurusan Teknik Elektro Unsoed/ Acep Taryana/May-2015/ Halaman 1

I Sistem Real-Time(RT)

I.1 Definisi[2] :

Urutan komputasi ditentukan oleh lintasan waktu atau event eksternal ke komputer.

dan Hasil komputasi tergantung pada nilai dari variable waktu atau waktu yang diperlukan untuk melakukan eksekusi komputasi.

I.2 Kategori Sistem Real-Time :

Rata-rata waktu eksekusi lebih kecil dari waktu maksimum yang telah ditentukan. Ukuran waktu dinyatakan dalam interval(Soft).

Komputasi harus selesai dalam waktu maksimum tertentu pada setiap kesempatan(Hard) .

I.3 Contoh Aplikasi

Contoh aplikasi kategori pertama[2] :Sebuah ATM bank. ATM merupakan aplikasi real-time apabila

ciri-ciri di bawah ini terpenuhi :

Adanya triger atau driven dari event-event eksternal yaitu penempatan kartu ke dalam mesin yang berfungsi untuk memulai transaksi.

Unjuk kerja komputasi tergantung variabel waktu yaitu pembatasan pengambilan maksimum per hari atau per minggu.

Konstraint sistem didasarkan pada rata-rata "response time" yang tidak kritis pada setiap transaksi.

Contoh aplikasi kategori kedua[3]: Sebuah Sistem "Safe Home". Perangkat lunak SafeHome

menyediakan fasilitas bagi pemilik rumah untuk mengkonfigurasikan keamanan sistem, ketika diinstall,

monitor semua sensor terhubung ke dalam keamanan sistem dan berinteraksi dengan pemilik rumah melalui

keypad atau function key yang terdapat dalam control panel SafeHome. Selama instalasi control panel

SafeHome digunakan untuk "program" dan menkonfigurasikan sistem. Setiap sensor dinyatakan dalam

sebuah bilangan dan punya tipe, password master diprogram, nomor telepon diinputkan untuk suatu

keperluan ketika terjadi event tertentu. Misalnya SafeHome ini berfungsi untuk pengamanan rumah terhadap

terjadinya kebakaran. Pada contoh yang kedua ini, konstraint waktu sangat strict (ketat). Misal response time

antara adanya event suhu ruangan yang mencapai sekian derajat dengan action terhadap event tersebut harus

terpenuhi dalam waktu maksimum yang telah ditentukan, dalam hitungan detik. Bandingkan dengan ATM,

ketika anda memasukan kartu ATM ke dalam mesin dan mesin merespon dalam waktu kira-kira 2 jam. Apa

yang terjadi ? Untuk kasus pertama, pelanggan paling kesal. Sedangkan untuk kasus yang kedua, akan

mengakibatkan kerugian material mungkin juga kerugian jiwa.

I.4 Aplikasi RT

Aplikasi yang tidak hanya menuntut kebenaran lojik namun juga menuntut konstraint waktu. Harus

dibedakan antara aplikasi RT dan aplikasi Bisnis non RT. Pada aplikasi RT waktu merupakan kebutuhan

("Requirement") sedangkan pada aplikasi bisnis non RT konstraint waktu merupakan "Performance". Ciri

dari aplikasi yang membutuhkan kriteria waktu yang sangat ketat adalah aplikasi bersifat time critical

artinya jika tuntutan terhadap waktu tidak terpenuhi maka tujuan sistem atau fungsi tidak tercapai.

Akibatnya, :

Perlu adanya batasan waktu

Waktu harus dinyatakan secara deterministik dan eksplisit

Waktu merupakan requirement

Adanya respon time (delta waktu yang diperlukan untuk melakukan action akibat adanya event)

I.5 Karakteristik :

1. Embedded Systems RT sistem sering merupakan embedded system. Sistem RT merupakan gabungan komponen Soft dan

Hard. Contoh : Pengontrol robot, merupakan komponen dari sistem robot yang terdiri dari mekanik lengan,

kontrol kordinat pergerakan, dan sensor sebagai antarmuka dengan lingkungan eksternal.

2. Interaksi dengan lingkungan luar


RT berinteraksi dengan lingkungan luar dengan sedikit campur tangan manusia pada saat sistem

berjalan. Contoh : Pada RT sistem untuk mengontrol proses manufaktur atau pada proses kimia yang dapat

melaporkan kondisi terjadinya alarm. Kondisi tersebut berasal dari data eksternal yang diterima melalui

antarmuka sensor.

3. Konstraint Real-Time RT system mempunyai konstraint waktu, sistem harus memproses event dalam frame waktu yang

diberikan.

4. Kontrol Real-Time RT sistem meliputi RT Control, sistem yang me-maintain kecepatan dari pergerakan pesawat luar

angkasa.

5. Sistem Reaktive Dengan adanya event driven maka sistem harus dengan cepat merespon stimuli eksternal.

6. Proses Konkuren Proses konkuren adalah proses proses yang berada pada saat yang sama dan harus berbagi sumber

daya global secara bergantian. Ketika proses berjalan, maka akan banyak event yang perlu diproses secara

pseudo paralel. Urutan kedatangan event tidak dapat diprediksi

I.6 Kekhususan RT terhadap masalah lain, melahirkan ide tentang :

1. RT constraint 2. Notion tentang waktu. 3. RT Database.

Metoda konvensional, dikenal dengan Locking

LOCK()

Proses Update/Delete/Append

UNLOCK()

Kemudian dikembangkan metoda yang lebih handal untuk menangani kecepatan akses dan untuk

memecahkan masalah konkurensi yang dikenal dengan exclusive-writer protokol.

4. RT Operating sistem. Sebuah OS harus menyediakan mekanisme penjadwalan priority. RT OS selain menyediakan

mekanisme priority juga harus menyediakan mekanisme untuk menginterupsi sebuah high-priority,

Interrupt Latency, Menyediakan multitasking.

5. RT Programming Language Beberapa bahasa yang digunakan untuk tujuan umum banyak digunakan untuk keperluan

pemgrograman RT (Contoh C, Fortran, Modula-2). Juga bahasa-bahasa yang mempunyai konsep Class

seperti ADA, C++ sering dingunakan dalam aplikasi dalam bidang militer dan komunikasi. RT language

mempunyai kemampuan multitasking, mengkonstruksi secara langsung untuk mengimplementasikan fungsi

RT, dan feature-feature pemrogramam modern.

I.7 Miskonsepsi :

Tidak melibatkan science dalam design sistem RT.

Komputasi RT ekuivalen dengan komputasi yang cepat.

Programming RT adalah kode dalam assembly, programming interrupt priority dan penulisan peralatan driver.

Sistem RT berfungsi dalam lingkungan yang statik.

Problem dalam design sistem RT dapat dipecahkan semua dalam lingkup bidang computer science.

I.8 Kehandalan :

Kehandalan perlu dijaga atau ditingkatkan, dengan tujuan agar sistem tidak gagal, karena kegagalan

menyebabkan kefatalan. Kehandalan berkaitan dengan back up dan kestabilan. Kehandalan terbagi 2 :

Kehandalan Hardware, misal dengan menyiapkan cadangan peralatan.

dan Kehandalan Software, harus dipenuhinya siklus hidup Perangkat Lunak dalam Software Engineering dari awal sampai akhir dengan benar yang meliputi : definisi requirement, design,

implementasi dan testing. Engineering merupakan usaha untuk meningkatkan kehandalan agar

mendekati 100% kesempurnaan. Selain itu, juga dapat dibuktikan secara matematis atau statistik.


I.9 Performance sistem RT:

Ditentukan oleh response time dan tingkat transfer data. Response time adalah waktu yang diperlukan

oleh sistem untuk mendeteksi event dan melakukan aksi. Parameter kunci yang mempengaruhi respon time

adalah context switching dan interrupt latency. Context switching meliputi waktu dan overhead untuk

mengalihkan task-task dari suatu keadaan ke keadaan lain. Interrupt letency adalah toleransi waktu

keterlambatan sebelum switch terjadi. Parameter lain adalah kecepatan komputasi dan kecepatan akses

media penyimpanan.

I.10 Interrupt Handling :

Salah satu ciri sistem RT adalah adanya interaksi dengan lingkungan luar. Berarti adanya stimulus-

interrupt dalam batasan waktu tertentu. Karena multiple stimulus sering terjadi maka perlu dipikirkan

tentang Priority dan Interrupt priority, kaitannya dengan bagaimana pengaturan aksi-aksi setelah terjadi

stimulus. Interrupt handling merupakan penanganan ketika terjadi aliran proses normal yang diinterupsi

oleh event yang terdeteksi oleh hardware.


II Konsep Pemrograman Real-Time

Prasyarat : Sebaiknya telah memahami tentang pengertian Proses, keadaan proses

(new, running, blocked, exit), perpindahan keadan proses, eksekusi proses,

berjalannya instruksi dalam proses (atomik atau primitif), deadlock, starvation,

multiprocessing.

Salah satu karakteristik sistem real-time adalah adanya proses yang berjalan secara konkuren, dengan

processor yang terbatas. Untuk berebut processor task-task tersebut diatur oleh scheduler. Konkurensi

merupakan landasan bagi tiga tema pokok yaitu multiprogramming, multiprocessing dan distributed

processing, salah satu ketiga tema pokok akan terjadi dalam sistem real-time. Sejumlah proses akan disebut

konkuren jika proses-proses tersebut berada pada saat yang sama dan harus berbagi sumber daya global

secara bergantian.

Konkurensi dapat muncul pada tiga konteks yang berbeda, yaitu :

Banyak aplikasi (multiple application).

Waktu pemrosesan komputer dibagi (shared) secara dinamis diantara sejumlah job atau aplikasi yang aktif.

Aplikasi terstruktur. Aplikasi diimplementasikan sebagai sekumpulan proses yang konkuren.

Struktur sistem operasi. Sistem operasi diimplementasikan sebagai kumpulan proses.

II.1 Prinsip Konkurensi :

1. Mutex (Critical section). Mutual exclusion adalah suatu kondisi dimana ada sekumpulan proses yang konkuren, tetapi hanya satu dari proses-proses konkuren tersebut yang diperbolehkan untuk

menggunakan sumber daya yang dibutuhkannya. Mutex terjadi karena adanya sumber daya yang tidak

dapat digunakan secara bersamaan, seperti printer. Sumber daya ini disebut sumber daya kritis. Bagian

proses yang menggunakan sumber daya kritis disebut memasuki seksi kritis (critical section).

2. Sinkronisasi 3. Inter-Proses dan Komunikasi (IPC)

Ketika terjadi konkurensi, maka proses proses akan saling bersaing atau berkompetisi untuk mendapatkan sumber daya

II.2 Syarat Mutual Exclusion

Algoritma harus menjamin bahwa hanya ada satu proses yang ada di seksi kritis.

Proses yang ada di luar seksi kritis dilarang menghambat (blocked) proses lain yang akan masuk seksi kritis.

Proses yang ingin masuk seksi kritis harus dijamin tidak menunggu selama waktu yang tidak terhingga (proses tidak mengalami deadlock atau starvation).

Ketika tidak ada proses di seksi kritis, proses yang akan masuk seksi kritis harus diijinkan tanpa waktu tunda

Tidak ada asumsi mengenai kecepatan relatif proses atau jumlah proses yang ada.

Proses berada di seksi kritis hanya selama waktu yang berhingga.

II.3 Konsep Pemrograman

II.3.1 Pengertian :

Pembuatan program yang disusun sedemikian rupa sehingga tercipta banyak proses yang berjalan secara

bersama-sama pada suatu saat yang memungkinkan terjadinya shared variabel global, shared sumber daya

global, komunikasi antar proses tersebut melalui pengiriman pesan (message passing) dan sinkronisasi antar

proses.

II.3.2 Ciri Program

Adanya event-driven.

Banyak proses yang berjalan secara bersama-sama.

Ada mekanisme pengaturan blocking proses melalui pendekatan : seksi kritis (mutex) dan sinkronisasi.


II.4 Syarat Program

Hanya ada satu proses yang berada pada seksi kritis pada satu saat.

Memenuhi kebenaran sekuensial dan logika temporal.

Proses tidak mengalami starvation.

Proses tidak mengalami deadlock.

Tidak terjadi Bussy waiting.

Solusi proses yang simetrik untuk menjamin serializibility. Dengan cara ini eksekusi instruksi seolah-olah berada pada pemrograman dengan logika sekuensial.

II.5 Tahapan Pembuatan Program

1. Cari titik observasi, yaitu titik pengamatan terhadap aksi dalam proses sebelum memasuki seksi kritis dan setelah keluar dari seksi kritis (Gambar II.1).

2. Apakah ada syarat untuk melewati titik observasi tersebut? Jika ada maka jadikan titik observasi sebagai titik sinkronisasi.

3. Tetapkan syarat formal untuk melewati titik tersebut. 4. Buatlah program konkuren yang memenuhi kebenaran logika sekuensial dan temporal.

Gambar II.1. Titik observasi pada Critical Section.

II.6 Hipotesa Pemrograman

Tidak ada asumsi yang dapat digunakan pada saat pelaksanaan eksekusi suatu proses.

Semua proses harus berakhir.

II.7 Mekanisme Blocking Proses

II.7.1 Low level:

Lock gate

Semaphore

Mailbox Ada dua aksi yang harus dilakukan pada penggunaan mekanisme blocking proses low level:

1. Deklarasi 2. Mendeklarasikan mekanisme block dengan pernyataan Create atau Declare 3. Manipulasi, menggunakan primitif dari mekanisme block, yaitu instruksi-instruksi yang berkaitan

dengan mekanisme tersebut (harus instruksi yang simetris/berpasangan)

II.7.1.1 Lock Gate

II.7.1.1.1 Pengertian :

Mekanisme blocking proses yang sudah tersedia baik di bahasa pemrograman maupun sistem operasi.

Menawarkan penanganan block proses dengan fasilitas yang dipunyai.

Menggunakan variabel kerja B dengan type Boolean yang diberi harga awal False pada saat mekanisme Lock gate di Create atau di declare.

Ada antrian Q yang digunakan untuk penanganan status proses P. Sifat antrian adalah FIFO.

Primitif yang digunakan adalah Lock(name) dan Unlock(name).

Critical Section

(CS)

Titik Observasi 1 (TO1)

Titik Observasi 2 (TO2)


II.7.1.1.2 Notasi Algoritmik Primitif Lock dan Unlock

Procedure Lock(name)

Begin

if B Then

Blocked status proses P

Tempatkan proses P dalam antrian Q

B True End

Procedure Unlock(name)

Begin

B False If antrian Q not empty Then

Keluarkan proses P yang ada di Head(Q)

Aktifkan status proses P

End

II.7.1.1.3 Contoh Penggunaan Lock Gate.

II.7.1.1.3.1 Seksi Kritis

Ketika proses hendak masuk seksi kritis, proses memeriksa nilai variabel lock lebih dahulu.

Jika variabel lock bernilai False, proses mengubah variabel lock menjadi True dan masuk seksi kritis. Sebaliknya, proses diblok sampai dibebaskan (unlock) oleh proses lain yang sebelumnya berada di seksi

kritis.

Misal ada n proses konkuren yang akan masuk ke seksi kritis pada Gambar II.2. P1 P2 P3 . Pn

Secara umum : Pi

Gambar II.2. Titik observasi untuk n buah proses yang akan mengakses CS.

Tahapan :

1. Didapatkan Titik observasi 1 (TO1) dan TO2 2. Karena titik observasi sudah didapatkan, maka titik sinkronisasi didapatkan dan disebut dengan TS1,

TS2.

3. Syarat untuk melewati CS : TS1 terjadi sebelum TS2. Secara formal dapat ditulis sebagai berikut : TS1(CS) < TS2(CS)

4. Buat program konkuren.

CS CS CS CS

CS

TO1

TO2


Program SeksiKritis

{ Pada saat Create Lockgate(CS), secara otomatis akan menginisialisasi

var B bernilai false. Pada program utama diciptakan proses-proses,

setiap proses akan masuk ke seksi kritis dengan terlebih dahulu lakukan

lock dan setelahnya unlock. Ketika proses berada dalam CS maka proses

lain tidak boleh masuk ke CS dengan cara di blok(antri di antrian Q

yang telah didefinisikan).}

Procedure Proses(Var i : integer)

Begin

Lock(CS)

Unlock(CS)

End

{ Deklarasi Global baik primitif, variabel dan konstanta }

Create Lockgate(CS)

{ program utama }

Begin

Loop

Proses(1)

Proses(2)

Proses(n)

Forever

End

II.7.1.1.3.2 Baca-Tulis

Cerminan paling sederhana dari komunikasi antar proses.

Ada dua proses yang konkuren, yaitu Baca dan Tulis. Proses Baca(P1) akan membaca data dari M (memory atau secondary storage) dan proses tersebut adalah benar nilai ditulis oleh Proses Tulis(P2) di

M.

Proses baca akan dilakukan setelah proses tulis selesai.

Pencarian solusi :

1. Cari titik observasi. P1 P2

Gambar II.3. Pencarian titik observasi pada 2 proses (baca dan tulis).

2. Adakah syarat untuk melewati TO.

TO1 : bukan TO, hilangkan karena tidak penting.

TO2 : merupakan tanda untuk melaksanakan TO3, oleh karena itu penting.

TO3 : penting.

TO4 : tidak penting.

Sehingga titik observasinya adalah TO2 (sekarang sebut TS1) dan TO3 ( disebut TS2)

3. Syarat formal untuk melewatinya. Akhir tulis(m) < awal baca (m)

4. Buat program konkuren.

Baca(m) Tulis(m)

TO3 (Awal

Baca)

TO2

(Akhir

tulis)

TO1

TO4(Akhir

Baca)


Program BacaTulis

{Pada saat Create Lockgate(M), secara otomatis akan menginisialisasi

var B bernilai false. Pada program utama diciptakan proses Baca, proses

Tulis. Setiap proses akan masuk ke seksi kritis (tulis(M) dan

baca(M)).}

Procedure Baca

Begin

Loop

Lock(M)

Lock(M)

forever

End

Procedure Tulis

Begin

Loop

Unlock(M)

Forever

End


Create Lockgate(M)

{ Program utama }

Begin

Baca

Tulis

End

II.7.1.2 Semaphore

II.7.1.2.1 Pengertian

Diperkenalkan oleh Edgard Dijkstra, mempunyai prinsip yang hampir sama dengan mekanisme lock.

Menggunakan variabel kerja eo dengan type integer (nilai dibebaskan kepada pengguna, dengan syarat

eo 0 ).

Ada antrian Q yang digunakan untuk penanganan status proses P.

Primitif yang digunakan adalah P(name) (atau Down atau Wait) dan V(name) (atau Up atau Signal).

Untuk mendeklarasikannya, digunakan pernyataan Create Semaphore(name, initvalue)

II.7.1.2.2 Notasi Algoritmik Primitif P dan V

Procedure P(name)

Begin

eo eo - 1 If eo < 0 Then

Blocked status proses P

Tempatkan proses P dalam antrian Q

End

Procedure V(name)

Begin

eo eo + 1 If eo



Ilustrasi persoalan dapat dilihat pada Gambar II.2.

Solusi:

Program SeksiKritis

{ Pada saat Create Semaphore(CS,1), nilai eo dinisialisasi dengan 1. Pada

program utama diciptakan proses-proses, setiap proses akan masuk ke seksi

kritis dengan terlebih dahulu lakukan P(CS) dan setelahnya V(CS). Ketika

proses berada dalam CS maka proses lain tidak boleh masuk ke CS dengan

cara di blok(antri di antrian Q yang telah didefinisikan).}

Procedure Proses(Var i : integer)

Begin

P(CS)

V(CS)

End


Create Semaphore(CS, 1)

{ program utama }

Begin

Loop

Proses(1)

Proses(2)

Proses(n)

Forever

End

Properti : Nilai awal dari semaphore sebuah proses menunjukan jumlah proses yang dapat melewati P(name) tanpa

diblok. Nilai awal 0 menunjukan bahwa proses yang melewati P(name) langsung akan terblok sedangkan nilai awal 1

menunjukan bahwa pada satu saat maksimal hanya ada satu proses yang dapat melewati P(name).


Ilustrasi persoalan dapat dilihat pada Gambar II.3. Program BacaTulis

{Pada saat Create Semaphore(M, 0), secara otomatis eo diinisialisasi

dengan nilai 0. Pada program utama diciptakan proses Baca, proses Tulis.

Setiap proses akan masuk ke seksi kritis (tulis(M) dan baca(M)).}

Procedure Baca

Begin

Loop

P(M)

forever

End

Procedure Tulis

Begin

Loop

V(M)

Forever

End


Create Semaphore(M, 0) {Merupakan private semaphore}

{ Program utama }

Begin

Baca

Tulis

End


II.7.1.3 Mailbox

II.7.1.3.1 Pengertian

Mekanisme konkuren untuk memenuhi kebutuhan IPC (Interprocess Communication) melalui pengiriman pesan secara tidak langsung (indirect message passing).

Merupakan suatu buffer of messages dari proses-proses yang saling berkomunikasi.

Skema adaptif mailbox untuk pemrograman konkuren yang ideal adalah blocking read dan blocking

write. Tetapi dalam banyak hal, implementasi yang paling sering digunakan adalah blocking read dan

unblocking write.

Secara umum message passing dengan mailbox mempunyai sepasang primitif, yaitu:

Send(mbname, message) atau Write(mbname, message) . Digunakan untuk mengirimkan pesan (message) ke tujuan tertentu (destination).

Receive(mbname, message) atau Read(mbname, message). Digunakan untuk mengambil pesan (message) dari tujuan tertentu atau dapat juga dari sumber tak ditentukan lebih dahulu (penerima

tidak peduli dengan sumber pesan).

Sebagai contoh, jika proses A akan mengirim pesan kepada proses B melalui mailbox1, maka penulisan pernyataannya:

process A;

...

send(mailbox1, message)

...

process B;

...

receive(mailbox1, message)

...

Suatu mailbox dibuat dengan pernyataan Create Mailbox(mbname, mbcapacity).

II.7.1.3.2 Contoh Penggunaan


Program SeksiKritis

{ Awalnya mailbox dikirim pesan dengan Send. Berarti jika ada proses yang

memanggil Receive maka proses tersebut akan masuk ke CS dan proses

dibelakangnya akan terblok sampai proses tersebut mengirimkan pesan lagi ke

mailbox}

Procedure Proses(Var I : integer)

Begin

Receive(CS, message)

Send(CS, message)

End

{ Deklarasi global }

. . .

message-1

message-2

message-3

. . .

Mailbox

antrian Readantrian Write

. . .


Create Mailbox(CS)

{ program utama }

Begin

Send(CS, message)

Loop

Proses(1)

Proses(2)

Proses(n)

Forever

End


Program BacaTulis

{ Proses Baca akan terblok terus menerus sampai adanya pesan di mailbox

yang dikirimkan oleh proses Tulis}

Procedure Baca

Begin

Loop

Receive(MB, message)

forever

End

Procedure Tulis

Begin

Loop

Send(MB, message)

Forever

End

{ Deklarasi global }

Create Mailbox(MB)

{ Program utama }

Begin

Baca

Tulis

End

II.7.2 High level:

Monitor

Rendezvous


III Studi Kasus Konkurensi

III.1 Seksi Kritis

Seksi kritis merupakan masalah mendasar dalam lingkungan konkurensi. Ketika proses hendak masuk

seksi kritis, proses memeriksa nilai variabel lock lebih dahulu. Jika variabel lock bernilai False, proses

mengubah variabel lock menjadi True dan masuk seksi kritis. Sebaliknya, proses diblok sampai dibebaskan

oleh proses lain yang sebelumnya berada di seksi kritis.

III.2 Baca-Tulis

Masalah baca-tulis data dari ke memory atau secondary storage merupakan cerminan paling sederhana

dari komunikasi antar proses. Ada dua proses yang konkuren, yaitu proses Baca dan Tulis. Proses Baca akan

membaca data, sementara proses Tulis akan menulis data. Jika proses Tulis sudah selesai menulis, maka

proses tersebut akan memberi tanda bahwa proses sudah selesai. Proses baca akan dilakukan setelah proses

tulis. Proses baca adalah benar jika nilai data yang dibaca oleh proses Baca adalah sama dengan nilai data

yang baru ditulis oleh proses Tulis.

III.3 Sleeping Barbershop Problem

Salon pangkas rambut mempunyai satu kursi pemangkasan dan n kursi untuk pelanggan-pelanggan

yang menunggu. Jika tidak ada pelanggan, pemangkas duduk di kursi pemangkasan dan tidur. Ketika

pelanggan datang, dia membangunkan pemangkas. Jika pelanggan-pelanggan berikutnya datang, sementara

pemangkas sedang memotong rambut pelanggan lain, pelanggan-pelanggan itu duduk di kursi tunggu (jika

masih terdapat kursi tunggu yang kosong) atau meninggalkan salon jika semua kursi tunggu telah penuh.

Gambar III.1. Sleeping Barbershop Program

III.4 Producer-Consumer

Producer (produsen) memproduksi barang kemudian diletakkan di sebuah conveyor (ban berjalan)

dengan kapasistas terbatas n atau tidak terbatas. Consumer (konsumen) akan mengambil barang yang telah

diproduksi oleh produsen melalui conveyor yang sama.

Akan muncul masalah:

Jika conveyor penuh sementara produsen masih ingin meletakkan produk pada conveyor tersebut (masalah bagi produsen). Hal ini terjadi jika asumsi kapasitas conveyor terbatas.

Jika conveyor kosong sementara konsumen ingin mengambil produk (masalah bagi konsumen). Oleh karena itu kedua proses membutuhkan sinkronisasi agar sama-sama dapat terhindar dari

permasalahan.

Tempat

Cukur

Kursi

tunggu

Pintu

in/out


Gambar III.2. Producer- Consumer Problem

III.5 Dining Philosophers Problem

Lima filsuf bertemu untuk makan malam. Mereka duduk di sekeliling meja makan yang bentuknya

bulat. Tetapi saat mereka akan makan, ada persoalan praktis yang muncul. Spaghetti yang dihidangkan

sebagai menu makan malamnya begitu ruwet dan licin, sehingga untuk memakannya diperlukan dua garpu

sekaligus. Sementara itu, meja sudah diatur sedemikian hingga hanya ada satu garpu untuk setiap filsuf.

Gambar III.3. Susunan Dining Philosophers

Aktivitas hidup setiap filsuf dianggap hanya ada dua, yaitu makan dan berpikir yang dilakukan secara

bergantian. Ketika filsuf lapar, filsuf mencoba memperoleh garpu kiri dan kanan sekaligus dengan urutan

manapun. Jika sukses memperoleh dua garpu sekaligus, filsuf makan. Kemudian bila telah selesai makan,

filsuf meletakkan kembali garpunya dan melanjutkan berpikir.

Supaya semua filsuf dapat makan secara adil, dalam arti tidak ada filsuf yang makan terus menerus atau

terus menunggu karena garpu yang dibutuhkan tidak selalu tersedia, maka diputuskan pendekatan

penyelesaian sebagai berikut:

Pada keadaan awal, semua filsuf dianggap sedang berpikir.

Jika seorang filsuf sedang makan, maka filsuf yang duduk di sebelah kiri dan kanannya tidak diperkenankan makan pada saat itu.

Banyaknya filsuf yang dapat makan pada saat yang sama adalah dua orang.

Setiap saat, setiap filsuf mempunyai salah satu dari keadaan berikut: sedang makan

mau makan, tetapi jika garpu tidak tersedia maka ia menunggu (tidur) sampai garpu di kiri dan

kanannya tersedia (dibangunkan oleh filsuf di sebelahnya yang sudah selesai makan).

sedang berpikir

Filsuf yang sedang makan berhenti makan setelah selang waktu tertentu.

PRODUCER. .

.

. .

.CONSUMER

2 3 . . . . .1 N

aliran produk


III.6 Swimming Pool

Sebuah kolam renang dianggap mempunyai kapasitas tidak terbatas, artinya berapapun banyaknya

orang yang masuk dan berenang, selalu bisa ditampung (kolam renang sangat luas). Sedangkan tempat ganti

pakaian terbatas. Setiap orang yang berenang wajib mengikuti prosedur sebagai berikut:

ambil keranjang

ganti baju

titipkan keranjang

berenang

ambil keranjang

ganti baju

kembalikan keranjang

keluar/pergi

III.7 Pembaca/Penulis (Readers/Writers)

Ada 2 (dua) kelompok proses yaitu kelompok Pembaca (Readers) dan Penulis (Writers). Keduanya

dapat mengakses suatu file dengan ketentuan:

file dapat dibaca oleh beberapa Pembaca sekaligus

tetapi jika file sedang diakses oleh Penulis, maka hanya satu Penulis yang boleh menulis pada suatu saat. Perlu diperhatikan prioritas (prioritas di pembaca, prioritas di penulis, prioritas sama)


IV Pendekatan dan Mekanisme Solusi

Ada dua pendekatan untuk mendapatkan solusi, yaitu pendekatan seksi kritis (mutex) dan sinkronisasi.

Masing-masing pendekatan bisa menggunakan mekanisme lockgate, semaphore, mailbox dan mekanisme

high level.

IV.1 Pendekatan Seksi Kritis

Focus pendekatan seksi kritis adalah bagaimana menjaga sumber daya kritis terakses oleh hanya satu

proses pada satu saat. Dining Philosophers problem merupakan suatu contoh permasalahan yang dapat

dicarikan solusinya dengan pendekatan seksi kritis dan sinkronisasi. Permasalahan ini juga merupakan salah

satu analogi yang dapat digunakan untuk menggambarkan permasalahan dasar tentang terjadinya deadlock

dan starvation. Dalam permasalahan ini dimodelkan proses-proses yang saling bekompetisi untuk

mendapatkan akses ekslusif terhadap suatu resource yang terbatas jumlahnya.

P2

G1 G2

P1 P3

G3

G0

P0 P4

G4

Gambar IV.1. Arsitektur Dining Philosophers.

Filsuf, dimisalkan P0, P1, P2, P3, dan P4 duduk di sekeliling meja makan, dan Garpu G0, G1, G2, G3,

G4. Permasalahan yang muncul sebagai berikut:

Bagaimana membuat algoritma yang mengatur agar filsuf-filsuf tersebut dapat makan bersama dengan

garpu yang terbatas; Syarat algoritma adalah: tidak boleh ada 2 filsuf yang memakai garpu yang sama pada

waktu bersamaan ( mutual exclusion).

Tahapan :

1. Cari titik observasi.

Pi

Gambar IV.2. Titik observasi Dining Philosopher dalam pendekatan Seksi Kritis

TO1 merupakan titik observasi sebelum filsuf makan. Untuk bisa makan, maka 2 garpu (garpu kiri dan

garpu kanan) harus sudah dipegang.

TO2 merupakan titik observasi setelah filsuf makan. Garpu kiri dan kanan diletakkan di atas meja.

2. TO1 dan TO2 didapatkan. 3. Tentukan syarat formal untuk melewati .

Akhir pegang Garpu kiri < Awal letakkan garpu kiri

AND Akhir pegang Garpu kanan < Awal letakkan garpu kanan.

< Makan >

TO1

TO2


Bagaimana menyatakan Garpu kiri dan kanan, untuk sejumlah 5 garpu ?

Akhir pegang (Gi) < Awal letakan (Gi)

AND

Akhir pegang(Gi +1 mod 5) < Awal letakkan(Gi + 1 mod 5)

4. Buat program konkuren

Solusi Dining Philosophers menggunakan pendekatan Seksi Kritis. Program DinSeksiKritis1

{ Solusi menggunakan pendekatan seksi kritis dengan semaphore}

Procedure PHIL( var I : integer)

Begin

Loop

P(GI)

P(GI+1 mod 5)

V(GI+1 mod 5)

V(GI)

Forever

End

{ Deklarasi global}

Create Semaphore(Gi,1) {Gi merupakan array dari index 0 s/d 4, masing-masing

elemen diset nilai 1}

{ Program utama}

Begin

PHIL(0)

PHIL(1)

PHIL(2)

PHIL(3)

PHIL(4)

End

Program DinSeksiKritis2

{ Solusi menggunakan pendekatan seksi kritis dengan Lockgate}

Procedure PHIL( var i : integer)

Begin

Loop

Lock(Gi)

Lock(Gi+1 mod 5)

Unlock(Gi+1 mod 5)

Unlock(Gi)

Forever

End

{ Deklarasi global}

Create Lockgate(Gi) {Gi merupakan array dari index 0 s/d 4, masing-masing

elemen diset nilai false}

{ Program utama}

Begin

PHIL(0)

PHIL(1)

PHIL(2)

PHIL(3)

PHIL(4)

End

4..0i


Dari 2 solusi di atas, apabila semua filsuf berebut untuk makan pada saat yang hampir bersamaan maka

akan timbul deadlock. Tunjukkan !

Untuk mengatasinya harus dijaga :

Pada satu saat hanya ada 4 orang yang berada diruang makan. Hadirkan satpam ! Program DinSeksiKritis3

{ Solusi menggunakan pendekatan seksi kritis dengan Semaphore dengan

pembatasan jumlah filsuf di ruangan}

Procedure PHIL( var i : integer)

Begin

Loop

P(Guard)

Lock(Gi)

Lock(Gi+1 mod 5)

Unlock(Gi+1 mod 5)

Unlock(Gi)

V(Guard)

Forever

End

{ Deklarasi global}

Create Semaphore(Gi,1) {Gi merupakan array dari index 0 s/d 4, masing-masing

elemen diset nilai 1}

Create Semaphore(Guard,4)

{ Program utama}

Begin

PHIL(0)

PHIL(1)

PHIL(2)

PHIL(3)

PHIL(4)

End

IV.2 Pendekatan Sinkronisasi

Dengan sinkronisasi maka jalannya proses akan diatur sehingga sesuai dengan apa yang diharapkan

oleh requirement program. Proses yang sedang berinteraksi untuk sinkronisasi akan dapat ditentukan titik

temunya. Titik temu atau titik observasi adalah satu titik yang hanya dapat dilewati kalau ke-n proses

masing-masing sudah mencapai titik pengamatan masing-masing. Titik temu ke-n proses dapat dilihat pada

Gambar IV.3

P1 P2 P3 P4 Pn

Titik temu

Secara umum :

Pi

Titik temu

Gambar IV.3. Titik temu Proses-Proses


Titik temu atau titik observasi harus ditentukan. Tujuannya untuk memenuhi requirement program.

Contoh : Ada n buah proses, dimana setiap proses dijalankan. Sebelum semua proses mencapai suatu

titik tertentu untuk satu kali jalan, proses tidak boleh melanjutkan eksekusi berikutnya.

Tahapan :

1. Cari titik observasi (yaitu titik pengamatan suatu aksi dalam proses) 2. Apakah ada syarat untuk melewatinya (kalau ada jadikan sebagai titik sinkronisasi) 3. Tetapkan syarat formal untuk melewatinya 4. Buat program konkuren yang memenuhi kebenaran logika sekuensial dan kebenaran logika temporal.

1. Titik observasi didapatkan 2. Dari contoh di atas, pernyataan terakhir merupakan suatu requirement program yang dapat ditafsirkan

sebagai berikut :

end(SP1) < begin(SP2)




end(SPn) < begin(SP4)

secara umum syaratnya adalah end(SPi) < begin(SP i+1 )

3. Langkah untuk melewati titik sinkronisasi :

)1()( SjbeginSiendji


5. Bentuk umum sinkronisasi Procedure X (var i : Integer)

Loop

P(mutex)

Counter Counter + 1 {Seksi kritis} If Counter < N then Block

V(mutex)

Unblock

P(mutex)

CounterCounter 1 {Seksi kritis} V(mutex)

Forever

{deklarasi global}

Counter : integer (init =0)

Create semaphore(mutex,1)

{main program}

begin

X(1)

X(2)

X(n)

End

Ada beberapa solusi program untuk permasalahan di atas, yaitu : Program sinkron1

{ Solusi kesatu, apabila semua proses

dijalankan, dan hampir pada saat yang

bersamaan masuk ke maka sejumlah n-1 proses

akan terblok, ketika proses yang ke-n

masuk maka proses tersebut akan

membebaskan proses ke-1 sampai dengan

ke n-1 yang terblok di antrian (Q)}

Program sinkron2

{Solusi kedua, apabila semua proses

dijalankan, dan hampir pada saat yang

bersamaan masuk ke maka sejumlah n-1 proses

akan terblok, ketika proses yang ke-n

masuk maka proses tersebut akan

membebaskan proses ke-1, proses ke-1

membebaskan proses ke-2, proses ke-2

membebaskan proses ke-3, dan

seterusnya. }

Procedure X(var i : integer)

Loop

P(mutex)

CounterCounter + 1 If Counter = N then

For I=1 to N do

V(privsem)

V(mutex)

P(privsem)

P(mutex)

CounterCounter - 1 V(mutex)

Forever

Procedure X( var i : integer)

Loop

P(mutex)

CounterCounter + 1 If Counter = N then

V(privsem)

V(mutex)

P(privsem)

V(privsem)

P(mutex)

CounterCounter - 1 V(mutex)

Forever

{deklarasi global}

Counter : integer (init =0)

Create semaphore(mutex,1)

Create semaphore(privsem,0)

{main program}

begin

X(1)

X(2)

.

X(n)

End


IV.2.1 Contoh yang paling sederhana untuk pendekatan sinkronisasi adalah Problem Producer-Consumer.

Skema algoritma Produsen dan Konsumen Problem :

1. Cari titik observasi : Hal yang menjadi pusat perhatian bagi produsen adalah ,

Perlu dihitung item yang di produce.

Ketika akan meletakkan item di conveyor, hal ini harus dijadikan titik observasi jika conveyor terbatas. Lain halnya jika conveyor tidak terbatas.

Setelah meletakan item di conveyor. Merupakan titik observasi yang menjadi tanda bagi Konsumen, mempersilahkanya untuk mengambil item dari conveyor.

Hal yang menjadi pusat perhatian bagi konsumen adalah ,

Ketika akan mengambil item. Konsumen harus menunggu sampai item ada di conveyor(konsumen terblok).

Konsumen akan dibebaskan oleh produsen setelah meletakan item di conveyor.

Lakukan pengurangan terhadap jumlah item setelah men-consume.

2. Titik sinkronisasi : Yang menjadi titik sinkronisasi adalah titik pertemuan antara produsen selesai meletakan item dengan

konsumen sebelum mengambil item dari conveyor.

3. Tetapkan syarat formal untuk melewatinya : End(TS1) < Begin(TS2) 4. Buatlah program konkuren.

Procedure Produsen

Loop

{TO1}

forever

Procedure Konsumen

Loop

{TO4}

forever

{deklarasi global }

Create semaphore (.. , .)

{main program}

Begin

Produsen

Konsumen

End

Solusi 1. Kapasitas conveyor tidak terbatas. Produsen dan konsumen tunggal Procedure Produsen

Begin

Loop

V(n)

Forever

End

Procedure Konsumen

Begin

Loop

P(n)

Forever

End

{deklarasi global }

Create semaphore (n , 0) {Private Semaphore}

{main program}

Begin

Produsen

Konsumen

End

Solusi 2. Kapasitas conveyor tidak terbatas. Produsen dan konsumen jamak. Karena produsen dan konsumen jamak maka akses ke konveyor perlu dibungkus dengan mutex (suatu

semaphore bernilai awal 1, sehingga hanya ada satu proses yang ada di conveyor pada satu saat). Hal ini

menyebabkan efek serializibility.

TO2 yang

menjadi TS1

TO3 yang

menjadi TS2


Procedure Produsen(var I : integer)

Begin

Loop

P(s)

V(s)

V(n)

Forever

End

Procedure Konsumen (var i : integer)

Begin

Loop

P(n)

P(s)

V(s)

Forever

End

{deklarasi global }

Create semaphore (n , 0) {Private Semaphore}

Create semaphore (s , 1) {Mutex }

{main program}

Begin

Produsen (1)

..

Produsen (n)

Konsumen(1)

..

Konsumen(m)

End

Solusi 3. Kapasitas conveyor tidak terbatas, setelah produsen memproduce item dan konsumen men-consume item, ubah ( tambah atau kurangi) variabel yang menandakan jumlah item(n). Setelah produce

item , maka counter n dinaikan 1 (n + 1) dan Consume (n-1). Konsumen akan menunggu (terblok) jika

konveyor kosong atau n=0.Dan akan dibebaskan jika n=1 ( setelah produsen mem-produce item). Procedure Produsen(var i : integer)

Begin

Loop

P(s)

n n + 1 if n=1 then V(delay)

V(s)

Forever

End

Procedure Konsumen(var i : integer)

Begin

P(delay)

Loop

P(s)

nn 1 V(s)

if n=0 then P(delay)

Forever

End

{deklarasi global }

n : integer (= 0)

Create semaphore (delay, 0) {Private Semaphore}


{main program}

Begin

Produsen (1)

..

Produsen (n)

Konsumen(1)

..

Konsumen(m)

End

Pada solusi 3, logika secara sekuensial terpenuhi namun logika temporal tidak terpenuhi. Tunjukan !!!!

Perhatikan sekenario pada simulasi ke-9, pengurangan n tidak boleh terjadi karena dari requirement

dinyatakan bahwa jika n=0 maka proses konsumen harus terblok.

Kemungkinan Skenario Program solusi 3.

Aksi n delay

1 Inisialisasi 0 0

2 Produsen : Critical section 1 1

3 Konsumen : P(delay) 1 0

4 Konsumen : Critical section 0 0

5 Producer : Critical section 1 1


6 Konsumen : if n=0 then P(delay) 1 1

7 Konsumen : Critical section 0 1

8 Konsumen : if n=0 then P(delay) 0 0

9 Konsumen : Critical section -1 0

Solusi 4. Kapasitas konveyor terbatas (e). Solusi ke-4 merupakan solusi yang lebih bersih dan lebih mewakili solusi permasalahan secara umum.

Procedure Produsen (var i : integer)

Begin

Loop

P(e)

P(s)

V(s)

V(n)

Forever

End

Procedure Konsumen(var I : integer)

Begin

Loop

P(n)

P(s)

V(s)

V(e)

Forever

End

{deklarasi global }

Const ukuran_conveyor : integer (= ....)

Create semaphore (n, 0) {Private Semaphore}


Create semaphore (e, ukuran_conveyor)

{main program}

Begin

Produsen (1)

..

Produsen (n)

Konsumen(1)

..

Konsumen(m)

End

IV.2.2 Dining- Philosophers Problem

1. Cari titik temu. Titik temu untuk setiap filsuf adalah event saat berakhirnya . Artinya semua filsuf sebelum

mencapai titik temu itu harus sudah mempunyai status , , . Proses (filsuf)

yang tidak maka harus terblok. Filsuf yang terblok akan dibebaskan oleh filsuf sebelah kanannya

atau sebelah kirinya setelah selesai .

2. Cari titik sinkronisasi 3. Syarat formalnya :

4. Program konkuren

Program DinSinkronisasi

{ Solusi menggunakan pendekatan sinkronisasi dengan semaphore}

Procedure PHIL( var I : integer)

Begin

Loop

{sebelum makan}

P(mutex)

if Si-1 != makan && Si+1 != makan then

Si = makan V(Privi)

Else

Si = mau makan

V(mutex)

P(Privi)

{setelah makan}

)1()( SjbeginSiendji


P(mutex)

if Si-1 = mau makan && SI-2 != makan then

V(PrivI-1)

If SI+1 = mau makan && SI+2 != makan then

V(PrivI+1)

V(mutex)

Forever

End

{ Deklarasi global}

Create Semaphore(Mutex,1)

Create Semaphore(Privi,0) {Privi merupakan array dari index 0 s/d 4}

Status = (mikir,maumakan,makan)

Si = array[0..4] of Status

{ Program utama}

Begin

PHIL(0)

PHIL(1)

PHIL(2)

PHIL(3)

PHIL(4)

End


V Implementasi

Salah satu contoh implementasi mekanisme yang ada adalah sebagai berikut :

No. Mekanisme Implementasi

IRMX C++ Builder

1 Semaphore:

P(X) , V(X)

Memanfaatkan semaphore :

rq_receive_units() dan rq_send_units()

Memanfaatkan class Thread :

WaitForSingleObject(x,INFINITE)

ReleaseSemaphore(x,1,NULL)

Contoh pemanfaatan di dalam C++ builder #ifndef mthread7H

#define mthread7H

/* Nama file : mthread7.h

Deskripsi : Program untuk mensimulasikan "Problem Dining Philosopher"

Menggunakan pendekatan Seksi Kritis mekanisme Semaphore

Create By : Acep Taryana

Date : 17 Mei 2000 */

//---------------------------------------------------------------------------

#include

#include

#include

#include

#include

#include

typedef enum { Makan , MauMakan, Mikir} StatusFilsuf;

typedef enum {Used , NotUsed } StatusGarpu;

//---------------------------------------------------------------------------

class TMutexThread : public TThread

{

public :

_fastcall TMutexThread(int TheThreadNum);

/*Konstruktor TMutexThread diaktifkan ketika terjadi event FormCreate dari

Program.

fungsi Konstruktor untuk membentuk Thread masing-masing filsuf dengan

aktifitas

Konstruktorsebagai berikut :

- Mengisi variabel PhilsumNum dan GarpuNum dengan Nilai variabel

TheThreadNum

- Men-set status filsuf dan garpu ke-i (Mikir dan Not Used) Garpu ke-i

adalah

garpu disebelah kiri filsuf.

- Mengaktifkan Thread masing-masing filsuf(memanggil Execute) */

private :

int PhilsupNum, GarpuNum;

String StatusFilsuf, StatusGarpu;

void _fastcall Execute(void);

/* Initial State(I.S) : Thread filsuf sudah terbentuk

Aktifitas : Loop forever untuk setiap thread, Menjaga bahwa

hanya ada maks 4 orang filsuf yang berada di mejamakan dan Mengatur status

garpu sehingga

garpu yang sedang dipakai dijamin tidak akan diserobot oleh filsuf

lain,

mengupdate status dari setiap filsuf, mengupdate status dari setiap

garpu.

Final State(F.S) : Setiap Thread filsuf dan main terminated. */

void _fastcall UpdateStatusFilsuf(int s);

/* I.S. s berisi nilai yang menyatakan status filsuf

Aktifitas : Menseleksi nilai status filsuf, kemudian memanggil

UpdateDisplayStatusFilsuf(void)

F.S : Didapatkan status filsuf dalam bentuk string */

void _fastcall UpdateDisplayStatusFilsuf(void);


/* I.S : Status filsuf dalam bentuk string sudah ada

F.S : Dilayar tercetak status filsuf */

void _fastcall UpdateStatusGarpu(int s);

/* I.S. s berisi nilai yang menyatakan status garpu

Aktifitas : Menseleksi nilai status garpu, kemudian memanggil

UpdateDisplayStatusGarpu(void)

F.S : Didapatkan status garpu dalam bentuk string */

void _fastcall UpdateDisplayStatusGarpu(void);

/* I.S : Status garpu dalam bentuk string sudah ada

F.S : Dilayar tercetak status garpu */

};

//---------------------------------------------------------------------------

class TForm1 : public TForm

{

__published: // IDE-managed Components

TPanel *Panel1;

TLabel *Garpu1;

TLabel *Garpu2;

TLabel *Garpu3;

TLabel *Garpu4;

TLabel *Garpu5;

TCheckBox *PhilsupCB3;





TLabel *LStatus1;

TLabel *LStatus2;

TLabel *LStatus3;

TLabel *LStatus4;

TLabel *LStatus5;

void __fastcall FormCreate(TObject *Sender);

void __fastcall FormDestroy(TObject *Sender);

private: // User declarations

TMutexThread *Philsup[5];

public: // User declarations

__fastcall TForm1(TComponent* Owner);

};

//---------------------------------------------------------------------------

extern TForm1 *Form1;

//---------------------------------------------------------------------------

#endif


#include

#pragma hdrstop

#include "mthread7.h"

//---------------------------------------------------------------------------

#pragma resource "*.dfm"

TForm1 *Form1;

//---------------------------------------------------------------------------

//Variabel Global

HANDLE Garpu[5], // Semaphore Garpu

Guard; // Semaphore untuk menjaga filsuf.

// Didalam meja makan tidak boleh lebih dari 4 orang

CRITICAL_SECTION CriticalSection; // Seksi Kritis

StatusFilsuf SFilsuf[5]; // status dari setiap filsuf

StatusGarpu SGarpu[5]; // status dari setiap garpu "Used,

NotUsed"

int N=5 - 1; // jumlah filsuf yang berada di meja

makan

int Counter; // index dari filsuf

//---------------------------------------------------------------------------

__fastcall TForm1::TForm1(TComponent* Owner) : TForm(Owner)

{

}

//---------------------------------------------------------------------------

void __fastcall TForm1::FormCreate(TObject *Sender)

{ int i;

// Buat semaphore dengan jumlah maksimum 1

for (i=0; i


UpdateStatusGarpu(SGarpu[GarpuNum]);

Counter = 0; // inisialisasi filsuf

// Oject akan dibebaskan setelah terminated

FreeOnTerminate = TRUE;

// Awal eksekusi thread

Resume();

}

//---------------------------------------------------------------------------

void _fastcall TMutexThread::Execute(void)

{

// Selama thread belum berakhir

while (!Terminated)

{

// < ---------------- M I K I R ----------------->

SFilsuf[PhilsupNum] = Mikir;

SGarpu[GarpuNum] = NotUsed;

SGarpu[(GarpuNum + 1) % 5] = NotUsed;

UpdateStatusFilsuf(SFilsuf[PhilsupNum]);


// Masuk seksi kritis

EnterCriticalSection(&CriticalSection);

if (Counter == 4)

WaitForSingleObject(Guard, INFINITE); // Satpam beraksi untuk

mencegah

// filsuf kelima tidak masuk

else Counter++;

LeaveCriticalSection(&CriticalSection);

WaitForSingleObject(Garpu[GarpuNum], INFINITE);

WaitForSingleObject(Garpu[(GarpuNum+1) % 5], INFINITE);

// < ------------------- M A K A N ----------------------- >

Sleep(4000);

SFilsuf[PhilsupNum] = Makan;

SGarpu[GarpuNum] = Used; // Garpu kiri

SGarpu[(GarpuNum + 1) % 5 ] = Used; // Garpu kanan

UpdateStatusFilsuf(SFilsuf[PhilsupNum]);


UpdateStatusGarpu(SGarpu[(GarpuNum+1) % 5]);

Sleep(4000);

ReleaseSemaphore(Garpu[(GarpuNum+1) % 5],1,NULL);

ReleaseSemaphore(Garpu[GarpuNum],1,NULL);

EnterCriticalSection(&CriticalSection);

Counter--; // Filsuf meninggalkan meja makan / tidak aktif makan

LeaveCriticalSection(&CriticalSection);

ReleaseSemaphore(Guard,1,NULL); // Satpam membebaskan filsuf yang diblok

}

}

//---------------------------------------------------------------------------

void _fastcall TMutexThread::UpdateStatusFilsuf(int s)

{

switch (s)

{

case Makan :

StatusFilsuf = "Makan";

break;

case Mikir :

StatusFilsuf = "Mikir";

break;

}

Synchronize(UpdateDisplayStatusFilsuf);

}

void _fastcall TMutexThread::UpdateStatusGarpu(int s)

{

switch (s)


{

case 0 :

StatusGarpu = "Used";

break;

case 1 :

StatusGarpu = "NotUsed";

break;

}

Synchronize(UpdateDisplayStatusGarpu);

}

void _fastcall TMutexThread::UpdateDisplayStatusFilsuf(void)

{

switch (PhilsupNum)

{

case 0 :

Form1->LStatus1->Caption = StatusFilsuf;

Form1->PhilsupCB1->Checked = (SFilsuf[PhilsupNum] == Makan ? True :

False);

break;

case 1 :



False);

break;

case 2 :



False);

break;

case 3 :



False);

break;

case 4 :



False);

break;

}

}

//---------------------------------------------------------------------------

void _fastcall TMutexThread::UpdateDisplayStatusGarpu(void)

{

switch (PhilsupNum)

{

case 0 :

Form1->Garpu1->Caption = StatusGarpu;


Form1->Garpu1->Color = ( SGarpu[PhilsupNum]==NotUsed ? clWhite :

clYellow);

Form1->Garpu2->Color = ( SGarpu[(PhilsupNum + 1) % 5]==NotUsed ?

clWhite : clYellow);

break;

case 1 :




clYellow);



break;

case 2 :




clYellow);




break;

case 3 :




clYellow);



break;

case 4 :




clYellow);



break;

}

}


DAFTAR PUSTAKA

[1].Cristopher Vickery,Real-Time and Systems Programming for PCs

[2].Stuart Bennet, Real-Time Computer Control : An Introduction

[3].Roger S. Pressman, Software Engineering (A Practitioner's Approach),

Fourth Edition.

[4]. William Stallings, Operating Systems, Second Edition, Prentice Hall

International Edition, 1995

[5]. Gregory R. Andrews, Concurrent Programming, Principles and

practice.

CatatanKuliahRTP

Documents

Transcript of CatatanKuliahRTP