POKOK BAHASAN:
- UNIX System Call
- Manajemen Memory
TUJUAN BELAJAR:
Setelah mempelajari materi dalam bab ini, mahasiswa diharapkan mampu:
- Menggunakan system call fork, wait dan execl pada Linux.
- Menggunakan perintah-perintah untuk manajemen memory.
DASAR TEORI:
1. UNIX SYSTEM CALL
Pada praktikum ini akan dilakukan percobaan menggunakan system call yang berhubungan dengan proses pada system operasi UNIX yang biasa disebut UNIX System Call, yaitu system call fork, execl dan wait. Pada percobaan yang dilakukan akan dibuat program yang didalamnya terdapat fungsi system call. Untuk menjalankannya pada Linux gunakan g++.
System Call Fork
System call fork adalah suatu system call yang membuat suatu proses baru pada system operasi UNIX. Pada percobaan ini menggunakan mesin Linux dan beberapa program yang berisi system call fork().
Bila suatu program berisi sebuah fungsi fork(), eksekusi dari program menghasilkan eksekusi dua proses. Satu proses dibuat untuk memulai eksekusi program. Bila system call fork() dieksekusi, proses lain dibuat. Proses asal disebut proses parend dan proses kedua disebut proses child. Proses child merupakan duplikat dari proses parent. Kedua proses melanjutkan eksekusi dari titik dimana system call fork() menghasilkan eksekusi pada program utama. Karena UNIX adalah system operasi time sharing, dua proses tersebut dapat mengeksekusi secara konkuren.
Nilai yang dihasilkan oleh fork() disimpan dalam variable bertipe pid_t, yang berupa nilai integer. Karena nilai dari variable ini tidak digunakan, maka hasil fork() dapat diabaikan.
- Untuk kill proses gunakan Ctrl+C.
- Untuk dokumentasi fork() dapat dilihat dengan ketikkan man 2 fork.
- Untuk melihat id dari proses, gunakan system call getpid()
- Untuk melihat dokumentasi dari getpid(), ketikkan man 2 getpid
Perbedaan antara proses parent dan proses child adalah
- Mempunyai pid yang berbeda
- Pada proses parent , fork() menghasilkan pid dari proses child jika sebuah proses child dibuat.
- Pada proses child, fork() selalu menghasilkan 0
- Membedakan copy dari semua data, termasuk variable dengan current value dan stack
- Membedakan program counter (PC) yang menunjukkan eksekusi berikutnya meskipun awalnya keduanya mempunyai nilai yang sama teta pi setelah itu berbeda.
- Setelah fork, kedua proses tersebut tidak menggunakan variable bersama.
System call fork menghasilkan :
- Pid proses child yang baru ke proses parent, hal ini sama dengan memberitahukan proses parent nama dari child-nya
- 0 : menunjukkan proses child
- -1 : 1 jika terjadi error, fork() gagal karena proses baru tidak dapat dibuat.
System Call Wait
System call wait menyebabkan proses menunggu sinyal (menunggu sampai sembarang tipe sinyal diterima dari sembarang proses). Biasanya digunakan oleh proses parent untuk menunggu sinyal dari system operasi ke parent bila child diterminasi. System call wait menghasilkan pid dari proses yang mengirimi sinyal. Untuk melihat dokumentasi wait gunakan perintah man 2 wait.
System Call Execl
Misalnya kita ingin proses baru mengerjakan sesuatu yang berbeda dari proses parent, sebutlah menjalankan program yang berbeda. Sistem call execl meletakkan program executable baru ke memory dan mengasosiasikannya dengan proses saat itu. Dengan kata lain, mengubah segala sesuatunya sehingga program mulai mengeksekusi dari file yang berbeda.
2 MANAJEMEN MEMORY
Linux mengimplementasikan sistem virtual memory demand-paged. Proses mempunyai besar memory virtual yang besar (4 gigabyte). Pada virtual memory dilakukan transfer page antara disk dan memory fisik.
Jika tidak terdapat cukup memory fisik, kernel melakukan swapping beberapa page lama ke disk. Disk drive adalah perangkat mekanik yang membaca dan menulis ke disk yang lebih lambat dibandingkan mengakses memory fisik. Jika memory total page lebih dari memory fisik yang tersedia, kernel lebih banyak melakukan swapping dibandingkan eksekusi kode program, sehingga terjadi thrashing dan mengurangi utilitas.
Jika memory fisik ekstra tidak digunakan, kernel meletakkan kode program sebagai disk buffer cache. Disk buffer menyimpan data disk yang diakses di memory; jika data yang sama dibutuhkan lagi dapat dengan cepat diambil dari cache.
Pertama kali sistem melakukan booting, ROM BIOS membentuk memory test
seperti terlih at berikut :
ROM BIOS (C) 1990 008192 KB OK
WAIT......
Kemudian informasi penting ditampilkan selama proses booting pada linux seperti terlihat berikut :
Memory: 7100k/8192k available (464k
kernel code, 384k reserved, 244k data) ...
Adding Swap: 19464k swap-space
Informasi diatas menampilkan jumlah RAM tersedia setelah kernel di-load ke memory (dalam hal ini 7100K dari 8192K). Jika ingin melihat pesan saat booting kernel yang terlalu cepat dibaca dapat dilihat kembali dengan perintah dmesg.
Setiap Linux dijalankan, perintah free digunakan untuk menampilkan total memory yang tersedia. Atau menggunakan cat /proc/meminfo. Memory fisik dan ruang swap ditampilkan disini. Contoh output pada sistem :
total used free shared buffers
Mem: 7096 5216 1880 2328 2800
Swap: 19464 0 19464
Informasi ditampilkan dalam kilobyte (1024 byte). Memory ”total” adalah jumlah tersedia setelah load kernel. Memory digunakan untuk proses atau disk bufferring sebagai “used”. Memory yang sedang tidak digunakan ditampilkan pada kolom “free”. Memory total sama dengan jumlah kolom ”used” dan ”free”.
Memory diindikasikan “shared” yaitu berapa banyak memory yang digunakan lebih dari satu proses. Program seperti shell mempunyai lebih dari satu proses yang berjalan. Kode executable read-only dan dapat disharing oleh semua proses yang berjalan pada shell. Kolom “buffers” menampilkan berapa banyak memory digunakan untuk disk buffering.
Perintah free juga menunjukkan dengan jelas bagaimana swap space dilakukan dan berpa banyak swapping yang terjadi.
Percobaan berikut untuk mengetahui manajemen memory :
1. Pada saat bootup, dengan satu user log in, dengan perintah free sistem melaporkan berikut :
Terdapat free memory (4.4MB) dan sedikit disk buffer (1.1MB).
2. Situasi berubah setelah menjalankan perintah yang membaca data dari disk (command ls –lR /.)
Disk buffer bertambah menjadi 2 MB. Hal ini berakibat pula pada kolom ”used” dan memory ”free” juga berkurang.
Perintah top dan ps -u juga sangat berguna untuk menunjukkan bagaimana penggunaan memory berubah secara dinamis dan bagaimana proses individu menggunakan memory. Contoh tampilannya :
PERCOBAAN:
Percobaan 1: Melihat proses parent dan proses child.
1. Dengan menggunakan editor vi, buatlah file fork1.cpp dan ketikkan program berikut:
Berikut Hasilnya:
2. Gunakan g++ compil untuk menjalankan program diatas
$ g++ -o fork1 fork1.cpp
$ ./fork1
Berikut Hasilnya:
3. Amati Output yang dihasilkan.
Analisa:
Program di atas bertujuan untuk memantau proses induk dan anak dengan cara memeriksa PID (Process Identifier) dan PPID (Parent Process Identifier) dari setiap proses. Untuk mengakses nilai PID dan PPID, kita menggunakan fungsi getpid() dan getppid() yang telah dideklarasikan dalam unistd.h. Kedua fungsi ini mengembalikan nilai bertipe pid_t, yaitu signed integer yang menunjukkan PID. Ketika kita menjalankan program ini dan melihatnya dengan perintah 'ps', kita dapat melihat bahwa proses ./fork1 memiliki PID 3660, yang merupakan identifikasi uniknya, dan PPID 1881, yang menunjukkan bahwa proses ini dibuat oleh proses bash.
Selain itu, dalam program ini, kita menggunakan fungsi getuid() untuk mendapatkan ID pengguna yang menjalankan program, serta fungsi sleep() untuk menghentikan eksekusi program untuk sementara dalam detik tertentu.
Percobaan 2 : Membuat dua proses terus menerus dengan sebuah system call fork().
1. Dengan menggunakan editor vi, buatlah file fork2.cpp dan ketikkan program berikut :
Berikut Hasilnya:
Berikut Hasilnya:
3. Amati output yang dihasilkan
Analisa :
Tujuan program di atas adalah menciptakan dua proses secara berulang menggunakan sistem panggilan fork(). Fork adalah panggilan sistem yang memungkinkan pembuatan proses baru. Proses asal yang memanggil fork disebut sebagai parent process, sedangkan proses baru yang dibuat setelah fork disebut child process. Hasil yang dikembalikan oleh fork adalah PID (Process Identifier) dari child process. Dalam eksperimen ini, child process memiliki PID 3792, sementara parent process memiliki PID 1881. Variabel x digunakan untuk menghitung berapa kali loop telah dijalankan. Dilihat dari urutan keluarannya, parent process selalu dimulai sebelum child process, meskipun keduanya melakukan tugas yang sama. Program ini akan terus berulang dalam loop tanpa berhenti, dan untuk menghentikannya, perlu dihentikan secara paksa menggunakan interupsi dengan menggunakan Ctrl+C.
Percobaan 3 : Membuat dua proses sebanyak lima kali.
1. Dengan menggunakan editor vi, buatlah file fork3.cpp dan ketikkan program berikut :
Berikut Hasilnya:
2. Gunakan g++ compiler untuk menjalankan program diatas
Berikut Hasilnya:
3. Amati output yang dihasilkan
Analisa :
Program ini mirip dengan program fork2, tetapi dengan perbedaan bahwa dalam program ini, loop hanya berjalan sebanyak 5 kali, tidak tak hingga. Dalam eksperimen ini, child process memiliki PID 3888, sedangkan parent process memiliki PID 1881. Seperti sebelumnya, terlihat bahwa parent process selalu dimulai lebih dulu daripada child process, meskipun keduanya melakukan tugas yang sama. Perbedaan utama adalah loop yang dibatasi hingga 5 iterasi, tidak tak hingga seperti pada program sebelumnya.
Percobaan 4 : Proses parent menuggu sinyal dari proses child dengan system call wait.
1. Dengan menggunakan editor vi, buatlah file fork4.cpp dan ketikkan program berikut :
Berikut Hasilnya:
Berikut Hasilnya:
3. Amati output yang dihasilkan
Analisa :
Program ini membedakan tugas antara proses child dan parent dengan menggunakan kondisi if..else berdasarkan hasil return dari sistem panggilan fork. Saat fork digunakan dalam program ini, jika itu adalah child process, maka nilainya akan menjadi 0, sementara jika itu adalah parent process, nilainya akan menjadi bilangan positif berupa PID dari child process. Jika proses child gagal terbentuk, fork akan mengembalikan nilai -1. Dengan informasi ini, program membagi tugas antara proses parent dan child dengan kondisi if..else. Karena parent process akan selalu dimulai lebih dulu daripada child process, program menggunakan sistem panggilan wait() untuk membuat parent process berhenti sementara dan menunggu hingga child process selesai dan diterminasi. Setelah child process selesai, sistem panggilan wait akan mengembalikan nilai berupa PID dari proses child yang telah diterminasi. Oleh karena itu, dalam program ini, wait digunakan dalam loop do..while, sehingga proses parent akan terus menunggu hingga proses child selesai.
Percobaan 5 : System call fork/exec dan wait mengeksekusi program bernama ls, menggunakan file executable /bin/ls/ dengan satu parameter -l yang ekuivalen dengan ls -l.
1. Dengan menggunakan editor vi, buatlah file fork5.cpp dan ketikkan program berikut :
Berikut Hasilnya:
2. Gunakan g++ compiler untuk menjalankan program diatas
Berikut Hasilnya:
3. Amati output yang dihasilkan
Analisa :
Program ini melibatkan proses forking, dan dalam proses child, perintah "ls -l" akan dijalankan. Ini dicapai dengan menggunakan sistem panggilan execl pada proses child. Execl adalah sistem panggilan yang digunakan untuk mengeksekusi file. Dalam kasus ini, child process akan menjalankan perintah "ls" dengan argumen "-l" pada file yang berlokasi di /bin/ls, serta argumen "/home". Execl dapat menerima banyak parameter, tetapi yang paling penting adalah tiga parameter utama: path ke file yang akan dieksekusi, argumen perintah (bisa lebih dari satu), dan NULL sebagai penanda akhir dari daftar argumen. Sistem panggilan execl akan menggantikan citra proses sebelumnya dengan citra proses yang baru. Oleh karena itu, jika execl berhasil dieksekusi oleh proses child dan selesai diterminasi, proses child akan tetap berjalan. Inilah sebabnya mengapa baris kode di bawah pemanggilan execl dalam contoh di atas tidak akan dijalankan.
Percobaan 6 : System call fork/exec dan wait mengeksekusi program lain.
1. Dengan menggunakan editor vi, buatlah file fork6.cpp dan ketikkan program berikut :
Berikut Hasilnya:
Berikut Hasilnya:
3. Amati output yang dihasilkan
Analisa :
Dalam program ini, proses child menjalankan program lain, yaitu "fork3," dengan menggunakan sistem panggilan execl. Dalam contoh di atas, proses dengan PID 4273 adalah proses parent, sementara proses dengan PID 4273 adalah proses child. Namun, ketika proses child menjalankan execl dan mengeksekusi "fork3," proses dengan PID 4273 dalam program "fork3" akan berperan sebagai proses parent, dan ia akan membuat proses child baru dengan PID 4274.
Percobaan 7 : Melihat Manjemen Memory
1. Perhatikan dengan perintah dmesg jumlah memory tersedia dan prosesswapping
$ dmesg | more
Berikut Hasilnya:
Analisa :
Perintah dmesg digunakan untuk mencetak dan mengontrol buffer ring kernel. Di dalam informasi yang dicetak oleh dmesg, terdapat pula jumlah memori yang tersedia.
2. Dengan perintah free perhatikan jumlah memory ”free”, ”used”, “share” dan “buffer” .
$ free
Berikut Hasilnya:
Analisa :
Perintah free akan menampilkan informasi tentang memori dan swap dalam kilobyte (1 kilobyte).
3. Dengan perintah dibawah ini apakah hasilnya sama dengan no 2 ?
$ cat /proc/meminfo
Berikut Hasilnya :
Analisa :
Hasil yang ditampilan oleh cat /proc/meminfo hampir sama dengan hasil pada free. Hanya saja bedanya cat /proc/meminfo menampilkan lebih banyak informasi daripada free.
4. Gunakan perintah dibawah ini
$ ls –lR /.
Berikut Hasilnya :
Analisa :
Perintah ls -lR /. menampilkan semua direktori dan file yang ada pada system informasi. Karena banyaknya file yang ditampilkan, perintah tersebut akan berjalan secara terus menerus tanpa henti.
5. Perhatikan perubahan manajemen memory
$ free
Hasil Sebelumnya:
Hasil Sesudahnya:
Analisa :
Dapat dilihat bahwa memori yang “free” menjadi berkurang, memori yang “available” berkurang, dan penggunaan memori shared dan buff/cache bertambah, sedangkan besar swap “used” bertambah dan swap “free” menjadi berkurang.
6. Jalankan sebuah program, misalnya open Office. manajemen memory. Dan perhatikan Perubahannya
$ free
Berikut Hasilnya:
Analisa :
Setelah dijalankan open Office, memori yang digunakan dan shared memori menjadi lebih besar dan memori available berkurang juga. Selain itu, beberapa swap mulai digunakan.
7. Dengan perintah ps bagaimana penggunaan memory untuk se tiap proses diatas ?
$ ps -uax
Berikut Hasilnya:
Analisa :
Perintah ini sangat berguna untuk menunjukkan bagaimana penggunaan memori berubah secara dinamis dan bagaimana proses individu menggunakan memori.
KESIMPULAN
System calls adalah cara yang telah diprogram di mana program komputer meminta layanan dari kernel sistem operasi tempatnya berjalan. System calls menyediakan antarmuka antara proses dan sistem operasi. Dalam praktikum ini, dilakukan tiga jenis system calls, yaitu fork, execl, dan wait. System call fork digunakan untuk membuat proses baru dengan menduplikasi proses yang telah ada. Proses baru yang dibuat disebut sebagai child process, sementara proses yang memanggilnya disebut sebagai parent process. System call execl berfungsi untuk mengeksekusi file dengan memberikan path file dan argumen perintah file. Execl menempatkan program yang dapat dieksekusi ke dalam memori dan mengasosiasikannya dengan proses saat itu. Sementara itu, system call wait digunakan untuk menunggu perubahan status pada child process yang dipanggil, serta untuk mendapatkan informasi tentang child process yang telah mengalami perubahan status. Linux menerapkan sistem virtual memory demand-paged, yang memungkinkan transfer halaman data antara disk dan memori fisik. Ketika memori fisik tidak mencukupi, kernel melakukan swapping, yaitu memindahkan beberapa halaman data yang lama ke disk. Jika jumlah total halaman melebihi kapasitas memori fisik yang tersedia, kernel cenderung melakukan swapping lebih sering daripada mengeksekusi kode program, yang dapat menyebabkan thrashing dan mengurangi efisiensi.
Perbedaan antara proses parent dan proses child mencakup perbedaan PID (Process Identifier) yang berbeda, penggandaan semua data termasuk variabel dengan nilai saat ini dan stack, program counter yang menunjukkan instruksi eksekusi selanjutnya, serta fakta bahwa setelah fork, kedua proses tersebut tidak menggunakan variabel yang sama.
0 Comments: