Process Programming menjelaskan tentang proses dari sudut pandang seorang programmer di linux.
1. PID
Pertama – tama kita akan membahas PID, apa itu PID? PID adalah “Process ID” atau “Process Identifier”. Process identifier adalah integer unik berukuran 16 bit yang berurutan, anda bisa menganggap PID ini sebagai sebuah nomor induk (primary key) untuk membedakan process satu dengan yang lain. Selain itu juga ada PPID, Parent PID, yaitu adalah PID dari process yang men-spawn atau memanggil suatu process. Contohnya ada process “A” yang membutuhkan process “B”, maka process “A” akan memanggil process “B”, lalu process “B” akan memiliki sebuah PID unik dan sebuah PPID yaitu PID dari process yang memanggilnya, dalam kasus ini yang memanggilnya adalah process “A” sehingga PPID dari process “B” adalah PID process “A”.
Setiap process pasti memiliki PID dan PPID, kecuali process “init”, yang mana process ini adalah parent dari semua process, sehingga tidak memiliki PPID(karena tidak ada parent nya).
Ada beberapa cara untuk mengetahui PID dan PPID dari suatu process, salah satunya(menggunakan bahasa C++) adalah dengan menggunakan fungsi getpid(); dan getppid(); . jangan lupa gunakan typecast untuk merubah return valuenya menjadi integer. Kurang lebih seperti ini:
========================================================================printf(“PID=%d”,(int)getpid());
========================================================================
2. PROCESS SPAWNING
Tadi anda membaca istilah “men-spawn” process, atau memanggil process lainnya. Sekarang penulis akan menjelaskan bagaimana sebuah process men-spawn process lainnya. Terdapat 3 cara, yaitu :
System Call Fork
system call fork adalah sebuah fungsi yang digunakan untuk menduplikasi suatu process, misal ada sebuah process “A” yang melakukan fork, maka process “A” akan men-spawn process “A”(anak) juga (dengan PID yang berbeda tentunya).cara menggunakannya adalah
=================
pid_t cpid;
cpid=fork();
=================
cpid(singkatan untuk child pid) akan berisi PID dari process “A”(anak).bila PID>0 maka fork berhasil dan nilainya adlaah PID dari anaknya. Bila PID=0 berarti fork dijalankan di process anak (karena process anak sama dengan process parent maka ia pasti akan melakukan fork juga, namun karena posisinya sebagai anak maka fork nya tidak dijalankan, sehingga return value nya 0), bila return nya kurang dari 0 maka fork gagal karena beberapa alasan, salah satunya kehabisan memory.
System Call Exec Family
System call exec adalah sekumpulan fungsi yang digunakan untuk mengganti process yang sedang berjalan dengan process yang lain. Misal anda menjalankan process “A” dan meng-exec-nya menjadi process B. maka process A tadi akan dirubah menjadi process “B”, namun karena process tersebut hanya dirubah, maka PID akan tetap(pid nya tetap pid A).
ada banyak cara menggunakan exec, contohnya execv, execvp, dan lain lain, berikut penulis lampirkan situs yang sebaiknya anda baca:
a.) tentang keluarga exec:
b.) cara menggunakan execvp
Biasanya, bila suatu process ingin melakukan spawn process baru, ia akan melakukan fork() dahulu, untuk membuat “anak process”, lalu akan mengganti kerja dari anak process tersebut menjadi process yang dikehendaki dengan exec family. Bila butuh penjelasan lebih lanjut silahkan baca:
Fungsi “system”
fungsi system adalah cara yang paling gampang, anda tinggal menulis system(“X”) dengan X diganti menjadi process yang ingin dijalankan. Namun process ini sangat buruk dari sisi komputer. Berikut adalah sedikit kerja yang dilakukan komputer bila anda menggunakan fungsi system:
a.mensuspend program anda
b.memanggil operating system
c.membuka OS Shell (menjalankan OS baru didalam OS asli anda)
d.sekarang OS baru teserbut harus mencari program X untuk dijalankan
e.mengalokasikan memory untuk process X
f.mengeksekusi process X
g.dealokasi memory
h.menutup OS Baru tadi
i.melanjutkan program anda
jadi ibaratnya, kalau anda menggunakan fork-exec adalah anda pergi ke toko, membeli kompor untuk memasak indomie di rumah, maka pemanggilan fungsi system ini seperti membuat rumah baru lalu membakar rumah anda untuk memasak indomie tadi. Memang sama sama hasilnya tercapai (memasak indomie) namun sangat boros resource, selain itu antivirus membenci fungsi system karena boros resource dan tidak aman(pemanggilan process di OS baru berarti seperti memberikan kernel previlage pada process tsb), ibaratnya bila anda membakar rumah pasti ada polisi datang, walau anda tidak ditangkap tapi pasti ada keributan yang terjadi (menunggu antivirus berjalan, dan melakukan pekerjaannya).maka dari itu biasakanlah menggunakan fork-exec.
Exec dan fork membutuhkan #include <unistd> dan system membutuhkan #include <stdlib.h>. beda dari system call dengan fungsi system adalah:system call berarti menjalankan suatu fungsi dari system, sedangkan system adalah memanggil system baru dan menjalankan fungsi didalam system baru tersebut.
SIGNALS
adalah sebuah event yang dikirimkan oleh sebuah proces ke process itu sendiri atau process lain yang digunakan untuk notifikasi bahwa terjadi suatu event. Contoh beberapa signal terkenal yaitu:
1.) SIGKILL (membunuh process secara paksa)
2.)SIGTERM (mengirim request untuk membunuh process)
3.)SIGSEGV (Signal segmentation violation, error pada memory akses, biasanya ingin mengakses memory yang bukan hak nya)
4.)SIGSTOP (men-stop/pause suatu process)
5.)SIGCONT(meng-contintue suatu process yg di stop)
6.)SIGINT (Interrupt suatu process, contohnya ketika ada input dari keyboard.
Cara mengirimkannya ada 2 cara, bisa dengan syntax
=====
Kill –[SIGNAL] pid
====
Dengan [SIGNAL] diganti signal apa yang dikirim(SIGKILL, SIGSEGV,SIGTERM) dan pid adalah pid dari process tujuan(yang mau kita kirimin signalnya)
Bisajuga dengan system call kill(pid_t pid,int sig);, dengan pid adalah pid dari tujuan signal dan dengan sig adalah padanan angka dari signal, contohnya padanan dari SIGKILL adalah 9. Sebagai tambahan, bila menggunakan cara pertama bisa dengan “cara kill -9 pid” untuk mengirim signal SIGKILL. Pengiriman signal membutuhkan header file #include <sys/types.h> dan #include <signal.h>.
WAIT
Ketika sebuah process memanggil process baru(anak) maka process parent tersebut bisa menunggu(di block) sampai process anak selesai dengan fungsi wait. fungsi wait membutuhkan header file #include <sys/types.h> dan #Include <sys/wait.h>
Cara melakukannya adalah dengan cara:
===
int status;
pid_t temp;
temp=wait(&status);
===
Dengan temp adalah pid dari anak yang selesai, masalahnya adalah bila ada banyak process dan kita hanya ingin menunggu selesainya sebuah process spesifik, maka kita tidak bisa menggunakan wait() (sebenarnya bisa namun dengan cara yang agak panjang), namun cara mudahnya adalah dengan menggunakan waitpid,syntaxnya adalah
=============
Int temp = waitpid(pid_t cpid, int *status, int option);
=============
dengan cpid adalah pid dari child yang ingin ditunggu, status tidak perlu dipedulikan, dan option adalah option dari waitpid(anda bisa membuka man waitpid untuk melihat optionnya.), return dari waitpid(ditampung dalam variabel temp) adalah pid dari child yang berubah(bernilai sama dengan cpid),atau -1 bila error.
0 komentar: