Apa Itu Kecepatan Clock dan Process Control Block? Inilah Pengertian tentang Sinyal Clock, Manajemen Proses, dan Scheduling beserta dengan Implementasinya (+ Algoritma Penjadwalan dalam Bahasa C#)

Assalamu‘alaikum wr. wb.

Hello guys, Kembali lagi bersama Inzaghi's Blog! Biasanya jika kita mendengar istilah "Clock", pastinya yang terbenak dipikiran kita adalah "Jam", tapi bukan disitu saja. Memang sih artinya Jam, akan tetapi lebih ke Penjadwalan atau Scheduling. Juga, pada Postingan ini, saya akan membahas tentang Manajemen Proses pada Sistem Operasi termasuk Process Control Block (PCB). Untuk selengkapnya, silakan lihat pada Postingan ini.

KECEPATAN CLOCK PADA CPU

Sumber : Intel.co.id dan Nesabamedia.com

Performa CPU — “otak” dari PC Anda — berdampak besar pada kecepatan pemuatan program dan kelancaran pengoperasiannya. Namun, ada beberapa cara berbeda untuk mengukur performa prosesor. Kecepatan clok (juga disebut “laju clock” atau “frekuensi”) adalah salah satu yang paling signifikan.

Jika Anda ingin tahu cara memeriksa kecepatan clock, klik menu Start (atau klik tombol Windows*) lalu ketik “System Information”. Nama model dan kecepatan clock CPU Anda akan tercantum pada “Processor”.

Apa Itu Kecepatan Clock?

Secara umum, Kecepatan Clock atau Clock Speed lebih tinggi berarti CPU yang lebih cepat. Namun, banyak faktor lain yang turut berperan.

CPU Anda memproses banyak instruksi (kalkulasi tingkat rendah seperti aritmatika) dari berbagai program setiap detik. Kecepatan clock mengukur jumlah siklus yang dijalankan CPU per detik, yang diukur dalam GHz (gigahertz).

Secara teknis, “siklus” adalah pulsa yang disinkronkan oleh osilator internal, tetapi untuk keperluan ini, siklus adalah unit dasar yang membantu memahami kecepatan CPU. Selama setiap siklus, miliaran transistor di dalam prosesor membuka dan menutup.

Frekuensi dalam hal ini jumlah operasi dalam waktu yang ditetapkan, seperti ditunjukkan di atas.

CPU dengan kecepatan clock 3,2 GHz menjalankan 3,2 miliar siklus per detik. (CPU lama kecepatannya diukur dalam megahertz, atau juta siklus per detik.)

Terkadang, beberapa instruksi diselesaikan dalam satu siklus clock; dalam kasus lain, satu instruksi mungkin ditangani selama beberapa siklus clock. Karena desain CPU yang berbeda menangani instruksi secara berbeda, yang terbaik adalah membandingkan kecepatan clock dalam merek dan generasi CPU yang sama.

Misalnya, CPU dengan kecepatan clock lebih tinggi dari lima tahun yang lalu mungkin diungguli oleh CPU baru dengan kecepatan clock lebih rendah, karena arsitektur baru memroses instruksi secara lebih efisien. Prosesor Intel® Seri X mungkin mengungguli prosesor seri K dengan kecepatan clock lebih tinggi, karena membagi tugas antara lebih banyak core dan dilengkapi dengan cache CPU lebih besar. Tetapi dalam generasi CPU yang sama, prosesor dengan kecepatan clock lebih tinggi umumnya akan mengungguli prosesor dengan kecepatan lebih rendah pada banyak aplikasi. Karena itulah penting untuk membandingkan prosesor dari merek dan generasi yang sama.

Mengapa Kecepatan Clock Penting?

Kecepatan clock CPU adalah indikator yang baik mengenai performa prosesor. Meskipun aplikasi seperti pengeditan video dan streaming dikenal mengandalkan performa multi-core, banyak game video baru masih meraih tolok ukur terbaik pada CPU dengan kecepatan clock tertinggi.

Clock Speed Lebih Tinggi Belum Tentu Lebih Baik

CPU yang memiliki clock speed lebih rendah belum tentu kecepatannya dalam memproses data lebih buruk daripada CPU dengan clock speed yang lebih tinggi.

Pasalnya, selain jumlah siklus per detik, yang juga perlu diperhatikan adalah seberapa banyak instruksi yang bisa dieksekusi oleh sebuah prosesor dalam setiap siklus. Hal ini terkait dengan efisiensi prosesor dalam menangani instruksi.

Clock speed yang lebih rendah tapi setiap siklusnya mampu mengeksekusi lebih banyak instruksi justru lebih bagus. Mengapa demikian? Karena jumlah siklusnya lebih sedikit, maka tenaga yang dibutuhkan prosesor untuk menjalankan tugasnya pun juga ikut berkurang. Prosesor pun lebih hemat daya dan tidak mudah panas.

Clock Speed Disesuaikan Secara Otomatis

Makin tinggi clock speed, makin besar daya listrik yang dibutuhkan, dan makin tinggi panas yang dihasilkan. Untungnya, CPU modern sudah menggunakan algoritma pintar yang mampu menyesuaikan clock speed secara otomatis sehingga CPU tidak terus-menerus bekerja pada kecepatan tinggi.

Ketika komputer hanya digunakan untuk keperluan ringan seperti menulis artikel di Wordpad, CPU bekerja pada kecepatan rendah untuk mencegah panas dan mengurangi konsumsi daya listrik. Ketika komputer digunakan untuk bermain game, clock speed akan naik dengan sendirinya untuk memenuhi kebutuhan resource gaming yang besar.

Clock Speed Bukan Segalanya

Clock speed merupakan indikator yang signifikan dalam menilai kecepatan sebuah komputer, tapi masih ada beberapa faktor lain yang perlu diperhatikan seperti jumlah core CPU, memori cache CPU, mekanisme pendinginan CPU, arsitektur CPU, kapasitas RAM, SSD atau HDD, dan graphics card. Sebuah komputer yang memiliki CPU dengan clock speed lebih rendah tapi menggunakan SSD bisa saja lebih cepat daripada komputer yang memiliki CPU lebih baik tapi menggunakan HDD.

APA ITU PROCESS CONTROL BLOCK (PCB)? BESERTA DENGAN MANAJEMEN PROSES LAINNYA

Sumber : Nesabamedia.com, Pinkysoshi.wordpress.com, dan Panduanilkom.blogspot.com

1. Process Control Block (PCB)

Setiap proses yang ada di dalam Sistem Operasi memperoleh sebuah PCB atau Process Control Block, PCB ini di dalamnya berisi informasi seputar proses tersebut yakni berupa sebuah tanda pengenal atau ID Process yang nantinya akan digunakan sebagai nomor identitas, prioritas eksekusi, status proses, serta tentang informasi tentang lokasi dari proses di dalam sebuah memori.

Sementara itu, Process Control Block merupakan berbagai informasi lain yang diperlukan Sistem Operasi untuk mengontrol dan berkoordinasi dengan berbagai proses yang aktif.

Hampir seluruh Sistem Operasi modern seperti yang Anda gunakan sekarang sudah memilki Process Control Block. Akan tetapi, strukturnya masih berbeda-beda di setiap Sistem Operasi tersebut. Maka dari itu, PCB memiliki sifat unik karena antara Sistem Operasi yang satu dengan yang lainnya berbeda.

Adapun prioritas proses adalah sebuah besaran atau nilai yang memberikan informasi mengenai seberapa sering proses tersebut dijalankan prosesor. Proses yang mempunyai prioritas tinggi nanti dijalankan lebih sering serta dieksekusi terlebih dahulu jika dibandingkan dengan proses yang memiliki prioritas lebih rendah.

Setiap proses yang ada di dalam Sistem Operasi akan digambarkan oleh Process Control Block. Di dalam PCB terdapat banyak informasi yang saling berhubungan dengan proses yang lebih spesifik.

Process Control Block hanya bertugas untuk menyimpan informasi yang mana antara proses satu dengan proses lainnya akan bervariasi. Salah satu contoh struktur data yang mengontrol beberapa Process Control Block misalnya process table.

Di bawah ini merupakan elemen-elemen yang terdapat pada PCB Running :

• Identifier : Elemen ini digunakan untuk mengidentifikasi dan membedakan antara satu proses dengan proses yang lainnya
• State : Status dari proses  yang sedang dieksekusi, diblok, dan lain-lain
• Priority : Status dari proses  yang sedang dieksekusi, diblok, dan lain-lain priority
• Program Counter : Alamat berikutnya akan dieksekusi
• Memory Pointers :  Pointer yang nantinya akan menunjukkan alamat memori data dan kode yang saling berhubungan dengan blok dan memori yang dibagikan dengan proses yang lainnya (jika ada)
• Context data : Data yang ada di dalam register prosesor pada saat proses akan diseksekusi
• I/O status Information : Informasi yang berkaitan dengan permintaan mengenai I/O device yang masih belum terpenuhi (misalnya akses ke harddisk), apa saja daftar file yang digunakan oleh proses, dan lain sebagainya
• Accounting Information : Informasi seputar total waktu proses yang sudah digunakan, batas waktu proses, nomor urutan, dan lain sebagainya

Pembagian Process Control Block

Process Control Block dibagi menjadi 3 (Tiga) Kelompok, yaitu :

• Process identification data : Proses yang menyertakan identifier pada prosesnya
• Process state data : Potongan-potongan informasi yang isinya menjelaskan status proses yang ditangguhkan, memungkinkan Sistem Operasi melakukan restart serta masih bisa mengeksekusinya dengan benar
• Process control data : Digunakan Sistem Operasi yang akan mengelola proses itu sendiri

2. Status Proses (Process Status)

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

Tiga status utama yaitu :

• Running : Status yang dimiliki pada saat instruksi-instruksi dari sebuah proses dieksekusi.
• Waiting : Status yang dimiliki pada saat proses menunggu suatu event (contohnya: proses I/O).
• Ready : Status yang dimiliki pada saat proses siap untuk dieksekusi oleh prosesor.

Dua status tambahan, yaitu saat pembentukan dan terminasi :

• New : Status yang dimiliki pada saat proses baru saja dibuat.
• Terminated : Status yang dimiliki pada saat proses telah selesai dieksekusi.

3. Pembuatan Proses

Suatu proses dapat membuat beberapa proses baru, melalui sistem pemanggilan pembuatan proses, selama jalur eksekusi. Pembuatan proses dinamakan induk proses, jika dibuat proses dari proses induk disebut anak dari proses tersbut. Tiap proses baru tersebut dapat membuat proses lainnya, membentuk suatu pohon proses.

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 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 terlalu banyak subproses. Sistem Operasi dalam mengelola proses dapat melakukan operasi-operasi terhadap proses. Operasi tersebut adalah :

• Penciptaan proses
• Penghancuran/terminasi proses
• Penundaan proses
• Pelanjutan kembali proses
• Pengubahan prioritas proses
• Memblok proses
• Membangunkan proses
• Menjadwalkan proses
• Memungkinkan proses berkomunikasi dengan proses lain

Ketika proses baru ditambahkan, sistem operasi membangun struktur data untuk mengelola dan mengalokasikan ruang alamat proses. Pembuatan Proses Melibatkan banyak aktivitas, yaitu :

• Memberi identitas proses
• Menyisipkan proses pada tabel proses
• Menentukan prioritas awal proses
• Menciptakan PCB
• Mengalokasikan sumber daya awal bagi proses

4. 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 (keluaran) 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 proses induk melakukan terminasi sengaja pada turunannya. Alasan terminasi tersebut seperti :

• Turunan melampaui penggunaan sumber-daya yang telah dialokasikan. Dalam keadaan ini, proses induk perlu mempunyai mekanisme untuk memeriksa status turunannya-nya.
• Task yang ditugaskan kepada turunan tidak lagi diperlukan.
• Proses induk selesai, dan sistem operasi tidak mengizinkan proses turunan untuk tetap berjalan. Jadi, semua proses turunan akan berakhir pula. Hal ini yang disebut cascading termination.
• Proses memerlukan memori lebih banyak daripada yang dapat disediakan sistem.
• Proses berusaha menggunakan sumber data atau file yang tidak diijinkan dipakainya, atau proses mencoba menggunakannya tidak untuk peruntukannya, seperti menulis file read only.
• Proses memcoba perhitungan terlarang, seperti pembagian dengan nol,atau mencoba menyimpan angka yang lebih besar daripada yang dapat diakomodasi oleh perangkat keras
• Kesalahan muncul pada masukan/keluaran, seperti ketidakmampuan menemukan file, kegagalan membaca atau menulis setelah sejumlah maksimum percobaan yang ditentukan.

Penghancuran proses melibatkan pembebasan proses dari sistem, yaitu :

• Sumber daya-sumber daya yang dipakai dikembalikan.
• Proses dihancurkan dari tabel sistem.
• PCB dihapus (ruang memori PCB dikembalikan ke pool memori bebas).

5. Terminasi Proses

1. Sistem Berbagi Memori

Berbagi Memori atau yang disebut juga sebagai Shared Memory System merupakan salah satu cara komunikasi antar proses dengan cara mengalokasikan suatu alamat memori untuk dipakai berkomunikasi antar proses. Alamat dan besar alokasi memori yang digunakan biasanya ditentukan oleh pembuat program. Pada metode ini, sistem akan mengatur proses mana yang akan memakai memori pada waktu tertentu sehingga pekerjaan dapat dilakukan secara efektif.

2. Sistem Berkirim Pesan

Suatu proses dikatakan independen apabila proses tersebut tidak dapat terpengaruh atau dipengaruhi oleh proses lain yang sedang dijalankan pada sistem. Berarti, semua proses yang tidak membagi data apa pun (baik sementara/tetap) dengan proses lain adalah independent. Sedangkan proses kooperatif adalah proses yang dapat dipengaruhi atau pun terpengaruhi oleh proses lain yang sedang dijalankan dalam sistem. Dengan kata lain, proses dikatakan kooperatif bila proses dapat membagi datanya dengan proses lain. Ada empat 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 mengizinkan 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 paralel.

Proses ini menyediakan dua operasi yaitu mengirim pesan dan menerima pesan. Ketika dua bagian sistem ingin berkomunikasi satu sama lain, yang harus dilakukan pertama kali adalah membuat sebuah link komunikasi antara keduanya. Setelah itu, kedua bagian itu dapat saling bertukar pesan melalui link komunikasi tersebut. Terdapat dua macam cara berkomunikasi, yaitu :

• Komunikasi langsung. Dalam komunikasi langsung, setiap proses yang ingin berkirim pesan harus mengetahui secara jelas dengan siapa mereka berkirim pesan. Hal ini dapat mencegah pesan salah terkirim ke proses yang lain. Karakteristiknya antara lain:
• Link dapat otomatis dibuat
• Sebuah link berhubungan dengan tepat satu proses komunikasi berpasangan
• Diantara pasangan itu terdapat tepat satu link
• Link tersebut biasanya merupakan link komunikasi dua arah
• Komunikasi tidak langsung. Berbeda dengan komunikasi langsung, jenis komunikasi ini menggunakan sejenis kotak surat atau port yang mempunyai ID unik untuk menerima pesan. Proses dapat berhubungan satu sama lain jika mereka membagi port mereka. Karakteristik komunikasi ini antara lain:
• Link hanya terbentuk jika beberapa proses membagi kotak surat mereka
• Sebuah link dapat terhubung dengan banyak proses
• Setiap pasang proses dapat membagi beberapa link komunikasi
• Link yang ada dapat merupakan link terarah ataupun link yang tidak terarah.

3.  Komunikasi Proses Dalam Sistem

Sistem operasi menyediakan alat-alat proses kooperatif untuk berkomunikasi dengan yang lain lewat sebuah komunikasi dalam proses (IPC = Inter-Process Communication). IPC menyediakan sebuah mekanisme untuk mengizinkan prosesproses 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 system – sistem pesan dapat diberikan dalam banyak cara.

6. Sinkronisasi

Komunikasi antara proses membutuhkan subroutine untuk mengirim dan menerima data primitif. Terdapat desain yang berbeda-beda dalam implementasi setiap primitif. Pengiriman pesan mungkin dapat diblok (blocking) atau tidak dapat dibloking (nonblocking) – juga dikenal dengan nama sinkron atau asinkron.

Ketika dalam keadaan sinkron, terjadi dua kejadian :

• Blocking send. Pemblokiran pengirim sampai pesan sebelumnya diterima.
• Blocking receive. Pemblokiran penerima sampai terdapat pesan yang akan dikirim.

Sedangkan untuk keadaan asinkron, yang terjadi adalah :

• Non-blocking send. Pengirim dapat terus mengirim pesan tanpa memperdulikan apakah pesan sebelumnya sampai atau tidak.
• Non-blocking receive. Penerima menerima semua pesan baik berupa pesan yang valid atau pesan yang salah (null).

7. Penundaan (Suspend)

Penundaan (Suspend) adalah operasi penting dan telah diterapkan dengan beragam cara. Penundaan biasanya berlangsung singkat. Penundaan sering dilakukan sistem untuk memindahkan proses-proses tertentu guna mereduksi beban sistem selama beban puncak.

Proses yang ditunda (suspended blocked) tidak berlanjut sampai proses lain meresume. Untuk jangka panjang, sumber daya-sumber daya proses dibebaskan. Keputusan membebaskan sumber daya-sumber daya bergantung sifat masing-masing sumber daya. Memori utama seharusnya segera dibebaskan begitu proses tertunda agar dapat dimanfaatkan proses lain. Resuming (pengaktifan kembali) proses, yaitu menjalankan proses dari titik (instruksi) dimana proses ditunda. Operasi suspend dan resume penting, sebab :

• Jika sistem berfungsi secara buruk dan mungkin gagal maka proses-proses dapat disuspend agar diresume setelah masalah diselesaikan. Contoh : Pada proses , bila tiba-tiba kerta habis maka proses disuspend. Setelah kertas dimasukkan kembali, proses pun dapat diresume.
• Pemakai yang ragu/khawatir mengenai hasil prose dapat mensuspend proses (bukan membuang (abort) proses). Saat pemakai yakin proses akan berfungsi secara benar maka dapat me-resume (melanjutkan kembali di instruksi saat disuspend) proses yang disuspend.
• Sebagai tanggapan terhadap fluktuasi jangka pendek beban sistem, beberapa proses dapat disuspend dan diresume saat beban kembali ke tingkat normal.

8. Buffering

Dalam setiap jenis komunikasi, baik langsung atau tidak langsung, penukaran pesan oleh proses memerlukan antrian sementara. Pada dasarnya, terdapat tiga cara untuk mengimplementasikan antrian tersebut :

• Kapasitas Nol. Antrian mempunyai panjang maksimum nol, sehingga tidak ada penungguan pesan (message waiting). Dalam kasus ini, pengirim harus memblok sampai penerima menerima pesan.
• Kapasitas Terbatas. Antrian mempunyai panjang yang telah ditentukan, paling banyak n pesan dapat dimasukkan. Jika antrian tidak penuh ketika pesan dikirimkan, pesan yang baru akan menimpa, dan pengirim pengirim dapat melanjutkan eksekusi tanpa menunggu. Link mempunyai kapasitas terbatas. Jika link penuh, pengirim harus memblok sampai terdapat ruang pada antrian.
• Kapasitas Tak Terbatas. Antrian mempunyai panjang yang tak terhingga, sehingga semua pesan dapat menunggu disini. Pengirim tidak akan pernah di blok.

PENGERTIAN DAN JENIS-JENIS ALGORITMA PENJADWALAN (SCHEDULING ALGORITHM)

Sumber : Studentterpelajar.com, Tutorinformasi.blogspot.com, dan Desainerblog.wordpress.com

A. Pengertian dan Jenis-jenis Algoritma Penjadwalan

Proses memerlukan prosesor dan penjadwalan pemakaian prosesor. Berdasarkan berbagai ketentuan pada penjadwalan proses serentak, dapat disusun teknik penjadwalan prosesor. Dapat dipandang semua proses serentak itu sebagai satu kumpulan proses yang memerlukan prosesor Penjadwalan proses didasarkan pada Sistem Operasi yang menggunakan prinsip multiprogramming. Dengan cara mengalihkan kerja CPU untuk beberapa proses, maka CPU akan semakin produktif. Algoritma diperlukan untuk mengatur giliran proses-proses yang ada di ready queue yang mengantre untuk dialokasikan ke CPU. Beberapa Algoritma penjadwalan dijelaskan sebagai berikut : 

1. First Come First Served (FCFS) Scheduling 

FCFS merupakan algoritma penjadwalan yang paling sederhana yang digunakan dalam CPU. Dengan menggunakan algoritma ini setiap proses yang berada pada status ready dimasukkan kedalam FIFO queue atau antrian dengan prinsip first in first out, sesuai dengan waktu kedatangannya. Proses yang tiba terlebih dahulu yang akan dieksekusi. Kelemahan dari Algoritma ini : 

• Waiting time rata-ratanya cukup lama
• Terjadinya convoy effect, yaitu proses-proses menunggu lama untuk menunggu 1 proses besar yang sedang dieksekusi oleh CPU. Algoritma ini juga menerapkan konsep non-preemptive, yaitu setiap proses yang sedang dieksekusi oleh CPU tidak dapat di-interrupt oleh proses yang lain

Pada Algoritma ini, maka proses yang pertama kali meminta jatah waktu untuk menggunakan CPU akan dilayani terlebih dahulu. Pada skema ini, proses yang meminta CPU pertama kali akan dialokasikan ke CPU pertama kali. Misalnya terdapat tiga proses yang dapat dengan urutan P1, P2, dan P3 dengan waktu CPU-burst dalam milidetik yang diberikan sebagai berikut :

Gant chart dengan penjadwalan FCFS dapat digambarkan sebagai berikut :

Waktu tunggu untuk P1 adalah 0, P2 adalah 24 dan P3 adalah 27 sehingga rata - rata waktu tunggu adalah (0+24+27)/3 = 17 milidetik.

Apabila urutannya P2, P3 dan P1 dengan waktu CPU-burst dalam milidetik yang diberikan sebagai berikut :

Maka Gant chart-nya dengan penjadwalan FCFS digambarkan sebagai berikut :

Waktu tunggu untuk P1 adalah 6, P2 adalah 0 dan P3 adalah 3 sehingga ratarata waktu tunggu adalah (6+0+3)/3 = 3 milidetik. Rata-rata waktu untuk kasus ini jauh lebih baik jika dibandingkan dengan kasus sebelumnya.

Algoritma FCFS termasuk non-preemptive, karena sekali CPU dialokasikan pada suatu proses, maka proses tersebut tetap akan memakai CPU sampai proses tersebut melepaskannya (berhenti atau meminta I/O).

2. Shortest Job First (SJF) Scheduling

Pada Algoritma ini setiap proses yang ada di ready queue akan dieksekusi berdasarkan burst time terkecil. Hal ini mengakibatkan waiting time yang pendek untuk setiap proses dan karena hal tersebut maka waiting time rata-ratanya juga menjadi pendek. Ada beberapa kekurangan dari Algoritma ini yaitu : 

• Susahnya untuk memprediksi burst time proses yang akan dieksekusi selanjutnya. 
• Proses yang mempunyai burst time yang besar akan memiliki waiting time yang besar pula SJF (Shortest Job First) karena yang dieksekusi terlebih dahulu adalah proses dengan burst time yang lebih kecil.

Algoritma ini dapat dibagi menjadi dua bagian yaitu : 

• Preemptive. Jika ada proses yang sedang dieksekusi oleh CPU dan terdapat proses di ready queue dengan burst time yang lebih kecil daripada proses yang sedang dieksekusi tersebut, maka proses yang sedang dieksekusi oleh CPU akan digantikan oleh proses yang berada di ready queue tersebut. Preemptive SJF sering disebut juga Shortest-Remaining-Time-First scheduling. 
• Non-preemptive. CPU tidak memperbolehkan proses yang ada di ready queue untuk menggeser proses yang sedang dieksekusi oleh CPU meskipun proses yang baru tersebut mempunyai burst time yang lebih kecil. 

Contoh dari SJF Scheduling :

a. Non Preemptive

    1.) Waktu kedatangan sama

 

    2.) Waktu kedatangan tidak sama

 

b. Preemptive

 

3. Priority Scheduling 

Priority Scheduling merupakan Algoritma penjadwalan yang mendahulukan proses yang memiliki prioritas tertinggi. Setiap proses memiliki prioritasnya masing-masing. Prioritas suatu proses dapat ditentukan melalui beberapa karakteristik antara lain : 

1. Time limit. 
2. Memory requirement. 
3. Akses file. 
4. Perbandingan antara I/O burst dengan CPU burst. 
5. Tingkat kepentingan proses. 

Pada Algoritma ini terdapat 2 (Dua) macam penjadwalan, yaitu :

1. Preemptive. Jika ada suatu proses yang baru datang memiliki prioritas yang lebih tinggi daripada proses yang sedang dijalankan, maka proses yang sedang berjalan tersebut dihentikan, lalu CPU dialihkan untuk proses yang baru datang tersebut. 
2. Nonpreemtive. Proses yang baru datang tidak dapat menganggu proses yang sedang berjalan, tetapi hanya diletakkan di depan queue. 

Kelemahan pada priority scheduling adalah dapat terjadinya indefinite blocking (starvation). Solusi dari permasalahan ini adalah aging, yaitu meningkatkan prioritas dari setiap proses yang menunggu dalam queue secara bertahap. 

Contoh dari Priority Scheduling :

 

4. Round Robin Scheduling 

Algoritma ini menggilir proses yang ada di antrian. Setiap proses mendapat jatah sebesar time quantum. Jika time quantum-nya habis atau proses sudah selesai, CPU akan dialokasikan ke proses berikutnya. Semua proses mendapat jatah waktu yang sama dari CPU yaitu (1/n), dan tak akan menunggu lebih lama dari (n-1)q dengan q adalah lama 1 quantum. Jika q terlalu besar maka akan sama dengan algoritma FCFS. Jika terlalu kecil, akan semakin banyak peralihan proses sehingga banyak waktu terbuang.

Dengan waktu quantum (quantum time) untuk membatasi waktu proses, biasanya 1-100 milidetik. Setelah waktu habis, proses ditunda dan ditambahkan pada ready queue. Jika suatu proses memiliki CPU burst lebih kecil dibandingkan dengan waktu quantum, maka proses tersebut akan melepaskan CPU jika telah selesai bekerja, sehingga CPU dapat segera digunakan oleh proses selanjutnya. Sebaliknya, jika suatu proses memiliki CPU burst yang lebih besar dibandingkan dengan waktu quantum, maka proses tersebut akan dihentikan sementara jika sudah mencapai waktu quantum, dan selanjutnya mengantri kembali pada posisi ekor dari ready queue, CPU kemudian menjalankan proses berikutnya. Jika terdapat n proses pada ready queue dan waktu quantum q, maka setiap proses mendapatkan 1/n dari waktu CPU paling banyak q unit waktu pada sekali penjadwalan CPU. Tidak ada proses yang menunggu lebih dari (n-1)q unit waktu. Performansi algoritma round robin dapat dijelaskan sebagai berikut, jika q besar, maka yang digunakan adalah algoritma FIFO, tetapi jika q kecil maka sering terjadi context switch. Misalkan ada 3 proses: P1, P2, dan P3 yang meminta pelayanan CPU dengan quantum-time sebesar 4 milidetik, maka dapat digambarkan sebagai berikut :

Maka Gant chart-nya dapat digambarkan sebagai berikut :

Waktu tunggu untuk P1 adalah 6, P2 adalah 4, dan P3 adalah 7 sehingga rata- rata waktu tunggu adalah (6 + 4 + 7)/3 = 5.66 milidetik. 

Algoritma Round-Robin ini di satu sisi memiliki keuntungan, yaitu adanya keseragaman waktu. Namun di sisi lain, algoritma ini akan terlalu sering melakukan switching. Semakin besar quantum-timenya maka switching yang terjadi akan semakin sedikit.

Pada multiprogramming, selalu akan terjadi beberapa proses berjalan dalam suatu waktu. Sedangkan pada uniprogramming hal ini tidak akan terjadi, karena hanya ada satu proses yang berjalan pada saat tertentu. Konsep dasar dari multiprogramming ini adalah: suatu proses akan menggunakan CPU sampai proses tersebut dalam status wait (misalnya meminta I/O) atau selesai. Pada saat wait , maka CPU akan nganggur (idle). Untuk mengatasi hal ini, maka CPU dialihkan ke proses lain pada saat suatu proses sedang dalam wait, demikian seterusnya. 

B. Implementasi dalam Bahasa C#

Berikut, inilah Contoh-contoh Implementasi Program Penjadwalan Clock dalam Bahasa C#.

1. Sinyal Clock

Kita akan membuat Algoritma Penjadwalan Sinyal Clock dengan menggunakan Sinyal Clock. Pertama kita buat terlebih dahulu programnya dalam Bahasa C#.

using System;
using System.IO.Ports;
using System.Threading;
namespace ConsoleApp2
{
    class Program
    {
        static bool jobIsEnabledA = true;
        static bool jobIsEnabledB = true;
        static bool jobIsEnabledC = true;
        static void Main(string[] args)
        {
            Console.WriteLine("Starting at: {0}", DateTime.Now.ToString("h:mm:ss"));
            while (true)
            {
                var currentTime = DateTime.Now.Second;
                if (currentTime % 2 == 0 && jobIsEnabledA)
                {
                    jobIsEnabledA = false;
                    ThreadPool.QueueUserWorkItem((state) => { Console.WriteLine(string.Format("Pertama! {0}", currentTime)); });
                }
                if (currentTime % 3 == 0 && jobIsEnabledB)
                {
                    jobIsEnabledB = false;
                    ThreadPool.QueueUserWorkItem((state) => { Console.WriteLine(string.Format("Kedua! {0}", currentTime)); });
                }
                if (currentTime % 5 == 0 && jobIsEnabledC)
                {
                    jobIsEnabledC = false;
                    ThreadPool.QueueUserWorkItem((state) => { Console.WriteLine(string.Format("Ketiga! {0}", currentTime)); });
                }
                if (currentTime == 30)
                {
                    jobIsEnabledA = true;
                    jobIsEnabledB = true;
                    jobIsEnabledC = true;
                }
                var logText = string.Format("{0} jobIsEnabledA: {1} jobIsEnabledB: {2} jobIsEnabledC: {3}",
                    DateTime.Now.ToString("h:mm:ss"), jobIsEnabledA, jobIsEnabledB, jobIsEnabledC);
                Console.WriteLine(logText);
                Thread.Sleep(1000);
            }
        }
        static void Task1()
        {
            while (jobIsEnabledA)
            {
                var currentTime = DateTime.Now.Second;
                Console.WriteLine(string.Format("Pertama: {0}", currentTime));
                Thread.Sleep(1000);
            }
        }
    }
}

Lalu, inilah hasilnya :

Setelah kita jalankan program tersebut, maka akan jalan terus tanpa henti kecuali jika kita keluarkan program tersebut. Mengapa demimkian? Mari kita bahas penjelasannya di bawah.

PENJELASAN :

Pertama dari QueueUserWorkItem lalu kita lanjut ke sebuah tread yang bernama ThreadPool. Kemudian dibagi-bagi lagi tugasnya menjadi 3 bagian yaitu jobIsEnabledA, jobIsEnabledB, dan jobIsEnabledC. Saat kita menjalankan program tersebut, maka akan mengikuti sesuai dengan format jam yang ada di komputer. Untuk currentTime % 2 == 0 && jobIsEnabledA merepresentasikan jumlah detik dengan kelipatan 2, kemudian currentTime % 3 == 0 && jobIsEnabledB merepresentasikan jumlah detik dengan kelipatan 3, dan currentTime % 5 == 0 && jobIsEnabledC merepresentasikan jumlah detik dengan kelipatan 5. Dan semuanya hasilnya adalah false. Akan tetapi jika currentTime == 30 maka semua variabel jobsEnabled -nya akan mejadi true. Dan jika sudah mendekati nilai akhir, maka akan menjadi true dan mengulang dari awal lagi. Dan juga Thread.Sleep(1000) merespresentasikan jumlah milidetik, jika 1000 maka menjadi 1 detik.

2. Scheduling Implementation Interface Program

Pertama, kita buat terlebih dahulu programnya dalam Bahasa C# (Sebagai Back-end), dan kodenya ada dibawah ini dengan Nama File MainWindowViewModel.cs pada Folder Arkom\SchedulingSimulation\WpfApp1\WpfApp1.

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Linq;
using System.Runtime.CompilerServices;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
namespace WpfApp1
{
    public class MainWindowViewModel : INotifyPropertyChanged
    {
        public event PropertyChangedEventHandler PropertyChanged;
        private int _valueSlider1;
        public int ValueSlider1 { get { return _valueSlider1; } set { _valueSlider1 = value; OnPropertyChanged(); } }
        private int _valueSlider2;
        public int ValueSlider2 { get { return _valueSlider2; } set { _valueSlider2 = value; OnPropertyChanged(); } }
        private int _valueSlider3;
        public int ValueSlider3 { get { return _valueSlider3; } set { _valueSlider3 = value; OnPropertyChanged(); } }
        private int _valueSlider4;
        public int ValueSlider4 { get { return _valueSlider4; } set { _valueSlider4 = value; OnPropertyChanged(); } }

        private string _info1;
        public string Info1 { get { return _info1; } set {  _info1 = value; OnPropertyChanged(); } }
        private string _info2;
        public string Info2 { get { return _info2; } set { _info2 = value; OnPropertyChanged(); } }
        private string _info3;
        public string Info3 { get { return _info3; } set { _info3 = value; OnPropertyChanged(); } }
        private string _info4;
        public string Info4 { get { return _info4; } set { _info4 = value; OnPropertyChanged(); } }
        private string _infoAll;
        public string InfoAll { get { return _infoAll; } set { _infoAll = value; OnPropertyChanged(); } }
        public void Run()
        {
            Task.Run(() => Task1());
            Task.Run(() => Task2());
            Task.Run(() => Task3());
            Task.Run(() => Task4());
            Thread.Sleep(250);
        }
        public void Task1()
        {
            while (true)
            {
                int milS = DateTime.Now.Millisecond;
                if (milS % 2 == 0)
                {
                    Info1 = DateTime.Now.ToString("hh:mm:ss ffff");
                    ValueSlider1 = milS;
                }
                Thread.Sleep(1);
            }
        }
        public void Task2()
        {
            while (true)
            {
                int milS = DateTime.Now.Millisecond;
                if (milS % 3 == 0)
                {
                    Info2 = DateTime.Now.ToString("hh:mm:ss ffff");
                    ValueSlider2 = milS;
                }
                Thread.Sleep(1);
            }
        }
        public void Task3()
        {
            while (true)
            {
                int milS = DateTime.Now.Millisecond;
                if (milS % 4 == 0)
                {
                    Info3 = DateTime.Now.ToString("hh:mm:ss ffff");
                    ValueSlider3 = milS;
                }
                Thread.Sleep(1);
            }
        }
        public void Task4()
        {
            while (true)
            {
                int milS = DateTime.Now.Millisecond;
                if (milS % 5 == 0)
                {
                    Info4 = DateTime.Now.ToString("hh:mm:ss ffff");
                    ValueSlider4 = milS;
                }
                Thread.Sleep(1);
            }
        }
        protected void OnPropertyChanged([CallerMemberName] string name = null)
        {
            PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(name));
        }
    }
}

Lalu kita juga buat kode lain dalam Bahasa XAML (Sebagai Front-end) agar dapat membuat Interface/Antarmuka tersebut Nama File MainWindow.xaml pada Folder Arkom\SchedulingSimulation\WpfApp1\WpfApp1.

<Window x:Class="WpfApp1.MainWindow"
        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
        xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
        xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
        xmlns:local="clr-namespace:WpfApp1"
        mc:Ignorable="d"
        Background="LightGreen"
        Title="MainWindow" Height="500" Width="500">
    <Grid>
        <Grid.Resources >
            <Style TargetType="StackPanel" >
                <Setter Property="Margin" Value="40" />
            </Style>
            <Style TargetType="TextBlock" >
                <Setter Property="FontSize" Value="25" />
            </Style>
        </Grid.Resources>
        <Grid.ColumnDefinitions>
            <ColumnDefinition></ColumnDefinition>
            <ColumnDefinition></ColumnDefinition>
        </Grid.ColumnDefinitions>
        <Grid.RowDefinitions>
            <RowDefinition></RowDefinition>
            <RowDefinition></RowDefinition>
            <RowDefinition></RowDefinition>
        </Grid.RowDefinitions>
        <StackPanel Grid.Row="0" Grid.Column="0">
            <TextBlock Text="{Binding Info1}"></TextBlock>
            <Slider Value="{Binding ValueSlider1}" Maximum="1000" TickPlacement="BottomRight" TickFrequency="1000" />
        </StackPanel>
        <StackPanel Grid.Row="0" Grid.Column="1">
            <TextBlock Text="{Binding Info2}"></TextBlock>
            <Slider Value="{Binding ValueSlider2}" Maximum="1000" TickPlacement="BottomRight" TickFrequency="1000" />
        </StackPanel>
        <StackPanel Grid.Row="1" Grid.Column="0">
            <TextBlock Text="{Binding Info3}"></TextBlock>
            <Slider Value="{Binding ValueSlider3}" Maximum="1000" TickPlacement="BottomRight" TickFrequency="1000" />
        </StackPanel>
        <StackPanel Grid.Row="1" Grid.Column="1">
            <TextBlock Text="{Binding Info4}"></TextBlock>
            <Slider Value="{Binding ValueSlider4}" Maximum="1000" TickPlacement="BottomRight" TickFrequency="1000" />
        </StackPanel>
        <StackPanel Grid.Row="2" Grid.Column="0" Grid.ColumnSpan="2">
            <TextBlock Text="{Binding InfoAll}"></TextBlock>
        </StackPanel>
    </Grid>
</Window>

Kemudian kita jalankan program tersebut :

3. Multi-Parallel Scheduling Program

Pertama, kita buat terlebih dahulu programnya dalam Bahasa C# (Sebagai Back-end) dengan Nama File MainWindowViewModel.cs pada Folder Arkom\ParalelComputation\ParalelComputation\ParalelComputation.

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Linq;
using System.Management;
using System.Runtime.CompilerServices;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
namespace ParalelComputation
{
    public class MainWindowViewModel : INotifyPropertyChanged
    {
        public event PropertyChangedEventHandler PropertyChanged;
        private IList<PerProcess> _PerProcesses = new List<PerProcess>();
        public IList<PerProcess> PerProcesses { get { return _PerProcesses; } set { _PerProcesses = value; OnPropertyChanged(); } }

        private string _infoAll = "Start";
        public string InfoAll { get { return _infoAll; } set { _infoAll = value; OnPropertyChanged(); } }

        public void Run()
        {
            int physicalProcessors;
            foreach (var item in new ManagementObjectSearcher("Select * from Win32_ComputerSystem").Get())
            {
                physicalProcessors = int.Parse(item["NumberOfProcessors"].ToString());
            }
            int coreCount = 0;
            foreach (var item in new ManagementObjectSearcher("Select * from Win32_Processor").Get())
            {
                coreCount += int.Parse(item["NumberOfCores"].ToString());
            }
            int logicalProcessors = Environment.ProcessorCount;

            IList<PerProcess> perProcesses = new List<PerProcess>();
            for (int i = 0; i < logicalProcessors; i++)
            {
                PerProcess perProcess = new PerProcess(i);
                Task.Run(() => perProcess.Run());
                perProcesses.Add(perProcess);
            }
            PerProcesses = perProcesses;
            InfoAll = "Number of Thread: " + coreCount;
        }


        protected void OnPropertyChanged([CallerMemberName] string name = null)
        {
            PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(name));
        }
    }
}

Kemudian kita buat juga programnya dalam Bahasa XAML (Sebagai Front-end) agar dapat membuat interface/antarmuka tersebut dengan Nama File MainWindow.xaml pada Folder Arkom\ParalelComputation\ParalelComputation\ParalelComputation.

<Window x:Class="ParalelComputation.MainWindow"
        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
        xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
        xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
        xmlns:local="clr-namespace:ParalelComputation"
        mc:Ignorable="d"
        Background="LightGreen"
        Title="MainWindow" Height="500" Width="300">
    <Grid>
        <Grid.Resources >
            <Style TargetType="StackPanel" >
                <Setter Property="Margin" Value="40" />
            </Style>
            <Style TargetType="TextBlock" >
                <Setter Property="FontSize" Value="18" />
            </Style>
        </Grid.Resources>
        <Grid.ColumnDefinitions>
            <ColumnDefinition></ColumnDefinition>
        </Grid.ColumnDefinitions>
        <Grid.RowDefinitions>
            <RowDefinition Height="3*"></RowDefinition>
            <RowDefinition></RowDefinition>
        </Grid.RowDefinitions>
        <ListView Background="LightGreen" ItemsSource="{Binding PerProcesses}">
            <ListView.ItemTemplate>
                <DataTemplate>
                    <StackPanel  Orientation="Vertical">
                        <TextBlock Foreground="Blue" Text="{Binding Index}"></TextBlock>
                        <TextBlock Text="{Binding Info}"></TextBlock>
                        <Slider Value="{Binding ValueSlider}" Maximum="1000" TickPlacement="BottomRight" TickFrequency="1000" />
                    </StackPanel>
                </DataTemplate>
            </ListView.ItemTemplate>
        </ListView>
        <StackPanel Grid.Row="1" Grid.Column="0" Grid.ColumnSpan="2">
            <TextBlock Text="{Binding InfoAll}"></TextBlock>
        </StackPanel>
    </Grid>
</Window>

Kemudian kita jalankan program tersebut dan inilah hasilnya :

Itulah Materi tentang Sinyal Clock dan Scheduling beserta dengan Algoritmanya. Semoga bermanfaat bagi Anak IT. Dan untuk File Source Code untuk Algoritma Penjadwalan dalam C#, silakan lihat dan download di sini.

Terima Kasih 😄😘👌👍 :)

Wassalamu‘alaikum wr. wb.