FCFS 和 SRT 处理器算法计算

Question

我有一个包含 500 个作业的作业队列，其中包含 String jobName、intarrivalTime、int cpuTime 和 String pageFaults（对于 pageFaults，它在文件中看起来像这样......“”12、25、100、120 "" 并且它作为字符串被读入）。我必须计算以下...

1)吞吐量 = ?

2)平均等待时间=开始时间-到达时间

3) 平均周转时间 = cpuTime + waitingTime + finishTime - 到达时间

4) CPU 空闲时间 = ?

-startTime = ?

-finishTime = ?

吞吐量、CPU 空闲时间、startTime 和 finishTime 的计算方法是什么？

我的平均等待时间和平均周转时间计算是否正确？

另外，我该如何对这些计算进行编码？

这些都是使用先到先服务和最短剩余时间算法完成的。

这是我目前所拥有的，

头等舱：

我已经开始遍历 ArrayList 并对部分计算进行编码，但这是我能做到的。

import java.io.File;
import java.util.ArrayList;
import java.util.Scanner;
import java.io.IOException;

public class TextFile
 {
  public static void main(String[] args) throws IOException
  {
   double startTime = (0.0);
   double finishTime = (0.0);

   //double throughput = (0.0);
   double waitingTime = (0.0);
   double turnaroundTime = (0.0);
   //double cpuIdleTime = (0.0);

   String jobName = " ";
   int arrivalTime = (0);
   int cpuTime = (0);
   String pageFault = " ";

   //DataObject object = new DataObject(jobName, arrivalTime, cpuTime, pageFault);

   Scanner input = new Scanner(new File("JobQueue.txt"));

   ArrayList<DataObject> list = new ArrayList<DataObject>(); 

   while(input.hasNext())
    {
     jobName = input.next();
     arrivalTime = input.nextInt();
     cpuTime = input.nextInt();
     pageFault = input.next();

     DataObject data = new DataObject(jobName, arrivalTime, cpuTime, pageFault);
     list.add(data);
    }

   //Calculations for FCFS

    for (DataObject data : list)
    {
     startTime =

     finishTime =

     waitingTime = startTime - arrivalTime;

     turnaroundTime = cpuTime + waitingTime + finishTime - arrivalTime;


    }// compute throughput, average waiting time, etc

   System.out.print(list);//Test output to ensure array list is working

   System.out.printf("%.2f\n", turnaroundTime);

   // compute throughput, average waiting time, etc...
   input.close();
   }
  }

二等：

public class DataObject
{
 private String jobName;
 private int arrivalTime;
 private int cpuTime;
 private String pageFault;

 public DataObject(String job, int arrival, int cpu, String interrupt)
 {
  jobName = job;
  arrivalTime = arrival;
  cpuTime = cpu;
  pageFault = interrupt;
 }

 public void setjobName(String job)
 {
  jobName = job;
 }

 public String getJobName()
 {
  return jobName;
 }

 public void setArrivalTime(int arrival)
 {
  arrivalTime = arrival;
 }

 public int getArrivalTime()
 {
  return arrivalTime;
 }

 public void setcpuTime(int cpu)
 {
  cpuTime = cpu;
 }

 public int getcpuTime()
 {
  return cpuTime;
 }

 public void setPageFault(String interrupt)
 {
  pageFault = interrupt;
 }

 public String getPageFault()
 {
  return pageFault;
 }

 public String toString()
 {
  return String.format("\n%s %d %d %s\n", getJobName(), getArrivalTime(), getcpuTime(), getPageFault()); 
 }
}

Answer 1

系统的吞吐量为：

吞吐量 = 完成的进程数/（时间单位）。 我所说的时间单位是指完成分子中的进程数所需的时间。

CPU 空闲时间 很容易理解，正如它所说的，它是 CPU 保持空闲即不执行任何任务的时间。前任。一个进程在时间 t 完成完成，一个新进程在 t+4 进入，因此 CPU 在这期间保持空闲。

开始时间是进程在CPU中开始执行的时间，并不是进程的到达时间。

完成时间整个过程的执行结束。

等待时间 - 进程在运行队列中花费的平均时间。 对于等待时间，您已考虑waiting time as the start time - arrival time。这在您使用的程序中是正确的，即 FCFS 和最短剩余时间优先（考虑没有时间切片）
有时会使用时间片，并以循环方式对进程进行寻址，从而为每个进程提供固定的处理器时间片。所以使用公式Waiting time = Finish time - Arrival time - CPU time 似乎更充分的证明，也适用于你的方法。

周转时间 - 从提交流程到完成的平均时间。您可以使用Turnaround time = finish time - start time 轻松计算此值

如果您需要平均值，只需计算每个进程然后将总和除以进程数（简单平均值）

这是一个链接，其中给出了所有方法的算法。检查http://www.read.seas.harvard.edu/~kohler/class/05s-osp/notes/notes5.html 在您的编码中获得良好的开端:-)