İşletim Sistemleri Proses Sıralama Algoritmaları - Java

Merhaba, bu yazımda işletim sistemleri dersinin ödevi için Java programlama diliyle hazırladığım proses sıralama algoritmalarını paylaşacağım. Sırasıyla FCFS (First come first served), SJF-NP(Shortest job fist - non preemptive), SJF-P(Shortest job first - preemptive), PR-NP(Priority ranking - non preemptive), PR-P(Priority ranking - preemptive) ve RR(Round robin) algoritmaları için çıktılar verilmiştir.

Ekran görüntüsü şu şekildedir:

 

Kaynak kodu da aşağıdaki gibidir:

 

//0:Varış
	//1:Patlama
	//2:Bekleme
	//3:Toplam
	//4:Yapildi
	//5:Sıra
	//6:İndis
	//7:Kalan Süre
	//8:Oncelik
	
	//0:Ortalama Bekleme Zamanı
	//1:Ortalama Tamamlanma Zamanı
	//2:Ortalama Cevap Zamanı
	//3:Tamamlanma Zamanı
	package odev3;
	
	import java.math.BigDecimal;
	import java.math.RoundingMode;
	import java.util.Scanner;
	
	/**
	 *
	 * @author Serhat Yılmaz
	 */
	public class Odev3 {
	
	    /**
	     * @param args the command line arguments
	     */
	    private static int ProcessArrayLength = 9;
	
	    private static double[][] Tablo = new double[6][4];
	
	    private static int Quantum = 4;
	
	    public static void main(String[] args) {
	        // TODO code application logic here
	        System.out.print("Hesaplamak istediğiniz proses sayısı giriniz: ");
	
	        int ProsesSayisi = 0;
	
	        Scanner scanIn = new Scanner(System.in);
	        ProsesSayisi = Integer.parseInt(scanIn.nextLine());
	
	        int[][] Prosesler = new int[ProsesSayisi][ProcessArrayLength];
	
	        for (int i = 0; i < ProsesSayisi; i++) {
	            System.out.print("Proses " + (i + 1) + " Varış Zamanı (ms): ");
	            Prosesler[i][0] = Integer.parseInt(scanIn.nextLine());
	            System.out.print("Proses " + (i + 1) + " Patlama Zamanı (ms): ");
	            Prosesler[i][1] = Integer.parseInt(scanIn.nextLine());
	            Prosesler[i][6] = i + 1;
	            System.out.print("Proses " + (i + 1) + " Öncelik Sırası: ");
	            Prosesler[i][8] = Integer.parseInt(scanIn.nextLine());
	        }
	        Quantum = KuantumHesapla(ProsesSayisi, Prosesler);
	        scanIn.close();
	
	        //varış zamanına göre sırala
	        Prosesler = Sirala(ProsesSayisi, Prosesler, 0);
	
	        System.out.println("nn============================================================================nnFirst Come First Served");
	
	        FCFSCikis(ProsesSayisi, Prosesler);
	        FCFSBeklemeZamanlariListele(ProsesSayisi, Prosesler);
	        FCFSTamamlanmaZamanlariListele(ProsesSayisi, Prosesler);
	        Tablo[0][0] = FCFSOrtalamaBeklemeVeCevaplama(ProsesSayisi, Prosesler);
	        Tablo[0][1] = FCFSOrtalamaTamamlanmaZamani(ProsesSayisi, Prosesler);
	        Tablo[0][2] = Tablo[0][0];
	        Tablo[0][3] = FCFSTamamlanmaZamani(ProsesSayisi, Prosesler);
	
	        System.out.println("============================================================================nnShortest Job First Non-Preemptive");
	        int[][] SJFNP = new int[ProsesSayisi][ProcessArrayLength];
	        SJFNP = SJFNPHesapla(ProsesSayisi, Prosesler);
	        SJFNP = Sirala(ProsesSayisi, SJFNP, 5);
	        SJFNPCikis(ProsesSayisi, SJFNP);
	        SJFNPBeklemeZamanlariListele(ProsesSayisi, SJFNP);
	        SJFNPTamamlanmaZamanlariListele(ProsesSayisi, SJFNP);
	        Tablo[1][0] = SJFNPOrtalamaBeklemeVeCevaplama(ProsesSayisi, SJFNP);
	        Tablo[1][1] = SJFNPOrtalamaTamamlanmaZamani(ProsesSayisi, SJFNP);
	        Tablo[1][2] = Tablo[1][0];
	        Tablo[1][3] = SJFNPTamamlanmaZamani(ProsesSayisi, SJFNP);
	
	        System.out.println("============================================================================nnShortest Job First Preemptive");
	        SJFPHesapla(ProsesSayisi, Prosesler);
	
	        System.out.println("============================================================================nnPriority Ranking Non-Preemptive");
	        int[][] PRNP = new int[ProsesSayisi][ProcessArrayLength];
	        PRNP = PRNPHesapla(ProsesSayisi, Prosesler);
	        //PRNP = Sirala(ProsesSayisi, PRNP, 6);
	        PRNPCikis(ProsesSayisi, PRNP);
	        PRNPBeklemeZamanlariListele(ProsesSayisi, PRNP);
	        PRNPTamamlanmaZamanlariListele(ProsesSayisi, PRNP);
	        Tablo[3][0] = PRNPOrtalamaBeklemeVeCevaplama(ProsesSayisi, PRNP);
	        Tablo[3][1] = PRNPOrtalamaTamamlanmaZamani(ProsesSayisi, PRNP);
	        Tablo[3][2] = Tablo[3][0];
	        Tablo[3][3] = PRNPTamamlanmaZamani(ProsesSayisi, PRNP);
	
	        System.out.println("============================================================================nnPriority Ranking Preemptive");
	        PRPHesapla(ProsesSayisi, Prosesler);
	
	        System.out.println("============================================================================nnRound Robin");
	        RRHesapla(ProsesSayisi, Prosesler);
	
	        TabloYazdir();
	    }
	
	    private static void Yazdir(int ProsesSayisi, int[][] Prosesler) {
	
	        for (int i = 0; i < ProsesSayisi; i++) {
	            System.out.println("P" + Prosesler[i][6] + " Varış Zamanı: " + Prosesler[i][0]);
	            System.out.println("P" + Prosesler[i][6] + " Patlama Zamanı: " + Prosesler[i][1]);
	        }
	    }
	
	    private static void FCFSCikis(int ProsesSayisi, int[][] Prosesler) {
	        System.out.println("nFCFS Çıkışı: ");
	        int toplam = Prosesler[0][0];
	        if (toplam != 0) {
	            System.out.print("   ");
	        }
	        for (int i = 0; i < ProsesSayisi; i++) {
	            System.out.print("P" + Prosesler[i][6] + " ");
	        }
	        System.out.println("");
	        if (toplam != 0) {
	            System.out.print("0  ");
	        }
	        for (int i = 0; i < ProsesSayisi; i++) {
	            System.out.print(toplam + " ");
	            if (toplam < 10) {
	                System.out.print(" ");
	            }
	            toplam += Prosesler[i][1];
	        }
	        System.out.print(toplam + " ");
	        System.out.println("");
	    }
	
	    private static void FCFSBeklemeZamanlariListele(int ProsesSayisi, int[][] Prosesler) {
	        System.out.println("nFCFS Bekleme Zamanları: ");
	        for (int i = 0; i < ProsesSayisi; i++) {
	            if (i <= 0) {
	                Prosesler[i][2] = 0;
	            } else {
	                Prosesler[i][2] = (Prosesler[i - 1][1] + Prosesler[i - 1][2]) - (Prosesler[i][0] - Prosesler[i - 1][0]);
	            }
	            System.out.println("P" + Prosesler[i][6] + ": " + Prosesler[i][2] + "ms");
	        }
	    }
	
	    private static double FCFSOrtalamaBeklemeVeCevaplama(int ProsesSayisi, int[][] Prosesler) {
	        int toplam = 0;
	        //Proseslerin bekleme zamanlarını hesapla
	        for (int i = 0; i < ProsesSayisi; i++) {
	            if (i <= 0) {
	                Prosesler[i][2] = 0;
	            } else {
	                Prosesler[i][2] = (Prosesler[i - 1][1] + Prosesler[i - 1][2]) - (Prosesler[i][0] - Prosesler[i - 1][0]);
	            }
	            toplam += Prosesler[i][2];
	        }
	
	        return ((double) toplam / (double) ProsesSayisi);
	
	    }
	
	    private static double FCFSOrtalamaTamamlanmaZamani(int ProsesSayisi, int[][] Prosesler) {
	        int toplam = 0;
	        for (int i = 0; i < ProsesSayisi; i++) {
	            toplam += Prosesler[i][1];
	        }
	
	        return ((double) toplam / (double) ProsesSayisi);
	    }
	
	    private static double FCFSTamamlanmaZamani(int ProsesSayisi, int[][] Prosesler) {
	        int toplam = Prosesler[0][0];
	        for (int i = 0; i < ProsesSayisi; i++) {
	            toplam += Prosesler[i][1];
	        }
	        return (double) toplam;
	    }
	
	    private static void FCFSTamamlanmaZamanlariListele(int ProsesSayisi, int[][] Prosesler) {
	        System.out.println("nFCFS Tamamlanma Zamanları: ");
	        for (int i = 0; i < ProsesSayisi; i++) {
	            System.out.println("P" + Prosesler[i][6] + ": " + Prosesler[i][1] + "ms");
	        }
	    }
	
	    private static int[][] SJFNPHesapla(int ProsesSayisi, int[][] Prosesler) {
	        int toplam = 0;
	        int kalanProses = ProsesSayisi;
	        int k = 0;
	        int enBuyukPatlama = 0;
	        int onceki = 0;
	        int sira = 1;
	        while (true) {
	            //en büyüğü tespit et
	            enBuyukPatlama = 0;
	            for (int i = 0; i < ProsesSayisi; i++) {
	                if (Prosesler[i][4] == 1 || Prosesler[i][0] > toplam) {
	                    continue;
	                }
	                if (Prosesler[i][1] >= enBuyukPatlama) {
	                    enBuyukPatlama = Prosesler[i][1];
	                }
	            }
	            //en küçüğü tespit et
	            int enKucukPatlama = enBuyukPatlama;
	            for (int i = 0; i < ProsesSayisi; i++) {
	                if (Prosesler[i][4] == 1 || Prosesler[i][0] > toplam) {
	                    continue;
	                }
	                if (Prosesler[i][1] <= enKucukPatlama) {
	                    enKucukPatlama = Prosesler[i][1];
	                    k = i;
	                }
	            }
	
	            if (k == 0) {
	                Prosesler[k][2] = 0;
	            } else {
	                Prosesler[k][2] = (Prosesler[onceki][1] + Prosesler[onceki][2]) - (Prosesler[k][0] - Prosesler[onceki][0]);
	            }
	            Prosesler[k][3] = Prosesler[k][1] + Prosesler[k][2];
	            Prosesler[k][4] = 1;
	            Prosesler[k][5] = sira;
	            kalanProses--;
	            toplam += Prosesler[k][3];
	
	            if (kalanProses == 0) {
	                break;
	            }
	            onceki = k;
	            sira++;
	        }
	
	        Prosesler = Sirala(ProsesSayisi, Prosesler, 5);
	
	        return Prosesler;
	    }
	
	    private static void SJFNPCikis(int ProsesSayisi, int[][] Prosesler) {
	        System.out.println("nSJF-NP Çıkışı: ");
	        int toplam = Prosesler[0][0];
	        if (toplam != 0) {
	            System.out.print("   ");
	        }
	        String proses = "";
	        	        
	        for (int i = 0; i < ProsesSayisi; i++) {
	            System.out.print("P" + Prosesler[i][6] + " ");
	        }
	        System.out.println("");
	        if (toplam != 0) {
	            System.out.print("0  ");
	        }
	        for (int i = 0; i < ProsesSayisi; i++) {
	            System.out.print(toplam + " ");
	            if (toplam < 10) {
	                System.out.print(" ");
	            }
	            toplam += Prosesler[i][1];
	        }
	        System.out.print(toplam + " ");
	        System.out.println("");
	    }
	
	    private static void SJFNPBeklemeZamanlariListele(int ProsesSayisi, int[][] Prosesler) {
	        System.out.println("nSJF-NP Bekleme Zamanları: ");
	        for (int i = 0; i < ProsesSayisi; i++) {
	            System.out.println("P" + Prosesler[i][6] + ": " + Prosesler[i][2] + "ms");
	        }
	    }
	
	    private static double SJFNPOrtalamaBeklemeVeCevaplama(int ProsesSayisi, int[][] Prosesler) {
	        int toplam = 0;
	        for (int i = 0; i < ProsesSayisi; i++) {
	            toplam += Prosesler[i][2];
	        }
	        return ((double) toplam / (double) ProsesSayisi);
	    }
	
	    private static double SJFNPOrtalamaTamamlanmaZamani(int ProsesSayisi, int[][] Prosesler) {
	        int toplam = 0;
	        for (int i = 0; i < ProsesSayisi; i++) {
	            toplam += Prosesler[i][1];
	        }
	
	        return ((double) toplam / (double) ProsesSayisi);
	    }
	
	    private static double SJFNPTamamlanmaZamani(int ProsesSayisi, int[][] Prosesler) {
	        int toplam = Prosesler[0][0];
	        for (int i = 0; i < ProsesSayisi; i++) {
	            toplam += Prosesler[i][1];
	        }
	        return (double) toplam;
	    }
	
	    private static void SJFNPTamamlanmaZamanlariListele(int ProsesSayisi, int[][] Prosesler) {
	        System.out.println("nSJF-NP Tamamlanma Zamanları: ");
	        for (int i = 0; i < ProsesSayisi; i++) {
	            System.out.println("P" + Prosesler[i][6] + ": " + Prosesler[i][1] + "ms");
	        }
	    }
	
	    private static void SJFPHesapla(int ProsesSayisi, int[][] Prosesler) {
	
	        Prosesler = Sirala(ProsesSayisi, Prosesler, 6);
	        int toplamSure = Prosesler[0][0];
	        for (int i = 0; i < ProsesSayisi; i++) {
	            toplamSure += Prosesler[i][1];
	            Prosesler[i][7] = Prosesler[i][1];
	            Prosesler[i][2] = 0;
	            Prosesler[i][3] = 0;
	        }
	
	        int[][] GeciciProsesler = new int[toplamSure][ProcessArrayLength];
	        int GeciciProsesSayisi = 0;
	        int aktifIslem = -1;
	        int oncekiIslem = -1;
	        int yeniIslemIndis = 0;
	        for (int zaman = 0; zaman <= toplamSure; zaman++) {
	            int enKucukZaman = toplamSure;
	            for (int i = 0; i < ProsesSayisi; i++) {
	                if (Prosesler[i][0] > zaman || Prosesler[i][7] <= 0) {
	                    continue;
	                }
	                if (Prosesler[i][7] < enKucukZaman) {
	                    enKucukZaman = Prosesler[i][7];
	                    aktifIslem = i;
	                }
	            }
	            if (aktifIslem == -1) {
	                continue;
	            }
	            if (oncekiIslem != aktifIslem) {
	                GeciciProsesler[yeniIslemIndis][0] = zaman;
	                GeciciProsesler[yeniIslemIndis][6] = Prosesler[aktifIslem][6];
	                GeciciProsesSayisi++;
	                yeniIslemIndis++;
	            } else {
	                GeciciProsesler[yeniIslemIndis - 1][1] = (zaman + 1) - GeciciProsesler[yeniIslemIndis - 1][0];
	            }
	
	            for (int i = 0; i < ProsesSayisi; i++) {
	                if (Prosesler[i][7] > 0 && Prosesler[i][0] <= zaman) {
	                    Prosesler[i][3]++;
	                    if (i != aktifIslem) {
	                        Prosesler[i][2]++;
	                    }
	                }
	            }
	            Prosesler[aktifIslem][7]--;
	            oncekiIslem = aktifIslem;
	        }
	
	        //ÇIKIŞ
	        System.out.println("nSJF-P Çıkışı: ");
	        if (GeciciProsesler[0][0] != 0) {
	            System.out.print("   ");
	        }
	        for (int i = 0; i < GeciciProsesSayisi; i++) {
	            System.out.print("P" + GeciciProsesler[i][6] + " ");
	        }
	        System.out.println("");
	        if (GeciciProsesler[0][0] != 0) {
	            System.out.print("0  ");
	        }
	        for (int i = 0; i < GeciciProsesSayisi; i++) {
	            System.out.print(GeciciProsesler[i][0] + " ");
	            if (GeciciProsesler[i][0] < 10) {
	                System.out.print(" ");
	            }
	        }
	        System.out.print(toplamSure + " ");
	        System.out.println("");
	
	        //ÇIKIŞ
	        //BEKLEME SÜRELERİ
	        System.out.println("nSJF-P Bekleme Zamanları: ");
	        for (int i = 0; i < ProsesSayisi; i++) {
	            System.out.println("P" + Prosesler[i][6] + ": " + Prosesler[i][2] + "ms");
	        }
	        //BEKLEME SÜRELERİ
	        //ORTALAMA BEKLEME VE CEVAPLAMA
	        int bzToplam = 0;
	        for (int i = 0; i < ProsesSayisi; i++) {
	            bzToplam += Prosesler[i][2];
	        }
	        double bz = (double) bzToplam / (double) ProsesSayisi;
	
	        Tablo[2][0] = bz;
	        Tablo[2][2] = Tablo[2][0];
	        //ORTALAMA BEKLEME VE CEVAPLAMA
	        //TAMAMLANMA ZAMANLARI
	        System.out.println("nSJF-P Tamamlanma Zamanları: ");
	        for (int i = 0; i < ProsesSayisi; i++) {
	            System.out.println("P" + Prosesler[i][6] + ": " + Prosesler[i][3] + "ms");
	        }
	        //TAMAMLANMA ZAMANLARI        
	        //ORTALAMA TAMAMLANMA ZAMANI
	        int toplam = 0;
	        for (int i = 0; i < ProsesSayisi; i++) {
	            toplam += Prosesler[i][3];
	        }
	
	        Tablo[2][1] = ((double) toplam / (double) ProsesSayisi);
	        //ORTALAMA TAMAMLANMA ZAMANI
	        //TAMAMLANMA ZAMANI
	        Tablo[2][3] = toplamSure;
	        //TAMAMLANMA ZAMANI
	    }
	
	    private static int[][] PRNPHesapla(int ProsesSayisi, int[][] Prosesler) {
	        int toplam = 0;
	        int kalanProses = ProsesSayisi;
	        int k = 0;
	        int enBuyukOncelik = 0;
	        int onceki = 0;
	        int sira = 1;
	        for (int i = 0; i < ProsesSayisi; i++) {
	            Prosesler[i][4] = 0;
	        }
	        while (true) {
	            //en büyüğü tespit et
	            enBuyukOncelik = 0;
	            for (int i = 0; i < ProsesSayisi; i++) {
	                if (Prosesler[i][4] == 1 || Prosesler[i][0] > toplam) {
	                    continue;
	                }
	                if (Prosesler[i][8] >= enBuyukOncelik) {
	                    enBuyukOncelik = Prosesler[i][8];
	                }
	            }
	            //en küçüğü tespit et
	            int enKucukOncelik = enBuyukOncelik;
	            for (int i = 0; i < ProsesSayisi; i++) {
	                if (Prosesler[i][4] == 1 || Prosesler[i][0] > toplam) {
	                    continue;
	                }
	                if (Prosesler[i][8] <= enKucukOncelik) {
	                    enKucukOncelik = Prosesler[i][8];
	                    k = i;
	                }
	            }
	
	            if (sira == 1) {
	                Prosesler[k][2] = 0;
	            } else {
	                Prosesler[k][2] = (Prosesler[onceki][1] + Prosesler[onceki][2]) - (Prosesler[k][0] - Prosesler[onceki][0]);
	            }
	            Prosesler[k][3] = Prosesler[k][1] + Prosesler[k][2];
	            Prosesler[k][4] = 1;
	            Prosesler[k][5] = sira;
	            kalanProses--;
	            toplam += Prosesler[k][3];
	
	            if (kalanProses == 0) {
	                break;
	            }
	            onceki = k;
	            sira++;
	        }
	
	        Prosesler = Sirala(ProsesSayisi, Prosesler, 5);
	
	        return Prosesler;
	    }
	
	    private static void PRNPCikis(int ProsesSayisi, int[][] Prosesler) {
	        System.out.println("nPR-NP Çıkışı: ");
	        int toplam = Prosesler[0][0];
	        if (toplam != 0) {
	            System.out.print("   ");
	        }
	        for (int i = 0; i < ProsesSayisi; i++) {
	            System.out.print("P" + Prosesler[i][6] + " ");
	        }
	        System.out.println("");
	        if (toplam != 0) {
	            System.out.print("0  ");
	        }
	        for (int i = 0; i < ProsesSayisi; i++) {
	            System.out.print(toplam + " ");
	            if (toplam < 10) {
	                System.out.print(" ");
	            }
	            toplam += Prosesler[i][1];
	        }
	        System.out.print(toplam + " ");
	        System.out.println("");
	    }
	
	    private static void PRNPBeklemeZamanlariListele(int ProsesSayisi, int[][] Prosesler) {
	        System.out.println("nPR-NP Bekleme Zamanları: ");
	        for (int i = 0; i < ProsesSayisi; i++) {
	            System.out.println("P" + Prosesler[i][6] + ": " + Prosesler[i][2] + "ms");
	        }
	    }
	
	    private static double PRNPOrtalamaBeklemeVeCevaplama(int ProsesSayisi, int[][] Prosesler) {
	        int toplam = 0;
	        for (int i = 0; i < ProsesSayisi; i++) {
	            toplam += Prosesler[i][2];
	        }
	        return ((double) toplam / (double) ProsesSayisi);
	    }
	
	    private static double PRNPOrtalamaTamamlanmaZamani(int ProsesSayisi, int[][] Prosesler) {
	        int toplam = 0;
	        for (int i = 0; i < ProsesSayisi; i++) {
	            toplam += Prosesler[i][1];
	        }
	
	        return ((double) toplam / (double) ProsesSayisi);
	    }
	
	    private static double PRNPTamamlanmaZamani(int ProsesSayisi, int[][] Prosesler) {
	        int toplam = Prosesler[0][0];
	        for (int i = 0; i < ProsesSayisi; i++) {
	            toplam += Prosesler[i][1];
	        }
	        return (double) toplam;
	    }
	
	    private static void PRNPTamamlanmaZamanlariListele(int ProsesSayisi, int[][] Prosesler) {
	        System.out.println("nPR-NP Tamamlanma Zamanları: ");
	        for (int i = 0; i < ProsesSayisi; i++) {
	            System.out.println("P" + Prosesler[i][6] + ": " + Prosesler[i][1] + "ms");
	        }
	    }
	
	    private static void PRPHesapla(int ProsesSayisi, int[][] Prosesler) {
	
	        Prosesler = Sirala(ProsesSayisi, Prosesler, 6);
	        int toplamSure = Prosesler[0][0];
	        for (int i = 0; i < ProsesSayisi; i++) {
	            toplamSure += Prosesler[i][1];
	            Prosesler[i][2] = 0;
	            Prosesler[i][3] = 0;
	            Prosesler[i][4] = 0;
	            Prosesler[i][5] = 0;
	            Prosesler[i][7] = Prosesler[i][1];
	        }
	
	        int _enBuyukOncelik = 0;
	        for (int i = 0; i < ProsesSayisi; i++) {
	            if (Prosesler[i][8] >= _enBuyukOncelik) {
	                _enBuyukOncelik = Prosesler[i][8];
	            }
	        }
	        _enBuyukOncelik++;
	        int[][] GeciciProsesler = new int[toplamSure][ProcessArrayLength];
	        int GeciciProsesSayisi = 0;
	        int aktifIslem = -1;
	        int oncekiIslem = -1;
	        int yeniIslemIndis = 0;
	        for (int zaman = 0; zaman <= toplamSure; zaman++) {
	            //en küçüğü tespit et
	            int enKucukOncelik = _enBuyukOncelik;
	            for (int i = 0; i < ProsesSayisi; i++) {
	                if (Prosesler[i][0] > zaman || Prosesler[i][7] <= 0) {
	                    continue;
	                }
	                if (Prosesler[i][8] < enKucukOncelik) {
	                    enKucukOncelik = Prosesler[i][8];
	                    aktifIslem = i;
	                }
	            }
	            if (aktifIslem == -1) {
	                continue;
	            }
	            if (oncekiIslem != aktifIslem) {
	                GeciciProsesler[yeniIslemIndis][0] = zaman;
	                GeciciProsesler[yeniIslemIndis][6] = Prosesler[aktifIslem][6];
	                GeciciProsesSayisi++;
	                yeniIslemIndis++;
	            } else {
	                GeciciProsesler[yeniIslemIndis - 1][1] = (zaman + 1) - GeciciProsesler[yeniIslemIndis - 1][0];
	            }
	
	            for (int i = 0; i < ProsesSayisi; i++) {
	                if (Prosesler[i][7] > 0 && Prosesler[i][0] <= zaman) {
	                    Prosesler[i][3]++;
	                    if (i != aktifIslem) {
	                        Prosesler[i][2]++;
	                    }
	                }
	            }
	            Prosesler[aktifIslem][7]--;
	            oncekiIslem = aktifIslem;
	        }
	
	        //ÇIKIŞ
	        System.out.println("nPR-P Çıkışı: ");
	        if (GeciciProsesler[0][0] != 0) {
	            System.out.print("   ");
	        }
	        for (int i = 0; i < GeciciProsesSayisi; i++) {
	            System.out.print("P" + GeciciProsesler[i][6] + " ");
	        }
	        System.out.println("");
	        if (GeciciProsesler[0][0] != 0) {
	            System.out.print("0  ");
	        }
	        for (int i = 0; i < GeciciProsesSayisi; i++) {
	            System.out.print(GeciciProsesler[i][0] + " ");
	            if (GeciciProsesler[i][0] < 10) {
	                System.out.print(" ");
	            }
	        }
	        System.out.print(toplamSure + " ");
	        System.out.println("");
	
	        //ÇIKIŞ
	        //BEKLEME SÜRELERİ
	        System.out.println("nPR-P Bekleme Zamanları: ");
	        for (int i = 0; i < ProsesSayisi; i++) {
	            System.out.println("P" + Prosesler[i][6] + ": " + Prosesler[i][2] + "ms");
	        }
	        //BEKLEME SÜRELERİ
	        //ORTALAMA BEKLEME VE CEVAPLAMA
	        int bzToplam = 0;
	        for (int i = 0; i < ProsesSayisi; i++) {
	            bzToplam += Prosesler[i][2];
	        }
	        double bz = (double) bzToplam / (double) ProsesSayisi;
	
	        Tablo[4][0] = bz;
	        Tablo[4][2] = Tablo[4][0];
	        //ORTALAMA BEKLEME VE CEVAPLAMA
	        //TAMAMLANMA ZAMANLARI
	        System.out.println("nPR-P Tamamlanma Zamanları: ");
	        for (int i = 0; i < ProsesSayisi; i++) {
	            System.out.println("P" + Prosesler[i][6] + ": " + Prosesler[i][3] + "ms");
	        }
	        //TAMAMLANMA ZAMANLARI        
	        //ORTALAMA TAMAMLANMA ZAMANI
	        int toplam = 0;
	        for (int i = 0; i < ProsesSayisi; i++) {
	            toplam += Prosesler[i][3];
	        }
	
	        Tablo[4][1] = ((double) toplam / (double) ProsesSayisi);
	        //ORTALAMA TAMAMLANMA ZAMANI
	        //TAMAMLANMA ZAMANI
	        Tablo[4][3] = toplamSure;
	        //TAMAMLANMA ZAMANI
	    }
	
	    private static void RRHesapla(int ProsesSayisi, int[][] Prosesler) {
	
	        System.out.println("Uygun Kuantum Zamanı: " + Quantum);
	
	        Prosesler = Sirala(ProsesSayisi, Prosesler, 0);
	        int toplamSure = Prosesler[0][0];
	        for (int i = 0; i < ProsesSayisi; i++) {
	            toplamSure += Prosesler[i][1];
	            Prosesler[i][2] = 0;
	            Prosesler[i][3] = 0;
	            Prosesler[i][4] = 0;
	            Prosesler[i][5] = 0;
	            Prosesler[i][7] = Prosesler[i][1];
	        }
	
	        int[][] GeciciProsesler = new int[toplamSure][ProcessArrayLength];
	        int GeciciProsesSayisi = 0;
	        int aktifIslem = 0;
	        int oncekiIslem = -1;
	        int yeniIslemIndis = 0;
	        int quantumCounter = 0;
	        Boolean degistir = false;
	        for (int zaman = 0; zaman <= toplamSure; zaman++) {
	            int ToplamKalan = 0;
	            for (int i = 0; i < ProsesSayisi; i++) {
	                ToplamKalan += Prosesler[i][7];
	            }
	            if (ToplamKalan <= 0) {
	                break;
	            }
	            if (Prosesler[aktifIslem][0] > zaman) {
	                continue;
	            }
	
	            if ((yeniIslemIndis > 0 && quantumCounter % Quantum == 0) || Prosesler[aktifIslem][7] == 0) {
	                degistir = true;
	            }
	            if (degistir) {
	                if (aktifIslem == ProsesSayisi - 1) {
	                    aktifIslem = 0;
	                } else {
	                    aktifIslem++;
	                }
	
	                while (Prosesler[aktifIslem][7] == 0) {
	                    if (aktifIslem == ProsesSayisi - 1) {
	                        aktifIslem = 0;
	                    } else {
	                        aktifIslem++;
	                    }
	                }
	                quantumCounter = 0;
	                degistir = false;
	            }
	
	            if (oncekiIslem != aktifIslem) {
	                GeciciProsesler[yeniIslemIndis][0] = zaman;
	                GeciciProsesler[yeniIslemIndis][6] = Prosesler[aktifIslem][6];
	                GeciciProsesSayisi++;
	                yeniIslemIndis++;
	            } else {
	                GeciciProsesler[yeniIslemIndis - 1][1] = (zaman + 1) - GeciciProsesler[yeniIslemIndis - 1][0];
	            }
	
	            for (int i = 0; i < ProsesSayisi; i++) {
	                if (Prosesler[i][7] > 0 && Prosesler[i][0] <= zaman) {
	                    Prosesler[i][3]++;
	                    if (i != aktifIslem) {
	                        Prosesler[i][2]++;
	                    }
	                }
	            }
	            Prosesler[aktifIslem][7]--;
	            oncekiIslem = aktifIslem;
	            quantumCounter++;
	        }
	
	        //ÇIKIŞ
	        System.out.println("nRR Çıkışı: ");
	        if (GeciciProsesler[0][0] != 0) {
	            System.out.print("   ");
	        }
	        for (int i = 0; i < GeciciProsesSayisi; i++) {
	            System.out.print("P" + GeciciProsesler[i][6] + " ");
	        }
	        System.out.println("");
	        if (GeciciProsesler[0][0] != 0) {
	            System.out.print("0  ");
	        }
	        for (int i = 0; i < GeciciProsesSayisi; i++) {
	            System.out.print(GeciciProsesler[i][0] + " ");
	            if (GeciciProsesler[i][0] < 10) {
	                System.out.print(" ");
	            }
	        }
	        System.out.print(toplamSure + " ");
	        System.out.println("");
	
	        //ÇIKIŞ
	        //BEKLEME SÜRELERİ
	        System.out.println("nRR Bekleme Zamanları: ");
	        for (int i = 0; i < ProsesSayisi; i++) {
	            System.out.println("P" + Prosesler[i][6] + ": " + Prosesler[i][2] + "ms");
	        }
	        //BEKLEME SÜRELERİ
	        //ORTALAMA BEKLEME VE CEVAPLAMA
	        int bzToplam = 0;
	        for (int i = 0; i < ProsesSayisi; i++) {
	            bzToplam += Prosesler[i][2];
	        }
	        double bz = (double) bzToplam / (double) ProsesSayisi;
	
	        Tablo[5][0] = bz;
	        Tablo[5][2] = Tablo[5][0];
	        //ORTALAMA BEKLEME VE CEVAPLAMA
	        //TAMAMLANMA ZAMANLARI
	        System.out.println("nRR Tamamlanma Zamanları: ");
	        for (int i = 0; i < ProsesSayisi; i++) {
	            System.out.println("P" + Prosesler[i][6] + ": " + Prosesler[i][3] + "ms");
	        }
	        //TAMAMLANMA ZAMANLARI        
	        //ORTALAMA TAMAMLANMA ZAMANI
	        int toplam = 0;
	        for (int i = 0; i < ProsesSayisi; i++) {
	            toplam += Prosesler[i][3];
	        }
	
	        Tablo[5][1] = ((double) toplam / (double) ProsesSayisi);
	        //ORTALAMA TAMAMLANMA ZAMANI
	        //TAMAMLANMA ZAMANI
	        Tablo[5][3] = toplamSure;
	        //TAMAMLANMA ZAMANI
	    }
	
	    private static int KuantumHesapla(int ProsesSayisi, int[][] Prosesler) {
	        Prosesler = Sirala(ProsesSayisi, Prosesler, 1);
	        int q;
	        int i = (int) Math.round(Double.valueOf(ProsesSayisi) * 0.8);
	        i = i >= ProsesSayisi ? ProsesSayisi : (i > 0 ? i - 1 : i);
	        q = Prosesler[i][1] + 1;
	        return q;
	    }
	
	    private static int[][] Sirala(int ProsesSayisi, int[][] Prosesler, int siralamaOlcut) {
	        int[] temp = new int[ProcessArrayLength];
	        for (int n = 0; n < ProsesSayisi; n++) {
	            for (int k = 1; k < ProsesSayisi; k++) {
	                if (Prosesler[k - 1][siralamaOlcut] > Prosesler[k][siralamaOlcut]) {
	                    temp = Prosesler[k];
	                    Prosesler[k] = Prosesler[k - 1];
	                    Prosesler[k - 1] = temp;
	                }
	            }
	        }
	
	        return Prosesler;
	    }
	
	    private static void TabloYazdir() {
	        String[] algs = new String[6];
	        algs[0] = "FCFS  ";
	        algs[1] = "SJF-NP";
	        algs[2] = "SJF-P ";
	        algs[3] = "PR-NP ";
	        algs[4] = "PR-P  ";
	        algs[5] = "RR    ";
	
	        int maxlentgth = 0;
	        for (int i = 0; i <= 5; i++) {
	            if (String.valueOf(round(Tablo[i][0], 2)).length() > maxlentgth) {
	                maxlentgth = String.valueOf(round(Tablo[i][0], 2)).length();
	            }
	
	            if (String.valueOf(round(Tablo[i][1], 2)).length() > maxlentgth) {
	                maxlentgth = String.valueOf(round(Tablo[i][1], 2)).length();
	            }
	
	            if (String.valueOf(round(Tablo[i][2], 2)).length() > maxlentgth) {
	                maxlentgth = String.valueOf(round(Tablo[i][2], 2)).length();
	            }
	
	            if (String.valueOf(round(Tablo[i][3], 2)).length() > maxlentgth) {
	                maxlentgth = String.valueOf(round(Tablo[i][3], 2)).length();
	            }
	        }
	
	        System.out.println("nn");
	        SeperatorLine(maxlentgth, "=");
	        System.out.print("|        | ");
	        System.out.print("OBZ");
	        for (int j = 0; j < (maxlentgth - 3); j++) {
	            System.out.print(" ");
	        }
	        System.out.print(" | ");
	        System.out.print("OTZ");
	        for (int j = 0; j < (maxlentgth - 3); j++) {
	            System.out.print(" ");
	        }
	        System.out.print(" | ");
	        System.out.print("OCZ");
	        for (int j = 0; j < (maxlentgth - 3); j++) {
	            System.out.print(" ");
	        }
	        System.out.print(" | ");
	        System.out.print("TZ");
	        for (int j = 0; j < (maxlentgth - 2); j++) {
	            System.out.print(" ");
	        }
	        System.out.println(" |");
	
	        SeperatorLine(maxlentgth, "=");
	
	        for (int i = 0; i <= 5; i++) {
	            System.out.print("| " + algs[i] + " | ");
	            System.out.print(round(Tablo[i][0], 2));
	            for (int j = 0; j < (maxlentgth - String.valueOf(round(Tablo[i][0], 2)).length()); j++) {
	                System.out.print(" ");
	            }
	            System.out.print(" | ");
	            System.out.print(round(Tablo[i][1], 2));
	            for (int j = 0; j < (maxlentgth - String.valueOf(round(Tablo[i][1], 2)).length()); j++) {
	                System.out.print(" ");
	            }
	            System.out.print(" | ");
	            System.out.print(round(Tablo[i][2], 2));
	            for (int j = 0; j < (maxlentgth - String.valueOf(round(Tablo[i][2], 2)).length()); j++) {
	                System.out.print(" ");
	            }
	            System.out.print(" | ");
	            System.out.print(round(Tablo[i][3], 2));
	            for (int j = 0; j < (maxlentgth - String.valueOf(round(Tablo[i][3], 2)).length()); j++) {
	                System.out.print(" ");
	            }
	            System.out.println(" |");
	            SeperatorLine(maxlentgth, "=");
	        }
	
	        System.out.println("nnAçıklama:");
	        System.out.println("OBZ: Ortalama Bekleme Zamanı");
	        System.out.println("OTZ: Ortalama Tamamlanma Zamanı");
	        System.out.println("OCZ: Ortalama Cevaplama Zamanı");
	        System.out.println("TZ : Tamamlanma Zamanı");
	    }
	
	    public static void SeperatorLine(int maxLentgh, String character) {
	        int repeat = 11 + (4 * maxLentgh) + (3 * 3) + 2;
	        for (int i = 0; i < repeat; i++) {
	            System.out.print(character);
	        }
	        System.out.println("");
	    }
	
	    public static double round(double value, int places) {
	        if (places < 0) {
	            throw new IllegalArgumentException();
	        }
	
	        BigDecimal bd = new BigDecimal(value);
	        bd = bd.setScale(places, RoundingMode.HALF_UP);
	        return bd.doubleValue();
	    }
	
	}
	
	//0:Varış
	//1:Patlama
	//2:Bekleme
	//3:Toplam
	//4:Yapildi
	//5:Sıra
	//6:İndis
	//7:Kalan Süre
	//8:Oncelik
	
	//0:Ortalama Bekleme Zamanı
	//1:Ortalama Tamamlanma Zamanı
	//2:Ortalama Cevap Zamanı
	//3:Tamamlanma Zamanı
	


Yorumlar

Twitter'da Ben!

Yükleniyor...