时间片轮转调度算法实验
时间片算法实验报告
时间片算法实验报告时间片调度算法是一种基于轮询的调度算法，在实验中它被应用于多道程序运行环境中，实现了多个程序之间的轮流执行。
本实验旨在通过实现一个基于时间片调度算法的简单操作系统，以及对其进行性能评估来深入理解该调度算法的工作原理和优缺点。
1. 实验所用材料与方法本实验使用C语言编程实现一个具有基本功能的操作系统。
在该系统中，定义了一个PCB（Process Control Block，进程控制块）结构体，用于保存进程的相关信息，如进程ID、优先级、状态等。
同时，系统中维护一个进程队列，用于存储所有申请CPU时间片的进程。
在时间片调度算法中，系统将时间划分为固定的时间片，当一个进程得到CPU 的时间片后，执行一段指定的CPU时间，然后被中断，以便让其他进程获得执行的机会。
在本实验中，假设每个时间片的长度为100ms。
2. 实验过程与结果在实验中，首先实现了一个简单的时间片调度算法的操作系统，并使用该操作系统执行了一系列的测试任务，利用日志记录了每个任务的执行时间和完成情况。
然后，对比了不同任务数量和优先级情况下的系统性能，并分析了结果。
通过实验结果可以看出，当任务数量较少时，时间片调度算法能够保证每个任务能够按照预期的时间片轮流执行，且每个任务完成时间较为均衡。
然而，当任务数量增多时，由于时间片的限制，每个任务能够获得的执行时间减少，导致任务完成时间延长，系统的响应时间也相应增加。
此外，实验还对比了不同优先级的任务在系统中的执行情况。
当任务的优先级较高时，系统会优先执行这些任务，从而保证任务的及时响应。
然而，如果某些优先级较低的任务长时间得不到执行，可能会导致任务的响应速度变慢，甚至影响整个系统的正常运行。
3. 实验总结与思考时间片调度算法是一种简单且公平的调度算法，它能够有效地提高多任务环境中任务的响应速度。
然而，该算法也存在一些不足之处。
首先，由于每个任务只能获得固定的执行时间片，当任务数量增多时，每个任务可获得的执行时间减少，从而导致任务的完成时间延长。
实验二带优先级的时间片轮换的进程调度算法的实现
•
struct pcb *p;
•
for (i=0;i<MAXPIOR;i++)
•
{p=array[i];
•
while (p!=NULL)
•
{printf("id:%d,state:%d,pior:%d,life:%d\n",p->ident,p->state,p->pior,p->life);
•
p=p->next;
• {int i=0,ii=0;
• for (i=0;i<7;i++)
•
if (stricmp(str,command[i])==0)
•
break;
• switch(i)
•
{case 0:printf("thank you for using the program!\n");exit(0);
•
break;
•{
•
int i=MAXPIOR-1,pior=0,t;
•
struct pcb *pp,*qq,*pr,*r;
•
do
•
{
•
while (i>=0 && array[i]==NUf (i<0)
•
{
•
printf("NO process,please create it! \n");
第1个，再降低其优先级，插入到相应的队列中。 C）ps 查看当前进程状态 D）sleep 命令将进程挂起 E）awake 命令唤醒1个被挂起的进程 F）kill 命令杀死进程 G）quit命令退出 （4）选用面向对象的编程方法。
操作系统实验三 时间片轮转法完成进程调度
实验三：时间片轮转法完成进程调度一、实验目的：（1）加深对进程的理解（2）理解进程控制块的结构（3）理解进程运行的并发性（4）掌握时间片轮转法进程调度算法实验内容：（1）建立进程控制块（2）设计三个链队列，分别表示运行队列、就绪队列和完成队列（3）用户输入进程标识符以及进程所需的时间，申请空间存放进程PCB信息。
（4）每一个时间片结束输出各进程的进程号，CPU时间（即已经占用的CPU时间），所需时间（即还需要的CPU时间），以及状态（即用W表示等待，R表示运行，F表示完成）实验程序：#include <stdio.h>#include <stdlib.h>#include <string.h>typedef struct node{char name[10];/*进程标识符*/int prio;/*进程优先数*/int round;/*进程时间轮转时间片*/int cputime; /*进程占用CPU时间*/int needtime; /*进程到完成还要的时间*/int count;/*计数器*/char state; /*进程的状态*/struct node *next; /*链指针*/}PCB;PCB *finish,*ready,*tail,*run; //队列指针int N,t; //进程数,时间片的大小void firstin(){run=ready;//就绪队列头指针赋值给运行头指针run->state='R'; //进程状态变为运行态ready=ready->next; //就绪队列头指针后移到下一进程}void prt1(char a)//输出标题函数{if(toupper(a)=='P')//优先级法printf("进程名占用CPU时间到完成还要的时间轮转时间片状态\n");} void prt2(char a,PCB *q)//进程PCB输出{if(toupper(a)=='P')//优先级法的输出printf("%4s %8d %12d %14d %8c\n",q->name,q->cputime,q->needtime,q->roun d,q->state);}void prt(char algo)//输出函数二、三、{PCB *p;prt1(algo);//输出标题if(run!=NULL)//如果运行指针不空prt2(algo,run);//输出当前正在运行的PCBp=ready;//输出就绪队列PCBwhile(p!=NULL){prt2(algo,p);p=p->next;}p=finish;//输出完成队列的PCBwhile(p!=NULL){prt2(algo,p);p=p->next;}getchar(); //按住任意键继续}void insert(PCB *q)//时间片轮转的插入算法{PCB *p1,*s,*r;s=q;//待插入的PCB指针p1=ready;//就绪队列头指针r=p1;//*r做pl的前驱指针while(p1!=NULL)if(p1->round<=s->round){r=p1;p1=p1->next;}if(r!=p1){r->next=s;s->next=p1;}else{s->next=p1;//否则插入在就绪队列的头ready=s;}}void create(char alg)//时间片轮转法创建链表进程PCB{PCB *p;int i,time;char na[10];ready=NULL;finish=NULL;run=NULL;printf("输入进程名及其需要运行的时间(中间以空格隔开)：\n"); for(i=1;i<=N;i++){p=new PCB;scanf("%s %d",&na,&time);strcpy(p->name,na);p->cputime=0;p->needtime=time;p->state='W';//进程的状态p->round=0;if(ready!=NULL)insert(p);else{p->next=ready;ready=p;}}printf("*************时间片轮转法进程调度过程*************\n"); prt(alg);run=ready;ready=ready->next;run->state='R';}void timeslicecycle(char alg)//时间片轮转法{while(run!=NULL){run->cputime=run->cputime+t;//处理时间加trun->needtime=run->needtime-t;//完成需要时间减trun->round=run->round+t;//运行完将其变为完成态，插入完成队列if(run->needtime<=0)//当进程完成时{run->next=finish;finish=run;run->state='F';run=NULL;if(ready!=NULL)//就绪队列不空，将第一个进程投入进行firstin();}else{run->state='W';//将进程插入到就绪队列中等待轮转insert(run);//将就绪队列的第一个进程投入运行firstin();}prt(alg);}}void main()//主函数{char algo='P';//算法标记printf("输入进程的个数：");scanf("%d",&N);//输入进程数printf("定义时间片大小：");scanf("%d",&t);//输入时间片大小create(algo);//创建进程timeslicecycle(algo);//时间片轮转法调度}//main()四、实验结果：五、实验小结：时间片轮转调度是一种最古老，最简单，最公平且使用最广的算法。
操作系统实验二报告-时间片轮转进程调度算法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算法进行进程调度, 计算进程的完成时间、周转时间和带权周转时间；➢计算所有进程的平均周转时间和平均带权周转时间；➢按格式输出调度结果。
实验二时间片轮转算法实验报告
实验二时间片轮转算法实验报告一、实验目的本次实验的主要目的是了解时间片轮转算法的工作原理，学习如何使用时间片轮转算法进行进程调度，并了解时间片大小对进程调度的影响。
二、实验原理时间片轮转算法是一种公平的进程调度算法，它采用循环队列的形式，将所有需要运行的进程按照到达时间排序，并将它们按照轮转的方式依次执行，每个进程在一个时间片内执行一定的时间（时间片大小），然后被暂停并放在队列的末尾等待下一次调度。
当一个进程的时间片用完后，它会被暂停并放在队列的最后，而在这个时间片内没有执行完的进程会被暂停并放到队列的开头，以便继续下一轮的运行。
这样一直循环下去，直到所有进程都运行完毕。
三、实验步骤1.设定进程数量和时间片大小。
2.定义进程结构体，包括进程ID、到达时间、服务时间、剩余时间等信息。
3.初始化所有进程，并按照到达时间排序。
4.创建一个循环队列，并将所有已到达的进程入队。
5.按照时间片大小循环执行以下步骤：a.从队列中取出一个进程，执行一次时间片大小的时间。
b.更新队列中所有进程的剩余时间。
c.如果剩余时间大于0，将进程放入队尾。
d.如果剩余时间等于0，表示进程执行完毕，将其从队列中移除。
e.输出每个时间片的调度情况。
6.统计平均等待时间和平均周转时间，并输出结果。
四、实验结果本次实验我们设置了4个进程，并且时间片大小为3、以下是每个时间片的调度情况：时间片1：进程1执行，剩余时间为2时间片2：进程2执行，剩余时间为4时间片3：进程3执行，剩余时间为5时间片4：进程1执行，剩余时间为1时间片5：进程2执行，剩余时间为3时间片6：进程3执行，剩余时间为4时间片7：进程4执行，剩余时间为2时间片8：进程1执行，剩余时间为0，进程1执行完毕时间片9：进程2执行，剩余时间为2时间片10：进程3执行，剩余时间为3时间片11：进程4执行，剩余时间为1时间片12：进程2执行，剩余时间为1时间片13：进程3执行，剩余时间为2时间片14：进程4执行，剩余时间为0，进程4执行完毕时间片15：进程2执行，剩余时间为0，进程2执行完毕时间片16：进程3执行，剩余时间为1时间片17：进程3执行，剩余时间为0根据以上调度情况，我们可以计算出平均等待时间和平均周转时间。
时间片轮转调度算法实验
时间片轮转调度算法实验时间片轮转调度算法是一种基于时间片轮转的进程调度算法，它按照轮转的方式，将每个进程分配一个时间片，如果该进程在时间片结束前未完成其任务，则该进程将被挂起，然后下一个进程继续执行。
下面将从实验过程、结果分析和算法优缺点三个方面回答该问题。
实验过程：本次实验使用C语言编写程序，模拟了一个简单的时间片轮转调度算法。
实验环境为Windows 10操作系统，使用了Dev-C++ 5.11编译器。
实验流程如下：1.首先定义了一个进程的结构体，其中包括了进程的名称、进程需要执行的时间片以及已经执行的时间片。
2.定义一个队列来存储进程，为了方便起见，队列采用了循环存储结构。
3.在主函数中，首先输入需要执行的进程数和一个时间片长度，接着依次输入每个进程的名称和需要执行的时间。
程序会根据输入的信息初始化进程，并将进程加入队列。
4.最后，程序开始模拟调度器的调度过程。
每次从队列中取出一个进程，将其执行时间减去一个时间片。
如果执行时间为0，则代表该进程已经完成任务，将其移出队列。
如果执行时间大于0，则将该进程重新加入队列尾部，然后下一个进程开始执行。
结果分析：在进行实验的过程中，我们发现时间片轮转调度算法可以很好地实现多进程的调度。
通过不断地轮转时间片，每个进程都有机会被执行。
此外，该算法具有良好的响应时间和公平性，能够确保每个进程都能够在一定时间内执行一定的任务，从而提高了系统的利用率和效率。
算法优缺点：时间片轮转调度算法具有以下几个优点：1. 公平性：每个进程都能够在一定时间内获得相同的可执行时间。
2. 可控性：时间片长度可以根据需要自行改变。
3. 高效性：可以很好地支持多进程的调度，提高了系统的利用率和效率。
同时，该算法也存在一些缺点：1.时间片的长度可能对进程的执行效率产生影响，长度过长会导致进程轮转过于缓慢，降低了系统的响应速度，长度过短则会增加进程上下文切换的次数。
2. 由于算法本身的局限性，它可能无法解决一些与进程先后顺序等有关的问题，例如死锁或者资源争用等。
时间片轮转调度算法实验报告
xx大学操作系统实验报告姓名：学号：班级：实验日期：实验名称：时间片轮转RR进程调度算法实验二时间片轮转RR进程调度算法1.实验目的：通过这次实验，理解时间片轮转RR进程调度算法的运行原理，进一步掌握进程状态的转变、进程调度的策略及对系统性能的评价方法。
2.需求分析(1) 输入的形式和输入值的范围；输入：进程个数n 范围：0<n<=100时间片q依次输入（进程名进程到达时间进程服务时间）所有进程平均带权周转时间：(3) 程序所能达到的功能1）进程个数n，输入时间片大小q，每个进程的到达时间T1, … ,T n和服务时间S1, … ,S n。
2）要求时间片轮转法RR调度进程运行，计算每个进程的周转时间和带权周转时间，并且计算所有进程的平均周转时间和带权平均周转时间；3）输出：模拟整个调度过程，输出每个时刻的进程运行状态；4）输出：输出计算出来的每个进程的周转时间、带权周转时间、所有进程的平均周转时间以及带权平均周转时间。
(4) 测试数据，包括正确的输入及其输出结果和含有错误的输入及其输出结果。
正确输入：错误输入：2、概要设计所有抽象数据类型的定义：static int MaxNum=100int ArrivalTime //到达时间int ServiceTime //服务时间int FinishedTime //结束时间int WholeTime //周转时间double WeightWholeTime //带权周转时间double AverageWT //平均周转时间double AverageWWT //平均带权周转时间主程序的流程:●变量初始化●接受用户输入的n，q ，T1…..Tn,S1….Sn;●进行进程调度，计算进程的开始运行时间、结束时间、执行顺序、周转时间、带权周转时间；●计算所有进程的平均周转时间、平均带权周转时间；●按照格式输出调度结果。
各程序模块之间的层次(调用)关系Main函数通过对Input函数进行调用，对函数的成员变量进行赋值，再通过RRAlgorithm函数求出题目要求的各个数据结果，最后通过display函数对结果进行格式输出。
OS_时间片轮转调度算法
OS_时间⽚轮转调度算法时间⽚轮转调度算法⼀．实验⽬的：1）学习时间⽚轮转调度算法。
2）学习C++程序设计的⽅法。
⼆．实验环境：1）⼀台运⾏Windows2000Professional操作系统计算机。
2）计算机中需要安装VisualC++6.0企业版。
三．实验内容：本实验主要是实现时间⽚轮转调度算法。
1）进⼊VisualC++的窗⼝，新建⼀个C++的⽂件，命名为01.cpp. 2）在源程序编辑窗⼝输⼊如下的源程序：#include#include#includeusing namespace std;int n;class PCB{public:int pri;//进程优先数int runtime;//进程运⾏CPU时间int pieceOftime;//轮转时间⽚string procname;//进程名string state;//进程状态int needOftime;//还需要时间int Counter;PCB * next;};PCB * run = NULL;PCB * ready = NULL;PCB * finish = NULL;PCB * tial = ready;void Dtime(int t);void Prinft(int a){if(a==1){cout<<"进程名称"<<"\\t"<<"优先数"<<"\\t"<<"还需要时间"<<"\\t"<<"已运⾏时间"<<"\\t"<<"状态:"<}elsecout<<"进程名称"<<"\\t"<<"已运⾏时间"<<"\\t"<<"还需要时间"<<"\\t"<<"计数器"<<"\\t"<<"时间⽚"<<" \\t"<<"状态"< }void Prinft(int b,PCB * p){if(b==1){cout<procname<<"\\t\\t"<pri<<"\\t"<needOftime<<"\\t\\t"<runtime<<"\\t\\t"<state<< endl;}elsecout<procname<<"\\t\\t"<runtime<<"\\t\\t"<needOftime<<"\\t\\t"<Counter<<"\\t"<pi eceOftime<<"\\t"<state<}void display(int c){PCB *p;if(run!=NULL) /*如果运⾏指针不空*/Prinft(c,run); /*输出当前正在运⾏的PCB*///Dtime(2);p=ready; /*输出就绪队列PCB*/while(p!=NULL){Prinft(c,p);p=p->next;}//Dtime(2);p=finish; /*输出完成队列的PCB*/while(p!=NULL){Prinft(c,p);p=p->next;}}void insert(PCB *p)//插⼊就绪队列按Pri⼤⼩{PCB *S1,*S2;if(ready==NULL){p->next = NULL;ready = p;}else{S1 = ready;S2 = S1;while(S1!=NULL){if(S1->pri >= p->pri){S2 = S1;S1 = S1->next;}elsebreak;}if(S2->pri >= p->pri){S2->next = p;p->next = S1;}else{p->next = ready;ready = p;}}}bool CTProcessOfPri(){PCB * Node;cout <<"输⼊创建进程的数⽬:"<>n;for(int j = 0;j < n; j++){Node = new PCB;if(Node==NULL)return false;else{cout <<"输⼊进程的名称,进程需CPU时间:"<cin >>Node->procname>>Node->needOftime;Node->runtime = 0;Node->state ="就绪";Node->pri =Node->needOftime;cout <<"进程"<procname<<"创建完毕!"<}insert(Node);}return true;}void priority(int i){run = ready;ready = ready->next;run->state = "运⾏";Prinft(i);while(run!=NULL) /*当运⾏队列不空时，有进程正在运⾏*/{run->runtime=run->runtime+1;run->needOftime=run->needOftime-1;run->pri=run->pri-1; /*每运⾏⼀次优先数降低1个单位*/if(run->needOftime==0) /*如所需时间为0将其插⼊完成队列*/ { run->state = "完成";run->next = finish;finish = run;run=NULL; /*运⾏队列头指针为空*/ if(ready!=NULL) /*如就绪队列不空*/ {run = ready;run->state = "运⾏";ready = ready->next;}}else if((ready!=NULL)&&(run->pripri)) {run->state="就绪";insert(run);run = ready;run->state = "运⾏";ready = ready->next;}display(i); /*输出进程PCB信息*/}}void queue(PCB *p){if(ready==NULL){p->next = NULL;ready = p;tial = p;}else{tial->next = p;tial = p;p->next = NULL;}}bool CTProcessOfRuntime(){PCB * Node;int m;cout <<"输⼊创建进程的数⽬:"<cin >>n;cout <<"输⼊时间⽚:"<cin >>m;for(int j = 0;j < n; j++){Node = new PCB;if(Node==NULL)return false;else{cout <<"输⼊进程的名称,进程需CPU时间:"< cin >>Node->procname>>Node->needOftime; Node->runtime = 0;Node->state ="就绪";Node->Counter = 0;Node->pieceOftime = m;cout <<"进程"<procname<<"创建完毕!"< queue(Node);}return true;}void Runtime(int c){run = ready;ready = ready->next;run->state = "运⾏";Prinft(c);while(run!=NULL){run->runtime=run->runtime+1;run->needOftime=run->needOftime-1;run->Counter = run->Counter + 1;if(run->needOftime==0){run->state = "完成";run->next = finish;finish = run;run = NULL;if(ready!=NULL){run = ready;ready = ready->next;}}else if(run->Counter == run->pieceOftime){run->Counter = 0;run->state = "就绪";queue(run);run=NULL;if(ready!=NULL){run = ready;run->state = "运⾏";ready = ready->next;}}display(c);}}int main(){int i;cout <<"*******************************************"<cout <<"* 1 优先数调度算法 2 循环时间⽚轮转算法*"<>i;switch(i){case 1:CTProcessOfPri();priority(i);break;case 2: CTProcessOfRuntime(); Runtime(i);break;default:break;}return 0;}void Dtime(int t){time_t current_time;time_t start_time;time(&start_time);do{time(& current_time);}while((current_time-start_time) 3）编译并运⾏，其结果为：4）输⼊相应的操作，结果为：。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
时间片轮转调度算法实验
时间片轮转调度算法是一种广泛应用于计算机操作系统中的调度算法。
本文将介绍时间片轮转调度算法的基本原理、特点以及实验过程。
一、时间片轮转调度算法的基本原理
时间片轮转调度算法是一种基于时间片的调度算法，它将CPU时间分配给多个进程，每个进程都被赋予一个时间片，当时间片用完后，该进程将被挂起，CPU时间将被分配给下一个进程。
被挂起的进程将被放入一个就绪队列中，等待下一轮时间片到来。
二、时间片轮转调度算法的特点
1.公平性：时间片轮转调度算法可以保证每个进程都能够得到一定的CPU时间，从而保证了公平性。
2.响应时间快：时间片轮转调度算法可以保证进程的响应时间快，因为每个进程都会被分配一定的CPU时间。
3.适用性广：时间片轮转调度算法适用于多种场景，包括多用户、多任务、实时任务等。
4.实现简单：时间片轮转调度算法的实现比较简单，可以通过一个就绪队列和一个定时器来实现。
三、时间片轮转调度算法的实验过程
1.实验环境：本次实验使用了Linux操作系统，编程语言为C++。
2.实验步骤：
（1）创建进程：首先需要创建多个进程，并将它们放入就绪队列中。
（2）分配时间片：为了模拟时间片轮转调度算法，需要为每个进程分配一个时间片。
（3）执行进程：按照就绪队列中的顺序，依次执行每个进程，并在执行完一个时间片后，将进程放回就绪队列中。
（4）更新进程状态：根据进程的执行情况，更新进程的状态，包括运行中、就绪、阻塞等。
（5）输出结果：最后，输出每个进程的执行结果，包括进程的状态、执行时间等。
3.实验结果：
经过实验，我们发现时间片轮转调度算法可以保证每个进程都能够得到一定的CPU时间，并且响应时间较快。
同时，我们也发现时间片的大小会对进程的执行时间和响应时间产生影响。
如果时间片过小，会导致进程频繁切换，从而降低CPU的利用率；如果时间片过
大，会导致进程响应时间过长，影响用户体验。
四、总结
时间片轮转调度算法是一种广泛应用于计算机操作系统中的调度算法，具有公平性、响应时间快、适用性广、实现简单等特点。
通过实验，我们可以更好地理解时间片轮转调度算法的原理和特点，从而更好地应用于实际场景中。