操作系统基于C语言的时间片轮转算法模拟

好的，时间片轮转算法是一种常见的调度算法，用于实现多任务处理。下面是一个基于C语言的时间片轮转算法模拟：

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

#define MAX_PROCESS 10
#define TIME_QUANTUM 2

struct process {
    int pid;
    int burst_time;
    int remaining_time;
};

void simulate_rr(struct process *proc, int n) {
    int i, j, time = 0;
    int complete = 0, start_time = 0, end_time, turnaround_time = 0, waiting_time = 0;
    int *flag = (int*)malloc(n * sizeof(int));
    struct process *queue = (struct process*)malloc(n * sizeof(struct process));

    for (i = 0; i < n; i++) {
        flag[i] = 0;
        queue[i] = proc[i];
    }

    while (complete < n) {
        for (i = 0; i < n; i++) {
            if (queue[i].remaining_time > 0) {
                if (queue[i].remaining_time > TIME_QUANTUM) {
                    time += TIME_QUANTUM;
                    queue[i].remaining_time -= TIME_QUANTUM;
                } else {
                    time += queue[i].remaining_time;
                    queue[i].remaining_time = 0;
                    complete++;
                    end_time = time;
                    turnaround_time += end_time - queue[i].burst_time;
                    waiting_time += end_time - queue[i].burst_time - start_time;
                }
            }
        }

        for (i = 0; i < n; i++) {
            if (queue[i].remaining_time > 0 && flag[i] == 0) {
                flag[i] = 1;
                start_time = time;
            }

            if (queue[i].remaining_time == 0 && flag[i] == 1) {
                flag[i] = 2;
            }
        }

        int k = 0;
        for (i = 0; i < n; i++) {
            if (flag[i] == 2) {
                queue[k++] = queue[i];
            }
        }

        while (k < n) {
            for (i = 0; i < n; i++) {
                if (queue[i].remaining_time > 0 && flag[i] == 0) {
                    flag[i] = 1;
                    start_time = time;
                    queue[k++] = queue[i];
                    break;
                }
            }
        }
    }

    printf("Average Turnaround Time: %.2f\n", (float)turnaround_time / n);
    printf("Average Waiting Time: %.2f\n", (float)waiting_time / n);

    free(flag);
    free(queue);
}

int main() {
    int i, n;
    struct process proc[MAX_PROCESS];

    printf("Enter the number of processes: ");
    scanf("%d", &n);

    for (i = 0; i < n; i++) {
        printf("Enter the burst time for process %d: ", i+1);
        scanf("%d", &proc[i].burst_time);
        proc[i].remaining_time = proc[i].burst_time;
        proc[i].pid = i+1;
    }

    simulate_rr(proc, n);

    return 0;
}

在这个模拟中，我们定义了一个 `struct process` 结构体来表示每个进程，包括进程ID、执行时间和剩余时间。`simulate_rr` 函数实现了时间片轮转算法的逻辑。我们使用一个 `flag` 数组来标记每个进程是否已经执行完成，使用一个队列来保存未完成的进程。在每次循环中，我们遍历队列中的进程，执行一个时间片，如果进程仍然未执行完成，则将其重新加入队列。每当一个进程执行完成，我们计算其完成时间、周转时间和等待时间，并将其从队列中删除。最后计算平均周转时间和平均等待时间，并释放动态分配的内存。

这个模拟仅供参考，实际应用中可能需要根据具体情况进行调整。