LAPORAN RESMI

PRAKTIKUM SISTEM OPERASI

MODUL 3

Oleh:

Kelompok 42

Gigih Prio Nugroho 5109100002

Agus Budi Raharjo 5109100164

Asisten:

  Syifa Primastuti

5107100059

LABORATORIUM ARSITEKTUR DAN JARINGAN KOMPUTER

JURUSAN TEKNIK INFORMATIKA

FAKULTAS TEKNOLOGI INFORMASI

INSTITUT TEKNOLOGI SEPULUH NOPEMBER

2010

Soal Pendahuluan:

1. Sebutkan dan jelaskan faktor-faktor pembeda antara proses dan thread !

Factor pembeda antara proses dan thread:

Proses

Proses memiliki ruang tersendiri di memori untuk menampung proses image. Selain itu akses ke hardware (processor, memori, I/O) yang dibatasi.

- Proses adalah suatu program yang sedang di eksekusi

- State yang dimiliki antara lain :  new, ready, running, waiting,

atau terminated. Setiap proses direpresentasikan ada sistem operasi

berdasarkan proses-control-block (PCB)-nya.

- Sebuah proses, ketika sedang tidak dieksekusi, ditempatkan pada antrian yang

sama. Akses terproteksi ke prosesor, proses lain (IPC), sumber daya I/O, file

- Penjadwalan/Eksekusi mengikuti lintasan eksekusi melalui sebuah program

dan dapat digilirkan dengan eksekusi proses lainnya.

Thread

Sedangkan thread akses ke memori dan resource diakses oleh prosesnya. Thread sendiri memiliki berbagai keuntungan diantaranya waktu pembuatan yang lebih cepat, waktu pemberhentian yang lebih cepat, waktu pergantian antar thread lebih cepat bila dibandingkan proses serta komunikasi antar thread yang lebih efisien karena mereka saling berbagi memori antar thread itu sendiri.

- Thread adalah sebuah alur kontrol dari sebuah proses.

- State : Spawn (Membiakkan thread lain ) , Block (Menunggu suatu event,

maka thread akan terblokir. menyimpan user register, program counter,

stack) , Unblock (Thread akan dipindahkan ke keadaan ready ) , Finish

(Dealokasi konteks register dan stack )

- Memiliki stack eksekusi

- Beberapa thread menyimpan variabel-variabel lokal

- Semua thread menggunakan sumber daya prosesnya

- Ada tiga perbedaan tipe dari model yang berhubungan dengan user dan kernel

thread. :

Model many to one: memetakan beberapa user level thread hanya ke

satu buah kernel thread.

Model one to one: memetakan setiap user thread ke dalam satu kernel

thread. berakhir.

Model many to many: mengizinkan pengembang untuk membuat user

thread sebanyak mungkin, konkurensi tidak dapat tercapai karena hanya

satu thread yang dapat dijadualkan oleh kernel dalam satu waktu.

2. Jelaskan tentang race condition dan beri contoh studi kasusnya !

Race Condition ialah suatu kondisi dimana ketika ada dua proses atau thread yang

membaca atau menulis suatu shared memori secara bersamaan sehingga hasilnya

ditentukan oleh urutan eksekusi proses atau thread tersebut.

Contoh:

int counter = 0;

//Proses yang dilakukan oleh produsen

item nextProduced;

while (1) {

while (counter == BUFFER_SIZE) { ... do nothing ... }

buffer[in] = nextProduced;

in = (in + 1) % BUFFER_SIZE;

counter++;

}//Proses yang dilakukan oleh konsumen

item nextConsumed;

while (1) {

while (counter == 0) { ... do nothing ... }

nextConsumed = buffer[out] ;

out = (out + 1) % BUFFER_SIZE;

counter--;}

3. Jelaskan tentang deadlock dan berikan contohnya !

Deadlock merupakan suatu kondisi dimana proses tidak berjalan lagi atau pun tidak ada

komunikasi lagi antar proses. Deadlock disebabkan karena proses yang satu menunggu

sumber daya yang sedang dipegang oleh proses lain yang sedang menunggu sumber daya

yang dipegang oleh proses tersebut.

Contoh studi kasus Deadlock:

Proses A mempunyai resource X, proses B mempunyai resource Y. Kemudian kedua

proses ini dijalankan bersama, proses A memerlukan resource Y dan proses B

memerlukan resource X, tetapi kedua proses tidak akan memberikan resource yang

dimiliki sebelum proses dirinya sendiri selesai dilakukan. Sehingga akan terjadi tunggu-

menunggu.

4. Jelaskan tentang multithread dan berikan contoh pengaplikasian multithread !

Multithread adalah cara pengeksekusian yang mengizinkan beberapa alur terjadi dalam

satu proses. Multithreading atau yang lebih dikenal Thread pada suatu istilah komputer

dapat diartikan sebagai sebuah proses untuk melakukan suatu pekerjaan tertentu. Melalui

multithreading, program yang kita buat dapat mengerjakan beberapa perintah secara

bersamaan, efeknya waktu yang dibutuhkan untuk menyelesaikan semua perintah tersebut

dari awal sampai akhir menjadi lebih sedikit. Namun demikian, membuat aplikasi yang

multithreading haruslah berhati-hati, karena bila semakin banyak perintah yang dijalankan

sementara penanganan untuk multithreading ini tidak teliti maka output program dapat

terjadi kesalahan atau juga dapat terjadi deadlock. Untuk itu pada umumnya pada aplikasi

multithreading dikenal adanya istilah Unsyncronized dan Syncronized Threads.

Contoh pengaplikasian Multithread :

Adobe PageMaker, aplikasi ini merupakan aplikasi untuk merancang, menulis, dan

menghasilkan desktop publishing. Aplikasi berjalan pada shared system pada sistem

operasi OS/2. Terdiri dari 3 thread yang selalu aktif:

Service thread

Event-handling thread

Screen-redraw thread

5. Jelaskan apa yang dimaksud dengan mutex, sebutkan juga perbedaan dan persamaanya

jika dibandingkan dengan semaphore !

Mutexes (mutex locks) adalah penguncian yang diperlukan untuk menjaga konsistensi data

ketika beberapa thread dapat mengakses atau memodifikasi data pada saat yang sama, sehingga

thread-thread lain yang mencoba mengakusisi mutex akan mem-block. Pemblokiran didapatkan

dengan melakukan “spinning” atau “sleeping”

Mutex Semaphore

Dalam bahasa oracle, mutex dikenal sebagai kait (latches)

Semaphore dikenal sebagai menunggu. (wait)

Digunakan untuk mencegah dua proses dari mengeksekusi potongan kode yang sama, atau mengakses data yang sama, pada waktu yang sama.

Digunakan untuk membatasi akses ke sumber daya tunggal.

Dilepaskan hanya oleh thread yang telah diperoleh

Dilepaskan dari thread lain (atau proses) sehingga lebih cocok untuk beberapa masalah sinkronisasi

6. Jelaskan apa yang dimaksud dari :

pthread_t, pthread_mutex_t, pthread_create, pthread_detach, pthread_cancel,

pthread_mutex_lock, pthread_mutex_unlock, pthread_mutex_destroy.

pthread_t

Berfungsi untuk menyimpan thread ID.

pthread_mutex_t

mendeklarasikan variabel mutex pthread_create

Membuat suatu Thread baru dan langsung dieksekusi.Saat memanggil fungsi ini

kita harus mendefinisikan sebuah atribut objek dari thread tersebut,jika tidak

maka atributnya akan diset default.

pthread_detach

Fungsi ini digunakan untuk menunjukkan penyimpanan untuk thread yang bisa

dipakai ketika mengakhiri thread. Jika thread belum berakhir, pthread_detach ()

tidak akan mengakhiri thread. Pengaruh panggilan pthread_detach () pada target

thread yang sama tidak ditentukan.

pthread_cancel

Saat fungsi ini dipanggil, request akan dibatalkan.tetapi Thread masih

running.pemangggilan fungsi ini gagal jika ID Thread yang akan dicancel tidak

valid.

pthread_mutex_lock

Kunci mutex. Jika mutex telah dilock, maka fungsi ini akan memblok eksekusi

sampai mutex diunlock. Beberapa thread dapat sekaligus terblok oleh lock mutex,

dan hanya satu thread yang unblock (secara acak) saat mutex diunlock.

pthread_mutex_unlock

Membuka kunci mutex (unlock). Fungsi ini sebaiknya dipanggil oleh thread yang

melock mutex.

pthread_mutex_destroy

Function untuk menghapus variabel mutex.

7. Jelaskan permodelan thread dilihat dari levelnya:

a. Kernel Level

Semua manajemen thread dikerjakan oleh aplikasi Kernel tidak menyadari keberadaan thread. kernel tidak menyadari user-level thread maka semua pembuatan dan

penjadwalan thread dilakukan di user space tanpa intervensi dari kernel sehingga cepat untuk dibuat dan diatur

Jika salah satu user-level thread menjalankan blocking system call maka akan mengakibatkan seluruh proses diblok walaupun ada thread lain yang bisa jalan dalam aplikasi tersebut.

Contoh user-thread libraries adalah POSIX Pthreads, Mach C-threads, dan Solaris threads.

b. User Level

Didukung langsung oleh sistem operasi. Pembuatan, penjadwalan, dan manajeman thread dilakukan oleh kernel

pada kernel space . pengaturan thread dilakukan oleh sistem operasi maka pembuatan dan

pengaturan kernel thread lebih lambat dibandingkan user thread. thread diatur oleh kernel, sehingga jika sebuah thread menjalankan

blocking system call maka kernel bisa menjadwalkan thread lain di aplikasi untuk melakukan eksekusi

lingkungan multiprocessor , kernel bisa menjadwal thread-thread pada processor yang berbeda.

Kernel memelihara informasi konteks bagi proses & thread– Manajemen thread dilakukan oleh kernel, bukan aplikasi

Contoh sistem operasi yang mendukung kernel thread adalah Windows NT, Solaris, Digital UNIX.

c. Hybrid

mikrokernel yang memiliki kode yang tidak menunjukkan bahwa kernel tersebut adalah mikrokernel di dalam ruangan kernel-nya. Kode-kode tersebut ditaruh di dalam ruangan kernel agar dapat dieksekusi lebih cepat dibandingkan jika ditaruh di dalam ruangan user

8. Jelaskan gambar dibawah ini :

Gambar tersebut adalah gambaran tentang multithreading, ketika sebuah thread dijalankan maka dia memiliki empat kemungkinan state atau keadaan: waiting, sleeping, dead, dan blocked. Waiting adalah saat sebuah thread stand by untuk dijalankan, Sleep untuk berhenti sejenak, Dead adalah saat thread dimusnakan begitu ia selesai dijalankan, dan Blocked pada saat menunggu thread lain selesai dieksekusi

9. Salah satu masalah lain dalam lock file adalah livelock, jelaskan mengenai apa itu livelock

Livelock hampir sama seperti deadlock, tetapi state pada prosesnya secara konstan berubah menghargai  satu sama lain, tidak progressing.

Live lock adalah spesial kasus dari resource starvation, definisi umumnya hanya state yang spesifik pada proses bukan progressing.

Contohnya livelock :

ketika dua orang berpapasan di koridor yang sempit, dan masing-masing mencoba mempersilakan yang lainnya lewat dengan geser sedikit ke samping, tetapi keduanya tidak terpengaruh dari satu sisi ke satu sisi tanpa membuat progresss karena mereka melalui jalan yang sama saat waktu yang sama.

10. buat program yang menunjukan perbedaan antara pendekatan multi process dan multi threading dengan menyelesaikan problem ini:

setiap program membuat 10 proses atau 10 thread(1 program 10 thread saja atau 10 proses saja)

setiap thread ataupun proses menyelesaikan fungsi f(n), f(n)=fibonaci ke-n dimana n adalah nomor thread atau nomor proses

ulangi (buat program lain) yang membuat 50, dan 100 thread atau proses;maksudnya buat:

1 program yang membuat 50 thread

1 program yang membuat 50 proses

1 program yang membuat 100 thread

1 program yang membuat 100 proses

buat kesimpulan dari percobaan tersebut!:

jawab :

SOURCE CODE THREAD(10 deret fibonacci)

#include <pthread.h>

#include <stdio.h>

void* fibo(void* n) // fungsi fibonacci dan memasukkan parameter looping sebagai urutan thread

{

int a,batas;

double fibo0=1, fibo1=1, fibo2;

batas=(int)n-1;

if(batas<=1)

printf("Fibonacci %d = %.0lf\n",batas, fibo1);

else

{ for(a=1;a<batas;a++)

{

fibo2=fibo1+fibo0;

fibo0=fibo1;

fibo1=fibo2;

}

printf("Fibonacci %d = %.0lf\n",a,fibo2);

//pencetakan dimulai dari 0 s.d 9 karena fibonacci dimulai dari 0

}

}

int main()

{

int loop;

pthread_t thread;

for(loop=1;loop<=10;loop++)

{

pthread_create(&thread,NULL,&fibo,(void*)loop);

pthread_join(thread,NULL);

}

return 0;

}

SOURCE CODE PROSES(10 deret fibonacci):

#include <pthread.h>

#include <stdio.h>

double fibonacci(int loop)

{

if(loop<=1)

return 1;

else

return fibonacci(loop-1) + fibonacci(loop-2);

}

int main()

{

int loop;

pid_t pid;

pid = fork();

for(loop=0;loop<10;loop++)

{

if ( pid == 0)

{

printf("Fibonacci %d = %.0lf\n", loop, fibonacci(loop)); //pencetakan dimulai dari 0 s.d 9 karena fibonacci dimulai dari 0

pid= fork();

}

wait();

}

return 0;

}

untuk program 50 deret fibonacci multithreading, 50 deret fibonacci multiprocessing, 100 deret fibonacci multithreading dan 100 deret fibonacci multiprocessing kami lampirkan.

Kesimpulan : perbedaan kecepatan mencolok pada perbandingan running 50 deret fibonacci multithreading dengan running 50 deret fibonacci multiprocessing. Multithreading sangat cepat dalam merunning program, sedangkan multiprocessing jauh lebih lambat.

Soal Shift

1. Buatlah sebuah program yang mensimulasikan komputasi paralel sederhana, dimana program akan menjumlahkan hasil komputasi dari tiap operasi matematika pada tiap thread. Program akan meminta input berupa jumlah thread, dan operasi matematika pada tiap thread. Hasil akan disimpan dalam file. Misal :Input thread : 2Operasi thread 1 : 5 * 2Operasi thread 2 : 3 * 2 * 7

JAWAB :

#include <pthread.h>

#include <stdio.h>

#include <string.h>

int tingkat(char x) //pemberian return value operator

{ if(x=='+') return -600;

else if(x=='-') return -500;

else if(x=='*') return -400;

else if(x=='/') return -300;

else if(x=='^') return -200;

else return -1000;

}

int poin(char x) //pemberian derajat operator

{ if(x=='+'|| x=='-') return 1;

else if(x=='*'|| x=='/') return 2;

else if(x=='^') return 3;

else return 0;

}

int balik(int x, int y, int tanda) //perhitungan sesuai return value operator

{ if(tanda==-600) return x+y;

else if(tanda==-500) return x-y;

else if(tanda==-400) return x*y;

else if(tanda==-300) return x/y;

else if(tanda==-200) return x^y;

else return -1000;

}

void* operasi() //penerapan algoritma konversi infix ke postfix dengan mengubah character menjadi integer

{

char soal[30];

int counter=0, stackx=0,a, save;

printf("\noperasi thread : ");

scanf("\n%s",soal); //input soal

char stack[strlen(soal)]; //pembuatan array untuk stack dan hasil sebanyak panjang string

int hasil[strlen(soal)];

for(a=0; a<strlen(soal); a++) //start pembacaan dari depan

{ if((soal[a]!='*')&&(soal[a]!='+')&&(soal[a]!='-')&&(soal[a]!='/')&&(soal[a]!='(')&&(soal[a]!='^')&&(soal[a]!=')'))

{ hasil[counter++]=soal[a]-48; } //mengisi hasil dgn operan

else

{ if(stackx==0) //jika stack kosong, maka operan akan langsung dimasukkan ke stack

{stack[stackx++]=soal[a];}

else

{ if((soal[a]!='(')&&(soal[a]!=')'))

{ if(poin(soal[a])> poin(stack[stackx-1]))

{ stack[stackx++]=soal[a]; } //jika derajat operator baru lebih tinggi

else

{ stackx--; //jika derajat operator baru lebih rendah, maka akan dikeluarkan dulu

if(stack[stackx]!='(')

{ hasil[counter++]=tingkat(stack[stackx]);

stack[stackx++]= soal[a];

}

}

}

else //special case untuk tanda kurung

{

if(soal[a]=='(') stack[stackx++]=soal[a];

if(soal[a]==')')

{ stackx--;

while(stack[stackx]!='(') //isi stack akan dipindah sampai ketemu '('

hasil[counter++]=tingkat(stack[stackx--]); //pop stack pindah ke hasil

}

}

}

}

}

while((stackx != 0))//mengeluarkan isi stack ke dalam postfix yang tersisa

hasil[counter++]=tingkat(stack[--stackx]); //pop stack pindah ke hasil

int try=0;

for(a=0; a<strlen(soal);a++) //menghilangkan tanda kurung

{ if(soal[a]!='(' && soal[a]!=')')

try++;

}

// for(a=0; a<try;a++)

// printf("%d,", hasil[a]);

counter=0;

int x=-100,y=-100;

for(a=0; a<try;a++) //perhitungan

{

if(hasil[a]<-100)

{

stackx=1;

while(1)

{ if(hasil[a-stackx]>-100)

{

if(y>-100)

{ x=hasil[a-stackx];

hasil[a-stackx]=balik(x,y,hasil[a]);

counter=hasil[a-stackx];

hasil[a]=-100;

y=-100;

x=-100;

break;

}

else

{ y=hasil[a-stackx];

hasil[a-stackx]=-100;

}

}

stackx++;

}

}

}

FILE *fp;

fp=fopen("test.txt", "r+");

fscanf(fp, "%d", &save);

fclose(fp);

fp=fopen("test.txt", "w+");

save= save+counter;

fprintf(fp, "%d", save);

fclose(fp);

}

int main()

{

int loop, jumlah=0;

FILE *fp;

fp=fopen("test.txt", "w+");

fprintf(fp, "%d", jumlah);

fclose(fp);

printf("input thread : ");

scanf("%d", &jumlah);

pthread_t thread;

for(loop=1;loop<=jumlah;loop++)

{

pthread_create(&thread,NULL,&operasi,NULL);

pthread_join(thread,NULL);

}

return 0;

}

2. Buatlah contoh program simulasi penelusuran direktori, dimana program meminta input berupa direktori yang akan ditelusuri, kemudian program akan menelusuri isinya dan tiap kali menemukan suatu direktori, program akan membuat thread baru untuk menelusuri direktori tersebut. Program akan menghasilkan output berupa file dengan nama file berupa direktori yang ditemukan dan isi filenya berupa daftar nama file dan direktori yang ditemukan. Contoh :

/home -> ini yang ditelusuri, isinya|

>> a.txt>>b.txt>>/aku|

>> c.txt

Maka akan dibuat 2 file, yaitu file dengan nama home yang berisi a.txt, b.txt, dan aku, dan file dengan nama aku yang berisi c.txt

JAWAB :

#include<stdio.h>

#include<dirent.h>

#include<stdlib.h>

#include<pthread.h>

#include <string.h>

char direc[100];

void *cari(void *va)

{

DIR *dir;

struct dirent *vari;

char *directory = (char *)va;

dir = opendir(directory);

chdir(directory);

char var[100];

FILE *log = fopen(direc,"w");

while (dir)

{

if((vari=readdir(dir))!=NULL)

{

if (vari->d_type == 8 && vari->d_name[0]!='.')

{

fprintf (log,"<< %s \n",vari->d_name);

}

else if (vari->d_type == 4 && vari->d_name[0]!='.')

{

pthread_t thread;

fprintf (log,"<< /%s\n",vari->d_name);

pthread_create(&thread,NULL,&cari,vari->d_name);

pthread_join(thread,NULL);

}

}

else break;

}

fclose(log);

closedir(dir);

return;

}

int main()

{

pthread_t va;

printf ("nama direktori : ");

scanf ("%s",direc);

pthread_create(&va,NULL,&cari,direc);

pthread_join(va,NULL);

return 0;

}