轮转调度(Round Robin)代码：周转时间等计算错误排查求助

任务背景 #

• 从CSV文件计算作业调度的平均周转时间、平均等待时间及中断次数
• CSV格式规则：首行为各作业的到达时间（arrival times），其余行数值求和得到对应作业的执行时间（burst time）

原代码问题说明 #

提供的Round Robin调度代码存在以下逻辑错误：

1. 未考虑作业到达时间：初始直接将所有作业加入队列，忽略了作业未到达时不能参与调度的规则
2. 完成时间计算错误：直接用currentTime作为作业完成时间，未处理作业到达时间晚于当前时间的情况
3. 周转时间、等待时间推导逻辑不严谨：基于错误的完成时间计算，导致结果偏差
4. 中断次数统计不准确：将未完成作业重新入队都计入中断，实际只有当时间片耗尽被迫切换时才应计数

修正后的代码实现 #

#include <queue>
#include <algorithm>
#include <climits>

// 假设已定义全局/局部变量：
// int arrivalTimes[MAX_COLS];    // 作业到达时间数组
// int burstTimes[MAX_COLS];      // 作业总执行时间数组
// int finishTimes[MAX_COLS];     // 新增：作业完成时间数组
// double turnaroundTimes[MAX_COLS];
// double waitingTimes[MAX_COLS];
// int interrupts = 0;
// int colCount;                  // 作业数量
// int quantum;                   // 时间片大小

// 实现Round Robin调度
void roundRobinScheduling() {
    std::queue<int> jobQueue;
    int remainingBurstTimes[MAX_COLS];
    bool isInQueue[MAX_COLS] = {false}; // 标记作业是否已在队列中，避免重复入队
    int currentTime = 0;
    int completedJobs = 0;

    // 初始化剩余执行时间与完成时间
    for (int i = 0; i < colCount; ++i) {
        remainingBurstTimes[i] = burstTimes[i];
        finishTimes[i] = 0;
    }

    while (completedJobs < colCount) {
        // 将当前时间已到达、未完成且未入队的作业加入队列
        for (int i = 0; i < colCount; ++i) {
            if (arrivalTimes[i] <= currentTime && remainingBurstTimes[i] > 0 && !isInQueue[i]) {
                jobQueue.push(i);
                isInQueue[i] = true;
            }
        }

        if (jobQueue.empty()) {
            // 无作业可执行，直接推进时间到下一个作业的到达时间
            int nextArrival = INT_MAX;
            for (int i = 0; i < colCount; ++i) {
                if (remainingBurstTimes[i] > 0 && arrivalTimes[i] > currentTime) {
                    nextArrival = std::min(nextArrival, arrivalTimes[i]);
                }
            }
            currentTime = nextArrival;
            continue;
        }

        int currentJob = jobQueue.front();
        jobQueue.pop();
        isInQueue[currentJob] = false;

        // 处理作业到达时间晚于当前时间的情况
        if (currentTime < arrivalTimes[currentJob]) {
            currentTime = arrivalTimes[currentJob];
        }

        // 计算本次可执行的时间：不超过剩余执行时间与时间片的最小值
        int executeTime = std::min(quantum, remainingBurstTimes[currentJob]);
        currentTime += executeTime;
        remainingBurstTimes[currentJob] -= executeTime;

        if (remainingBurstTimes[currentJob] > 0) {
            // 作业未完成，重新加入队列等待下一轮调度
            jobQueue.push(currentJob);
            isInQueue[currentJob] = true;
            // 仅当时间片耗尽时统计中断（符合Round Robin调度的中断定义）
            if (executeTime == quantum) {
                interrupts++;
            }
        } else {
            // 作业完成，记录完成时间并计算周转、等待时间
            finishTimes[currentJob] = currentTime;
            completedJobs++;
            turnaroundTimes[currentJob] = finishTimes[currentJob] - arrivalTimes[currentJob];
            waitingTimes[currentJob] = turnaroundTimes[currentJob] - burstTimes[currentJob];
        }
    }

    // 计算平均周转时间与平均等待时间
    double totalTurnaroundTime = 0;
    double totalWaitingTime = 0;
    for (int i = 0; i < colCount; ++i) {
        totalTurnaroundTime += turnaroundTimes[i];
        totalWaitingTime += waitingTimes[i];
    }
    double averageTurnaroundTime = totalTurnaroundTime / colCount;
    double averageWaitingTime = totalWaitingTime / colCount;
}

修正点说明 #

1. 作业到达时间处理：每次循环先筛选当前时间已到达的作业加入队列，避免未到达作业提前参与调度
2. 空闲时间优化：当队列无作业时，直接将当前时间推进到下一个作业的到达时间，避免无效空循环
3. 完成时间准确记录：新增finishTimes数组，精准记录每个作业的实际完成时间
4. 周转/等待时间修正：基于正确的完成时间计算周转时间（完成时间-到达时间），等待时间（周转时间-总执行时间）
5. 中断次数修正：仅当时间片耗尽（执行时间等于设定的quantum）时统计中断，符合Round Robin调度的中断逻辑

内容的提问来源于stack exchange，提问作者Nozakai