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 Semaphore dikenal sebagai menunggu.

sebagai kait (latches) (wait)

Digunakan untuk mencegah dua proses Digunakan untuk membatasi akses ke

dari mengeksekusi potongan kode yang sumber daya tunggal.
sama, atau mengakses data yang sama,
pada waktu yang sama.

Dilepaskan hanya oleh thread yang telah Dilepaskan dari thread lain (atau proses)
diperoleh 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 : 2
Operasi thread 1 : 5 * 2
Operasi 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;