Question

我目前正着手使用FCFS和Round Robin算法模拟进程调度程序。

首先，我想使输入的解析尽可能简单......

我有一些结构来保存特定信息。该计划的工作原理如下：

my_project FCFS in.file
OR
my_project RR 2 in.file

in.file看起来如下：

./Job1.txt
./Job2.txt
./Job3.txt
./Job4.txt

所以我想处理这个输入文件并订购作业。

文本文件如下所示。

10
1fi
if i < 3 i=i+1 goto 8
3sdkfj
4ksdkk
5kdkfk
6kdkjf
7dkjkfd
if k < 2 k=k+1 goto 2
9dkkf
10dku
if j < 2 j=j+1 goto 2

除第一行（表示此作业的开始时间）和以if开头的行外，所有行都没有意义。即如果我＆lt; 3 i = i + 1 goto 4表示只要i小于3就跳转到line4。

所以基本上我想通过上面的命令行解析输入文件，并按开始时间（第一行）排序作业。我真的希望尽可能高效地完成这一步。到目前为止，我已经编写了以下代码：

/* I/O Files */ 
static char *inputFile;
static FILE *input;

/*Scheduled jobs indexed by PID*/
struct job list[20];

/* the next job to schedule */
static struct job *job_next = NULL;

/* Time */
time clock;

/*Initialises job list* /
static void initialise_list(void) {
     for(int i = 0; i < sizeof(job_list); i++) {
        job_list[i].params.pid = -1;
    }
}

/ **从输入文件中读取和解析输入* / static void parse_input（void）{

char buffer[BUFSIZ];
unsigned int jobs;

struct job *current;

jobs = 0;

initialise_list();

/** Read input file **/
while( fgets(buffer, sizeof(buffer), input)) {
    time start, finish;
    pid job;        

    //if(buffer[0] == '#') {
    //  continue;
    //}

    sscanf(buffer, "Job%d%ld", &job, &start);

        if(start < 0) {
            fprintf(stderr, "Job start time must be greater than or equal to 0,     found %ld.\n", start);
            exit(EXIT_FAILURE);
        }

        if(finish <= 0) {
            fprintf(stderr, "Job finish time must be greater than 0, found %ld.      \n", arrival);
            exit(EXIT_FAILURE);
        }

        current = &list[job];

        current->parameters.pid = job;
        current->parameters.start = start;


        jobs++;


}    


 int main(int argc, char **argv) {

    /* Open input and output files */
    for(int i = 0; i < argc; i++) {
        if(strcmp(argv[i], "in.file") {
            inputFile = argv[i];    
            input = fopen(inputFile,"r");
        }
    }
    if(!inputFile) {
        exit(EXIT_FAILURE);
    }
    parse_input();
    fclose;
    return EXIT_SUCCESS;
}

到目前为止

使用结构。

/**
 * Simulation of a process scheduler
*/

#ifndef SCHEDULER_H_
#define SCHEDULER_H_

#include <stddef.h>


/* types */
/** units of time */
typedef long time;
/** process identifier */
typedef int pid;

/** Information about a job of interest to the task scheduler */
struct job_data {

/* pid of this process */
    pid pid;
    /* time process starts */
    time start;
    /* time needed to finish */
    time finish;
    /* time spent processing so far */
    time scheduled;
    /* size of the process */
    size_t size;

};

struct job {

    /* Various parameters used by the scheduler */
    struct job_data parameters;
    /* next job to be scheduled */
    struct job *next;


};

最后，我希望能够按照开始时间顺序对作业进行排序，以便它们可以通过特定算法进行调度。

所以我需要有关如何传递输入文件的帮助。在文件中读取作业并获得开始时间和顺序，然后启动＆＃39; tick＆＃39;时间，即文本文件的第一行。

任何帮助都会很棒!!

Answer 1

我不知道你的问题是什么（你似乎已经发布了你正在做的事情的描述而没有提出任何要求）。因此，我的回答不能成为答案，所以我只是以“希望有用”的方式絮絮叨叨。

在真实系统中;不同的任务在不同的时间开始运行，在不同的时间阻塞以等待不同的事情（并且在他们等待发生的事情时被解锁），并最终终止/退出。

除此之外还有一些高级功能;像显式任务优先级控制（例如“nice（）”），分组任务，CPU时间配额等。我不确定你是否想要担心这些事情。

您不需要实现BASIC的最小子集（使用变量，循环等）来实现任何这一点，并且尝试这样做只会增加无意义的复杂性。每个文件都可以是一个简单的线性列表。例如：

123         ;Starting time
r22         ;Task runs for 22 ticks
s23         ;Task blocks due to "sleep()" for 23 seconds
r4          ;Task runs for 4 ticks
f4          ;Task blocks waiting for "4 units" of file IO (how quickly it unblocks depends on file system load)
r32         ;Task runs for 32 ticks
n8          ;Task blocks until it receives 8 packets from network
r22         ;Task runs for 22 ticks
            ;Task terminates

您可以随时添加命令。例如，从“r”命令开始，然后添加“因睡眠而被阻止”等。最后，您可以添加“任务生成新任务”和“任务等待孩子退出”等任务，以及“任务”发送一些东西（通过.tipe，socket，等等）解锁另一个任务“等等。

你会注意到（在我的例子中）所有命令都是“操作码，即时”形式。这是故意的 - 它使解析变得简单（获取字符，获取整数，将它们添加到数组或链表中）。

Process Scheduler Simulation解析输入

1 个答案: