GATE-CS-2002 Question 3

本篇介绍GATE-CS-2002的问题3，是一道涉及操作系统和进程调度算法的问题。

问题描述

有 $n$ 个进程，每个进程需要 $p_i$ 的处理时间和 $q_i$ 的IO时间。 进程调度算法需要满足以下条件：

• 每个进程必须被调度
• 每个进程必须在开始执行前获得 $q_i$ 的IO时间
• 每个进程必须在完成后立即释放处理器

这里有两种进程调度算法：

1. Round Robin Algorithm（轮流调度算法）：时间片长度为 $t$ 时间单位。如果一个进程需要更多时间来完成，它将被排队等待后续的时间片。如果进程完成或者需要IO，则此进程将进入下一个周期（即下一个时间片）。

2. Shortest First Algorithm（最短进程优先算法）：选择下一个处理时间最短的进程，如果有多个进程的处理时间相同，则按照他们的 $ID$ 排序。

编写程序来模拟这两种算法并比较其平均等待时间。程序将接收以下数据作为输入：

• $n$：进程数量
• $pi_1, pi_2, ..., pi_n$：每个进程的处理时间
• $qi_1, qi_2, ..., qi_n$：每个进程的IO时间
• $t$：时间片长度

解题思路

对于本问题，我们需要模拟两种进程调度算法：

• 轮流调度算法
• 最短进程优先算法

我们需要根据输入数据创建进程，然后在两种算法下执行这些进程。最后，我们将输出两种算法的平均等待时间，并比较它们。

下面是两种算法的实现：

轮流调度算法

// 进程等待队列
queue<Process> waitingQueue;
// 进程执行队列
queue<Process> executionQueue;

// 创建进程
for (int i = 0; i < n; i++) {
    Process p(i, pi[i], qi[i]);
    waitingQueue.push(p);
}

// 这个时间片的起始时间
int currentTime = 0;

while (!waitingQueue.empty() || !executionQueue.empty()) {

    // 把等待队列中的进程加入执行队列中
    while (!waitingQueue.empty()) {
        Process process = waitingQueue.front();
        if (process.QI <= currentTime) {
            executionQueue.push(process);
            waitingQueue.pop();
        } else {
            break;
        }
    }

    if (!executionQueue.empty()) {
        Process process = executionQueue.front();
        executionQueue.pop();

        if (process.PI <= t) {
            currentTime += process.PI;
            for (int i = currentTime - process.PI; i < currentTime; i++) {
                process.logs[i] = process.ID;
            }
        } else {
            currentTime += t;
            process.PI -= t;
            for (int i = currentTime - t; i < currentTime; i++) {
                process.logs[i] = process.ID;
            }
            waitingQueue.push(process);
        }
    } else {
        currentTime++;
    }
}

// 计算平均等待时间
int totalWaitingTime = 0;
for (int i = 0; i < n; i++) {
    Process process = processes[i];
    totalWaitingTime += process.waitingTime;
}
double averageWaitingTime = (double)totalWaitingTime / n;

最短进程优先算法

// 创建进程
for (int i = 0; i < n; i++) {
    Process p(i, pi[i], qi[i]);
    processes.push_back(p);
}
sort(processes.begin(), processes.end(), Process::compare);

// 这个时间的起始时间
int currentTime = 0;

while (!processes.empty()) {

    Process process = processes.front();
    processes.erase(processes.begin());

    currentTime += process.PI;
    for (int i = currentTime - process.PI; i < currentTime; i++) {
        process.logs[i] = process.ID;
    }

}

// 计算平均等待时间
int totalWaitingTime = 0;
for (int i = 0; i < n; i++) {
    Process process = processes[i];
    totalWaitingTime += process.waitingTime;
}
double averageWaitingTime = (double)totalWaitingTime / n;

总结

本问题需要掌握操作系统中进程调度算法，特别是轮流调度算法和最短进程优先算法。我们需要编写程序来模拟这两种算法，并比较它们的平均等待时间。此外，我们还需要考虑如何处理输入数据和创建程序。最后，我们通过比较运行时间和计算结果来确认程序的正确性。