基于优先级的调度算法

Question

我开发了一个实现优先级调度算法(优先级调度)的程序。进程总数直接从标准输入中读取，每个进程指定到达时间和执行时间，分别是其优先级。我计算了平均响应时间，分别计算了平均等待时间。

我的实现是最佳的吗？我能换什么？

一个已知的问题是，如果我输入了更多的进程，那么并不是每个进程都会显示在ID列下。

代码：

#include<stdio.h>
struct process
{
    int WT,AT,BT,TAT,PT;
};
struct process a[10];
int main()
{
    int n,temp[10],t,count=0,short_p;
    float total_WT=0,total_TAT=0,Avg_WT,Avg_TAT;
    printf("Enter the number of processes:\n");
if (scanf("%d", &n) == 1) {

    printf("Enter arrival time, execution time and priority\n");
    printf("Arrival Execution Priority\n");
} else {
        printf("Fail\n");
    return 1;
    }

       for(int i=0;i<n;i++)
    {
if(scanf("%d",&a[i].AT)==1){
    } else{
        printf("Fail\n");
        return 1;
        }

        if(scanf("%d",&a[i].BT)==1){
        temp[i]=a[i].BT;
    }

        else{
        printf("Fail\n");
        return 1;
        }

        if(scanf("%d",&a[i].PT)==1){
    }else{
        printf("Fail\n");
        return 1;
        }

    }
a[9].PT=10000;
for(t=0;count!=n;t++)
    {
        short_p=9;
        for(int i=0;i<n;i++)
        {
            if(a[short_p].PT>a[i].PT && a[i].AT<=t && a[i].BT>0)
            {
                short_p=i;
            }
        }
a[short_p].BT=a[short_p].BT-1;
            count++;
            a[short_p].WT=t+1-a[short_p].AT-temp[short_p];
            a[short_p].TAT=t+1-a[short_p].AT;
            total_WT=total_WT+a[short_p].WT;
            total_TAT=total_TAT+a[short_p].TAT;
    Avg_WT=total_WT/n;
    Avg_TAT=total_TAT/n;
    printf("ID WT TAT\n");
    for(int i=0;i<n;i++)
    {
        printf("%d %d\t%d\n",i+1,a[i].WT,a[i].TAT);
    }
    printf("The average waiting time for the process is: %f\n",Avg_WT);
    printf("The average return time of the process is: %f\n",Avg_TAT);
    return 0;
}
```

Answer 1

变量名

在6个月的时间里，一个和两个字母变量名对您或任何需要维护代码的人都没有任何意义。使用描述性变量名称，并使代码尽可能自文档化。

根据需要声明变量

在上世纪70年代和80年代C的原始版本中，变量必须声明在函数的顶部。现在情况不再是这样了，这是一种建议的编程实践，可以根据需要声明变量。在C语言中，该语言不提供变量的默认初始化，因此变量应该作为声明的一部分进行初始化。为了提高可读性和可维护性，每个变量都应该在自己的行上声明和初始化。参见下面示例中的声明。

复杂性

函数main()太复杂(做得太多)。随着程序规模的增加，main()的使用应限于调用解析命令行的函数、调用为处理设置的函数、调用执行程序所需功能的函数以及调用函数以清理程序的主要部分。

这里也有一个叫做单一责任原则的编程原则。单一责任原则指出：

每个模块、类或函数都应该对软件提供的功能的单个部分负责，而该责任应该完全由该模块、类或函数封装。

在main()中至少有3种可能的功能。

• 获取进程计数并检查错误
• 获取与流程相关的值
• 计算和打印结果

if语句中的空then子句增加了代码的复杂性，可以通过反转表达式中的逻辑来简化它们。

        if (scanf("%d", &a[i].AT) != 1) {
            printf("Fail\n");
            return 1;
        }

避免全局变量

很难读、写、调试和维护使用全局变量的程序。程序中的任何函数都可以修改全局变量，因此需要在对代码进行更改之前对每个函数进行检查。在C和C++中，全局变量会影响命名空间，如果它们在多个文件中定义，它们可能导致链接错误。这个堆叠溢出问题的答案提供了更全面的解释。进程a的数组应该在main中定义，并通过引用传递给需要它的函数。

幻数

main()函数中有魔法数字(10，0，1 )，最好是为它们创建符号常量，以使代码更易读和更易于维护。这些数字可以在许多地方使用，只要编辑一行就可以更改它们，从而使维护更容易。令人困惑的代码示例：

    a[9].PT = 10000;    // What is 10,000 and why are you assigning it to a[9].PT?

    return 0;
    return 1;

    struct process [10]

对于return 1或return 0，包括stdlib.h，并使用公共符号常量出口_失效与退出_成功。

对于数组大小，使用以下方法定义符号常量：

#define MAX_PROCESSES 10

这允许您用一行编辑来更改进程的最大数量，如果需要，也可以在for循环中使用它。

代码中的数值常数有时被称为幻数幻数，因为它们没有明显的意义。在堆栈过流上对此进行了讨论。

使用上述建议的

重构代码

这可能不是我解决问题的方法，但我尽可能多地使用您的代码来说明我的意思。与其使用固定大小的数组，我可能会在运行时使用calloc()分配动态数组，这比小的固定大小的数组更方便用户。我所做的一切改变都是为了降低代码的复杂性，并使其更易读和更易于维护。我没有测试我的重构是否有效，它只是一个建议的集合。

#include<stdio.h>
#include<stdlib.h>

#define MAX_PROCESSES 10
struct process
{
    int WT;
    int AT;
    int BT;
    int TAT;
    int PT;
};

int get_process_count()
{
    int process_count = 0;

    printf("Enter the number of processes:\n");
    if (scanf("%d", &process_count) != 1) {
        return 0;
    }

    return process_count;
}

int get_process_data(int process_count, struct process a[MAX_PROCESSES])
{
    printf("Enter arrival time, execution time and priority\n");
    printf("Arrival Execution Priority\n");

    for (int i = 0; i < process_count; i++)
    {
        if (scanf("%d", &a[i].AT) != 1) {
            printf("Fail\n");
            return 1;
        }

        if (scanf("%d", &a[i].BT) != 1) {
            printf("Fail\n");
            return 1;
        }

        if (scanf("%d", &a[i].PT) != 1) {
            printf("Fail\n");
            return 1;
        }
    }

    return 0;
}

void process_and_report_results(int process_count, struct process a[MAX_PROCESSES])
{
    int t = 0;
    int count = 0;
    int short_p = 0;
    float total_WT = 0.0;
    float total_TAT = 0.0;
    float Avg_WT, Avg_TAT;

    a[9].PT = 10000;
    for (t = 0; count != process_count; t++)
    {
        short_p = 9;
        for (int i = 0; i < process_count; i++)
        {
            if (a[short_p].PT > a[i].PT && a[i].AT <= t && a[i].BT > 0)
            {
                short_p = i;
            }
        }

        int temp = a[t].BT;
        a[short_p].BT = a[short_p].BT - 1;
        count++;
        a[short_p].WT = t + 1 - a[short_p].AT - temp;
        a[short_p].TAT = t + 1 - a[short_p].AT;
        total_WT = total_WT + a[short_p].WT;
        total_TAT = total_TAT + a[short_p].TAT;
        Avg_WT = total_WT / process_count;
        Avg_TAT = total_TAT / process_count;

        printf("ID WT TAT\n");
        for (int i = 0; i < process_count; i++)
        {
            printf("%d %d\t%d\n", i + 1, a[i].WT, a[i].TAT);
        }
        printf("The average waiting time for the process is: %f\n", Avg_WT);
        printf("The average return time of the process is: %f\n", Avg_TAT);
    }
}

int main()
{
    struct process a[MAX_PROCESSES];
    int process_count = 0;

    process_count = get_process_count();
    if (process_count < 1)
    {
        return EXIT_FAILURE;
    }

    if (get_process_data(process_count, a) < 1)
    {
        return EXIT_FAILURE;
    }

    process_and_report_results(process_count, a);

    return EXIT_SUCCESS;
}