modul 4 - proses

MODUL PERKULIAHAN

Sistem Operasi

Proses

Fakultas Program Studi Tatap Muka Kode MK Disusun Oleh

Fakultas Ilmu Komputer

Teknik Informatika

04 Sukma Wardhana, M.Kom.

Abstract Kompetensi

Sistem komputer awal hanya diperbolehkan satu program yang akan dieksekusi pada satu waktu. Program ini memiliki kontrol penuh terhadap sistem, dan memiliki akses ke semua sumber daya sistem. Sistem komputer saat ini-hari memungkinkan beberapa program yang akan dimuat ke memori dan dieksekusi secara bersamaan.

Mahasiswa diharapkan mampu memahami mengenai proses.

2013 2 Sistem Operasi Pusat Bahan Ajar dan eLearning

Sukma Wardhana, M.Kom, http://www.mercubuana.ac.id

PROSES

Sistem komputer awal hanya diperbolehkan satu program yang akan dieksekusi pada satu

waktu. Program ini memiliki kontrol penuh terhadap sistem, dan memiliki akses ke semua

sumber daya sistem. Sistem komputer saat ini-hari memungkinkan beberapa program yang

akan dimuat ke memori dan dieksekusi secara bersamaan. Evolusi ini diperlukan kontrol yang

lebih kuat dan lebih kompartementalisasi dari berbagai pro¬grams. Kebutuhan ini

mengakibatkan pengertian proses, yang merupakan program dalam eksekusi. Proses adalah

unit kerja dalam sistem time-sharing modern.

Semakin kompleks sistem operasi, semakin diharapkan untuk melakukan atas nama

penggunanya. Meskipun perhatian utamanya adalah pelaksanaan program pengguna, itu

juga perlu untuk mengurus berbagai tugas sistem yang lebih baik ditinggalkan di luar kernel

itu sendiri. Oleh karena itu sistem terdiri dari kumpulan proses: proses sistem Operating-

mengeksekusi kode sistem, dan proses pengguna mengeksekusi kode pengguna. Semua

proses ini berpotensi dapat mengeksekusi bersamaan, dengan CPU (atau CPU) multiplexing

antara mereka. Dengan beralih CPU antara proses, sistem operasi dapat membuat komputer

lebih produktif.

4. 1 Konsep Proses

Salah satu halangan untuk pembahasan sistem operasi adalah pertanyaan apa yang harus

memanggil semua kegiatan CPU. Sebuah sistem batch mengeksekusi pekerjaan, sedangkan

sistem waktu bersama memiliki program pengguna, atau tugas. Bahkan pada sistem single-

user, seperti MS-DOS dan Macintosh OS, pengguna mungkin dapat menjalankan beberapa

program pada satu waktu: satu program batch yang interaktif dan beberapa. Bahkan jika

pengguna dapat mengeksekusi hanya satu

program pada satu waktu, sistem operasi perlu mendukung kegiatan sendiri internal yang

diprogram, seperti spooling. Dalam banyak hal, semua kegiatan yang serupa, jadi kita sebut

mereka semua proses.

Istilah kerja dan proses yang digunakan hampir bergantian dalam teks ini. Meskipun kami

pribadi lebih suka proses panjang, banyak teori sistem operasi dan terminologi dikembangkan

selama waktu ketika sistem operasi kegiatan utama adalah pengolahan pekerjaan. Akan

menyesatkan untuk menghindari penggunaan istilah umum diterima yang mencakup

pekerjaan kata (seperti penjadwalan job) hanya karena proses istilah digantikan itu.



4.1.1 Proses

Secara informal, proses adalah program dalam eksekusi. Pelaksanaan proses harus maju

secara berurutan. Artinya, setiap saat, paling banyak satu instruksi dieksekusi atas nama

proses.

Proses adalah lebih dari kode program (kadang-kadang dikenal sebagai bagian teks). Hal ini

juga mencakup kegiatan saat ini, yang diwakili oleh nilai dari program counter dan isi dari

register prosesor. Sebuah proses umumnya juga termasuk proses stack, yang berisi data

sementara (seperti parameter subrutin, alamat kembali, dan variabel sementara), dan bagian

data yang berisi variabel global.

Kami menekankan bahwa program dengan sendirinya bukan proses; Program adalah sebuah

entitas pasif, seperti isi file yang disimpan pada disk, sedangkan proses adalah suatu entitas

aktif, dengan sebuah program counter menentukan instruksi berikutnya untuk mengeksekusi

dan seperangkat sumber daya yang terkait.

Meskipun dua proses dapat dikaitkan dengan program yang sama, mereka tetap dianggap

dua urutan eksekusi yang terpisah. Sebagai contoh, beberapa pengguna mungkin

menjalankan salinan program mail, atau pengguna yang sama dapat memanggil banyak

salinan dari program editor. Masing-masing adalah proses yang terpisah, dan, meskipun

bagian teks adalah sama, bagian data yang akan bervariasi. Itu adalah

juga umum untuk memiliki proses yang memunculkan banyak proses yang berjalan. Masalah

ini akan dibahas lebih lanjut dalam Bagian 4.4.

4.1.2 Process State

Sebagai suatu proses mengeksekusi, itu perubahan negara. Keadaan dari sebuah proses

didefinisikan dalam bagian oleh aktivitas saat ini proses tersebut. Setiap proses mungkin di

salah satu negara berikut:

• New: Proses sedang dibuat.

• Menjalankan: Instruksi sedang dieksekusi.

• Waiting: proses menunggu beberapa event terjadi (seperti I / O selesai atau

penerimaan sinyal).

• Siap: Proses sedang menunggu untuk ditugaskan ke prosesor.

• Dihentikan: Proses telah selesai eksekusi.

Nama-nama ini sewenang-wenang, dan berbeda antara sistem operasi. Negara-negara yang

mereka wakili ditemukan pada semua sistem, namun. Sistem operasi tertentu juga

membedakan antara lebih halus menggambarkan negara proses. Adalah penting untuk

menyadari bahwa hanya satu proses dapat berjalan pada prosesor pada setiap saat. Banyak

proses mungkin siap dan menunggu, namun.



4.1.3 Proses Control Block

Setiap proses direpresentasikan dalam sistem operasi dengan blok kontrol proses (PCB) -

juga disebut blok kontrol tugas. Terdiri banyak potongan informasi yang terkait dengan proses

tertentu, termasuk ini:

negara Proses: Negara mungkin baru, siap, berjalan, menunggu, berhenti, dan sebagainya.

counter Program: Counter mengindikasikan address dari instruksi berikutnya yang akan

dieksekusi untuk proses ini.

CPU register: Register bervariasi dalam jumlah dan jenis, tergantung pada arsitektur

komputer. Mereka termasuk akumulator, register indeks, tumpukan pointer, dan register

tujuan umum, ditambah kondisi-kode informa¬tion. Seiring dengan program counter, informasi

negara ini harus disimpan ketika interrupt terjadi, untuk memungkinkan proses untuk

dilanjutkan benar sesudahnya (Gambar 4.3).

informasi penjadwalan CPU: Informasi ini termasuk prior¬ity proses, pointer ke antrian

penjadwalan, dan setiap parameter penjadwalan lainnya. (Bab 5 menjelaskan proses

penjadwalan.)

informasi Memory-manajemen: Informasi ini dapat mencakup informasi seperti nilai dasar dan

batas register, tabel halaman, atau tabel segmen tergantung pada sistem memori yang

digunakan oleh sistem operasi (Bab 8).

• Informasi Akuntansi: Informasi ini termasuk jumlah CPU dan real time yang digunakan,

batas waktu, nomor rekening, nomor pekerjaan atau proses, dan sebagainya.

• I / O informasi status: Informasi meliputi daftar perangkat I / O (seperti tape drive)

dialokasikan untuk proses ini, daftar file yang terbuka, dan sebagainya.

PCB hanya berfungsi sebagai repositori untuk informasi yang mungkin berbeda dari proses

untuk memproses.

4.2 Proses Penjadwalan

Tujuan dari multiprogramming adalah untuk memiliki beberapa proses yang berjalan setiap

saat, untuk memaksimalkan penggunaan CPU. Tujuan dari pembagian waktu adalah untuk

mengganti CPU diantara proses begitu sering bahwa pengguna dapat berinteraksi dengan

setiap program ketika sedang berjalan. Untuk sistem prosesor tunggal, tidak akan pernah ada

lebih dari satu proses yang berjalan. Jika ada proses yang lebih, sisanya harus menunggu

sampai CPU bebas dan dapat dijadwalkan kembali.

4.2.1 Penjadwalan Antrian

Sebagai proses memasuki sistem, mereka dimasukkan ke dalam antrian pekerjaan. Antrian

ini terdiri semua proses dalam sistem. Proses yang berada di memori utama dan siap dan

menunggu untuk mengeksekusi disimpan pada daftar yang disebut antrian siap. Antrian ini



biasanya disimpan sebagai linked list. Sebuah sundulan siap antrian akan berisi pointer ke

PCB pertama dan terakhir dalam daftar. Setiap PCB memiliki medan pointer yang menunjuk

ke proses selanjutnya dalam ready queue.

Ada juga antrian lain dalam sistem. Ketika suatu proses dialokasikan CPU, dijalankan untuk

sementara dan akhirnya berhenti, terganggu, atau menunggu terjadinya peristiwa tertentu,

seperti selesainya suatu permintaan I / O. Dalam kasus permintaan 1/0, permintaan seperti

itu mungkin ke dedicated tape drive, atau ke perangkat bersama, seperti disk. Karena ada

banyak proses dalam sistem, disk mungkin sibuk dengan permintaan I / O dari beberapa

proses lain. Oleh karena itu, proses tersebut mungkin harus menunggu disk. Daftar proses

menunggu 1/0 perangkat tertentu disebut antrian perangkat. Setiap perangkat memiliki

perangkat antrian sendiri (Gambar 4.4).

Sebuah representasi umum untuk diskusi tentang penjadwalan proses adalah diagram

queue¬ing, seperti yang terjadi di Gambar 4.5 (pada halaman 95). Setiap kotak persegi

panjang mewakili antrian. Dua jenis antrian yang hadir: antrian siap dan satu set antrian

perangkat. Lingkaran merupakan sumber daya yang melayani antrian, dan panah

menunjukkan aliran proses dalam sistem.

Sebuah proses baru awalnya dimasukkan ke dalam antrian siap. Ini menunggu dalam antrian

siap sampai dipilih untuk eksekusi (atau dikirim) dan diberikan CPU. Setelah proses

dialokasikan CPU dan mengeksekusi, salah satu dari beberapa peristiwa bisa terjadi:

• Masalah processcould I / O permintaan, dan kemudian ditempatkan dalam sebuah I /

O antrian.

• Proses ini bisa membuat subproses yang baru dan menunggu selesainya.

• Proses dapat dihapus secara paksa dari CPU, sebagai hasilnya interupsi, dan

diletakkan kembali di ready queue.

Dalam dua kasus pertama, proses akhirnya beralih dari negara menunggu untuk status siaga,

dan kemudian dimasukkan kembali dalam antrian siap. Sebuah proses terus siklus ini sampai

berakhir, pada saat itu dihapus dari semua antrian dan memiliki PCB dan sumber daya

deallocated.

4.2.2 Schedulers

Sebuah proses berpindah antara berbagai antrian penjadwalan sepanjang masa. Sistem

operasi harus memilih, untuk keperluan penjadwalan, proses dari antrian ini dalam cara

tertentu. Proses seleksi dilakukan oleh scheduler yang tepat.

Dalam sistem batch, sering ada proses lebih diserahkan daripada yang bisa dilakukan segera.

Proses ini spooled ke perangkat penyimpanan massal (biasanya disk), di mana mereka

disimpan untuk eksekusi nanti. Scheduler jangka panjang (atau scheduler pekerjaan) memilih

proses dari kolam ini dan beban mereka ke dalam memori untuk eksekusi. Jangka pendek



scheduler (atau CPU scheduler) memilih dari antara proses-proses yang siap untuk

mengeksekusi, dan mengalokasikan CPU untuk salah satu dari mereka.

Perbedaan utama antara kedua penjadwal ini adalah frekuensi eksekusi mereka. Scheduler

jangka pendek harus memilih proses baru untuk CPU cukup sering. Sebuah proses dapat

mengeksekusi untuk hanya beberapa milidetik sebelum menunggu permintaan I / O.

Seringkali, scheduler jangka pendek menjalankan setidaknya sekali setiap 100 milidetik.

Karena durasi waktu yang pendek antara eksekusi, scheduler jangka pendek harus sangat

cepat. Jika dibutuhkan 10 milidetik untuk memutuskan untuk melaksanakan proses untuk 100

milidetik, maka 10 / (100 + 10) = 9 persen dari CPU sedang digunakan (terbuang) hanya untuk

penjadwalan pekerjaan.

Scheduler jangka panjang, di sisi lain, mengeksekusi jauh lebih jarang. Mungkin ada menit

antara penciptaan proses baru dalam sistem. Scheduler jangka panjang mengontrol

multiprogramming derajat (jumlah proses dalam memori). Jika tingkat multiprogramming

stabil, maka rata-rata penciptaan proses harus sama dengan tingkat kepergian rata-rata

proses meninggalkan sistem.Dengan demikian, scheduler jangka panjang mungkin perlu

dipanggil hanya ketika proses meninggalkan sistem. Karena semakin lama interval antara

eksekusi, scheduler jangka panjang bisa mengambil lebih banyak waktu untuk memutuskan

proses yang harus dipilih untuk eksekusi.

Adalah penting bahwa penjadwal jangka panjang membuat pilihan hati-hati. Secara umum,

sebagian besar proses dapat digambarkan sebagai salah I / O terikat atau CPU terikat.

Sebuah I / O proses terikat adalah salah satu yang menghabiskan lebih banyak waktu yang

melakukan 1/0 daripada menghabiskan

melakukan perhitungan. Proses CPU-terikat, di sisi lain, adalah salah satu yang gener¬ates I

/ O permintaan jarang, menggunakan lebih dari waktu melakukan perhitungan dari sebuah I /

O proses terikat menggunakan. Adalah penting bahwa scheduler jangka panjang pilih

campuran proses yang baik dari I / O-terikat dan CPU-terikat proses. Jika semua proses

adalah I / O bound, ready queue akan hampir selalu kosong, dan scheduler short¬term akan

memiliki sedikit untuk melakukan. Jika semua proses CPU terikat, yang 1/0 antrian menunggu

akan hampir selalu kosong, perangkat akan digunakan, dan lagi sistem akan tidak seimbang.

Sistem dengan kinerja terbaik akan memiliki kombinasi / O-terikat proses CPU-bound dan

saya.

Pada beberapa sistem, scheduler jangka panjang mungkin tidak ada atau minimal. Sebagai

contoh, sistem time-sharing sering tidak scheduler jangka panjang, tetapi hanya

menempatkan setiap proses baru dalam memori untuk penjadwal jangka pendek. Stabilitas

sistem ini tergantung baik pada keterbatasan fisik (seperti jumlah terminal yang tersedia) atau

pada sifat menyesuaikan diri dari pengguna manusia. Jika kinerja menurun ke tingkat yang



tidak dapat diterima, beberapa pengguna hanya akan berhenti, dan akan melakukan sesuatu

yang lain.

Beberapa sistem operasi, seperti sistem time-sharing, dapat memperkenalkan tambahan,

tingkat menengah penjadwalan. Ini scheduler jangka menengah yang digambarkan di

Gambar 4.6. Ide kunci di balik scheduler jangka menengah adalah bahwa kadang-kadang

dapat menguntungkan untuk menghapus proses dari memori (dan dari pertikaian aktif untuk

CPU), dan dengan demikian mengurangi tingkat multiprogramming. Pada beberapa waktu

kemudian, proses dapat diperkenalkan kembali ke dalam memori dan pelaksanaannya dapat

dilanjutkan di mana ia tinggalkan.Skema ini disebut swapping. Proses ini bertukar keluar dan

bertukar di kemudian oleh scheduler jangka menengah. Menukar mungkin diperlukan untuk

meningkatkan campuran proses, atau karena perubahan persyaratan memori overcommitted

memori yang tersedia, membutuhkan memori yang akan dibebaskan. Swapping dibahas

secara lebih rinci dalam Bab 8.

4.2.3 Konteks Beralih

Beralih CPU kepada proses lain memerlukan menyelamatkan negara dari proses yang lama

dan loading negara yang disimpan untuk proses baru. Tugas ini dikenal sebagai context

switch.Konteks-switch waktu murni overhead, karena sistem tidak melakukan kerja yang

berguna saat beralih. Kecepatannya bervariasi dari mesin ke mesin, tergantung pada

kecepatan memori, jumlah register yang harus disalin, dan keberadaan instruksi khusus

(seperti instruksi tunggal untuk memuat atau menyimpan semua register). Biasanya,

kecepatan berkisar 1-1000 mikrodetik.

Konteks-switch kali sangat tergantung pada dukungan hardware. Misalnya, beberapa

prosesor (seperti DECSYSTEM-20) menyediakan beberapa set register. Sebuah switch

konteks hanya meliputi mengubah pointer ke kasir saat set. saja, jika ada proses lebih aktif

daripada ada mendaftar set, resor sistem untuk menyalin data mendaftar ke dan dari memori,

seperti sebelumnya.Juga, semakin kompleks sistem operasi, semakin banyak pekerjaan

harus dilakukan selama context switch. Sebagaimana akan kita lihat dalam Bab 8, teknik

manajemen memori tingkat lanjut dapat mensyaratkan data tambahan harus diaktifkan

dengan konteks masing-masing. Sebagai contoh, ruang alamat dari proses saat ini harus

dipertahankan sebagai ruang tugas selanjutnya adalah siap untuk digunakan. Bagaimana

ruang alamat yang diawetkan, dan jumlah pekerjaan yang diperlukan untuk melakukannya,

tergantung pada metode manajemen memori dari sistem operasi. Seperti yang akan kita lihat

di Bagian 4.5, switching konteks telah menjadi seperti hambatan kinerja yang struktur baru

(benang) yang digunakan untuk menghindarinya bila memungkinkan.

4.3 Operasi pada Proses



Proses dalam sistem dapat mengeksekusi secara bersamaan, dan harus dibuat dan dihapus

secara dinamis. Dengan demikian, sistem operasi harus menyediakan mekanisme untuk

pembuatan proses dan terminasi.

4.3.1 Proses Penciptaan

Sebuah proses dapat membuat beberapa proses baru, melalui system call membuat proses,

selama eksekusi. Proses menciptakan disebut proses induk, sedangkan proses baru disebut

anak-anak proses itu. Masing-masing proses baru pada gilirannya menciptakan proses

lainnya, membentuk pohon proses (Gambar 4.7).

Secara umum, proses akan membutuhkan sumber daya tertentu (waktu CPU, memori, lalat,

perangkat I / O) untuk menyelesaikan tugasnya. Ketika proses menciptakan subprocess,

subproses mungkin dapat memperoleh sumber daya secara langsung dari sistem operasi,

atau dapat dibatasi untuk subset sumber daya dari proses induk. Orangtua mungkin harus

partisi sumber daya di antara anak-anaknya, atau mungkin dapat berbagi beberapa sumber

daya (seperti memori atau file) antara beberapa anak-anaknya. Membatasi proses anak

subset sumber daya orangtua mencegah proses apapun dari overloading sistem dengan

menciptakan terlalu banyak subproses.

Selain berbagai sumber daya fisik dan logis bahwa proses memperoleh ketika dibuat, data

inisialisasi (input) dapat diteruskan oleh proses induk untuk proses anak. Sebagai contoh,

perhatikan proses yang berfungsi untuk menampilkan status file, mengatakan FI, pada layar

terminal. Ketika dibuat, maka akan mendapatkan, sebagai masukan dari proses induknya,

nama file FI, dan itu akan mengeksekusi menggunakan datum bahwa untuk mendapatkan

informasi yang diinginkan. Hal ini juga bisa mendapatkan nama dari perangkat output.

Beberapa sistem operasi melewati sumber daya untuk proses anak. Pada sistem tersebut,

proses baru bisa mendapatkan dua lalat terbuka, FI dan perangkat terminal, dan mungkin

hanya perlu mentransfer datum antara keduanya.

Ketika proses membuat proses baru, dua kemungkinan ada dalam hal eksekusi:

• Orangtua terus melaksanakan bersamaan dengan anak-anaknya.

• Orangtua menunggu sampai beberapa atau semua anak perusahaan telah dihentikan.

Ada juga dua kemungkinan dalam hal ruang alamat dari proses baru:

• Proses anak merupakan duplikat dari proses induk.

• Proses anak memiliki program dimuat ke dalamnya.

Untuk menggambarkan ini implementasi yang berbeda, mari kita mempertimbangkan sistem

operasi UNIX. Dalam UNIX, tiap proses diidentifikasi oleh pengidentifikasi proses, yang

merupakan integer yang unik. Sebuah proses baru dibuat oleh system call fork. Proses yang

baru terdiri dari salinan ruang alamat dari proses aslinya. Mekanisme ini memungkinkan

proses induk untuk berkomunikasi dengan mudah dengan proses anaknya. Kedua proses



(induk dan anak) meneruskan eksekusi pada instruksi setelah fork dengan satu perbedaan:

Kembalinya kode untuk garpu adalah nol untuk proses baru (anak), sedangkan (nol) proses

identifier anak dikembalikan ke orang tua.

Biasanya, sistem panggilan execve digunakan setelah garpu oleh salah satu dari dua proses

untuk menggantikan proses ruang 'memori dengan program baru. Sistem execve panggilan

beban file biner ke memori (menghancurkan gambar memori dari program yang berisi system

call execve) dan mulai pelaksanaannya. Dengan cara ini, kedua proses dapat berkomunikasi,

dan kemudian berpisah. Orang tua dapat membuat anak-anak lebih, atau, jika tidak ada lagi

yang harus dilakukan saat anak berjalan, dapat mengeluarkan sistem menunggu panggilan

untuk bergerak sendiri dari antrian siap sampai penghentian anak.

Sistem operasi VMS Desember, sebaliknya, menciptakan proses baru, beban program

tertentu dalam proses itu, dan mulai berjalan. Sistem operasi Microsoft Windows / NT

mendukung kedua model: Ruang alamat induk dapat diduplikasi, atau orang tua dapat

menentukan nama program untuk sistem operasi untuk memuat ke dalam ruang alamat dari

proses baru.

4.3.2 Proses Pemutusan

Sebuah proses berakhir ketika selesai mengeksekusi pernyataan terakhir dan meminta sistem

operasi untuk menghapusnya dengan menggunakan sistem keluar panggilan. Pada saat itu,

proses dapat kembali data (output) untuk proses induknya (melalui system call wait). Semua

resourcesof proses, termasuk memori fisik dan virtual, lalat terbuka, dan I / O buffer, yang

deallocated oleh sistem operasi.

Ada situasi tambahan saat pemutusan terjadi. Sebuah proses dapat menyebabkan terminasi

dari proses lain melalui sistem panggilan yang sesuai (misalnya, batalkan). Biasanya, seperti

system call dapat dipanggil oleh hanya induk proses yang harus diakhiri. Jika tidak, pengguna

sewenang-wenang bisa membunuh pekerjaan masing-masing. Perhatikan bahwa orangtua

perlu mengetahui identitas anak-anaknya. Dengan demikian, ketika satu proses membuat

proses baru, identitas dari proses yang baru dibuat akan diteruskan ke orangtua.

Orang tua dapat mengakhiri eksekusi salah satu dari anak-anak untuk berbagai alasan,

seperti:

• Anak telah melampaui penggunaannya dari beberapa sumber daya yang telah

dialokasikan.

• Tugas ditugaskan kepada anak tidak lagi diperlukan.

• orang tua ini keluar, dan sistem operasi tidak memungkinkan anak untuk melanjutkan

jika induknya berakhir.

Untuk menentukan kasus pertama, orangtua harus memiliki mekanisme untuk memeriksa

keadaan anak-anaknya.



Banyak sistem, termasuk VMS, jangan biarkan anak untuk eksis jika induknya telah berakhir.

Dalam sistem tersebut, jika suatu proses berakhir (baik normal atau tidak normal), maka

semua anak-anaknya juga harus dihentikan. Fenomena ini disebut sebagai pemutusan

Cascading dan biasanya dimulai oleh sistem operasi.

Untuk menggambarkan proses eksekusi dan terminasi, mari kita perhatikan lagi sistem UNIX.

Dalam UNIX, proses dapat mengakhiri dengan menggunakan system call exit, dan proses

induknya dapat menunggu untuk acara itu dengan menggunakan sistem menunggu

panggilan. Sistem menunggu panggilan mengembalikan identifier proses anak dihentikan,

sehingga orang tua dapat membedakan mana yang mungkin banyak anak-anak telah

dihentikan. Jika orangtua berakhir, bagaimanapun, semua anak dihentikan oleh sistem

operasi. Tanpa orangtua, UNIX tidak tahu kepada siapa untuk melaporkan kegiatan anak.

4.4 Proses Bekerjasama

Proses bersamaan mengeksekusi dalam sistem operasi dapat berupa proses yang

independen atau proses bekerja sama. Proses adalah independen jika tidak dapat

mempengaruhi atau dipengaruhi oleh proses lain mengeksekusi dalam sistem. Jelas, setiap

proses yang tidak berbagi data (sementara atau persisten) dengan proses lain adalah

independent. Di sisi lain, proses bekerja sama jika dapat mempengaruhi atau dipengaruhi oleh

proses lain mengeksekusi dalam sistem. Jelas, setiap proses yang berbagi data dengan

proses lain adalah proses bekerja sama.

Ada beberapa alasan untuk menyediakan lingkungan yang memungkinkan kerjasama proses:

• Berbagi informasi: Sejak beberapa pengguna mungkin tertarik pada bagian yang sama

dari informasi (misalnya, file bersama), kita harus menyediakan lingkungan untuk

memungkinkan akses bersamaan ke jenis sumber daya.

• Perhitungan speedup: Jika kita ingin tugas tertentu untuk menjalankan lebih cepat, kita

harus memecahnya menjadi sub-tugas, masing-masing akan mengeksekusi secara

paralel dengan yang lain. Perhatikan bahwa percepatan tersebut dapat dicapai hanya

jika komputer memiliki beberapa processingelements (seperti CPU atau 1/0 saluran).

• Modularity: Kita mungkin ingin membangun sistem secara modular, membagi fungsi

sistem ke dalam proses yang terpisah, seperti yang dibahas dalam Bab 3.

• Kenyamanan: Bahkan pengguna individu mungkin memiliki banyak tugas untuk

dikerjakan pada satu waktu. Misalnya, pengguna dapat mengedit, mencetak, dan

menyusun secara paralel.

Eksekusi konkuren yang membutuhkan kerjasama antar proses membutuhkan mekanisme

untuk memungkinkan proses untuk berkomunikasi satu sama lain (Bagian 4.6), dan untuk

menyinkronkan tindakan mereka (Bab 6).



Untuk menggambarkan konsep proses bekerja sama, mari kita mempertimbangkan masalah

produsen-konsumen, yang merupakan paradigma umum untuk proses bekerja sama. Sebuah

proses produser menghasilkan informasi yang dikonsumsi oleh proses konsumen. Sebagai

contoh, sebuah program cetak menghasilkan karakter yang dikonsumsi oleh driver printer.

Sebuah compiler dapat menghasilkan kode assembly, yang dikonsumsi oleh assembler.

Assembler, pada gilirannya, dapat menghasilkan modul obyek, yang dikonsumsi oleh loader.

Untuk memungkinkan produsen dan konsumen proses berjalan secara bersamaan, kita harus

telah tersedia penyangga item yang dapat diisi oleh produser dan dikosongkan oleh

konsumen.Seorang produser dapat memproduksi satu item sementara konsumen memakan

item lain. Produsen dan konsumen harus disinkronkan, sehingga konsumen tidak mencoba

untuk mengkonsumsi item yang belum diproduksi. Dalam situasi ini, konsumen harus

menunggu sampai item diproduksi.

Masalah tak terbatas-bufferproducer konsumen menempatkan ada batasan praktis pada

ukuran buffer. Konsumen mungkin harus menunggu untuk item baru, tetapi produser selalu

dapat menghasilkan item baru. The dibatasi-buffer masalah konsumen producer-

mengasumsikan bahwa ada ukuran buffer tetap. Dalam hal ini, konsumen harus menunggu

jika buffer kosong dan produser harus menunggu jika buffer penuh.

Buffer mungkin baik disediakan oleh sistem operasi melalui penggunaan IPC (Bagian 4.6),

atau secara eksplisit kode oleh programmer aplikasi dengan menggunakan memori bersama.

Mari kita menggambarkan solusi bersama-memori untuk masalah dibatasi-buffer. Produsen

dan konsumen proses berbagi variabel-variabel berikut:

var n;

jenis item = ...;

var penyangga: array [-0..N 1] item; in, out: 0..N-l;

dengan variabel masuk dan keluar diinisialisasi dengan nilai 0. penyangga bersama

diimplementasikan sebagai array melingkar dengan dua pointer logis: masuk dan keluar.

Variabel dalam poin ke posisi bebas berikutnya dalam buffer; keluar poin ke posisi penuh

pertama dalam buffer. Buffer kosong ketika di = keluar; buffer penuh ketika di + f mod n =

keluar.

Kode untuk produsen dan konsumen proses berikut. No-op adalah instruksi melakukan apa-

apa. Jadi, sementara kondisi tidak melakukan-op hanya menguji kondisi berulang-ulang

sampai menjadi palsu.

Proses produsen memiliki nextp variabel lokal, di mana item baru yang akan diproduksi

disimpan:

mengulang kembali

menghasilkan item dalam nextp



sedangkan pada + 1 mod n = keluar melakukan no-op; penyangga

[di]: = nextp; di: = di + 1 mod n; sampai palsu;

Proses konsumen memiliki nextc variabel lokal, di mana item untuk dikonsumsi disimpan:

mengulang kembali

sedangkan pada = keluar melakukan no-op; nextc: = penyangga

[keluar]; out: = keluar + 1 mod n;

mengkonsumsi item dalam nextc

sampai palsu;

Skema ini memungkinkan paling n-1 item dalam buffer pada saat yang sama. Kami

meninggalkan sebagai latihan bagi Anda untuk memberikan solusi di mana n item dapat di

buffer pada saat yang sama.

Dalam Bab 6, kita akan membahas secara detail bagaimana sinkronisasi antara proses

bekerja sama dapat diimplementasikan secara efektif dalam lingkungan shared-memori.

4.5 Threads

Ingat bahwa proses didefinisikan oleh sumber daya menggunakan dan dengan lokasi di mana

ia mengeksekusi. Ada banyak contoh, namun, di mana akan sangat berguna untuk sumber

daya untuk dibagikan dan diakses secara bersamaan. Situasi ini mirip dengan kasus di mana

sistem garpu panggilan dipanggil dengan program counter baru, atau benang kontrol,

melaksanakan dalam ruang alamat yang sama. Konsep ini sangat berguna bahwa beberapa

sistem operasi baru menyediakan mekanisme untuk mendukung melalui fasilitas benang.

4.5.1 Thread Struktur

Sebuah thread, kadang-kadang disebut proses ringan (LWP), adalah unit dasar dari

penggunaan CPU, dan terdiri dari program counter, satu set register, dan ruang stack. Berbagi

dengan benang rekan bagian kode, bagian data, dan sumber daya sistem operasi seperti file

terbuka dan sinyal, secara kolektif dikenal sebagai tugas. Proses tradisional atau berat sama

dengan tugas dengan satu thread. Sebuah tugas tidak apa-apa jika tidak ada benang di

dalamnya, dan benang harus dalam tepat satu tugas. Pembagian luas membuat CPU beralih

antara benang sebaya dan penciptaan benang murah, dibandingkan dengan konteks switch

antara proses kelas berat. Meskipun saklar konteks thread masih membutuhkan saklar

mendaftar set, tidak ada pekerjaan-memori-manajemen yang terkait perlu dilakukan. Seperti

lingkungan pemrosesan paralel, multithreading proses dapat memperkenalkan masalah

concurrency control yang memerlukan penggunaan bagian atau kunci penting.

Juga, beberapa sistem menerapkan thread user-level di level user perpustakaan, daripada

melalui panggilan sistem, sehingga switching thread tidak perlu untuk memanggil sistem

oper¬ating, dan menyebabkan interupsi ke kernel. Beralih antara benang tingkat user- dapat



dilakukan secara independen dari sistem operasi dan, oleh karena itu, sangat cepat. Dengan

demikian, memblokir benang dan beralih ke thread lain adalah solusi yang masuk akal untuk

masalah bagaimana server dapat menangani banyak permintaan secara efisien. Benang

user-level memiliki kekurangan, namun. Sebagai contoh, jika kernel single-threaded, maka

setiap benang level user mengeksekusi system call akan menyebabkan seluruh tugas untuk

menunggu sampai kembali system call.

Kita bisa memahami fungsi dari benang dengan membandingkan kontrol multi-benang

dengan kontrol multi-proses. Dengan beberapa proses, masing-masing pro¬cess beroperasi

secara independen dari yang lain; setiap proses memiliki program counter sendiri, tumpukan

mendaftar, dan ruang alamat. Jenis organisasi ini berguna ketika pekerjaan yang dilakukan

oleh proses yang tidak terkait. Beberapa proses dapat melakukan tugas yang sama juga.

Misalnya, beberapa proses dapat memberikan data ke mesin remote dalam implementasi

sistem file jaringan. Namun, lebih efisien untuk memiliki satu proses yang berisi beberapa

benang melayani tujuan yang sama. Dalam pelaksanaan beberapa proses, setiap proses

mengeksekusi kode yang sama tetapi memiliki sumber daya memori dan file sendiri. Salah

satu proses multi-threaded menggunakan sumber daya yang lebih sedikit daripada beberapa

proses berlebihan, termasuk memori, file dan penjadwalan CPU. Misalnya, seperti Solaris

berkembang, daemon jaringan sedang ditulis ulang sebagai benang kernel untuk

meningkatkan kinerja sangat fungsi-fungsi server jaringan.

Threads beroperasi, dalam banyak hal, dengan cara yang sama seperti proses. Thread dapat

berada di salah satu dari beberapa negara: siap, diblokir, berlari, atau dihentikan. Seperti

proses, benang berbagi CPU, dan hanya satu thread pada suatu waktu aktif (berjalan).

Sebuah benang dalam proses mengeksekusi secara berurutan, dan setiap thread memiliki

sendiri stack dan program counter. Thread dapat membuat benang anak, dan dapat

memblokir menunggu sistem panggilan untuk menyelesaikan; jika satu thread diblokir, thread

lain dapat berjalan. Namun, tidak seperti proses, benang tidak terlepas dari salah satu

yang lain. Karena semua benang dapat mengakses setiap alamat dalam tugas, thread dapat

membaca atau menulis di atas tumpukan thread lain. Struktur ini tidak memberikan

perlindungan antara benang. Perlindungan tersebut, bagaimanapun, tidak harus neces¬sary.

Sedangkan proses dapat berasal dari pengguna yang berbeda, dan mungkin bermusuhan

satu sama lain, hanya satu pengguna dapat memiliki tugas masing-masing dengan beberapa

thread. Benang, dalam hal ini, mungkin akan dirancang untuk membantu satu sama lain, dan

karena itu tidak akan membutuhkan perlindungan bersama. Gambar 4.8 menggambarkan

tugas dengan beberapa thread.

Mari kita kembali ke contoh kita proses file-server diblokir dalam model single-proses. Dalam

skenario ini, tidak ada proses server lain dapat mengeksekusi sampai proses pertama adalah

diblokir.Sebaliknya, dalam kasus tugas yang berisi beberapa thread, sementara satu thread



server diblokir dan menunggu, thread kedua dalam tugas yang sama bisa dijalankan. Dalam

aplikasi ini, kerja sama beberapa benang yang merupakan bagian dari pekerjaan yang sama

menganugerahkan keuntungan dari throughput yang lebih tinggi dan meningkatkan kinerja.

Aplikasi lain, seperti masalah produsen-konsumen, membutuhkan berbagi buffer umum dan

begitu juga mendapatkan keuntungan dari fitur ini pemanfaatan thread: Produsen dan

konsumen bisa benang dalam tugas. Sedikit overhead diperlukan untuk beralih di antara

mereka, dan, pada sistem multiprosesor, mereka bisa menjalankan secara paralel pada dua

prosesor untuk efisiensi maksimum.

Thread menyediakan mekanisme yang memungkinkan proses berurutan untuk membuat

memblokir panggilan sistem sementara juga mencapai paralelisme. Untuk menggambarkan

keuntungan mekanisme ini, kita akan pertimbangkan untuk menulis file server dalam sebuah

sistem di mana benang tidak tersedia. Kita telah melihat bahwa, dalam sebuah file server

single-threaded, proses server harus membawa permintaan sampai selesai sebelum

mengambilnya newwork. F permintaan melibatkan menunggu akses disk, CPU idle selama

menunggu. Oleh karena itu, jumlah permintaan per detik yang dapat diolah jauh lebih sedikit

dibandingkan dengan eksekusi paralel. Tanpa pilihan beberapa thread, seorang desainer

sistem berusaha untuk meminimalkan perlambatan kinerja proses single¬threaded perlu

meniru struktur paralel benang dengan menggunakan proses kelas berat. Dia bisa

melakukannya, tapi pada biaya struktur program nonsequential kompleks.

Abstraksi disajikan oleh sekelompok proses ringan adalah bahwa beberapa benang kontrol

dikaitkan dengan beberapa sumber daya bersama. Ada banyak alternatif mengenai benang;

kami menyebutkan beberapa dari mereka sebentar. Thread dapat didukung oleh kernel

(seperti dalam Mach dan sistem OS / 2 operasi). Dalam hal ini, satu set sistem panggilan

sama dengan yang untuk proses disediakan. Atau, mereka dapat didukung di atas kernel,

melalui serangkaian panggilan perpustakaan di tingkat pengguna (seperti yang dilakukan di

Proyek Andrew dari CMU).

Mengapa sistem operasi mendukung satu versi atau yang lain? Benang tingkat user- tidak

melibatkan kernel, dan oleh karena itu lebih cepat untuk beralih antara benang dari kernel

yang didukung. Namun, setiap panggilan ke sistem operasi dapat menyebabkan seluruh

proses untuk menunggu, karena jadwal kernel hanya proses (tidak memiliki pengetahuan

tentang benang), dan proses yang sedang menunggu mendapatkan waktu CPU. Penjadwalan

juga bisa menjadi tidak adil. Pertimbangkan dua proses, satu dengan 1 benang (proses) dan

yang lainnya dengan 100 benang (proses b). Setiap proses umumnya menerima jumlah yang

sama irisan waktu, sehingga benang dalam proses berjalan 100 kali lebih cepat sebagai

benang dalam proses b. Pada sistem dengan benang kernel yang didukung, beralih antara

benang lebih memakan waktu karena kernel (melalui interupsi) harus melakukan switch.

Setiap thread dapat dijadwalkan secara independen, namun, sehingga proses b bisa



menerima 100 kali waktu CPU yang memproses menerima. Selain itu, proses b bisa memiliki

100 panggilan sistem dalam operasi bersamaan, accomplishingfar lebih dari proses yang

sama akan pada sistem dengan dukungan benang hanya user-level.

Karena kompromi yang terlibat dalam masing-masing dua pendekatan ini untuk threading,

beberapa sistem menggunakan pendekatan hybrid di mana kedua user-level dan kernel

thread yang didukung diimplementasikan. Solaris 2 merupakan sistem tersebut dan dijelaskan

dalam bagian berikutnya.

Thread mendapatkan popularitas karena mereka memiliki beberapa character¬istics proses

kelas berat tetapi dapat mengeksekusi lebih efisien. Ada banyak aplikasi di mana kombinasi

ini berguna. Misalnya, beberapa implementa¬tions dari kernel UNX adalah tasking tunggal:

Hanya satu tugas dapat mengeksekusi kode dalam kernel pada suatu waktu. Banyak

masalah, seperti sinkronisasi akses data (penguncian struktur data sementara mereka

sedang dimodifikasi) dihindari, karena hanya satu proses diperbolehkan untuk melakukan

modifikasi. Mach, di sisi lain, multithreaded, memungkinkan kernel untuk melayani banyak

permintaan

secara bersamaan.Dalam hal ini, benang sendiri sinkron: thread lain dalam kelompok yang

sama dapat berjalan hanya jika saat ini melaksanakan benang relin¬quishes kontrol. Tentu

saja, thread saat akan melepaskan kontrol hanya ketika itu tidak memodifikasi data bersama.

Pada sistem di mana benang asyn¬chronous, beberapa mekanisme penguncian eksplisit

harus digunakan, seperti dalam sistem di mana beberapa proses berbagi data. Sinkronisasi

proses dibahas dalam Bab 6.

4.5.2 Contoh: Solaris 2

Pemeriksaan sistem benang dalam sistem operasi saat ini akan membantu kita untuk

mengklarifikasi banyak masalah. Untuk tujuan ini, kita memilih Solaris 2, versi dari UNIX, yang

sampai tahun 1992 hanya didukung proses kelas berat tradisional. Ini telah berubah menjadi

sistem operasi modern dengan dukungan untuk benang di tingkat kernel dan user,

multiprocessing simetris, dan penjadwalan real-time.

Solaris 2 mendukung benang user-level, seperti yang dijelaskan dalam Bagian 4.5.1. Mereka

didukung oleh perpustakaan untuk penciptaan dan penjadwalan mereka, dan kernel tahu apa-

apa benang tersebut. Solaris 2 mengharapkan berpotensi ribuan benang user-level untuk

bersaing untuk siklus CPU.

Solaris 2 mendefinisikan tingkat menengah benang juga. Antara benang tingkat user- dan

kernel thread-level adalah proses ringan. Setiap tugas (masih disebut "proses" di SunOS

nomenklatur) berisi setidaknya satu LWP. LWPs ini dimanipulasi oleh perpustakaan benang.

Benang user-level multiplexing pada LWPs proses, dan benang hanya user-level saat ini



terhubung ke LWPs menyelesaikan pekerjaan. Sisanya baik diblokir atau menunggu LWP di

mana mereka dapat berjalan.

Semua operasi dalam kernel dijalankan oleh thread kernel-level standar. Ada benang kernel-

level untuk setiap LWP, dan ada beberapa tingkat benang kernel- yang dijalankan atas nama

kernel dan tidak LWP terkait (misalnya, benang untuk melayani permintaan disk). Seluruh

sistem benang digambarkan pada Gambar 4.9. Kernel thread-level adalah satu-satunya

benda yang dijadwalkan dalam sistem (lihat Bab 5). Beberapa thread kernel-tingkat

multiplexing pada prosesor dalam sistem, sedangkan beberapa terikat prosesor tertentu.

Misalnya, kernel thread terkait dengan driver perangkat untuk perangkat yang terhubung ke

prosesor tertentu hanya akan berjalan di prosesor itu. By request, thread juga dapat

disematkan ke prosesor. Hanya thread yang berjalan pada prosesor, dengan prosesor

dialokasikan hanya benang tersebut (lihat thread paling kanan pada Gambar 4.9).

Pertimbangkan sistem ini beroperasi. Setiap satu tugas mungkin memiliki banyak benang

tingkat user-. Thread user-level ini dapat dijadwalkan dan beralih di antara proses ringan

kernel yang didukung tanpa intervensi dari kernel. Tidak ada konteks beralih diperlukan untuk

satu thread user-level untuk memblokir dan lain untuk mulai berjalan, sehingga thread user-

level sangat efisien.

Thread user-level ini didukung oleh proses ringan. Setiap LWP terhubung ke tepat satu kernel

thread-level, sedangkan setiap thread user-level independen dari kernel. Mungkin ada banyak

LWPs tugas, tetapi mereka dibutuhkan hanya ketika benang perlu berkomunikasi dengan

kernel. Misalnya, satu LWP diperlukan untuk setiap thread yang dapat menghalangi secara

bersamaan dalam sistem panggilan. Pertimbangkan lima permintaan membaca file yang

berbeda yang dapat terjadi secara bersamaan. Kemudian, lima LWPs akan diperlukan, karena

mereka semua bisa menunggu I / O selesai pada kernel. II tugas hanya empat LWPs, maka

permintaan kelima akan harus menunggu untuk salah satu LWPs untuk kembali dari kernel.

Menambahkan LWP keenam akan mendapatkan apa-apa jika kita hanya ada cukup bekerja

selama lima.

Benang kernel dijadwalkan oleh scheduler kernel dan mengeksekusi pada CPU atau CPU

dalam sistem. Jika blok kernel thread (biasanya menunggu operasi I / O untuk

menyelesaikan), prosesor ini bebas untuk menjalankan kernel thread yang lain. Jika thread

yang diblokir berjalan atas nama LWP, blok LWP juga. Up rantai, benang user-level saat ini

melekat pada LWP juga blok. Jika tugas yang berisi benang yang hanya memiliki satu LWP,

blok seluruh tugas sampai I / O selesai. Perilaku ini adalah sama dengan proses di bawah

versi lama dari sistem operasi.

Dengan Solaris 2, tugas tidak lagi harus memblokir sementara menunggu I / O untuk

diselesaikan. Tugas mungkin memiliki beberapa LWPs; jika salah satu blok, yang lain bisa

terus mengeksekusi dalam tugas.



Kami menyimpulkan contoh ini dengan memeriksa kebutuhan sumber daya dari masing-

masing jenis benang tersebut.

• Sebuah kernel thread hanya memiliki struktur data kecil dan tumpukan. Beralih antara

benang kernel tidak memerlukan perubahan memori akses infor¬mation, dan karena itu

relatif cepat.

• Sebuah LWP berisi blok kontrol proses dengan data mendaftar, informasi akuntansi, dan

informasi memori. Beralih di antara LWPs karena itu memerlukan sedikit kerja dan relatif

lambat.

• Sebuah benang level user hanya memerlukan stack dan program counter: tidak ada

sumber kernel yang diperlukan. Kernel tidak terlibat dalam penjadwalan thread user-level

ini; Oleh karena itu, beralih di antara mereka cepat. Mungkin ada ribuan benang user-level

tersebut, tetapi semua kernel akan pernah lihat adalah LWPs dalam proses yang

mendukung benang user-level tersebut.

4.6 Interprocess Communication

Dalam Bagian 4.4, kami menunjukkan bagaimana proses kerjasama dapat berkomunikasi

dalam lingkungan shared-memori. Skema ini mensyaratkan bahwa proses ini berbagi kolam

buffer umum, dan bahwa kode untuk mengimplementasikan buffer secara eksplisit ditulis oleh

programmer aplikasi. Cara lain untuk mencapai efek yang sama adalah untuk sistem operasi

untuk menyediakan sarana untuk proses untuk berkomunikasi satu sama lain melalui fasilitas

komunikasi antar proses (IPC) bekerja sama.

IPC menyediakan mekanisme untuk memungkinkan proses untuk berkomunikasi dan

syn¬chronize tindakan mereka. Interprocess-komunikasi terbaik yang disediakan oleh sistem

mes¬sage.Sistem pesan dapat didefinisikan dalam berbagai cara. Sistem kelulusan pesan-

juga memiliki kelebihan lain, seperti akan ditunjukkan dalam Bab 16.

Perhatikan bahwa skema komunikasi bersama-memori dan pesan-sistem tidak saling

eksklusif, dan dapat digunakan secara bersamaan dalam satu sistem operasi atau bahkan

proses tunggal.

4.6.1 Struktur Dasar

Fungsi dari sistem pesan adalah untuk memungkinkan proses untuk berkomunikasi satu sama

lain tanpa perlu resor untuk variabel bersama. Fasilitas IPC menyediakan setidaknya dua

operasi: kirim (pesan) dan receivefmessoye).

Pesan yang dikirim oleh proses bisa baik ukuran tetap atau variabel. jika pesan hanya

berukuran tetap dapat dikirim, pelaksanaan fisik straightfor¬ward. Pembatasan ini,

bagaimanapun, membuat tugas pemrograman lebih sulit. Di sisi lain, pesan-variabel



berukuran memerlukan implementasi fisik yang lebih kompleks, tapi tugas pemrograman

menjadi lebih sederhana.

II proses P dan Q ingin berkomunikasi, mereka harus mengirim pesan dan menerima pesan

dari satu sama lain; link komunikasi harus ada di antara mereka. Link ini dapat

diimplementasikan dalam berbagai cara. Kami prihatin sini tidak dengan implementasi fisik

link (seperti memori bersama,

bus perangkat keras, atau jaringan, yang tercakup dalam Bab 15), melainkan dengan isu-isu

implementasi logis, seperti sifat logis. Beberapa pertanyaan penerapan dasar ini:

• Bagaimana link yang didirikan?

• Dapatkah link dikaitkan dengan lebih dari dua proses?

• Berapa banyak link bisa ada antara setiap pasangan proses?

• Apakah kapasitas link? Artinya, apakah link memiliki beberapa ruang buffer? Jika tidak,

berapa banyak?

• Berapa ukuran pesan? Dapat link mengakomodasi variabel-berukuran atau hanya pesan

berukuran tetap?

• Apakah link searah atau dua arah? Artinya, jika ada hubungan antara P dan Q, pesan bisa

mengalir hanya satu arah (misalnya hanya dari P ke Q) atau di kedua arah?

Definisi searah harus dinyatakan lebih hati-hati, karena link mungkin berhubungan dengan

lebih dari dua proses. Dengan demikian, kita katakan bahwa link searah hanya jika setiap

proses terhubung ke link dapat mengirim atau menerima, tapi tidak keduanya, dan setiap link

memiliki setidaknya satu proses penerima terhubung.

Selain itu, ada beberapa metode untuk secara logis menerapkan link dan mengirim /

menerima operasi:

• Komunikasi langsung atau tidak langsung

• Symmetric atau komunikasi asimetris

• Otomatis atau penyangga eksplisit

• Kirim dengan copy atau kirim melalui referensi

• Pesan Tetap berukuran atau variabel-berukuran

Untuk sisa bagian ini, kita menguraikan jenis sistem pesan.

4.6.2 Penamaan

Proses yang ingin berkomunikasi harus memiliki cara untuk merujuk satu sama lain. Mereka

dapat menggunakan salah komunikasi langsung atau komunikasi tidak langsung, seperti yang

akan kita bahas dalam dua subbagian berikutnya.



4.6.2.1 Komunikasi Langsung

Dalam disiplin langsung komunikasi, setiap proses yang ingin communi¬cate harus secara

eksplisit nama penerima atau pengirim komunikasi. Dalam skema ini, mengirim dan

menerima primitif didefinisikan sebagai berikut:

sendfP, pesan). Kirim pesan untuk memproses P. receiveCQ, pesan).

Menerima pesan dari proses Q.

Sebuah link komunikasi dalam skema ini memiliki sifat sebagai berikut:

• Sebuah link didirikan secara otomatis diantara setiap pasang proses yang ingin

berkomunikasi. Proses perlu tahu hanya identitas masing-masing untuk berkomunikasi.

• Sebuah link dikaitkan dengan tepat dua proses.

• Antara setiap proses pasangan , terdapat persis satu link.

• Link mungkin searah, tetapi biasanya dua arah.

Untuk menggambarkan, mari kita menyajikan solusi untuk masalah produsen-konsumen.

Untuk memungkinkan produsen dan konsumen proses berjalan secara bersamaan, kita

membiarkan produsen untuk memproduksi satu item sementara konsumen memakan item

lain. Ketika produser selesai menghasilkan item, ia akan mengirimkan barang itu untuk

konsumen. Konsumen mendapatkan item melalui menerima operasi. jika item belum

diproduksi lagi, proses konsumen harus menunggu sampai item diproduksi. Proses produsen

didefinisikan sebagai

mengulang kembali

menghasilkan item dalam nextp

kirim (konsumen, nextp); sampai palsu;

Proses konsumen didefinisikan sebagai

mengulang kembali

menerima (produser, nextc);

mengkonsumsi item dalam nextc untilfalse;

Skema ini menunjukkan simetri dalam menangani; yaitu, pengirim dan penerima proses harus

nama satu sama lain untuk berkomunikasi. Sebuah varian dari skema ini mempekerjakan

asimetri dalam mengatasi. Hanya nama pengirim penerima; penerima tidak diperlukan untuk

nama pengirim. Dalam skema ini, mengirim dan menerima primitif didefinisikan sebagai

berikut:

• sendfP, pesan). Kirim pesan ke proses P

• menerima ^, pesan). Menerima pesan dari proses apapun; id variabel diatur ke nama

proses dengan mana komunikasi telah terjadi.

Kerugian di kedua skema ini (simetris dan asimetris) adalah modularitas terbatas definisi

proses yang dihasilkan. Mengubah nama dari sebuah proses mungkin memerlukan

pemeriksaan semua definisi proses lain. Semua referensi untuk nama lama harus ditemukan,



sehingga mereka dapat dimodifikasi dengan nama baru. Situasi ini tidak diinginkan dari sudut

pandang kompilasi terpisah.

4.6.2.2 Komunikasi Tidak Langsung

Dengan komunikasi tidak langsung, pesan yang dikirim dan diterima dari kotak surat (juga

disebut sebagai port). Sebuah kotak dapat dilihat secara abstrak sebagai objek mana pesan

dapat ditempatkan oleh proses dan dari mana pesan dapat dihapus. Setiap kotak surat

memiliki identifikasi yang unik. Dalam skema ini, proses dapat berkomunikasi dengan

beberapa proses lain melalui sejumlah kotak surat yang berbeda. Dua proses dapat

berkomunikasi hanya jika proses memiliki kotak surat bersama. Yang mengirim dan menerima

primitif didefinisikan sebagai berikut:

sendfA, pesan). Kirim pesan ke kotak surat A. receivefA, pesan).

Menerima pesan dari mailbox A.

Dalam skema ini, link komunikasi memiliki sifat sebagai berikut:

• Sebuah link dibangun antara sepasang proses hanya jika mereka memiliki kotak pesan

bersama.

• Sebuah link dapat berhubungan dengan lebih dari dua proses.

• Antara setiap pasang proses komunikasi, mungkin ada beberapa link yang berbeda,

setiap link yang sesuai dengan satu kotak.

• Sebuah link dapat berupa searah atau dua arah.

Sekarang anggaplah bahwa proses Pi, P2, P3 dan semua berbagi mailbox A. Proses Pi

mengirim pesan ke A, sedangkan P2 dan P3 masing-masing mengeksekusi terima dari A.

Proses mana yang akan menerima pesan yang dikirim oleh Pi? Pertanyaan ini dapat

diselesaikan dalam berbagai cara:

• Biarkan link untuk dihubungkan dengan paling banyak dua proses.

• Biarkan paling banyak satu proses pada suatu waktu untuk mengeksekusi menerima

operasi.

• Memungkinkan sistem untuk memilih sewenang-wenang yang proses akan menerima

mes¬sage (yaitu, baik P2 atau P3, tetapi tidak keduanya, akan menerima pesan). Sistem

mungkin mengidentifikasi penerima kepada pengirim.

Sebuah kotak dapat dimiliki baik oleh proses atau sistem. Jika kotak pesan dimiliki oleh suatu

proses (yaitu, kotak pesan melekat atau didefinisikan sebagai bagian proses), maka kita

membedakan antara pemilik (yang hanya bisa menerima pesan melalui mailbox ini) dan

pengguna kotak surat (yang hanya dapat mengirim pesan ke kotak surat). Karena setiap kotak

surat memiliki pemilik yang unik, tidak ada kebingungan tentang siapa yang harus menerima

pesan yang dikirim ke kotak surat ini. Ketika sebuah proses yang memiliki kotak surat berakhir,

kotak surat menghilang. Setiap proses yang kemudian mengirim pesan ke kotak surat ini



harus diberitahu bahwa kotak surat tidak ada lagi (melalui penanganan eksepsi, dijelaskan

dalam Bagian 4.6.4).

Ada berbagai cara untuk menunjuk pemilik dan pengguna kotak pesan tertentu. Salah satu

kemungkinan adalah untuk memungkinkan proses untuk mendeklarasikan variabel dari jenis

kotak surat. Proses yang menyatakan kotak adalah pemilik yang kotak itu. Setiap proses lain

yang tahu nama kotak surat ini dapat menggunakan kotak ini.

Di sisi lain, kotak surat yang dimiliki oleh sistem operasi memiliki eksistensi sendiri. Hal ini

independen, dan tidak terikat pada proses tertentu. Sistem operasi menyediakan mekanisme

yang memungkinkan proses:

• Untuk membuat kotak surat baru

• Untuk mengirim dan menerima pesan melalui kotak surat

• Untuk menghancurkan kotak surat

Proses yang menciptakan kotak surat baru adalah pemilik yang kotak surat default. Awalnya,

pemilik adalah satu-satunya proses yang dapat menerima pesan melalui mailbox ini. Namun,

kepemilikan dan menerima hak istimewa dapat diteruskan ke proses lain melalui panggilan

sistem yang tepat. Tentu saja, ketentuan ini dapat mengakibatkan beberapa receiver untuk

setiap kotak pesan. Proses juga dapat berbagi kotak surat melalui fasilitas proses penciptaan.

Sebagai contoh, proses f P menciptakan kotak A, dan kemudian menciptakan proses Q baru,

P dan Q dapat berbagi mailbox A. Karena semua proses dengan hak akses ke kotak surat

pada akhirnya dapat mengakhiri, setelah beberapa waktu kotak surat mungkin tidak lagi dapat

diakses oleh proses apapun. Dalam hal ini, sistem operasi harus merebut kembali ruang apa

pun yang digunakan untuk kotak surat. Tugas ini mungkin memerlukan beberapa bentuk

pengumpulan sampah (lihat Bagian 10.3.5), di mana operasi terpisah terjadi untuk mencari

dan memori deallocate yang tidak lagi digunakan.

4.6.3 Buffering

Sebuah link memiliki beberapa kapasitas yang menentukan jumlah pesan yang bisa berada

di dalamnya sementara. Properti ini dapat dilihat sebagai antrian pesan yang melekat pada

link. Pada dasarnya, ada tiga cara yang antrian tersebut dapat diimplementasikan:

• Kapasitas Zero: Antrian memiliki panjang maksimum 0; dengan demikian, link can¬not

memiliki pesan yang menunggu di dalamnya. Dalam hal ini, pengirim harus menunggu

sampai penerima menerima pesan. Kedua proses harus disinkronkan untuk transfer

pesan berlangsung. Sinkronisasi ini disebut rendezvous.

• Kapasitas Dibatasi: Antrian memiliki panjang terbatas n; dengan demikian, paling pesan n

dapat berada di dalamnya. Jika antrian tidak penuh ketika pesan baru dikirim, yang

terakhir ditempatkan dalam antrian (baik pesan disalin atau pointer ke pesan disimpan),

dan pengirim dapat melanjutkan eksekusi tanpa menunggu. Link memiliki kapasitas yang



terbatas, namun. Jika link penuh, pengirim harus ditunda sampai ruang yang tersedia

dalam antrian.

• Kapasitas tak terbatas: Antrian memiliki panjang potensial tidak terbatas; dengan

demikian, sejumlah pesan bisa menunggu di dalamnya. Pengirim tidak pernah tertunda.

Kasus nol-kapasitas kadang-kadang disebut sebagai sistem pesan tanpa penyangga; kasus

lain memberikan penyangga otomatis.

Kami mencatat bahwa, dalam kasus nol-kapasitas, proses tidak tahu apakah pesan telah tiba

di tempat tujuan setelah operasi mengirim selesai. Jika informasi ini sangat penting untuk

perhitungan, pengirim harus berkomunikasi secara eksplisit dengan penerima untuk

mengetahui apakah kedua menerima pesan. Sebagai contoh, anggaplah processP

mengirimkan pesan untuk memproses Q dan dapat melanjutkan eksekusi setelah pesan

diterima. Proses P mengeksekusi urutan

sendCQ, pesan); receiveCQ, pesan);

Proses Q mengeksekusi

receivefP, pesan); kirim (P, "pengakuan");

Proses tersebut dikatakan berkomunikasi asynchronous.

Ada kasus-kasus khusus yang tidak bisa langsung masuk ke salah satu kategori yang telah

kita bahas:

a. Proses pengiriman pesan tidak pernah tertunda. Namun, jika penerima belum menerima

pesan sebelum proses pengiriman mengirimkan pesan lain, pesan pertama hilang.

Keuntungan dari skema ini adalah bahwa pesan-pesan besar tidak perlu disalin lebih dari

sekali. Kerugian utama adalah bahwa tugas pemrograman menjadi lebih sulit. Proses

perlu synchronizeexplicitly, untuk memastikan kedua yang messagesare tidak hilang dan

bahwa pengirim dan penerima tidak memanipulasi buffer pesan secara bersamaan.

b. Proses pengiriman pesan tertunda sampai menerima balasan. Skema ini diadopsi dalam

sistem operasi Thoth. Dalam sistem ini, pesan yang ukuran tetap (delapan kata). Sebuah

P proses yang mengirim pesan diblokir sampai proses penerimaan telah menerima pesan

dan telah dikirim kembali balasan delapan kata oleh replyfP, pesan) primitif. Pesan

balasan menimpa buffer pesan asli.Satu-satunya perbedaan antara mengirim dan

membalas primitif adalah bahwa mengirim sebuah menyebabkan proses pengiriman akan

diblokir, sedangkan jawabannya memungkinkan kedua proses pengiriman dan proses

penerimaan untuk melanjutkan eksekusi mereka segera.

Metode komunikasi sinkron ini dapat diperluas dengan mudah ke dalam prosedur remote

panggilan (RPC) system dengan fitur lengkap. Sebuah sistem RPC didasarkan pada

kesadaran bahwa subroutine atau panggilan prosedur dalam sistem prosesor tunggal

bertindak persis seperti sistem pesan di mana blok pengirim sampai menerima balasan.

Pesan tersebut kemudian seperti panggilan subrutin, dan pesan kembali mengandung nilai



subroutine dihitung. Langkah logis berikutnya, oleh karena itu, untuk proses konkuren untuk

dapat memanggil satu sama lain sebagai subrutin menggunakan RPC. Bahkan, kita akan

melihat dalam Bab 16 bahwa RPC dapat digunakan antara proses yang berjalan pada

komputer yang terpisah untuk memungkinkan beberapa komputer untuk bekerja sama dalam

cara yang saling menguntungkan.

4.6.4 Kondisi Exception

Sebuah sistem pesan sangat berguna dalam lingkungan terdistribusi, di mana proses mungkin

berada di lokasi yang berbeda (mesin). Dalam lingkungan seperti itu, kemungkinan bahwa

kesalahan akan terjadi selama komunikasi (dan pengolahan) jauh lebih besar daripada dalam

lingkungan tunggal mesin. Dalam lingkungan single-mesin, pesan biasanya

diimplementasikan dalam memori bersama. Jika terjadi kegagalan, seluruh sistem gagal.

Dalam lingkungan terdistribusi, bagaimanapun, pesan ditransfer oleh jalur komunikasi, dan

kegagalan satu situs (atau link) tidak selalu mengakibatkan kegagalan seluruh sistem.

Ketika kegagalan terjadi baik dalam sistem terpusat atau terdistribusi, beberapa error recovery

(exception handling-kondisi) harus terjadi. Mari kita bahas secara singkat beberapa kondisi

pengecualian bahwa sistem harus menangani dalam konteks skema pesan.

4.6.4.1 Proses Menghentikan

Entah pengirim atau penerima dapat menghentikan sebelum pesan diproses. Situasi ini akan

meninggalkan pesan yang tidak akan pernah diterima atau proses menunggu pesan yang

tidak akan pernah dikirim. Wfe mempertimbangkan dua kasus di sini:

1. Proses penerima P mungkin menunggu pesan dari Q proses yang telah dihentikan. F ada

tindakan yang diambil, P akan diblokir selamanya. Dalam hal ini, sistem dapat

menghentikan baik P atau memberitahu P Q telah dihentikan.

2. Proses P dapat mengirim pesan ke Q proses yang telah dihentikan. Dalam otomatis

bufferingscheme, tidak ada salahnya dilakukan; P hanya berlanjut dengan

pelaksanaannya. FP perlu tahu bahwa pesannya telah diproses oleh Q, harus

memprogram secara eksplisit untuk pengakuan. Dalam kasus tidak ada buffering, P akan

diblokir selamanya. Seperti dalam kasus 1, sistem dapat menghentikan baik P atau

memberitahu P Q telah dihentikan.

4.6.4.2 Hilang Pesan

Sebuah pesan dari proses P untuk memproses Q dapat menjadi hilang di suatu tempat dalam

jaringan komunikasi, karena kegagalan hardware atau komunikasi-line. Ada tiga metode

dasar untuk menangani acara ini:

1. Sistem operasi bertanggung jawab untuk mendeteksi acara ini dan untuk resend¬ing

pesan.

2. Proses pengiriman bertanggung jawab untuk mendeteksi acara ini dan untuk

retrans¬mitting pesan, f ia ingin melakukannya.



3. Sistem operasi bertanggung jawab untuk mendeteksi acara ini; kemudian

memberitahukan proses pengiriman bahwa pesan telah hilang. Proses pengiriman dapat

melanjutkan karena memilih.

Hal ini tidak selalu diperlukan untuk mendeteksi pesan yang hilang. Bahkan, beberapa

protokol jaringan menentukan bahwa pesan tidak dapat diandalkan, sedangkan beberapa

jaminan relia¬bility (lihat Bab 15). Pengguna harus menentukan (yaitu, baik memberitahukan

sistem, atau memprogram persyaratan ini sendiri) bahwa deteksi tersebut harus dilakukan.

Bagaimana kita mendeteksi bahwa pesan hilang? Metode deteksi yang paling umum adalah

dengan menggunakan timeout. Ketika pesan dikirim keluar, pesan balasan, mengakui

penerimaan pesan, selalu dikirim kembali. Sistem operasi atau proses kemudian dapat

menentukan interval waktu selama yang mengharapkan pesan pengakuan tiba. Jika periode

ini berlalu sebelum pengakuan tiba, sistem operasi (atau proses) mungkin menganggap

bahwa pesan hilang, dan pesan yang dikirim kembali. Hal ini dimungkinkan, bagaimanapun,

bahwa pesan tidak tersesat, tetapi hanya mengambil sedikit lebih lama dari yang diharapkan

untuk melakukan perjalanan melalui jaringan. Dalam hal ini, kita mungkin memiliki beberapa

salinan pesan yang sama mengalir melalui jaringan. Suatu mekanisme harus ada untuk

membedakan antara berbagai jenis pesan. Masalah ini dibahas secara lebih rinci dalam Bab

16.

4.6.4.3 Pesan Scrambled

Pesan dapat disampaikan ke tujuan, namun tidak beraturan di jalan (misalnya, karena suara

dalam saluran komunikasi). Kasus ini mirip dengan kasus pesan hilang. Biasanya, sistem

operasi akan memancarkan kembali pesan asli. Kesalahan memeriksa kode (seperti

checksum, paritas, dan CRC) yang biasa digunakan untuk mendeteksi jenis kesalahan.

4.6.5 Contoh: Mach

Sebagai contoh sistem operasi berbasis pesan, mempertimbangkan sistem oper¬ating Mach,

yang dikembangkan di Carnegie Mellon University. The Mach kernel mendukung penciptaan

dan penghancuran banyak tugas, yang mirip dengan proses tetapi memiliki beberapa benang

kontrol. Kebanyakan komunikasi di Mach, termasuk sebagian besar panggilan sistem dan

semua informasi intertask, dilakukan oleh pesan. Pesan yang dikirim dan diterima dari kotak

surat, yang disebut pelabuhan di Mach.

Bahkan panggilan sistem yang dibuat oleh pesan. Ketika setiap tugas dibuat, dua kotak pesan

khusus, kotak Kernel dan Beritahu kotak, juga diciptakan. Kernel kotak digunakan oleh kernel

untuk berkomunikasi dengan tugas. Kernel mengirimkan notifikasi kejadian event ke Beritahu

pelabuhan. Hanya tiga panggilan sistem yang diperlukan untuk transfer pesan. The msgsend

panggilan mengirim pesan ke kotak pesan. Sebuah pesan yang diterima melalui msgj-eceive.



RPC dijalankan melalui msgjrpc, yang mengirimkan pesan dan menunggu tepat satu pesan

kembali dari pengirim.

Port-mengalokasikan system call membuat kotak surat baru dan mengalokasikan ruang untuk

antrian yang pesan. Ukuran maksimum pesan antrian default delapan pesan. Tugas yang

menciptakan kotak adalah pemilik yang kotak itu. Pemilik juga diberikan menerima akses ke

kotak surat. Hanya satu tugas pada satu waktu baik dapat sendiri atau menerima dari kotak

surat, namun hak-hak ini dapat dikirim ke tugas-tugas lain jika diinginkan.

Kotak ini memiliki pesan antrian awalnya kosong. Sebagai pesan dikirim ke kotak surat, pesan

akan disalin ke kotak surat. Semua pesan memiliki prioritas yang sama. Jaminan mach bahwa

beberapa pesan dari pengirim yang sama yang antri di pertama-in, first-out (FIFO) order,

namun tidak menjamin pemesanan mutlak. Misalnya, pesan yang dikirim dari masing-masing

dua pengirim dapat antri di urutan apapun.

Pesan itu sendiri terdiri dari sebuah header tetap-panjang, diikuti oleh bagian data variabel-

panjang. Header termasuk panjang pesan dan dua nama kotak surat. Ketika pesan dikirim,

satu nama kotak surat kotak surat yang pesan sedang dikirim. Umumnya, benang pengiriman

mengharapkan balasan; yang nama kotak surat pengirim diteruskan ke tugas penerima, yang

dapat menggunakannya sebagai "alamat pengirim" untuk mengirim pesan kembali.

Bagian variabel pesan adalah daftar diketik item data. Setiap entri dalam daftar memiliki

jenis, ukuran, dan nilai. Jenis objek ditentukan dalam pesan penting, karena operasi-sistem

didefinisikan benda - seperti kepemilikan atau menerima hak akses, menyatakan tugas, dan

segmen memori - dapat dikirimkan dalam pesan.

Yang mengirim dan menerima operasi sendiri cukup fleksibel. Misalnya, ketika pesan dikirim

ke kotak pesan, kotak pesan mungkin penuh. Jika kotak pesan tidak penuh, pesan akan

disalin ke kotak surat dan benang pengiriman terus. f kotak surat penuh, benang pengiriman

memiliki empat pilihan:

1. Tunggu tanpa batas waktu sampai ada ruang di kotak surat.

2. Tunggu paling n milidetik.

3. Jangan menunggu sama sekali, tapi segera kembali.

4. Untuk sementara men-cache pesan. Satu pesan dapat diberikan kepada sistem operasi

untuk menjaga meskipun kotak pesan yang sedang dikirim penuh. Bila pesan sebenarnya

dapat dimasukkan ke dalam kotak surat, pesan dikirim kembali ke pengirim; hanya satu

pesan tersebut ke kotak surat lengkap bisa tertunda setiap saat untuk thread mengirim

diberikan.

Opsi terakhir ini dimaksudkan untuk tugas-tugas server, seperti driver line-printer. Setelah

menyelesaikan permintaan, tugas-tugas ini mungkin perlu mengirim satu kali membalas tugas

yang telah meminta pelayanan, tetapi juga harus melanjutkan permintaan layanan lain,

bahkan jika kotak surat balasan untuk klien penuh.



Menerima operasi harus menentukan dari mana kotak atau set kotak untuk menerima pesan.

Satu set kotak adalah kotak surat koleksi , seperti yang dinyatakan oleh tugas, yang dapat

dikelompokkan bersama-sama dan diperlakukan sebagai salah satu kotak surat untuk tujuan

tugas. Threads in tugas dapat menerima hanya dari kotak surat atau kotak set yang tugas

yang telah menerima akses. Sebuah sistem portstatus panggilan mengembalikan pesan

nomor di kotak pesan tertentu. Menerima operasi mencoba untuk menerima dari (1) setiap

kotak dalam satu set kotak, atau (2) tertentu (bernama) kotak. ff ada pesan yang menunggu

untuk diterima, benang penerima mungkin menunggu, menunggu di sebagian besar n

milidetik, atau tidak menunggu.

Sistem Mach dirancang secara khusus untuk sistem terdistribusi, yang kita bahas dalam Bab

15 sampai 18, tetapi Mach juga cocok untuk sistem single¬processor. Masalah utama dengan

sistem pesan secara umum kinerja yang buruk disebabkan oleh menyalin pesan pertama dari

pengirim ke kotak surat, dan kemudian dari mailer ke penerima. Sistem Pesan Mach mencoba

untuk menghindari operasi copy ganda dengan menggunakan teknik manajemen virtual-

memory (Bab 9). Pada dasarnya, Mach memetakan ruang alamat yang berisi pesan pengirim

ke ruang alamat penerima. Pesan sendiri pernah benar-benar disalin. Teknik pesan-

manajemen ini memberikan dorongan kinerja besar, tetapi bekerja untuk hanya pesan

intrasistem. Sistem operasi Mach dibahas secara rinci dalam bab tentang situs web kami.

4.6.6 Contoh: Windows NT

Sistem operasi Windows NT adalah contoh desain modern yang mempekerjakan modularitas

untuk meningkatkan fungsi dan mengurangi waktu yang dibutuhkan untuk

mengimplementasikan fitur baru. NT menyediakan dukungan untuk beberapa envi¬ronments

operasi atau subsistem yang program aplikasi berkomunikasi dengan melalui mekanisme

pesan lewat. Program aplikasi dapat dianggap sebagai klien subsistem NT server.

Fasilitas pesan lewat di NT disebut Local Fasilitas Procedure Call (LPC). Fasilitas prosedur

panggilan lokal pada Windows NT yang digunakan untuk berkomunikasi antara dua proses

yang pada mesin yang sama. Hal ini mirip dengan mekanisme Procedure Call yang stan¬dard

jauh yang banyak digunakan, tetapi dioptimalkan untuk dan khusus untuk NT. Windows NT,

seperti Mach, menggunakan objek pelabuhan untuk membangun dan memelihara hubungan

antara dua proses. Setiap klien yang memanggil sub¬system membutuhkan saluran

komunikasi yang disediakan oleh benda pelabuhan dan tidak pernah diwariskan. Ada dua

jenis port yang menggunakan NT, port koneksi dan port komunikasi, yang benar-benar sama

tetapi diberi nama yang berbeda sesuai dengan bagaimana mereka digunakan. Port koneksi

adalah obyek bernama (lihat Bab 23 untuk informasi lebih lanjut tentang obyek NT), terlihat

semua proses, dan memberikan aplikasi cara untuk mendirikan sebuah saluran komunikasi.

Komunikasi ini bekerja sebagai berikut:



• Klien membuka pegangan ke objek port koneksi subsistem itu.

• Client mengirimkan permintaan sambungan

• Server menciptakan dua port komunikasi pribadi dan kembali menangani satu mereka

untuk klien.

• Klien dan server menggunakan port pegangan yang sesuai untuk mengirim pesan atau

callback dan mendengarkan balasan.

NT menggunakan tiga jenis teknik messagepassing melalui port yang klien menentukan

ketika menetapkan saluran. Yang paling sederhana, yang digunakan untuk pesan kecil,

adalah dengan menggunakan antrian pesan pelabuhan sebagai penyimpanan intermediate

dan menyalin pesan dari satu proses yang lain. Dengan menggunakan metode ini, pesan

hingga 256 byte dapat dikirim.

Jika klien perlu mengirim pesan yang lebih besar, melewati melalui objek ayat (memori

bersama). Klien harus memutuskan, ketika mendirikan saluran, apakah atau tidak akan perlu

mengirim pesan yang besar. Jika klien menentukan bahwa ia ingin mengirim pesan besar,

meminta objek bagian yang akan dibuat.

Demikian juga, jika server memutuskan bahwa balasan akan besar, juga akan membuat objek

bagian. Untuk menggunakan objek bagian, pesan kecil dikirim yang berisi pointer dan ukuran

informasi tentang objek bagian. Metode ini sedikit lebih rumit daripada metode pertama, tetapi

menghindari menyalin data. Dalam kedua kasus mekanisme callback dapat digunakan ketika

salah satu klien atau server can¬not segera merespon permintaan. Mekanisme callback

memungkinkan mereka untuk melakukan penanganan pesan asynchronous.

Salah satu kelemahan menggunakan message passing untuk melakukan fungsi-fungsi

dasar, seperti fungsi grafis, adalah bahwa kinerja mungkin tidak sebagus sistem-non-pesan

lewat (yaitu, memori bersama). Dalam rangka meningkatkan kinerja, lingkungan NT asli

(Win32) menggunakan metode ketiga pesan lewat disebut LPC cepat. Seorang klien

mengirimkan permintaan koneksi ke port koneksi server dan menunjukkan akan

menggunakan LPC cepat. Server set up thread dedicated server untuk menangani

permintaan, 64 KB objek bagian, dan obyek pasangan acara. Sejak saat itu, pesan yang

disahkan pada objek bagian dan sinkronisasi dilakukan oleh objek pasangan acara. Ini

menghilangkan menyalin pesan, overhead yang menggunakan objek pelabuhan, dan atas

menentukan benang klien menyebutnya karena ada satu thread server per thread client.

Kernel juga memberikan preferensi penjadwalan thread khusus. saja, kelemahan metode ini

adalah bahwa ia menggunakan sumber daya lebih dari dua metode lainnya. Karena ada

beberapa overhead yang terlibat dalam pesan lewat, NT mungkin 'batch "beberapa pesan ke

satu" pesan "untuk mengurangi overhead karena pesan lewat. Untuk informasi lebih lanjut

tentang Windows NT, silakan lihat Bab 23.



4.7 Ringkasan

Sebuah proses adalah program dalam eksekusi. Sebagai suatu proses mengeksekusi, itu

perubahan negara. The negara proses didefinisikan oleh aktivitas proses saat ini. Setiap

proses mungkin dalam satu negara berikut: baru, siap, berjalan, menunggu, atau dihentikan.

Setiap proses direpresentasikan dalam sistem operasi dengan blok kontrol sendiri prosesnya

(PCB).

Sebuah proses, jika tidak melaksanakan, ditempatkan di beberapa antrian tunggu. Ada dua

antrian utama kelas dalam sebuah sistem operasi: I / O antrian permintaan dan antrian siap.

Ready queue berisi semua proses yang siap untuk mengeksekusi dan sedang menunggu

untuk CPU. Setiap proses diwakili oleh PCB dan PCB dapat dihubungkan bersama untuk

membentuk antrian siap.Jangka panjang (job) penjadwalan proses seleksi akan diizinkan

untuk bersaing untuk CPU. Biasanya, penjadwalan jangka panjang sangat dipengaruhi oleh

pertimbangan alokasi sumber daya, terutama manajemen memori. Jangka pendek (CPU)

penjadwalan adalah pemilihan satu proses dari ready queue.

Proses dalam sistem dapat mengeksekusi secara bersamaan. Ada beberapa alasan untuk

memungkinkan eksekusi konkuren: berbagi informasi, perhitungan

speedup, modularitas dan kenyamanan. Pelaksanaan bersamaan membutuhkan mekanisme

untuk proses penciptaan dan penghapusan.

Proses mengeksekusi dalam sistem operasi dapat berupa proses indepen¬dent atau proses

bekerja sama. Proses bekerja sama harus memiliki sarana untuk berkomunikasi satu sama

lain. Pada prinsipnya, ada dua skema komunikasi comple¬mentary: memori dan pesan

bersama sistem. Metode bersama-memori membutuhkan berkomunikasi proses untuk

berbagi beberapa vari¬ables.Proses diharapkan untuk bertukar informasi melalui

penggunaan variabel-variabel bersama. Dalam sistem shared-memori, tanggung jawab untuk

pro¬viding komunikasi terletak pada programer aplikasi; sistem operasi harus menyediakan

hanya memori bersama. Metode Pesan-sistem memungkinkan proses untuk bertukar pesan.

Tanggung jawab untuk menyediakan komunikasi kemudian terletak pada sistem operasi itu

sendiri. Kedua skema tidak saling eksklusif, dan dapat digunakan secara bersamaan dalam

sistem operasi tunggal.

Proses bekerja sama secara langsung berbagi ruang alamat logika dapat diimplementasikan

sebagai proses ringan atau benang. Sebuah thread adalah unit dasar dari penggunaan CPU,

dan berbagi dengan benang rekan bagian kode, bagian data, dan sumber daya sistem

operasi, yang dikenal sebagai tugas. Sebuah tugas tidak apa-apa jika tidak ada benang di

dalamnya, dan benang harus dalam tepat satu tugas. Pembagian luas membuat CPU beralih

antara benang rekan dan penciptaan benang murah, dibandingkan dengan konteks switch

antara proses kelas berat.



Latihan Soal

1. Beberapa sistem operasi mikrokomputer populer menyediakan sedikit atau tidak ada

sarana pemrosesan konkuren. Diskusikan komplikasi utama yang pemrosesan konkuren

menambah sistem operasi.

2. Jelaskan perbedaan antara jangka pendek, jangka menengah, dan penjadwalan jangka

panjang.

3. Sebuah komputer DECSYSTEM-20 memiliki beberapa daftar set. Jelaskan tindakan

context switch jika konteks baru sudah dimuat ke salah satu set mendaftar. Apa lagi yang

harus terjadi jika konteks baru dalam memori daripada set register, dan semua set register

digunakan?

4. Apa dua keuntungan yang benang memiliki lebih dari beberapa proses? Apa kelemahan

utama yang mereka miliki? Sarankan satu aplikasi yang akan mendapat manfaat dari

penggunaan benang, dan satu yang tidak.

5. Sumber daya apa yang digunakan ketika thread dibuat? Bagaimana mereka berbeda dari

yang digunakan saat proses diciptakan?

Daftar Pustaka

1. Silbershatz Abraham, Galvin Peter Douglas Alger (1998), Operating System

Concepts, Addison Wesley Longman, Inc.

modul 4 - proses

Documents