Jumat, 22 April 2011

Tugas Sistem Operasi 1

Sinkronisasi
Komunikasi antara proses membutuhkan place by calls untuk mengirim dan menerima data primitif.
Terdapat desain yang berbeda-beda dalam implementasi setiap primitif. 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 memblok sampai pesan tersedia.
  • Penerimaan yang tidak diblok: Penerima mengembalikan pesan valid atau null
Manfaat Sinkronisasi proses
Sinkronisasi diperlukan untuk menghindari terjadinya ketidakkonsistenan data akibat adanya akses data secara konkuren. Diperlukan adanya suatu mekanisme untuk memastikan urutan / giliran pengaksesan suatu data yang saling bekerjasama sehingga terjadi sinkronisasi


Deadlock

Deadlock adalah suatu kondisi dimana dua proses atau lebih tidak dapat meneruskan eksekusinya

Resources (1)
 Contoh resources sistem komputer
  • printers
  • tape drives
Proses-proses membutuhkan akses ke resource secara teratur
Contoh 1 : suatu proses memegang (hold) resource A dan meminta resource B
pada saat yang sama proses lain sedang memegang resource B dan meminta resource A
masing-masing proses melakukan block, dalam kondisi seperti ini terjadi deadlock

Resources (2)
Contoh 2 :
semaphores A dan B, di-inisialisasi 1
P0 P1
wait (A); wait(B)
wait (B); wait(A)
. .
. .
. .
signal(A) signal(B)
signal(B) signal(A)

Resources (3)

Contoh 3 :
  • Bridge Crossing
  • Traffic hanya satu arah
  • Masing-masing bagian jembatan dapat digambarkan sebagai resource.
  • Jika deadlock terjadi, dapat diselesaikan dengan cara satu mobil mundur ke belakang.
  • Beberapa mobil harus kembali jika terjadi deadlock
  • Memungkinkan terjadinya starvation

Resources (4)
  • Deadlock terjadi ketika…
  • proses-proses diberikan hak akses secara eksklusif ke devices (resources)
  • Preemptable resources
  • dapat diambil dari proses tanpa menimbulkan efek yang buruk
  • Nonpreemptable resources
  • akan menyebabkan proses gagal jika diambil

4 Kondisi Terjadinya Deadlock
  • Kondisi Mutual exclusion
  • hanya satu proses dalam satu waktu yang dapat memegang (hold) resource
  • Hold and wait condition
  • suatu proses memegang satu resource dan me-request resource yang lain
  • No preemption condition
  • resource hanya dapat di-release setelah proses menyelesaikan task-nya pada resource tersebut
  • Circular wait condition
  • Masing-masing proses menunggu resource yang digunakan oleh proses lain secara berantai.
  • Terdapat himpunan proses yang sedang menunggu {P0, P1, …, P0} sedemikian sehingga P0 menunggu resource yang dipegang oleh P1 , P1 sedang menunggu resource yang dipegang oleh P2, …, Pn–1 . Pn–1 menunggu resource yang dipegang oleh Pn . Dan Pn menunggu resource yang dipegang oleh P0 .

Metode-metode Penanganan Deadlocks
  •  Memastikan bahwa sistem tidak akan pernah masuk ke dalam kondisi (state) deadlock. 
  • Memungkinkan sistem untuk masuk ke dalam kondisi deadlock dan kemudian melakukan recovery (pemulihan).
  • Mengabaikan masalah deadlock dan membuat deadlock tidak pernah terjadi dalam sistem; digunakan pada OS umumnya (Unix).

Metode Pencegahan Deadlock (1)

Cara pencegahan (Prevention) dari sisi permintaan (request) resources :
  • Mutual Exclusion – tidak diperlukan untuk resource-resource yang di-share; harus dipegang (hold) untuk resource-resource yang tidak di-share (nonsharable resources).
  • Hold and Wait – harus dijamin bahwa kapanpun suatu permintaan proses pada resource, proses tersebut tidak memegang resource yang lain.
  • Membutuhkan proses untuk me-request dan mengalokasikan resources sebelum memulai eksekusi, atau membolehkan proses untuk me-request resource hanya ketika proses tidak sedang memegang resource.
  • Utilisasi resource yang rendah memungkinkan terjadinya starvation.

Metode Pencegahan Deadlock (2)

  • No Preemption
  • Jika suatu proses yang memegang beberapa resource me-request resource yang lain yang tidak dapat secara langsung dialokasikan, maka semua resource yang sedang dipegang dibebaskan (released).
  • Preempted resources ditambahkan ke list resources dimana proses sedang menunggu.
  • Proses akan di-restart hanya jika dapat mengambil kembali (regain) resource, juga resource yang baru yang di-request.
  • Circular Wait
  • Membuat penomoran pada proses-proses yang mengakses resource. Suatu proses dimungkinkan untuk dapat meminta resource kapanpun, tetapi permintaannya harus dibuat terurut.

Syarat Langkah Kelemahan
Mutual Exclusion Spooling resource Dapat menyebabkan chaos
Hold & Wait Meminta resource diawal Sulit memperkirakan di awal dan tidak optimal
No Pre-emptive Mengambil resource di tengah jalan Hasil proses tidak akan baik
Circular Wait Penomoran permintaan resource Tidak ada penomoran yang memuaskan semua pihak

Metode Penghindaran Deadlock (1)
  •  Memberi kesempatan ke permintaan resource yang tidak mungkin menyebabkan deadlock.
  • Jika pemberian akses tidak mungkin mengarah pada deadlock, maka resource akan diberikan pada proses yang meminta.
  • Jika tidak aman, proses yang meminta akan di-suspend sampai suatu waktu permintaannya aman untuk diberikan.
  • Kondisi aman (safe state)
  • Jika tidak terjadi deadlock
  • Kondisi tidak aman (unsafe state)
  • Jika tidak terdapat cara untuk memenuhi semua permintaan

Metode Penghindaran Deadlock (2)
  • Membutuhkan sistem yang memiliki informasi resource yang tersedia.
  • Masing-masing proses memastikan jumlah maksimum resource yang diperlukan.
  • Algoritma penghindaran (avoidence) deadlock memastikan tidak akan terjadi kondisi circular wait.
  • Kondisi (state) alokasi resource didefinisikan sebagai jumlah dan alokasi resource yang tersedia dan maksimum permintaan resource oleh proses.

Basic Facts
  • Jika sistem dalam kondisi aman (safe state) Þ tidak ada deadlock.
  • Jika sistem dalam kondisi tidak aman (unsafe state) Þ kemungkinan dapat terjadi deadlock
  • Pendekatan penghindaran (avoidence) memastikan bahwa sistem tidak akan pernah masuk ke dalam kondisi unsafe state.

Deteksi dan Pemulihan Deadlock
  •  Menentukan apakah deadlock sedang terjadi, kemudian proses-proses dan resource yang terlibat dalam deadlock tersebut.
  • Setelah kondisi deadlock terdeteksi, maka langkah pemulihan deadlock dilakukan.

Cara Pemulihan Deadlock

Ada beberapa cara untuk pemulihan deadlock :
  • Menggagalkan semua proses yang deadlock
  • Mem-backup semua proses yang deadlock dan me-restart semua proses tersebut
  • Menggagalkan proses-proses yang deadlock secara berturut-turut hingga tidak ada deadlock.
  • Menggagalkan pengalokasian resource-resource secara berturut-turut hingga tidak ada deadlock.
  • Kriteria proses-proses yang akan disingkirkan :
  • Memiliki waktu proses (yang telah berjalan) kecil.
  • Jumlah keluaran sedikit
  • Memiliki estimasi sisa waktu eksekusi terbesar.
  • Jumlah total resource terkecil yang telah dialokasikan
  • Memiliki prioritas terkecil 
Buffering I/O
Buffering adalah melembutkan lonjakan-lonjakan kebutuhan pengaksesan I/O, sehingga meningkatkan efisiensi dan kinerja sistem operasi.
Terdapat beragam cara buffering, antar lain :
a. Single buffering.
Merupakan teknik paling sederhana. Ketika proses memberi perintah untuk perangkat I/O, sistem operasi menyediakan buffer memori utama sistem untuk operasi.Untuk perangkat berorientasi blok.Transfer masukan dibuat ke buffer sistem. Ketika transfer selesai, proses memindahkan blok ke ruang pemakai dan segera meminta blok lain. Teknik ini disebut reading ahead atau anticipated input. Teknik ini dilakukan dengan harapan blok akan segera diperlukan. Untuk banyak tipe komputasi, asumsi ini berlaku. Hanya di akhir pemrosesan maka blok yang dibaca tidak diperlukan.
Keunggulan :
Pendekatan in umumnya meningkatkan kecepatan dibanding tanpa buffering. Proses pemakai dapat memproses blok data sementara blok berikutnya sedang dibaca. Sistem operasi dapat menswap keluar proses karena operasi masukan berada di memori sistem bukan memori proses pemakai.
Kelemahan :
o Merumitkan sistem operasi karena harus mencatat pemberian buffer-buffer sistem ke proses pemakai.
o Logika swapping juga dipengaruhi. Jika operasi I/O melibatkan disk
untuk swapping, maka membuat antrian penulisan ke disk yang sama yang digunakan untuk swap out proses. Untuk menswap proses dan melepas memori utama tidak dapat dimulai sampai operasi I/O selesai, dimana waktu swapping ke disk tidak bagus untuk dilaksanaka Buffering keluaran serupa buffering masukan. Ketika data transmisi, data lebih dulu dikopi dari ruang pemakai ke buffer sistem. Proses pengirim menjadi bebas untuk melanjutkan eksekusi berikutnya atau di swap ke disk Jika perlu.
Untuk perangkat berorientasi aliran karakter.

Single buffering dapat diterapkan dengan dua mode, yaitu :
o Mode line at a time.
Cocok untuk terminal mode gulung (scroll terminal atau dumb terminal). Masukan pemakai adalah satu baris per waktu dengan enter menandai akhir baris. Keluaran terminal juga serupa, yaitu satu baris per waktu.
Contoh mode ini adalah printer.
Buffer digunakan untuk menyimpan satu baris tunggal. Proses pemakai
ditunda selama masukan, menunggu kedatangan satu baris seluruhnya.
Untuk keluaran, proses pemakai menempatkan satu baris keluaran pada buffer dan melanjutkan pemrosesan. Proses tidak perlu suspend kecuali bila baris kedua dikirim sebelum buffer dikosongkan.
o Mode byte at a time.
Operasi ini cocok untuk terminal mode form, dimana tiap ketikan adalah penting dan untuk peripheral lain seperti sensor dan pengendali.

b. Double buffering.
Peningkatan dapat dibuat dengan dua buffer sistem.Proses dapat ditransfer ke/dari satu buffer sementara sistem operasi mengosongkan (atau mengisi) buffer lain. Teknik ini disebut double buffering atau buffer swapping. Double buffering menjamin proses tidak menunggu operasi I/O. Peningkatan ini harus dibayar dengan peningkatan kompleksitas. Untuk berorientasi aliran karakter, double buffering mempunyai 2 mode alternatif, yaitu :
o Mode line at a time.
Proses pemakai tidak perlu ditunda untuk I/O kecuali proses secepatnya mengosongkan buffer ganda.
o Mode byte at a time.
Buffer ganda tidak memberi keunggulan berarti atas buffer tunggal.
Double buffering mengikuti model producer-consumer.

c. Circular buffering.
Seharusnya melembutkan aliran data antara perangkat I/O dan proses. Jika kinerja proses tertentu menjadi fokus kita, maka kita ingin agar operasi I/O mengikuti proses. Double buffering tidak mencukupi jika proses melakukan operasi I/O yang berturutan dengan cepat. Masalah sering dapat dihindari denga menggunakan lebih dari dua buffer. Ketika lebih dari dua buffer yang digunakan, kumpulan buffer itu sendiri diacu sebagai circulat buffer. Tiap bufferindividu adalah satu unit di circular buffer.

Proses Control Block dan Penjadwalan




Gambar Proses Control Block
Penjelasan mengenai process control block :
1) Setiap proses digambarkan dalam sistem operasi oleh sebuah proses control block PCB). PCB berisikan banyak informasi yang berhubungan dengan sebuah proses yang spesifik, yaitu :
Status proses : Status mungkin dimiliki oleh setiap proses new, ready,running, waiting, terminated.
a) NEW
Status yang dimiliki pada saat proses baru saja dibuat oleh penjadwalan tingkat tinggi,  tetapi belum siap melakukan eksekusi.
b) READY
Status yang dimiliki pada saat proses siap dieksekusi oleh processor.
c) RUNNING
Status yang dimiliki pada saat instruksi-instruksi dari sebuah proses dieksekusi. Proses bisa dieksekusi karena CPU tidak sedang mengerjakan tugas yang lain.
d) WAITING
Status yang dimiliki pada saat proses menunggu suatu event, seperti penyelesaian I/O atau menerima signal.
e) TERMINATED
Status yang dimiliki pada saat proses telah selesai dieksekusi.
2) Program counter
adalah menunjukkan alamat berikutnya yang akan dieksekusi oleh proses tersebut.
3) CPU registers
Register bervariasi dalam setiap jumlah dan jenis, tergantung pada rancangan komputer. Register tersebut termasuk dalam accumulator, register indeks, stack pointer, general-purpose register, ditambah kode informasi pada kondisi apa pun. Beserta dengan program counter, keadaan / status informasi harus disimpan pada saat gangguan terjadi, untuk memungkinkan proses tersebut berjalan / bekerja dengan benar setelahnya.
4) Informasi manajemen memori
Informasi ini termasuk dalam suatu informasi sebagai nilai dari dasar dan batas register, tabel halaman atau tabel segmen tergantung pada sistem memori yang digunakan dalam sistem operasi.
5) Informasi pencatatan
Informasi ini termasuk jumlah dari CPU dan waktu riil yang digunakan, batas waktu, jumlah akun jumlah job atau proses, dan banyak lagi.
6) Informasi status I/O
Informasi termasuk daftar dari perangkat I/O yang digunakan 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.
PENJADWALAN PADA KONSEP SISTEM OPERASI
Penjadwalan berkaitan dengan permasalahan CPU untuk memutuskan proses mana yang akan dieksekusi dalam suatu sistem. Proses yang belum mendapat jatah alokasi dari CPU akan mengantri di ready queue. Algoritma penjadwalan berfungsi untuk menentukan proses manakah yang ada di ready queue yang akan dieksekusi oleh CPU.
Beberapa Algoritma penjadwalan adalah sebagai berikut :
1. First in first out
Algoritma ini merupakan algoritma penjadwalan yang paling sederhana
yang digunakan CPU. Dengan menggunakan algoritma ini setiap proses yang berada pada status ready dimasukkan kedalam FIFO queue atau antrian dengan prinsip first in first out, sesuai dengan waktu kedatangannya. Proses yang tiba terlebih dahulu yang akan dieksekusi.
Contoh:
Ada tiga buah proses yang datang secara bersamaan yaitu pada 0 ms, P1 memiliki burst time 24 ms, P2 memiliki burst time 3 ms, dan P3 memiliki burst time 3 ms. Hitunglah waiting time rata-rata dan turnaround time( burst time + waiting time) dari ketiga proses tersebut dengan menggunakan algoritma FCFS. Waiting time untuk P1 adalah 0 ms (P1 tidak perlu menunggu), sedangkan untuk P2 adalah sebesar 24 ms (menunggu P1 selesai), dan untuk P3 sebesar 27 ms (menunggu P1 dan P2 selesai).

Gambar gantt chart kedatangan proses
Urutan kedatangan adalah P1, P2 , P3; gantt chart untuk urutan ini adalah:
Waiting time rata-ratanya adalah sebesar(0+24+27)/3 = 17ms. Turnaround time untuk P1 sebesar 24 ms, sedangkan untuk P2 sebesar 27 ms (dihitung dari awal kedatangan P2 hingga selesai dieksekusi), untuk P3 sebesar 30 ms. Turnaround time rata-rata untuk ketiga proses tersebut adalah (24+27+30)/3 = 27 ms.
Kelemahan dari algoritma ini:
1. Waiting time rata-ratanya cukup lama.
2. Terjadinya convoy effect, yaitu proses-proses menunggu lama untuk menunggu 1 proses besar yang sedang dieksekusi oleh CPU. Algoritma ini juga menerapkan konsep non-preemptive, yaitu setiap proses yang sedang dieksekusi oleh CPU tidak dapat di-interrupt oleh proses yang lain.
Misalkan proses dibalik sehingga urutan kedatangan adalah P3, P2, P1. Waiting time adalah P1=6; P2=3; P3=0. Average waiting time: (6+3+0)/3=3.

Gambar gantt chart kedatangan proses urutan kedatangan dibalik
2. Priority Function
Priority Function merupakan algoritma penjadwalan yang mendahulukan proses yang memiliki prioritas tertinggi. Setiap proses memiliki prioritasnya masing-masing.
Prioritas suatu proses dapat ditentukan melalui beberapa
karakteristik antara lain:
1. Time limit.
2. Memory requirement.
3. Akses file.
4. Perbandingan antara burst M/K dengan CPU burst.
5. Tingkat kepentingan proses.
Priority function juga dapat dijalankan secara preemptive maupun non-preemptive. Pada preemptive, jika ada suatu proses yang baru datang memiliki prioritas yang lebih tinggi daripada proses yang sedang dijalankan, maka proses yang sedang berjalan tersebut dihentikan, lalu CPU dialihkan untuk proses yang baru datang tersebut.
Sementara itu, pada non-preemptive, proses yang baru datang tidak dapat menganggu proses yang sedang berjalan, tetapi hanya diletakkan di depan queue.
Kelemahan pada priority function adalah dapat terjadinya indefinite blocking( starvation). Suatu proses dengan prioritas yang rendah memiliki kemungkinan untuk tidak dieksekusi jika terdapat proses lain yang memiliki prioritas lebih tinggi darinya.
Solusi dari permasalahan ini adalah aging, yaitu meningkatkan prioritas dari setiap proses yang menunggu dalam queue secara bertahap.
Contoh:
Setiap 10 menit, prioritas dari masing-masing proses yang menunggu dalam queue dinaikkan satu tingkat. Maka, suatu proses yang memiliki prioritas 127, setidaknya dalam 21 jam 20 menit, proses tersebut akan memiliki prioritas 0, yaitu prioritas yang tertinggi (semakin kecil angka menunjukkan bahwa prioritasnya semakin tinggi).
3. 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 yaitu (1/n), dan tak akan menunggu lebih lama dari (n-1)q dengan q adalah lama 1 quantum.
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.
Permasalahan utama pada Round Robin adalah menentukan besarnya time quantum. Jika time quantum yang ditentukan terlalu kecil, maka sebagian besar proses tidak akan selesai dalam 1 quantum. Hal ini tidak baik karena akan terjadi banyak switch, padahal CPU memerlukan waktu untuk beralih dari suatu proses ke proses lain (disebut dengan context switches time).
Sebaliknya, jika time quantum terlalu besar, algoritma Round Robin akan berjalan seperti algoritma first come first served. Time quantum yang ideal adalah jika 80% dari total proses memiliki CPU burst time yang lebih kecil dari 1 time quantum.

Gambar Urutan kejadian algoritma Round Robin
4. Multilevel Feedback
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.
Hal 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 M/K dapat terus sibuk. Semakin rendah tingkatannya, panjang CPU burst proses juga semakin besar.

Gambar Multilevel Feedback Queue
5. Last In First Out
Pada algoritma ini setiap proses yang ada di ready queue akan dieksekusi berdasarkan burst time terkecil.
Hal ini mengakibatkan waiting time yang pendek untuk setiap proses dan karena hal tersebut maka waiting time rata-ratanya juga menjadi pendek, sehingga dapat dikatakan bahwa algoritma ini adalah algoritma yang optimal.Proses yang tiba belakangan yang akan dieksekusi terlebih dahulu.

Multiprocesing
Kita perlu mempelajari penjadwalan pada prosesor jamak berhubung sistem
dengan prosesor jamak akan semakin banyak digunakan karena kemampuannya yang
lebih baik dari sistem dengan prosesor tunggal. Seperti halnya pada prosesor tunggal,
prosesor jamak juga membutuhkan penjadwalan. Namun pada prosesor jamak,
penjadwalannya jauh lebih kompleks dari pada prosesor tunggal. Dalam penjadwalan
prosesor jamak, tiap proses dapat mengakses memori dengan cara yang sama [uniform
memory access].
Pembatasan dalam penjadwalan juga terjadi dalam multiprosesor. Hal ini
disebabkan karena:
a) kemungkinan adanya load sharing. Load sharing terjadi jika ada beberapa prosesor
yang identik. Untuk mengatasi hal itu maka tiap prosesor memiliki kemampuan
penjadwalan mandiri (self schedulling).
b) kemungkinan terlewatinya sebuah proses dari antrian [ready queue] atau beberapa
prosesor memilih untuk mengeksekusi proses yang sama. permasalahan seperti itu
bisa dijawab dengan sebuah master-slave structure, yaitu suatu struktur dimana
satu prosesor ditunjuk sebagai master. Master inilah yang akan bertanggung jawab
dalam hal penjadwalan, memproses I/O, dan sebagainya. Sedangkan prosesor yang
lain [slave] hanya bertugas untuk mengeksekusi user code. Hal ini disebut juga
sebagai Asymmetric Multiprocessing karena hanya satu prosesor yang dapat
mengakses struktur data dari sistem.
Ada beberapa jenis dari sistem penjadualan prosesor jamak, namun yang akan
dibahas dalam bab ini adalah penjadwalan pada sistem prosesor jamak yang memiliki
fungsi-fungsi prosesor yang memiliki fungsi yang sama (Homogeneous processors within
a multiprocessor). Diantaranya ada 2 yaitu:
1. Penjadwalan Asymmetric MultiProcessing (AMP)
Pendekatan pertama untuk penjadwalan prosesor jamak adalah penjadwalan
asymmetric multiprocessing atau biasa disebut juga sebagai penjadwalan Master
Slave MultiProcessor. Dimana pada metode ini satu prosesor bertindak sebagai
master dan prosesor lainnya sebagai slave. Master Processor bertugas untuk
menjadualkan dan mengalokasikan proses yang akan dijalankan oleh Slave
Processors. Master Processor melakukan pekerjaan yang berhubungan dengan
System, Slave Processor melayani user requests dalam pengeksekusian program.
Pemrosesan yang banyak tidak menyebabkan penurunan performance. Metode ini
sederhana karena hanya satu prosesor yang mengakses struktur data sistem dan
juga mengurangi data sharing. Sebagai contoh, prosesor master memilih proses yang
akan dieksekusi, kemudian mencari prosesor yang available, dan memberikan
instruksi start processor. Prosesor slave memulai eksekusi pada lokasi memori yang
dituju. Saat slave mengalami sebuah kondisi tertentu, prosesor slave memberi
interupsi kepada prosesor master dan berhenti untuk menunggu perintah
selanjutnya. Perlu diketahui bahwa prosesor slave yang berbeda dapat ditujukan
untuk suatu proses yang sama pada waktu yang berbeda. Master processor dapat
mengeksekusi OS dan menangani I/O, sedangkan sisanya processor tidak punya
kemampuan I/O dan disebut sebagai Attached Processor (Aps). APs mengeksekusi kodekode
user dibawah pengawasan master processor.
2. Penjadwalan Symmetric MultiProcessing (SMP)
Penjadwalan SMP adalah pendekatan kedua untuk penjadwalan prosesor jamak.
Pada metode ini setiap prosesor menjadwalkan dirinya sendiri (self scheduling).
Penjadwalan terlaksana dengan menjadwalkan setiap prosesor untuk memeriksa
antrian ready dan memilih suatu proses untuk dieksekusi. Jika suatu sistem prosesor
jamak mencoba untuk mengakses dan mengupdate suatu struktur data, penjadwal
dari prosesor-prosesor tersebut harus diprogram dengan hati-hati, kita harus yakin
bahwa dua prosesor tidak memilih proses yang sama dan proses tersebut tidak
hilang dari antrian. Secara virtual, semua sistem operasi modern mendukung SMP,
termasuk Windows XP, Windows 2000, Windows Vista, Solaris, Linux, dan Mac OS X.
Lock digunakan untuk proses sinkronisasi, apabila ada 2 atau lebih proses yang ingin
mengakses alamat memori yang sama dan mengubah shared memory. Dalam skema
tersebut, salah satu penjadwalan akan digunakan. Salah satu cara menggunakan
symmetric multiprocessing(SMP). Dimana setiap prosesor menjadwalkan diri sendiri.
Setiap prosesor memeriksa ready queue dan memilih proses yang akan dieksekusi.
Permasalahan pada prosesor jamak
1) Load sharing : dapat terjadi apabila proses yang jalan di satu prosesor overload
sehingga sebagian proses berpindah ke prosesor yang lain
2) Time Sharing : masing - masing proses akan dijalankan bila terdapat CPU yang telah
menyelesaikan job nya
3) Space Sharing: multiple threads dalam waktu yang sama masuk ke multiple CPUs
4) Gang scheduling: semua thread berasal dari proses yang running pada suatu waktu

Mikrokernel
Pendekatan mikrokernel berisi sebuah abstraksi yang sederhana terhadap hardware, dengan sekumpulan primitif atau system call yang dapat digunakan untuk membuat sebuah sistem operasi agar dapat berjalan, dengan layanan-layanan seperti manajemen thread, komunikasi antar address space, dan komunikasi antar proses. Layanan-layanan lainnya, yang biasanya disediakan oleh kernel, seperti halnya dukungan jaringan, pada pendekatan microkernel justru diimplementasikan di dalam ruangan pengguna (user-space), dan disebut dengan server.Server atau disebut sebagai peladen adalah sebuah program, seperti halnya program lainnya. Server dapat mengizinkan sistem operasi agar dapat dimodifikasi hanya dengan menjalankan program atau menghentikannya. Sebagai contoh, untuk sebuah mesin yang kecil tanpa dukungan jaringan, server jaringan (istilah server di sini tidak dimaksudkan sebagai komputer pusat pengatur jaringan) tidak perlu dijalankan. Pada sistem operasi tradisional yang menggunakan monolithic kernel, hal ini dapat mengakibatkan pengguna harus melakukan rekompilasi terhadap kernel, yang tentu saja sulit untuk dilakukan oleh pengguna biasa yang awam.Dalam teorinya, sistem operasi yang menggunakan microkernel disebut jauh lebih stabil dibandingkan dengan monolithic kernel, karena sebuah server yang gagal bekerja, tidak akan menyebabkan kernel menjadi tidak dapat berjalan, dan server tersebut akan dihentikan oleh kernel utama. Akan tetapi, dalam prakteknya, bagian dari system state dapat hilang oleh server yang gagal bekerja tersebut, dan biasanya untuk melakukan proses eksekusi aplikasi pun menjadi sulit, atau bahkan untuk menjalankan server-server lainnya.Sistem operasi yang menggunakan microkernel umumnya secara dramatis memiliki kinerja di bawah kinerja sistem operasi yang menggunakan monolithic kernel. Hal ini disebabkan oleh adanya overhead yang terjadi akibat proses input/output dalam kernel yang ditujukan untuk mengganti konteks (context switch) untuk memindahkan data antara aplikasi dan server.Beberapa sistem operasi yang menggunakan microkernel:IBM AIX, sebuah versi UNIX dari IBMAmoeba, sebuah kernel yang dikembangkan untuk tujuan edukasiKernel Mach, yang digunakan di dalam sistem operasi GNU/Hurd, NexTSTEP, OPENSTEP, dan Mac OS/XMinix, kernel yang dikembangkan oleh Andrew Tanenbaum untuk tujuan edukasiSymbian OS, sebuah sistem operasi yang populer digunakan pada hand phone, handheld device, embedded device, dan PDA Phone.

Concurrency: Mutual Exclusion & Synchronization

Postingan berikut ini akan sedikit menjelaskan tentang apa itu definisi dari Proses, Thread, Mutual Exclution, Race Condition, Sinkronisasi, Deadlock, Starvation, Monitor, dan Semaphore. mudah-mudahan bermanfaat….
Proses
Secara tidak langsung, proses merupakan 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 metoda, 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 mencakup program counter, register, dan variabel di dalamnya.
Perbedaan antara program dengan proses adalah program merupakan entitas yang pasif, yaitu suatu file yang berisi kumpulan instruksi-instruksi yang disimpan di dalam disk (file executable), sedangkan proses merupakan entitas yang 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. Intinya 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 membuat 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 salinan yang berbeda pada mail program, atau pengguna yang sama dapat meminta banyak salinan dari program editor. Tiap-tiap proses ini adalah 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.
Thread
Proses merupakan sebuah program yang mengeksekusi thread tunggal. Kendali 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 mengeksekusi multi-threads. Misalnya user melakukan pekerjaan secara bersamaan yaitu mengetik dan menjalankan pemeriksaan ejaan didalam proses yang sama.
Gambar Diagram yang menggambarkan penukaran dari proses ke proses oleh CPU
proses
Thread merupakan unit dasar dari penggunaan CPU, yang terdiri dari Thread ID, program counter, register set, dan stack. Sebuah thread berbagi code section, data section, dan sumber daya system 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. Perbedaannya ialah proses dengan thread yang banyak mengerjakan lebih dari satu tugas pada satu satuan waktu.
Pada umumnya, perangkat lunak yang berjalan pada komputer modern dirancang 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.
Terkadang ada sebuah aplikasi yang perlu menjalankan beberapa tugas yang serupa. Sebagai contohnya sebuah web server dapat mempunyai ratusan klien yang mengaksesnya secara concurrent. Kalau web server berjalan sebagai proses yang hanya mempunyai thread tunggal maka ia hanya dapat 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 multi-threading. 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.
Mutual Exclution
Mutual Exclusion adalah suatu cara yang menjamin jika ada sebuah proses yang menggunakan variabel atau berkas yang sama (digunakan juga oleh proses lain), maka proses lain akan dikeluarkan dari pekerjaan yang sama. Jadi, Mutual Exclusive terjadi ketika hanya ada satu proses yang boleh memakai sumber daya, dan proses lain yang ingin memakai sumber daya tersebut harus menunggu hingga sumber daya tadi dilepaskan atau tidak ada proses yang memakai sumber daya tersebut.
Pengertian lain Mutual exclusion adalah jaminan hanya satu proses yang mengakses sumber daya pada suatu interval waktu tertentu, sedangkan proses lain dilarang mengerjakan hal yang sama -> contoh : sumberdaya printer hanya bisa diakses 1 proses, tidak bisa bersamaan -> sumber daya ini disebut sumber daya kritis.
Bagian program yang sedang mengakses memori atau sumberdaya yang dipakai bersama disebut critical section / region. Kesuksesan proses-proses kongkuren memerlukan pendefinisian critical section dan memaksakan mutual exclusion diantara proses-proses kongkuren yang sedang berjalan. Pemaksaan mutual exclusion merupakan landasan pemrosesan kongkuren, namun pemaksaan mutual exclusion dapat menimbulkan 2 masalah yaitu :
  • Deadlock
Adalah banyak proses yang saling menunggu hasil dari proses yang lain untuk dapat melanjutkan atau menyelesaikan tugasnya.
Contoh :
    • 2 proses : P1 dan P2
Dua sumber daya kritis, R1 dan R2
Proses P1 dan P2 harus mengakses kedua sumber daya
Skenario berikut dapat terjadi : R1 diberikan ke P1 sedang R2 diberikan ke P2
Karena untuk melanjutkan eksekusi memerlukan kedua sumberdaya sekaligus maka kedua proses akan saling menunggu sumber daya lain selamanya. Kedua proses dalam kondisi deadlock, tidak dapat membuat kemajuan apapun.
  • Startvation
Adalah suatu proses akan menunggu suatu kejadian atau hasil suatu proses lain supaya dapat menyelesaikan tugasnya, tetapi kejadian yang ditunggu tidak pernah terjadi karena selalu diambil lebih dulu oleh proses yang lain.
Contoh :
      • Tiga proses : P1, P2, P3
P1,P2,P3 memerlukan pengaksesan sumber daya R secara periodik
Skenario berikut dapat terjadi :
        • P1 diberi sumberdaya R, P2 dan P3 blocked menunggu sumber daya R
        • Ketika P1 keluar dari critical section, P2 dan P3 diijinkan mengakses R
        • Asumsi P3 diberi hak akses, kemudian setelah selesai hak akses kembali diberikan ke P1 yang saat itu kembali membutuhkan sumberdaya R.
Jika pemberian hak akses terus-menerus antara P1 dan P3, maka P2 tidak pernah memperoleh pengaksesan sumberdaya R, meski tidak ada deadlock. Pada situasi ini P2 mengalami startvation
Pada sistem dengan banyak proses (sistem kongkuren) terdapat 3 kategori interaksi diantara proses-proses, yaitu :
mutual-exclusion

Race Condition

Race Condition adalah suatu kondisi dimana beberapa proses mengakses dan memanipulasi suatu data secara konkuren. Nilai akhir dari data tersebut tergantung dari proses mana yang terakhir selesai dieksekusi. Race condition merupakan masalah yang dapat terjadi pada beberapa proses yang memanipulasi suatu data secara konkruen, sehingga data tersebut tidak sinkron lagi. Nilai akhirnya akan tergantung pada proses mana yang terakhir dieksekusi. Pada saat proses-proses berbagi data, ada kemungkinan bahwa data yang dibagi secara bersama itu akan menjadi tidak konsisten, karena ada kemungkinan proses-proses tersebut melakukan akses secara bersamaan yang menyebabkan data tersebut berubah, hal ini disebut dengan Race Condition.
Kesimpulannya Race condition terjadi ketika:
  • Banyak proses atau thread membaca & menulis item data,
  • Hasil akhir dari aktifitas baca & tulis tersebut tergantung pada urutan eksekusi dari proses yang terlibat.
Untuk menghindari Race Condition inilah dilakukan apa yang dinamakan Proses Sinkronisasi.

Synchronization
Apakah sinkronisasi itu sebenarnya? Dan mengapa kita memerlukan sinkronisasi tersebut? Marilah kita pelajari lebih lanjut mengenai sinkronisasi. Seperti yang telah kita ketahui bahwa proses dapat bekerja sendiri (independent process) dan juga dapat bekerja bersama proses-proses yang lain (cooperating process).
Apa kegunaan sinkronisasi dalam hubungannya dengan sistem operasi? Sinkronisasi diperlukan untuk menghindari terjadinya ketidakkonsistenen data akibat adanya akses data secara konkuren. Disini sinkronisasi diperlukan agar data tersebut tetap konsisten.
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 memblok samapai pesan tersedia.
  • Penerimaan yang tidak diblok: Penerima mengembalikan pesan valid atau null.
Kesimpulannya:
  • Komunikasi memerlukan sinkronisasi
    • Sender (pengirim) harus mengirim sebelum receiver (penerima) dapat menerima,
  • Apa yang terjadi terhadap proses setelah ia menjalankan primitif send atau receive?
    • Sender & receiver mungkin (bisa pula tidak) menjadi blocking (waiting for message).

Deadlock

Deadlock dalam arti sebenarnya adalah kebuntuan. Kebuntuan yang dimaksud dalam sistem operasi adalah kebuntuan proses. Jadi Deadlock ialah suatu kondisi dimana proses tidak berjalan lagi atau pun tidak ada komunikasi lagi antar proses. Deadlock disebabkan karena proses yang satu menunggu sumber daya yang sedang dipegang oleh proses lain yang sedang menunggu sumber daya yang dipegang oleh proses tersebut. Dengan kata lain setiap proses dalam set menunggu untuk sumber yang hanya dapat dikerjakan oleh proses lain dalam set yang sedang menunggu. Contoh sederhananya ialah pada gambar berikut ini.
Contoh 23.1. XXX
Proses P1 Proses P2
….. …..
….. …..
Receive (P2); Receive (P1);
….. …..
….. …..
Send (P2, M1); Send (P1, M2);
Proses tersebut dapat direpresentasikan dengan gambar sebagai berikut.
exc-deadlock
Dari gambar tersebut bisa dilihat bahwa kedua kereta tersebut tidak dapat berjalan. Karena kedua kereta tersebut saling menunggu kereta yang lain untuk lewat dulu agar keretanya dapat berjalan. Sehingga terjadilah Deadlock.
exc-deadlock2
Contoh lain yang dapat merepresentasikan Deadlock ialah jembatan gantung sebagai berikut. Sehingga orang yang ada di sebelah kiri jembatan tidak dapat melaju sebab terjadi Deadlock di tengah jembatan (bagian yang dilingkari). Contoh lain ialah di persimpangan jalan berikut ini:
exc-deadlock3
Dalam kasus ini setiap mobil bergerak sesuai nomor yang ditentukan, tetapi tanpa pengaturan yang benar, maka setiap mobil akan bertemu pada satu titik yang permanen (yang dilingkari) atau dapat dikatakan bahwa setiap mobil tidak dapat meanjutkan perjalanan lagi atau dengan kata lain terjadi Deadlock. Contoh lain pada proses yang secara umum terdiri dari tiga tahap, yaitu untuk meminta, memakai, dan melepaskan sumber daya yang di mintanya. Contoh kode-nya:
Contoh 23.2. Lalulintas
public class Proses {
public synchronized void getA() {
//proses untuk mendapat sumber daya a
}
public synchronized void getB(){
//proses untuk mendapat sumber daya b
}
public void releaseA(){
//proses untuk melepaskan sumber daya a
}
public void releaseB(){
//proses untuk melepaskan sumber daya b
}
}
public class Coba {
public static void main(String [] args) {
Proses P = new Proses();
Proses Q = new Proses();
P.getA();
Q.getB();
P.getB();
Q.getA();
}
}
Tanpa adanya perintah untuk mereleased artinya saat P mendapatkan A dan Q mendapatkan B, tetapi tidak dilepaskan, maka saat P minta B dan Q minta A, maka keduanya akan saling menunggu hingga salah satu melepaskan sumber dayanya, sedangkan kebutuhan P ada pada Q dan Q ada pada P, sehingga terjadi Deadlock. Secara umum kejadian ini dapat mudah terjadi dalam pemrograman multi-thread. Sebab ada kemungkinan lebih besar untuk menggunakan sumber daya bersama.
Starvation
indefinite blocking (starvation) yaitu suatu proses dengan prioritas yang rendah memiliki kemungkinan untuk tidak dieksekusi jika terdapat proses lain yang memiliki prioritas lebih tinggi darinya. Solusi dari permasalahan ini adalah aging, yaitu meningkatkan prioritas dari setiap proses yang menunggu dalam antrian secara bertahap.
Misalnya:
starvation
Monitor
Konsep monitor diperkenalkan pertama kali oleh Hoare (1974) dan Brinch Hansen (1975) untuk mengatasi beberapa masalah yang timbul ketika memakai semafor.
Monitor merupakan kumpulan dari prosedur, variabel, dan struktur data dalam satu modul. Monitor hanya dapat diakses dengan menjalankan fungsinya. Kita tidak dapat mengambil variabel dari monitor tanpa melalui prosedurnya. Hal ini dilakukan untuk melindungi variabel dari akses yang tidak sah dan juga mengurangi terjadinya error. Dengan mempergunakan monitor, sebuah proses dapat memanggil prosedur di dalam monitor, tetapi tidak dapat mengakses struktur data (termasuk variabel- variabel) internal dalam monitor. Dengan karakteristik demikian, monitor dapat mengatasi manipulasi yang tidak sah terhadap variabel yang diakses bersama-sama karena variabel lokal hanya dapat diakses oleh prosedur lokal.
Monitor tetap mempertahankan kondisi mutual eksklusifnya dengan membatasi hanya satu proses yang dapat aktif dalam monitor dalam suatu waktu. Yang mengatur kondisi tersebut adalah kompiler dan bukan programmer. Ternyata, mempertahakankan kondisi mutual eksklusif saja tidaklah cukup. Diperlukan juga suatu cara untuk memblok suatu proses jika ia tidak dapat terus berjalan. Misalnya dalam masalah bounded buffer, proses harus diblok ketika buffer telah penuh. Oleh karena itu, monitor harus diperlengkapi dengan mekanisme sinkronisasi yang lain. Salah satu mekanisme yang dipergunakan adalah variabel kondisi yang terdapat dalam monitor dan hanya dapat diakses oleh monitor.
shared variable declarations
void bodyP1 (….)
{
……
}
void bodyP2 (….)
{
……
}
…..
void bodyPn (….)
{
……
}
void main{
initialization code
}
Konstruksi monitor memastikan hanya satu proses yang aktif pada suatu waktu. Sehingga sebenarnya programmer tidak membutuhkan synchronization codes yang disisipkan secara eksplisit. Akan tetapi konstruksi monitor tidak benar-benar powerfull untuk modelisasi sebuah skema synchronization, sehingga perlu ditambahkan mekanisme sinkronisasi tambahan. Mekanisme ini disediakan oleh konstruksi conditional, seperti deklarasi variabel di bawah ini:
condition x,y; wait dan signal merupakan operasi-operasi yang dapat dipanggil dalam variabel kondisi.
monitor
Operasi x.wait menahan proses sampai proses lain memanggil x.signal. Operasi x.signal melanjutkan proses yang tertahan, jika tidak ada proses yang tertahan operasi ini tidak mempunyai pengaruh apa-apa. Misalkan x.signal dipanggil oleh proses P, lalu ada proses Q tertahan dan diasosiasikan dengan kondisi x. Jelasnya jika proses Q yang tertahan diijinkan untuk melanjutkan eksekusinya, pensinyalan proses P harus menunggu. Jika tidak kedua P dan Q akan aktif secara simultan melalui monitor. Ada dua kemungkinan yang terjadi yaitu:
1. P menunggu sampai Q meninggalkan monitor atau menunggu untuk kondisi lain
2. Q menunggu sampai Pmeninggalkan monitor atau menunggu untuk kondisi lain.
monitor2
Monitor merupakan konsep bahasa pemrograman, sehingga kompilator bertanggung jawab dalam mengkondisikan monitor sebagai mutual eksklusif. Namun, tidak semua kompilator bias menerapkannya. Sehingga meski bahasa pemrograman yang sama mungkin tidak memiliki semaphore, akan tetapi menambahkan semaphore akan lebih mudah.
Semaphore
Masalah critical section bisa diselesaikan dengan penggunaan Instruksi Atomik. Akan tetapi, cara tersebut tidak mudah untuk diterapkan pada masalah yang lebih kompleks, misalnya ada lebih dari dua proses yang berjalan. Untuk mengatasi hal ini, kita dapat menggunakan alat sinkronisasi yang dinamakan semaphore. Semaphore S merupakan sebuah variabel integer yang diakses hanya melalui dua operasi standar atomik yaitu wait dan signal.
void wait(int s){
while (s<=0){no-op;}
s=s-1;
}
void signal(s){
s=s+1
}
Berikut ini merupakan implementasi semaphore untuk mengatasi masalah critical-section.
int mutex=1;
do{
wait(mutex);
critical section
signal(mutex);
remainder section
}while(TRUE);
Dalam subrutin ini, proses akan memeriksa harga dari semaphor, apabila harganya 0 atau kurang maka proses akan menunggu, sebaliknya jika lebih dari 0, maka proses akan mengurangi nilai dari semaphore tersebut dan menjalankan operasi yang lain. Arti dari harga semaphore dalam kasus ini adalah hanya boleh satu proses yang dapat melewati subrutin wait pada suatu waktu tertentu, sampai ada salah satu atau proses itu sendiri yang akan memanggil signal.

Jenis-Jenis Thread

Dalam sub bab sebelumnya telah dibahas pengertian dari thread, keuntungannya, tingkatan atau levelnya seperti pengguna dan kernel. Maka dalam subbab ini pembahasan akan dilanjutkan dengan jenis-jenis thread tersebut dan contohnya baik pada Solaris mau pun Java.

Model Multithreading

Sistem-sistem yang ada sekarang sudah banyak yang bisa mendukung untuk kedua pengguna dan kernel thread, sehingga model-model multithreading-nya pun menjadi beragam. Implementasi multithreading yang umum akan kita bahas ada tiga, yaitu model many-to-one, one-to-one, dan many-to-many.

Gambar XXX Model Multithreading

Model Many to One

Model many-to-one ini memetakan beberapa tingkatan pengguna thread hanya ke satu buah kernel thread. Managemen proses thread dilakukan oleh (di ruang) pengguna, sehingga menjadi efisien, tetapi apabila sebuah thread melakukan sebuah pemblokingan terhadap sistem pemanggilan, maka seluruh proses akan berhenti (blocked). Kelemahan dari model ini adalah multihreads tidak dapat berjalan atau bekerja secara paralel di dalam multiprosesor dikarenakan hanya satu thread saja yang bisa mengakses kernel dalam suatu waktu.

Gambar XXX Model Many to One

Model One to One

Model one-to-one memetakan setiap thread pengguna ke dalam satu kernel thread. Hal ini membuat model one-to-one lebih sinkron daripada model many-to-one dengan mengizinkan thread lain untuk berjalan ketika suatu thread membuat pemblokingan terhadap sistem pemanggilan; hal ini juga mengizinkan multiple thread untuk berjalan secara parallel dalam multiprosesor. Kelemahan model ini adalah dalam pembuatan thread pengguna dibutuhkan pembuatan korespondensi thread pengguna. Karena dalam proses pembuatan kernel thread dapat mempengaruhi kinerja dari aplikasi maka kebanyakan dari implementasi model ini membatasi jumlah thread yang didukung oleh sistem. Model one-to-one diimplementasikan oleh Windows NT dan OS/2.

Gambar XXX Model One to One

Model Many to Many

Beberapa tingkatan thread pengguna dapat menggunakan jumlah kernel thread yang lebih kecil atau sama dengan jumlah thread pengguna. Jumlah dari kernel thread dapat dispesifikasikan untuk beberapa aplikasi dan beberapa mesin (suatu aplikasi dapat dialokasikan lebih dari beberapa kernel thread dalam multiprosesor daripada dalam uniprosesor) dimana model many-to-one mengizinkan pengembang untuk membuat thread pengguna sebanyak mungkin, konkurensi tidak dapat tercapai karena hanya satu thread yang dapat dijadwalkan oleh kernel dalam satu waktu. Model one-to-one mempunyai konkurensi yang lebih tinggi, tetapi pengembang harus hati-hati untuk tidak membuat terlalu banyak thread tanpa aplikasi dan dalam kasus tertentu mungkin jumlah thread yang dapat dibuat dibatasi.

Gambar XXX Model Many to Many

Thread dalam Solaris 2

Solaris 2 merupakan salah sastu versi dari UNIX yang sampai dengan tahun 1992 hanya masih mendukung proses berat (heavyweight) dengan kontrol oleh satu buah thread. Tetapi sekarang Solaris 2 sudah berubah menjadi sistem operasi yang modern yang mendukung threads di dalam level kernel dan pengguna, simetrik multiproses (SMP), dan penjadwalan real-time.
Threads di dalam Solaris 2 sudah dilengkapi dengan library mengenai API-API untuk pembuatan dan managemen thread. Di dalam Solaris 2 terdapat juga level tengah thread. Di antara level pengguna dan level kernel thread terdapat proses ringan/ lightweight (LWP). Setiap proses yang ada setidaknya mengandung minimal satu buah LWP. Library thread memasangkan beberapa thread level pengguna ke ruang LWP-LWP untuk diproses, dan hanya satu user-level thread yang sedang terpasang ke suatu LWP yang bisa berjalan. Sisanya bisa diblok mau pun menunggu untuk LWP yang bisa dijalankan.
Operasi-operasi di kernel seluruhnya dieksekusi oleh kernel-level threads yang standar. Terdapat satu kernel-level thread untuk tiap LWP, tetapi ada juga beberapa kernel-level threads yang berjalan di bagian kernel tanpa diasosiasikan dengan suatu LWP (misalnya thread untuk pengalokasian disk). Thread-thread kernel-level merupakan satu-satunya objek yang dijadwalkan ke dalam sistem (lihat Bab 6 mengenai scheduling). Solaris menggunakan model many-to-many.
Thread level pengguna dalam Solaris bisa berjenis bound mau pun unbound. Suatu bound thread level pengguna secara permanen terpasang ke suatu LWP. Jadi hanya thread tersebut yang bekerja di LWP, dan dengan suatu permintaan, LWP tersebut bisa diteruskan ke suatu prosesor. Dalam beberapa situasi yang membutuhkan waktu respon yang cepat (seperti aplikasi real-time), mengikat suatu thread sangatlah berguna. Suatu thread yang unbound tidak secara permanen terpasang ke suatu LWP. Semua threads unbound dipasangkan (secara multiplex) ke dalam suatu ruang yang berisi LWP-LWP yang tersedia untuk aplikasi. Secara default thread-thread yang ada adalah unbound.
Misalnya sistem sedang beroperasi, setiap proses bisa mempunyai threads level pengguna yang banyak. User-user level thread ini bisa dijadwal dan diganti di antara LWP-LWP-nya oleh thread library tanpa intervensi dari kernel. User-level threads sangatlah efisien karena tidak dibutuhkan bantuan kerja kernel oleh thread library untuk menukar dari satu user-level thread ke yang lain.
Setiap LWP terpasang dengan tepat satu kernel-level thread, dimana setiap user-level thread tidak tergantung dari kernel. Suatu proses mungkin mempunyai banyak LWP, tetapi mereka hanya dibutuhkan ketika thread harus berkomunikasi dengan kernel. Misalnya, suatu LWP akan dibutuhkan untuk setiap thread yang bloknya konkuren di sistem pemanggilan. Anggap ada lima buah pembacaan berkas yang muncul. Jadi dibutuhkan lima LWP, karena semuanya mungkin mengunggu untuk penyelesaian proses I/O di kernel. Jika suatu proses hanya mempunyai empat LWP, maka permintaan yang kelima harus menunggu unuk salah satu LWP kembali dari kernel. Menambah LWP yang keenam akan sia-sia jika hanya terdapat tempat untuk lima proses.
Kernel-kernel threads dijadwal oleh penjadwal kernel dan dieksekusi di CPU atau CPU-CPU dalam sistemnya. Jika suatu kernel thread memblok (misalnya karena menunggu penyelesaian suatu proses I/O), prosesor akan bebas untuk menjalankan kernel thread yang lain. Jika thread yang sedang terblok sedang menjalankan suatu bagian dari LWP, maka LWP tersebut akan ikut terblok. Di tingkat yang lebih atas lagi, user-level thread yang sedang terpasang ke LWP tersebut akan terblok juga. Jika suatu proses mempunyai lebih dari satu LWP, maka LWP lain bisa dijadwal oleh kernel.
Para pengembang menggunakan struktur-struktur data sebagai berikut untuk mengimplementasikan thread-thread dalam Solaris 2:
  • Suatu user-level thread mempunyai thread ID, himpunan register (mencakup suatu PC dan stack pointer), stack dan prioritas (digunakan oleh library untuk penjadwalan). Semua struktur data tersebut berasal dari ruang user.
  • Suatu LWP mempunyai suatu himpunan register untuk user-level thread yang ia jalankan, juga memori dan informasi pencatatan. LWP merupakan suatu struktur data dari kernel, dan bertempat pada ruang kernel.
  • Suatu kernel thread hanya mempunyai struktur data yang kecil dan sebuah stack. Struktur datanya melingkupi copy dari kernel-kernel registers, suatu pointer yang menunjuk ke LWP yang terpasang dengannya, dan informasi tentang prioritas dan penjadwalan.
Setiap proses dalam Solaris 2 mempunyai banyak informasi yang terdapat di process control block (PCB). Secara umum, suatu proses di Solaris mempunyai suatu proses id (PID), peta memori, daftar dari berkas yang terbuka, prioritas, dan pointer yang menunjuk ke daftar LWP yang terasosiasi kedalam proses.

Gambar XXX Thread Solaris dan Java

Thread Java

Seperti yang telah kita lihat, thread didukung selain oleh sistem operasi juga oleh paket library thread. Sebagai contoh, Win32 library mempunyai API untuk multithreading aplikasi Windows, dan Pthreads mempunyai fungsi manajmen thread untuk sistem POSIX-compliant. Java adalah unik dalam mendukung tingkatan bahasa untuk membuat dan managemen thread.
Semua program java mempunyai paling sedikit satu kontrol thread. Bahkan program java yang sederhana mempunyai hanya satu main() method yang berjalan dalam thread tunggal dalam JVM. Java menyediakan perintah-perintah yang mendukung pengembang untuk membuat dan memanipulasi kontrol thread pada program.

Pembuatan Thread

Satu cara untuk membuat thread secara eksplisit adalah dengan membuat kelas baru yang diturunkan dari kelas thread, dan menimpa run() method dari kelas Thread tersebut.
Object yang diturunkan dari kelas tersebut akan menjalankan sebagian thread control dalam JVM. Bagaimana pun, membuat suatu objek yang diturunkan dari kelas Thread tidak secara spesifik membuat thread baru, tetapi start() method lah yang sebenarnya membuat thread baru.
Memanggil start ( ) method untuk objek baru mengalokasikan memori dan menginisialisasikan thread baru dalam JVM dan memanggil run ( ) method membuat thread pantas untuk dijalankan oleh JVM. (Catatan: jangan pernah memanggil run ( ) method secara langsung. Panggil start ( ) method dan ini secara langsung akan memanggil run ( ) method).
Ketika program ini dijalankan, dua thread akan dibuat oleh JVM. Yang pertama dibuat adalah thread yang berasosiasi dengan aplikasi - thread tersebut mulai dieksekusi pada main ( ) method. Thread kedua adalah runner thread secara ekspilisit dibuat dengan start () method. Runner thread memulai eksekusinya dengan run ( ) method.
Pilihan lain untuk membuat sebuah thread yang terpisah adalah dengan mendefinisikan suatu kelas yang mengimplementasikan runnable interface. Runnable interface tersebut didefinisikan sebagai berikut:
Public interface Runnable
 {
  Public abstract void run ();
 }
 
Sehingga, ketika sebuah kelas diimplementasikan dengan runnable, kelas tersebut harus mendefinisikan run( ) method (Kelas thread yang berfungsi untuk mendefinisikan static dan instance method, juga mengimplementasikan runnable interface. Itu menerangkan bahwa mengapa sebuah kelas diturunkan dari thread harus mendefinisikan run( ) method).
Implementasi dari runnable interface sama dengan mengekstend kelas thread, satu - satunya kemungkinan untuk mengganti "extends thread" dengan "implements runnable".
Class worker2 implements Runnable
 {
  Public void run ( ) {
     System. Out. Println ("I am a worker thread. ");
  }
 }
 
Membuat sebuah thread dari kelas yang diimplementasikan oleh runnable berbeda dengan membuat thread dari kelas yang mengekstend thread. Selama kelas baru tersebut tidak mengekstend thread, dia tidak mempunyai akses ke objek static atau instance method — seperti start ( ) method — dari kelas thread. Bagaimana pun, sebuah objek dari kelas thread adalah tetap dibutuhkan, karena yang membuat sebuah thread baru dari kontrol adalah start ( ) method.
Di kelas kedua, sebuah objek thread baru dibuat melalui runnable objek dalam konstruktornya. Ketika thread dibuat oleh start ( ) method, thread baru mulai dieksekusi pada run ( ) method dari runnable objek. Kedua method dari pembuatan thread tersebut adalah cara yang paling sering digunakan.

Managemen Thread

Java menyediakan beberapa fasilitas API untuk mengatur thread — thread, diantaranya adalah:

  • Suspend(): berfungsi untuk menunda eksekusi dari thread yang sedang berjalan.
  • Sleep(): berfungsi untuk menempatkan thread yang sedang berjalan untuk tidur dalam beberapa waktu.
  • Resume(): hasil eksekusi dari thread yang sedang ditunda.
  • Stop(): menghentikan eksekusi dari sebuah thread; sekali thread telah dihentikan dia tidak akan memulainya lagi.
Setiap method yang berbeda untuk mengontrol keadaan dari thread mungkin akan berguna dalam situasi tertentu. Sebagai contoh: Applets adalah contoh alami untuk multithreading karena mereka biasanya memiliki grafik, animasi, dan audio — semuanya sangat baik untuk mengatur berbagai thread yang terpisah. Bagaimana pun, itu tidak akan mungkin bagi sebuah applet untuk berjalan ketika dia sedang tidak ditampilkan, jika applet sedang menjalankan CPU secara intensif. Sebuah cara untuk menangani situasi ini adalah dengan menjalankan applet sebagai thread terpisah dari kontrol, menunda thread ketika applet sedang tidak ditampilkan dan melaporkannya ketika applet ditampilkan kembali.
Anda dapat melakukannya dengan mencatat bahwa start() method dari sebuah applet dipanggil ketika applet tersebut pertama kali ditampilkan. Apabila user meninggalkan halaman web atau applet keluar dari tampilan, maka method stop() pada applet dipanggil (ini merupakan suatu keuntungan karena start() dan stop() keduanya terasosiasi dengan thread dan applet). Jika user kembali ke halaman web applet, kemudian start() method dipanggil kembali. Destroy() method dari sebuah applet dipanggil ketika applet tersebut dipindahkan dari cache-nya browser. Ini memungkinkan untuk mencegah sebuah applet berjalan ketika applet tersebut sedang tidak ditampilkan pada sebuah web browser dengan menggunakan stop() method dari applet yang ditunda dan melaporkan eksekusi tersebut pada thread di applet start() method.

Keadaan Thread

Sebuah thread java dapat menjadi satu dari 4 kemungkinan keadaan:

  1. new: sebuah thread pada keadaan ini ada ketika objek dari thread tersebut dibuat.
  2. runnable: memanggil start() method untuk mengalokasikan memori bagi thread baru dalam JVM dan memanggil run() method untuk membuat objek.
  3. block: sebuah thread akan diblok jika menampilkan sebuah kalimat pengeblokan. Contohnya: sleep() atau suspend().
  4. dead: sebuah thread dipindahkan ke keadaan dead ketika run() method berhenti atau ketika stop() method dipanggil.

Gambar XXX Keadaan Thread

Thread dan JVM

Pada penambahannya ke java program mengandung beberapa thread yang berbeda dari kontrol, disini ada beberapa thead yang sedang berjalan secara tidak sinkron untuk kepentingan dari penanganan sistem tingkatan JVM seperti managemen memori dan grafik kontrol. Garbage Collector mengevaluasi objek ketika JVM untuk dilihat ketika mereka sedang digunakan. Jika tidak, maka itu akan kembali ke memori dalam sistem.

JVM dan Sistem Operasi

Secara tipikal implementasi dari JVM adalah pada bagian atas terdapat host sistem operasi, pengaturan ini mengizinkan JVM untuk menyembunyikan detail implementasi dari sistem operasi dan menyediakan sebuah kekonsistenan, lingkungan yang abstrak tersebut mengizinkan program-program java untuk beroprasi pada berbagai sistem operasi yang mendukung sebuah JVM. Spesifikasi bagi JVM tidak mengidentifikasi bagaimana java thread dipetakan ke dalam sistem operasi.

Contoh Solusi Multithreaded

Pada bagian ini, kita memperkenalkan sebuah solusi multithreaded secara lengkap kepada masalah produser konsumer yang menggunakan penyampaian pesan. Kelas server pertama kali membuat sebuah mailbox untuk mengumpulkan pesan, dengan menggunakan kelas message queue kemudian dibuat produser dan konsumer threads secara terpisah dan setiap thread mereferensi ke dalam mailbox bersama. Thread produser secara bergantian antara tidur untuk sementara, memproduksi item, dan memasukkan item ke dalam mailbox. Konsumer bergantian antara tidur dan mengambil suatu item dari mailbox dan mengkonsumsinya. Karena receive () method dari kelas message queue adalah tanpa pengeblokan, konsumer harus mencek apakah pesan yang diambilnya tersebut adalah nol.

2 komentar:

  1. cing atuh tulisana sing alus, ulah make leungeun kede hahaha ..

    BalasHapus
  2. keterkaitan antara critical region, race condition dan deadlock apa ya ?

    BalasHapus