Tugas Bonus Sitem Operasi

KELOMPOK :


Rifadli Setiawan (1210511040)
 
Willy Andrian Cahyadi (1210511044) 

Tubagus M Rizky (1210511067)

Teguh Prinarwanto (1210511068)





KonsepDasarPenjadwalan
1. SO modern umumnya merupakan sistem multitasking.
2. TujuanUtama: untuk mempunyai proses berjalan secara bersamaan, untuk memaksimalkan kinerja  dariCPU.
3. PemanfaatanCPU maksimumdiperoleh dengan multiprogramming
CPU-I/O Burst Cycle-Pelaksanaan proses terdiri dari suatu siklus tungguI/O dan eksekusi CPU

CPU Scheduler
Pada saat CPU menganggur, maka sistem operasi harus menyeleksi proses-proses yang ada di memori utama (ready queue) untuk dieksekusi dan mengalokasikan CPU untuk salah satu dari proses tersebut. Seleksi semacam ini disebut dengan short-term scheduler (CPU scheduler). Keputusan untuk menjadwalkan CPU mengikuti empa keadaan dibawah ini :
a) Apabila proses berpindah dari keadaan running ke waiting;
b) Apabila proses berpindah dari keadaan running ke ready;
c) Apabila proses berpindah dari keadaan waiting ke ready;
d) Apabila proses berhenti.

Apabila model penjadwalan yang dipilih menggunakan keadaan 1 dan 4, maka penjadwakan semacam ini disebut non-peemptive. Sebaliknya, apabila yang digunakan adalah keadaan 2 dan 3, maka disebut dengan preemptive.
Pada non-preemptive, jika suatu proses sedang menggunakan CPU, maka proses tersebut akan tetap membawa CPU sampai proses tersebut melepaskannya (berhenti atau dalam keadaan waiting). Preemptive scheduling memiliki kelemahan, yaitu biaya yang dibutuhkan sangat tinggi. Antara lain, harus selalu dilakukan perbaikan data. hal ini terjadi jika suatu proses ditinggalkan dan akan segera dikerjakan proses yang lain.


Dispatcher
Dispatcher adalah suatu modul yang akan memberikan kontrol pada CPU terhadap penyeleksian proses yang dilakukan selama short-term scheduling. Fungsi¬fungsi yang terkandung di dalam-nya meliputi :
a) Switching context;
b) Switching ke user-mode;
c) Melompat ke lokasi tertentu pada user program untuk memulai program.
Waktu yang diperlukan oleh dispatcher untuk menghentikan suatu proses dan memulai untuk menjalankan proses yang lainnya disebut dispatch latency.

KomponenPenjadwalan Proses
1.AntrianPenjadwalan(Scheduler Queue)
-Ready queue
-I/O queue
-Job queue
2. Penjadwal(Scheduler)
-Short-Term Scheduler
-Medium-Term Scheduler
-Long-Term Scheduler

Tipe Penjadwalan
Terdapat 3 tipe penjadwal berada secara bersama-sama pada sistem operasi yang kompleks, yaitu:
1. Penjadwalan Jangka Pendek ( Short Term Scheduler )
Bertugas menjadwalkan alokasi pemroses di antara proses-proses ready di memori utama. Penjadwalan dijalankan setiap terjadi pengalihan proses untuk memilih proses berikutnya yang harus dijalankan.

2. Penjadwalan Jangka Menengah ( Medium Term Scheduler )
Setelah eksekusi selama suatu waktu, proses mungkin menunda sebuah eksekusi karena membuat permintaan layanan masukan/keluaran atau memanggil suatu system call. Proses-proses tertunda tidak dapat membuat suatu kemajuan menuju selesai sampai kondisi-kondisi yang menyebabkan tertunda dihilangkan. Agar ruang memori dapat bermanfaat, maka proses dipindah dari memori utama ke memori sekunder agar tersedia ruang untuk proses-proses lain. Kapasitas memori utama terbatas untuk sejumlah proses aktif. Aktivitas pemindahan proses yang tertunda dari memori utama ke memori sekunder disebut swapping. Proses-proses mempunyai kepentingan kecil saat itu sebagai proses yang tertunda. Tetapi, begitu kondisi yang membuatnya tertunda hilang dan proses dimasukkan kembali ke memori utama dan ready.

3. Penjadwal Jangka Panjang ( Long Term Scheduler )
Penjadwal ini bekerja terhadap antrian batch dan memilih batch berikutnya yang harus dieksekusi. Batch biasanya adalah proses-proses dengan penggunaan sumber daya yang intensif (yaitu waktu pemroses, memori, perangkat masukan/keluaran), program-program ini berprioritas rendah, digunakan sebagai pengisi (agar pemroses sibuk) selama periode aktivitas job-job interaktif rendah.

Kriteria Penjadwalan Proses
Dalam melakukan penjadwalan proses, SO mempertimbangkan sejumlah faktor:

1.Keadilan(fairness)
Memastikan bahwa setiap proses mendapat giliran yang adil, tetapi tidak selalu berarti jatah waktu yang sama. perlu dipastikan tidak terjadi proses yang tidak terlayani dalam jangka waktu yang lama.

2. Efisiensi(Processor Utilization)
Penggunaan waktu CPU (CPU Time) seoptimal mungkin processor terpakai terus menerus selama masih ada antrian ready.

3. Waktu tanggapan(Response time)
Mempercepat(secepat dan sependek mungkin) waktu tanggapdengan pemakai secara interaktif.
response time adalah waktu antara pengguna memberikan input dengan SO memberikan output atau umpan balik kepengguna.

4. Waiting Time
harus seminim mungkin merupakan durasi waktu yang dihabiskan suatu proses dalam antrian ready selama siklus hidupnya.

5. Turn Around Time
harus seminim mungkin merupakan durasi waktu dari suatu proses aktif dalam sistem sampai dengan selesai.

6. Throughput
rata-rata proses yang dapat diselesaikan per satuan waktu.nilai throughput harus tinggi

Strategi Penjadwalan


KriteriaPenjadwalanyang Optimal
-Memaksimumkan utilisasiCPU
-Memaksimumkan throughput
-Meminimukan turnaround time
-Meminimumkan waiting time
-Meminimumkan response time

Algoritma penjadwalan RR (Round Robin)
-Merupakan penjadwalan preemptive.
-Setiap proses dianggap penting dan mendapat jatah waktu CPU (time slice/quantum) tertentu misalkan 10  atau 100 milidetik.
-Setelah waktu tersebut maka proses akandi-preempt dan dipindahkan keready queue.
-Adil dan sederhana.


 




Berikut adalah Algortima Round Robin dalam C++

#include
class sched{
public:
    int n,bt[10],at[10],tat[10],wt[10],rt[10],finish[10],twt,ttat,total;
    void readData();
 
    void Init();
    void dispTime();
    int getNextProcess(int);
    void computeRR();
};

void sched::readData()
{
    cout<<"\nBanyak proses    = ";
    cin>>n;
    cout<<"\nBurst Time    = \n";
    for(int i=0;i    cin>>bt[i];
    cout<<"\nArrival Time    = \n";
    for(i=0;i    cin>>at[i];
}

void sched::Init(){
    total=0;
    twt=0;
    ttat=0;
    for(int i=0; i        rt[i]=bt[i];
        finish[i]=0;
        wt[i]=0;
        tat[i]=0;
        total+=bt[i];
        }
}



void sched::dispTime()
{
    for(int i=0;i    {

        twt+=wt[i];
        tat[i]=wt[i]+bt[i];
        ttat+=tat[i];
        cout<<"Waiting time for P"<<(i+1)<<" = "<}

int sched::getNextProcess(int time){

        int i,low;
        for(i=0;i            if(finish[i]==0){low=i; break; }
        for(i=0;i            if(finish[i]!=1)
                if(rt[i]                        low=i;
        return low;

}

void sched::computeRR(){

    readData();
    Init();
    int time,j,q,i,dec=0;
    cout<<"\nTime slice    = \n";
    cin>>q;
    cout<<"\n===========================================================\n";
    cout<<"\n-------------------------Gantt Chart-----------------------\n";
    cout<<"\n===========================================================\n";
    for(time=0;time    {
        for(i=0;i        {
            if(at[i]<=time && finish[i]==0)
            {

                cout<<"("<                if(rt[i]                    dec=rt[i];
                }
                else {dec=q;}

                rt[i]=rt[i]-dec;
                if(rt[i]==0) finish[i]=1;
                for(j=0;j                    if(j!=i && finish[j]==0 && at[j]<=time)
                        wt[j]+=dec;
                 time=time+dec;

            }

        }

    }

    cout<<"("<    dispTime();

}

void main()
{
    sched s;
    int ch;

    while(ch!=3)
    {
        cout<<"\n\n1.Round Robin\n2.Exit\nEnter choice: ";
        cin>>ch;
        cout<<"======================================";
        switch(ch)
        {
          
            case 1: s.computeRR(); break;
            case 2: break;
            default: cout<<"Invalid Option\n";

        }
    }

}



====================OUTPUT=======================





===================================================
Kesimpulan
Algoritma Round Robin mengacu pada time slace dimana , semua proses dianggap penting sehingga diberi sejumlah waktu oleh pemroses yang disebut kwanta (quantum) atau time slice dimana proses itu berjalan. Jika proses masih running sampai akhir quantum, maka CPU akan mempreempt proses itu dan memberikannya ke proses lain.
Penjadwal membutuhkannya dengan memelihara daftar proses dari runnable. Ketika quantum habis untuk satu proses tertentu, maka proses tersebut akan diletakkan diakhir daftar (list)
Jika time quantum yang ditentukan terlalu kecil, maka sebagian besar proses tidak akan selesai dalam 1 quantum. Hal ini tidak baik karena akan terjadi banyak switch, padahal CPU memerlukan waktu untuk beralih dari suatu proses ke proses lain (disebut dengan context switches time). Sebaliknya, jika time quantum terlalu besar, algoritma Round Robin akan berjalan seperti algoritma first come first served. Time quantum yang ideal adalah jika 80% dari total proses memiliki CPU burst time yang lebih kecil dari 1 time quantum.

Klik disini untuk melihat source di google code  
=====================================================