Sistem Operasi. Bahan Kuliah IKI-20230

Sistem Operasi Bahan Kuliah IKI-20230

Gabungan Kelompok Kerja 21–28 Semester Genap 2002/2003 dan 41–49 Semester Ganjil 2003/2004 Mata Kuliah Sistem Operasi

Sistem Operasi: Bahan Kuliah IKI-20230 oleh Gabungan Kelompok Kerja 21–28 Semester Genap 2002/2003 dan 41–49 Semester Ganjil 2003/2004 Mata Kuliah Sistem Operasi $Revision: 1.1 $ Edisi Diterbitkan 11 November 2003 Hak Cipta © 2003 oleh Gabungan Kelompok Kerja 21–28 Semester Genap 2002/2003 dan 41–49 Semester Ganjil 2003/2004 Mata Kuliah Sistem Operasi. Silakan menyalin, mengedarkan, dan/ atau, memodifikasi bagian dari dokumen – $Revision: 1.1 $ – – yang dikarang oleh Gabungan Kelompok Kerja 21–28 Semester Genap 2002/2003 dan 41–49 Semester Ganjil 2003/2004 Mata Kuliah Sistem Operasi, sesuai dengan ketentuan "GNU Free Documentation License versi 1.1" atau versi selanjutnya dari FSF (Free Software Foundation); tanpa bagian "Invariant", tanpa teks "Front-Cover", dan tanpa teks "Back-Cover". Lampiran A ini> berisi salinan lengkap dari lisensi tersebut. Ketentuan ini TIDAK berlaku untuk bagian dan/ atau kutipan yang bukan dikarang oleh Gabungan Kelompok Kerja 21–28 Semester Genap 2002/2003 dan 41–49 Semester Ganjil 2003/2004 Mata Kuliah Sistem Operasi.

Catatan Revisi Revisi 1.7 17-11-2003 Revised by: Kelompok 49 Versi rilis alfa buku OS Revisi 1.5 17-11-2003 Revised by: Kelompok 49 Penggabungan pertama seluruh pekerjaan kelompok 41 sampai kelompok 48. Masih ada beberapa gambar yang belum lengkap. Rujuka Revisi 1.4 08-11-2003 Revised by: Kelompok 49 Pengubahan template versi 1.3 dengan template yang baru yang akan digunakan dalam versi 1.4-2.0 Revisi 1.3.0.5 12-11-2003 Revised by: RMS46 Revisi ini diedit oleh Rahmat M. Samik-Ibrahim: dipilah sesuai dengan sub-pokok bahasan yang ada. Revisi 1.3 30-09-2003 Revised by: RMS46 Revisi ini diedit oleh Rahmat M. Samik-Ibrahim: melanjutkan perbaikan tata letak dan pengindeksan. Revisi 1.2 17-09-2003 Revised by: RMS46 Revisi ini diedit oleh Rahmat M. Samik-Ibrahim: melanjutkan perbaikan. Revisi 1.1 01-09-2003 Revised by: RMS46 Revisi ini diedit oleh Rahmat M. Samik-Ibrahim: melakukan perbaikan struktur SGML, tanpa terlalu banyak mengubah isi buku. Revisi 1.0 27-05-2003 Revised by: RMS46 Kompilasi ulang, serta melakukan sedikit perapihan. Revisi 0.21.4 05-05-2003 Revised by: Kelompok 21 Perapihan berkas dan penambahan entity. Revisi 0.21.3 29-04-2003 Revised by: Kelompok 21 Perubahan dengan menyempurnakan nama file. Revisi 0.21.2 24-04-2003 Revised by: Kelompok 21 Merubah Kata Pengantar. Revisi 0.21.1 21-04-2003 Revised by: Kelompok 21 Menambahkan Daftar Pustaka dan Index. Revisi 0.21.0 26-03-2003 Revised by: Kelompok 21 Memulai membuat tugas kelompok kuliah Sistem Operasi.

Persembahan Buku ini dipersembahkan dari Gabungan Kelompok Kerja 21–28 Semester Genap 2002/2003 dan 41–49 Semester Ganjil 2003/2004 Mata Kuliah Sistem Operasi, oleh Gabungan Kelompok Kerja 21–28 Semester Genap 2002/2003 dan 41–49 Semester Ganjil 2003/2004 Mata Kuliah Sistem Operasi, untuk siapa saja yang ingin mempelajari Sistem Operasi. Tim penyusun buku ini ialah sebagai berikut: Kelompok 21 (Koordinator) Dhani Yuliarso, Fernan, Hanny Faristin, Melanie Tedja, Paramanandana D.M., Widya Yuwanda. Kelompok 22 Budiono Wibowo, Agus Setiawan, Baya U.H.S., Budi A. Azis Dede Junaedi, Heriyanto, Muhammad Rusdi. Kelompok 23 Indra Agung, Ali Khumaidi, Arifullah, Baihaki A.S., Christian K.F. Daeli, Eries Nugroho, Eko Seno P., Habrar, Haris Sahlan. Kelompok 24 Adzan Wahyu Jatmiko, Agung Pratomo, Dedy Kurniawan, Samiaji Adisasmito, Zidni Agni. Kelompok 25 Nasrullah, Amy S. Indrasari, Ihsan Wahyu, Inge Evita Putri, Muhammad Faizal Ardhi, Muhammad Zaki Rahman, N. Rifka N. Liputo, Nelly, Nur Indah, R. Ayu P., Sita A.R. Kelompok 26 Rakhmad Azhari, Adhe Aries, Adityo Pratomo, Aldiantoro Nugroho, Framadhan A., Pelangi, Satrio Baskoro Y. Kelompok 27 Teuku Amir F.K., Alex Hendra Nilam, Anggraini W., Ardini Ridhatillah, R. Ferdy Ferdian, Ripta Ramelan, Suluh Legowo, Zulkifli. Kelompok 28 Christiono H, Arief Purnama L.K., Arman Rahmanto, Fajar, Muhammad Ichsan, Rama P. Tardan, Unedo Sanro Simon. Kelompok 41 Ahmad Furqan S K., Aristo, Obeth M S. Kelompok 42 Puspita K S, Retno Amelia, Susi R, Sutia H. Kelompok 43 Agus Setiawan, Adhita Amanda, Afaf M, Alisa Dewayanti, Andung J Wicaksono, Dian Wulandari L, Gunawan, Jefri Abdullah, M Gantino, Prita I. Kelompok 44 Arnold W, Antonius H, Irene, Theresia B, Ilham W K, Imelda T, Dessy N, Alex C.

Kelompok 45 Bima Satria T, Adrian Dwitomo, Alfa Rega M, Boby, Diah Astuti W, Dian Kartika P, Pratiwi W, S Budianti S, Satria Graha, Siti Mawaddah, Vita Amanda. Kelompok 46 Josef, Arief Aziz, Bimo Widhi Nugroho, Chrysta C P, Dian Maya L, Monica Lestari P, Muhammad Alaydrus, Syntia Wijaya Dharma, Wilmar Y Ignesjz, Yenni R Kelompok 47 Bayu Putera, Enrico, Ferry Haris, Franky, Hadyan Andika, Ryan Loanda, Satriadi, Setiawan A, Siti P Wulandari, Tommy Khoerniawan, Wadiyono Valens, William Hutama. Kelompok 48 Amir Murtako, Dwi Astuti A, M Abdushshomad E, Mauldy Laya, Novarina Azli, Raja Komkom S. Kelompok 49 (Koordinator) Fajran Iman Rusadi, Carroline D Puspa.

4

Daftar Isi Kata Pengantar ...........................................................................................................................................i 1. Konsep Dasar Perangkat Komputer ....................................................................................................1 2. Konsep Dasar Sistem Operasi ..............................................................................................................2 3. Proses dan Penjadwalan........................................................................................................................3 3.1. Konsep Proses .............................................................................................................................3 3.1.1. Definisi Proses ................................................................................................................3 3.1.2. Status Proses...................................................................................................................4 3.1.3. Process Control Block ....................................................................................................5 3.1.4. Threads ...........................................................................................................................7 3.2. Penjadwalan Proses.....................................................................................................................8 3.2.1. Queue Scheduling...........................................................................................................8 3.2.2. Scheduler ......................................................................................................................10 3.2.3. Context Switch .............................................................................................................12 3.3. Interaksi Proses .........................................................................................................................14 3.3.1. Proses yang Kooperatif.................................................................................................14 3.3.2. Masalah Produser/Konsumer........................................................................................14 3.4. Hubungan Antara Proses dan Client/Server Proses ..................................................................17 3.4.1. Hubungan Antara Proses ..............................................................................................17 3.4.1.1. Proses yang Kooperatif ....................................................................................18 3.4.1.2. Komunikasi Proses Dalam Sistem ...................................................................19 3.4.1.2.1. Sistem Penyampaian Pesan .................................................................20 3.4.1.2.2. Penamaan ............................................................................................20 3.4.1.2.2.1. Komunikasi Langsung ............................................................20 3.4.1.2.2.2. Komunikasi Tidak Langsung ..................................................21 3.4.1.3. Sinkronisasi......................................................................................................22 3.4.1.4. Buffering ..........................................................................................................22 3.4.1.5. Contoh Produser-Konsumer.............................................................................23 3.4.1.6. Mailbox ............................................................................................................25 3.4.2. Client/Server System ....................................................................................................26 3.4.2.1. Socket...............................................................................................................26 3.4.2.1.1. Server dan Thread ...............................................................................26 3.4.2.1.2. Java Socket ..........................................................................................26 3.4.2.1.3. RPC (Remote Procedure Call) ............................................................28 3.4.2.1.4. Java RMI .............................................................................................28 3.4.2.1.4.1. Pembuatan Remote Objek ......................................................28 3.4.2.1.4.2. Akses ke Remote Objek..........................................................28 3.5. Konsep Thread ..........................................................................................................................29 3.5.1. Apa itu Thread..............................................................................................................29 3.5.2. Keuntungan Thread ......................................................................................................30 3.5.3. User dan Kernel Threads ..............................................................................................31 3.5.4. Multithreading Models .................................................................................................32 3.5.5. Fork dan exec System Call ...........................................................................................34 3.5.6. Cancellation..................................................................................................................34 3.5.7. Penanganan Sinyal........................................................................................................35 3.5.8. Thread Pools.................................................................................................................36

v

3.5.9. Hal-Hal Lainnya dari Thread........................................................................................36 3.5.9.1. Thread-Specific Data .......................................................................................37 3.5.9.2. Pthreads............................................................................................................37 3.6. Ilustrasi Thread dengan Linux dan Java....................................................................................37 3.6.1. Thread dengan Linux ...................................................................................................37 3.6.2. Thread dengan Java ......................................................................................................38 3.6.2.1. Pembuatan Thread ...........................................................................................38 3.6.2.2. JVM dan Host Operating System.....................................................................39 3.7. Penjadwal CPU .........................................................................................................................39 3.7.1. Konsep Dasar................................................................................................................39 3.7.2. Siklus Burst CPU-I/O ...................................................................................................40 3.7.3. Penjadwalan CPU .........................................................................................................42 3.7.4. Penjadwalan Preemptive...............................................................................................42 3.7.5. Dispatcher.....................................................................................................................43 3.7.6. Kriteria Penjadwalan ....................................................................................................43 3.7.7. Penjadwalan Preemptive...............................................................................................43 3.8. Algoritma Penjadwalan.............................................................................................................44 3.8.1. First-Come, First-Served ..............................................................................................44 3.8.2. Shortest-Job First .........................................................................................................44 3.8.3. Priority .........................................................................................................................45 3.8.4. Round-Robin.................................................................................................................45 3.8.5. Multilevel Queue...........................................................................................................45 3.8.6. Multilevel Feedback Queue ..........................................................................................45 3.9. Prioritas dan Multiprosesor .......................................................................................................46 3.9.1. Apa itu Prioritas............................................................................................................46 3.9.2. Multiprosesor................................................................................................................46 3.10. Sistem Waktu Nyata ................................................................................................................47 3.10.1. Sistem Hard Real-Time ..............................................................................................47 3.10.2. Sistem Soft Real-Time................................................................................................47 3.11. Rangkuman .............................................................................................................................50 3.11.1. Proses..........................................................................................................................50 3.11.2. Thread.........................................................................................................................50 3.11.3. Penjadwalan CPU .......................................................................................................51 3.12. Latihan ....................................................................................................................................52 3.12.1. Proses..........................................................................................................................52 3.12.2. Thread.........................................................................................................................53 3.12.3. Penjadwalan CPU .......................................................................................................53 3.12.4. Client/Server System ..................................................................................................54 3.13. Rujukan ...................................................................................................................................54 4. Sinkronisasi dan Deadlock ..................................................................................................................56 5. Managemen Memori ...........................................................................................................................57 5.1. Swapping...................................................................................................................................57

vi

6. Sistem Berkas .......................................................................................................................................58 7. I/O..........................................................................................................................................................59 8. Studi Kasus: GNU/Linux ....................................................................................................................60 A. GNU Free Documentation License .....................................................................................................61 A.1. PREAMBLE ............................................................................................................................61 A.2. APPLICABILITY AND DEFINITIONS ................................................................................61 A.3. VERBATIM COPYING...........................................................................................................62 A.4. COPYING IN QUANTITY .....................................................................................................62 A.5. MODIFICATIONS...................................................................................................................63 A.6. COMBINING DOCUMENTS.................................................................................................64 A.7. COLLECTIONS OF DOCUMENTS ......................................................................................64 A.8. AGGREGATION WITH INDEPENDENT WORKS..............................................................65 A.9. TRANSLATION ......................................................................................................................65 A.10. TERMINATION.....................................................................................................................65 A.11. FUTURE REVISIONS OF THIS LICENSE .........................................................................65 A.12. How to use this License for your documents .........................................................................66 Indeks........................................................................................................................................................67

vii

Daftar Tabel 3-1. Tabel Flag dan Fungsinya...................................................................................................................38

Daftar Gambar 3-1. Status Proses.........................................................................................................................................4 3-2. Process Control Block ..........................................................................................................................6 3-3. ..............................................................................................................................................................6 3-4. Device Queue .......................................................................................................................................8 3-5. Diagram Antrian...................................................................................................................................9 3-6. Medium-term Scheduler.....................................................................................................................12 3-7. Context Switch ...................................................................................................................................12 3-8. Thread.................................................................................................................................................29 3-9. Many-To-One .....................................................................................................................................32 3-10. One-To-One......................................................................................................................................32 3-11. Many-To-Many.................................................................................................................................33 3-12. Siklus Burst ......................................................................................................................................40 3-13. ..........................................................................................................................................................41 3-14. Grafik Hard Real-Time.....................................................................................................................48 3-15. Grafik Soft Real-Time ......................................................................................................................48

viii

Kata Pengantar Buku ini merupakan hasil karya Gabungan Kelompok Kerja 21–28 Semester Genap 2002/2003 dan 41–49 Semester Ganjil 2003/2004 Mata Kuliah Sistem Operasi Fakultas Ilmu Komputer Universitas Indonesia (Fasilkom UI). Sebagai tim penyusun, kami sangat senang atas peluncuran buku ini. Penulisan buku ini bertujuan untuk mengatasi kelangkaan bahan kuliah berbahasa Indonesia, serta diharapkan akan dimanfaatkan sebagai rujukan oleh para peserta kuliah angkatan berikutnya. Kami menyadari bahwa ini masih banyak kekurangannya. Silakan menyampaikan kritik/ tanggapan/ usulan anda ke <writeme03 AT yahoogroups DOT com>.

i

Bab 1. Konsep Dasar Perangkat Komputer

1

Bab 2. Konsep Dasar Sistem Operasi

2

Bab 3. Proses dan Penjadwalan 3.1. Konsep Proses Jika kita berdiskusi mengenai sistem operasi, maka akan timbul sebuah pertanyaan yaitu mengenai istilah apa yang tepat untuk menyebut semua aktivitas yang dilakukan oleh CPU. Sistem Batch mengeksekusi jobs sebagaimana suatu sistem time-share menggunakan program pengguna ( user programs ) atau tasks . Bahkan pada sistem dengan satu penggunapun, seperti pada Microsoft Windows dan Macintosh OS, seorang pengguna mampu menjalankan beberapa program pada saat yang sama, contohnya Word Processor, Web Browser, dan paket e-mail. Bahkan jika pengguna hanya dapat menjalankan satu program pada satu waktu, sistem operasi perlu untuk mendukung aktivitas program internalnya sendiri, seperti managemen memori. Dalam banyak hal, seluruh aktivitas ini adalah serupa, maka kita menyebut seluruh program itu proses-proses. Istilah job dan proses digunakan hampir dapat dipertukarkan pada tulisan ini. Walau kami sendiri lebih menyukai istilah proses, banyak teori dan terminologi sistem-operasi dikembangkan selama suatu waktu ketika aktivitas utama sistem operasi adalah job processing . Akan membingungkan jika kita menghindari penggunaan istilah yang telah diterim oleh publik yang memasukkan kata job hanya karena proses memiliki istilah job sebagai pengganti atau pendahulunya.

3.1.1. Definisi Proses Secara tidak langsung, proses adalah program yang sedang dieksekusi. Menurut SilberSchatz, suatu proses adalah lebih dari sebuah kode program, yang terkadang disebut text section . Proses juga mencakup program counter , yaitu sebuah stack untuk menyimpan alamat dari instruksi yang akan dieksekusi selanjutnya dan register. Sebuah proses pada umumnya juga memiliki sebuah stack yang berisikan data-data yang dibutuhkan selama proses dieksekusi (seperti parameter method, alamat return dan variabel lokal), dan sebuah data section yang menyimpan variabel global. Sama halnya dengan SilberSchatz, Tanenbaum juga berpendapat bahwa proses adalah sebuah program yang dieksekusi yang mecakup program counter , register, dan variabel di dalamnya. Kami tekankan bahwa program itu sendiri bukanlah sebuah proses; suatu program adalah satu entitas pasif; seperti isi dari sebuah berkas yang disimpan didalam disket. Sedangkan sebuah proses dalam suatu entitas aktif, dengan sebuah program counter yang menyimpan alamat instruksi selanjut yang akan dieksekusi dan seperangkat sumber daya ( resource yang dibutuhkan agar sebuah proses dapat dieksekusi. Untuk mempermudah kita membedakan program dengan proses, kita akan menggunakan analogi yang diberikan oleh Tanenbaum. Misalnya ada seorang tukang kue yang ingin membuat kue ulang tahun untuk anaknya. Tukang kue tersebut memiliki resep kue ulang tahun dan bahan-bahan yang dibutuhkan untuk membuat kue ulang tahun di dapurnya seperti: tepung terigu, telur, gula, bubuk vanila dan bahan-bahan lainnya. Dalam analogi ini, resep kue ulang tahun adalah sebuah program, si tukang kue tersebut adala prosesor (CPU), dan bahan-bahan untuk mebuat kue tersebut adalah data input. Sedangkan proses-nya adalah kegiatan sang tukang kue untuk membaca resep, mengolah bahan, dan memanggang kue tersebut. Walau dua proses dapat dihubungkan dengan program yang sama, program tersebut dianggap dua urutan eksekusi yang berbeda. Sebagai contoh, beberapa pengguna dapat menjalankan copy yang berbeda pada

3

Bab 3. Proses dan Penjadwalan mail program, atau pengguna yang sama dapat meminta banyak copy dari program editor. Tiap-tiap proses ini adakah proses yang berbeda dan walau bagian text-section adalah sama, data section -nya bervariasi. Adalah umum untuk memiliki proses yang menghasilkan banyak proses begitu ia bekerja. Hal ini akan dijelaskan lebih detail pada subbab Hubungan Antar Proses.

3.1.2. Status Proses Bila sebuah proses dieksekusi, maka statusnya akan berubah-ubah. Status dari sebuah proses mencerminkan aktivitas atau keadaan dari proses itu sendiri. Berikut ini adalah status-status yang mungkin dimiliki sebuah proses menurut Tanenbaum:

•

Running: pada saat menggunakan CPU pada suatu waktu

•

Ready: proses diberhentikan sementara karena menunggu proses lain untuk dieksekusi

•

Blocked: tidak dijalankan sampai event dari luar (yang berhubungan dengan proses tersebut) terjadi

Sedangkan menurut SilberSchatz, terdapat 5 macam jenis status yang mungkin dimiliki oleh suatu proses:

•

New: status yang dimiliki pada saat proses baru saja dibuat

•

Running: status yang dimiliki pada saat instruksi-instruksi dari sebuah proses dieksekusi

•

Waiting: status yang dimiliki pada saat proses menunggu suatu event (contohnya: proses I/O)

•

Ready: status yang dimiliki pada saat proses siap untuk dieksekusi oleh prosesor

•

Terminated: status yang dimililki pada saat proses telah selesai dieksekusi

Nama-nama tersebut adalah berdasar opini, istilah tersebut bervariasi di sepanjang sistem operasi. Keadaan yang mereka gambarkan ditemukan pada seluruh sistem. Namun, pada sistem operasi tertentu lebih baik menggambarkan keadaan/status proses. Penting untuk diketahui bahwa hanya satu proses yang dapat berjalan pada prosesor mana pun pada satu waktu. Namun, banyak proses yang dapat berstatus ready atau waiting. Keadaan diagram yang berkaitan dangan keadaan tersebut dijelaskan pada Gambar 3-1.

4

Bab 3. Proses dan Penjadwalan Gambar 3-1. Status Proses

http://bebas.vlsm.org/v06/Kuliah/SistemOperasi/BUKU/SistemOperasi/img/4-1.png Ada tiga kemungkinan bila sebuah proses memilki status running:

•

Jika program telah selesai dieksekusi maka status dari proses tersebut akan berubah menjadi Terminated.

•

Jika waktu yang disediakan oleh OS untuk proses tersebut sudah habis maka akan terjadi interrupt dan proses tersebut kini berstatus Ready.

•

Jika suatu event terjadi pada saat proses dieksekusi (seperti ada request I/O) maka proses tersebut akan menunngu event tersebut selesai dan proses berstatus Waiting.

3.1.3. Process Control Block Tiap proses digambarkan dalam sistem operasi oleh sebuah process control block PCB - juga disebut sebuah control block. Sebuah PCB ditunjukkan dalam Gambar 2-2. PCB berisikan banyak bagian dari informasi yang berhubungan dengan sebuah proses yang spesifik, termasuk hal-hal dibawah ini:

•

Status proses: status mungkin, new, ready, running, waiting, halted, dan juga banyak lagi.

•

Program counter: suatu stack yang berisi alamat dari instruksi selanjutnya untuk dieksekusi untuk proses ini.

•

CPU register: Register bervariasi dalam jumlah dan jenis, tergantung pada rancangan komputer. Register tersebut termasuk accumulator , indeks register, stack pointer , general-purposes register , ditambah code information pada kondisi apa pun. Besertaan dengan program counter, keadaaan/status

5

Bab 3. Proses dan Penjadwalan informasi harus disimpan ketika gangguan terjadi, untuk memungkinkan proses tersebut berjalan/bekerja dengan benar setelahnya (lihat Gambar 2-3). •

Informasi managemen memori: Informasi ini dapat termasuk suatu informasi sebagai nilai dari dasar dan batas register, tabel page/halaman, atau tabel segmen tergantung pada sistem memori yang digunakan oleh sistem operasi (lihat Bab Managemen memori).

•

Informasi pencatatan: Informasi ini termasuk jumlah dari CPU dan waktu riil yang digunakan, batas waktu, jumlah akun jumlah job atau proses, dan banyak lagi.

•

Informasi status I/O: Informasi termasuk daftar dari perangkat I/O yang di gunakan pada proses ini, suatu daftar berkas-berkas yang sedang diakses dan banyak lagi.

•

PCB hanya berfungsi sebagai tempat penyimpanan informasi yang dapat bervariasi dari proses yang satu dengan yang lain.

Gambar 3-2. Process Control Block

http://bebas.vlsm.org/v06/Kuliah/SistemOperasi/BUKU/SistemOperasi/img/4-2.png

6

Bab 3. Proses dan Penjadwalan Gambar 3-3.


3.1.4. Threads Model proses yang didiskusikan sejauh ini telah menunjukkan bahwa suatu proses adalah sebuah program yang menjalankan eksekusi thread tunggal. Sebagai contoh, jika sebuah proses menjalankan sebuah program Word Processor, ada sebuah thread tunggal dari instruksi-instruksi yang sedang dilaksanakan. Kontrol thread tunggal ini hanya memungkinkan proses untuk menjalankan satu tugas pada satu waktu. Banyak sistem operasi modern telah memiliki konsep yang dikembangkan agar memungkinkan sebuah proses untuk memiliki eksekusi multithreads , agar dapat secara terus menerus mengetik dan

7

Bab 3. Proses dan Penjadwalan menjalankan pengecek ejaan didalam proses yang sama, maka sistem operasi tersebut memungkinkan proses untuk menjalankan lebih dari satu tugas pada satu waktu. Pada subbab Thread akan dibahas proses multithreaded lebih lanjut.

3.2. Penjadwalan Proses Multiprogramming bertujuan untuk memaksimalkan penggunaan CPU dengan cara mengatur alokasi waktu yang digunakan oleh CPU,sehingga proses berjalan sepanjang waktu dan meperkecil waktu idle . Untuk sistem yang bersifat uniprosesor , hanya ada satu proses yang bisa berjalan setiap waktunya. Jika proses yang ada lebih dari satu, maka proses yang lain harus menunggu sampai CPU bebas dan siap untuk dijadwalkan kembali.

3.2.1. Queue Scheduling Ketika sebuah proses memasuki sistem, proses itu diletakkan di dalam job queue . Pada antrian ini terdapat seluruh proses yang berada dalam sistem. Sedangkan proses yang berada pada memori utama, siap dan menunggu untuk mengeksekusi disimpan dalam sebuah daftar yang bernama ready queue . Antrian ini biasanya disimpan sebagai linked list . Header dari ready queue berisi pointer untuk PCB pertama dan PCB terakhir pada list. Setiap PCB memiliki pointer field yang menunjuk kepada PCB untuk proses selanjutnya dalam ready queue . Sistem operasi juga memiliki antrian lain. Ketika sebuah proses dialokasikan ke CPU, proses tersebut berjalan sebentar lalu berhenti, di-interupsi, atau menunggu suatu hal tertentu, seperti selesainya suatu permintaan I/O. Dalam permintaan I/O, bisa saja yang diminta itu adalah tape drive , atau peralatan yang di- share secara bersama-sama, seperti disk. Karena ada banyak proses dalam sistem, disk bisa saja sibuk dengan permintaan I/O dari proses lainnya. Untuk itu proses tersebut mungkin harus menunggu disk tersebut. Daftar dari proses-proses yang menunggu peralatan I/O tertentu disebut dengan device queue . Tiap peralatan memiliki device queue -nya masing-masing. Gambar 3-4 .

8

Bab 3. Proses dan Penjadwalan Gambar 3-4. Device Queue

http://bebas.vlsm.org/v06/Kuliah/SistemOperasi/BUKU/SistemOperasi/img/4-4.png Penjadwalan proses dapat direpresentasikan secara umum dalam bentuk diagram antrian, seperti yang ditunjukkan oleh Gambar 3-5. Setiap kotak segi empat menunjukkan sebuah antrian. Dua tipe antrian menunjukan antrian yang siap dan seperangkat device queues . Lingkaran menunjukkan sumber daya yang melayani antrian, dan tanda panah mengindikasikan alur dari proses-proses yang ada dalam sistem.

9

Bab 3. Proses dan Penjadwalan Gambar 3-5. Diagram Antrian

http://bebas.vlsm.org/v06/Kuliah/SistemOperasi/BUKU/SistemOperasi/img/4-5.png Sebuah proses baru pertama-tama diletakkan dalam ready queue . Proses tersebut menunggu di dalam ready antrian sampai dia dipilih untuk eksekusi, atau dengan kata lain di- dispatched . Begitu proses tersebut dialokasikan ke CPU dan sedang berjalan, beberapa kemungkinan di bawah ini dapat terjadi:

•

Proses tersebut mengeluarkan permintaan I/O, lalu ditempatkan dalam sebuah antrian I/O

•

Proses tersebut dapat membuat sub proses yang baru dan menunggu untuk di-terminasi

•

Proses tersebut dapat dikeluarkan secara paksa dari CPU, sebagai hasil dari suatu interupsi, dan diletakkan kembali dalam ready queue

Pada dua kemungkinan pertama (proses meminta I/O atau membuat sub proses baru), proses berganti keadaan dari waiting state menjadi ready state , lalu diletakkan kembali dalam ready queue . Proses akan meneruskan siklus ini sampai dia di-terminasi , yaitu saat dimana proses tersebut dikeluarkan dari seluruh antrian yang ada dan memiliki PCB-nya sendiri dan seluruh sumber daya yang dia gunakan dialokasikan kembali.

10

Bab 3. Proses dan Penjadwalan

3.2.2. Scheduler Sebuah proses berpindah-pindah di antara berbagai penjadwalan antrian seumur hidupnya. Sistem operasi harus memilih dan memproses antrian-antrian ini berdasarkan kategorinya dengan cara tertentu. Oleh karena itu, proses seleksi ini harus dilakukan oleh scheduler yang tepat. Dalam sistem batch , seringkali proses yang diserahkan lebih banyak daripada yang dapat dilaksanakan dengan segera. Proses-proses ini disimpan pada suatu mass-storage device (semacam disk), dimana proses tersebut disimpan untuk eksekusi di lain waktu. Long-term scheduler , atau job scheduler , memilih proses dari tempat ini dan mengisinya ke dalam memori. Sedangkan short-term scheduler , atau CPU scheduler , hanya memilih proses yang sudah siap untuk melakukan eksekusi, dan mengalokasikan CPU untuk proses tersebut. Hal yang cukup jelas untuk membedakan kedua jenis scheduler ini adalah frekuensi dari eksekusinya. Short-term scheduler harus memilih proses baru untuk CPU sesering mungkin. Sebuah proses dapat mengeksekusi hanya dalam beberapa milidetik sebelum menunggu permintaan I/O. Seringkali, short-term scheduler mengeksekusi paling sedikit sekali setiap 100 milidetik. Karena durasi waktu yang pendek antara eksekusi-eksekusi tersebut, short-term scheduler seharusnya cepat. Jika memerlukan waktu 10 mili detik untuk menentukan suatu proses eksekusi selama 100 mili detik, maka 10/(100 + 10) = 9 persen dari CPU sedang digunakan (atau terbuang) hanya untuk pekerjaan penjadwalan. Long-term scheduler , pada sisi lain, mengeksekusi jauh lebih jarang. Mungkin ada beberapa menit waktu yang dibutuhkan untuk pembuatan proses baru dalam sistem. Long-term scheduler mengontrol degree of multiprogramming (jumlah proses dalam memori). Jika degree of multiprogramming stabil, maka tingkat rata-rata penciptaan proses harus sama dengan tingkat rata rata proses meninggalkan sistem. Maka dari itu long-term scheduler mungkin dipanggil hanya ketika suatu proses meninggalkan sistem. Karena interval yang lebih panjang antara eksekusi, long-term scheduler dapat menggunakan waktu yang lebih lama untuk menentukan proses mana yang harus dipilih untuk dieksekusi. Sangat penting bagi long-term scheduler membuat seleksi yang hati-hati. Secara umum, proses dapat dibedakan atas dua macam, yaitu proses I/O bound dan proses CPU bound . Proses I/O bound adalah proses yang lebih banyak menghabiskan waktunya untuk mengerjakan I/O dari pada melakukan komputasi. Proses CPU-bound , di sisi lain, jarang melakukan permintaan I/O, dan menggunakan lebih banyak waktunya untuk melakukan komputasi. Oleh karena itu, long-term scheduler harus memilih gabungan proses yang baik antara proses I/O bound dan CPU bound . Jika seluruh proses adalah I/O bound , ready queue akan hampir selalu kosong, dan short-term scheduler akan memiliki sedikit tugas. Jika seluruh proses adalah CPU bound , I/O waiting queue akan hampir selalu kosong, peralatan akan tidak terpakai, dan sistem akan menjadi tidak seimbang.Sistem dengan kinerja yang terbaik akan memiliki kombinasi yang baik antara proses CPU bound dan I/O bound . Pada sebagian sistem, long-term scheduler bisa jadi tidak ada atau kerjanya sangat minim. Sebagai contoh, sistem time-sharing seperti UNIX sering kali tidak memiliki long-term scheduler . Stabilitas sistem-sistem seperti ini bergantung pada keterbatasan fisik (seperti jumlah terminal yang ada) atau pada penyesuaian sendiri secara alamiah oleh manusia sebagai pengguna. Jika kinerja menurun pada tingkat yang tidak dapat diterima, sebagian pengguna akan berhenti. Sebagian sistem operasi, seperti sistem time-sharing , dapat memperkenalkan sebuah scheduler tambahan, yaitu medium-term scheduler . Scheduler ini digambarkan pada Gambar 3-6. Ide utama atau kunci dari scheduler ini terkadang akan menguntungkan untuk memindahkan proses dari memori (dan dari pengisian aktif dari CPU), dan akibatnya degree of multiprogramming akan berkurang. Di kemudian waktu, proses dapat dibawa kembali dalam memori dan eksekusinya dapat dilanjutkan pada keadaan dimana proses itu dipindahkan tadi. Skema ini disebut swapping . Proses di- swapped out dan di-

11

Bab 3. Proses dan Penjadwalan swapped in oleh scheduler ini. Swapping mungkin diperlukan untuk meningkatkan mutu penggabungan proses, atau karena perubahan dalam kebutuhan memori yang mengakibatkan memori harus dibebaskan. Swapping dibahas dalam Bagian 5.1. Gambar 3-6. Medium-term Scheduler


3.2.3. Context Switch Mengganti CPU ke proses lain memerlukan penyimpanan keadaan dari proses lama dan mengambil keadaan dari proses yang baru. Hal ini dikenal dengan sebutan context switch . Context switch sebuah proses direpresentasikan dalam PCB dari suatu proses; termasuk nilai dari CPU register, status proses (bisa dilihat pada Gambar 3-7)dan informasi manajemen memori. Ketika context switch terjadi, kernel menyimpan data dari proses lama ke dalam PCB nya dan mengambil data dari proses baru yang telah terjadwal untuk berjalan. Waktu context switch adalah murni overhead , karena sistem melakukan pekerjaan yang tidak begitu berarti selama melakukan pengalihan. Kecepatannya bervariasi dari mesin ke mesin, bergantung pada kecepatan memori, jumlah register yang harus di-copy, dan ada tidaknya instruksi khusus (seperti instruksi tunggal untuk mengisi atau menyimpan seluruh register). Tingkat kecepatan umumnya berkisar antara 1 sampai 1000 mikro detik.

12

Bab 3. Proses dan Penjadwalan Gambar 3-7. Context Switch

http://bebas.vlsm.org/v06/Kuliah/SistemOperasi/BUKU/SistemOperasi/img/4-3.png Waktu context switch sangat begantung pada dukungan perangkat keras. Sebagai contoh, prosesor seperti UltraSPARC menyediakan beberapa set register. Sebuah proses context switch hanya memasukkan perubahan pointer ke set register yang ada saat itu. Tentu saja, jika proses aktif yang ada lebih banyak daripada proses yang ada pada set register, sistem menggunakan bantuan untuk meng-copy data register dari dan ke memori, sebagaimana sebelumnya. Semakin kompleks suatu sistem operasi, semakin banyak pekerjaan yang harus dilakukan selama context switch . Bisa dilihat pada Bab Memori, teknik managemen memori tingkat lanjut dapat mensyaratkan data tambahan untuk diganti dengan tiap data. Sebagai contoh, ruang alamat dari proses yang ada saat itu harus dijaga sebagai ruang alamat untuk proses yang akan dikerjakan berikutnya. Bagaimana ruang alamat dijaga, berapa banyak pekerjaan dibutuhkan untuk menjaganya, tergantung pada metode managemen memori dari sistem operasi. Akan kita lihat pada Bab Memori, context switch terkadang bisa menyebabkan bottleneck , dan programmer

13

Bab 3. Proses dan Penjadwalan menggunakan struktur baru (threads) untuk menghindarinya kapan pun memungkinkan.

3.3. Interaksi Proses Proses yang dijalankan pada suatu sistem operasi dapat bekerja secara bersama-sama ataupun sendiri saja. Bagian sebelum ini telah menjelaskan mengenai konsep proses dan bagaimana penjadwalan proses itu. Disini kita akan melihat bagaimana hubungan antara proses-proses itu.

3.3.1. Proses yang Kooperatif Proses yang bersifat concurrent bekerja sama dengan proses lain. Proses itu kooperatif jika mereka dapat saling mempengaruhi. Kerja sama antar proses itu penting karena beberapa alasan :

•

Pembagian informasi : Beberapa proses dapat mengakses beberapa data yang sama.

•

Kecepatan komputasi : Tugas yang dijalankan dapat berjalan dengan lebih cepat jika tugas tersebut dipecah-pecah menjadi beberapa sub bagian dan dieksekusi secara paralel dengan sub bagian yang lain. Peningkatan kecepatan ini dapat dilakukan jika komputer tersebut mempunyai beberapa elemen pemrosesan, seperti CPU atau jalur I/O.

•

Modularitas : Akan lebih mudah untuk mengatur tugas yang kompleks jika tugas tersebut dipecah menjadi beberapa sub bagian, kemudian mempunyai proses atau thread yang berbeda untuk menjalankan setiap sub bagian.

•

Kenyamanan : User bisa dengan mudah mengerjakan sesuatu yang berbeda dalam waktu yang sama. Contohnya satu user dapat mengetik, mengedit, dan mencetak suatu halaman tertentu secara bersamaan.

Kerja sama antar proses membutuhkan suatu mekanisme yang memperbolehkan proses-proses untuk mengkomunikasikan data dengan yang lain dan meng- synchronize kerja mereka sehingga tidak ada yang saling menghalangi. Salah satu cara proses dapat saling berkomunikasi adalah Interprocess Communication (IPC) yang akan dijelaskan lebih lanjut di bagian berikut.

3.3.2. Masalah Produser/Konsumer Produser membuat suatu informasi yang dapat dibagi dengan proses lainnya. Konsumer menghabiskan data yang dibuat oleh produser. Misalnya program cetak memproduksi karakter yang dipakai oleh printer . Masalah yang biasanya dihadapi oleh produser dan konsumer adalah bagaimana caranya mensinkronisasikan kerja mereka sehingga tidak ada yang saling mengganggu. Salah satu contoh bagaimana masalah ini dapat terjadi adalah Bounded Buffer Problem . Solusi pembagian memori untuk Bounded Buffer Problem diterangkan dengan program sebagai berikut : import java.util.*;

14

Bab 3. Proses dan Penjadwalan public class BoundedBuffer { public BoundedBuffer() { // buffer diinisialisasikan kosong count = 0; in = 0; out = 0; buffer = new Object[BUFFER_SIZE]; } // produser memanggil method ini public void enter( Object item ) { while ( count == BUFFER_SIZE ) ; // tidak melakukan apa-apa // menambahkan suatu item ke dalam buffer ++count; buffer[in] = item; in = ( in + 1 ) % BUFFER_SIZE; if ( count == BUFFER_SIZE ) System.out.println( "Producer Entered " + item + " Buffer FULL" ); else System.out.println( "Producer Entered " + item + " Buffer Size = " + count ); } // konsumer memanggil method ini public Object remove() { Object item ; while ( count == 0 ) ; // tidak melakukan apa-apa // menyingkirkan suatu item dari buffer --count; item = buffer[out]; out = ( out + 1 ) % BUFFER_SIZE; if ( count == 0 ) System.out.println( "Consumer consumed " + item + " Buffer EMPTY" ); else System.out.println( "Consumer consumed " + item + " Buffer Size = " +count ); return item; } public static final int NAP_TIME = 5; private static final int BUFFER_SIZE = 5;

15


private private private private

volatile int count; int in; // arahkan ke posisi kosong selanjutnya int out; // arahkan ke posisi penuh selanjutnya Object[] buffer;

}

Buffer adalah tempat penyimpanan data dimana produser mengisinya dan konsumer mengosongkan buffer tersebut. Jika buffer kosong, konsumer harus menunggu, dan ketika buffer penuh, produser harus menunggu. Disinilah produser harus bekerja sama dengan konsumer. Konsumer harus menunggu sampai ada barang yang diproduksi. Program dibawah ini menggambarkan proses yang dijalankan oleh produser untuk Bounded Buffer Problem //Producer.java import java.util.*; public class Producer extends Thread { public Producer(BoundedBuffer b) { buffer = b; } public void run() { Date message; while (true) { int sleeptime = (int) (BoundedBuffer.NAP_TIME * Math.random() ); System.out.println("Producer sleeping for " + sleeptime + " seconds"); try { sleep(sleeptime*1000); } catch(InterruptedException e) {} // membuat suatu barang & memasukkannya ke buffer message = new Date(); System.out.println("Producer produced " + message); buffer.enter(message); } } private

BoundedBuffer buffer;

}

Program berikut menggambarkan proses yang dijalankan oleh konsumer pada Bounded Buffer Problem // Consumer.java import java.util.*; public class Consumer extends Thread { public Consumer(BoundedBuffer b) { buffer = b; }

16

Bab 3. Proses dan Penjadwalan public void run() { Date message; while (true) { int sleeptime = (int) (BoundedBuffer.NAP_TIME * Math.random() ); System.out.println("Consumer sleeping for " + sleeptime + " seconds"); try { sleep(sleeptime*1000); } catch(InterruptedException e) {} // mengambil barang dari buffer System.out.println("Consumer wants to consume."); message = (Date)buffer.remove(); } } private

BoundedBuffer buffer;

}

Masalah produser-konsumer dengan unbounded-buffer tidak menempatkan batas praktikal pada ukuran pada buffer . Konsumer harus menunggu untuk barang baru, tetapi produser dapat selalu memproduksi barang baru. Sedangkan masalah produser-konsumer bounded-buffer mengasumsikan ukuran buffer yang ditetapkan. Pada kasus ini, konsumer harus menunggu sampai buffer kosong dan produser harus menunggu sampai buffer penuh.

3.4. Hubungan Antara Proses dan Client/Server Proses Sebelumnya kita telah ketahui seluk beluk dari suatu proses mulai dari pengertiannya, cara kerjanya, sampai operasi-operasinya seperti proses pembentukannya dan proses pemberhentiannya setelah selesai melakukan eksekusi. Kali ini kita akan mengulas bagaimana hubungan antar proses dapat berlangsung, misal bagaimana beberapa proses dapat saling berkomunikasi dan bekerja-sama. Kalau pada sub-bab sebelumnya kita banyak membahas mengenai buffer, dan lingkungan yang berbagi memori. Pada bagian ini kita lebih banyak membahas teknik komunikasi antara proses melalui kirim(send) dan terima (recive) yang biasa dikenal sebagai IPC. Selain itu pada bagian ini kita akan menyingung sedikit mengenai client/server proses. Beberapa topik yang akan dibahas adalah Java RMI (Remote Method Invocation) dan RPC (Remote Procedure Call). Yang keduanya juga menggunakan mekanisme komunikasi IPC, namun menggunkan sistem yang terdistribusi yang melibatkan jaringan. Pada bagian ini juga akan dibahas mengenai infrastruktur dasar jaringan yaitu socket.

17


3.4.1. Hubungan Antara Proses 3.4.1.1. Proses yang Kooperatif Proses yang bersifat simultan (concurrent) dijalankan pada sistem operasi dapat dibedakaan menjadi yaitu proses independen dan proses kooperatif. Suatu proses dikatakan independen apabila proses tersebut tidak dapat terpengaruh atau dipengaruhi oleh proses lain yang sedang dijalankan pada sistem. Berarti, semua proses yang tidak membagi data apa pun (baik sementara/ tetap) dengan proses lain adalah independent. Sedangkan proses kooperatif adalah proses yang dapat dipengaruhi atau pun terpengaruhi oleh proses lain yang sedang dijalankan dalam sistem. Dengan kata lain, proses dikatakan kooperatif bila proses dapat membagi datanya dengan proses lain. Ada 4 alasan untuk penyediaan sebuah lingkungan yang memperbolehkan terjadinya proses kooperatif : 1. Pembagian informasi : apabila beberapa pengguna dapat tertarik pada bagian informasi yang sama (sebagai contoh, sebuah berkas bersama), kita harus menyediakan sebuah lingkungan yang mengijinkan akses secara terus menerus ke tipe dari sumber-sumber tersebut. 2. Kecepatan penghitungan / komputasi : jika kita menginginkan sebuah tugas khusus untuk menjalankan lebih cepat, kita harus membagi hal tersebut ke dalam subtask, setiap bagian dari subtask akan dijalankan secara parallel dengan yang lainnya. Peningkatan kecepatan dapat dilakukan hanya jika komputer tersebut memiliki elemen-elemen pemrosesan ganda (seperti CPU atau jalur I/O). 3. Modularitas : kita mungkin ingin untuk membangun sebuah sistem pada sebuah model modular-modular, membagi fungsi sistem menjadi beberapa proses atau threads. 4. Kenyamanan : bahkan seorang pengguna individu mungkin memiliki banyak tugas untuk dikerjakan secara bersamaan pada satu waktu. Sebagai contoh, seorang pengguna dapat mengedit, memcetak, dan meng-compile secara parallel.

import java.util.*; public class BoundedBuffer { public BoundedBuffer() { // buffer diinisialisasikan kosong count = 0; in = 0; out = 0; buffer = new Object[BUFFER_SIZE]; } // produser memanggil method ini public void enter( Object item ) { while ( count == BUFFER_SIZE ) ; // do nothing // menambahkan suatu item ke dalam buffer ++count; buffer[in] = item;

18

Bab 3. Proses dan Penjadwalan in = ( in + 1 ) % BUFFER_SIZE; if ( count == BUFFER_SIZE ) System.out.println( "Producer Entered " + item + " Buffer FULL" ); else System.out.println( "Producer Entered " + item + " Buffer Size = " + count ); } // consumer memanggil method ini public Object remove() { Object item ; while ( count == 0 ) ; // do nothing // menyingkirkan suatu item dari buffer --count; item = buffer[out]; out = ( out + 1 ) % BUFFER_SIZE; if ( count == 0 ) System.out.println( "Consumer consumed " + item + " Buffer EMPTY" ); else System.out.println( "Consumer consumed " + item + " Buffer Size = " +count ); return item; } public static final int NAP_TIME = 5; private static final int BUFFER_SIZE = 5; private volatile int count; private int in; // arahkan ke posisi kosong selanjutnya private int out; // arahkan ke posisi penuh selanjutnya private Object[] buffer; }

Sebuah produsen proses membentuk informasi yang dapat digunakan oleh konsumen proses. Sebagai contoh sebuah cetakan program yang membuat banyak karakter yang diterima oleh driver pencetak. Untuk memperbolehkan produser dan konsumer proses agar dapat berjalan secara terus menerus, kita harus menyediakan sebuah item buffer yang dapat diisi dengan proses produser dan dikosongkan oleh proses konsumer. Proses produser dapat memproduksi sebuah item ketika konsumer sedang mengkonsumsi item yang lain. Produser dan konsumer harus dapat selaras. Konsumer harus menunggu hingga sebuah item diproduksi.

3.4.1.2. Komunikasi Proses Dalam Sistem Cara lain untuk meningkatkan efek yang sama adalah untuk sistem operasi yaitu untuk menyediakan alat-alat proses kooperatif untuk berkomunikasi dengan yang lain lewat sebuah komunikasi dalam proses IPC (Inter-Process Communication). IPC menyediakan sebuah mekanisme untuk megijinkan proses-proses untuk berkomunikasi dan menyelaraskan aksi-aksi mereka tanpa berbagi ruang alamat yang sama. IPC adalah khusus digunakan dalam sebuah lingkungan yang terdistribusi dimana proses komunikasi tersebut mungkin saja tetap ada dalam komputer-komputer yang berbeda yang tersambung

19

Bab 3. Proses dan Penjadwalan dalam sebuah jaringan. IPC adalah penyedia layanan terbaik dengan menggnakan sebuah sistem penyampaian pesan, dan sistem-sistem pesan dapat diberikan dalam banyak cara. 3.4.1.2.1. Sistem Penyampaian Pesan Fungsi dari sebuah sistem pesan adalah untuk memperbolehkan komunikasi satu dengan yang lain tanpa perlu menggunakan pembagian data. Sebuah fasilitas IPC menyediakan paling sedikit 2 operasi yaitu kirim (pesan) dan terima (pesan). Pesan dikirim dengan sebuah proses yang dapat dilakukan pada ukuran pasti atau variabel. Jika hanya pesan dengan ukuran pasti dapat dikirimkan, level sistem implementasi adalah sistem yang sederhana. Pesan berukuran variabel menyediakan sistem implementasi level yang lebih kompleks. Jika dua buah proses ingin berkomonikasi, misalnya proses P dan proses Q, mereka harus mengirim pesan atau menirima pesan dari satu ke yang lainnya. Jalur ini dapat diimplentasikan dengan banyak cara, namun kita hanya akan memfokuskan pada implementasi logiknya saja, bukan implementasi fisik(seperti shared memory, hardware bus, atau jaringan).Berikut ini ada beberapa metode untuk mengimplementasikan sebuah jaringan dan operasi pengiriman / penerimaan secara logika :

•

Komunikasi langsung atau tidak langsung.

•

Komunikasi secara simetris / asimetris.

•

Buffer otomatis atau eksplisit.

•

Pengiriman berdasarkan salinan atau referensi.

•

Pesan berukuran pasti dan variabel.

3.4.1.2.2. Penamaan Proses-proses yang ingin dikomunikasikan harus memiliki sebuah cara untuk memilih satu dengan yang lain. Mereka dapat menggunakan komunikasi langsung / tidak langsung. 3.4.1.2.2.1. Komunikasi Langsung Setiap proses yang ingin berkomunikasi harus memiliki nama yang bersifat eksplisit baik penerimaan atau pengirim dari komunikasi tersebut. Dalam konteks ini, pengiriman dan penerimaan pesan secara primitive dapat dijabarkan sebagai :

•

Send (P, message) - mengirim sebuah pesan ke proses P.

•

Receive (Q, message) - menerima sebuah pesan dari proses Q.

Sebuah jaringan komunikasi pada bahasan ini memiliki beberapa sifat, yaitu :

•

Sebuah jaringan yang didirikan secara otomatis diantara setiap pasang dari proses yang ingin dikomunikasikan. Proses tersebut harus mengetahui identitas dari semua yang ingin dikomunikasikan.

•

Sebuah jaringan adalah terdiri dari penggabungan 2 proses.

20

Bab 3. Proses dan Penjadwalan •

Diantara setiap pesan dari proses terdapat tepat sebuah jaringan.

Pembahasan ini memperlihatkan sebuah cara simetris dalam pemberian alamat. Oleh karena itu, baik keduanya yaitu pengirim dan penerima proses harus memberi nama bagi yang lain untuk berkomunikasi, hanya pengirim yang memberikan nama bagi penerima sedangkan penerima tidak menyediakan nama bagi pengirim. Dalam konteks ini, pengirim dan penerima secara sederhana dapat dijabarkan sebagai :

•

Send (P, message) - mengirim sebuah pesan kepada proses P.

•

Receive (id, message) - menerima sebuah pesan dari semua proses. Variabel id diatur sebagai nama dari proses dengan komunikasi.

Kerugian dari kedua cara yang disebutkan diatas adalah adanya kebatasan modularitas, merubah nama proses mungkin mengharuskan kita untuk merubah semua definisi proses yang lain. Semua referensi kepada nama yang lama harus ditemukan.

3.4.1.2.2.2. Komunikasi Tidak Langsung Dengan komunikasi tidak langsung, pesan akan dikirimkan pada dan diterima dari / melalui mailbox (Kotak Surat) atau terminal-terminal, sebuah mailbox dapat dilihat secara abstrak sebagai sebuah objek didalam setiap pesan yang dapat ditempatkan dari proses dan dari setipap pesan yang bias dipindahkan. Setiap kotak surat memiliki sebuah identifikasi (identitas) yang unik, sebuah proses dapat berkomunikasi dengan beberapa proses lain melalui sebuah nomor dari mailbox yang berbeda. Dua proses dapat saling berkomunikasi apabila kedua proses tersebut sharing mailbox. Pengirim dan penerima dapat dijabarkan sebagai :

•

Send (A, message) - mengirim pesan ke mailbox A.

•

Receive (A, message) - menerima pesan dari mailbox A.

Dalam masalah ini, link komunikasi mempunyai sifat sebagai berikut :

•

Sebuah link dibangun diantara sepasang proses dimana kedua proses tersebut membagi mailbox.

•

Sebuah link mungkin dapat berasosiasi dengan lebih dari 2 proses.

•

Diantara setiap pasang proses komunikasi, mungkin terdapat link yang berbeda-beda, dimana setiap link berhubungan pada satu mailbox.

Misalkan terdapat proses P1, P2 dan P3 yang semuanya share mailbox. Proses P1 mengirim pesan ke A, ketika P2 dan P3 masing-masing mengeksekusi sebuah kiriman dari A. Proses mana yang akan menerima pesan yang dikirim P1?. Jawabannya tergantung dari jalur yang kita pilih :

•

Mengijinkan sebuah link berasosiasi dengan paling banyak 2 proses.

21


Mengijinkan paling banyak 1 proses pada suatu waktu untuk mengeksekusi hasil kiriman (receive operation).

•

Mengijinkan sistem untuk memilih secara mutlak proses mana yang akan menerima pesan (apakah itu P2 atau P3 tetapi tidak keduanya, tidak akan menerima pesan). Sistem mungkin mengidentifikasi penerima kepada pengirim.

Mailbox mungkin dapat dimiliki oleh sebuah proses atau sistem operasi. Jika mailbox dimiliki oleh proses, maka kita mendefinisikan antara pemilik (yang hanya dapat menerima pesan melalui mailbox) dan pengguna dari mailbox (yang hanya dapat mengirim pesan ke mailbox). Selama setiap mailbox mempunyai kepemilikan yang unik, maka tidak akan ada kebingungan tentang siapa yang harus menerima pesan dari mailbox. Ketika proses yang memiliki mailbox tersebut diterminasi, mailbox akan hilang. Semua proses yang mengirim pesan ke mailbox ini diberi pesan bahwa mailbox tersebut tidak lagi ada. Dengan kata lain, mempunyai mailbox sendiri yang independent, dan tidak melibatkan proses yang lain. Maka sistem operasi harus memiliki mekanisme yang mengijinkan proses untuk melakukan hal-hal dibawah ini : •

Membuat mailbox baru.

•

Mengirim dan menerima pesan melalui mailbox.

•

Menghapus mailbox.

Proses yang membuat mailbox pertama kali secara default akan memiliki mailbox tersebut. Untuk pertama kali, pemilik adalah satu-satunya proses yang dapat menerima pesan melalui mailbox ini. Bagaimanapun, kepemilikan dan hak menerima pesan mungkin dapat dialihkan ke proses lain melalui sistem pemanggilan.

3.4.1.3. Sinkronisasi Komunikasi antara proses membutuhkan place by calls untuk mengirim dan menerima data primitive. Terdapat design yang berbeda-beda dalam implementasi setiap primitive. Pengiriman pesan mungkin dapat diblok (blocking) atau tidak dapat dibloking (nonblocking) - juga dikenal dengan nama sinkron atau asinkron.

•

Pengiriman yang diblok : Proses pengiriman di blok sampai pesan diterima oleh proses penerima (receiving process) atau oleh mailbox.

•

Pengiriman yang tidak diblok : Proses pengiriman pesan dan mengkalkulasi operasi.

•

Penerimaan yang diblok : Penerima mem blok samapai pesan tersedia.

•

Penerimaan yang tidak diblok : Penerima mengembalikan pesan valid atau null.

22


3.4.1.4. Buffering Baik komunikasi itu langsung atau tak langsung, penukaran pesan oleh proses memerlukan antrian sementara. Pada dasarnya, terdapat tiga jalan dimana antrian tersebut diimplementasikan :

•

Kapasitas nol: antrian mempunyai panjang maksimum 0, maka link tidak dapat mempunyai penungguan pesan (message waiting). Dalam kasus ini, pengirim harus memblok sampai penerima menerima pesan.

•

Kapasitas terbatas: antrian mempunyai panjang yang telah ditentukan, paling banyak n pesan dapat dimasukkan. Jika antrian tidak penuh ketika pesan dikirimkan, pesan yang baru akan menimpa, dan pengirim pengirim dapat melanjutkan eksekusi tanpa menunggu. Link mempunyai kapasitas terbatas. Jika link penuh, pengirim harus memblok sampai terdapat ruang pada antrian.

•

Kapasitas tak terbatas: antrian mempunyai panjang yang tak terhingga, maka, semua pesan dapat menunggu disini. Pengirim tidak akan pernah di blok.

3.4.1.5. Contoh Produser-Konsumer Sekarang kita mempunyai solusi problem produser-konsumer yang menggunakan penyampaian pesan. Produser dan konsumer akan berkomunikasi secara tidak langsung menggunakan mailbox yang dibagi. Buffer menggunakan java.util.Vector class sehingga buffer mempunyai kapasitas tak terhingga. Dan send() dan read() method adalah nonblocking. Ketika produser memproduksi suatu item, item tersebut diletakkan ke mailbox melalui send() method. Konsumer menerima item dari mailbox menggunakan receive() method. Karena receive() nonblocking, consumer harus mengevaluasi nilai dari Object yang direturn dari receive(). Jika null, mailbox kosong. import java.util.*; public class Producer extends Thread { private MessageQueueueue mbox; public Producer( MessageQueueueue m ) { mbox = m; } public void run() { Date message; while ( true ) { int sleeptime = ( int ) ( Server.NAP_TIME * Math.random() ); System.out.println( "Producer sleeping for " + sleeptime + " seconds" ); try { Thread.sleep(sleeptime*1000); } catch( InterruptedException e ) {} message = new Date(); System.out.println( "Producer produced " + message ); mbox.send( message ); } } }

23

Bab 3. Proses dan Penjadwalan import java.util.*; public class Consumer extends Thread { private MessageQueueueue mbox; public Consumer( MessageQueueueue m ) { mbox = m; } public void run() { Date message; while ( true ) { int sleeptime = ( int ) ( Server.NAP_TIME * Math.random()); System.out.println("Consumer sleeping for " + sleeptime + " seconds" ); try { Thread.sleep( sleeptime * 1000 ); } catch( InterruptedException e ) {} message = ( Date ) mbox.receive(); if ( message != null ) System.out.println("Consumer consume " + message ); } } }

Kita memiliki dua aktor di sini, yaitu Produser dan Konsumer. Produser adalah thread yang menghasilkan waktu (Date) kemudian menyimpannya ke dalam antrian pesan. Produser juga mencetak waktu tersebut di layer (sebagai umpan balik bagi kita). Konsumer adalah thread yang akan mengakses antrian pesan untuk mendapatkan waktu (date) itu dan tak lupa mencetaknya di layer. Kita menginginkan supaya konsumer itu mendapatkan waktu sesuatu dengan urutan sebagaimana produser menyimpan waktu tersebut. Kita akan menghadapi salah satu dari dua kemungkinan situasi di bawah ini :

•

Bila p1 lebih cepat dari c1, kita akan memperoleh output sebagai berikut : . . . Consumer consume Wed May 07 14:11:12 ICT 2003 Consumer sleeping for 3 seconds Producer produced Wed May 07 14:11:16 ICT 2003 Producer sleeping for 4 seconds // p1 sudah mengupdate isi mailbox waktu dari Wed May 07 // 14:11:16 ICT 2003 ke Wed May 07 14:11:17 ICT 2003, // padahal c1 belum lagi mengambil waktu Wed May 07 14:11:16 Producer produced Wed May 07 14:11:17 ICT 2003 Producer sleeping for 4 seconds Consumer consume Wed May 07 14:11:17 ICT 2003 Consumer sleeping for 4 seconds // Konsumer melewatkan waktu Wed May 07 14:11:16 . . .

24


Bila p1 lebih lambat dari c1, kita akan memperoleh keluaran seperti berikut : . . . Producer produced Wed May 07 14:11:11 ICT 2003 Producer sleeping for 1 seconds Consumer consume Wed May 07 14:11:11 ICT 2003 Consumer sleeping for 0 seconds // c1 sudah mengambil isi dari mailbox, padahal p1 belum // lagi megupdate isi dari mailbox dari May 07 14:11:11 // ICT 2003 ke May 07 14:11:12 ICT 2003, c1 mendapatkan // waktu Wed May 07 14:11:11 ICT 2003 dua kali. Consumer consume Wed May 07 14:11:11 ICT 2003 Consumer sleeping for 0 seconds Producer sleeping for 0 seconds Producer produced Wed May 07 14:11:12 ICT 2003 . . .

Situasi di atas dikenal dengan race conditions. Kita dapat menghindari situasi itu dengan mensinkronisasikan aktivitas p1 dan c1 (sehubungan dengan akses mereka ke mailbox. Proses tersebut akan didiskusikan pada chapter yang akan datang (chapter 5).

3.4.1.6. Mailbox import java.util.*; public class MessageQueue { private Vector q; public MessageQueue() { q = new Vector(); } // Mengimplementasikan pengiriman nonblocking public void send( Object item ) { q.addElement( item ); } // Mengimplementasikan penerimaan nonblocking public Object receive() { Object item; if ( q.size() == 0 ) { return null; } else { item = q.firstElement(); q.removeElementAt(0); return item;

25

Bab 3. Proses dan Penjadwalan } } }

1. Menunggu sampai batas waktu yang tidak dapat ditentukan sampai terdapat ruang kosong pada mailbox. 2. Menunggu paling banyak n milidetik. 3. Tidak menunggu, tetapi kembali (return) secepatnya. 4. Satu pesan dapat diberikan kepada sistem operasi untuk disimpan, walaupun mailbox yang dituju penuh. Ketika pesan dapat disimpan pada mailbox, pesan akan dikembalikan kepada pengirim(sender). Hanya satu pesan kepada mailbox yang penuh yang dapat diundur (pending) pada suatu waktu untuk diberikan kepada thread pengirim.

3.4.2. Client/Server System Dengan makin berkembangnya teknologi jaringan komputer, sekarang ini ada kecenderungan sebuah sistem yang bekerja sama menggunakan jaringan. Dalam topik ini akan kita bahas beberapa metoda komunikasi antar proses yang melibatkan jaringan komputer.

3.4.2.1. Socket Socket adalah sebuah endpoint untuk komunikasi didalam jaringan. Sepasang proses atau thread berkomunikasi dengan membangun sepasang socket, yang masing-masing proses memilikinya. Socket dibuat dengan menyambungkan dua buah IP Address melalui port tertentu. Secara umum socket digunakan dalam client/server system, dimana sebuah server akan menunggu client pada port tertentu. Begitu ada client yang mengkontak server maka server akan menyetujui komunikasi dengan client melalui socket yang dibangun. 3.4.2.1.1. Server dan Thread Pada umumnya sebuah server melayani client secara konkuren, oleh sebab itu dibutuhkan thread yang masing-masing thread melayani clientnya masing-masing. Jadi server akan membentuk thread baru begitu ada koneksi dari client yang diterima (accept) Server menggunakan thread apabila client melakukan koneksi, sehingga server memiliki tingkat reabilitas yang tinggi. Pada sistem yang memiliki banyak pemakai sekaligus thread mutlak dibutuhkan, karena setiap pemakai sistem pasti menginginkan respon yang baik dari server.

26

Bab 3. Proses dan Penjadwalan 3.4.2.1.2. Java Socket Java menyediakan dua buah tipe socket yang berbeda dan sebuah socket spesial. Semua soket ini tersedia dalam paket jaringan, yang merupakan paket standar java. Berikut ini soket yang disediakan oleh java : •

Connection-Oriented (TCP) socket, yang diimplementasikan pada kelas java.net.Socket

•

Connectionless Socket (UDP), yang diimplentasikan oleh kelas java.net.DatagramSocket

•

Dan yang terakhir adalah java.net.MulticastSocket, yang merupakan perluasan (extended) dari Socket UDP. Tipe socket ini memiliki kemampuan untuk mengirim pesan kebanyak client sekaligus (Multicast), sehingga baik digunakan pada sistem yang memiliki jenis layanan yang sama.

... public WebServer(int port, String docRoot) throws IOException { this.docRoot = new File(docRoot); if(!this.docRoot.isDirectory()) { throw new IOException(docRoot + " bukan direktori."); } System.out.println("Menghidupkan Web server "); System.out.println("port : " + port); System.out.println("docRoot : " + docRoot); try { serverSocket = new ServerSocket(port); } catch(IOException ioe) { System.out.println("Port sudah digunakan"); System.exit(1); } }

public void run() { while(true) { try{ System.out.println("Menanti connection ... "); Socket socket = serverSocket.accept(); String alamatClient = socket.getInetAddress().getHostAddress(); System.out.println("Menangkap connection dari " + alamatClient); InputStream inputStream = socket.getInputStream(); InputStreamReader inputStreamReader = new InputStreamReader(inputStream); BufferedReader bufferedReader = new BufferedReader(inputStreamReader); OutputStream outputStream = socket.getOutputStream(); ...

27


Potongan kode diatas memperlihatkan teknik yang digunakan oleh java untuk membuka socket (pada kasus ini server socket). Selanjutnya server dapat berkomunikasi dengan clientnya menggunakan InputStream untuk menerima pesan dan OutputStream untuk mengirim pesan.

3.4.2.1.3. RPC (Remote Procedure Call) Remote Procedure Call (RPC) adalah sebuah metoda yang memungkinkan kita untuk mengakses sebuah prosedur yang berada di komputer lain. Untuk bisa melakukan ini sebuah komputer (server) harus menyediakan layanan remote prosedur. Pendekatan yang dilakuan adalah, sebuah server membuka socket, menunggu client yang meminta proseduryang disediakan oleh server. Remote Procedure Call masih menggunakan cara primitive dalam pemrograman, yaitu menggunakan paradigma procedural programming. Hal itu membuat kita sulit ketika menyediakan banyak remote procedure. RPC menggunakan soket untuk berkomunikasi dengan proses lainnya. Pada beberapa sistem (Seperti SUN) RPC secara default sudah terinstall kedalam sistemnya, biasanya RPC ini digunakan untuk administrasi sistem. Sehingga seorang administrator jaringan bisa mengakses sistemnya dan memanajemen sistemnya dari mana saja, selama sistemnya terhubung kejaringan.

3.4.2.1.4. Java RMI Pendekatan kedua yang akan kita bahas adalah RMI (Remote Method Invocation), sebuah teknik pemanggilan method remote yang lebih secara umum lebih baik daripada RPC. RMI menggunakan paradigma pemrograman berorientasi objek (OOP).Dengan RMI memungkinkan kita untuk mengirim objek sebagai parameter dari remote method. Dengan dibolehkannya program java memanggil method pada remote objek, RMI membuat user dapat mengembangkan aplikasi java yang terdistribusi pada jaringan Untuk membuat remote method bisa diakses RMI mengimplementasikan remote object menggukan stub dan skleton. Stub bertindak sebagai proxy disisi client, yaitu yang menghubungkan client dengan skleton yang berada disisi server. Stub yang ada disisi client bertanggung jawab untuk membungkus nama method yang akan diakses, dan parameternya, hal ini biasa dikenal dengan marshalling. Stub mengirim paket yang sudah dibungkus ini ke server dan akan di buka (unmarshalling) oleh skleton. Skleton akan menerima hasil keluaran yang telah diproses oleh method yang dituju, lalu akan kembali dibungkus (marshal) dan dikirim kembali ke client yang akan diterima oleh stub dan kembali dibuka paketnya (unmarshall). 3.4.2.1.4.1. Pembuatan Remote Objek Untuk membuat remote objek kita harus mendefinisikan semua method yang akan kita sediakan pada jaringan, setelah itu dapat digunakan RMI compiler untuk membuat stub dan skleton. Setelah itu kita harus mem-binding remote objek yang kita sediakan kedalam sebuah RMI registry. Setelah itu client dapat mengakses semua remote method yang telah kita sediakan menggunkan stub yang telah dicompile menggunakan RMI compiler terebut.

28

Bab 3. Proses dan Penjadwalan 3.4.2.1.4.2. Akses ke Remote Objek Sekali objek didaftarkan ke server, client dapat mengakses remote object dengan menjalankan Naming.lookup() method. RMI menyediakan url untuk pengaksesan ke remote objek yaitu rmi://host/objek, dimana host adalah nama server tempat kita mendaftarkan remote objek dan objek adalah parameter yang kita gunakan ketika kita memanggil method Naming.rebind(). Client juga harus menginstall RMISecurityManager untuk memastikan keamanan client ketika membuka soket kejaringan. Java memilki sistem security yang baik sehingga user dapat lebih nyaman dalam melakukan komunikasi pada jaringan. Selain itu java sudah mendukung pemorograman berorientasi object, sehingga pengembangan software berskala besar sangat dimungkinkan dilakukan oleh java. RMI sendiri merupakan sistem terdistribusi yang dirancang oleh SUN pada platfrom yang spesifik yaitu Java, apabila anda tertarik untuk mengembangkan sistem terdistribusi yang lebih portable dapat digunakan CORBA sebagai solusi alternatifnya.

3.5. Konsep Thread 3.5.1. Apa itu Thread Thread adalah unit dasar dari penggunaan CPU, thread mengandung Thread ID, program counter , register set , dan stack . Sebuah Thread berbagi code section , data section , dan sumber daya sistem operasi dengan Thread lain yang dimiliki oleh proses yang sama. Thread juga sering disebut lightweight process . Sebuah proses tradisional atau heavyweight process mempunyai thread tunggal yang berfungsi sebagai pengendali. Perbedaan antara proses dengan thread tunggal dengan proses dengan thread yang banyak adalah proses dengan thread yang banyak dapat mengerjakan lebih dari satu tugas pada satu satuan waktu

29

Bab 3. Proses dan Penjadwalan Gambar 3-8. Thread

Banyak software yang berjalan pada PC modern didesain secara multithreading . Sebuah aplikasi biasanya diimplementasi sebagai proses yang terpisah dengan beberapa thread yang berfungsi sebagai pengendali. Contohnya sebuah web browser mempunyai thread untuk menampilkan gambar atau tulisan sedangkan thread yang lain berfungsi sebagai penerima data dari network. Kadang kala ada situasi dimana sebuah aplikasi diperlukan untuk menjalankan beberapa tugas yang serupa. Sebagai contohnya sebuah web server bisa mempunyai ratusan klien yang mengaksesnya secara concurrent . Kalau web server berjalan sebagai proses yang hanya mempunyai thread tunggal maka ia hanya bisa melayani satu klien pada pada satu satuan waktu. Bila ada klien lain yang ingin mengajukan permintaan maka ia harus menunggu sampai klien sebelumnya selesai dilayani. Solusinya adalah dengan membuat web server menjadi multithreading . Dengan ini maka sebuah web server akan membuat thread yang akan mendengar permintaan klien, ketika permintaan lain diajukan maka web server akan menciptakan thread lain yang akan melayani permintaan tersebut. Java mempunyai pengunaan lain dari thread. Perlu dikeahui bahwa java tidak mempunyai konsep asynchronous . Sebagai contohnya kalau program java mencoba untuk melakukan koneksi ke server maka ia akan berada dalam keadaan block state sampai koneksinya jadi ( bisa dibayangkan apa yang terjadi apabila servernya mati ). Karena java tidak memiliki konsep asynchronous maka solusinya adalah dengan membuat thread yang mencoba untuk melakukan koneksi ke server dan thread lain yang pertamanya tidur selamabeberap waktu ( misalnya 60 detik ) kemudian bangun. Ketika waktu tidurnya habis maka ia akan bangun dan memeriksa apakah thread yang melakukan koneksi ke server masih mencoba untuk melakukan koneksi ke server, kalau thread tersebut masih dalam keadaan mencoba untuk melakukan koneksi ke server maka ia akan melakukan interrupt dan mencegah thread tersebut untuk mencoba melakukan koneksi ke server.

3.5.2. Keuntungan Thread Keuntungan dari program yang multithrading dapat dipisah menjadi empat kategori :

30

Bab 3. Proses dan Penjadwalan 1. Responsi : Membuat aplikasi yang interaktif menjadi multithreading dapat membuat sebuah program terus berjalan meskipun sebagian dari program tersebut diblok atau melakukan operasi yang panjang, karena itu dapat meningkatkan respons kepada pengguna. Sebagai contohnya dalam web browser yang multithreading , sebuah thread dapat melayani permintaan pengguna sementara thread lain berusaha menampilkan image. 2. Berbagi sumber daya : thread berbagi memori dan sumber daya dengan thread lain yang dimiliki oleh proses yang sama. Keuntungan dari berbagi kode adalah mengijinkan sebuah aplikasi untuk mempunyai beberapa thread yang berbeda dalam lokasi memori yang sama. 3. Ekonomi : dalam pembuatan sebuah proses banyak dibutuhkan pengalokasian memori dan sumber daya. Alternatifnya adalah dengan penggunaan thread, karena thread berbagi memori dan sumber daya proses yang memilikinya maka akan lebih ekonomis untuk membuat dan context switch thread. Akan susah untuk mengukur perbedaan waktu antara proses dan thread dalam hal pembuatan dan pengaturan, tetapi secara umum pembuatan dan pengaturan proses lebih lama dibandingkan thread. Pada Solaris, pembuatan proses lebih lama 30 kali dibandingkan pembuatan thread, dan context switch proses 5 kali lebih lama dibandingkan context switch thread. 4. Utilisasi arsitektur multiprocessor : Keuntungan dari multithreading bisa sangat meningkat pada arsitektur multiprocessor , dimana setiap thread dapat berjalan secara pararel di atas processor yang berbeda. Pada arsitektur processor tunggal, CPU menjalankan setiap thread secara bergantian tetapi hal ini berlangsung sangat cepat sehingga menciptakan ilusi pararel, tetapi pada kenyataannya hanya satu thread yang dijalankan CPU pada satu-satuan waktu( satu -satuan waktu pada CPU biasa disebut time slice atau quantum ).

3.5.3. User dan Kernel Threads

User Thread User thread didukung diatas kernel dan diimplementasi oleh thread library pada user level. Library meneyediakan fasilitas untuk pembuatan thread, penjadwalan thread, dan manajemen thread tanpa dukungan dari kernel. Karena kernel tidak menyadari user-level thread maka semua pembuatan dan penjadwalan thread dilakukan di user space tanpa intervensi dari kernel. Oleh karena itu, user -level thread biasanya cepat untuk dibuat dan diatur. Tetapi user thread mempunyai kelemahan yaitu apabila kernelnya merupakan thread tunggal maka apabila 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.

Kernel Thread Kernel thread didukung langsung oleh sistem operasi. Pembuatan, penjadwalan, dan manajeman thread dilakukan oleh kernel pada kernel space . Karena pengaturan thread dilakukan oleh sistem operasi maka pembuatan dan pengaturan kernel thread lebih lambat dibandingkan user thread. Keuntungannya adalah thread diatur oleh kernel, karena itu jika sebuah thread menjalankan blocking system call maka kernel bisa menjadwalkan thread lain di aplikasi untuk melakukan eksekusi. Keuntungan lainnya adalah pada

31

Bab 3. Proses dan Penjadwalan lingkungan multiprocessor , kernel bisa menjadwal thread-thread pada processor yang berbeda. Contoh sistem operasi yang mendukung kernel thread adalah Windows NT, Solaris, Digital UNIX.

3.5.4. Multithreading Models

Many-to-One Model Many-to-One model memetakan banyak user-level thread ke saru kernel thread. Pengaturan thread dilakukan di user space, oleh karena itu ia efisien tetapi ia mempunyai kelemahan yang sama dengan user thread. Selain itu karena hanya satu thread yang bisa mengakses thread pada suatu waktu maka multiple thread tidak bisa berjalan secara pararel pada multiprocessor . User-level thread yang diimplementasi pada sistem operasi yang tidak mendukung kernel thread menggunakan Many-to-One model. Gambar 3-9. Many-To-One

One-to-One Model One-to-One model memetakan setiap user thread ke kernel thread. Ia menyediakan lebih banyak concurrency dibandingkan Many-to-One model. Keuntungannya sama dengan keuntungan kernel thread. Kelemahannya model ini adalah setiap pembuatan user thread membutuhkan pembuatan kernel thread. Karena pembuatan thread bisa menurunkan performa dari sebuah aplikasi maka implmentasi dari model ini membatasi jumlah thread yang dibatasi oleh sistem. Contoh sistem operasi yang mendukung One-to-One model adalah Windows NT dan OS/2.

32

Bab 3. Proses dan Penjadwalan Gambar 3-10. One-To-One

Many-to-Many Model Many-to-many model multiplexes banyak user-level thread ke kernel thread yang jumlahnya lebih kecil atau sama banyaknya dengan user-level thread. Jumlah kernel thread bisa spesifik untuk sebagian aplikasi atau sebagian mesin. Many-to-One model mengijinkan developer ntuk membuat user thread sebanyak yang ia mau tetapi concurrency tidak dapat diperoleh karena hanya satu thread yang bisa dijadwal oleh kernel pada suatu waktu. One-to-One menghasilkan concurrency yang lebih tetapi developer harus hati-hati untuk tidak menciptakan terlalu banyak thread dalam suatu aplikasi( dalam beberapa hal, developer hanya bisa membuat thread dalam jumlah yang terbatas ). Many-to-Many model tidak menderita kelemahan dari 2 model di atas. Developer bisa membuat user thread sebanyak yang diperlukan, dan kernel thread yang bersangkutan bisa bejalan secara pararel pada multiprocessor . Dan juga ketika suatu thread menjalankan blocking system call maka kernel dapat menjadwalkan thread lain untuk melakukan eksekusi. Contoh sistem operasi yang mendukung model ini adalah Solaris, IRIX, dan Digital UNIX.

33

Bab 3. Proses dan Penjadwalan Gambar 3-11. Many-To-Many

3.5.5. Fork dan exec System Call Ada 2 kemungkinan dalam system UNIX jika fork dipanggil oleh salah satu thread dalam proses: 1. Semua thread diduplikasi. 2. Hanya thread yang memanggil fork . Kalau thread memanggil exec System Call maka program yang dispesifikasi di parameter exec akan mengganti keseluruhan proses termasuk thread dan LWP. Penggunaan 2 versi dari fork diatas tergantung dari aplikasi. Kalau exec dipanggil seketika sesudah fork, maka duplikasi seluruh thread tidak dibutuhkan, karena program yang dispesifikasi di parameter exec akan mengganti seluruh proses. Pada kasus ini cukup hanya mengganti thread yang memanggil fork . Tetapi jika proses yang terpisah tidak memanggil exec sesudah fork maka proses yang terpisah tersebut hendaknya menduplikasi seluruh thread.

3.5.6. Cancellation Thread cancellation adalah tugas untuk memberhentikan thread sebelum ia menyelesaikan tugasnya. Sebagi contohnya jika dalam program java kita hendak mematikan JVM( Java Virtual Machine ) maka sebelum JVM-nya dimatikan maka seluruh thread yang berjalan dihentikan terlebuh dahulu. Thread yang akan diberhentikan biasa disebut target thread. Pemberhentian target thread bisa terjadi melalui 2 cara yang berbeda : 1. Asynchronous cancellation : suatu thread seketika itu juga memberhentikan target thread.

34

Bab 3. Proses dan Penjadwalan 2. Defered cancellation : target thread secara perodik memeriksa apakah dia harus berhenti, cara ini memperbolehkan targetthread untuk memberhentikan dirinya sendiri secara terurut. Hal yang sulit dari pemberhentian thread ini adalah ketika terjadi situasi dimana sumber daya sudah dialokasikan untuk thread yang akan diberhentikan. Selain itu kesulitan lain adalah ketika thread yang diberhentikan sedang meng-update data yang ia bagi dengan thread lain. Hal ini akan menjadi masalah yang sulit apabila digunakan asynchronous cancellation . Sistem operasi akan mengambil kembali sumber daya dari thread yang diberhentikan tetapi seringkali sistem operasi tidak mengambil kembali semua sumber daya dari thread yang diberhentikan. Alternatifnya adalah dengan menggunakan Deffered cancellation . Cara kerja dari deffered cancellation adalah dengan menggunakan 1 thread yang berfungsi sebagai pengindikasi bahwa target thread hendak diberhentikan. Tetapi pemberhentian hanya akan terjadi jika target thread memeriksa apakah ia harus berhenti atau tidak. Hal ini memperbolehkan thread untuk memeriksa apakah ia harus berhenti pada waktu dimana ia bisa diberhentikan secara aman yang aman. Pthread merujuk tersebut sebagai cancellation points . Pada umumnya sistem operasi memperbolehkan proses atau thread untuk diberhentikan secara asynchronous . Tetapi Pthread API menyediakan deferred cancellation . Hal ini berarti sistem operasi yang mengimplementasikan Pthread API akan mengijinkan deferred cancellation .

3.5.7. Penanganan Sinyal Sebuah sinyal digunakan di sistem UNIX untuk notify sebuah proses kalau suatu peristiwa telah terjadi. Sebuah sinyal bisa diterima secara synchronous atau asynchronous tergantung dari sumber dan alasan kenapa peristiwa itu memberi sinyal. Semua sinyal( asynchronous dan synchronous ) mengikuti pola yang sama : 1. Sebuah sinyal dimunculkan oleh kejadian dari suatu persitiwa. 2. Sinyal yang dimunculkan tersebut dikirim ke proses. 3. Sesudah dikirim, sinyal tersebut harus ditangani. Contoh dari sinyal synchronous adalah ketika suatu proses melakukan pengaksesan memori secarai ilegal atau pembagian dengan nol, sinyal dimunculkan dan dikirim ke proses yang melakukan operasi tersebut. Contoh dari sinyal asynchronous misalnya kita mengirimkan sinyal untuk mematikan proses dengan keyboard( alt-f4 ) maka sinyal asynchronous dikirim ke proses tersebut. Jadi ketika suatu sinyal dimunculkan oleh peristiwa diluar proses yang sedang berjalan maka proses tersebut menerima sinyal tersebut secara asynchronous . Setiap sinyal bisa ditangani oleh salah satu dari 2 penerima sinyal : 1. Penerima sinyal yang merupakan set awal dari sistem operasi. 2. Penerima sinyal yang didefinisikan sendiri ole user. Penanganan sinyal pada program yang hanya memakai thread tunggal cukup mudah yaitu hanya dengan mengrimkan sinyal ke prosesnya. Tetapi mengirimkan sinyal lebih rumit pada program yang multithreading , karena sebuah proses bisa memiliki beberapa thread. Secara umum ada 4 pilihan kemana sinyal harus dikirim :

35

Bab 3. Proses dan Penjadwalan 1. Mengirimkan sinyal ke thread yang dituju oleh sinyal tersebut. 2. Mengirimkan sinyal ke setiap thread pada proses tersebut. 3. Mengirimkan sinyal ke thread tertentu dalam proses. 4. 4. Menugaskan thread khusus untuk menerima semua sinyal yang ditujukan pada proses. Cara untuk mengirimkan sebuah sinyal tergantung dari tipe sinyal yang dimunculkan. Sebagai contoh sinyal synchronous perlu dikirimkan ke thread yang memunculkan sinyal tersebut bukan thread lain pada proses tersebut. Tetapi situasi dengan sinyal asynchronous menjadi tidak jelas. Beberapa sinyal asynchronous seperti sinyal yang berfungsi untuk mematikan proses ( contoh : alt-f4 ) harus dikirim ke semua thread. Beberapa versi UNIX yang multithreading mengijinkan thread menerima sinyal yang akan ia terima dan menolak sinyal yang akan ia tolak. Karena itu sinyal asynchronouns hanya dikirimkan ke thread yang tidak memblok sinyal tersebut. Solaris 2 mengimplementasikan pilihan ke-4 untuk menangani sinyal. Windows 2000 tidak menyediakan fasilitas untuk mendukung sinyal, sebagai gantinya Windows 2000 menggunakan asynchronous procedure calls( APCs ) . Fasilitas APC memperbolehkan user thread untuk memanggil fungsi tertentu ketika user thread menerima notifikasi peristiwa tertentu.

3.5.8. Thread Pools Pada web server yang multithreading ada 2 masalah yang timbul : 1. Ukuran waktu yang diperlukan untuk menciptakan thread untuk melayani permintaan yang diajukan terlebih pada kenyataannya thread dibuang ketika ia seketika sesudah ia menyelesaikan tugasnya. 2. Pembuatan thread yang tidak terbatas jumlahnya dapat menurunkan performa dari sistem. Solusinya adalah dengan penggunaan Thread Pools, cara kerjanya adalah dengan membuat beberapa thread pada proses startup dan menempatkan mereka ke pools , dimana mereka duduk diam dan menunggu untuk bekerja. Jadi ketika server menerima permintaan maka maka ia akan membangunkan thread dari pool dan jika threadnya tersedia maka permintaan tersebut akan dilayani. Ketika thread sudah selesai mengerjakan tugasnya maka ia kembali ke pool dan menunggu pekerjaan lainnya. Bila tidak thread yang tersedia pada saat dibutuhkan maka server menunggu sampai ada 1 thread yang bebas. Keuntungan thread pool : 1. Biasanya lebih cepat untuk melayani permintaan dengan thread yang ada dibanding dengan menunggu thread baru dibuat. 2. Thread pool membatasi jumlah thread yang ada pada suatu waktu. Hal ini pentingpada sistem yang tidak bisa mendukung banyak thread yang berjalan secara concurrent . Jumlah thread dalam pool bisa tergantung dari jumlah CPU dalam sistem, jumlah memori fisik, dan jumlah permintaan klien yang concurrent .

36


3.5.9. Hal-Hal Lainnya dari Thread 3.5.9.1. Thread-Specific Data Thread yang dimiliki oleh suatu proses memang berbagi data tetapi setiap thread mungkin membutuhkan duplikat dari data tertentu untuk dirinya sendiri dalam keadaan tertentu. Data ini disebut thread -specific data.

3.5.9.2. Pthreads Pthreads merujuk kepada POSIX standard( IEEE 1003.1 c ) mendefinisikan sebuah API untuk pembuatan thread dan sinkronisasi. Pthreads adalah spesifikasi untuk thread dan bukan merupakan suatu implementasi. Desainer sistem operasi boleh mengimplementasikan spesifikasi tersebut dalam berbagai cara yang mereka inginkan. Secara umum Libraries yang mengimplementasikan Pthreads dilarang pada sistem berbasis UNIX seperti Solaris 2. Sistem operasi Windows secara umum belum mendukung Pthreads, walaupun versi shareware -nya sudah ada di domain publik.

3.6. Ilustrasi Thread dengan Linux dan Java Dewasa ini, banyak sistem operasi yang telah mendukung proses multithreading. Setiap sistem operasi memiliki konsep tersendiri dalam mengimplementasikannya ke dalam sistem.

3.6.1. Thread dengan Linux Kernel Linux mulai menggunakan thread pada versi 2.2. Thread dalam Linux dianggap sebagai task , seperti halnya proses. Kebanyakan sistem operasi yang mengimplementasikan multithreading menjalankan sebuah thread terpisah dari proses. Linus Torvalds mendefinisikan bahwa sebuah thread adalah Context of Execution (COE), yang berarti bahwa hanya ada sebuah Process Control Block (PCB) dan sebuah penjadwal yang diperlukan. Linux tidak mendukung multithreading , struktur data yang terpisah, atau pun rutin kernel. Linux menyediakan dua macam system call , yaitu fork dan clone. fork memiliki fungsi untuk menduplikasi proses dimana proses anak yang dihasilkan bersifat independent. clone memiliki sifat yang mirip dengan fork yaitu sama-sama membuat duplikat dari proses induk. Namun demikian, selain membuat proses baru yang terpisah dari proses induk, clone juga mengizinkan terjadinya proses berbagi ruang alamat antara proses anak dengan proses induk, sehingga proses anak yang dihasilkan akan sama persis dengan proses induknya. Setiap proses memiliki struktur data yang unik. Namun demikian, proses-proses di Linux hanya menyimpan pointer-pointer ke struktur data lainnya dimana instruksi disimpan, sehingga tidak harus menyimpan instruksi ke setiap struktur data yang ada. Hal ini menyebabkan context switch antar proses di Linux menjadi lebih cepat. Ketika fork dieksekusi, sebuah proses baru dibuat bersamaan dengan proses penyalinan struktur data dari proses induk. Ketika clone dieksekusi, sebuah proses baru juga dibuat, namun proses tersebut tidak

37

Bab 3. Proses dan Penjadwalan menyalin struktur data dari proses induknya. Proses baru tersebut hanya menyimpan pointer ke struktur data proses induk. Oleh karena itu, proses anak dapat berbagi ruang alamat dan sumber daya dengan proses induknya. Satu set flag digunakan untuk mengindikasikan seberapa banyak kedua proses tersebut dapat berbagi. Jika tidak ada flag yang ditandai, maka tidak ada sharing, sehingga clone berlaku sebagai fork. Jika kelima flag ditandai, maka proses induk harus berbagi semuanya dengan proses anak. Tabel 3-1. Tabel Flag dan Fungsinya Flag

Keterangan

CLONE_VM

Berbagi data dan Stack

CLONE_FS

Berbagi informasi sistem berkas

CLONE_FILES

Berbagi berkas

CLONE_SIGHAND

Berbagi sinyal

CLONE_PID

Berbagi PID dengan proses induk

3.6.2. Thread dengan Java Sistem operasi mendukung thread pada tingkat kernel atau tingkat pengguna. Java merupakan salah satu dari sedikit bahasa pemrograman yang mendukung thread di tingkat bahasa untuk pembuatan dan manajemen thread. Karena thread dalam Java diatur oleh Java Virtual Machine (JVM), tidak dengan user level library ataupun kernel, sulit mengelompokkan thread di Java apakah di tingkat pengguna atau kernel. Setiap program dalam Java memiliki minimal sebuah thread, yaitu main thread yang merupakan single-thread tersendiri di JVM. Java juga menyediakan perintah untuk membuat dan memodifikasi thread tambahan sesuai kebutuhan di program.

3.6.2.1. Pembuatan Thread Ada dua cara untuk membuat thread dalam Java. Pertama, thread dapat dibuat secara eksplisit dengan cara membuat objek baru dari class yang telah meng- extends class Thread yang menyebabkan class tersebut mewarisi method - method dan field dari class super. Dalam kasus ini, sebuah class hanya bisa meng- extends sebuah class. Keterbatasan ini dapat diatasi dengan cara kedua yaitu meng- implements interface Runnable, yang merupakan cara yang paling sering digunakan untuk membuat thread, sehingga class tersebut dapat meng- extends class lain. Sebuah objek yang berasal dari subkelas Thread dapat dijalankan sebagai thread pengontrol yang terpisah dalam JVM. Membuat objek dari class Thread tidak akan membuat thread baru. Hanya dengan method start thread baru akan terbentuk. Memanggil method start untuk membuat objek baru akan mengakibatkan 2 hal, yaitu: 1. Pengalokasian memori dan menginisialisasikan sebuah thread baru dalam JVM. 2. Memanggil method run, yang sudah di- override, membuat thread dapat dijalankan oleh JVM

38

Bab 3. Proses dan Penjadwalan (Catatan: Method run dijalankan jika method start dipanggil. Memanggil method run secara langsung hanya menghasilkan sebuah single-thread tambahan selain main thread) Contoh pembuatan thread dengan membuat objek baru dari class yang meng-extends class Thread: public class TestThread1 { public static void main (String[] args) { BuatThread1 b = new BuatThread1(); for(int i = 0; i < angka; i++) { b.start(); } } } class BuatThread1 extends Thread { public void run() { try { System.out.println("Thread baru dibuat."); } catch (InterruptedException e) { } } }

3.6.2.2. JVM dan Host Operating System Implementasi umum dari JVM adalah di atas sebuah host operating system . Hal ini memungkinkan JVM untuk menyembunyikan implementasi detail dari sistem operasi tempat JVM dijalankan dan menyediakan lingkungan abstrak dan konsisten yang memungkinkan program-program Java untuk beroperasi di atas platform apa pun yang mendukung JVM. Spesifikasi untuk JVM tidak mengindikasikan bagaimana thread-thread Java dipetakan ke sistem operasi tempat JVM dijalankan, melainkan menyerahkan keputusan tersebut kepada implementasi tertentu dari JVM. Windows 95/98/NT/2000 menggunakan model One-to-One , sehingga setiap thread Java untuk JVM pada sistem operasi tersebut dipetakan kepada sebuah kernel thread . Solaris 2 awalnya mengimplementasikan JVM menggunakan model Many-to-One (disebut Green Threads) . Akan tetapi, sejak JVM versi 1.1 dengan Solaris 2.6, mulai diimplementasikan menggunakan model Many-to-Many .

3.7. Penjadwal CPU Penjadwalan CPU adalah basis dari multi programming sistem operasi. Dengan men-switch CPU diantara proses. Akibatnya sistem operasi bisa membuat komputer produktif. Dalam bab ini kami akan mengenalkan tentang dasar dari konsep penjadwalan dan beberapa algoritma penjadwalan. Dan kita juga memaparkan masalah dalam memilih algoritma dalam suatu sistem.

39


3.7.1. Konsep Dasar Tujuan dari multi programming adalah untuk mempunyai proses berjalan secara bersamaan, unutk memaksimalkan kinerja dari CPU. Pada sistem prosesor tunggal, tidak pernah ada proses yang berjalan lebih dari satu. Bila ada proses yang lebih dari satu maka proses yang lain harus mengantri sampai cpu bebas proses. Ide dari multi porgamming sangat sederhana. Ketika sebuah proses dieksekusi maka proses yang lain harus menunggu sampai proses pertama selesai. Pada sistem komputer yang sederhana CPU akan banyak dalam posisi idle. Sehingga waktu CPU ini sangat terbuang,. Akan tetapi dengan multiprogamming, kita mencoba menggunakan waktu secara produktif. Beberapa proses di simpan di memori dalam satu waktu. Ketika suatu proses harus menuggu, Sistem operasi bisa saja akan menghentikan cpu dari suatu proses yang sedang diekseskusi dan memberikan sumberdaya kepada proses yang lainnya. Begitu seterusnya. Penjadwalan adalah fungsi dasar dari suatu sistem opersai. Hampir semua sumber komputer dijadwalkan sebelum digunakan. CPU salah satu sumber dari komputer yang penting yang menjadi sentral dari sentral penjadwalan di sistem operasi.

3.7.2. Siklus Burst CPU-I/O Keberhasilan dari penjadwalan CPU tergantung dari beberapa properti prosesor. Pengeksekusian dari proses tersebut terdiri atas siklus CPU ekskusi dan I/O Wait. Proses hanya akan bolak-balik dari dua state ini. Pengeksekusian proses dimulai dengan CPU Burst, setelah itu diikuti oleh I/O burst, kemudian CPU Burst lagi lalu I/O Burst lagi begitu seterusnya dan dilakukan secara bergiliran.Dan , CPU Burst terakhir, akan berakhir dengan permintaan sistem untuk mengakhiri pengeksekusian daripada melalui I/O Burst lagi. Kejadian siklus Burst akan dijelaskan pada Gambar 3-12

40

Bab 3. Proses dan Penjadwalan Gambar 3-12. Siklus Burst

Durasi dari CPU bust ini telah diukur secara ekstensif, walaupun mereka sangat berbeda dari proses ke prose. Mereka mempunyai frekeunsi kurva yang sama seperti yang diperlihatkan pada Gambar 3-13

41

Bab 3. Proses dan Penjadwalan Gambar 3-13.

3.7.3. Penjadwalan CPU Kapanpun CPU menjadi idle, sistem opersai harus memilih salah satu proses untuk masuk kedalam antrian ready (siap) untuk dieksekusi. Pemilihan tersebut dilakukan oleh penjadwal short term. Penjadwalan memilih dari sekian proses yang ada di memori yang sudah siap dieksekusi, den mengalokasikan CPU untuk mengeksekusinya

3.7.4. Penjadwalan Preemptive Penjadwalan CPU mungkin akan dijalankan ketika proses : 1. Berubah dari running ke waiting state 2. Berubah dari running ke ready state 3. Berubah dari waiting ke ready 4. Terminates

42

Bab 3. Proses dan Penjadwalan Penjadwalan dari no 1 sampai 4 non premptive sedangkan yang lain premptive. Dalam penjadwalan nonpreemptive sekali cpu telah dialokasikan untuk sebuah proses , maka tidak bisa di ganggu, penjadwalan model seperti ini digunakan oleh windows 3.x; windows 95 telah menggunakan penjadwalan preemptive.

3.7.5. Dispatcher Komponen yang lain yang terlibat dalam penjadwalan CPU adalan dispatcher. Dispatcher adalah modul yang memberikan kontrol CPU kepada proses yang fungsinya adalah : 1. Switching context 2. Switching to user mode 3. Lompat dari suatu bagian di porgam user untuk mengulang progam.

Dispatcher seharusnya secepat mungkin,

3.7.6. Kriteria Penjadwalan Algoritma penjadwalan CPU yang berbeda mempunyai property yang berbeda. Dalam memilih algoritma yang digunakan untuk situasi tertentu, kita harus memikirkan properti yang berbeda untuk algoritma yang berbeda. Banyak kriteria yang dianjurkan utnuk membandingkan penjadwalan CPU algoritma.

3.7.7. Penjadwalan Preemptive Kritria yang biasanya digunakan dalam memilh adalah : 1. CPU utilization : kita ingin menjaga CPU sesibuk mungkin. CPU utilization akan mempunyai range dari 0 ke 100 persen. Di sistem yang sebenarnya seharusnya ia mempunyai range dari 40 persen samapi 90 persen 2. Throughput : jika cpu sibuk mengeksekusi proses, jika begitu kerja telah dilaksanakan. Salah satu ukuran kerja adalah banyak proses yang diselesaikan per unit waktu, disebut througput. Untuk proses yang lama mungkin 1 proses per jam ; untuk proses yang sebentar mungkin 10 proses perdetik. 3. Turnaround time : dari sudur pandang proses tertentu, kriteria yang penting adalah berapa lama untuk mengeksekusi proses tersebut. Interval dari waktu yang dijinkan dengan waktu yang dibutuhkan untuk menyelesaikan sebuah prose disebut turn around time. Trun around time adalah jumlah periode untuk menunggu untuk bisa ke memori, menunggu di ready queue, eksekusi di CPU, dan melakukan I/O 4. Waiting time : algoritma penjadwalan cpu tidak mempengaruhi waktu untuk melaksanakan proses tersebut atau I/O; itu hanya mempengaruhi jumlah waktu yang dibutuhkan proses di antrian ready. Waiting time adalah jumlah periode menghabiskan di antrian ready.

43

Bab 3. Proses dan Penjadwalan 5. Response time : di sistem yang interaktif, turnaround time mungkin bukan waktu yang terbaik untuk kriteria. Sering sebuah proses bisa memproduksi output diawal, dan bisa meneruskan hasil yang baru sementara hasil yang sebelumnya telah diberikan ke user. Ukuran yang lain adalah waktu dari pengiriamn permintaan sampai respon yang pertama di berikan. Ini disebut response time, yaitu waktu untuk memulai memberikan respon, tetapi bukan waktu yang dipakai output untu respon tersebut.

Biasanya yang dilakukan adalah memaksimalkan CPU utilization dan throughput, dan minimalkan turnaround time, waiting time, dan response time dalam kasus tertentu kita mengambil rata-rata.

3.8. Algoritma Penjadwalan Proses yang belum mendapat jatah alokasi dari CPU akan mengantri di ready queue. Di sini algoritma diperlukan untuk mengatur giliran proses-proses tersebut. Berikut ini adalah algoritmanya

3.8.1. First-Come, First-Served Algoritma ini merupakan algoritma yang paling sederhana. Dari namanya, kita bisa menebak kalau algoritma ini akan mendahulukan proses yang lebih dulu datang. Jadi proses akan mengantri sesuai waktu kedatangannya. Kelemahan algoritma ini adalah waiting time rata-rata yang cukup lama. Sebagai contoh ; ada tiga algoritma yang datang berturut-turut. Algoritma pertama mempunyai burst time 7 milidetik, sedangkan yang kedua dan ketiga masing-masing 5 milidetik dan 1 milidetik. Waiting time proses pertama ialah 0 milidetik (proses pertama tak perlu menunggu). Waiting time proses kedua ialah 7 milidetik (menunggu proses pertama), dan yang ketiga 12 milidetik (menunggu proses pertama dan kedua). Jadi waiting time rata-rata sebesar (0+7+12)/3 = 6,33 milidetik. Bandingkan jika proses datang dengan urutan terbalik (yang terakhir datang pertama dan kebalikannya). Waiting time rata-ratanya hanya sebesar (0+1+6)/3 = 2,33 milidetik (jauh lebih kecil). Bayangngkan selisih yang mungkin terjadi jika beda burst time tiap proses sangat besar. Munculah istilah convoy effect , dimana proses lain menunggu satu proses besar mengembalikan sumber daya CPU. Tentu kemungkinan utilisasi CPU akan lebih baik jika proses yang lebih singkat didahulukan. Algoritma ini nonpreemptive . Setelah CPU dialokasikan ke suatu proses, hanya proses tersebut yang bisa mengambalikannya.

3.8.2. Shortest-Job First Algoritma ini mempunyai cara yang berbeda untuk mengatur ntrian di ready queue . Proses diatur menurut panjang CPU burst berikutnya ( lebih tepatnya shortest next CPU burst ). Waiting time rata-rata dari algoritma ini sangat kecil, sehingga layak disebut optimal. Perbandingan algoritma ini dengan algoritma pertama telah kita lihat di bagian sebelumnya ( shortest job first ), di mana proses yang memiliki CPU burst terkecil jika didahulukan akan mengurangi waiting time

44

Bab 3. Proses dan Penjadwalan rata-ratanya. Kelemahan algoritma ini yaitu kita tak pernah tahu secara pasti panjang CPU burst proses berikutnya. Kita hanya bisa mengira-ngira nilainya. Algoritma ini bisa merupakan preemptive atau nonpreemptive . Jika preemptive, jika ada proses datang dengan sisa CPU burst yang lebih kecil daripada yang sedang dieksekusi, maka proses tersebut akan menggantikan proses yang sedang dieksekusi. Contoh : 2 proses datang bersamaan dengan CPU burst masing-masing sebesar 4 dan 5 milidetik. Algoritma ini akan mengalokasikan CPU untuk proses yang memiliki CPU burst 4 milidetik, sementara satu lagi akan menunggu di ready queue . Baru 1 milidetik proses pertama dieksekusi, ada proses lain datang dengan besar CPU burst 2 milidetik. Alokasi CPU segera diberikan pada proses baru tersebut karena mempunyai sisa waktu terkecil yaitu 2 milidetik(proses yang dieksekusi mempunyai sisa waktu 3 milidetik karena telah mendapat alokasi CPU selama 1 milidetik), dan kedua proses yang datang pertama kembali menunggau di ready queue . Bandingkan waiting time rata-ratanya, yang nonpreemptive sebesar (0+4+9)/3 = 4,33 milidetik, dan yang preemptive sebesar ((3-1)+6+(1-1))/3 = 2,66 milidetik.

3.8.3. Priority Algoritma ini memberikan skala prioritas kepada tiap proses. Proses yang mendapat prioritas terbesar akan didahulukan. Skala diberikan dalam bentuk integer. Beberapa sistem menggunakan integer kecil untuk prioritas tertinggi, beberapa sistem menggunakan integer besar. Algoritma ini bisa preemptive maupun nonpreeemptive . Jika preemptive maka proses bisa diinterupsi oleh proses yang prioritasnya lebih tinggi. Kelemahan dari algoritma ini adalah proses dengan prioritas kecil bisa-bisa tidak akan mendapat jatah CPU. Hal ini bisa diatasi dengan aging , yaitu semakin lama menunggu, prioritas semakin tinggi.

3.8.4. Round-Robin Algoritma ini menggilir proses yang ada di antrian. Proses akan mendapat jatah sebesar time quantum . Jika time quantum nya habis atau proses sudah selesai CPU akan dialokasikan ke proses berikutnya. Tentu proses ini cukup adil karena tak ada proses yang diprioritaskan, semua proses mendapat jatah waktu yang sama dari CPU (1/n), dan tak akan menunggu lebih lama dari (n-1)/q. Algoritma ini sepenuhnya bergantung besarnya time quantum . Jika terlalu besar, algoritma ini akan sama saja dengan algoritma first-come first-served . Jika terlalu kecil, akan semakin banyak peralihan proses sehingga banyak waktu terbuang.

3.8.5. Multilevel Queue Algoritma ini mengelompokkan antrian dalam beberapa buah antrian. Antrian-antrian tersebut diberi prioritas.Antrian yang lebih rendah tak boleh mendapat alokasi selama ada antrian tinggi yang belum kebagian. Tiap antrian boleh memiliki algoritma yang berbeda. Kita juga bisa menjatah waktu CPU untuk tiap antrian. Semakin tinggi tingkatannya, semakin besar jatah waktu CPUnya.

45


3.8.6. Multilevel Feedback Queue Algoritma ini mirip sekali dengan algoritma Multilevel Queue . Perbedaannya ialah algoritma ini mengizinkan proses untuk pindah antrian. Jika suatu proses menyita CPU terlalu lama, maka proses itu akan dipindahkan ke antrian yang lebih rendah. Ini menguntungkan proses interaksi, karena proses ini hanya memakai waktu CPU yang sedikit. Demikian pula dengan proses yang menunggu terlalu lama. Proses ini akan dinaikkan tingkatannya. Biasanya prioritas tertinggi diberikan kepada proses dengan CPU burst terkecil, dengan begitu CPU akan terutilisasi penuh dan I/O bisa terus sibuk. Semakin rendah tingkatannya, panjang CPU burst proses juga semakin besar. Algoritma ini didefinisikan melalui beberapa parameter, antara lain : •

Jumlah antrian

•

Algoritma penjadwalan tiap antrian

•

Kapan menaikkan proses ke antrian yang lebih tinggi

•

Kapan menurunkan proses ke antrian yang lebih rendah

•

Antrian mana yang akan dimasuki proses yang membutuhkan

Dengan pendefinisian seperti tadi membuat algoritma ini sering dipakai. Karena algoritma ini mudah dikonfigurasi ulang supaya cocok dengan sistem. Tapi untuk mengatahui mana penjadwal terbaik, kita harus mengetahui nilai parameter tersebut.

3.9. Prioritas dan Multiprosesor Penjadwalan pada multiprosesor jelas lebih kompleks, karena kemungkinan masalah yang timbul jauh lebih banyak daripada prosesor tunggal.

3.9.1. Apa itu Prioritas Prioritas adalah suatu istilah yang digunakan untuk menentukan tingkat urutan atau hirarki suatu proses yang sedang masuk dalam ready queue .

3.9.2. Multiprosesor Mengacu pada buku Operating System Edisi ke-6 karya Silberschatz, sistem dengan prosesor jamak yang dimaksud adalah suatu sistem dimana prosesor-prosesornya identik. Dalam hal ini berarti tiap proses dapat masuk antrian manapun dari prosesor-prosesor yang ada. Yang patut diperhatikan, tiap prosesor dapat memilih proses apa saja yang ingin dijalankan dari ready queue . Dengan kata lain, prioritas proses ditentukan secara independen oleh masing-masing prosesor. Jadi salah satu prosesor bisa saja idle ketika ada proses yang sedang ditunda . Oleh karena itu, tiap prosesor harus di synchronize lebih dulu agar tidak ada dua prosesor atau lebih yang berebut mengeksekusi proses yang sama dan mengubah shared data . Sistem seperti ini dikenal juga dengan sebutan synchronous . Selain synchronous ,ada juga sistem lain

46

Bab 3. Proses dan Penjadwalan yang disebut asynchronous , yang juga dikenal dengan struktur " master-slave " dimana salah satu prosesor dialokasikan khusus untuk mengatur penjadwalan. Sedangkan prosesor yang lain ditujukan untuk mengkomputasikan proses yang telah dijadwalkan sebelumnya oleh master prosesor. Peningkatan dari sistem ini adalah mengalokasikan penjadwalan, pemrosesan I/O, dan kegiatan sistem lainnya kepada satu prosesor tertentu kepada master . Sedangkan prosesor yang lain hanya bertugas mengeksekusi user code .

3.10. Sistem Waktu Nyata Pada sub bab ini, kami akan mencoba sedikit menggambarkan fasilitas penjadualan yang dibutuhkan untuk mendukung komputasi real-time dengan bantuan sistem komputer. Suatu sistem komputasi dinamakan real-time jika sistem tersebut dapat mendukung eksekusi program/aplikasi dengan waktu yang memiliki batasan. Dengan kata lain, sistem real-time harus memenuhi kondisi berikut: 1. Batasan waktu: memenuhi deadline, artinya bahwa aplikasi harus menyelesaikan tugasnya dalam waktu yang telah dibatasi. 2. Dapat diprediksi: artinya bahwa sistem harus bereaksi terhadap semua kemungkinan kejadian selama kejadian tersebut bisa diprediksi. 3. Proses bersamaan: artinya jika ada beberapa proses yang terjadi bersamaan, maka semua deadline nya harus terpenuhi. Komputasi real-time ada 2 jenis, yaitu sistem Hard real-time dan sistem Soft real-time.

3.10.1. Sistem Hard Real-Time Sistem hard real-time dibutuhkan untuk menyelesaikan critical task dengan jaminan waktu tertentu. Jika kebutuhan waktu tidak terpenuhi, maka aplikasi akan gagal. Dalam definisi lain disebutkan bahwa kontrol sistem hard real-time dapat mentoleransi keterlambatan tidak lebih dari 100 mikro detik. Secara umum, sebuah proses di kirim dengan sebuah pernyataan jumlah waktu dimana dibutuhkan untuk menyelesaikan atau menjalankan I/O. Kemudian penjadual bisa menjamin proses untuk selesai atau menolak permintaan karena tidak mungkin dilakukan. Mekanisme ini dikenal dengan resource reservation. Oleh karena itu setiap operasi harus dijamin dengan waktu maksimum. Pemberian jaminan seperti ini tidak dapat dilakukan dalam sistem dengan secondary storage atau virtual memory , karena sistem seperti ini tidak dapat meramalkan waktu yang dibutuhkan untuk mengeksekusi suatu proses. Contoh dalam kehidupan sehari-hari adalah pada sistem pengontrol pesawat terbang. Dalam hal ini, keterlambatan sama sekali tidak boleh terjadi, karena dapat berakibat tidak terkontrolnya pesawat terbang. Nyawa penumpang yang ada dalam pesawat tergantung dari sistem ini, karena jika sistem pengontrol tidak dapat merespon tepat waktu, maka dapat menyebabkan kecelakaan yang merenggut korban jiwa.

3.10.2. Sistem Soft Real-Time Komputasi soft real-time memiliki sedikit kelonggaran. Dalam sistem ini, proses yang kritis menerima prioritas lebih daripada yang lain. Walaupun menambah fungsi soft real-time ke sistem time sharing mungkin akan mengakibatkan ketidakadilan pembagian sumber daya dan mengakibatkan delay yang lebih lama, atau mungkin menyebabkan starvation , hasilnya adalah tujuan secara umum sistem yang

47

Bab 3. Proses dan Penjadwalan bisa mendukung multimedia, grafik berkecepatan tinggi, dan variasi tugas yang tidak bisa diterima di lingkungan yang tidak mendukunng komputasi soft real-time. Contoh penerapan sistem ini dalam kehidupan sehari-hari adalah pada alat penjual/pelayan otomatis. Jika mesin yang menggunakan sistem ini telah lama digunakan, maka mesin tersebut dapat mengalami penurunan kualitas, misalnya waktu pelayanannya menjadi lebih lambat dibandingkan ketika masih baru. Keterlambatan pada sistem ini tidak menyebabkan kecelakaan atau akibat fatal lainnya, melainkan hanya menyebabkan kerugian keuangan saja. Jika pelayanan mesin menjadi lambat, maka para pengguna dapat saja merasa tidak puas dan akhirnya dapat menurunkan pendapatan pemilik mesin. Untuk lebih memahami tentang perbedaan kedua sistem ini dapat diperhatikan dari diagram dibawah ini. Gambar 3-14. Grafik Hard Real-Time

http://www.ncst.ernet.in/education/pgdst/coosfac/slides/rtos.pdf

48

Bab 3. Proses dan Penjadwalan Gambar 3-15. Grafik Soft Real-Time

http://www.ncst.ernet.in/education/pgdst/coosfac/slides/rtos.pdf Setelah batas waktu yang diberikan telah habis, pada sistem hard real-time, aplikasi yang dijalankan langsung dihentikan. Akan tetapi, pada sistem soft real-time, aplikasi yang telah habis masa waktu pengerjaan tugasnya, dihentikan secara bertahap atau dengan kata lain masih diberikan toleransi waktu. Mengimplementasikan fungsi soft real time membutuhkan design yang hati-hati dan aspek yang berkaitan dengan sistem operasi. Pertama, sistem harus punya prioritas penjadualan, dan proses real-time harus memiliki prioritas tertinggi, tidak melampaui waktu, walaupun prioritas non real time bisa terjadi. Kedua, dispatch latency harus lebih kecil. Semakin kecil latency, semakin cepat real time proses mengeksekusi. Untuk menjaga dispatch tetap rendah, kita butuh agar system call untuk preemptible . Ada beberapa cara untuk mencapai tujuan ini. Pertama adalah dengan memasukkan preemption points di durasi system call yang lama, yang memeriksa apakah prioritas utama butuh untuk dieksekusi. Jika sudah, maka contex switch mengambil alih, ketika high priority proses selesai, proses yang diinterupsi meneruskan dengan system call. Points premption bisa diganti hanya di lokasi yang aman di kernel dimana kernel struktur tidak bisa dimodifikasi. Metoda yang lain adalah dengan membuat semua kernel preemptible. Karena operasi yang benar bisa dijamin, semua struktur data kernel harus diproteksi dengan mekanisme sinkronisasi. Dengan metode ini, kernel bisa selalu di preemptible , karena setiap data kernel yang sedang di update diproteksi dengan pemberian prioritas yang tinggi. Jika ada proses dengan prioritas tinggi ingin membaca atau memodifikasi data kernel yang sedang dijalankan, prioritas yang tinggi harus menunggu sampai proses dengan prioritas rendah tersebut selesai. Situasi seperti ini dikenal dengan priority inversion. Kenyataanya, serangkaian proses dapat saja mengakses sumber daya yang sedang dibutuhkan oleh proses yang lebih tinggi prioritasnya. Masalah ini dapat diatasi dengan priority-inheritance protocol,

49

Bab 3. Proses dan Penjadwalan yaitu semua proses yang sedang mengakses sumber daya mendapat prioritas tinggi sampai selesai menggunakan sumber daya. Setelah selesai, prioritas proses ini dikembalikan menjadi seperti semula.

3.11. Rangkuman 3.11.1. Proses Sebuah proses adalah suatu program yang sedang dieksekusi. Proses lebih dari sebuah kode program tetapi juga mencakup program counter , stack , dan sebuah data section . Dalam pengeksekusiannya sebuah proses juga memiliki status yang mencerminkan keadaan dari proses tersebut. Status dari proses dapat berubah-ubah setiap saat sesuai dengan kondisinya. Status tersebut mungkin menjadi satu dari lima status berikut: new, ready, running, waiting, atau terminated. Setiap proses juga direpresentasikan oleh proces control block (PCB) yang menyimpan segala informasi yang berkaitan dengan proses tersebut. Sebuah proses, ketika sedang tidak dieksekusi, ditempatkan pada antrian yang sama. Disini ada 2 kelas besar dari antrian dalam sebuah sistem operasi: permintaan antrian I/O dan ready queue. Ready queue memuat semua proses yang siap untuk dieksekusi dan yang sedang menunggu untuk dijalankan pada CPU. PCB dapat digunakan untuk mencatat sebuah ready queue. Penjadwalan Long-term adalah pilihan dari proses-proses untuk diberi ijin menjalankan CPU. Normalnya, penjadwalan long-term memiliki pengaruh yang sangat besar bagi penempatan sumber daya, terutama manajemen memori. Penjadwalan Short-term adalah pilihan dari satu proses dari ready queue. Proses-proses pada sistem dapat dieksekusi secara berkelanjutan. Disini ada beberapa alasan mengapa proses tersebut dapat dieksekusi secara berkelanjutan: pembagian informasi, penambahan kecepatan komputasi, modularitas, dan kenyamanan atau kemudahan. Eksekusi secara berkelanjutan menyediakan sebuah mekanisme bagi proses pembuatan dan penghapusan. Pengeksekusian proses-proses pada sistem operasi mungkin dapat digolongkan menjadi proses yang mandiri dan kooperasi. Proses kooperasi harus memiliki beberapa alat untuk mendukung komunikasi antara satu dengan yang lainnya. Prinsipnya adalah ada dua rencana komplementer komunikasi: pembagian memori dan sistem pesan. Metode pembagian memori menyediakan proses komunikasi untuk berbagi beberapa variabel. Proses-proses tersebut diharapkan dapat saling melakukan tukar-menukar informasi seputar pengguna variabel yang terbagi ini. Pada sistem pembagian memori, tanggung jawab bagi penyedia komunikasi terjadi dengan programmer aplikasi; sistem operasi harus menyediakan hanya pembagian memori saja. Metode sistem pesan mengijinkan proses-proses untuk tukar-menukar pesan. Tanggung jawab bagi penyedia komunikasi ini terjadi dengan sistem operasi tersebut.

3.11.2. Thread Threadadalah sebuah alur kontrol dari sebuah proses. Suatu proses yang multithreaded mengandung beberapa perbedaan alur kontrol dengan ruang alamat yang sama. Keuntungan dari multithreaded meliputi peningkatan respon dari pengguna, pembagian sumber daya proses, ekonomis, dan kemampuan untuk mengambil keuntungan dari arsitektur multiprosesor. Thread tingkat pengguna adalah thread yang tampak oleh programmer dan tidak diketahui oleh kernel. Thread tingkat pengguna secara tipikal dikelola oleh sebuah library thread di ruang pengguna. Thread tingkat kernel didukung dan dikelola oleh

50

Bab 3. Proses dan Penjadwalan kernel sistem operasi. Secara umum, thread tingkat pengguna lebih cepat dalam pembuatan dan pengelolaan dari pada kernel thread. Ada 3 perbedaan tipe dari model yang berhubungan dengan pengguna dan kernel thread yaitu one-to one model, many-to-one model, many-to-many model.

•

Model many to one: memetakan beberapa pengguna level thread hanya ke satu buah kernel thread.

•

Model one to one: memetakan setiap thread pengguna ke dalam satu kernel thread berakhir.

•

Model many to many: mengijinkan pengembang untuk membuat thread pengguna sebanyak mungkin, konkurensi tidak dapat tercapai karena hanya satu thread yang dapat dijadwalkan oleh kernel dalam satu waktu.

Thread cancellation adalah tugas untuk memberhentikan thread sebelum ia menyelesaikan tugasnya. Thread yang akan diberhentikan disebut target thread Pemberhentian target thread bisa terjadi melalui 2 cara yang berbeda

• •

Asynchronous cancellation : suatu thread seketika itu juga memberhentikan target thread. Deffered cancellation : target thread secara periodik memeriksa apakah dia harus berhenti, cara ini memperbolehkan target thread untuk memberhentikan dirinya sendiri secara terurut.

Thread Pools adalah cara kerja dengan membuat beberapa thread pada proses startup dan menempatkan mereka ke pools. Keuntungan Thread Pools

•

Biasanya lebih cepat untuk melayani permintaan dengan thread yang ada dibanding dengan menunggu thread baru dibuat

•

Thread pool membatasi jumlah thread yang ada pada suatu waktu. Hal ini penting pada sistem yang tidak bisa mendukung banyak thread yang berjalan secara concurrent

Threaddi Linux dianggap sebagai task . System call yang dipakai antara lain fork dan clone. Perbedaan antara keduanya adalah clone selain dapat membuat duplikat dari proses induk -nya seperti fork, juga dapat berbagi ruang alamat yang sama antara proses induk dengan proses anak. Seberapa besar kedua proses tersebut dapat berbagi tergantung banyaknya flag yang ditandai. Java adalah unik karena telah mendukung thread didalam tingkatan bahasanya. Semua program Java sedikitnya terdiri dari kontrol sebuah thread tunggal dan mempermudah membuat kontrol untuk multiple thread dengan program yang sama. JAVA juga menyediakan library berupa API untuk membuat thread, termasuk method untuk suspend dan resume suatu thread, agar thread tidur untuk jangka waktu tertentu dan menghentikan thread yang berjalan. Sebuah java thread juga mempunyai 4 kemungkinan keadaan, diantaranya: New, Runnable, Blocked dan Dead. Perbedaan API untuk mengelola thread seringkali mengganti keadaan thread itu sendiri.

51


3.11.3. Penjadwalan CPU Penjadwalan CPU adalah pemilihan proses dari antrian ready untuk dapat dieksekusi. Algoritma yang digunakan dalam penjadulan CPU ada bermacam-macam. Diantaranya adalah First Come Firsrt Serve (FCFS), merupakan algoritma sederhana dimana proses yang datang duluan maka dia yang dieksekusi pertama kalinya. Algoritma lainnya adalah Sorthest Job First (SJF), yaitu penjadulan CPU dimana proses yang paling pendek dieksekusi terlebih dahulu. Kelemahan algoritma SJF adalah tidak dapat menghindari starvation. Untuk itu diciptakan algoritma Round Robin (RR). Penjadulan CPU dengan Round Robin adalah membagi proses berdasarkan waktu tertentu yaitu waktu quantum q. Setelah proses menjalankan eksekusi selama q satuan waktu maka akan digantikan oleh proses yang lain. Permasalahannya adalah bila waktu quantumnya besar sedang proses hanya membutuhkan waktu sedikit maka akan membuang waktu. Sedang bila waktu quantum kecil maka akan memakan waktu saat contect-swicth. Penjadwlan FCFS adalah nonpreemptive yaitu tidak dapat diinterupsi sebelum proses dieksekusi seluruhnya. Penjadwalan RR adalah preemtive yaitu dapat dieksekusi saat prosesnya masih dieksekusi. Sedangkan penjadwalan SJF dapat berupa nonpreemtive dan preemtive.

3.12. Latihan 3.12.1. Proses 1. sebutkan 5 aktivitas sistem operasi yang merupakan contoh dari suatu manajemen proses. 2. Definisikan perbedaan antara penjadwalan short term, medium term dan long term. 3. Jelaskan tindakan yang diambil oleh sebuah kernel ketika context switch antar proses. 4. Informasi apa saja yang disimpan pada tabel proses saat context switch dari satu proses ke proses lain. 5. Di sistem UNIX terdapat banyak status proses yang dapat timbul (transisi) akibat event (eksternal) OS dan proses tersebut itu sendiri. Transisi state apa sajakah yang dapat ditimbulkan oleh proses itu sendiri. Sebutkan! 6. Apa keuntungan dan kekurangan dari : •

komunikasi Simetrik dan asimetrik

•

Automatic dan explicit buffering

•

Send by copy dan send by reference

•

Fixed-size dan variable sized messages

7. Jelaskan perbedaan short-term, medium-term dan long-term ?

52

Bab 3. Proses dan Penjadwalan 8. Jelaskan apa yang akan dilakukan oleh kernel kepada context switch ketika proses sedang berlangsung ? 9. Beberapa single-user mikrokomputer sistem operasi seperti MS-DOS menyediakan sedikit atau tidak sama sekali arti dari pemrosesan yang konkuren. Diskusikan dampak yang paling mungkin ketika pemrosesan yang konkuren dimasukkan ke dalam suatu sistem operasi ? 10. Perlihatkan semua kemungkinan keadaan dimana suatu proses dapat sedang berjalan, dan gambarkan diagram transisi keadaan yang menjelaskan bagaimana proses bergerak diantara state. 11. Apakah suatu proses memberikan ’issue’ ke suatu disk I/O ketika, proses tersebut dalam ’ready’ state, jelaskan ? 12. Kernel menjaga suatu rekaman untuk setiap proses, disebut Proses Control Blocks (PCB). Ketika suatu proses sedang tidak berjalan, PCB berisi informasi tentang perlunya melakukan restart suatu proses dalam CPU. Jelaskan 2 informasi yang harus dipunyai PCB.

3.12.2. Thread 1. Tunjukkan dua contoh pemrograman dari multithreading yang dapat meningkatkan sebuah solusi thread tunggal. 2. Tunjukkan dua contoh pemrograman dari multithreading yang tidak dapat meningkatkan sebuah solusi thread tunggal. 3. Sebutkan dua perbedaan antara user level thread dan kernel thread. Saat kondisi bagaimana salah satu dari thread tersebut lebih baik 4. Jelaskan tindakan yang diambil oleh sebuah kernel saat context switch antara kernel level thread. 5. Sumber daya apa sajakah yang digunakan ketika sebuah thread dibuat? Apa yang membedakannya dengan pembentukan sebuah proses. 6. Tunjukkan tindakan yang diambil oleh sebuah thread library saat context switch antara user level thread.

3.12.3. Penjadwalan CPU 1. Definisikan perbedaan antara penjadwalan secara preemptive dan nonpreemptive! 2. Jelaskan mengapa penjadwalan strict nonpreemptive tidak seperti yang digunakan di sebuah komputer pusat. 3. Apakah keuntungan menggunakan time quantum size di level yang berbeda dari sebuah antrian sistem multilevel? Pertanyaan nomor 4 sampai dengan 5 dibawah menggunakan soal berikut:

53

Bab 3. Proses dan Penjadwalan Misal diberikan beberapa proses dibawah ini dengan panjang CPU burst ( dalam milidetik) Semua proses diasumsikan datang pada saat t=0 Tabel 3-2. Tabel untuk soal 4 — 5 Proses

Burst Time

Prioritas

P1

10

3

P2

1

1

P3

2

3

P4

1

4

P5

5

2

4. Gambarkan 4 diagram Chart yang mengilustrasikan eksekusi dari proses-proses tersebut menggunakan FCFS, SJF, prioritas nonpreemptive dan round robin. 5. Hitung waktu tunggu dari setiap proses untuk setiap algoritma penjadwalan. 6. Jelaskan perbedaan algoritma penjadwalan berikut: •

FCFS

•

Round Robin

•

Antrian Multilevel feedback

7. Penjadwalan CPU mendefinisikan suatu urutan eksekusi dari proses terjadwal. Diberikan n buah proses yang akan dijadwalkan dalam satu prosesor, berapa banyak kemungkinan penjadwalan yang berbeda? berikan formula dari n. 8. Tentukan perbedaan antara penjadwalan preemptive dan nonpreemptive (cooperative). Nyatakan kenapa nonpreemptive scheduling tidak dapat digunakan pada suatu komputer center. Di sistem komputer nonpreemptive, penjadwalan yang lebih baik digunakan.

3.12.4. Client/Server System 1. Jelaskan bagaimana Java RMI dapat bekerja 2. Apa yang dimaksud dengan marshaling, jelaskan kegunaanya!

54


3.13. Rujukan Avi Silberschatz, Peter Galvin, Greg Gagne. Applied Operationg System Concepts 1st Ed. 2000. John Wiley & Sons, Inc. William Stallings: Operating Systems -- Fourth Edition, Prentice Hall, 2001. Soal Mid-Test 2002 Fasilkom UI - RMS Ibrahim http://people.cs.uchicago.edu/~mark/51081/LabFAQ/lab5/IPC.html Website Kuliah Sistem Terdistribusi Fasilkom UI, http://telaga.cs.ui.ac.id/WebKuliah/sisdis2003/ http://linas.org/linux/threads-faq.html http://www.javaworld.com/javaworld/jw-04-1996/jw-04-threads.html

55

Bab 4. Sinkronisasi dan Deadlock

56

Bab 5. Managemen Memori 5.1. Swapping

57

Bab 6. Sistem Berkas

58

Bab 7. I/O

59

Bab 8. Studi Kasus: GNU/Linux

60

Lampiran A. GNU Free Documentation License Version 1.1, March 2000 Copyright © 2000 Free Software Foundation, Inc. 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA Everyone is permitted to copy and distribute verbatim copies of this license document, but changing it is not allowed.

A.1. PREAMBLE The purpose of this License is to make a manual, textbook, or other written document "free" in the sense of freedom: to assure everyone the effective freedom to copy and redistribute it, with or without modifying it, either commercially or noncommercially. Secondarily, this License preserves for the author and publisher a way to get credit for their work, while not being considered responsible for modifications made by others. This License is a kind of "copyleft", which means that derivative works of the document must themselves be free in the same sense. It complements the GNU General Public License, which is a copyleft license designed for free software. We have designed this License in order to use it for manuals for free software, because free software needs free documentation: a free program should come with manuals providing the same freedoms that the software does. But this License is not limited to software manuals; it can be used for any textual work, regardless of subject matter or whether it is published as a printed book. We recommend this License principally for works whose purpose is instruction or reference.

A.2. APPLICABILITY AND DEFINITIONS This License applies to any manual or other work that contains a notice placed by the copyright holder saying it can be distributed under the terms of this License. The "Document", below, refers to any such manual or work. Any member of the public is a licensee, and is addressed as "you". A "Modified Version" of the Document means any work containing the Document or a portion of it, either copied verbatim, or with modifications and/or translated into another language. A "Secondary Section" is a named appendix or a front-matter section of the Document that deals exclusively with the relationship of the publishers or authors of the Document to the Document’s overall subject (or to related matters) and contains nothing that could fall directly within that overall subject. (For example, if the Document is in part a textbook of mathematics, a Secondary Section may not explain any mathematics.) The relationship could be a matter of historical connection with the subject or with related matters, or of legal, commercial, philosophical, ethical or political position regarding them. The "Invariant Sections" are certain Secondary Sections whose titles are designated, as being those of Invariant Sections, in the notice that says that the Document is released under this License. The "Cover Texts" are certain short passages of text that are listed, as Front-Cover Texts or Back-Cover Texts, in the notice that says that the Document is released under this License.

61

Lampiran A. GNU Free Documentation License A "Transparent" copy of the Document means a machine-readable copy, represented in a format whose specification is available to the general public, whose contents can be viewed and edited directly and straightforwardly with generic text editors or (for images composed of pixels) generic paint programs or (for drawings) some widely available drawing editor, and that is suitable for input to text formatters or for automatic translation to a variety of formats suitable for input to text formatters. A copy made in an otherwise Transparent file format whose markup has been designed to thwart or discourage subsequent modification by readers is not Transparent. A copy that is not "Transparent" is called "Opaque". Examples of suitable formats for Transparent copies include plain ASCII without markup, Texinfo input format, LaTeX input format, SGML or XML using a publicly available DTD, and standard-conforming simple HTML designed for human modification. Opaque formats include PostScript, PDF, proprietary formats that can be read and edited only by proprietary word processors, SGML or XML for which the DTD and/or processing tools are not generally available, and the machine-generated HTML produced by some word processors for output purposes only. The "Title Page" means, for a printed book, the title page itself, plus such following pages as are needed to hold, legibly, the material this License requires to appear in the title page. For works in formats which do not have any title page as such, "Title Page" means the text near the most prominent appearance of the work’s title, preceding the beginning of the body of the text.

A.3. VERBATIM COPYING You may copy and distribute the Document in any medium, either commercially or noncommercially, provided that this License, the copyright notices, and the license notice saying this License applies to the Document are reproduced in all copies, and that you add no other conditions whatsoever to those of this License. You may not use technical measures to obstruct or control the reading or further copying of the copies you make or distribute. However, you may accept compensation in exchange for copies. If you distribute a large enough number of copies you must also follow the conditions in section 3. You may also lend copies, under the same conditions stated above, and you may publicly display copies.

A.4. COPYING IN QUANTITY If you publish printed copies of the Document numbering more than 100, and the Document’s license notice requires Cover Texts, you must enclose the copies in covers that carry, clearly and legibly, all these Cover Texts: Front-Cover Texts on the front cover, and Back-Cover Texts on the back cover. Both covers must also clearly and legibly identify you as the publisher of these copies. The front cover must present the full title with all words of the title equally prominent and visible. You may add other material on the covers in addition. Copying with changes limited to the covers, as long as they preserve the title of the Document and satisfy these conditions, can be treated as verbatim copying in other respects. If the required texts for either cover are too voluminous to fit legibly, you should put the first ones listed (as many as fit reasonably) on the actual cover, and continue the rest onto adjacent pages. If you publish or distribute Opaque copies of the Document numbering more than 100, you must either include a machine-readable Transparent copy along with each Opaque copy, or state in or with each Opaque copy a publicly-accessible computer-network location containing a complete Transparent copy of the Document, free of added material, which the general network-using public has access to download

62

Lampiran A. GNU Free Documentation License anonymously at no charge using public-standard network protocols. If you use the latter option, you must take reasonably prudent steps, when you begin distribution of Opaque copies in quantity, to ensure that this Transparent copy will remain thus accessible at the stated location until at least one year after the last time you distribute an Opaque copy (directly or through your agents or retailers) of that edition to the public. It is requested, but not required, that you contact the authors of the Document well before redistributing any large number of copies, to give them a chance to provide you with an updated version of the Document.

A.5. MODIFICATIONS You may copy and distribute a Modified Version of the Document under the conditions of sections 2 and 3 above, provided that you release the Modified Version under precisely this License, with the Modified Version filling the role of the Document, thus licensing distribution and modification of the Modified Version to whoever possesses a copy of it. In addition, you must do these things in the Modified Version: A. Use in the Title Page (and on the covers, if any) a title distinct from that of the Document, and from those of previous versions (which should, if there were any, be listed in the History section of the Document). You may use the same title as a previous version if the original publisher of that version gives permission. B. List on the Title Page, as authors, one or more persons or entities responsible for authorship of the modifications in the Modified Version, together with at least five of the principal authors of the Document (all of its principal authors, if it has less than five). C. State on the Title page the name of the publisher of the Modified Version, as the publisher. D. Preserve all the copyright notices of the Document. E. Add an appropriate copyright notice for your modifications adjacent to the other copyright notices. F. Include, immediately after the copyright notices, a license notice giving the public permission to use the Modified Version under the terms of this License, in the form shown in the Addendum below. G. Preserve in that license notice the full lists of Invariant Sections and required Cover Texts given in the Document’s license notice. H. Include an unaltered copy of this License. I. Preserve the section entitled "History", and its title, and add to it an item stating at least the title, year, new authors, and publisher of the Modified Version as given on the Title Page. If there is no section entitled "History" in the Document, create one stating the title, year, authors, and publisher of the Document as given on its Title Page, then add an item describing the Modified Version as stated in the previous sentence. J. Preserve the network location, if any, given in the Document for public access to a Transparent copy of the Document, and likewise the network locations given in the Document for previous versions it was based on. These may be placed in the "History" section. You may omit a network location for a work that was published at least four years before the Document itself, or if the original publisher of the version it refers to gives permission.

63

Lampiran A. GNU Free Documentation License K. In any section entitled "Acknowledgements" or "Dedications", preserve the section’s title, and preserve in the section all the substance and tone of each of the contributor acknowledgements and/or dedications given therein. L. Preserve all the Invariant Sections of the Document, unaltered in their text and in their titles. Section numbers or the equivalent are not considered part of the section titles. M. Delete any section entitled "Endorsements". Such a section may not be included in the Modified Version. N. Do not retitle any existing section as "Endorsements" or to conflict in title with any Invariant Section. If the Modified Version includes new front-matter sections or appendices that qualify as Secondary Sections and contain no material copied from the Document, you may at your option designate some or all of these sections as invariant. To do this, add their titles to the list of Invariant Sections in the Modified Version’s license notice. These titles must be distinct from any other section titles. You may add a section entitled "Endorsements", provided it contains nothing but endorsements of your Modified Version by various parties–for example, statements of peer review or that the text has been approved by an organization as the authoritative definition of a standard. You may add a passage of up to five words as a Front-Cover Text, and a passage of up to 25 words as a Back-Cover Text, to the end of the list of Cover Texts in the Modified Version. Only one passage of Front-Cover Text and one of Back-Cover Text may be added by (or through arrangements made by) any one entity. If the Document already includes a cover text for the same cover, previously added by you or by arrangement made by the same entity you are acting on behalf of, you may not add another; but you may replace the old one, on explicit permission from the previous publisher that added the old one. The author(s) and publisher(s) of the Document do not by this License give permission to use their names for publicity for or to assert or imply endorsement of any Modified Version.

A.6. COMBINING DOCUMENTS You may combine the Document with other documents released under this License, under the terms defined in section 4 above for modified versions, provided that you include in the combination all of the Invariant Sections of all of the original documents, unmodified, and list them all as Invariant Sections of your combined work in its license notice. The combined work need only contain one copy of this License, and multiple identical Invariant Sections may be replaced with a single copy. If there are multiple Invariant Sections with the same name but different contents, make the title of each such section unique by adding at the end of it, in parentheses, the name of the original author or publisher of that section if known, or else a unique number. Make the same adjustment to the section titles in the list of Invariant Sections in the license notice of the combined work. In the combination, you must combine any sections entitled "History" in the various original documents, forming one section entitled "History"; likewise combine any sections entitled "Acknowledgements", and any sections entitled "Dedications". You must delete all sections entitled "Endorsements."

64

Lampiran A. GNU Free Documentation License

A.7. COLLECTIONS OF DOCUMENTS You may make a collection consisting of the Document and other documents released under this License, and replace the individual copies of this License in the various documents with a single copy that is included in the collection, provided that you follow the rules of this License for verbatim copying of each of the documents in all other respects. You may extract a single document from such a collection, and distribute it individually under this License, provided you insert a copy of this License into the extracted document, and follow this License in all other respects regarding verbatim copying of that document.

A.8. AGGREGATION WITH INDEPENDENT WORKS A compilation of the Document or its derivatives with other separate and independent documents or works, in or on a volume of a storage or distribution medium, does not as a whole count as a Modified Version of the Document, provided no compilation copyright is claimed for the compilation. Such a compilation is called an "aggregate", and this License does not apply to the other self-contained works thus compiled with the Document, on account of their being thus compiled, if they are not themselves derivative works of the Document. If the Cover Text requirement of section 3 is applicable to these copies of the Document, then if the Document is less than one quarter of the entire aggregate, the Document’s Cover Texts may be placed on covers that surround only the Document within the aggregate. Otherwise they must appear on covers around the whole aggregate.

A.9. TRANSLATION Translation is considered a kind of modification, so you may distribute translations of the Document under the terms of section 4. Replacing Invariant Sections with translations requires special permission from their copyright holders, but you may include translations of some or all Invariant Sections in addition to the original versions of these Invariant Sections. You may include a translation of this License provided that you also include the original English version of this License. In case of a disagreement between the translation and the original English version of this License, the original English version will prevail.

A.10. TERMINATION You may not copy, modify, sublicense, or distribute the Document except as expressly provided for under this License. Any other attempt to copy, modify, sublicense or distribute the Document is void, and will automatically terminate your rights under this License. However, parties who have received copies, or rights, from you under this License will not have their licenses terminated so long as such parties remain in full compliance.

65

Lampiran A. GNU Free Documentation License

A.11. FUTURE REVISIONS OF THIS LICENSE The Free Software Foundation may publish new, revised versions of the GNU Free Documentation License from time to time. Such new versions will be similar in spirit to the present version, but may differ in detail to address new problems or concerns. See http://www.gnu.org/copyleft/. Each version of the License is given a distinguishing version number. If the Document specifies that a particular numbered version of this License "or any later version" applies to it, you have the option of following the terms and conditions either of that specified version or of any later version that has been published (not as a draft) by the Free Software Foundation. If the Document does not specify a version number of this License, you may choose any version ever published (not as a draft) by the Free Software Foundation.

A.12. How to use this License for your documents To use this License in a document you have written, include a copy of the License in the document and put the following copyright and license notices just after the title page: Copyright © YEAR YOUR NAME. Permission is granted to copy, distribute and/ or modify this document under the terms of the GNU Free Documentation License, Version 1.1 or any later version published by the Free Software Foundation; with the Invariant Sections being LIST THEIR TITLES, with the Front-Cover Texts being LIST, and with the Back-Cover Texts being LIST. A copy of the license is included in the section entitled "GNU Free Documentation License".

If you have no Invariant Sections, write "with no Invariant Sections" instead of saying which ones are invariant. If you have no Front-Cover Texts, write "no Front-Cover Texts" instead of "Front-Cover Texts being LIST"; likewise for Back-Cover Texts. If your document contains nontrivial examples of program code, we recommend releasing these examples in parallel under your choice of free software license, such as the GNU General Public License, to permit their use in free software.

66

Indeks Blocking, 22 Buffer, 19 Buffering, 14 Bounded Buffer, 23 Bounded Buffer Problem, 14 bounded-buffer , 14 Buffer, 14 Unbounded Buffer, 23 unbounded-buffer , 14 Cancellation Asynchronous cancellation , 34 Defered cancellation , 34 Client, 26 Client/Server Proses, 17 Context Switch, 12 Flag pada Thread di Linux Tabel Fungsi Flag, 37 Hal-Hal Lainnya dari Thread Pthreads, 37 Thread-Specific Data, 37 IPC send / recives, 19 Java RMI, 28 Keuntungan Thread Berbagi sumber daya, 30 Ekonomi, 30 Responsi, 30 Utilisasi arsitetktur multiprocessor , 30 Komunikasi Langsung, 20 Komunikasi tak Langsung, 20 kooperatif, 18 Mailbox, 21 multiprosesor, 46 Multithreading Models Many-to-Many Model, 32 Many-to-One Model, 32 One-to-One Model, 32 nonBlocking, 22 Penamaan, 20 Penanganan Sinyal penerima Sinyal, 35 Pola Penanganan Sinyal, 35 Penjadwalan proses, 8 Prioritas, 46 Procedural Programming, 28

Process Control Block - PCB, 5 Produsen Konsumen, 18 Proses Definisi proses, 3 Kooperatif Pembagian informasi, 14 Queue Scheduling device queue, 8 job queue, 8 ready queue, 8 Remote Registry, 28 RPC, 28 scheduler CPU scheduler, 11 job scheduler, 11 long-term scheduler, 11 medium-term scheduler, 11 short-term scheduler, 11 Server, 26 Sinkronisasi, 22 Sistem Waktu nyata Sistem Hard Real-Time, 47 Sistem Soft Real-Time, 47 Skleton, 28 Socket, 26 Status Proses New, 4 Ready, 4 Runing, 4 Terminated, 4 Waiting, 4 Stub, 28 System callLinux clone Perbedaan fork dan clone, 37 fork, 37 Thread, 7 Definisi thread, 29 Multithreading, 29 Thread Pools Keuntungan Thread Pools, 36 threaddi Java Membuat thread , 38 User dan Kernel Threads Kernel Thread, 31 User Thread, 31

67

Sistem Operasi. Bahan Kuliah IKI-20230

Recommend Documents