round_robin c++实现

Round-robin（轮流调度）是一种常见的 CPU 调度算法，它按照时间片轮流分配 CPU 时间给每个进程。下面是一个简单的 C++ 实现：

#include <iostream>
#include <queue>
using namespace std;

struct Process {
    string name;
    int burst_time;
    int remaining_time;
};

void round_robin(vector<Process>& processes, int time_quantum) {
    int n = processes.size();
    queue<Process> q;
    int current_time = 0;
    int total_waiting_time = 0;
    int total_turnaround_time = 0;
    int completed_processes = 0;

    for (int i = 0; i < n; i++) {
        processes[i].remaining_time = processes[i].burst_time;
    }

    q.push(processes[0]);
    int i = 1;

    while (completed_processes < n) {
        Process p = q.front();
        q.pop();

        if (p.remaining_time > time_quantum) {
            p.remaining_time -= time_quantum;
            current_time += time_quantum;
        } else {
            current_time += p.remaining_time;
            p.remaining_time = 0;
            completed_processes++;
            total_waiting_time += current_time - p.burst_time;
            total_turnaround_time += current_time;
        }

        while (i < n && processes[i].burst_time <= current_time) {
            q.push(processes[i]);
            i++;
        }

        if (p.remaining_time > 0) {
            q.push(p);
        }
    }

    cout << "Average waiting time: " << (double)total_waiting_time / n << endl;
    cout << "Average turnaround time: " << (double)total_turnaround_time / n << endl;
}

int main() {
    vector<Process> processes = {{"P1", 10}, {"P2", 5}, {"P3", 8}, {"P4", 7}};
    int time_quantum = 2;
    round_robin(processes, time_quantum);
    return 0;
}

在上面的代码中，我们定义了一个 Process 结构体来保存进程的名称和执行时间。round_robin 函数接受一个包含所有进程的 vector 和时间片大小 time_quantum 作为输入，并输出平均等待时间和平均周转时间。在函数中，我们首先初始化每个进程的 remaining_time 为其 burst_time。然后，我们将第一个进程加入队列中，并从队列中取出进程进行执行。如果进程的 remaining_time 大于时间片大小，则将其 remaining_time 减去时间片大小并将其放回队列中。否则，我们将进程的 remaining_time 设为 0，记录完成进程数量、等待时间和周转时间，并将其从队列中删除。接着，我们将所有已到达但未执行的进程加入队列中，然后将队列中的下一个进程取出进行执行。最后，我们输出平均等待时间和平均周转时间。