SHARE
TWEET

Untitled

a guest Dec 5th, 2019 102 Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  1. import java.util.*;
  2. import java.util.Comparator;
  3. import java.util.LinkedList;
  4. import java.util.Queue;
  5.  
  6. public class Scheduler {
  7.    
  8.     Comparator<Process> comparator = new Comparator<Process>()
  9.     {
  10.         public int compare(Process a, Process b)
  11.         {
  12.             return a.arrivalTime < b.arrivalTime ? -1 : a.arrivalTime > b.arrivalTime ? 1 : 0;
  13.         }
  14.     };
  15.     Comparator<Process> priorityComparator = new Comparator<Process>()
  16.     {
  17.         public int compare(Process a, Process b)
  18.         {
  19.             return a.priority < b.priority ? 1 : a.priority > b.priority ? -1 : 0;
  20.         }
  21.     };
  22.    
  23.    
  24.     Average priorityScheduling (ArrayList<Process> processes) {
  25.        
  26.         Collections.sort(processes, comparator);
  27.        
  28.         PriorityQueue<Process> pq = new PriorityQueue<Process>(processes.size(), priorityComparator);
  29.  
  30.         int time = processes.get(0).arrivalTime;
  31.         int i = 0;
  32.         while (true) {
  33.             if(pq.isEmpty() && i == processes.size()) break;
  34.             while(i < processes.size() && processes.get(i).arrivalTime == time) {
  35.                 pq.add(processes.get(i));
  36.                 ++i;
  37.             }
  38.             while (!pq.isEmpty()) {
  39.                 ++time;//context swithcing
  40.                 while(i < processes.size() && processes.get(i).arrivalTime == time) {
  41.                     pq.add(processes.get(i));
  42.                     ++i;
  43.                 }
  44.                 Process process = pq.poll();
  45.                 process.waitingTime = time - process.arrivalTime;
  46.                 time += process.burstTime;
  47.                 while(i < processes.size() && processes.get(i).arrivalTime == time) {
  48.                     pq.add(processes.get(i));
  49.                     ++i;
  50.                 }
  51.             }
  52.             ++time;
  53.         }
  54.         double averageWaitingTime = 0, averageTurnaroundTime = 0;
  55.         i = 0;
  56.         while(i < processes.size()){
  57.             processes.get(i).executionOrder = i+1;
  58.             processes.get(i).turnaroundTime += processes.get(i).waitingTime;
  59.             averageWaitingTime += processes.get(i).waitingTime;
  60.             averageTurnaroundTime += processes.get(i).turnaroundTime;
  61.             ++i;
  62.         }
  63.         averageWaitingTime /= processes.size();
  64.         averageTurnaroundTime /= processes.size();
  65.         Average average = new Average(averageWaitingTime, averageTurnaroundTime);
  66.         return average;
  67.     }
  68.    
  69.     Average roundRobinScheduling (ArrayList<Process> processes, int timeQuantum) {
  70.        
  71.         Collections.sort(processes, comparator);
  72.        
  73.         Queue<Process> q = new LinkedList<>();
  74.        
  75.         int time = processes.get(0).arrivalTime;
  76.         int i = 0;
  77.         while (true){
  78.             if (q.isEmpty() && i == processes.size()) break;
  79.             while (i < processes.size() && processes.get(i).arrivalTime <= time) {
  80.                 q.add(processes.get(i));
  81.                 ++i;
  82.             }
  83.             while (!q.isEmpty()){
  84.                 ++time;//context swithcing
  85.                 while (i < processes.size() && processes.get(i).arrivalTime <= time) {
  86.                     q.add(processes.get(i));
  87.                     ++i;
  88.                 }
  89.                 Process process = q.poll();
  90.                 process.waitingTime += time - process.arrivalTime;
  91.                 process.burstTime = (timeQuantum >= process.burstTime)?0 :process.burstTime-timeQuantum;
  92.                 time += timeQuantum;
  93.                 while (i < processes.size() && processes.get(i).arrivalTime <= time) {
  94.                     q.add(processes.get(i));
  95.                     ++i;
  96.                 }
  97.                 if (process.burstTime > 0){
  98.                     process.arrivalTime = time;
  99.                     q.add(process);
  100.                 }
  101.             }
  102.             ++time;
  103.         }
  104.         double averageWaitingTime = 0, averageTurnaroundTime = 0;
  105.         i = 0;
  106.         while(i < processes.size()){
  107.             processes.get(i).executionOrder = i+1;
  108.             processes.get(i).turnaroundTime += processes.get(i).waitingTime;
  109.             averageWaitingTime += processes.get(i).waitingTime;
  110.             averageTurnaroundTime += processes.get(i).turnaroundTime;
  111.             ++i;
  112.         }
  113.         averageWaitingTime /= processes.size();
  114.         averageTurnaroundTime /= processes.size();
  115.         Average average = new Average(averageWaitingTime, averageTurnaroundTime);
  116.         return average;
  117.     }
  118.    
  119.     public static void shortesJobFirst(Process PA[],Comparator<Process> c)
  120.     {
  121.         ArrayList<Process> WaitingQueue = new ArrayList<Process>();
  122.         Process running = null;
  123.         int time = 0;
  124.        
  125.         Comparator<Process> comparator = new Comparator<Process>()
  126.         {
  127.             public int compare(Process a,Process b)
  128.             {
  129.                 return a.burstTime < b.burstTime ? -1 : a.burstTime > b.burstTime ? +1 : 0;
  130.             }
  131.         };
  132.        
  133.         int numOfProcesses = 0,nextToQueue = 0;
  134.         while(numOfProcesses<PA.length || WaitingQueue.size() != 0 || running != null)
  135.         {
  136.             while(nextToQueue < PA.length && PA[nextToQueue].arrivalTime == time)
  137.             {
  138.                 int indx = Collections.binarySearch(WaitingQueue,PA[nextToQueue],comparator);
  139.                 if(indx < 0)
  140.                     indx = -(indx + 1);
  141.                 WaitingQueue.add(indx,PA[nextToQueue++]);
  142.                 numOfProcesses++;
  143.             }
  144.            
  145.             if(running == null)
  146.             {
  147.                 if(WaitingQueue.size() > 0)
  148.                     running = WaitingQueue.remove(0);
  149.             }
  150.             else
  151.             {
  152.                 if(WaitingQueue.size() > 0 && running.burstTime == 0)
  153.                     running = WaitingQueue.remove(0);
  154.                 else if(running.burstTime == 0)
  155.                     running = null;
  156.                 else if(WaitingQueue.size() > 0 && WaitingQueue.get(0).burstTime < running.burstTime)
  157.                 {
  158.                     int indx = Collections.binarySearch(WaitingQueue,running,comparator);
  159.                     if(indx < 0)
  160.                         indx = -(indx + 1);
  161.                     WaitingQueue.add(indx,running);
  162.                     running = WaitingQueue.remove(0);
  163.                 }
  164.                 else
  165.                 {
  166.                     running.burstTime--;
  167.                     running.turnaroundTime++;
  168.                 }
  169.             }
  170.            
  171.             for(int i=0;i<WaitingQueue.size();i++)
  172.             {
  173.                 WaitingQueue.get(i).waitingTime++;
  174.                 WaitingQueue.get(i).turnaroundTime++;
  175.             }
  176.            
  177.             time++;
  178.         }
  179.     }
  180.    
  181. }
RAW Paste Data
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy. OK, I Understand
 
Top