CARA KERJA CPU PADA SISTEM OPERASI

 CARA KERJA CPU PADA SISTEM OPERASI

Elemen pada processor. Processor terdiri dari dari 4 elemen yang melakukan operasi terhadap data, ke 4 elemen itu yaitu instruksi, petunjuk instruksi, beberapa register dan ALU (Arithmetic Logic Unit). Petunjuk instruksi akan memberi tahu processor dimana instruksi dari sebuah aplikasi diletakkan di memori.

Cara processor melakukan tugas : penunjuk instruksi mengarahkan fetch instruksi ke sebuah spot di memori yang menampung sebuah instruksi. Fetch kemudian menangkap instruksi tersebut dan memberikannya ke dekoder instruksi, kemudian mengamati instruksi tersebut dan menentukan langkah selanjutnya untuk melengkapi instruksi tersebut.

Cara kerja processor

ALU kemudian mengerjakan perintah yang diminta instruksi : menambah data, membagi data, atau memanipulasi data yang ada. Setelah processor menerjemahkan dan mengerjakan instruksi, unit kontrol memberitahukan fetch instruksi untuk menangkap instruksi berikutnya di memori. Proses ini berlangsung terus menerus, dari satu instruksi ke instruksi berikutnya, dalam suatu langkah yang rumit, untuk menciptakan hasil yang dapat dilihat di monitor.

Untuk meyakinkan semua itu berjalan dalam satu kesatuan waktu, bagian itu memerlukan suatu clock generator. Clock generator meregulasi setiap langkah yang dikerjakan processor. Seperti sebuah metronome, sebuah clock generator mengirim pulsa-pulsa elektrik untuk menentukan langkah yang harus dikerjakan processor. Pulsa tersebut diukur dalam jutaan langkah per detik, atau megahertz, yang dikenal sebagai ukuran kecepatan processor. Semakin banyak pulsa dibuat, semakin cepat kerja processor. 

Prosesor dalam membagi tugas menjalankan banyak aplikasi di Sistem Operasi

Jadi pada pemrosesan instruksi dalam prosesor umumnya dibagi menjadi dua tahap, tahap yg pertama bias disebut Instruction Fetch, sedangkat pada tahap ke dua disebut Instruction Execute. Tahap pertama disini berisikan pemrosesan prosesor dimana CU mengambil data atau menginstruksikan  dari main mempory agar ke register, sedangkan tahap kedua disini berisikan pemrosesan pemrosesan dimana CU mengantarkan data atau instruksi dari register ke main-memory untuk selanjutnya ditampung di RAM, setelah Instruction Fetch dilakukan. Waktu pada tahap pertama ditambah dengan yang tahap kedua bias disebut juga sebagai waktu siklus mesin atau bisa juga disebut machine cycles time

Penghitung program dalam processor umumnya bergerak secara berurutan. Walaupun demikian, beberapa instruksi dalam processor, yang disebut dengan instruksi lompatan, mengizinkan processor mengakses instruksi yang terletak bukan pada urutannya. Hal ini disebut juga percabangan instruksi (branching instruction).

Cabang-cabang instruksi tersebut dapat berupa cabang yang bersifat kondisional (memiliki syarat tertentu) atau non-kondisional. Sebuah cabang yang bersifat non-kondisional selalu berpindah ke sebuah instruksi baru yang berada di luar aliran instruksi, sementara sebuah cabang yang bersifat kondisional akan menguji terlebih dahulu hasil dari operasi sebelumnya untuk melihat apakah cabang instruksi tersebut akan dieksekusi atau tidak. Data yang diuji untuk percabangan instruksi disimpan pada lokasi yang disebut dengan flag.

Penjadwalan CPU adalah dasar dari multi programming sistem operasi. Cara kerja dari penjadwalan CPU adalah men-switch CPU diantara proses yang dikerjakan.

Penjadwalan CPU terjadi apabila :

a)      Proses berubah dari running state ke waiting state.

b)      Proses berubah dari running state ke ready state.

c)      Proses berubah dari waiting state ke ready state.

d)     Proses terminates.

Jenis-Jenis Antrean (queue) :

a)      Job queue adalah kumpulan semua proses dalam system.

b)      Ready queue adalah kumpulan semua proses dalam main memory (memory utama), ready, waiting untuk diekseskusi.

c)      Devices queue adalah kumpulan proses yang menunggu (waiting) untuk I/O devices.

Penjadwalan CPU memiliki 3 jenis yaitu :

a)      Long-Term Scheduler adalah pemilihan proses yang akan dibawa ke antrean ready (ready queue).

b)      Short-Term Scheduler adalah pemilihan proses yang akan dieksekusi berikutnya dan Mengalokasikan CPU.

c)      Medium-Term Scheduler adalah Proses yang terkena swaping.

Cara prosesor membedakan suatu aplikasi dengan aplikasi lainnya

Sebuah komputer akan bekerja apabila mendapat instruksi-instruksi yang dikemas dalam sebuah program. Processor dari sebuah komputer hanya dapat mengeksekusi program yang menggunakan instruksi-instruksi yang dapat dikenalinya. Instruksi-instruksi ini dikenal sebagai instruksi mesin (machine instruction) atau instruksi komputer (computer instruction). Kumpulan fungsi yang dapat dieksekusi processor disebut set instruksi (instruction set) CPU. Instruksi mesin ini berupa kode-kode biner.

Semua bahasa pemrograman, baik bahasa assembler maupun bahasa tingkat tinggi yang digunakan akan diubah menjadi bentuk kode biner oleh sebuah compiler yang biasanya sudah tersedia dalam sebuah bahasa pemrograman, kemudian disimpan dalam memory program.   

Ketika program aplikasi dipanggil oleh user dan dijalankan, processor akan mengenali aplikasi tersebut berdasarkan kode-kode biner yang tersimpan didalam set instruksi. Setiap program aplikasi memiliki kode-kode biner dan set instruksi yang berbeda satu sama lain sesuai dengan program aplikasinya. Jadi processor dapat membedakan antara satu aplikasi dan aplikasi lain berdasarkan kode-kode biner  pada set instruksi aplikasi tersebut.

KESIMPULAN

Jadi kesimpulannya CPU atau Central Processing Unit berfungsi melakukan operasi aritmatika dan logikaterhadap data yang diambil dari memori atau dari informasi yang dimasukkan melaluibeberapa perangkat kerasI/O atau Input Output merupakan alat yang menginput data yang akan diolah danmengoutput data yang sudah diolah.S/I atau System Interconection berfungsi untuk menghubungkan antara CPU, MainMemory dan alat Input Output.Main Memory merupakan memori yang memiliki kapasitas yang cukup besar yangmenampung semua instruksi dan data sebelum diproses CPU

MUHAMMAD RIDWAN

1010 511 103

LOCAL  C

referensi:
http://aagddalemkemaraputra.blogspot.com/2009/06/fungsi-dan-cara-kerja-cpu.html
http://note-why.blogspot.com/2012/10/cara-kerja-processor.html
http://moving-onn.blogspot.com/2011/05/cara-kerja-processor.html

Penjadwalan CPU dengan FCFS

1.      Penjadwalan CPU dengan FCFS

1.1  Dasar Teori

Penjadwalan CPU adalah permasalahan menentukan proses mana pada ready queue yang dialokasikan ke CPU. Pada saat CPU menganggur, maka sistem operasi harus menyeleksi prosesproses yang ada di memori utama (ready queue) untuk dieksekusi dan mengalokasikan CPU untuk salah satu dari proses tersebut. Seleksi semacam ini disebut dengan shortterm scheduler (CPU scheduler). Keputusan untuk menjadwalkan CPU mengikuti empat keadaan dibawah ini :

1. Apabila proses berpindah dari keadaan running ke waiting;

2. Apabila proses berpindah dari keadaan running ke ready;

3. Apabila proses berpindah dari keadaan waiting ke ready;

4. Apabila proses berhenti.

Setiap algoritma diukur “turnaround time” dan “waiting time” untuk membandingkan performansi dengan algoritma lain. Dan untuk mengukur turnaround time dan waiting time, digunakan “Gant Chart”. CPU time (Burst Time) membutuhkan semua proses diasumsikan diketahui. Arrival time untuk setiap proses pada ready queue diasumsikan diketahui.

1.2  Algoritma

First-Come First-Served Scheduling (FCFS) adalah 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 :

Proses              Burst Time

P1                           24

P2                           3

P3                           3

Gant Chart dengan penjadwalan  FCFS sebagai berikut :

P1           P2           P3

                               

0              24               27                    30

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. Sedangkan apabila proses datang dengan urutan P2, P3, dan P1, hasil penjadwalan CPU dapat dilihat pada gant chart berikut :

P2           P3           P1

                               

0               3                 6                    30

Waktu tunggu sekarang untuk P1 adalah 6, P2 adalah 0 dan P3 adalah 3 sehingga rata-rata waktu tunggu adalah (6 + 0 + 3)/3 = 3 milidetik. Rata-rata waktu tunggu kasus ini jauh lebih baik dibandingkan dengan kasus sebelumnya. Pada penjadwalan CPU dimungkinkan terjadi Convoy effect apabila proses yang pendek berada pada proses yang panjang.

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

1.3  Listing/source code  Program C++ yang sudah benar

#include<stdio.h>#include<string.h>main()

{

int n, ar[100], b[100], i, j, tmp, wt[100], ta[100], time[100];

int totWT=0, totTA=0;

float AvWT, AvTA;

char name[20][20], tmpName[20];

printf(“\t.:: Program Penjadwalan CPU FCFS ::.\n”);

puts(“”);

printf(“Banyak Proses\t= “); scanf(“%d”, &n);

puts(“”);

// Masukkan data yang diproses

for(i=0; i<n; i++){

fflush(stdin);

printf(“Nama Proses\t= “); gets(name[i]);

printf(“Arrival time\t= “); scanf(“%d”, &ar[i]);

printf(“Burst time\t= “); scanf(“%d”, &b[i]);

puts(“”);

}

// SORTING Data

for(i=0; i<n; i++){

for(j=i+1; j<n; j++)

if(ar[i]>ar[j]){

//tukar nama

strcpy(tmpName, name[i]);

strcpy(name[i], name[j]);

strcpy(name[j], tmpName);

//tukar arrival time

tmp=ar[i];

ar[i]=ar[j];

ar[j]=tmp;

//tukar burst

tmp=b[i];

b[i]=b[j];

b[j]=tmp;

}

}

time[0]=ar[0];

puts(“\n\t.:: Process Table ::.”);

puts(“==========================================”);

printf(“| no | proses\t | time arrival\t | burst |\n”);

puts(“——————————————”);

for (i=0; i<n; i++){

printf(“| %2d | %s\t |  \t%d\t | %d\t |\n”, i+1, name[i], ar[i], b[i]);

time[i+1]=time[i]+b[i]; //menghitung time pada ganchart

wt[i]=time[i]-ar[i];

ta[i]=time[i+1]-ar[i];

totWT+=wt[i];

totTA+=ta[i];

}

puts(“==========================================”);

printf(“\tTotal waiting time\t= %d \n”, totWT);

printf(“\tTurn arround time\t= %d \n”, totTA);

puts(“\n\t.:: Time Process Table ::.”);

puts(“==================================================”);

printf(“| no | proses\t | waiting time\t | turn arround\t |\n”);

puts(“————————————————–”);

for(i=0; i<n; i++){

printf(“| %2d | %s\t |  \t%d\t | \t%d\t |\n”, i+1, name[i], wt[i], ta[i]);

}

puts(“==================================================”);

//untuk Gant Chart

puts(“\n”);

puts(“\t.:: Gant-Chart ::.\n”);

for(i=0; i<n; i++){

printf(” %s\t “, name[i]);

}

puts(“”);

for(i=0; i<n; i++){

printf(“|=========”);

}

printf(“|\n”);

for(i=0; i<=n; i++){

printf(” %d\t “, time[i]);

} printf(“//diperoleh dari penjumlahan Burst”);

puts(“\n”);

AvWT=(float)totWT/n; //average waiting time

AvTA=(float)totTA/n; //average turn arround time

printf(“\tAverage Waiting Time : %f\n”, AvWT);

printf(“\tAverage Turn Arround TIme : %f\n”, AvTA);

}

1.4  Hasil Output

Penjadwalan CPU FCFS dengan bahasa pemrograman C++

1.2  Analisa

Pertama masukkan banyak proses kemudia inputan ini di looping sebanyak inputan tadi, didalam proses looping terdapat inputan yaitu nama proses, arrival dan burst yang menggunakan array.

•             Untuk mengetahui nilai dari waiting time maka nilai dari arrival time dikurangi dengan nilai burst yang sudah dijumlah kan, seperti pada Gant Chart nya.

•             Untuk mencari nilai rata-rata waktu tunggu maka nilai waiting time dijumlahkan semua kemudian di bagi dengan jumlah waiting time tersebut.

•             Untuk mencari rata-rata time around maka nilai dari burst dijumlahkan kemudian di bagi dengan jumlah burst tadi.

1.3  Kesimpulan

Program ini merupakan program penjadwalan cpu dengan FCFS maksud nya proses yang pertama kali memintah jatah waktu maka akan di kerjakan terlebih dahulu baru proses berikutnya, dengan menggunakan penjadwalan cpu fcfs ini terdapat kekurangan nya yaitu :

•             Waktu tunggu rata-rata cukup lama

•             Terjadinya convoy effect, yaitu proses-proses menunggu lama untuk menunggu 1 proses besar yang sedang dieksekusi oleh CPU

•             Di penjadwalan cpu fcfs ini menerapkan konsep non-preemptive, yaitu setiap proses yang sedang dieksekusi oleh CPU tidak dapat di-interrupt oleh proses yang lain.

AJAR HERDITAMA                            1010 511 095 (Kelas B)

DWI PRASETYO ISWORO               1010 511 120 (Kelas B)

MUHAMMAD RIDWAN                   1010 511 103 (Kelas C)

MUHAMMAD FAJAR KAMALI       1010 511 126 (Kelas C)

TAUFAN FIRMANSYAH                  1010 511 102 (Kelas C)