0

我被困在我目前的任务上，主要是因为我在很长一段时间没有使用 C 之后对 C 不是很精通。

我们需要制作一个 FCFS（先到先服务）调度算法模拟器，它可以简单地遍历每个流程将发生的所有时间事件，并在它们完成流程和周转时间时打印出来。

我知道这个过程是如何工作的，但是将它实现到 C 或 C++ 程序中让我很困惑，我什至不知道从哪里开始。

我们将从标准输入获取输入，格式如下：

第一行：（# of cpus）（# of processes）（量子大小）

进程行：（ID）（优先级）（提交时间）（所需cpu时间）（需要I/O之前的计算时间）（每次计算的I/O时间）

根据从第一行定义的流程数量，需要更多流程线。

示例输入可能是：

1 1 10

1 1 0 20 5 50

长话短说，任何人都可以向我指出一些可以提供帮助的资源或示例源，其中包括多个 CPU 的可能性。或者，如果你们甚至可以帮助我入门，我将非常感激。我不是要你做整个事情，只是帮助我开始，这样我就会知道从那里去哪里。

谢谢！

编辑：

这是我到目前为止所得到的。这是非常初级的，但到目前为止我只是想完成这件事，就像我说的，我对 C 非常生疏（反正我不是精通它）：

int main()
{
    //process *  proc = (process *)malloc(100*sizeof(process));
    process proc[25];
    CPU cp[4];
    int count = 0;
    //int * input = malloc(sizeof(int) * 100);
    int input = 0;
    int cpus = 0;
    int processes = 0;
    int quantum = 0;
    int processLoop = 0;
    int x = 0;

    int id = 0;
    int pri = 0;
    int sub = 0;
    int cptime = 0;
    int compute = 0;
    int itime = 0;
    int complete = 0;


    while(1 == scanf("%d", &input))
    {
            if(count < 0)
                    break;
            if(count == 0)
            {
                    cpus = input;
            }
            else if(count == 1)
            {
                    processes = input;
            }
            else if(count == 2)
            {
                    quantum = input;
            }
            else
            {
                    if(count == 3)
                    {
                            proc[processLoop].ID = input;
                    }
                    else if(count == 4)
                    {
                            proc[processLoop].Priority = input;
                    }
                    else if(count == 5)
                    {
                            proc[processLoop].subTime = input;
                    }
                    else if(count == 6)
                    {
                            proc[processLoop].cpuTime = input;
                    }
                    else if(count == 7)
                    {
                            proc[processLoop].computeTime = input;
                    }
                    else if(count == 8)
                    {
                            proc[processLoop].ioTime = input;
                            proc[processLoop].isCompleted = 0;
                            processLoop++;
                            if(processLoop == processes)
                            {
                                    count = -1;         //Leaves possibility for multiple simulations in one run
                            }
                            else
                            {
                                    count = 2;          //Repeats if multiple processes are detected
                            }
                    }
            }
            count++;

    }

    for(x = 0; x < cpus; x++)
    {
            cpu[x].idle = 0;
    }

    return 0;
}

是的，超级原始且效率不高，但它读取所有数字并以 EOF 或任何非数字出现时结束。也是负数。我将 proc 设置为 25 个数组的原因是因为这是我们的教练所说的数量也会增加的限制。对于 CPU，他说最多将使用四个，所以我只是做了一个数组，主要是因为我对指针很糟糕。

现在我已经将数据放入了我的数组中，我需要按 subTime 对我的 proc 数组进行排序并开始进行实际计算。这部分会有多糟糕，尤其是在我糟糕的设置下？

4

2 回答 2

3

为您实现目标的行动计划：

  1. 为进程和 CPU 定义数据结构
  2. 扫描所有输入。初始化所有数据结构。
  3. 为单 CPU 开发代码。验证它是否正常工作
  4. 修改多 CPU 的代码。验证它是否有效

步骤1：

为 Process 定义数据结构。对于 C，您可以像这样使用结构：（对于 C++ 使用类）

typedef struct process
 {
       int ID;
       int Priority;
       int time_of_submission;
       int cpu_time_required;
       int compute_time_before_IO;
       int IO_time_per_compute;
       int isCompleted; // if 1 means its complete. at start, its value is 0
 }process;

对于 CPU，维护一个数组，它可以告诉你它的空闲或分配了一些进程。

typedef struct CPU
 {
       int idle;     // if set to 1, then its idle. 
                     // If set to 0, then its working on a process
       process *next; // points to the process that CPU is executing
                      // points to null if CPU is idle.
 }CPU;

第2步：

使用scanf扫描所有输入，process为所有输入进程填充 ' ' 数组。为了使您的工作更轻松，请process根据根据 FCFS 决定调度的字段对 ' ' 数组进行排序。（例如 time_of_submission、所需的 cpu 时间、优先级.. 我将其留给您用于其他领域）

初始化' CPU'的数组。

第三步： 开发单CPU代码。验证它是否正常工作。

我认为您对多 CPU 方案有疑问。所以暂时不要考虑多 CPU 的概念。在纸上写下单 CPU 的逻辑。创建伪代码。然后从中创建一个 C（或 C++）代码。每当卡在语法上时，请在谷歌上搜索如何做到这一点并继续前进。

第四步： 修改多CPU的代码。验证它是否有效

想想多 CPU 会发生什么。

Loop over all CPUs. 
    For CPU[i], check its status 

    if its idle
         assign it a process..similar logic as for single CPU case (step 3)
    if its not idle
         if its corresponding process is finished, set status of CPU to idle.

在这里完成后，您可以对其进行修改以具有要考虑的进程的优先级。

于 2012-04-12T05:06:09.213 回答
0 
#include <iostream>
using namespace std;
//fcfs algorithm in c++

//Here is the simple example involving 3 process;
//All process are assumed to be arrived at same time=0 seconds

int main()
{
    //arrival time of each proces=0;
    //all arive at same time
    //arrival time is assumed to be same
    int process[10]={1,2,3};
    int bt[10]={10,5,8};
    int wt[10];
    int tt[10];
    wt[0]=0;
    //waiting time of each process;

    for(int i=1;i<3;i++){
        wt[i]=bt[i-1]+wt[i-1];

    }
    //turnaround time calculation for each processs
    for(int i=0;i<3;i++){
        tt[i]=wt[i]+bt[i];

    }
    float awt=0;//average waiting time
    float att=0;//average turnaround time;
    for(int i=0;i<3;i++){
        awt=awt+wt[i];
        att=att+tt[i];

    }
    for(int i=0;i<3;i++){
        cout<<"process"<<i+1<<"--->"<<" "<<bt[i]<<" "<<wt[i]<<" "<<tt[i]<<endl;


    }
    cout<<"Awerage waiting time"<<awt/3<<endl;
    cout<<"average turnaround time"<<att/3<<endl;




}
于 2018-03-12T15:42:34.547 回答