Materi Praktikum Konkurensi

(1)

PRAKTIKUM

TOPIK KONKURENSI

(sebagai persiapan matakuliah Pemrograman Embedded)

Program Studi Teknik Elektro Unsoed

(2)

Daftar Isi

I

Memakai C++ Builder...1

I.1 Pengantar...1

I.2 Dasar Penggunaan C++ Builder...1

II

TASK...2

II.1

Task1...2

II.1.1 Tujuan...2

II.1.2 Deskripsi...2

II.1.3 Kode Sumber...2

II.1.4 AntarMuka dan Status Task Program DriverTask1...4

II.1.5 Pengamatan dan Kesimpulan...4

II.2

Task2...5

II.2.1 Tujuan...5

II.3

Task3...8

II.3.1 Tujuan...8

II.4

Task4...12

II.4.1 Tujuan...12

II.4.4 AntarMuka dan Status Task Program DriverTask4...14

II.5

Task5...15

II.5.1 Tujuan...15

II.6

Task6...19

II.6.1 Tujuan...19

II.7

Task7...20

II.7.1 Tujuan...20

III TUGAS AKHIR...21

III.1

Deskripsi...21

(3)

I

Memakai C++ Builder

I.1

Pengantar

Borland C++Builder adalah sebuah software pengembangan yang menganut paradigma

object-oriented

tidak murni (masih ada campuran dengan paradigma prosedural, Contoh OOL murni yaitu Smalltalk &

Eiffel), dengan lingkungan pemrograman visual untuk pengembangan aplikasi yang cepat dalam sistem

operasi Microsoft Windows 95, 98, NT. Aplikasi yang dibangun menggunakan C++Builder, akan lebih

efektif ,

coding

yang minimum.

Cara yang terbaik agar

familiar

dengan C++ Builder adalah cobalah untuk memulainya. Cara

menjalankan C++ Builder adalah sama dengan memulai aplikasi-aplikasi dalam platform Windows, yaitu

sebagai berikut :



Double-click icon C++Builder, jika sudah tersedia. Jika tidak ada icon maka Double-click file

BCB.EXE yang berlokasi di dalam \Program Files\Borland\CBuilder\Bin ( standar instalation).



Dan seterusnya………..

I.2

Dasar Penggunaan C++ Builder

Salah satu karakteristik sistem real-time adalah adanya proses – proses yang berjalan secara bersamaan

yang berusaha untuk mengakses suatu

resource

pada suatu saat, disebut sebagai proses konkuren. Dalam

C++ Builder ada sebuah kelas

TThread

(dalam vcl\class.hpp) yang dapat dimanfaatkan untuk menciptakan

suatu objek proses atau task dengan atribut dan method standar (lihat Source Kelas TThread). Pada suatu

program, dapat diciptakan beberapa Task yang mempunyai fungsi atau tugas masing-masing. Oleh karena

itu, untuk pembelajaran matakuliah Real-Time Programming digunakan C++ Builder (dengan catatan aspek

waktu diabaikan, hanya mempelajari aspek konkurensi).

/* Source Kelas TThread */

class __declspec(delphiclass) TThread;

class __declspec(pascalimplementation) TThread : public System::TObject { typedef System::TObject inherited;

private:

int FHandle; int FThreadID; bool FTerminated; bool FSuspended;

bool FMainThreadWaiting; bool FFreeOnTerminate; bool FFinished; int FReturnValue;

TNotifyEvent FOnTerminate; TThreadMethod FMethod;

System::TObject* FsynchronizeException; void __fastcall CallOnTerminate(void); TThreadPriority __fastcall GetPriority(void); void __fastcall SetPriority(TThreadPriority Value); void __fastcall SetSuspended(bool Value);

protected:

virtual void __fastcall DoTerminate(void); virtual void __fastcall Execute(void) = 0;

void __fastcall Synchronize(TThreadMethod Method);

__property int ReturnValue = {read=FReturnValue, write=FReturnValue, nodefault}; __property bool Terminated = {read=FTerminated, nodefault};

public:

__fastcall TThread(bool CreateSuspended); __fastcall virtual ~TThread(void); void __fastcall Resume(void); void __fastcall Suspend(void); void __fastcall Terminate(void); int __fastcall WaitFor(void);

__property bool FreeOnTerminate = {read=FFreeOnTerminate, write=FFreeOnTerminate, nodefault};

__property int Handle = {read=FHandle, nodefault};

__property TThreadPriority Priority = {read=GetPriority, write=SetPriority, nodefault};

__property bool Suspended = {read=FSuspended, write=SetSuspended, nodefault}; __property int ThreadID = {read=FThreadID, nodefault};

(4)

II

TASK

II.1

Task1

II.1.1

Tujuan



Memahami pembuatan dan penghapusan task.

II.1.2

Deskripsi

Task merupakan suatu objek yang memiliki kemampuan eksekusi. C++ Builder mengijinkan adanya

banyak TASK sekaligus berjalan secara pseudo konkuren (multitasking). Main program merupakan task

awal yang dijalankan pertama kali.

Pada program ini diperlihatkan terciptanya sebuah task awal kemudian task awal menciptakan task

anak. Hidup task anak tergantung kepada task parent ( task anak bisa bunuh diri).

II.1.3

Kode Sumber

//---// File : Task1.h

/* Deskripsi : Prototipe Task Child1 dan Task Awal Dibuat oleh : Acep Taryana, Updated : November 2000 */ #ifndef TASK1H

#define TASK1H

//---#include <vcl\Classes.hpp>

#include <vcl\Controls.hpp> #include <vcl\StdCtrls.hpp> #include <vcl\Forms.hpp> #include <vcl\ExtCtrls.hpp>

/* Konstruktor dari Task Child1, parameter kelas adalah THuruf bertipe Char */ class Child1 : public TThread

{

public :

__fastcall Child1(char THuruf); private :

char Huruf;

void __fastcall Execute();

/* IS : Task Child1 sudah di Create dan siap untuk dieksekusi */

/* Proses : Task Child1 menuliskan huruf dari 'A' .. '-' secara berulang2 */ /* FS : Task Child1 berhenti menulis karena Terminated */

void __fastcall TulisComboBox();

/* IS : Memo berisi tulisan sembarang */

/* FS : Huruf tertuliskan di suatu baris Current */ };

//---class TFormTask1 : public TForm

{

__published: // IDE-managed Components TMemo *Tulisan;

TTimer *Timer1;

void __fastcall AktifkanTask1Click(TObject *Sender); void __fastcall FormCreate(TObject *Sender);

void __fastcall Timer1Timer(TObject *Sender); private: // User declarations

Child1 *ObjectChild1;

public: // User declarations

__fastcall TFormTask1(TComponent* Owner); };

//---extern TFormTask1 *FormTask1;

(5)

//---#include <vcl\vcl.h>

#pragma hdrstop

#include "TASK1.h"

//---/* File : Task1.cpp

Deskripsi :

WinMain() di DriverTask1.cpp = merupakan main program yang berfungsi sebagai Task Awal. Task Awal diciptakan pertama kali dan akan menciptakan Task Child1. Task Awal akan mati setelah waktu tertentu dari Timer. Interval = 1000 ( 1 detik). Jadi jika Interval = 60000 (1 Menit).

Child1() = Task anak1, diciptakan oleh WinMain() dan berperilaku mencetak karakter 'A'..'-' berulang-ulang ke komponen Memo di FormTask1. Umur hidup Child1 ditentukan oleh Task Awal sebagai main program.

Dibuat oleh : Acep Taryana, Updated : November 2000 */ #pragma resource "*.dfm"

TFormTask1 *FormTask1;

int Counter; /* Hitung jumlah karakter */

//---__fastcall TFormTask1::TFormTask1(TComponent* Owner)

: TForm(Owner)

{ /* Merupakan Konstruktor dari TFormTask1, Class TFormTask1 dicreate oleh DriverTask1 secara otomatis pada saat program dijalankan */

}

__fastcall Child1::Child1(char THuruf): TThread(True) /* Task Child1 diCreate, langsung disuspended */ {

FreeOnTerminate = TRUE; Huruf = THuruf;

Resume(); /* Mengaktifkan Task Child1 yang tersuspended, dengan otomatis akan menjalankan Execute() */

}

void __fastcall Child1::Execute() {

Counter=0;

while ( !Terminated) {

TulisComboBox(); Huruf=Huruf + 1;

Sleep(800); /* Tidur 800 mili detik */ Counter++;

} }

void __fastcall Child1::TulisComboBox() {

if ( Counter > 30 )

{ Huruf ='A'; Counter=0; FormTask1->Tulisan->Lines->Clear();} FormTask1->Tulisan->Lines->Add(Huruf);

}

//---void __fastcall TFormTask1::AktifkanTask1Click(TObject *Sender)

{

ObjectChild1 = new Child1('A'); }

//---void __fastcall TFormTask1::FormCreate(TObject *Sender)

{

ObjectChild1 = new Child1('A'); }

//---void __fastcall TFormTask1::Timer1Timer(TObject *Sender)

{

ObjectChild1->Terminate(); FormTask1->Close();

}

(6)

#pragma hdrstop

//---/* File : DriverTask1.cpp */

/* Deskripsi : Merupakan Program Utama

Dibuat oleh : Acep Taryana, Updated : November 2000 */ USEFORM("TASK1.cpp", FormTask1);

USERES("DRIVERTASK1.res");

//---WINAPI WinMain(HINSTANCE, HINSTANCE, LPSTR, int)

{

try {

Application->Initialize();

Application->CreateForm(__classid(TFormTask1), &FormTask1); Application->Run();

}

catch (Exception &exception) {

Application->ShowException(&exception); }

return 0; }

//---II.1.4

AntarMuka dan Status Task Program DriverTask1

[image:6.595.87.466.62.306.2]

Gambar II.2 merupakan antarmuka program saat dieksekusi, sedangkan Gambar II.1 merupakan

keterangan dari setiap Task yang hidup pada saat eksekusi. Untuk memunculkan status thread pada saat

eksekusi, pilihlah menu View|Threads. Gambar II.2 menjelaskan, ada 2 buah task yang sedang berjalan

dengan State adalah Runnable.

Gambar II.1. Status Thread Saat Eksekusi

Gambar II.2. AntarMuka Program DriverTask1

[image:6.595.183.461.375.603.2]

(7)

II.2

Task2

II.2.1

Tujuan



Memahami pembuatan task anak oleh task awal lebih dari satu.



Memahami penghapusan task anak.

II.2.2

Deskripsi

Task awal menciptakan task anak1 dan task anak2, posisi task anak adalah sejajar baik dalam

penciptaan maupun saat eksekusi task.

Pada program ini diperlihatkan terciptanya sebuah task awal kemudian task awal menciptakan task

anak1 dan anak2. Task anak1 akan bunuh diri setelah CounterChild1 > 30, sedangkan hidup task anak2

tergantung kepada task parent (setelah mencapai batas waktu Timer).

II.2.3

Kode Sumber

//---#ifndef task2H

#define task2H

{

public :

char Huruf;

int CounterChild1;

{

public :

char Huruf;

int CounterChild2;

/* IS : Task Child2 sudah di Create dan siap untuk dieksekusi */ /* Proses : Task Child2 menuliskan huruf '.' secara berulang2 */ /* FS : Task Child2 berhenti menulis karena Terminated */

{

__published: // IDE-managed Components TMemo *Tulisan;

TTimer *Timer1;

void __fastcall FormCreate(TObject *Sender); void __fastcall Timer1Timer(TObject *Sender); private: // User declarations

Child1 *ObjectChild1; Child2 *ObjectChild2;

(8)

__fastcall TFormTask2(TComponent* Owner);

};

//---#endif

#pragma hdrstop

#include "TASK2.h"

Deskripsi :

WinMain() di DriverTask2.cpp = merupakan main program yang berfungsi sebagai Task Awal. Task Awal diciptakan pertama kali dan akan menciptakan Task Child1 dan Child2. Task Awal akan mati setelah waktu tertentu dari Timer. Interval = 1000, berarti 1 detik.

Child1() = Task anak1, diciptakan oleh WinMain() dan berperilaku mencetak karakter 'A'..'-' berulang-ulang ke komponen Memo di FormTask2. Umur hidup Child1 ditentukan oleh dirinya sendiri (bunuh diri). Child2() = Task anak2, diciptakan oleh WinMain() dan berperilaku mencetak karakter '.’ berulang-ulang ke komponen Memo di FormTask2. Umur hidup Child2 ditentukan oleh Task Awal sebagai main program.

: TForm(Owner)

}

CounterChild1=0;

}

CounterChild1=0; while ( !Terminated) {

Sleep(800); /* Tidur 800 mili detik */ CounterChild1++;

} }

if ( CounterChild1 > 30 )

{ Huruf ='A'; CounterChild1=0; FormTask2->Tulisan->Lines->Clear(); Terminate();

}

(9)

}

TulisComboBox();

} }

{ CounterChild2=0; FormTask2->Tulisan->Lines->Clear(); }

FormTask2->Tulisan->Lines->Add(Huruf); }

{

ObjectChild1 = new Child1('A'); ObjectChild2 = new Child2('.'); }

{

}

//---II.2.4

AntarMuka dan Status Task Program DriverTask2

AntarMuka dari program hampir sama dengan program DriverTask1, sedangkan status thread dari

DriverTask2 , sbb :

Gambar II.1. Status Task Awal, Task Anak1, Task Anak2

(10)

II.3

Task3

II.3.1

Tujuan



Memahami pembuatan task anak oleh task anak.



Memahami penghapusan task anak yang diciptakan oleh task anak.

II.3.2

Deskripsi

Pada program ini diperlihatkan terciptanya sebuah task awal kemudian task awal menciptakan task

anak1, task anak1 menciptakan task anak2. Task anak1 akan bunuh diri setelah CounterChild1 > 30,

sedangkan hidup task anak2 tergantung kepada task parent (setelah mencapai batas waktu Timer).

II.3.3

Kode Sumber

//---#ifndef task3H

#define task3H

{

public :

char Huruf;

int CounterChild1;

{

public :

char Huruf;

int CounterChild2;

/* IS : Task Child2 sudah di Create dan siap untuk dieksekusi */ /* Proses : Task Child2 menuliskan karakter '.' secara berulang2 */ /* FS : Task Child2 berhenti menulis karena Terminated */

{

__published: // IDE-managed Components TMemo *Tulis;

TTimer *Timer1;

void __fastcall FormCreate(TObject *Sender); void __fastcall Timer1Timer(TObject *Sender); private: // User declarations

(11)

};

//---#endif

#pragma hdrstop #include "TASK3.h"

Deskripsi :

WinMain() di DriverTask3.cpp = merupakan main program yang berfungsi sebagai Task Awal. Task Awal diciptakan pertama kali dan akan menciptakan Task Child1 dan Child2. Task Awal akan mati setelah waktu tertentu dari Timer. Interval = 1000, berarti 1 detik.

Child1() = Task anak1, diciptakan oleh WinMain() dan berperilaku mencetak karakter 'A'..'-' berulang-ulang ke komponen Memo di FormTask3. Umur hidup Child1 ditentukan oleh Task Awal sebagai main program. Child2() = Task anak2, diciptakan oleh WinMain() dan berperilaku mencetak karakter 'A'..'-' berulang-ulang ke komponen Memo di FormTask3. Umur hidup Child2 ditentukan oleh Task Awal sebagai main program.

: TForm(Owner)

}

CounterChild1=0;

ObjectChild2 = new Child2('.'); /* Create task Child2 */ }

} }

{ Huruf ='A'; CounterChild1=0; FormTask3->Tulis->Lines->Clear(); Terminate();

}

FormTask3->Tulis->Lines->Add(Huruf); }

(12)

menjalankan Execute() */ }

TulisComboBox();

} }

{ CounterChild2=0; FormTask3->Tulis->Lines->Clear(); }

FormTask3->Tulis->Lines->Add(Huruf); }

{

ObjectChild1 = new Child1('A');

}

{

}

//---II.3.4

AntarMuka dan Status Task Program DriverTask3

[image:12.595.159.521.472.583.2]

AntarMuka dari program hampir sama dengan program DriverTask2, sedangkan status thread dari

DriverTask3, pada saat semua Task aktif adalah sbb :

Gambar III.1. Status Task Awal, Task Anak1, Task Anak2 aktif

Dan ketika Task Child1 bunuh diri :

[image:12.595.158.523.628.735.2]

(13)

(14)

II.4

Task4

II.4.1

Tujuan



Memahami proses resume dan suspended.



Memahami pengaturan Prioritas Task

II.4.2

Deskripsi

Suspend adalah cara menghentikan TASK sementara. Selama ter-suspend TASK tidak akan dijadwalkan

oleh sistem operasi. TASK akan kembali berjalan normal setelah resume.

Sistem operasi Windows akan meng-schedule siklus CPU untuk setiap thread berdasarkan atas skala

priority. Prioriti teridiri dari tpIdle, tpLowest, tpNormal, tpHigher, tpHighest, tpTimeCritical.

II.4.3

Kode Sumber

//---#ifndef task4H

#define task4H

/* Konstruktor dari Task Child, parameter kelas adalah THuruf bertipe Char, dan Prioritas */

class Child : public TThread {

public :

__fastcall Child(char THuruf, TThreadPriority Prio); private :

char Huruf; int CounterChild;

/* IS : Task Child sudah di Create dan siap untuk dieksekusi */

/* Proses : Task Child menuliskan huruf sesuai label TASK (Task A mencetak "A") secara berulang2 */

/* FS : Task Child berhenti menulis karena Terminated */ void __fastcall TulisComboBox();

{

__published: // IDE-managed Components TMemo *Tulis;

TTimer *Timer1; TButton *bStop;

TButton *bSuspendResume; TLabel *NoTask;

TComboBox *TComboTask;

void __fastcall FormCreate(TObject *Sender); void __fastcall Timer1Timer(TObject *Sender);

void __fastcall bStopClick(TObject *Sender);

void __fastcall bSuspendResumeClick(TObject *Sender); private: // User declarations

Child *ObjectChild[6];

__fastcall TFormTask4(TComponent* Owner); };

//---#endif

(15)

//---#include <vcl\vcl.h> #pragma hdrstop #include "task4.h"

Deskripsi :

WinMain() di DriverTask4.cpp = merupakan main program yang berfungsi sebagai Task Awal. Task Awal diciptakan pertama kali dan akan menciptakan Task Child. Task Awal akan mati setelah waktu tertentu dari

Timer. Interval = 1000, berarti 1 detik atau diBerhentikan oleh User.

Child() = Task anak, diciptakan oleh WinMain() dan berperilaku mencetak suatu karakter berulang-ulang ke komponen Memo di FormTask4. Urutan komputasi setiap Task ditentukan oleh Prioritas masing-masing TASK. Masing-masing task dapat di Suspend dan di Resume.

: TForm(Owner)

{ /* Merupakan Konstruktor dari TformTask4, Class TformTask4 dicreate oleh DriverTask3 secara otomatis pada saat program dijalankan */

}

__fastcall Child::Child(char THuruf, TThreadPriority Prio): TThread(True) /* Task Child diCreate,

langsung disuspended */ {

Priority=Prio;

Resume(); /* Mengaktifkan Task Child yang tersuspended, dengan otomatis akan menjalankan Execute() */

}

void __fastcall Child::Execute() {

while ( !Terminated) {

TulisComboBox();

Sleep(1000); /* Tidur 1000 mili detik */ }

}

void __fastcall Child::TulisComboBox() {

FormTask4->Tulis->Lines->Add(Huruf ); }

{

ObjectChild[0] = new Child('A',tpHigher); ObjectChild[1] = new Child('B',tpNormal); ObjectChild[2] = new Child('C',tpHigher); ObjectChild[3] = new Child('D',tpLower); ObjectChild[4] = new Child('E',tpLowest); ObjectChild[5] = new Child('F',tpHighest); }

{ int i;

for (i=0; i<6; i++)

ObjectChild[i]->Terminate(); delete(ObjectChild); FormTask4->Close(); } //---void __fastcall TFormTask4::bStopClick(TObject *Sender)

{ int i;

(16)

ObjectChild[i]->Terminate(); delete(ObjectChild);

FormTask4->Close(); }

//---void __fastcall TFormTask4::bSuspendResumeClick(TObject *Sender)

{

if (ObjectChild[TComboTask->ItemIndex]->Suspended) { ObjectChild[TComboTask->ItemIndex]->Resume(); bSuspendResume->Caption="Suspend"; }

else { ObjectChild[TComboTask->ItemIndex]->Suspend(); bSuspendResume->Caption="Resume"; }

}

[image:16.595.129.525.247.692.2]

//---II.4.4

AntarMuka dan Status Task Program DriverTask4

[image:16.595.216.435.429.590.2]

Gambar IV.1. Status Thread

Gambar IV.2. AntarMuka DriverTask4

(17)

II.5

Task5

II.5.1

Tujuan



Mengenal masalah yang timbul dalam sharing sumber daya.

II.5.2

Deskripsi

Jika beberapa Task yang berjalan secara konkuren akan memakai sumber daya yang sama maka dapat

terjadi tabrakan. Sumber daya yang diperebutkan biasanya : Memori global, Port masukan/keluaran untuk

device tertentu. Pada contoh ini akan diperlihatkan bagaimana beberapa task harus menuliskan string ke

console (Memo sebagai sumber daya kritis). Pada Form disediakan fasilitas untuk menggunakan Mutex

dengan menyediakan CheckBox UseCriticalSection. Jika CheckedBox tersebut diklik berarti ketika sebuah

task menulis puisi ke Console akan dilindungi dengan Mutex. Dan sebaliknya.

Potongan program yang dibungkus dengan Mutex :

void __fastcall Child::Execute() { bool UseCriticalSection; while ( !Terminated) {

UseCriticalSection=FormTask5->cUseCriticalSection->Checked; if (UseCriticalSection)

EnterCriticalSection(&CriticalSection);

TulisComboBox(Tul1); Sleep(3000);

TulisComboBox(" "); if (UseCriticalSection)

LeaveCriticalSection(&CriticalSection); }

}

II.5.3

Kode Sumber

//---#ifndef task5H

#define task5H

/* Konstruktor dari Task Child, parameter kelas adalah THuruf bertipe Char, dan Prioritas */

class Child : public TThread {

public :

__fastcall Child(char *p1, char *p2, TThreadPriority Prio); private :

char Tul1[40],Tul2[40]; int CounterChild;

/* IS : Task Child sudah di Create dan siap untuk dieksekusi */

/* Proses : Task Child menuliskan String Puisi sesuai String TASK masing-masing*/ /* FS : Task Child berhenti menulis karena Terminated */

void __fastcall TulisComboBox(char *Tul); /* IS : Memo berisi tulisan sembarang */

/* FS : Puisi tertuliskan di suatu baris Current */ };

CRITICAL_SECTION CriticalSection;

{

(18)

TTimer *Timer1; TButton *bStop;

TCheckBox *cUseCriticalSection;

void __fastcall FormCreate(TObject *Sender); void __fastcall Timer1Timer(TObject *Sender);

void __fastcall bStopClick(TObject *Sender);

private: // User declarations Child *ObjectChild[6];

__fastcall TFormTask5(TComponent* Owner);

};

//---#endif

#pragma hdrstop #include "task5.h"

Deskripsi :

WinMain() di DriverTask5.cpp = merupakan main program yang berfungsi sebagai Task Awal. Task Awal diciptakan pertama kali dan akan menciptakan 3 buah Task Child. Task Awal akan mati setelah waktu tertentu dari Timer. Interval = 1000, berarti 1 detik.

Child() = Task anak, diciptakan oleh WinMain() dan berperilaku mencetak suatu puisi berulang-ulang ke komponen Memo di FormTask4. Urutan komputasi setiap Task ditentukan oleh Prioritas masing-masing TASK. Prioritas task diset sama(Normal).

Ada sharing sumber daya (tulis ke Memo), program ini akan memperlihatkan event akses sumber daya kritis dengan dilindungi Mutex dan tanpa Mutex.

: TForm(Owner)

{ /* Merupakan Konstruktor dari TformTask5, Class TformTask5 dicreate oleh DriverTask3 secara otomatis pada saat program dijalankan */

}

__fastcall Child::Child(char *p1, char *p2, TThreadPriority Prio): TThread(True) /* Task Child diCreate,

langsung disuspended */ {

FreeOnTerminate = TRUE; strcpy(Tul1,p1); strcpy(Tul2,p2); Priority=Prio;

Resume(); /* Mengaktifkan Task Child yang tersuspended, dengan otomatis akan menjalankan Execute() */

}

EnterCriticalSection(&CriticalSection);

(19)

Sleep(3000);

LeaveCriticalSection(&CriticalSection); }

}

void __fastcall Child::TulisComboBox(char *Tul) {

FormTask5->Tulis->Lines->Add(Tul); }

{ char p1[40],p2[40];

InitializeCriticalSection(&CriticalSection); strcpy(p1,"Asam di gunung, garam di laut"); strcpy(p2,"Asem di mulut, kosong di perut"); ObjectChild[0] = new Child(p1,p2,tpNormal); strcpy(p1,"Hanyut ikut arus deras"); strcpy(p2,"Satu minggu makan beras" ); ObjectChild[1] = new Child(p1,p2,tpNormal); strcpy(p1,"Tinggal janji dalam belanga"); strcpy(p2,"Tak bersisa bea siswa") ;

ObjectChild[2] = new Child(p1,p2,tpNormal); }

{ int i;

for (i=0; i<3; i++)

FormTask5->Close();

DeleteCriticalSection(&CriticalSection); }

//---void __fastcall TFormTask5::bStopClick(TObject *Sender)

{ int i;

for (i=0; i<3; i++)

FormTask5->Close();

DeleteCriticalSection(&CriticalSection); }

[image:19.595.85.465.62.549.2]

//---II.5.4

AntarMuka dan Status Task Program DriverTask5

(20)

[image:20.595.200.420.69.233.2]

Gambar V.2. AntarMuka DriverTask5

(21)

II.6

Task6

II.6.1

Tujuan



Memahami implementasi mekanisme Lockgate.

II.6.2

Deskripsi

terjadi tabrakan. Sumber daya yang diperebutkan biasanya : Memori global, Port masukan/keluaran untuk

device tertentu. Pada contoh ini akan diperlihatkan bagaimana beberapa task harus menuliskan string ke

Mekanisme Lockgate diimplementasikan dalam C++ Builder dengan menggunakan Class

RWSTDMutex di dalam “Stdmutex.h”. Ada 2 primitif yaitu :

void acquire (); // Acquire the mutex identik dengan Lock()

void release (); // Release the mutex identik dengan Unlock()

Misal : dideklarasikan RWSTDMutex Cs, maka potongan program yang dibungkus dengan Mutex

menggunakan mekanisme Lockgate :

CS.Acquire();

TulisComboBox(" "); if (UseCriticalSection) CS.release();

} }

II.6.3

Kode Sumber

Modifikasi Method Execute() pada Kode sumber II.5.3 seperti di atas dan deklarasikan di Task6.h

yaitu RWSTDMutex CS (Artinya CS adalah objek yang menginstansiasi kelas RWSTDMutex).

II.6.4

AntarMuka dan Status Task Program DriverTask6

Sama dengan bagian II.5.4

(22)

II.7

Task7

II.7.1

Tujuan



Memahami implementasi mekanisme Semaphore.

II.7.2

Deskripsi

terjadi tabrakan. Sumber daya yang diperebutkan biasanya : Memori global, Port masukan/keluaran untuk

device tertentu. Pada contoh ini akan diperlihatkan bagaimana beberapa task harus menuliskan string ke

Mekanisme Semaphore diimplementasikan dalam C++ Builder dengan menggunakan Class Tthread di

dalam “VCL\Classes.hpp”. Ada 2 primitif yaitu :

WaitForSingleObject (CS,INFINITE); // identik dengan P(CS)

ReleaseSemaphore(CS,1,NULL); // Release the semaphore identik dengan V(CS)

Terlebih dahulu harus dideklarasikan suatu CS dimana CS=CreateSemaphore();

WaitForSingleObject(CS,INFINITE);

ReleaseSemaphore(CS,1,NULL); }

}

II.7.3

Kode Sumber

Modifikasi Method Execute() pada Kode sumber II.5.3 seperti di atas dan deklarasikan di Task.h yaitu

HANDLE CS. Tambahkan CS=CreateSemaphore(NULL,1,1,NULL) di FormCreate dari FormTask7.

II.7.4

AntarMuka dan Status Task Program DriverTask7

Sama dengan bagian II.5.4

(23)

III

TUGAS AKHIR

III.1 Deskripsi

Implementasikanlah problem III.5 (DiningPhilosophers) pada Catatan Matakuliah RTP dengan

pendekatan Seksi Kritis dan Sinkronisasi, masing –masing pendekatan diimplementasikan dengan

mekanisme Lockgate dan Semaphore(Jumlah=4 buah program). Untuk mengimplementasikannya gunakan

RT OS(iRMX, dll) atau bahasa-bahasa program yang dapat menjelaskan konkurensi (ADA, C++, C++

Builder, dll) yang dikuasai dan pilih bahasa yang menyediakan primitif yang mirip dengan mekanisme –

mekanisme dalam pemrograman klasik(Lockgate, Semaphore, dll).

III.2 Aturan dan Laporan

Yang harus dikerjakan adalah



Empat buah program



Laporan yang meliputi : Deskripsi Masalah, Analisa Masalah, Rancangan ( terdiri dari Algoritma dan

Implementasi, dalam implementasi menjelaskan primitif-primitif yang disediakan oleh RT OS atau RT

Language yang dipilih ), Listing dan AntarMuka Program. Format penulisan laporan bebas.



Tugas Akhir dibuat secara berkelompok (5 orang).



Laporan Tugas Akhir harus dikumpulkan ke TU(Pak Hafid) 2 hari sebelum pelaksanaan Presentasi.

Waktu pelaksanaan presentasi akan ditentukan kemudian.