Question

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

1）吞吐量=？

2）平均等待时间= startTime - 到达时间

3）平均周转时间= cpuTime + waitingTime + finishTime - arrivalTime

4）CPU空闲时间=？

-startTime =？

-finishTime =？

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

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

另外，我如何编码这些计算？

这些都是使用First Come First Serve和Shortest Remaining Time算法完成的。

这是我到目前为止所拥有的，

头等舱：

我已经开始迭代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 在你的编码中有一个良好的开端： - ）

FCFS和SRT处理器算法计算

1 个答案: