时间片轮转算法C版
操作系统实验二报告-时间片轮转进程调度算法1
操作系统实验报告实验二时间片轮转进程调度算法学号：班级：姓名:【实验题目】: 时间片轮转进程调度算法【实验目的】通过这次实验, 加深对进程概念的理解, 进一步掌握进程状态的转变、进程调度的策略与对系统性能的评价方法。
【实验内容】问题描述:设计程序模拟进程的时间片轮转RR 调度过程。
假设有n 个进程分别在T1, … ,Tn 时刻到达系统, 它们需要的服务时间分别为S1, … ,Sn 。
分别利用不同的时间片大小q, 采用时间片轮转RR 进程调度算法进行调度, 计算每个进程的完成时间, 周转时间和带权周转时间, 并且统计n 个进程的平均周转时间和平均带权周转时间。
程序要求如下:1）进程个数n ；每个进程的到达时间T 1, … ,T n 和服务时间S 1, … ,S n ；输入时间片大小q 。
2）要求时间片轮转法RR 调度进程运行, 计算每个进程的周转时间, 带权周转时间, 并且计算所有进程的平均周转时间, 带权平均周转时间；3）输出: 要求模拟整个调度过程, 输出每个时刻的进程运行状态, 如“时刻3: 进程B开始运行”等等；4）输出：要求输出计算出来的每个进程的周转时间, 带权周转时间, 所有进程的平均周转时间, 带权平均周转时间。
实现提示:用C++语言实现提示:1）程序中进程调度时间变量描述如下:int ArrivalTime[100];int ServiceTime[100];int PServiceTime[100];int FinishTime[100];int WholeTime[100];double WeightWholeTime[100];double AverageWT,AverageWWT;bool Finished[100];➢2）进程调度的实现过程如下:➢变量初始化；➢接收用户输入n, T1, … ,Tn, S1, … ,Sn；时间片大小q；➢按照时间片轮转RR算法进行进程调度, 计算进程的完成时间、周转时间和带权周转时间；➢计算所有进程的平均周转时间和平均带权周转时间；➢按格式输出调度结果。
用c语言实现时间片轮转调度算法
用c语言实现时间片轮转调度算法时间片轮转调度算法是一种常见的进程调度算法，其主要思想是将所有就绪进程按顺序排列，每个进程分配一个时间片，当时间片用尽后，进程被送到队列的末尾，然后下一个进程被执行。
本文将介绍如何使用C语言实现时间片轮转调度算法。
首先，我们需要定义进程控制块（PCB），包括进程的ID、状态、优先级和时间片等信息。
可以使用结构体来表示PCB，代码如下：```typedef struct PCB {int pid; // 进程IDint status; // 进程状态（就绪、运行、等待、结束） int priority; // 进程优先级int time_slice; // 时间片} PCB;```接下来，我们需要创建一个就绪队列和一个等待队列来存储所有进程。
可以使用链表来实现队列，代码如下：```typedef struct Node {PCB *pcb; // PCB指针struct Node *next; // 指向下一个节点的指针} Node;// 就绪队列Node *ready_queue = NULL;// 等待队列Node *wait_queue = NULL;```然后，我们需要编写一个函数来创建进程并添加到就绪队列中。
该函数接受进程的ID、优先级和时间片作为参数，并返回一个指向新进程PCB的指针。
代码如下：```PCB *create_process(int pid, int priority, int time_slice) {PCB *pcb = (PCB*)malloc(sizeof(PCB));pcb->pid = pid;pcb->status = 0; // 就绪状态pcb->priority = priority;pcb->time_slice = time_slice;// 将新进程添加到就绪队列末尾Node *p = (Node*)malloc(sizeof(Node));p->pcb = pcb;p->next = NULL;if (ready_queue == NULL) {ready_queue = p;} else {Node *q = ready_queue;while (q->next != NULL) {q = q->next;}q->next = p;}return pcb;}```接下来，我们需要编写一个函数来模拟时间片轮转调度算法。
OS原理C语言实现时间片轮转
getthefirst(joblist, i,h);//获得初始执行表，可处理同时到达
printf("最先到达的作业有%d项，为：\n",h[0]);
g=h[0];
for(n=0;n<h[0];n++)
{
joblist[h[n+1]].isreached = 1; //到达，写入执行表
}
if(joblist[h[n]].run_time >=joblist[h[n]].need_time)
{ joblist[h[n]].jobisover=1;
printf("%d号作业执行完毕，",joblist[h[n]].number);
h[0]--;f++; printf("剩余%d项待执行作业\n",h[0]);
joblist[i].wtr_time = 0.00;
joblist[i].start_time=-1;
joblist[i].jobisover=0;
}
printf("there're %d jobs! \n then have a look:\n",i);
printf("%s\t%s\t%s\t%s\n",a,b,c,d);
}
time=w;
for (r=0;r<i;r++)
{if (joblist[r].isreached ==0)
{ if ((joblist[r].reach_time<=time)&&(joblist[r].visited ==0)) // 检查有无到达的作业，添加
c语言时间片轮转调度代码
时间片轮转调度算法是一种操作系统进程调度算法，它是先进先出（FIFO）调度算法的一种改进版本。
以下是一个用C语言实现的时间片轮转调度算法的简单示例：```c#include <stdio.h>#include <stdlib.h>#define QUANTUM 2 // 定义时间片长度#define PROCESSES 5 // 定义进程数量// 进程结构体typedef struct {int process_id;int arrival_time;int burst_time;int remaining_time;int finished;} Process;// 初始化进程队列void init_processes(Process *processes, int processes_num) {for (int i = 0; i < processes_num; i++) {processes[i].process_id = i + 1;processes[i].arrival_time = i % 5 + 1;processes[i].burst_time = 5;processes[i].remaining_time = processes[i].burst_time;processes[i].finished = 0;}}// 时间片轮转调度void round_robin(Process *processes, int processes_num) {int time = 0;int finished_processes = 0;while (finished_processes < processes_num) {for (int i = 0; i < processes_num; i++) {if (processes[i].arrival_time <= time && !processes[i].finished) { if (processes[i].remaining_time > QUANTUM) {processes[i].remaining_time -= QUANTUM;printf("Time %d: Process %d is running\n", time, processes[i].process_id);} else {processes[i].finished = 1;finished_processes++;printf("Time %d: Process %d is finished\n", time, processes[i].process_id);}}}time++;}}int main() {Process processes[PROCESSES];init_processes(processes, PROCESSES);round_robin(processes, PROCESSES);return 0;}```这个示例中，我们定义了一个进程结构体，包括进程ID、到达时间、运行时间、剩余时间和是否完成。
c语言实现基于时间片轮转调度算法
c语言实现基于时间片轮转调度算法以下是基于时间片轮转调度算法的C语言实现示例：```c#include <stdio.h>#include <stdlib.h>typedef struct Process {int pid; // 进程IDint burstTime; // 执行时间int remainingTime; // 剩余执行时间int arrivalTime; // 到达时间int waitingTime; // 等待时间} Process;void timeSliceScheduling(Process processes[], int n, int timeSlice) {int currentTime = 0;int completedProcesses = 0;while (completedProcesses < n) {for (int i = 0; i < n; i++) {if (processes[i].remainingTime > 0) {int executionTime = (processes[i].remainingTime > timeSlice) ? timeSlice : processes[i].remainingTime;processes[i].remainingTime -= executionTime;currentTime += executionTime;if (processes[i].remainingTime == 0) {completedProcesses++;processes[i].waitingTime = currentTime - processes[i].arrivalTime - processes[i].burstTime;}}}}}void printWaitingTime(Process processes[], int n) { printf("Process\tWaiting Time\n");for (int i = 0; i < n; i++) {printf("%d\t%d\n", processes[i].pid, processes[i].waitingTime);}}int main() {int n, timeSlice;printf("Enter the number of processes: ");scanf("%d", &n);Process processes[n];printf("Enter the burst time and arrival time for each process:\n");for (int i = 0; i < n; i++) {processes[i].pid = i + 1;printf("Process %d: ", processes[i].pid);scanf("%d%d", &processes[i].burstTime,&processes[i].arrivalTime);processes[i].remainingTime = processes[i].burstTime;processes[i].waitingTime = 0;}printf("Enter the time slice: ");scanf("%d", &timeSlice);timeSliceScheduling(processes, n, timeSlice);printWaitingTime(processes, n);return 0;}```这个示例演示了如何使用时间片轮转调度算法计算进程的等待时间。
时间片轮转调度算法实验报告
******************************************** 测试数据2：2 3 11 2 35 4 2测试数据3：【结论】（结果）测试数据1的运行结果（截图）：测试数据2的运行结果：测试数据3的运行结果：源程序代码：#include"stdio.h"#include"stdlib.h" struct stud{错误分析：链表初始化排序过程中：指针p=Null时，不能执行q->arrive等命令；错误解决方法：将while(q->arrive<p->arrive &&q){t=q;q=q->next;}改为：while(q&&q->arrive<p->arrive){t=q;q=q->next;}2、进程运行时间大于时间片时，程序进入死循环：当进程所需时间等于时间片时，运行结果正确：进程运行时间大于时间片时，程序进入死循环：错误分析：进程所需剩余时间计算错误；错误修改：即进入死循环。
当进程所需时间小于时间片时，应立即跳出进程就绪对列。
错误修改：在output()子函数中p->rest=p->rest-slice;后面加上一个语句：if(p->rest<0)p->rest=0;实验运行结果为：实验的体会及收获：通过这次试验，我对处理机的调度算法---基于时间片轮转调度算法思想有了更深的理解;另外使我对链表的知识有了更深的理解，而且锻炼了我的思维能力，使我能更全面地思考问题，以后还需要多做些这方面的练习。
实验还需改进之处：为考虑进程所需时间小于时间片大小的情况，如：进程运行完一次时间片时间中断后，但下一个进程的提交时间要迟很多，这时候就会浪费很多时间等待，这是该程序还需改进的地方。
另外，本实验中的RR算法的时间片大小固定，所以实际是属于基本轮转法，还有种是时间片长短是变化的，即改进轮转法。
操作系统课程设计时间片轮转算法
成一个循环链队列，用函数creatPCB()来实现。
b.建立函数judge()用来判断进程全部运行结束标志，即当所有进程的状态变为’e’（即完成状态）后，循环结束，表示所有进程都已运行成功。
c.建立时间片轮转算法creatProcess（）对进程进行轮转运行，首先指针s指向第一个进程PCB，即s=front，判断该进程的状态是否为’r’（就绪状态），即if(s->condition == 'r')，若是则表示此进程尚未执行结束，则执行s->worked_time++且s->need_time--，if(s->need_time==0)，则表示此进程已运行结束，将其状态置为结束，即s->condition='e'，并根据状态位输出完成信息，且以后不会再运行此进程。
将指针指向下个进程，s=s->next，并判断所有进程是否已全部运行结束，没有则重复上面算法。
当所有进程的状态位都变成’e’表示所有进程运行完成，则循环结束。
d.建立主函数main(),输入进程数N，调用初始化循环链队列函数creatPCB()和时间片轮转算法creatProcess(N)，每次选中进程的进程名以及运行一次后进程队列的变化，实现处理器的调度。
调试分析：5. 程序的运行及结果5.1错误调试开始运行到Q5运行完成后显示错误，如下图所示：图4：错误调试原因：经检查程序发现语句if(s->condition=='e' ){printf("进程%s已经运行完成！\n\n",s->name);}有错误，因为当某个进程运行完成后，其状态标志已修改为’e’，所以再次循环运行未完成的进程时，当运行到此句时仍会将前面已完成的进程重新输出一遍完成信息，导致输出错误。
解决方案：为每个进程加上一个结束标志flag，并赋初值为0，当进程运行完成后，将flag改为1，再将后面输出改为if(s->condition=='e' || s->flag==0 ){printf("进程%s已经运行完成！\n\n",s->name);s->flag==0;}，这样在前面进程运行完成输出后，后面再循环时就不会重新输出一遍了。
处理器调度算法c语言
处理器调度算法c语言一、概述处理器调度算法是操作系统中一个非常重要的问题。
在多任务操作系统中，有多个进程同时运行，而处理器只有一个，因此需要对进程进行调度，使得每个进程都能够得到适当的执行时间。
二、常见的处理器调度算法1. 先来先服务（FCFS）FCFS算法是最简单的调度算法之一。
它按照进程到达时间的先后顺序进行调度，即先到达的进程先执行。
这种算法容易实现，但可能会导致长作业等待时间过长。
2. 最短作业优先（SJF）SJF算法是根据每个进程所需的CPU时间来进行排序，并按照顺序进行调度。
这种算法可以减少平均等待时间和平均周转时间，并且可以最大限度地利用CPU资源。
3. 优先级调度优先级调度是根据每个进程的优先级来进行排序，并按照顺序进行调度。
这种算法可以确保高优先级进程得到更多的CPU时间，但可能会出现低优先级进程饥饿问题。
4. 时间片轮转（RR）RR算法将CPU分配给每个任务一定量的时间片，在该时间片内运行任务。
如果任务在该时间片内未完成，则将其放回队列尾部，并分配给下一个任务时间片。
这种算法可以确保公平性，并且可以避免长作业等待时间过长。
三、C语言中的处理器调度算法实现1. FCFS算法实现#include <stdio.h>int main(){int n, i, j;float avg_waiting_time = 0, avg_turnaround_time = 0;printf("Enter the number of processes: ");scanf("%d", &n);int burst_time[n], waiting_time[n], turnaround_time[n];printf("Enter the burst time for each process:\n");for(i=0; i<n; i++)scanf("%d", &burst_time[i]);waiting_time[0] = 0;turnaround_time[0] = burst_time[0];for(i=1; i<n; i++){waiting_time[i] = waiting_time[i-1] + burst_time[i-1];turnaround_time[i] = waiting_time[i] + burst_time[i];avg_waiting_time += waiting_time[i];avg_turnaround_time += turnaround_time[i];}avg_waiting_time /= n;avg_turnaround_time /= n;printf("\nProcess\tBurst Time\tWaiting Time\tTurnaround Time\n");for(i=0; i<n; i++)printf("P%d\t%d\t\t%d\t\t%d\n", i+1, burst_time[i], waiting_time[i], turnaround_time[i]);printf("\nAverage Waiting Time: %.2f\n", avg_waiting_ time);printf("Average Turnaround Time: %.2f\n", avg_turnaround_ time);return 0;}2. SJF算法实现#include <stdio.h>int main(){int n, i, j, temp;float avg_waiting_time = 0, avg_turnaround_time = 0; printf("Enter the number of processes: ");scanf("%d", &n);int burst_time[n], waiting_time[n], turnaround_time[n]; printf("Enter the burst time for each process:\n");for(i=0; i<n; i++)scanf("%d", &burst_time[i]);for(i=0; i<n-1; i++)for(j=i+1; j<n; j++)if(burst_time[i] > burst_time[j]){temp = burst_time[i];burst_time[i] = burst_time[j]; burst_time[j] = temp;}waiting_time[0] = 0;turnaround_time[0] = burst_time[0];for(i=1; i<n; i++){waiting_time[i] = waiting_time[i-1] + burst_time[i-1];turnaround_time[i] = waiting_time[i] + burst_time[i];avg_waiting_time += waiting_time[i];avg_turnaround_time += turnaround_time[i];}avg_waiting_time /= n;avg_turnaround_time /= n;printf("\nProcess\tBurst Time\tWaiting Time\tTurnaround Time\n");for(i=0; i<n; i++)printf("P%d\t%d\t\t%d\t\t%d\n", i+1, burst_time[i], waiting_time[i], turnaround_time[i]);printf("\nAverage Waiting Time: %.2f\n", avg_waiting_ time);printf("Average Turnaround Time: %.2f\n", avg_turnaround_ time);return 0;}3. 优先级调度算法实现#include <stdio.h>int main(){int n, i, j, temp;float avg_waiting_time = 0, avg_turnaround_time = 0;printf("Enter the number of processes: ");scanf("%d", &n);int burst_time[n], waiting_time[n], turnaround_time[n], priority[n];printf("Enter the burst time and priority for each process:\n"); for(i=0; i<n; i++)scanf("%d %d", &burst_time[i], &priority[i]);for(i=0; i<n-1; i++)for(j=i+1; j<n; j++)if(priority[i] > priority[j]){temp = priority[i];priority[i] = priority[j];priority[j] = temp;temp = burst_time[i];burst_time[i] = burst_time[j]; burst_time[j] = temp;}waiting_time[0] = 0;turnaround_time[0] = burst_time[0];for(i=1; i<n; i++){waiting_time[i] = waiting_time[i-1] + burst_time[i-1];turnaround_time[i] = waiting_time[i] + burst_time[i];avg_waiting_ time += waiting_ time[i];avg_turnaround_ time += turnaround_ time[i];}avg_waiting_ time /= n;avg_turnaround_ time /= n;printf("\nProcess\tBurst Time\tPriority\tWaiting Time\tTurnaround Time\n");for(i=0; i<n; i++)printf("P%d\t%d\t\t%d\t\t%d\t\t%d\n", i+1, burst_ time[i], priority[i], waiting_time[i], turnaround_time[i]);printf("\nAverage Waiting Time: %.2f\n", avg_waiting_ time);printf("Average Turnaround Time: %.2f\n", avg_turnaround _ time);return 0;}4. RR算法实现#include <stdio.h>int main(){int n, i, j, time_quantum;float avg_waiting_time = 0, avg_turnaround_time = 0;printf("Enter the number of processes: ");scanf("%d", &n);int burst_time[n], remaining_time[n], waiting_time[n], turnaround_time[n];printf("Enter the burst time for each process:\n");for(i=0; i<n; i++)scanf("%d", &burst_time[i]);printf("Enter the time quantum: ");scanf("%d", &time_quantum);for(i=0; i<n; i++)remaining_time[i] = burst_time[i];int t=0;while(1){int done = 1;for(i=0; i<n; i++){if(remaining_time[i] > 0){done = 0;if(remaining_ time[i] > time_ quantum){t += time_ quantum;remaining_ time[i] -= time_ quantum;}else{t += remaining _ time[i];waiting_time[i] = t - burst_time[i];remaining_ time[i] = 0;turnaround_ time[i] = waiting_time[i] + burst_time[i];avg_waiting_ time += waiting_ time[i];avg_turnaround _ time += turnaround_ time[i];}}}if(done == 1)break;}avg_waiting_ time /= n;avg_turnaround_ time /= n;printf("\nProcess\tBurst Time\tWaiting Time\tTurnaround Time\n");for(i=0; i<n; i++)printf("P%d\t%d\t\t%d\t\t%d\n", i+1, burst_time[i], waiting_time[i], turnaround_time[i]);printf("\nAverage Waiting Time: %.2f\n", avg_waiting_ time);printf("Average Turnaround Time: %.2f\n", avg_turnaround _ time);return 0;}四、总结以上是常见的处理器调度算法的C语言实现方式。
时间片轮转算法和优先级调度算法C语言模拟实现
时间片轮转算法和优先级调度算法C语言模拟实现时间片轮转算法（Round Robin Scheduling）和优先级调度算法（Priority Scheduling）是操作系统中常用的两种进程调度算法。
下面将分别对这两种算法进行C语言模拟实现，并进行详细解释。
```c#include <stdio.h>#include <stdbool.h>#define MAX_PROC_NUM 10#define TIME_QUANTUM 2typedef struct Processint pid; // 进程ID} Process;void roundRobinScheduling(Process processes[], intnum_processes)for (int i = 0; i < num_processes; i++)} else}}}}int maiProcess processes[MAX_PROC_NUM];int num_processes;printf("Enter the number of processes: "); scanf("%d", &num_processes);for (int i = 0; i < num_processes; i++)printf("Process %d: ", i+1);processes[i].pid = i+1;}roundRobinScheduling(processes, num_processes); return 0;```优先级调度算法模拟实现：```c#include <stdio.h>#include <stdbool.h>#define MAX_PROC_NUM 10typedef struct Processint pid; // 进程IDint priority; // 优先级} Process;void priorityScheduling(Process processes[], int num_processes)int highest_priority = 0;int highest_priority_index;highest_priority = -1;for (int i = 0; i < num_processes; i++)highest_priority = processes[i].priority;highest_priority_index = i;}}if (highest_priority == -1)continue;}} else}}int maiProcess processes[MAX_PROC_NUM];int num_processes;printf("Enter the number of processes: ");scanf("%d", &num_processes);for (int i = 0; i < num_processes; i++)printf("Process %d:\n", i+1);printf("Burst Time: ");printf("Priority: ");scanf("%d", &processes[i].priority);processes[i].pid = i+1;}priorityScheduling(processes, num_processes);return 0;```以上是时间片轮转算法和优先级调度算法的C语言模拟实现。
操作系统时间片轮转算法
进程时间片轮转调度算法一、实验题目：进程时间片轮转调度算法二、实验原理：在多道程序系统中，一个作业被提交后必须经过处理机调度后，方能获得处理机执行。
对调度的处理又都可采用不同的调度方式和调度算法。
调度算法是指：根据系统的资源分配策略所规定的资源分配算法。
三、实验目的：1、加深对进程概念的理解，明确进程和程序的区别。
2、深入系统如何组织进程、创建进程。
3、进一步认识如何实现处理器调度。
4、通过对进程调度算法的设计，深入理解进程调度的原理。
5、加深对时间片轮转调度算法的理解。
四、实验要求：用C语言编写程序完成单处理机的进程调度，要求采用时间片轮转调度算法。
实验具体要求包括：首先确定作业控制块的内容和组成方式；然后完成作业调度；最后编写主函数，并对所做工作进行测试。
五、运行结果时间片大小为1时（q=1）：时间片大小为4时（q=4）：六、代码#include"stdafx.h"#include<stdio.h>#include<stdlib.h>#include<string.h>#include<windows.h>#define OK 0#define OVERFLOW 1char pro[20] ; //进程int processNum; //进程数int timeSlice = 0; //时间片typedefchar QlemTypeChar;typedefint QlemTypeInt;typedefint Status;typedefstruct QNode{QlemTypeChar data;QlemTypeInt timeArrive = 0;QlemTypeInt timeService = 0;QlemTypeInt timeCount = 0;QlemTypeInt runCount = 0;QlemTypeInt timeFinal = 0; //完成时间QlemTypeInt timeRound = 0; //周转时间float timeRightRound = 0; //带权周转时间QlemTypeChar proState = 'W'; //进程的状态，W——就绪态，R——执行态，F——完成态struct QNode *next; //链表指针}QNode, *QueuePtr;typedefstruct{QueuePtr front; //队头指针QueuePtr rear; //队尾指针}LinkQueue;Status InitQueue(LinkQueue &Q){Q.front = Q.rear = (QueuePtr)malloc(sizeof(QNode));if(!Q.front) exit(OVERFLOW);Q.front->next = NULL;return OK;}Status EnQueue(LinkQueue &Q, QlemTypeChar e){ QueuePtr p;p = (QueuePtr)malloc(sizeof(QNode));if (!p) exit(OVERFLOW);p->data = e;p->next = NULL;Q.rear->next = p;Q.rear = p;return OK;}Status DeQueue(LinkQueue &Q, QlemTypeChar &e){ QueuePtr p;if (Q.front == Q.rear) return ERROR;p = Q.front->next;e = p->data;Q.front->next = p->next;if (Q.rear == p) Q.rear = Q.front;free(p);return OK;}QNode qq[10];void ProGetFirst(){ //取出就绪队列队首进程InitQueue(QPro);printf("请输入要创建的进程名称:\n");for (int i = 0; i < processNum-1; i++){fflush(stdin);scanf_s("%c", &pro[i]);}fflush(stdin);for (int i = 0; i<processNum-1; i++){qq[i].data = pro[i];EnQueue(QPro, qq[i].data);}}void scanfData(){printf("请输入要创建的进程数目:");scanf_s("%d", &processNum);processNum++;fflush(stdin);printf("\n");ProGetFirst();printf("创建进程到达时间：\n");for (int i = 0; i < processNum-1; i++){scanf_s("%d", &time_Arr[i]);}for (int i =0; i<processNum-1; i++){qq[i].timeArrive = time_Arr[i];EnQueue(QPro, qq[i].timeArrive);}printf("创建进程服务时间：\n");int time_Ser[10];for (int i = 0; i < processNum-1; i++){scanf_s("%d", &time_Ser[i]);}for (int i = 0; i<processNum-1; i++){qq[i].timeService = time_Ser[i];EnQueue(QPro, qq[i].timeService);}printf("请输入时间片大小：:");scanf_s("%d", &timeSlice);printf("\n");}void ProOutPut1(){ //获取进程信息printf("进程名\t 到达时间\t 服务时间\t 进程状态\t 执行次数\n"); for (int i = 0; i < processNum - 1; i++){printf("%c\t\t%d\t\t%d\t\t%c\t\t%d\n", qq[i].data, qq[i].timeArrive, qq[i].timeService, qq[i].proState, qq[i].runCount); }}void CalculatetimeFinal(){ //计算完成时间int timecou=0;int countTemp = 0;QlemTypeChar ee;for (int i = 0; i < processNum - 1; i++){countTemp += qq[i].timeService;}while (timecou < countTemp){for (int i = 0; i < processNum - 1; i++){if (qq[i].timeFinal == 0){if (qq[i].timeService - qq[i].timeCount >= timeSlice){timecou += timeSlice;}else{timecou += (qq[i].timeService - qq[i].timeCount);//DeQueue(QPro, ee);}if (timeSlice < qq[i].timeService) //时间片大小< 服务时间{int timetemp = timeSlice > qq[i].timeService ? qq[i].timeService : timeSlice; if ((qq[i].timeCount + timetemp) < qq[i].timeService){if (qq[i].timeService - qq[i].timeCount >= timeSlice){qq[i].timeCount += timeSlice;}else{qq[i].timeCount += (qq[i].timeService - qq[i].timeCount);}}else{if (qq[i].timeFinal == 0){qq[i].timeFinal = timecou;}}}else//时间片大小>= 服务时间{qq[i].timeFinal = timecou; //该进程的完成时间=count}}}}for (int i = 0; i < processNum - 1; ++i){qq[i].timeRound = qq[i].timeFinal - qq[i].timeArrive;qq[i].timeRightRound = (float)qq[i].timeRound / qq[i].timeService;}}void ProOutPut2(){ //获取进程处理后的信息printf("进程名\t 到达时间服务时间完成时间周转时间带权周转\n");for (int i = 0; i < processNum - 1; i++){printf(" %c\t\t%d\t %d\t %d\t %d\t %.2f\n", qq[i].data, qq[i].timeArrive, qq[i].timeService, qq[i].timeFinal, qq[i].timeRound, qq[i].timeRightRound);}}int_tmain(int argc, _TCHAR* argv[]){scanfData();ProOutPut1();CalculatetimeFinal();printf("\n");printf("CPU处理中......\n");printf("完成时间：");for (int i = 0; i < processNum - 1; i++){ printf("%d,", qq[i].timeFinal);}printf("\n");printf("周转时间：");for (int i = 0; i < processNum - 1; i++){ printf("%d,",qq[i].timeRound);}printf("\n");printf("带权周转时间：");for (int i = 0; i < processNum - 1; i++){ printf("%.2f,", qq[i].timeRightRound); }printf("\n");ProOutPut2();return 0;}。
处理器调度 时间片轮转法 实验报告(C和C 含源代码)
for(i=0;i<num;i++)
{
printf("\n mp;p[i].name
,p[i].priority
,p[i].time
,p[i].state);
}
printf("********************************************\n");
printf("\n 进程执行完成\n");
%d
%d
%c\n"
,&p[i].name
,p[i].priority
,p[i].time
,p[i].state);
}
printf("********************************************\n");
printf(" 按任意键继续执行：\n");
getchar();//等待输入回车符
把五个进程按顺序排成循环队列，用指针指出队列连接情况。另用一标志单
元记录轮到运行的进程。例如，当前轮到 P2 执行，则有：
标志单元 K2
K1
Q1
K2
2
1
R
PCB1
K2
Q2
K3
3
0
R
PCB2
K3
Q3
K4
1
0
R
PCB3
K4
Q4
K5
2
0
R
PCB4
K5
Q5
K1
4
0
R
PCB5
处理器调度总是选择标志单元指示的进程运行。由于本实验是模拟处理器调
void run(PCB *p)//进程运行子程序 {
时间片轮转算法及优先级调度算法C语言模拟实现收藏
时间片轮转算法及优先级调度算法C语言模拟实现收藏时间片轮转算法是一种常见的CPU调度算法，通过将进程按照到达顺序放置在一个就绪队列中，并且给予每个进程相同的时间片，当进程用完时间片后，将其放到队列的尾部，轮流执行其他进程。
优先级调度算法是根据进程的优先级来决定下一个执行的进程。
下面是使用C语言模拟实现时间片轮转算法和优先级调度算法的代码：```c#include <stdio.h>typedef structchar name[10];int arrivalTime;int burstTime;int remainingTime;} Process;int totalTurnaroundTime = 0;int totalWaitingTime = 0;//初始化每个进程的剩余执行时间for (int i = 0; i < numProcesses; i++)processes[i].remainingTime = processes[i].burstTime;}while (1)int allProcessesFinished = 1; // 标记所有进程是否执行完毕for (int i = 0; i < numProcesses; i++)if (processes[i].remainingTime > 0)allProcessesFinished = 0; // 还有未执行完毕的进程processes[i].remainingTime = 0;} else}printf("%s执行完毕，剩余时间：%d\n", processes[i].name, processes[i].remainingTime);}}if (allProcessesFinished)break; // 所有进程执行完毕，退出循环}}//计算平均周转时间和平均等待时间float averageTurnaroundTime = (float)totalTurnaroundTime / numProcesses;float averageWaitingTime = (float)totalWaitingTime / numProcesses;printf("平均周转时间：%.2f\n", averageTurnaroundTime);printf("平均等待时间：%.2f\n", averageWaitingTime);int maiint numProcesses;printf("请输入进程数量：");scanf("%d", &numProcesses);Process processes[numProcesses];for (int i = 0; i < numProcesses; i++)printf("请输入进程%d的名称、到达时间和执行时间：", i+1);scanf("%s%d%d", processes[i].name, &processes[i].arrivalTime, &processes[i].burstTime);}printf("请输入时间片大小：");return 0;```优先级调度算法：```c#include <stdio.h>typedef structchar name[10];int arrivalTime;int burstTime;int priority;int waitingTime;int turnaroundTime;} Process;void runPriority(Process* processes, int numProcesses)int totalWaitingTime = 0;int totalTurnaroundTime = 0;//对进程按照到达时间进行排序for (int i = 0; i < numProcesses; i++)for (int j = 0; j < numProcesses-i-1; j++)if (processes[j].arrivalTime > processes[j+1].arrivalTime) Process temp = processes[j];processes[j] = processes[j+1];processes[j+1] = temp;}}}processes[0].waitingTime = 0;//计算每个进程的等待时间和周转时间for (int i = 1; i < numProcesses; i++)processes[i].waitingTime = processes[i-1].waitingTime + processes[i-1].burstTime;processes[i].turnaroundTime = processes[i].waitingTime + processes[i].burstTime;totalWaitingTime += processes[i].waitingTime;totalTurnaroundTime += processes[i].turnaroundTime;}//计算平均等待时间和平均周转时间float averageWaitingTime = (float)totalWaitingTime / numProcesses;float averageTurnaroundTime = (float)totalTurnaroundTime / numProcesses;printf("平均等待时间：%.2f\n", averageWaitingTime);printf("平均周转时间：%.2f\n", averageTurnaroundTime);int maiint numProcesses;printf("请输入进程数量：");scanf("%d", &numProcesses);Process processes[numProcesses];for (int i = 0; i < numProcesses; i++)printf("请输入进程%d的名称、到达时间、执行时间和优先级：", i+1);scanf("%s%d%d%d", processes[i].name,&processes[i].arrivalTime, &processes[i].burstTime,&processes[i].priority);}runPriority(processes, numProcesses);return 0;```通过输入进程的信息，可以计算出使用时间片轮转算法和优先级调度算法的平均等待时间和平均周转时间，从而比较它们的效果。
时间片轮转调度算法
(1)一设计要求：编写一程序，可以创建若干个虚拟进程，并对若干个虚拟进程进行调度，调度策略为时间片轮转。
要求：进程的个数，进程的内容（即进程的功能序列）来源于一个进程序列描述文件，另外调度运行结果输出到一个运行日志文件。
二设计目的：熟悉进程调度、设计内容：1.设计PCB适用于轮转法；2.建立进程队列；三虚拟程序的描述：虚拟指令的格式：操作命令操作时间● C ：表示在CPU上计算● I ：表示输入● O ：表示输出● W ：表示等待● H ：表示进程结束操作时间代表该操作命令要执行多长时间。
这里假设I/O设备的数量没有限制，I和O 设备都只有一类。
I，O，W三条指令实际上是不占有CPU的，执行这三条指令就应该将进程放入对应的等待队列（INPUT等待队列，OUTPUT等待队列，WAIT等待队列）。
例如有一虚拟程序p1.prc描述如下：C 30O 12C 9I 14H 0................程序部分代码如下：enum InstructionSet {INPUT,OUTPUT,WAIT,HALT,CALC};//指令类class CInstruction{friend class COsTestDlg;friend class PCB;public:CInstruction(){}~CInstruction(){}CInstruction(InstructionSet iid,int rt){m_nInstructionID=iid;m_nRunTime=rt;}private:CInstruction* m_pNextInstruction;//用于链接一个进程的所有指令成为链表（指令序列）int m_nRunTime;//本指令需要运行的时间长度（定时器时间间隔的个数）InstructionSet m_nInstructionID;//指令类型标识};//进程控制块类class PCB{friend class COsTestDlg;public:PCB(){m_nPID=0;m_csProcessName="";m_nRemainedTime=0;//m_pRuningInstruction=NULL;m_pInstructionList=NULL;m_pNextPCB=NULL;}//构造或创建一个进程PCB(int pid,CString pname){m_nPID=pid;m_csProcessName=pname;m_nRemainedTime=0;//m_pRuningInstruction=NULL;m_pInstructionList=NULL;m_pNextPCB=NULL;}~PCB(){CInstruction* pTemp;while(m_pInstructionList){m_pInstructionList=m_pInstructionList->m_pNextInstruction; pTemp=m_pInstructionList;delete pTemp;}}//本进程添加一条指令void AppendInstruction(CInstruction* pInstruction){CInstruction* pTempInstruction;if(m_pInstructionList==NULL){//emptym_pInstructionList=pInstruction;}else{//more than one nodepTempInstruction = m_pInstructionList;while(pTempInstruction->m_pNextInstruction!=NULL) pTempInstruction=pTempInstruction->m_pNextInstruction; pTempInstruction->m_pNextInstruction=pInstruction;}}private:PCB* m_pNextPCB; //进程队列的指针int m_nPID; //进程标识符CString m_csProcessName; //进程名字int m_nRemainedTime; //当前运行指令运行还需要的时间CInstruction* m_pRuningInstruction; //指向正在运行或将要运行的指令CInstruction* m_pInstructionList; //指向本进程的指令序列（线性表）的第一条指令};PCB* m_pReadyPCBs;//就绪队列PCB* m_pBackupReadyPCBs;//后备就绪队列PCB* m_pInputWaittingPCBs;//输入等待队列PCB* m_pOutputWaittingPCBs;//输出等待队列PCB* m_pPureWaittingPCBs;//其他等待队列int m_nTimeSlice;//时间片大小（定时器时间间隔的倍数）void LoadPCBs(CString csFileName);//从文件中加载要试验的进程信息void RemoveProcess(PCB* pPCB);//删除进程void DoSchedule();void RunOneTimeRange(PCB* pPCB,int nTime);//运行一个时间段void TreadWaittingQueue(PCB* pWaittingPCBs);//处理某个等待队列，适时将完成进程移出到后备就绪队列。
操作系统，时间片轮转算法的C语言实现RoundRobin
操作系统，时间⽚轮转算法的C语⾔实现RoundRobin1 #include "windows.h"2 #include <conio.h>3 #include <stdlib.h>4 #include <fstream.h>5 #include <io.h>6 #include <string.h>7 #include <stdio.h>89void Create_ProcInfo(); // 建⽴进程调度需要的数据10void Display_ProcInfo(); // 显⽰当前系统全部进程的状态11void Scheduler_FF();12void Cpu_Sched();13void IO_Sched();14void NextRunProcess();15void DisData();16void DisResult();1718int RunPoint; // 运⾏进程指针，-1时为没有运⾏进程19int WaitPoint; // 阻塞队列指针，-1时为没有阻塞进程20int ReadyPoint; // 就绪队列指针，-1时为没有就绪进程21long ClockNumber; // 系统时钟22int ProcNumber; // 系统中模拟产⽣的进程总数23int FinishedProc; // 系统中模拟产⽣的进程总数24int q=9;//时间⽚252627//进程信息结构28struct ProcStruct29 {30int p_pid; // 进程的标识号31char p_state; // 进程的状态，C--运⾏ R--就绪 W--组塞 B--后备 F--完成32int p_rserial[16]; // 模拟的进程执⾏的CPU和I/O时间数据序列，间隔存储，0项存储有效项数33int p_pos; // 当前进程运⾏到的序列位置34int p_starttime; // 进程建⽴时间35int p_endtime; // 进程运⾏结束时间36int p_cputime; // 当前运⾏时间段进程剩余的需要运⾏时间37int p_iotime; // 当前I/O时间段进程剩余的I/O时间38int p_next; // 进程控制块的链接指针39int p_excutetime; // 记录⼀次时间⽚内执⾏的时间40 } proc[10];4142////////////////////////////////////////////////////////////////////////////43//44// 随机⽣成进程数量和每个CPU--I/O时间数据序列，进程数量控制在5到10之间， //45// 数据序列控制在6到12之间，CPU和I/O的时间数据值在5到15的范围 //46//47////////////////////////////////////////////////////////////////////////////4849void Create_ProcInfo(void )50 {51int s,i,j;5253 srand(GetTickCount()); // 初始化随机数队列的"种⼦"54 ProcNumber=((float) rand() / 32767) * 5 ; // 随机产⽣进程数量5~10555657for(i=0;i<ProcNumber;i++) // ⽣成进程的CPU--I/O时间数据序列58 {59 proc[i].p_pid=((float) rand() / 32767) * 1000;60 proc[i].p_state='B'; // 初始都为后备状态6162 s=((float) rand() / 32767) *6 + 2; // 产⽣的进程数据序列长度在6~12间63 proc[i].p_rserial[0]=s; // 第⼀项⽤于记录序列的长度64for(j=1;j<=s;j++) // ⽣成时间数据序列65 proc[i].p_rserial[j]=((float) rand() / 32767) *10 + 5;66// 赋其他字段的值67 proc[i].p_pos=1;68 proc[i].p_starttime=((float) rand() / 32767) *49+1; // 随机设定进程建⽴时间69 proc[i].p_endtime=0;70 proc[i].p_cputime=proc[i].p_rserial[1];71 proc[i].p_iotime=proc[i].p_rserial[2];72 proc[i].p_next=-1;73 proc[i].p_excutetime=0;74 }75 printf("\n---------------------------\n 建⽴了%2d 个进程数据序列\n\n", ProcNumber);76 DisData();77 printf("\nPress Any Key To Continue.......");78 _getch() ;79return ;80 }84// 显⽰系统当前状态8586////////////////////////////////////////////////////////////////////////8788void Display_ProcInfo(void)89 { int i,n;9091 system("cls") ;92 printf("时间⽚为%d",q);93 printf("\n 当前系统模拟%2d 个进程的运⾏时钟：%ld\n\n", ProcNumber,ClockNumber);9495 printf(" 就绪指针=%d, 运⾏指针=%d, 阻塞指针=%d\n\n",ReadyPoint,RunPoint,WaitPoint );96if(RunPoint!= -1)97 {98 printf(" 当前运⾏的进程 No.%d ID：%d\n", RunPoint,proc[RunPoint].p_pid);99 printf(" %6d,%6d,%6d\n",proc[RunPoint].p_starttime,proc[RunPoint].p_rserial[proc[RunPoint].p_pos],proc[RunPoint].p_cputime); 100 printf("当前运⾏的进程执⾏的时间为%d",proc[RunPoint].p_excutetime);101 printf("当前运⾏的进程执⾏的cpu时间为%d",proc[RunPoint].p_cputime);102 }103else104 printf(" 当前运⾏的进程ID：No Process Running !\n");105106 n=ReadyPoint;107 printf("\n Ready Process ...... \n");108while(n!=-1) // 显⽰就绪进程信息109 {110 printf(" No.%d ID:%5d,%6d,%6d,%6d\n",n,proc[n].p_pid,proc[n].p_starttime,proc[n].p_rserial[proc[n].p_pos],proc[n].p_cputime );111 n=proc[n].p_next;112 }113114 n=WaitPoint;115 printf("\n Waiting Process ...... \n");116while(n!=-1) // 显⽰阻塞进程信息117 {118 printf(" No.%d ID:%5d,%6d,%6d,%6d\n",n,proc[n].p_pid,proc[n].p_starttime,proc[n].p_rserial[proc[n].p_pos],proc[n].p_iotime);119 n=proc[n].p_next;120 }121122 printf("\n=================== 后备进程 ====================\n");123for(i=0; i<ProcNumber; i++)124if (proc[i].p_state=='B')125 printf(" No.%d ID:%5d,%6d\n",i,proc[i].p_pid,proc[i].p_starttime);126127 printf("\n================ 已经完成的进程 =================\n");128for(i=0; i<ProcNumber; i++)129if (proc[i].p_state=='F')130 printf("No.%d ID:%5d,%6d,%6d\n",i,proc[i].p_pid,proc[i].p_starttime,proc[i].p_endtime);131132 }133134////////////////////////////////////////////////////////////////////////135136// 显⽰模拟执⾏的结果137138////////////////////////////////////////////////////////////////////////139void DisResult(void)140 { int i;141 printf("\n---------------------------------\n");142for(i=0; i<ProcNumber; i++)143 {144 printf("ID=%4d> %2d ",proc[i].p_pid ,proc[i].p_rserial[0] );145 printf("%4d,%4d",proc[i].p_starttime,proc[i].p_endtime);146 printf("\n" );147 }148 }149150////////////////////////////////////////////////////////////////////////151152// 显⽰进程数据序列153154////////////////////////////////////////////////////////////////////////155void DisData(void)156 { int i,j;157158for(i=0; i<ProcNumber; i++)159 {160 printf("ID=%4d %2d > ",proc[i].p_pid ,proc[i].p_rserial[0] );161for(j=1; j<=proc[i].p_rserial[0];j++)162 printf("%4d",proc[i].p_rserial[j]);163 printf("\n" );164 }168// 选择下⼀个可以运⾏的进程169170////////////////////////////////////////////////////////////////////////171void NextRunProcess(void)172 {173if (ReadyPoint==-1) { RunPoint = -1; return;} // 就绪队列也没有等待的进程174175 proc[ReadyPoint].p_state ='C'; //ReadyPoint所指⽰的进程状态变为执⾏状态176 RunPoint=ReadyPoint;177if( proc[ReadyPoint].p_excutetime==-1)//进程为执⾏成功，接着上次的cpu时间执⾏178 {179 proc[ReadyPoint].p_excutetime=0;180 }181else182 proc[ReadyPoint].p_cputime =proc[ReadyPoint].p_rserial[proc[ReadyPoint].p_pos] ;183 ReadyPoint=proc[ReadyPoint].p_next;184 proc[RunPoint].p_next = -1;185186 }187////////////////////////////////////////////////////////////////////////188189// CPU调度190191////////////////////////////////////////////////////////////////////////192193void Cpu_Sched(void)194 {195int n;196197if (RunPoint == -1) // 没有进程在CPU上执⾏198 { NextRunProcess(); return; }199200 proc[RunPoint].p_cputime--; // 进程CPU执⾏时间减少1个时钟单位201 proc[RunPoint].p_excutetime++;202if((proc[RunPoint].p_cputime == 0&&proc[RunPoint].p_excutetime<=q))//若时间⽚未完，但进程已经结束203 {204//printf("若时间⽚未完，但进程已经结束\n");205 proc[RunPoint].p_excutetime=0;//清空运⾏时间206// 进程完成本次CPU后的处理207if (proc[RunPoint].p_rserial[0]==proc[RunPoint].p_pos) //进程全部序列执⾏完成208 {209 FinishedProc++;210 proc[RunPoint].p_state ='F';211 proc[RunPoint].p_endtime = ClockNumber;212 RunPoint=-1; //⽆进程执⾏213 NextRunProcess();214 }215else//进⾏IO操作，进⼊阻塞队列216 {217 proc[RunPoint].p_pos++;218 proc[RunPoint].p_state ='W';219 proc[RunPoint].p_iotime =proc[RunPoint].p_rserial[proc[RunPoint].p_pos];220 printf("进⼊阻塞队列\n");221 n=WaitPoint;222if(n == -1) //是阻塞队列第⼀个I/O进程223 WaitPoint=RunPoint;224else225 { do//放⼊阻塞队列第尾226 {227if(proc[n].p_next == -1)228 { proc[n].p_next = RunPoint;229break;230 }231 n=proc[n].p_next;232 } while(n!=-1) ;233 }234 RunPoint=-1;235 NextRunProcess();236 }237return;238 }239if(proc[RunPoint].p_cputime > 0&&proc[RunPoint].p_excutetime<q)//时间⽚未完程序未执⾏结束继续执⾏240 {241//printf("时间⽚未完程序未执⾏结束继续执⾏\n");242return;243 }244//{ printf("\n RunPoint=%d,ctime=%d",RunPoint,proc[RunPoint].p_cputime);getchar();return; }245if(proc[RunPoint].p_cputime > 0&&proc[RunPoint].p_excutetime==q)//时间⽚完，但是程序未执⾏完放到就绪队列尾部246 {247//printf("时间⽚完，但是程序未执⾏完放到就绪队列尾部\n");248int n;249 proc[RunPoint].p_state='R'; // 进程状态修改为就绪250 proc[RunPoint].p_next=-1;251 proc[RunPoint].p_excutetime=-1;//清空运⾏时间,-1代表程序未执⾏完成252if(ReadyPoint==-1) // 就绪队列⽆进程253 ReadyPoint=RunPoint;254else// 就绪队列有进程，放⼊队列尾255 {256 n=ReadyPoint;257while(proc[n].p_next!=-1) n=proc[n].p_next;258 proc[n].p_next=RunPoint;259 }260 RunPoint=-1;261 NextRunProcess(); //执⾏下⼀个进程262 }263264 }265266267268////////////////////////////////////////////////////////////////////////269270// I/O调度271272////////////////////////////////////////////////////////////////////////273274void IO_Sched(void)275 {276int n,bk;277278if (WaitPoint==-1) return; // 没有等待I/O的进程，直接返回279280 proc[WaitPoint].p_iotime--; // 进⾏1个时钟的I/O时间281282if (proc[WaitPoint].p_iotime > 0) return; // 还没有完成本次I/O283284// 进程的I/O完成处理285if (proc[WaitPoint].p_rserial[0]==proc[WaitPoint].p_pos) //进程全部任务执⾏完成286 {287 FinishedProc++;288 proc[WaitPoint].p_endtime = ClockNumber;289 proc[WaitPoint].p_state ='F';290291if(proc[WaitPoint].p_next==-1)292 { WaitPoint=-1;return ;}293else//调度下⼀个进程进⾏I/O操作294 {295 n=proc[WaitPoint].p_next;296 proc[WaitPoint].p_next=-1;297 WaitPoint=n;298 proc[WaitPoint].p_iotime =proc[WaitPoint].p_rserial[proc[WaitPoint].p_pos] ; 299return ;300 }301 }302else//进⾏下次CPU操作，进就绪队列303 {304 bk=WaitPoint;305 WaitPoint=proc[WaitPoint].p_next;306307 proc[bk].p_pos++;308 proc[bk].p_state ='R'; //进程状态为就绪309 proc[bk].p_cputime = proc[bk].p_rserial[proc[bk].p_pos];310 proc[bk].p_next =-1;311312 n=ReadyPoint;313if(n == -1) //是就绪队列的第⼀个进程314 { ReadyPoint=bk; return; }315else316 { do317 {318if(proc[n].p_next == -1) { proc[n].p_next = bk; break ; }319 n=proc[n].p_next;320 }321while(n!=-1);322 }323 }324return ;325 }326327328329330331////////////////////////////////////////////////////////////////////////332333// 检查是否有新进程到达，有则放⼊就绪队列334335////////////////////////////////////////////////////////////////////////336337void NewReadyProc(void)338 {339int i,n;340341for(i=0; i<ProcNumber; i++)342 {343if (proc[i].p_starttime == ClockNumber) // 进程进⼊时间达到系统时间344 {345 proc[i].p_state='R'; // 进程状态修改为就绪346 proc[i].p_next=-1;347348if(ReadyPoint==-1) // 就绪队列⽆进程349 ReadyPoint=i;350else// 就绪队列有进程，放⼊队列尾351 {352 n=ReadyPoint;353while(proc[n].p_next!=-1) n=proc[n].p_next;354 proc[n].p_next=i;355 }356 }357 } // for358return;359 }360361362////////////////////////////////////////////////////////////////////////363364// 调度模拟算法365366////////////////////////////////////////////////////////////////////////367368void Scheduler_FF(void)369 {370 FinishedProc=0;371if(ProcNumber==0)372 { printf(" 必须⾸先建⽴进程调度数据！ \n");373 system("cls"); return;374 }375376 ClockNumber=0;// 时钟开始计时, 开始调度模拟377while(FinishedProc < ProcNumber) // 执⾏算法378 {379 ClockNumber++; // 时钟前进1个单位380 NewReadyProc(); // 判别新进程是否到达381 Cpu_Sched(); // CPU调度382 IO_Sched(); // IO调度383 Display_ProcInfo(); //显⽰当前状态384 }385 DisResult();386 getch(); return;387 }388389void Change_q(void)390 {391 scanf("%d",&q);392 }393394///////////////////////////////////////////////////////////////////395396// 主函数397398///////////////////////////////////////////////////////////////////399400int main(int argc, char* argv[])401 {402char ch;403404 RunPoint=-1; // 运⾏进程指针，-1时为没有运⾏进程405 WaitPoint=-1; // 阻塞队列指针，-1时为没有阻塞进程406 ReadyPoint=-1; // 就绪队列指针，-1时为没有就绪进程407 ClockNumber=0; // 系统时钟408 ProcNumber=0; // 当前系统中的进程总数409410 system("cls") ;411while ( true )412 {413 printf("***********************************\n");414 printf(" 1: 建⽴进程调度数据序列 \n") ;415 printf(" 2: 执⾏调度算法\n") ;416 printf(" 3: 显⽰调度结果 \n") ;417 printf(" 4: 更改时间⽚ \n");418 printf(" 5: 退出\n") ;419 printf("***********************************\n");420 printf( "Enter your choice (1 ~ 5): ");421422do{ //如果输⼊信息不正确，继续输⼊423 ch = (char)_getch() ;424 } while(ch != '1' && ch != '2'&& ch != '3'&& ch != '4'&& ch != '5'); 425426if(ch == '5') { printf( "\n");return0; } // 选择4，退出427if(ch == '3') DisResult(); // 选择3428if(ch == '2') Scheduler_FF(); // 选择2429if(ch == '1') Create_ProcInfo(); // 选择1430if(ch == '4') Change_q();431 _getch() ;432 system("cls") ;433 }434//结束435 printf("\nPress Any Key To Continue:");436 _getch() ;437return0;438 }。
c语言做的时间片轮转算法
break;
case 3:
InitQueue(runq);
printf("当前执行队列中的进程有：\n");
OutQueue(runq);
break;
case 4: dispatch(rq,bq,runq);
break;
case 5: flag=0;
break;
default: printf("输入序号错误！\n");
}
printf("\n");
}
int IsEmpty(LinkQueue *Q)
{
if(Q->front==Q->rear)
return(TRUE);
else
return(FALSE);
}
LinkQueueNode * DeleteQueue(LinkQueue *Q)
{ LinkQueueNode *p;
break;
}
}
}
getchar();
switch(m)
{ case 1: InitQueue(rq);
BuildQueue(rq);
printf("当前就绪队列中的进程有：\n");
OutQueue(rq);
break;
case 2:
InitQueue(bq);
BuildQueue(bq);
printf("当前阻塞队列中的进程有：\n");
printf("1、创建就绪（ready）队列\n");
printf("2、创建阻塞队列（blocked）\n");
printf("3、创建执行队列（run）\n");
时间片轮转调度算法
时间片轮转调度算法部门： xxx时间： xxx整理范文，仅供参考，可下载自行编辑// 时间片轮转调度算法#include <iostream>#include <cstdio>#include <cmath>#include <cstring>using namespace std。
enum STATUS {RUN,READY,WAIT,FINISH}。
struct PCBNode{int processID。
//进程ID b5E2RGbCAPSTATUS status。
//进程状态 p1EanqFDPwint priorityNum。
//优先数 int reqTime。
//总的需要运行时间 DXDiTa9E3dint remainTime。
//剩下需要运行时间int arriveTime。
//进入就绪队列时间int startTime。
//开始运行时间int finishTime。
//结束运行时间int totalTime。
//周转时间float weightTotalTime。
//带权周转时间}。
struct QueueNode{int ID。
//进程IDstruct QueueNode * next。
//队列中下一个进程指针}。
struct LinkQueue{QueueNode *head。
//队首}。
void Fcfs(LinkQueue& Q, int& totalTimeSum, int& weightTotalTimeSum,PCBNode * ProcessTable>。
RTCrpUDGiT bool RR_Run(LinkQueue& Q,QueueNode* q, QueueNode* p, const int Round,int& currentTime,PCBNode * ProcessTable>。
时间片轮转算法和优先级调度算法C语言模拟实现收藏
时间片轮转算法和优先级调度算法C语言模拟实现收藏一、目的和要求进程调度是处理机管理的核心内容。
本实验要求用高级语言编写模拟进程调度程序，以便加深理解有关进程控制快、进程队列等概念，并体会和了解优先数算法和时间片轮转算法的具体实施办法。
二、实验内容1.设计进程控制块PCB的结构，通常应包括如下信息：进程名、进程优先数（或轮转时间片数）、进程已占用的CPU时间、进程到完成还需要的时间、进程的状态、当前队列指针等。
2.编写两种调度算法程序：优先数调度算法程序循环轮转调度算法程序3.按要求输出结果。
三、提示和说明分别用两种调度算法对伍个进程进行调度。
每个进程可有三种状态；执行状态（R UN）、就绪状态（READY,包括等待状态）和完成状态（FINISH），并假定初始状态为就绪状态。
（一）进程控制块结构如下：NAME——进程标示符PRIO/ROUND——进程优先数/进程每次轮转的时间片数（设为常数2）CPUTIME——进程累计占用CPU的时间片数NEEDTIME——进程到完成还需要的时间片数STATE——进程状态NEXT——链指针注：1.为了便于处理，程序中进程的的运行时间以时间片为单位进行计算；2.各进程的优先数或轮转时间片数，以及进程运行时间片数的初值，均由用户在程序运行时给定。
（二）进程的就绪态和等待态均为链表结构，共有四个指针如下：RUN——当前运行进程指针READY——就需队列头指针TAIL——就需队列尾指针FINISH——完成队列头指针（三）程序说明1. 在优先数算法中，进程优先数的初值设为：50-NEEDTIME每执行一次，优先数减1，CPU时间片数加1，进程还需要的时间片数减1。
在轮转法中，采用固定时间片单位（两个时间片为一个单位），进程每轮转一次，CPU时间片数加2，进程还需要的时间片数减2，并退出CPU，排到就绪队列尾，等待下一次调度。
2. 程序的模块结构提示如下：整个程序可由主程序和如下7个过程组成：（1）INSERT1——在优先数算法中，将尚未完成的PCB按优先数顺序插入到就绪队列中；（2）INSERT2——在轮转法中，将执行了一个时间片单位（为2），但尚未完成的进程的PCB，插到就绪队列的队尾；（3）FIRSTIN——调度就绪队列的第一个进程投入运行；（4）PRINT——显示每执行一次后所有进程的状态及有关信息。
时间片轮转算法
《操作系统A》课程综合性实验报告开课实验室：基础七2011年5月29日实验题目| 进程调度算法程序设计一、实验目的通过对进程调度算法的模拟，进一步理解进程的基本概念，加深对进程运行状态和进程调度过程、调度算法的理解。
二、设备与环境1.硬件设备：PC机一台2.软件环境：安装Windows操作系统或者Linux操作系统，并安装相关的程序开发环境，如C \C++\Java等编程语言环境。
三、实验内容（1）用C语言（或其它语言，如Java）实现对N个进程采用某种进程调度算法（如动态优先权调度）的调度。
（2）每个用来标识进程的进程控制块PCB可用结构来描述，包括以下字段：进程标识数ID。
进程优先数PRIORITY，并规定优先数越大的进程，其优先权越高。
进程已占用CPU时间CPUTIME。
进程还需占用的CPU时间ALLTIME。
当进程运行完毕时，ALLTIME变为0。
进程的阻塞时间STARTBLOCK ，表示当进程再运行STARTBLOCK 个时间片后，进程将进入阻塞状态。
进程被阻塞的时间BLOCKTIME ，表示已阻塞的进程再等待BLOCKTIME 个时间片后，将转换成就绪状态。
进程状态STATE。
队列指针NEXT，用来将PCB排成队列。
（3）优先数改变的原则：进程在就绪队列中呆一个时间片，优先数增加1。
进程每运行一个时间片，优先数减3。
（4）为了清楚地观察每个进程的调度过程，程序应将每个时间片内的进程的情况显示出来，包括正在运行的进程，处于就绪队列中的进程和处于阻塞队列中的进程。
（5）分析程序运行的结果，谈一下自己的认识。
3. 实验结果输入进程的数量，每个进程的名称、到达时间和服务时间，以及时间片：函-|口| -I得到的结果为:state= R state= R state= R state= R state= R4 4 ■ ■ ■ ■ :E^J^名其名曹名曹名甚客甜 程达塞达塞达畚达塞达务 5进船进能进能进重进船 :勺勺勺.勺勺.勺勺.勺勺.勺勺.勺勺.勺勺• 3B---1,-■- - 1■-■- - 1■-■- - 1■-■- - 1■-■- - 1■- ■- - 1■- ■- - 1■- ■- - 1■-■- -1■-■- - 1■-■- - 1■- ■- - 1■- ■- - 1■-■- - 1■- ■-- ij —二..1二..1二..1二 r二..1二..1二..1二..1二..1二..1二..1二..1二 r二..1二..1建进进进进进进进进进进进进进进进射个个个个个个个个个个个个个个个 ■屯 111222333444555进 WWWWWWWWW1A1A1A1A1A1A1A1A1A1A1A1A1A1A1A1A请请请请请请请请请请请请请请请请0 4 1 3 2 5 3 2 ■ ■■ ■ ■ ■■ ■■■ ■ ■ ■ ■ ■ ■ A可司• B 可可• C可可• D司.可您输入的时间片轮转进程队烫为:runtime=4 runtime=3 runtime=5 runtime=2 runtime=4arriuetime =0 arriuetime =1 arriuetime =2 arriuetime =3 arriuetime =4pname =A pname =B pname =C pname =D pname =E 的时间片为H请输入时恒4. 实验结果分析RR 算法：每次调度时，把CPU 分配给队首进程，并且令其执行一个时间片，时间片的大小 从几个ms 到几百ms 。
基于优先级的时间片轮转调度算法(C语言实现)
1
队列
1 typedef struct Link 2{
12 p = p->next;
13
14
}
}
1
removeFirst：将队列中第一个元素中的数据复制到给定参数中（用于返回），并删除
1 void removeFirst(Link *l, Block *b)
2{
3
Block *t;
4
5
// 空队列则直接返回
6
if (isEmpty(l))
7
{
8
return ;
11 }
12
13
14
// 若存在，则释放
15
if (p != NULL)
16
{
17
t->next = p->next;
1
18
free(p);
19
}
20 }
sortByArrivalTime：根据进程到达时间将队列排序（从小到大）
9
}
10
11
// t指向第二个Block，用于之后将队列接上
12 t = l->first->next->next;
13
14
// 将第一个Block中的内容复制到b中，用于返回
15
b->processID = l->first->next->processID;
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
int Queue_c::qEnQueue(ElemType e)
{
if(qFull())return ERROR;
Q[rear]=e;
rear=(rear+1)%QueueNum;
return OK;
}
//=================qDeQueue=============================== ElemType Queue_c::qDeQueue()
{
ElemType e;
if(qEmpty())return ERROR;
e=Q[front];
Q[front]=QueuePre;
front=(front+1)%QueueNum;
return e;
}
//===================qGetNumber============================= int Queue_c::qGetNumber()
{int i;
i=((rear-front+QueueNum)%QueueNum);
return i;
}
//==================qGetElem============================== ElemType Queue_c::qGetElem(int i)
{
if(qEmpty()){cout<<"ERROR!"<<endl;return ERROR;}
if(i>qGetNumber()-1)
{
cout<<"ERROR! there is no "<<i<<",or no "<<i<<" in Queu e now"<<endl;
return ERROR;
}
return Q[(front+i)%QueueNum];
}
//======================qShowQueue========================== int Queue_c::qShowQueue()
{int i;
if(qEmpty())return ERROR;
for(i=front;i!=rear%QueueNum;i=(i+1)%QueueNum)
{
cout<<Q[i]<<" ";
}//endfor
cout<<endl;
return OK;
}
//======================qShowAll========================= /*int Queue_c::qShowAll()
{
int i;
for(i=0;i<QueueNum;i++)cout<<Q[i]<<" ";
cout<<endl;
return OK;
}*/
/* int Queue_c::qXChange(int i)
{
ElemType t;
if(1==qGetNumber())return OK;
if(qEmpty()){cout<<"ERROR!"<<endl;return ERROR;}
if(i>qGetNumber()-1)
{
cout<<"ERROR! there is no "<<i<<",or no "<<i<<" in Queu e now"<<endl;
return ERROR;
}//endlf
t=Q[front];
Q[front]=Q[(i+front)%QueueNum];
Q[(i+front)%QueueNum]=t;
return OK;
}
*/
//========================================================
/************************End Of Class Queue_c***************** *****************/
/************************Class Work_c*************************** ***************/
//======================wCPU========================= int Work_c::wCPU()
{ int t;
ElemType temp;
//if(wScan(t))buf.qXChange(t);
buf.qDec();
temp=buf.qDeQueue();
if(temp>0)buf.qEnQueue(temp);
return OK;
}
//======================wScan=========================
//ElemType Work_c::wScan(int &t)
//{
//int i,m=12;
//ElemType temp;
//for(i=0;i<buf.qGetNumber();i++)
// {
// temp=buf.qGetElem(i);
// if(temp<m){m=temp;t=i;}//endif
// }//endfor
// if(m<=0||m>buf.qGetFrontElem())return ERROR;//如果是负数的话在这里就被拦下来了,所以,传出出去的m不可能是负数
//return m;
//}
//======================wMakeP=========================
int Work_c::wMakeP()
{
int t;
t=random(200)%2;
if(t){buf.qEnQueue(random(10)+1);return OK;}
return ERROR;
}
//========================================================
/**************************End of Class Work_c**************** *****************/。