Daftar Isi
Proses
Konsep Dasar dan Definisi Proses
Keadaan Proses
Process Control Back
Threads
Penjadwalan Proses
Penjadwalan Antrian
Penjadwal
Context Switch
Operasi-operasi Pada Proses
Pembuatan Proses
Terminasi Proses
Hubungan Antara Proses
Proses yang kooperatif
Komunikasi Proses Dalam Sistem
Thread
Konsep Dasar
Keuntungan
User Dan Kernel Threads
Jenis-Jenis Thread
Model Multithreading
Thread dalam Solaris 2
Thread Java
Penjadwalan CPU
Konsep Dasar
Algoritma Penjadwalan
Penjadwalan Multiprocessor
Penjadwalan Multiple Processor
Penjadwalan Real Time
Penjadwalan Thread
Java Thread dan Algoritmanya
Penjadwalan Java Thread
Evaluasi Algorithm
Kesimpulan
Proses
Thread
Penjadwalan CPU
Soal-soal Latihan
Proses
Thread
Penjadwalan CPU
Referensi
Daftar Istilah
Daftar Tabel
1. Tabel untuk soal 4 — 5

Proses

Satu selingan pada diskusi kita mengenai sistem operasi yaitu bahwa ada sebuah pertanyaan mengenai apa untuk menyebut semua aktivitas CPU. Sistem batch mengeksekusi jobs, sebagaimana suatu sistem time-shared telah menggunakan user programs, atau tugas-tugas/pekerjaan-pekerjaan. Bahkan pada sistem tunggal, seperti Microsoft Windows dan Macintosh OS, seorang user mampu untuk menjalankan beberapa program pada saat yang sama: Sebuah Word Processor, Web Browser, dan paket e-mail. Bahkan jika user dapat melakukan hanya satu program pada satu waktu, sistem operasi perlu untuk mendukung aktivitas program internalnya sendiri, seperti manajemen memori. Dalam banyak hal, seluruh aktivitas ini adalah serupa, maka kita menyebut seluruh program itu proses-proses (processes).

Istilah job dan proses digunakan hampir dapat dipertukarkan pada tulisan ini. Walau kami pribadi lebih mneyukai istilah proses, banyak teori dan terminologi sistem-operasi dikembangkan selama suatu waktu ketika aktivitas utama sistem operasi adalah job processing. Akan menyesatkan untuk menghindari penggunaan istilah umum yang telah diterima bahwa memasukkn kata job (seperti penjadwalan job) hanya karena proses memiliki job pengganti/pendahulu.


Process Control Back

Tiap proses digambarkan dalam sistem operasi oleh sebuah process control block (PCB) - juga disebut sebuah control block. Sebuah PCB ditunjukkan dalam gambar(4.2). PCB berisikan banyak bagian-dari informasi yang berhubungan dengan sebuah proses yang spesifik, termasuk ini:

Gambar4.2 Process Control Back


Penjadwalan Proses

Tujuan dari multiprogramming adalah untuk memiliki sejumlah proses yang berjalan pada sepanjang waktu, untuk memaksimalkan penggunaan CPU. Tujuan dari pembagian waktu adalah untuk mengganti CPU diantara proses-proses yang begitu sering sehingga user dapat berinteraksi dengan setiap program sambil CPU bekerja. Untuk sistem uniprosesor, tidak akan ada lebih dari satu proses berjalan. Jika ada proses yang lebih dari itu, yang lainnya akan harus menunggu sampai CPU bebas dan dapat dijadwalkan kembali.


Penjadwalan Antrian

Ketika proses memasuki sistem, mereka diletakkan dalam antrian job. Antrian ini terdiri dari seluruh proses dalam sistem. Proses yang hidup pada memori utama dan siap dan menunggu/wait untuk mengeksekusi disimpan pada sebuah daftar bernama ready queue. Antrian ini biasanya disimpan sebagai daftar penghubung. Sebuah header ready queue berisikan penunjuk kepada PCB-PCB awal dan akhir. Setiap PCB memiliki pointer field yang menunjukkan proses selanjutnya dalam ready queue.

Juga ada antrian lain dalam sistem. Ketika sebuah proses mengalokasikan CPU, proses tersebut berjalan/bekerja sebentar lalu berhenti, di interupsi, atau menunggu suatu kejadian tertentu, seperti penyelesaian suatu permintaan I/O. Pada kasus ini sebuah permintaan I/O, permintaan seperti itu mungkin untuk sebuah tape drive yang telah diperuntukkan, atau alat yang berbagi, seperti disket. Karena ada banyak proses dalam sistem, disket bisa jadi sibuk dengan permintaan I/O untuk proses lainnya. Maka proses tersebut mungkin harus menunggu untuk disket tersebut. Daftar dari proses yang menunggu untuk peralatan I/O tertentu disebut sebuah device queue. Tiap peralatan memiliki device queuenya sendiri (Gambar 4.4).

Reprensentasi umum untuk suatu diskusi mengenai penjadwalan proses adalah diagram antrian, seperti pada gambar 4.5. Setiap kotak segi empat menunjukkan sebuah antrian. Dua tipe antrian menunjukan antrian yang siap dan suatu perangkat device queues. Lingkaran menunjukkan sumber-sumber yang melayani sistem. Sebuah proses baru pertama-tama ditaruh dalam ready queue. Lalu menunggu dalam ready queue sampai proses tersebut dipilih untuk dikerjakan/lakukan atau di dispatched. Begitu proses tersebut mengalokasikan CPU dan menjalankan/mengeksekusi, satu dari beberapa kejadian dapat terjadi.

  • Proses tersebut dapat membuat subproses yang baru dan menunggu terminasinya sendiri.

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

Gambar4.5 Diagram Antrian

Dalam 2 kasus pertama, proses akhirnya berganti dari waiting state menjadi ready state, lalu diletakkan kembali dalam ready queue. Sebuah proses meneruskan siklus ini sampai berakhir, disaat dimana proses tersebut diganti dari seluruh queue dan memiliki PCB nya dan sumber-sumber/resources dialokasikan kembali.


Penjadwal

Sebuah proses berpindah antara berbagai penjadwalan antrian selama umur hidupnya. Sistem operasi harus memilih, untuk keperluan penjadwalan, memproses antrian-antrian ini dalam cara tertentu. Pemilihan proses dilaksanakan oleh penjadwal yang tepat/cocok. Dalam sistem batch, sering ada lebih banyak proses yang diserahkan daripada yang dapat dilaksanakan segera. Proses ini dipitakan/disimpan pada suatu alat penyimpan masal (biasanya disket), dimana proses tersebut disimpan untuk eksekusi dilain waktu. Penjadwalan longterm, atau penjadwal job , memilih proses dari pool ini dan mengisinya kedalam memori eksekusi. Penjadwalan shortterm harus memilih proses baru untuk CPU dengan sering. Sebuah proses dapat mengeksekusi untuk hanya beberapa milidetik sebelum menunggu permintaan I/O. Seringkali, penjadwalan shorterm mengeksekusi paling sedikit sekali setiap 100 milidetik. Karena durasi waktu yang pendek antara eksekusi, penjadwalan shorterm haruslah cepat. Jika memerlukan 10 mili detik untuk menentukan suatu proses eksekusi selama 100 mili detik, maka 10/(100 + 10) = 9 persen CPU sedang digunakan (terbuang) hanya untuk pekerjaan penjadwalan.

Penjadwalan longterm pada sisi lain, mengeksekusi jauh lebih sedikit. Mungkin ada beberapa menit antara pembuatan proses baru dalam sistem. Penjadwalan longterm mengkontrol derajat multiprogramming (jumlah proses dalam memori). Jika derajat multiprogramming stabil, lalu tingkat rata-rata dari penciptaan proses harus sama dengan tingkat kepergian rata rata dari proses yang meninggalkan sistem. Maka penjadwalan longterm mungkin diperlukan untuk dipanggil hanya ketika suatu proses meninggalkan sistem. Karena interval yang lebih panjang antara eksekusi, penjadwalan longterm dapat memakai waktu yang lebih lama untuk menentukan proses mana yang harus dipilih untuk dieksekusi.

Adalah penting bagi penjadwalan longterm membuat seleksi yang hati-hati. Secara umum, kebanyakan proses dapat dijelaskan sebagai I/O bound atau CPU bound. Sebuah proses I/O bound adalah salah satu yang membuang waktunya untuk mengerjakan I/O dari pada melakukan perhitungan. Suatu proses CPU-bound , pada sisi lain, adalah salah satu yang jarang menghasilkan permintaan I/O, menggunakan lebih banyak waktunya melakukan banyak komputasi daripada yang digunakan oleh proses I/O bound. Penting untuk penjadwalan longterm memilih campuran proses yang baik antara proses I/O bound dan CPU bound. Jika seluruh proses adalah I/O bound, ready queue akan hampir selalu kosong, dan penjadwalan shortterm akan memiliki sedikit tugas. Jika seluruh proses adalah CPU bound, I/O waiting queue akan hampir selalu kosong, peralatan akan tidak terpakai, dan sistem akan menjadi tidak imbang. Sistem dengan performa yang terbaik akan memiliki kombinasi proses CPU bound dan I/O bound.

Pada sebagian sistem, penjadwal long term dapat tidak turut serta atau minimal. Sebagai contoh, sistem time-sharing seperti UNIX sering kali tidak memiliki penjadwal long term . Stabilitas sistem-sistem ini bergantung pada keterbatasan fisik (seperti jumlah terminal yang ada) atau pada penyesuaian sendiri secara alamiah oleh manusia sebagai pengguna. Jika performa menurun pada tingkat yang tidak dapat diterima , sebagian pengguna akan berhenti.

Sebagian sistem operasi, seperti sistem time sharing, dapat memperkenalkan sebuah tambahan, penjadwalan tingkat menengah . Penjadwal medium-term ini digambarkan pada (gambar 4.6). Ide utama/kunci dibelakang sebuah penjadwal medium term adalah kadang kala akan menguntungkan untuk memindahkan proses dari memori (dan dari pengisian aktif dari CPU), dan maka untuk mengurangi derajat dari multiprogramming. Dikemudian waktu, proses dapat diperkenalkan kedalam memori dan eksekusinya dapat dilanjutkan dimana proses itu di tinggalkan/diangkat. Skema ini disebut swapping. Proses di swapped out, dan lalu di swapped in, oleh penjadwal medium term. Swapping mungkin perlu untuk meningkatkan pencampuran proses, atau karena suatu perubahan dalam persyaratan memori untuk dibebaskan. Swapping dibahas dalam ch 9.


Context Switch

Mengganti CPU ke proses lain memerlukan penyimpanan suatu keadaan proses lama (state of old process) dan kemudian beralih ke proses yang baru. Tugas tersebut diketahui sebagai context switch. Context switch sebuah proses digambarkan dalam PCB suatu proses; termasuk nilai dari CPU register, status proses (lihat gambar 4.1) dan informasi manajemen memori. Ketika sebuah context switch terjadi, kernel menyimpan context dari proses lama kedalam PCB nya dan mengisi context yang telah disimpan dari process baru yang telah terjadwal untuk berjalan. Pergantian waktu context adalah murni overhead, karena sistem melakukan pekerjaan yang tidak perlu. Kecepatannya bervariasi dari mesin ke mesin, bergantung pada kecepatan memori, jumlah register yang harus di copy, dan keberadaan instruksi khusus ( seperti instruksi tunggal untuk mengisi atau menyimpan seluruh register). Tingkat kecepatan umumnya berkisar antara 1 sampai 1000 mikro detik

Waktu context switch sangat begantung pada dukungan perangkat keras. Sebagai contoh, sebagian prosesor (seperti UltraSPARC) menyediakan seperangkat register berganda. Sebuah context switch hanya memasukkan perubahan pointer ke perangkat register yang ada. Tentu saja, jika ada lebih proses-proses aktif yang ada dari pada yang ada di perangkat register, sistem menggunakan bantuan untuk meng-copy data register pada dan dari memori, sebagaimana sebelumnya. Semakin sistem operasi kompleks, makin banyak pekerjaan yang harus dilakukan selama context switch. Sebagaimana dilihat pada ch 9, tehnik manajemen memori tingkat lanjut dapat mensyaratkan data tambahan untuk diganti dengan tiap context. Sebagai contoh, ruang alamat dari proses yang ada harus dijaga sebagai ruang pada pekerjaan berikutnya untuk digunakan. Bagaimana ruang alamat di jaga, berapa banyak pekerjaan dibutuhkan untuk menjaganya, tergantung pada metoda manajemen memori dari sistem operasi. Sebagaimana akan kita lihat pada ch 5, context switching telah menjadi suatu keharusan, bahwa programmer menggunakan struktur (threads) untuk menghindarinya kapanpun memungkinkan.


Operasi-operasi Pada Proses

Proses dalam sistem dapat dieksekusi secara bersama-sama, proses tersebut harus dibuat dan dihapus secara dinamis. Maka, sistem operasi harus menyediakan suatu mekanisme umtuk pembuatan proses dan terminasi proses.


Pembuatan Proses

Suatu proses dapat membuat beberapa proses baru, melalui sistem pemanggilan pembuatan proses, selama jalur eksekusi. Pembuatan proses dinamakan induk proses, sebagaimana proses baru di sebut anak dari proses tersbut. Tiap proses baru tersebut dapat membuat proses lainnya, membentuk suatu pohon proses (lihat gambar 4.7).

Secara umum, suatu proses akan memerlukan sumber tertentu (waktu CPU, memori, berkas, perangkat I/O) untuk menyelesaikan tugasnya. Ketika suatu proses membuat sebuah subproses,sehingga subproses dapat mampu untuk memperoleh sumbernya secara langsung dari sistem operasi. Induk mungkin harus membatasi sumber diantara anaknya, atau induk dapat berbagi sebagian sumber (seperti memori berkas ) diantara beberapa dari anaknya. Membatasi suatu anak proses menjadi subset sumber daya induknya mencegah proses apapun dari pengisian sistem yang telalu banyak dengan menciptakan terlau banyak subproses.

Sebagai tambahan pada berbagai sumber fisik dan logis bahwa suatu proses diperoleh ketika telah dibuat, data pemula (masukan) dapat turut lewat oleh induk proses sampai anak proses. Sebagai contoh, anggap suatu proses yang fungsinya untuk menunjukkan status sebuah berkas, katakan F1, pada layar terminal. Ketika dibuat, akan menjadi sebagai sebuah masukan dari proses induknya, nama dari berkas f1, dan akan mengeksekusi menggunakan kumpulan data tersebut untuk memperoleh informasi yang diinginkan. Proses tersebut juga mendapat nama dari perangkat luar. Sebagian sistem operasi melewati sumber-sumber ke anak proses. Pada sistem tersebut, proses baru bisa mendapat dua berkas terbuka yang baru, F1 dan perangkat terminal dan hanya perlu untuk mentransfer data antara kedua berkas tersebut.

Ketika suatu proses membuat proses baru, dua kemungkinan ada dalam term eksekusi:

  1. Induk terus menerus untuk mengeksekusi secara bersama-sama dengan anaknya.

  2. Induk menunggu sampai sebagian dari anaknya telah diakhiri/terminasi.

Juga ada dua kemungkinan dalam term dari addres space pada proses baru:

  1. Anak proses adalah duplikat dari induk proses.

  2. Anak proses memiliki program yang terisikan didalamnya.

Untuk mengilustrasikan implementasi yang berbeda ini, mari kita mempelajari sistem operasi UNIX. Dalam UNIX, tiap proses diidentifikasi oleh pengidentifikasi proses, yang merupakan integer yang unik. Proses baru dibuat oleh sistem pemanggilan fork system call. Proses baru tersebut terdiri dari sebuah copy ruang alamat dari proses aslinya (original). Mekanisme tersebut memungkinkan induk proses untuk berkomunikasi dengan mudah dengan anak proses. Kedua proses (induk dan anak) meneruskan eksekusi pada instruksi setelah fork dengan satu perbedaan: Kode kembali untuk fork adalah nol untuk proses baru (anak), sebagaimana proses pengidentifikasi non nol (non zero) dari anak dikembalikan kepada induk.

Umumnya, sistem pemanggilan execlp digunakan setelah sistem pemanggilan fork Oleh satu dari dua proses untuk menggantikan proses ruang memori dengan program baru. Sistem pemanggilan execlp mengisi suatu berkas binary kedalam memori ( menghancurkan gambar memori pada program yang berisikan sistem pemanggilan execlp) dan memulai eksekusinya. Dengan cara ini , kedua proses mampu untuk berkomunikasi, dan lalu untuk pergi ke arah yang berbeda. Induk lalu dapat membuat anak yang lebh banyak atau jika induk tidak punya hal lain untuk dilakukan ketika anak bekerja, induk dapat mengeluarkan sistem pemanggilan wait untuk tidak menggerakkan dirinya sendiri pada suatu antrian yang siap sampai anak berhenti. Program C ditunjukkan pada gambar 4.8 mengilustrasikan sistem pemanggilan pada UNIX yang sebelumnya dijelaskan. Induk membuat anak proses menggunakan sistem pemanggilan fork(). Kini kita mempunyai dua proses yang berbeda yang menjalankan sebuah copy pada program yang sama. Nilai dari pid untuk anak proses adalah nol (zero): maka untuk induk adalah nilai integer yang lebih besar dari nol. Anak proses meletakkan ruang alamatnya dengan UNIX command/bin/1s (digunakan untuk mendapatkan pendaftaran directory) menggunakan sistem pemanggilan execlp(). Ketika anak proses selesai, induk proses menyimpulkan dari pemanggilan untuk wait() dimana induk proses menyelesaikannya dengan menggunakan sistem pemanggilan exit().

Sistem operasi DEC VMS, secara kontras, membuat sebuah proses baru, mengisi program tertentu kedalam proses tersebut, dan memulai pekerjaannya. Sistem operasi Microsoft windows NT mendukung kedua model: Ruang alamat induk proses dapat di duplikasi, atau induk dapat menspesifikasi nama dari sebuah program untuk sistem operasi untuk diisikan kedalam ruang alamat pada proses baru.


Terminasi Proses

Sebuah proses berakhir ketika proses tersebut selesai mengeksekusi pernyataan akhirnya dan meminta sistem operasi untuk menghapusnya dengan menggunakan sistem pemanggilan exit. Pada titik itu, proses tersebut dapat mengembalikan data (keluara) pada induk prosesnya (melalui sistem pemanggilan wait) Seluruh sumber-sumber dari proses-termasuk memori fisik dan virtual, membuka berkas, dan penyimpanan I/O di tempatkan kembali oleh sistem operasi.

Ada situasi tambahan tertentu ketika terminasi terjadi. Sebuah proses dapat menyebabkan terminasi dari proses lain melalui sistem pemanggilan yang tepat (contoh abort). Biasanya, sistem seperti itu dapat dipanggil hanya oleh induk proses tersebut yang akan diterminasi. Bila tidak, user dapat secara sewenang-wenang membunuh job antara satu sama lain. Catat bahwa induk perlu tahu identitas dari anaknya. Maka, ketika satu proses membuat proses baru, identitas dari proses yang baru diberikan kepada induknya.

Induk dapat menterminasi/mengakhiri satu dari anaknya untuk beberapa alasan, seperti:

Untuk menentukan kasus pertama, induk harus memiliki mekanisme untuk memeriksa status anaknya. Banyak sistem, termasuk VMS, tidak memperbolehkan sebuah anak untuk ada jika induknya telah berakhir. Dalam sistem seperti ini, jika suatu proses berakhir (walau secara normal atau tidak normal), maka seluruh anaknya juga harus diterminasi. Fenomena ini, mengacu pada terminasi secara cascading, yang normalnya dimulai oleh sistem operasi.

Untuk mengilustrasikan proses eksekusi dan proses terminasi, kita menganggap bahwa, dalam UNIX, kami dapat mengakhiri suatu proses dengan sistem pemanggilan exit; proses induknya dapat menunggu untuk terminasi anak proses dengan menggunakan sistem pemanggilan wait. Sistem pemanggilan wait kembali ke pengidentifikasi proses dari anak yang telah diterminasi, maka induk dapat memberitahu kemungkinanan anak mana yang telah diterminasi. Jika induk menterminasi. Maka, anaknya masih punya sebuah induk untuk mengumpulkan status mereka dan mengumpulkan statistik eksekusinya.


Hubungan Antara Proses

Sebelumnya kita telah ketahui seluk beluk dari suatu proses mulai dari pengertiannya, cara kerjanya, sampai operasi-operasinya seperti proses pembentukannya dan proses pemberhentiannya setelah selesai melakukan eksekusi. Kali ini kita akan mengulas bagaimana hubungan antar proses dapat berlangsung, misal bagaimana beberapa proses dapat saling berkomunikasi dan bekerjasama.


Proses yang kooperatif

Proses yang bersifat simultan (concurrent) dijalankan pada sistem operasi dapat dibedakaan menjadi yaitu proses independent dan proses kooperatif. Suatu proses dikatakan independent apabila proses tersebut tidak dapat terpengaruh atau dipengaruhi oleh proses lain yang sedang dijalankan pada sistem. Berarti, semua proses yang tidak membagi data apapun (baik sementara / tetap) dengan proses lain adalah independent. Sedangkan proses kooperatif adalah proses yang dapat dipengaruhi ataupun terpengaruhi oleh proses lain yang sedang dijalankan dalam sistem. Dengan kata lain, proses dikatakan kooperatif bila proses dapat membagi datanya dengan proses lain.

Ada 4 alasan untuk penyediaan sebuah lingkungan yang memperbolehkan terjadinya proses kooperatif :

  1. Pembagian informasi : apabila beberapa pengguna dapat tertarik pada bagian informasi yang sama (sebagai contoh, sebuah berkas bersama), kita harus menyediakan sebuah lingkungan yang mengijinkan akses secara terus menerus ke tipe dari sumber-sumber tersebut.

  2. Kecepatan penghitungan / komputasi : jika kita menginginkan sebuah tugas khusus untuk menjalankan lebih cepat, kita harus membagi hal tersebut ke dalam subtask, setiap bagian dari subtask akan dijalankan secara parallel dengan yang lainnya. Peningkatan kecepatan dapat dilakukan hanya jika komputer tersebut memiliki elemen-elemen pemrosesan ganda (seperti CPU atau jalur I/O).

  3. Modularitas : kita mungkin ingin untuk membangun sebuah sistem pada sebuah model modular-modular, membagi fungsi sistem menjadi beberapa proses atau threads.

  4. Kenyamanan : bahkan seorang pengguna individu mungkin memiliki banyak tugas untuk dikerjakan secara bersamaan pada satu waktu. Sebagai contoh, seorang pengguna dapat mengedit, memcetak, dan meng-compile secara parallel.

import java.util.*;

public class BoundedBuffer {

  public BoundedBuffer() {
    // buffer diinisialisasikan kosong
    count   = 0;
    in      = 0;
    out     = 0;

    buffer = new Object[BUFFER_SIZE];
  }

  // produser memanggil method ini
  public void enter( Object item ) {
    while ( count == BUFFER_SIZE )
    ; // do nothing

    // menambahkan suatu item ke dalam buffer
    ++count;
    buffer[in]  = item;
    in  = ( in + 1 ) % BUFFER_SIZE;

    if ( count == BUFFER_SIZE )
      System.out.println( "Producer Entered " +
        item + " Buffer FULL" );
    else
      System.out.println( "Producer Entered " +
        item + " Buffer Size = " + count );
  }

// consumer memanggil method ini  
public Object remove() {
    Object item ;

    while ( count == 0 )
    ; // do nothing
    
    // menyingkirkan suatu item dari buffer
    --count;
    item  = buffer[out];
    out   = ( out + 1 ) % BUFFER_SIZE;

    if ( count == 0 )
      System.out.println( "Consumer consumed " +
        item + " Buffer EMPTY" );
    else
      System.out.println( "Consumer consumed " +
        item + " Buffer Size = " +count );

    return item;
  }

  public static final int NAP_TIME = 5;
  private static final int BUFFER_SIZE = 5;

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

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


Komunikasi Proses Dalam Sistem

Cara lain untuk meningkatkan efek yang sama adalah untuk sistem operasi yaitu untuk menyediakan alat-alat proses kooperatif untuk berkomunikasi dengan yang lain lewat sebuah komunikasi dalam proses (IPC=Inter-Process Communication). IPC menyediakan sebuah mekanisme untuk megijinkan proses-proses untuk berkomunikasi dan menyelaraskan aksi-aksi mereka tanpa berbagi ruang alamat yang sama. IPC adalah khusus digunakan dalam sebuah lingkungan yang terdistribusi dimana proses komunikasi tersebut mungkin saja tetap ada dalam komputer-komputer yang berbeda yang tersambung dalam sebuah jaringan. IPC adalah penyedia layanan terbaik dengan menggnakan sebuah sistem penyampaian pesan, dan sistem-sistem pesan dapat diberikan dalam banyak cara.


Penamaan

Proses-proses yang ingin dikomunikasikan harus memiliki sebuah cara untuk memilih satu dengan yang lain. Mereka dapat menggunakan komunikasi langsung / tidak langsung.


Komunikasi Tidak Langsung

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

Dalam masalah ini, link komunikasi mempunyai sifat sebagai berikut :

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

  • Sebuah link mungkin dapat berasosiasi dengan lebih dari 2 proses.

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

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

  • Mengijinkan sebuah link berasosiasi dengan paling banyak 2 proses.

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

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

Mailbox mungkin dapat dimiliki oleh sebuah proses atau sistem operasi. Jika mailbox dimiliki oleh proses, maka kita mendefinisikan antara pemilik (yang hanya dapat menerima pesan melalui mailbox) dan pengguna dari mailbox (yang hanya dapat mengirim pesan ke mailbox). Selama setiap mailbox mempunyai kepemilikan yang unik, maka tidak akan ada kebingungan tentang siapa yang harus menerima pesan dari mailbox. Ketika proses yang memiliki mailbox tersebut diterminasi, mailbox akan hilang. Semua proses yang mengirim pesan ke mailbox ini diberi pesan bahwa mailbox tersebut tidak lagi ada.

Dengan kata lain, mempunyai mailbox sendiri yang independent, dan tidak melibatkan proses yang lain. Maka sistem operasi harus memiliki mekanisme yang mengijinkan proses untuk melakukan hal-hal dibawah ini :

  • Membuat mailbox baru.

  • Mengirim dan menerima pesan melalui mailbox.

  • Menghapus mailbox.

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


Contoh Produser-Konsumer

Sekarang kita mempunyai solusi problem produser-konsumer yang menggunakan penyampaian pesan. Produser dan konsumer akan berkomunikasi secara tidak langsung menggunakan mailbox yang dibagi. Buffer menggunakan java.util.Vector class sehingga buffer mempunyai kapasitas tak terhingga. Dan send() dan read() method adalah nonblocking. Ketika produser memproduksi suatu item, item tersebut diletakkan ke mailbox melalui send() method. Konsumer menerima item dari mailbox menggunakan receive() method. Karena receive() nonblocking, consumer harus mengevaluasi nilai dari Object yang direturn dari receive(). Jika null, mailbox kosong.

	import java.util.*;

	public class Producer extends Thread {
	  private MessageQueueueue mbox;

	  public Producer( MessageQueueueue m ) {
		mbox  = m;
	  }

	  public void run() {
		Date message;

		while ( true ) {
		  int sleeptime   = ( int ) ( Server.NAP_TIME * Math.random() );
		  System.out.println( "Producer sleeping for " + sleeptime + " seconds" );
		  try {
			Thread.sleep(sleeptime*1000);
		  } catch( InterruptedException e ) {}

		  message = new Date();
		  System.out.println( "Producer produced " + message );
		  mbox.send( message );
		}
	  }
	}


	import java.util.*;

	public class Consumer extends Thread {
	  private MessageQueueueue mbox;

	  public Consumer( MessageQueueueue m ) {
		mbox  = m;
	  }

	  public void run() {
		Date message;

		while ( true ) {
		  int sleeptime = ( int ) ( Server.NAP_TIME * Math.random());
		  System.out.println("Consumer sleeping for " + sleeptime + " seconds" );
		  try {
			Thread.sleep( sleeptime * 1000 );
		  } catch( InterruptedException e ) {}

		  message = ( Date ) mbox.receive();

		  if ( message != null )
			System.out.println("Consumer consume " + message );
		}
	  }
	}
	

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

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


Mailbox

	import java.util.*;

	public class MessageQueue {
	  private Vector q;

	  public MessageQueue() {
		q   = new Vector();
	  }
	  
	  // Mengimplementasikan pengiriman nonblocking
	  public void send( Object item ) {
		q.addElement( item );
	  }
	  
	  // Mengimplementasikan penerimaan nonblocking
	  public Object receive() {
		Object item;
		if ( q.size() == 0 )
		  return null;
		else {
		  item  = q.firstElement();
		  q.removeElementAt(0);

		  return item;
		}
	  }
	}
	

  1. Menunggu sampai batas waktu yang tidak dapat ditentukan sampai terdapat ruang kosong pada mailbox.

  2. Menunggu paling banyak n milidetik.

  3. Tidak menunggu, tetapi kembali (return) secepatnya.

  4. Satu pesan dapat diberikan kepada sistem operasi untuk disimpan, walaupun mailbox yang dituju penuh. Ketika pesan dapat disimpan pada mailbox, pesan akan dikembalikan kepada pengirim (sender). Hanya satu pesan kepada mailbox yang penuh yang dapat diundur (pending) pada suatu waktu untuk diberikan kepada thread pengirim.


Thread

Thread, atau kadang-kadang disebut proses ringan (lightweight), adalah unit dasar dari utilisasi CPU. Di dalamnya terdapat ID thread, program counter, register, dan stack. Dan saling berbagi dengan thread lain dalam proses yang sama.


Jenis-Jenis Thread

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


Model Multithreading

Sistem-sistem yang ada sekarang sudah banyak yang bisa mendukung untuk kedua user dan kernel thread, sehingga model-model multithreading-nyapun menjadi beragam. Implementasi multithreading yang umum akan kita bahas ada tiga, yaitu model many-to-one, one-to-one, dan 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 user, simetrik multiproses (SMP), dan penjadwalan real-time.

Threads di dalam Solaris 2 sudah dilengkapi dengan library mengenai API-API untuk pembuatan dan manajemen thread. Di dalam Solaris 2 terdapat juga level tengah thread. Di antara user-level dan kernel-level thread terdapat proses ringan / lightweight (LWP). Setiap proses yang ada setidaknya mengandung minimal satu buah LWP. Library thread memasangkan beberapa user-level thread ke ruang LWP-LWP untuk diproses, dan hanya satu user-level thread yang sedang terpasang ke suatu LWP yang bisa berjalan. Sisanya bisa diblok maupun 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.

User-level threads dalam Solaris bisa berjenis bound maupun unbound. Suatu bound user-level thread 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 user-level threads 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:

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.


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 manajemen 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. Bagaimanapun, 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. Bagaimanapun, 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.


Manajemen Thread

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

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. Bagaimanapun, 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.


Penjadwalan CPU

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


Konsep Dasar

Tujuan dari multi programming adalah untuk mempunyai proses berjalan secara bersamaan, unutk memaksimalkan kinerja dari CPU. Untuk sistem uniprosesor, tidak pernah ada proses yang berjalan lebih dari satu. Bila ada proses yang lebih dari satu maka yang lain harus mengantri sampai cpu bebas.

Ide dari multi porgamming sangat sederhana. Ketika sebuah proses dieksekusi yang lain harus menunggu sampai selesai. Di sistem komputer yang sederhana CPU akan banyak dalam posisi idle.Semua waktu ini sangat terbunag,. Dengan multiprogamming kita mencoba menggunakan waktu secara produktif. Beberapa proses di simpan dalam memori dalam satu waktu. Ketika proses harus menuggu. Sistem operasi mengmbil cpu untuk memproses proses tersebut dan meninggalkan proses yang sedang dieksekusi.

penjadwalan adalah fungsi dasar dari suatu sistem opersai. Hampir semua sumber komputer dijadwalkan sebelum digunakan. CPU salah satu sumber dari komputer yang penting yang menjadi sentral dari sentral penjadwalan di sistem operasi.


Kriteria Penjadwalan

Algoritma penjadwalan CPU yang berbeda mempunyai property yang berbeda. Dalam memilih algoritma yang digunakan untuk situasi tertentu, kita harus memikirkan properti yang berbeda untuk algoritma yang berbeda. Banyak kriteria yang dianjurkan utnuk membandingkan penjadwalan CPU algoritma. Kritria yang biasanya digunakan dalam memilh adalah :

  1. CPU utilization : kita ingin menjaga CPU sesibuk mungkin. CPU utilization akan mempunyai range dari 0 ke 100 persen. Di sistem yang sebenarnya seharusnya ia mempunyai range dari 40 persen samapi 90 persen

  2. Throughput : jika cpu sibuk mengeksekusi proses, jika begitu kerja telah dilaksanakan. Salah satu ukuran kerja adalah banyak proses yang diselesaikan per unit waktu, disebut througput. Untuk proses yang lama mungkin 1 proses per jam ; untuk proses yang sebentar mungkin 10 proses perdetik.

  3. Turnaround time : dari sudur pandang proses tertentu, kriteria yang penting adalah berapa lama untuk mengeksekusi proses tersebut. Interval dari waktu yang dijinkan dengan waktu yang dibutuhkan untuk menyelesaikan sebuah prose disebut turn around time. Trun around time adalah jumlah periode untuk menunggu untuk bisa ke memori, menunggu di ready queue, eksekusi di CPU, dan melakukan I/O

  4. Waiting time : algoritma penjadwalan cpu tidak mempengaruhi waktu untuk melaksanakan proses tersebut atau I/O; itu hanya mempengaruhi jumlah waktu yang dibutuhkan proses di antrian ready. Waiting time adalah jumlah periode menghabiskan di antrian ready.

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

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


Algoritma Penjadwalan

Penjadwalan CPU berurusan dengan permasalahan memutuskan proses mana yang akan dillaksanakan , oleh karena itu banyak bermacam algoritma penjadwalan, di seksi ini kita akan mendiskripsikan beberapa algoritma.


Penjadwalan Shortest Job First

Salah satu algoritma yang lain adalah Shortest Job First. ALgoritma ini berkaitan dengan waktu setiap proses . Ketika CPU bebas proses yang mempunyai waktu terpendek untuk menyelesaikannya mendapat prioritas. Seandainya dua proses atau lebih mempunyai waktu yang sama maka FCFS algoritma digunakan untuk menyelsaikan masalah tersebut.

Ada dua skema dalam SJFS ini yaitu :

  1. nonpremptive — ketika CPU memberikan kepada proses itu tidak bisa ditunda hingga selesai

  2. premptive — bila sebuah proses datang dengan waktu prose lebih rendah dibandingkan dengan waktu proses yang sedang dieksekusi ooleh CPU maka proses yang waktunya lebih rendah mendapatkan prioritas. Skema ini disebut juga Short -Remaining Time First (SRTF)

Contoh :

SJF algoritma mungkin adalah yang paling optimal, karena ia memberikan rata-rata minimum waiting untuk kumpulan dari proses yang mengantri. Dengan mengeksekusi waktu yang paling pendek baru yang paling lama. Akibatnya rata-rata waktu mnenuggu menurun.

Hal yang sulit dengan SJF algoritma adalah mengethaui waku dari proses berikutnya. Untuk penjadwalan long term (lama) di sistem batch, kita bisa menggunakan panjang batas waktu proses yang user sebutkan ketika dia mengirim pekerjaan. Oleh karena itu sjf sering digunakan di penjadwalan long term.

Walaupun sjf optimal tetapi ia tidak bisa digunakan untuk penjadwalan CPU short term. Tidak ada jalan untuk mengetahui panjang dari cpu burst berikutnya. Salah satu cara untuk mengimplementasikannya adalah dengan memprediksikan CPU burst berikutnya.

Contoh SJF premptive :

kita lihat bahwa dengan premptive lebih baik hasilnya daripada non preemptive


Penjadwalan Multiprocessor

Multiprocessor membutuhkan penjadwalan yang lebih rumit karena mempunyai banyak kemungkinan yang dicoba tidak seperti pada processor tunngal. Tapi saat ini kita hanya fokus pada processor yang homogen(sama) sesuai dengan fungsi masing- masing dari processor tersebut. Dan juga kita dapat menggunakan processor yang tersedia untuk menjalankan proses didalam antrian.


Penjadwalan Real Time

Dalam bab 1, kita berdiskusi tentang pertumbuhan yang penting dari sistem real time. Disini, kita akan mendeskripsikan fasilitas penjadwalan yang dibuttuhkan untuk mendukung real time computing dengan bantuan sistem komputer.

Real time computing ada 2 type. sistem Hard real time dibutuhkan untuk menyelesaikan critical task dengan jaminan waktu tertentu. Secara umum, sebuah proses di kirim dengan sebuah pernyataan jumlah waktu dimana dibutuhkan untuk menyelesaikan atau menjalankan I/O. Kemudian penjadwal bisa menjamin proses untuk selesai atau menolak permintaan karena tidak mungkin dilakukan. Karena itu setiap operasi harus dijamin dengan waktu maksimum.

Soft real time computing lebih tidak ketat. Itu membutuhkan bahwa proses yang kritis menerima prioritas dari yang lain. Walaupun menambah fungsi soft real time ke sistem time sharing mungkin akan mengakibatkan pembagian sumber yang tidak adildan mengakibatkan delay yang lebih lama, atau mungkin pembatalan bagi proses tertentu, Hasilnya adalah tujuan secara umum sistem yang bisa mendukung multimedia, graphic berkecepatan tinggi, dan variasi tugas yang tidak bisa diterima di lingkungan yang tidak mendukunng soft real time computing

Mengimplementasikan fungsi soft real time membutuhkan design yang hati-hati dan aspek yang berkaitan dengan sistem operasi. Pertama, sistem harus punya prioritas penjadwalan, dan proses real time harus tidak melampaui waktu, walaupun prioritas non real time bisa terjadi. Kedua, dispatch latency harus lebih kecil. Semakin kecil latency, semakin cepat real time proses mengeksekusi.

Untuk menjaga dispatch tetap rendah. Kita butuh agar system call untuk preemptible. Ada beberapa cara untuk mencapai tujuan ini. Satu untuk memasukkan preemption points di durasi yang lama system call, yang mana memeriksa apakah prioritas yang utama butuh untuk dieksekusi. Jika satu sudah, maka switch context mengambil alih; ketika high priority proses selesai, proses yang diinterupsi meneruskan dengan system call. Points premption bisa diganti hanya di lokasi yang aman di kernel — hanya kernel struktur tidak bisa dimodifikasi walaupun dengan preemption points, dispatch latency bisa besar, karena pada prakteknya untuk menambah beberapa preemption points untuk kernel.

Metoda yang lain untuk berurusan dengan preemption untuk membuat semua kernel preemptible. Karena operasi yang benar bisa dijamin, semua data kernel struktur dengan di proteksi. Dengan metode ini, kernel bisa selalu di preemptible, karena semua kernel bisa diupdate di proteksi .

Apa yang bisa diproteksi jika prioritas yang utama butuh untuk dibaca atau dimodifisikasi yang bisa dibutuhkan oleh yang lain, prioritas yang rendah ? . Prioritas yang tinggi harus menunggu menunggu untuk menyelesaikan prioritas yang rendah.

Fase konflik dari dispatch latency mempunyai dua komponen :

  1. Preemption semua proses yang berjalan di kernel.

  2. Lepas prioritas yang rendah untuk prioritas yang tinggi.


Java Thread dan Algoritmanya

Penjadwalan thread yang Runnable oleh Java Virtual Machine dilakukan dengan konsep preemptive dan mempunyai prioritas tertinggi. Dalam algoritma evaluasi ditentukan terlebih dahulu kriteria-kriterianya seperti utilisasinya dilihat dari segi waktu tunggu yang digunakan dan throughput yang disesuaikan dengan waktu turnaroundnya.


Penjadwalan Java Thread

Java Virtual Machine menjadwalkan thread menggunakan preemptive, berdasarkan prioritas algoritma penjadwalan. Semua Java Thread diberikan sebuah prioritas dan Java Virtual Machine menjadwalkan thread yang Runnable dengan menggunakan prioritas tertinggi saat eksekusi. Jika ada dua atau lebih thread yang Runnable yang mempunyai prioritas tertinggi, Java Virtual Machine akan menjadwalkan thread tersebut menggunakan sebuah antrian secara FIFO.


Penjadwalan Round-Robin dengan Java

	public class Scheduler extends Thread{
		public Scheduler(){
		timeSlice = DEFAULT_TIME_SLICE;
		queue = new Circularlist();
		}
		public Scheduler(int quantum){
		timeSlice = quantum;
		queue = new Circularlist();
		}
		public addThread(Thread t) {
		t.setPriority(2);
		queue.additem(t);
		}
		private void schedulerSleep() {
		try{
		Thread.sleep(timeSlice );
		} catch (InterruptedException e){};
		}
		public void run(){
		Thread current;
		This.setpriority(6);
		While (true) {
		// get the next thread
		current = (Thread)qeue.getnext();
		if ( (current != null) && (current.isAlive()) ){
		current.setPriority(4);
		schedulerSleep();
		current.setPriority(2)
		}
		}
	}

	private CircularList queue;
	private int timeSlice;
	private static final int DEFAULT_TIME_SLICE = 1000;
	}

		public class TesScheduler{
		public static void main()String args[]) {
		Thread.currentThread().setpriority(Thread.Max_Priority);
		Schedular CPUSchedular = new Scheduler ();
		CPUSchedular.start()
		TestThread t1 = new TestThread("Thread 1");
		t1.start()
		CpuSchedular.addThread(t1);
		TestThread t2 = new TestThread("Thread 2");
		t2.start()
		CpuSchedular.addThread(t2);
		TestThread t3 = new TestThread("Thread 1");
		t3.start()
		CpuSchedular.addThread(t3);
		}
	}
	

Evaluasi Algorithm

Bagaimana kita memilih sebuah algoritma penjadwalan CPU untuk sistem-sistem tertentu. Yang menjadi pokok masalah adalah kriteria seperti apa yang digunakan untuk memilih sebuah algoritma. Untuk memilih suatu algoritma, pertama yang harus kita lakukan adalah menentukan ukuran dari suatu kriteria berdasarkan :


Sinkronisasi dalam Java

Setiap objek dalam java mempunyai kunci yang unik yang tidak digunakan biasanya. Saat method dinyatakan sinkron, maka method dipanggil untuk mendapatkan kunci untuk objek tersebut. Saat kunci tersebut dipunyai thread yang lain maka thread tersebut diblok dan dimasukkan kedalam kumpulan kunci objek, misalnya :

	public synchronized void enter(Object item){
		while (count == BUFFER_SIZE)
		Thread.yeild();
		++count;
		buffer[in] = item;
		in = (in+1) % BUFFER_SIZE;
	}

	public synchronized void remove (){
		Object item;
		while (count == 0)
		Thread.yeild();
		--count;
		item = buffer[out]
		out = (out+1) % BUFFER_SIZE;
		return item
	}
	

Contoh Method Wait() dan Notify()

	public synchronized void enter(Object item){
		while (count == BUFFER_SIZE){
		try{
		wait();
	}

	catch (InterruptedException e) {}
	}

	// add an item to the buffer
	++count;
	buffer[in] = item;
	in = (in+1) % BUFFER_SIZE;
	notify();
	}

	public synchronized void remove(Object item){
		while (count == 0){
		try{
		wait();
	}
	catch (InterruptedException e) {}
	}
	// remove an item to the buffer
	--count;
	item = buffer[out];
	out = (out+1) % BUFFER_SIZE;
	notify();
	return item;
	}
	

Kesimpulan

Proses

Sebuah proses adalah sebuah peristiwa adanya sebuah proses yang dapat dieksekusi. Sebagai sebuah eksekusi proses, maka hal tersebut membutuhkan perubahan keadaan. Keadaan dari sebuah proses dapat didefinisikan oleh aktivitas proses tertentu tersebut. Setiap proses mungkin menjadi satu dari beberapa state berikut, antara lain : new, ready, running, waiting, atau terminated. Setiap proses direpresentasikan ada sistem operasi berdasarkan proses-control-block (PCB)-nya.

Sebuah proses, ketika sedang tidak dieksekusi, ditempatkan pada antrian yang sama. Disini ada 2 kelas besar dari antrian dalam sebuah sistem operasi : permintaan antrian I/O dan ready queue. Ready queue memuat semua proses yang siap untuk dieksekusi dan yang sedang menunggu untuk dijalankan pada CPU. Setiap proses direpresentasikan oleh sebuah PCB, dan PCB tersebut dapat digabungkan secara bersamaan untuk mencatat sebuah ready queue. Penjadwalan Long-term adalah pilihan dari proses - proses untuk diberi ijin menjalankan CPU. Normalnya, penjadwalan long-term memiliki pengaruh yang sangat besar bagi penempatan sumber, terutama manajemen memori. Penjadwalan Short-term adalah pilihan dari satu proses dari ready queue.

Proses - proses pada sistem dapat dieksekusi secara berkelanjutan. Disini ada beberapa alasan mengapa proses tersebut dapat dieksekusi secara berkelanjutan : pembagian informasi, penambahan kecepatan komputasi, modularitas, dan kenyamanan atau kemudahan. Eksekusi secara berkelanjutan menyediakan sebuah mekanisme bagi proses pembuatan dan penghapusan.

Pengeksekusian proses - proses pada operating system mungkin dapat digolongkan menjadi proses independent dan kooperasi. Proses kooperasi harus memiliki beberapa alat untuk mendukung komunikasi antara satu dengan yang lainnya. Prinsipnya adalah ada dua rencana komplementer komunikasi : pembagian memori dan sistem pesan. Metode pembagian memori menyediakan proses komunikasi untuk berbagi beberapa variabel. Proses - proses tersebut diharapkan dapat saling melakukan tukar - menukar informasi seputar pengguna variabel yang terbagi ini. Pada sistem pembagian memori, tanggung jawab bagi penyedia komunikasi terjadi dengan programmer aplikasi; sistem operasi harus menyediakan hanya pembagian memori saja. Metode sistem pesan mengijinkan proses - proses untuk tukar - menukar pesan. Tanggung jawab bagi penyedia komunikasi ini terjadi dengan sistem operasi tersebut.


Thread

Thread adalah sebuah alur kontrol dari sebuah proses. Suatu proses yang multithreaded mengandung beberapa perbedaan alur kontrol dengan ruang alamat yang sama. Keuntungan dari multithreaded meliputi peningkatan respon dari user, pembagian sumber daya proses, ekonomis, dan kemampuan untuk mengambil keuntungan dari arsitektur multiprosesor. User level thread adalah thread yang tampak oleh programmer dan tidak diketahui oleh kernel. User level thread secara tipikal dikelola oleh sebuah library thread di ruang user. Kernel level thread didukung dan dikelola oleh kernel sistem operasi. Secara umum, user level thread lebih cepat dalam pembuatan dan pengelolaan dari pada kernel thread. Ada 3 perbedaan tipe dari model yang berhubungan dengan user dan kernel thread.

Java adalah unik karena telah mendukung thread didalam tingkatan bahasanya. Semua program Java sedikitnya terdiri dari kontrol sebuah thread tunggal dan mempermudah membuat kontrol untuk multiple thread dengan program yang sama. JAVA juga menyediakan library berupa API untuk membuat thread, termasuk method untuk suspend dan resume suatu thread, agar thread tidur untuk jangka waktu tertentu dan menghentikan thread yang berjalan. Sebuah java thread juga mempunyai 4 kemungkinan keadaan, diantaranya: New, Runnable, Blocked dan Dead. Perbedaan API untuk mengelola thread seringkali mengganti keadaan thread itu sendiri.


Soal-soal Latihan

Proses

  1. sebutkan 5 aktivitas sistem operasi yang merupakan contoh dari suatu manajemen proses.

  2. Definisikan perbedaan antara penjadwalan short term, medium term dan long term.

  3. Jelaskan tindakan yang diambil oleh sebuah kernel ketika context switch antar proses.

  4. Informasi apa saja yang disimpan pada tabel proses saat context switch dari satu proses ke proses lain.

  5. Di sistem UNIX terdapat banyak status proses yang dapat timbul (transisi) akibat event (eksternal) OS dan proses tersebut itu sendiri. Transisi state apa sajakah yang dapat ditimbulkan oleh proses itu sendiri. Sebutkan!

  6. Apa keuntungan dan kekurangan dari :

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

  8. Jelaskan apa yang akan dilakukan oleh kernel kepada context switch ketika proses sedang berlangsung ?

  9. Beberapa single-user mikrokomputer sistem operasi seperti MS-DOS menyediakan sedikit atau tidak sama sekali arti dari pemrosesan yang konkuren. Diskusikan dampak yang paling mungkin ketika pemrosesan yang konkuren dimasukkan ke dalam suatu sistem operasi ?

  10. Perlihatkan semua kemungkinan keadaan dimana suatu proses dapat sedang berjalan, dan gambarkan diagram transisi keadaan yang menjelaskan bagaimana proses bergerak diantara state.

  11. Apakah suatu proses memberikan 'issue' ke suatu disk I/O ketika, proses tersebut dalam 'ready' state, jelaskan ?

  12. Kernel menjaga suatu rekaman untuk setiap proses, disebut Proses Control Blocks (PCB). Ketika suatu proses sedang tidak berjalan, PCB berisi informasi tentang perlunya melakukan restart suatu proses dalam CPU. Jelaskan 2 informasi yang harus dipunyai PCB.