时间片轮转课程设计讲解

合集下载

时间片轮转法

时间片轮转法

轮转法调度
思考
假如在实际情况下,时间片大小为20ms,作业间调度花 费时间为5ms,则CPU的损耗率为20%,对每一个作业, 都有高达20%的损耗率是不可忍受的。而且时间片越小 损耗率越大,怎么办?
自然而然的,想到增大时间片的大小,例如增大到 500ms,则CPU损耗率只有1%,但是是否时间片越大,性 能越好?
试想,如果时间片足够大,使得所有的任务都可以在一 个时间片里运行完,那么轮转法就会退化为先来先服务 法,使得性能下降。
轮转法调度
总结
对时间片轮转法来说,合理的选择时间片的大小 是非常重要的。 若时间片选择太大:轮转法就会退化为先来先服 务法; 若时间片选择太小:则就会增加作业切换频率, 使得系统开销增大。
在实际当中,时间片一般选择100ms。
CPU调度-时间片轮转法
(假设听众都学习过先来先服务法)
轮转法调度
基本原理
★ 在轮转法中,系统将所有的就绪进程按先来先服务的 原则排成一个队列,每次调度时,把CPU分配给队首 进程,并令其执行一个时间片。当执行的时间片用完 时,产生中断,将该程序送往就绪队列的队尾,并把 处理机分配给新的队首进程,同时让它也执行一个时 间片。这样就保证就绪队列中的所有进程在一给定的 时间内均能获得一时间片的处理机执行时间。
P2
2
P3
10ห้องสมุดไป่ตู้
P4
4
P5
12
P1 P2 P3 P4 P5 P1 P3 P5 P3 P5
0 4 6 10 14 18 20 24 28 30 34
分析
P1 P2 P3 P4 P5
轮转法调度
到达时间 0 0 0 0 0
开始时间 0 4 6 10 14

采用时间片轮转算法调度程序

采用时间片轮转算法调度程序

采用时间片轮转算法调度程序学号:姓名:专业:指导教师:日期:目录一、需求分析 (3)1、设计要求: (3)2、解决方案: (3)二、课程设计简介 (4)1、课程设计题目 (4)2、课程设计目的 (4)3、课程设计内容 (4)4、时间安排 (4)三、概要设计 (4)1、基本原理 (4)2、算法思想设计 (5)3、数据结构及模块说明: (5)四、主要函数及其说明 (6)五、调试分析 (7)1、调试过程及步骤 (7)2、结果分析(以三个进程数为例) (8)六、总结及参考文献 (9)1、总结: (9)2、参考文献 (9)附录:程序源代码 (9)一、需求分析1、设计要求:在多道程序或多任务系统中,系统同时处于就绪状态的进程有若干个。

为了使系统中各进程能有条不紊地进行,必须选择某种调度策略,以选择一进程占用处理机。

要求用时间片轮转算法模拟单处理机调度,以巩固和加深处理机调度的概念。

2、解决方案:(1)、假设系统有5个进程,每个进程用一个进程控制块PCB来表示。

PCB包括:进程名、链接指针、到达时间、估计运行时间和进程状态。

其中,进程名即进程标识。

链接指针指出下一个到达进程的进程控制块地址,按照进程到达的顺序排队,统设置一个队头和队尾指针分别指向第一个和最后一个进程,新生成的进程放队尾。

估计运行时间:可由设计者任意指定一个时间值。

到达时间:进程创建时的系统时间或由用户指定,调度时,总是选择到达时间最早的进程。

进程状态:为简单起见,假定进程有三种状态,就绪、等待和完成,并假定进程一创建就处于就绪状态,用R表示,当一个进程运行结束时,就将其置成完成状态,用F表示。

当一个进程未运行完成并且时间片不足时,就将其置成等待状态,用W表示。

(2)、为每个进程任意确定一个要求运行时间和到达时间。

(3)、按照进程到达的先后顺序排成一个循环队列。

再设一队首指针指向第一个到达进程的首址。

(4)、执行处理机调度时,开始选择队首的第一个进程运行。

用时间片轮转法调度虚拟进程

用时间片轮转法调度虚拟进程

《操作系统课程设计》报告学号: _____________姓名: ______________班级: ____________指导教师: ______________报告日期:、课设目的通过对操作系统课程的学习,熟悉进程的概念、进程的管理与存储、进程的调度,通过实践深入理解进程的调度算法。

二、课设任务要求编写一个程序,可以创建若干个虚拟进程,并对若干个虚拟进程进行调度,调度策略为时间片轮转法,主要任务包括:进程的个数,进程的内容(即进程的功能序列)来源于一个进程序列描述文件,另外调度运行结果输出到一个运行日志文件;设计PCB适用于时间片轮转法;建立进程队列;实现时间片轮转调度算法,尽量可视化的展示调度的动态过程。

®总结程序设计的开发过程:需求分析、系统设计、系统实现及文档的收集和整理。

三、实验方法与设计分析每个进程有一个进程控制块(PCB)表示。

进程控制块可以包含如下信息:进程名、优先数、到达时间、需要运行时间、已用CPU时间、进程状态等等。

进程的优先数及需要的运行时间可以事先人为地指定(也可以由随机数产生)。

进程的到达时间为输入进程的时间。

进程的运行时间以时间片为单位进行计算。

每个进程的状态可以是就绪W( Wait)、运行R( Run)、或完成F(Fin ish )三种状态之一。

就绪进程获得CPU后都只能运行一个时间片。

用已占用CPU时间加1来表示。

如果运行一个时间片后,进程的已占用CPU时间已达到所需要的运行时间,则撤消该进程,如果运行一个时间片后进程的已占用CPU时间还未达所需要的运行时间,也就是进程还需要继续运行,此时应将进程的优先数减1 (即降低一级),然后把它插入就绪队列等待CPU 每进行一次调度程序都打印一次运行进程、就绪队列、以及各个进程的PCB,以便进行检查。

重复以上过程,直到所要进程都完成为止四、程序流程图增加进程结束进程#in elude "stdafx.h"#in elude <stdio.h>#in elude <stdlib.h>#in elude <stri ng.h>#in elude <etype.h>#in elude <iostream>#in elude <fstream>using n amespaee std;typedef struet n odestruet node *next; /*指向下一个进程的指针 */ }PCB;PCB *fini sh,*ready,*tail,*ru n;int N; /*定义进程的数目*/void firstin( void ){if (ready!二NULL){run二ready;ready二ready->n ext;run->state二'R'run->n ext=NULL;}else{run二NULL;}}void prt1( ehar a)■:结束五、程序源代码ehar n ame[10]; /* 进程名*/intround; /* 进程分配的时间片*/inteputime; /* 进程消耗的CUP寸间*/in t needtime;/* 进程需要的CUP寸间*/in t eount;/* 进程运行时间*/ehar state; /* 进程的状态:'R':运行:W:等待,'F':结束*/ofstream myfile( "bb.txt" ,ios::app||ios::tr un e);/*指向三个队列的队首的指针,tail为就绪队列的队尾指针*/<< " needtime" <<" count " <<" round" <<" state" <<endl; cputime" ;myfile << " needtime"" <<p->state<<endl;myfile<<p->state<<endl;void prt( char algo){PCB *p;prt1(algo);if (run!=NULL){prt2(algo,run);}p=ready;while (p!=NULL){prt2(algo,p);p=p->next;}p=finish;while (p!=NULL){prt2(algo,p);p=p->next;}getchar();}void insert(PCB *q){tail->next=q;tail=q;q->next=NULL;}void rcreate_task( char algo)PCB *p;void myfile<< " count " ;myfile<< " round" ;myfile<< " state" <<endl; prt2( char a,PCB *p) cout<<p->name<< " <<p->cputime<< " <<p->needtime<< " <<p->count<< " <<p->round<< "cout<< "name" << " cputime"myfile<< "name" ;myfile<<myfile<<p->name<< ";myfile<<p->cputime<< ;myfile<<p->needtime<< myfile<<p->count<<;myfile<<p->round<<int n,time;char na[10];ready=NULL;finish=NULL;run=NULL;cout<< " 请输入进程数目 N: ";cin>>N;for (n=0;n<N;n++){p=(PCB*)malloc( sizeof (PCB)); cout<< "Enter the name of process:" cin>>na;cout<< "Enter the time of process:" cin>>time;strcpy(p->name,na);p->cputime=0;p->needtime=time;p->count=0;p->state= 'W' ;p->round=2;if (ready!=NULL){insert(p);}else{p->next=ready;ready=p;tail=p;}}run=ready;ready=ready->next;run->state= 'R' ;cout<< "创建成功。

操作系统实验(时间片轮转)

操作系统实验(时间片轮转)

操作系统实验报告实验名称:时间片轮转调度班级:姓名:学号:实验目的:用高级语言编写和调试一个简单的时间片轮转调度程序,算法要求使用高优先权优先来进行进程调度。

实验内容:(1)用户输入进程名和优先级,并发执行的进程调度程序,每一个进程用一个进程控制块PCB 来代表。

PCB中应包含下列信息:进程名、进程优先数、进程需要运行的时间、占用CPU的时间及进程的状态等,各进程的优先数以及进程运行需要地时间片数,由用户输入。

(2)根据先来先服务原则,执行进程,每执行一次,需要时间减1,CPU时间片加1,在进程运行结束后,会显示进程的周转时间;(3)每个进程处于运行R、就绪W和完成F 三种状态之一,假定初始状态都为就绪状态W。

(4)系统能显示或打印各进程状态和参数的变化情况。

实验步骤:一、输入运行进程数目(测试数据为3);二、输入选择项(选择时间片轮转调度R);三、输入进程名称和服务时间;实验结果:小结:在这次试验中,主要掌握的是时间片轮转算法的执行过程,按照先来先服务原则,将进程排成一个队列,进程在所分配的时间片内运行的时候,修改自己的状态位,还有计数器加1操作,所需时间减1操作,时间片用完后,排在进程执行队列的尾部,处理机进行切换。

在进程运行结束后打印周转时间。

在最初实现算法的时候,没有添加计算周转时间的函数,后来通过在修改状态位的循环中添加计数器的累加语句,实现了在进程将状态位修改为“F”的时候系统输出周转时间。

源码:#include <stdio.h>#include <stdlib.h>#include <string.h>typedef struct node{char name[20]; /*进程的名字*/int prio; /*进程的优先级*/int round; /*分配CPU的时间片*/int cputime; /*CPU执行时间*/int needtime; /*进程执行所需要的时间*/char state; /*进程的状态,W--就绪态,R--执行态,F--完成态*/int count;/*记录执行的次数*/int count2; /*周转时间*/struct node *next; /*链表指针*/}PCB;PCB *ready=NULL,*run=NULL,*finish=NULL; /*定义三个队列,就绪队列,执行队列和完成队列*/int num;void GetFirst(); /*从就绪队列取得第一个节点*/void Output(); /*输出队列信息*/void InsertPrio(PCB *in); /*创建优先级队列,规定优先数越小,优先级越高*/void InsertTime(PCB *in); /*时间片队列*/void InsertFinish(PCB *in); /*时间片队列*/void PrioCreate(); /*优先级输入函数*/void TimeCreate(); /*时间片输入函数*/void Priority(); /*按照优先级调度*/void RoundRun(); /*时间片轮转调度*/int main(void){char chose;printf("请输入要创建的进程数目:\n");scanf("%d",&num);getchar();printf("输入进程的调度方法:(P/R)\n");scanf("%c",&chose);switch(chose){case 'P':case 'p':PrioCreate();Priority();break;case 'R':case 'r':TimeCreate();RoundRun();break;default:break;}Output();return 0;}void GetFirst() /*取得第一个就绪队列节点*/{run = ready;if(ready!=NULL){run ->state = 'R';ready = ready ->next;run ->next = NULL;}}void Output() /*输出队列信息*/{PCB *p;p = ready;printf("进程名\t优先级\t轮数\tcpu时间\t需要时间\t进程状态\t计数器\t周转时间\n"); while(p!=NULL){printf("%s\t%d\t%d\t%d\t%d\t\t%c\t\t%d\t%d\n",p->name,p->prio,p->round,p->cputime,p-> needtime,p->state,p->count,p->count2);p = p->next;}p = finish;while(p!=NULL){printf("%s\t%d\t%d\t%d\t%d\t\t%c\t\t%d\t%d\n",p->name,p->prio,p->round,p->cputime,p-> needtime,p->state,p->count,p->count2);p = p->next;}p = run;while(p!=NULL){printf("%s\t%d\t%d\t%d\t%d\t\t%c\t\t%d\n",p->name,p->prio,p->round,p->cputime,p->needt ime,p->state,p->count,p->count2);p = p->next;}}void InsertPrio(PCB *in) /*创建优先级队列,规定优先数越小,优先级越低*/{PCB *fst,*nxt;fst = nxt = ready;if(ready == NULL) /*如果队列为空,则为第一个元素*/{in->next = ready;ready = in;}else /*查到合适的位置进行插入*/{if(in ->prio >= fst ->prio) /*比第一个还要大,则插入到队头*/{in->next = ready;ready = in;}else{while(fst->next != NULL) /*移动指针查找第一个别它小的元素的位置进行插入*/{nxt = fst;fst = fst->next;}if(fst ->next == NULL) /*已经搜索到队尾,则其优先级数最小,将其插入到队尾即可*/{in ->next = fst ->next;fst ->next = in;}else /*插入到队列中*/{nxt = in;in ->next = fst;}}}}void InsertTime(PCB *in) /*将进程插入到就绪队列尾部*/{PCB *fst;fst = ready;if(ready == NULL){in->next = ready;ready = in;}else{while(fst->next != NULL){fst = fst->next;}in ->next = fst ->next;fst ->next = in;}}void InsertFinish(PCB *in) /*将进程插入到完成队列尾部*/ {PCB *fst;fst = finish;if(finish == NULL){in->next = finish;finish = in;}else{while(fst->next != NULL){fst = fst->next;}in ->next = fst ->next;fst ->next = in;}}void PrioCreate() /*优先级调度输入函数*/{PCB *tmp;int i;printf("输入进程名字和进程所需时间:\n");for(i = 0;i < num; i++){if((tmp = (PCB *)malloc(sizeof(PCB)))==NULL){perror("malloc");exit(1);}scanf("%s",tmp->name);getchar(); /*吸收回车符号*/scanf("%d",&(tmp->needtime));tmp ->cputime = 0;tmp ->state ='W';tmp ->prio = 50 - tmp->needtime; /*设置其优先级,需要的时间越多,优先级越低*/tmp ->round = 0;tmp ->count = 0;tmp ->count2 = 0;InsertPrio(tmp); /*按照优先级从高到低,插入到就绪队列*/}}void TimeCreate() /*时间片输入函数*/{PCB *tmp;int i;printf("输入进程名字和进程时间片所需时间:\n");for(i = 0;i < num; i++){if((tmp = (PCB *)malloc(sizeof(PCB)))==NULL){perror("malloc");exit(1);}scanf("%s",tmp->name);getchar();scanf("%d",&(tmp->needtime));tmp ->cputime = 0;tmp ->state ='W';tmp ->prio = 0;tmp ->round = 1; /*假设每个进程所分配的时间片是1*/tmp ->count = 0;tmp ->count2 = 0;InsertTime(tmp);}}void Priority() /*按照优先级调度,每次执行一个时间片*/{int flag = 1;GetFirst();while(run != NULL) /*当就绪队列不为空时,则调度进程如执行队列执行*/{Output(); /*输出每次调度过程中各个节点的状态*/while(flag){int count3;run->prio -= 2; /*优先级减去2*/run->cputime++; /*CPU时间片加一*/run->needtime--;/*进程执行完成的剩余时间减一*/run ->count2++;count3 = run ->count2;if(run->needtime == 0)/*如果进程执行完毕,将进程状态置为F,将其插入到完成队列*/{run ->state = 'F';run->count++; /*进程执行的次数加一*/run ->count2=count3;InsertFinish(run);flag = 0;}else /*将进程状态置为W,入就绪队列*/{run->state = 'W';run->count++; /*进程执行的次数加一*/run->count2++;InsertTime(run);flag = 0;}}flag = 1;GetFirst(); /*继续取就绪队列队头进程进入执行队列*/}}void RoundRun() /*时间片轮转调度算法*/{int flag = 1;GetFirst();while(run != NULL){Output();while(flag){int count3;run->count++;run->cputime++;run->needtime--;run->count2++;count3 = run ->count2;if(run->needtime == 0) /*进程执行完毕*/{run ->state = 'F';run ->count2++;run ->count2=count3;// printf("进程运行结束,shijian %d\n",&count2);InsertFinish(run);flag = 0;}else if(run->count == run->round)/*时间片用完*/{run->state = 'W';run ->count++;run ->count2++;//run->count++;// run->round++;/*计数器清零,为下次做准备*/InsertTime(run);flag = 0;}}flag = 1;GetFirst();}}。

进程调度模拟设计——时间片轮转、优先级法

进程调度模拟设计——时间片轮转、优先级法

学号:课程设计课程名字系统软件开发实训A题目进程调度模拟设计——时间片轮转、优先级法学院专业班级姓名指导教师2014 年01 月17 日课程设计任务书学生姓名:专业班级:指导教师:工作单位:题目: 进程调度模拟设计——时间片轮转、优先级法初始条件:1.预备内容:阅读操作系统的处理机管理章节内容,对进程调度的功能以及进程调度算法有深入的理解。

2.实践准备:掌握一种计算机高级语言的使用。

要求完成的主要任务:(包括课程设计工作量及其技术要求,以及说明书撰写等具体要求)1.模拟进程调度,能够处理以下的情形:⑴能够选择不同的调度算法(要求中给出的调度算法);⑵能够输入进程的基本信息,如进程名、优先级、到达时间和运行时间等;⑶根据选择的调度算法显示进程调度队列;⑷根据选择的调度算法计算平均周转时间和平均带权周转时间。

2.设计报告内容应说明:⑴课程设计目的与功能;⑵需求分析,数据结构或模块说明(功能与框图);⑶源程序的主要部分;⑷测试用例,运行结果与运行情况分析;⑸自我评价与总结。

时间安排:设计安排3周:查阅、分析资料 1天系统软件的分析与建模 4天系统软件的设计 5天系统软件的实现 3天撰写文档 1天课程设计验收答辩 1天设计验收安排:设计周的第三周的指定时间到实验室进行上机验收。

设计报告书收取时间:课程设计验收答辩完结时。

(注意事项:严禁抄袭,一旦发现,抄与被抄的一律按0分记)指导教师签名: 2013 年 12 月 10日系主任(或责任教师)签名: 2013 年 12 月 10日进程调度模拟设计——时间片轮转、优先级法1设计目的1.1 阅读操作系统的处理机管理章节内容,对进程调度的功能以及进程调度算法有深入的理解,能够使用其中的方法来进行进程调度模拟设计。

1.2 练掌握并运用时间片轮转和优先级法,掌握一种计算机高级语言的使用。

2 设计要求2.1 能够选择不同的调度算法(要求中给出的调度算法);2.2 能够输入进程的基本信息,如进程名、优先级、到达时间和运行时间等;2.3 根据选择的调度算法显示进程调度队列;2.4 根据选择的调度算法计算平均周转时间和平均带权周转时间。

时间片轮转课程设计讲解

时间片轮转课程设计讲解

武汉理工大学华夏学院课程设计报告书课程名称:操作系统原理题目:时间片轮转调度算法系名:信息工程系专业班级:姓名:学号:指导教师:司晓梅2015 年 6 月 26 日武汉理工大学华夏学院信息工程系课程设计任务书课程名称:操作系统原理课程设计指导教师:司晓梅班级名称:计算机1131-2 开课系、教研室:自动化与计算机一、课程设计目的与任务操作系统课程设计是《操作系统原理》课程的后续实践课程,旨在通过一周的实践训练,加深学生对理论课程中操作系统概念,原理和方法的理解,加强学生综合运用操作系统原理、Linux系统、C语言程序设计技术进行实际问题处理的能力,进一步提高学生进行分析问题和解决问题的能力,包含系统分析、系统设计、系统实现和系统测试的能力。

学生将在指导老师的指导下,完成从需求分析,系统设计,编码到测试的全过程。

二、课程设计的内容与基本要求1、课程设计题目时间片轮转进程调度模拟算法的实现2、课程设计内容用c/c++语言实现时间片轮转的进程调度模拟算法。

要求:1.至少要有5个以上进程2.进程被调度占有CPU后,打印出该进程正在运行的相关信息提示:时间片轮转调度算法中,进程调度程序总是选择就绪队列中的第一个进程,也就是说按照先来先服务原则调度,但一旦进程占用处理机则仅使用一个时间片。

在使用完一个时间片后,进程还没有完成其运行,它必须释放出处理机给下一个就绪的进程,而被抢占的进程返回到就绪队列的末尾重新排队等待再次运行。

1)进程运行时,只打印出相关提示信息,同时将它已经运行的时间片加1就可以了。

2)为进程设计出PCB结构。

PCB结构所包含的内容,有进程名、进程所需运行时间、已运行时间和进程的状态以及指针的信息等。

3、设计报告撰写格式要求:1设计题目与要求 2 设计思想3系统结构 4 数据结构的说明和模块的算法流程图5 使用说明书(即用户手册):内容包含如何登录、退出、读、写等操作说明6 运行结果和结果分析(其中包括实验的检查结果、程序的运行情况)7 自我评价与总结 8 附录:程序清单,注意加注释(包括关键字、方法、变量等),在每个模块前加注释;三、课程设计步骤及时间进度和场地安排本课程设计将安排在第17周, 现代教育技术中心。

操作系统实验(时间片轮转)

操作系统实验(时间片轮转)

操作系统




实验名称:时间片轮转调度
班级:
姓名:
学号:
实验目的:用高级语言编写和调试一个简单的时间片轮转调度程序。

实验内容:(1)用户输入进程,每一个进程用一个进程控制块PCB 来代表。

PCB 中应包含下列信息:进程名、进程优先数、进程需要运行的时间、占用
CPU的时间及进程的状态等,各进程的优先数以及进程运行需要地时
间片数,由用户输入。

(2)根据时间片轮转调度原则,执行进程,每执行一次,需要服务时间
减1(如果时间片=1),在进程运行结束后,会显示进程的周转时间;
(3)每个进程处于运行R、就绪W和完成F 三种状态之一,假定初
始状态都为就绪状态W。

(4)系统能显示或打印各进程状态和参数的变化情况。

实验步骤:
一、输入运行进程数目(测试数据为3);
二、输入选择项(选择时间片轮转调度R);
三、输入进程名称和服务时间;
实验结果:。

操作系统课程设计时间片轮转

操作系统课程设计时间片轮转

目录一、设计目的 (1)二、设计内容 (2)三、设计原理 (2)四、算法实现 (4)五、流程图 (6)六、源程序 (7)七、运行示例及结果分析 (12)八、心得体会 (12)九、参考资料 (13)时间片轮转法进行CPU调度一、设计目的处理机调度是操作系统中非常重要的部分。

为深入理解进程管理部分的功能,设计调度算法,模拟实现处理机的调度。

本课程设计是用时间片轮转算法模拟单处理机调度。

(1)创建进程,每个进程包括三组数据:进程名,进程到达时间,服务时间。

(2)自定义模拟的进程数目。

在进程数目之内,手动输入进程(进程名、到达时间和服务时间)。

自定义时间片大小。

(3)定义一个时间轴,为参考。

(4)初始化时间轴,根据先到先服务的原则,将已到达的进程插入到执行队列。

(5)分配给执行队列的队首一个时间片,开始运行时间片减1,时间轴则向前推进1,。

时间轴每推进一秒,检索是否有新的进程到达,若有则将到达的进程插入到执行队列的队尾。

(6)进程每运行1秒,服务时间减1,同时判断该进程是否运行完(服务时间是否为零)。

运行完则退出执行队列。

若没有则等待下一次运行。

(7)当一个时间片用完时,判断所有进程是否都运行完,若有,该模拟实验结束。

(8)当一个时间片用完时,判断该队首是否运行过一个完整的时间片,没有则保持该执行队列顺序不变。

有,则将该进程插入到队尾。

分配新的时间片给队首。

系统将所有的就绪进程按先来先服务的原则排成一个队列,每次调度时,把CPU分配给队首进程,并令其执行一个时间片。

时间片的大小从几ms到几百ms。

当执行的时间片用完时,由一个计时器发出时钟中断请求,调度程序便据此信号来停止该进程的执行,并将它送往就绪队列的末尾:然后,再把处理机分配给就绪队列中的队首进程,同时也让它执行一个时间片。

这样就可以保证就绪队列中的所有进程在一给定的时间内获得一时间片的处理机执行时间。

换言之,系统能在给定的时间内响应所有用户的请求。

优先级加时间片轮转进程调度算法_概述及解释说明

优先级加时间片轮转进程调度算法_概述及解释说明

优先级加时间片轮转进程调度算法概述及解释说明1. 引言1.1 概述本文旨在介绍优先级加时间片轮转进程调度算法。

进程调度是操作系统中的重要组成部分,它决定了多个进程之间的执行顺序和时间配比。

优先级调度算法和时间片轮转调度算法都是常用的进程调度算法,在不同场景下各具优缺点。

而结合这两种算法进行设计与实现,则能充分发挥它们的优势,提高系统的性能和效率。

1.2 文章结构本文将按照以下结构进行介绍:首先概述文章内容,明确文章重点和目标;然后详细讲解优先级调度算法,包括其定义、原理和实现方式;接着介绍时间片轮转调度算法,包括其定义、原理以及运行机制;随后探讨选择何种调度策略的问题;最后以设计思路与实现示例为基础,对结合优先级与时间片轮转调度算法进行分析,并进行性能评估和对比研究。

1.3 目的本文旨在深入探讨优先级加时间片轮转进程调度算法,阐明其背后的原理与机制,并通过实例演示说明如何设计与实现该算法。

此外,本文还将对该调度算法的优缺点进行分析,并提出进一步研究的方向和展望。

通过本文的阐述,读者能够全面了解并掌握优先级加时间片轮转进程调度算法的实现与应用。

2. 优先级调度算法:2.1 定义与原理:优先级调度算法是一种基于进程优先级的调度方法。

每个进程被赋予一个优先级,优先级越高的进程被认为是更重要的任务,应该在其他进程之前得到处理器资源。

该算法的原理是根据进程的优先级来确定调度顺序。

当有多个就绪状态的进程等待执行时,调度程序会选择具有最高优先级的进程执行。

如果两个或多个进程具有相同的优先级,则采用其他策略(如轮转或抢占)来选择将要运行的进程。

2.2 实现方式:实现这种调度算法可以采用不同的方法。

一种常见的方式是为每个进程分配一个固定的静态优先级,其值通常在范围内确定(比如0到255),其中较大的数字表示较高的优先级。

另一种方式是动态地根据某些因素为进程分配优先级,如当前执行时间、等待时间、紧迫性等。

在操作系统中,可以使用一个队列来存储就绪状态下各个进程,并按照它们的优先级进行排序。

操作系统课程设计时间片轮转算法

操作系统课程设计时间片轮转算法

成一个循环链队列,用函数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;},这样在前面进程运行完成输出后,后面再循环时就不会重新输出一遍了。

实验一 时间片轮转进程调度算法

实验一 时间片轮转进程调度算法

实验一时间片轮转进程调度算法时间片轮转(Round Robin)是一种常见的进程调度算法,其核心思想是每个进程被分配一个时间片,当时间片用完时,CPU会切换到下一个进程。

这种算法简单高效,能够保证每个进程都能获得公平的CPU时间。

在时间片轮转算法中,每个进程被分配一个相同大小的时间片,通常为几十毫秒到几百毫秒不等。

当一个进程占用完了其时间片,CPU会将其放入就绪队列的末尾,并将CPU分配给队列中的下一个进程。

这种方式可以确保每个进程都有机会运行,并且不会出现某个进程长时间占用CPU,导致其他进程饥饿的情况。

时间片轮转算法的优点之一是简单易实现,只需要设置一个固定的时间片大小和一个就绪队列即可。

另外,由于每个进程都有相同的时间片,因此可以较好地保证公平性,避免某个进程长时间占用CPU而导致其他进程无法运行的情况。

然而,时间片轮转算法也存在一些缺点。

首先,如果时间片设置过小,会导致频繁的进程切换,增加了系统的开销。

而如果时间片设置过大,可能会出现某些进程长时间占用CPU的情况,降低了系统的响应速度。

因此,选择合适的时间片大小对系统的性能至关重要。

另外,时间片轮转算法对I/O密集型的进程并不友好。

由于I/O操作需要等待外部设备的响应,进程可能会在I/O操作期间主动放弃CPU,这样会导致进程在等待I/O时浪费了部分时间片。

为了解决这个问题,可以考虑将I/O操作的等待时间纳入时间片,或者采用其他更适合I/O密集型进程的调度算法。

总的来说,时间片轮转算法是一种简单高效的进程调度算法,适用于大多数情况下。

在实际应用中,需要根据系统的特点和需求选择合适的时间片大小,以提高系统的性能和响应速度。

同时,针对不同类型的进程可以结合其他调度算法,以达到更好的效果。

操作系统实验2时间片轮转

操作系统实验2时间片轮转

实验二时间片轮转【实验目的】通过这次实验,加深对进程概念的理解,进一步掌握进程状态的转变、进程调度的策略及对系统性能的评价方法。

【实验内容】问题描述:设计程序模拟进程的时间片轮转RR调度过程。

假设有n个进程分别在T1, …,T n时刻到达系统,它们需要的服务时间分别为S1, … ,S n。

分别利用不同的时间片大小q,采用时间片轮转RR进程调度算法进行调度,计算每个进程的完成时间,周转时间和带权周转时间,并且统计n个进程的平均周转时间和平均带权周转时间。

程序要求如下:1)进程个数n;每个进程的到达时间T1, … ,T n和服务时间S1, … ,S n;输入时间片大小q。

2)要求时间片轮转法RR调度进程运行,计算每个进程的周转时间,带权周转时间,并且计算所有进程的平均周转时间,带权平均周转时间;3)输出:要求模拟整个调度过程,输出每个时刻的进程运行状态,如“时刻3:进程B 开始运行”等等;4)输出:要求输出计算出来的每个进程的周转时间,带权周转时间,所有进程的平均周转时间,带权平均周转时间。

源程序在VisualC++6.0中实现//RR算法#include<iostream.h>#include<iomanip.h>#include<stdio.h>#include<conio.h>#include<malloc.h>#include<stdlib.h>typedef int QElemType;#define OK 1#define ERROR 0#define OVERFLOW -1typedef int Status;typedef struct QNode{QElemType data;struct QNode *next;}QNode,*QueuePtr;typedef struct{QueuePtr front;QueuePtr rear;Status InitQueue(LinkQueue &Q);Status DestroyQueue(LinkQueue &Q);Status EnQueue(LinkQueue &Q,QElemType e);int DeQueue(LinkQueue &Q,QElemType e);bool QueueEmpty(LinkQueue &Q);static const int MaxNum=100;intn,q,ArrivalTime[MaxNum],ServiceTime[MaxNum],FinishedTime[MaxNum],WholeTime[MaxNu m];double WeightWholeTime[MaxNum],Average_WT=0,Average_WWT=0;LinkQueue Q;void RR(int*ArrivalTime,int*ServiceTime,int n,int q,LinkQueue &Q);void main(){cout<<"请输入进程总数n的值(0<n<=100):"<<endl;cin>>n;while(n<0||n>100){cout<<"你输入的n的值不正确,请重新输入!"<<endl;cin>>n;}cout<<"请依次输入各个进程的到达时间:"<<endl;for(int i=0;i<n;i++)cin>>ArrivalTime[i];cout<<"请依次输入各个进程的服务时间:"<<endl;for( i=0;i<n;i++)cin>>ServiceTime[i];cout<<"请输入时间片q的值(0<q<=200):"<<endl;cin>>q;while(q<0||q>200){cout<<"你输入的q值不正确,请重新输入!"<<endl;cin>>q;}RR(ArrivalTime,ServiceTime,n,q,Q);//调用RR算法}//RR算法的具体实现void RR(int*ArrivalTime,int*ServiceTime,int n,int q,LinkQueue &Q){int countTime=0,e;int STime[MaxNum],pushed[MaxNum];for(int i=0;i<n;i++){STime[i]=ServiceTime[i];pushed[i]=0;}EnQueue(Q,0);pushed[0]=1;int time=0;while(QueueEmpty(Q)==false){e=DeQueue(Q,e);if(STime[e]>q){STime[e]=STime[e]-q;countTime+=q;}else{countTime+=STime[e];STime[e]=0;FinishedTime[e]=countTime;}while(time<countTime){if(STime>0){cout<<"时刻"<<setw(2)<<time<<":进程"<<e<<"正在运行"<<endl;}time++;}for(i=1;i<n;i++){if(STime!=0&&i!=e&&ArrivalTime[i]<countTime&&pushed[i]==0||STime!=0&&i!=e&&A rrivalTime[i]==countTime){EnQueue(Q,i);pushed[i]=1;}}if(STime[e]>0)//判断进程e是否已执行完{EnQueue(Q,e);}}for(i=0;i<n;i++){//求周转时间和带权周转时间WholeTime[i]=FinishedTime[i]-ArrivalTime[i];WeightWholeTime[i]=(double)(WholeTime[i]*1.000000/ServiceTime[i]);Average_WT+=WholeTime[i];Average_WWT+=WeightWholeTime[i];}Average_WT/=n;//求平均周转时间Average_WWT/=n;//求平均带权周转时间//----------------输出----------------cout<<"完成:"<<" ";for(i=0;i<n;i++)cout<<setw(8)<<FinishedTime[i]<<" ";cout<<endl;cout<<"周转:"<<" ";for(i=0;i<n;i++)cout<<setw(8)<<WholeTime[i]<<" ";cout<<endl;cout<<"带权:"<<" ";for(i=0;i<n;i++)cout<<setw(8)<<setiosflags(ios::fixed)<<setprecision(2)<<WeightWholeTime[i]<<" "; cout<<endl;cout<<"平均周转时间为:"<<Average_WT<<endl;cout<<"平均带权周转时间为:"<<Average_WWT<<endl;DestroyQueue(Q);}//初始化链队列QStatus InitQueue(LinkQueue &Q){Q.front=Q.rear=(QueuePtr)malloc(sizeof(QNode));if(!Q.front)exit(OVERFLOW);Q.front->next=NULL;return OK;}//销毁链队列QStatus DestroyQueue(LinkQueue &Q){while(Q.front){Q.rear=Q.front->next;free(Q.front);Q.front=Q.rear;}return OK;}//入队Status EnQueue(LinkQueue &Q,QElemType e){QueuePtr p=(QueuePtr)malloc(sizeof(QNode));if(!p) exit(OVERFLOW);p->data=e;p->next=NULL;Q.rear->next=p;Q.rear=p;return OK;}//出队,并用e返回出队节点的元素值int DeQueue(LinkQueue &Q,QElemType 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 e;}//判断链队列Q是否为空bool QueueEmpty(LinkQueue &Q){if(Q.front==Q.rear)return true;else return false;}实例运行截图。

{时间管理}用时间片轮转法调度虚拟进程

{时间管理}用时间片轮转法调度虚拟进程

(时间管理)用时间片轮转法调度虚拟进程《操作系统课程设计》方案学号:姓名:班级:指导教师:方案日期:壹、课设目的通过对操作系统课程的学习,熟悉进程的概念、进程的管理和存储、进程的调度,通过实践深入理解进程的调度算法。

二、课设任务要求编写壹个程序,能够创建若干个虚拟进程,且对若干个虚拟进程进行调度,调度策略为时间片轮转法,主要任务包括:①进程的个数,进程的内容(即进程的功能序列)来源于壹个进程序列描述文件,另外调度运行结果输出到壹个运行日志文件;②设计PCB适用于时间片轮转法;③建立进程队列;④实现时间片轮转调度算法,尽量可视化的展示调度的动态过程。

○5总结程序设计的开发过程:需求分析、系统设计、系统实现及文档的收集和整理。

三、实验方法和设计分析每个进程有壹个进程控制块(PCB)表示。

进程控制块能够包含如下信息:进程名、优先数、到达时间、需要运行时间、已用CPU时间、进程状态等等。

进程的优先数及需要的运行时间能够事先人为地指定(也能够由随机数产生)。

进程的到达时间为输入进程的时间。

进程的运行时间以时间片为单位进行计算。

每个进程的状态能够是就绪W(Wait)、运行R(Run)、或完成F(Finish)三种状态之壹。

就绪进程获得CPU后均只能运行壹个时间片。

用已占用CPU时间加1来表示。

如果运行壹个时间片后,进程的已占用CPU 时间已达到所需要的运行时间,则撤消该进程,如果运行壹个时间片后进程的已占用CPU 时间仍未达所需要的运行时间,也就是进程仍需要继续运行,此时应将进程的优先数减1(即降低壹级),然后把它插入就绪队列等待CPU 。

每进行壹次调度程序均打印壹次运行进程、就绪队列、以及各个进程的PCB ,以便进行检查。

重复之上过程,直到所要进程均完成为止四、程序流程图是五、程序源代码#include"stdafx.h"#include<stdio.h>#include<stdlib.h>#include<string.h>#include<ctype.h> #include<iostream> #include<fstream>usingnamespacestd;ofstreammyfile("bb.txt",ios::app||ios::trunc);typedefstructnode{charname[10];/*进程名*/intround;/*进程分配的时间片*/intcputime;/*进程消耗的CUP时间*/intneedtime;/*进程需要的CUP时间*/intcount;/*进程运行时间*/charstate;/*进程的状态:'R':运行,'W':等待,'F':结束*/structnode*next;/*指向下壹个进程的指针*/}PCB;PCB*finish,*ready,*tail,*run;/*指向三个队列的队首的指针,tail为就绪队列的队尾指针*/intN;/*定义进程的数目*/voidfirstin(void){if(ready!=NULL){run=ready;ready=ready->next;run->state='R';run->next=NULL;}else{run=NULL;}}voidprt1(chara){cout<<"name"<<"cputime"<<"needtime"<<"count"<<"round"<<"state"<<endl;myfile<<"name";myfile<<"cputime";myfile<<"needtime";myfile<<"count";myfile<<"round";myfile<<"state"<<endl;}voidprt2(chara,PCB*p){cout<<p->name<<""<<p->cputime<<""<<p->needtime<<""<<p->count<<""<<p->round<<""<<p->state<<endl; myfile<<p->name<<"";myfile<<p->cputime<<"";myfile<<p->needtime<<"";myfile<<p->count<<"";myfile<<p->round<<"";myfile<<p->state<<endl;}voidprt(charalgo){PCB*p;{prt2(algo,run);}p=ready;while(p!=NULL){prt2(algo,p);p=p->next;}p=finish;while(p!=NULL){prt2(algo,p);p=p->next;}getchar();}voidinsert(PCB*q){tail->next=q;tail=q;q->next=NULL;}voidrcreate_task(charalgo){PCB*p;intn,time;charna[10];ready=NULL;finish=NULL;run=NULL;cout<<"请输入进程数目N:";cin>>N;for(n=0;n<N;n++){p=(PCB*)malloc(sizeof(PCB));cout<<"Enterthenameofprocess:"<<endl; cin>>na;cout<<"Enterthetimeofprocess:"<<endl; cin>>time;strcpy(p->name,na);p->cputime=0;p->needtime=time;p->round=2;if(ready!=NULL){insert(p);}else{p->next=ready;ready=p;tail=p;}}run=ready;ready=ready->next;run->state='R';cout<<"创建成功。

操作系统时间片轮转算法

操作系统时间片轮转算法

进程时间片轮转调度算法一、实验题目:进程时间片轮转调度算法二、实验原理:在多道程序系统中,一个作业被提交后必须经过处理机调度后,方能获得处理机执行。

对调度的处理又都可采用不同的调度方式和调度算法。

调度算法是指:根据系统的资源分配策略所规定的资源分配算法。

三、实验目的: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;}。

时间片轮转详解

时间片轮转详解

• • • • • • • • • • • • • • • • • • •
p=p->next; } return flag; } void creatProcess(int n){ //时间片轮转算法 PCB *s,*p; int i,j,flag1=0; s = (PCB *)malloc(sizeof(PCB)); s=front; printf("\n--------------------------------------------\n"); output(); printf("Press any key to continue...\n\n"); getch(); //按任意键继续 s=front; while(flag1 != 1){ if(s->condition == 'r'){ s->worked_time++; s->need_time--; if(s->need_time==0)
• 时间片设得太短会导致过多的进程切换, 降低了CPU效率;而设得太长又可能引起对 短的交互请求的响应变差。将时间片设为 100毫秒通常是一个比较合理的折衷。
时间片轮转算法的主要实现过程
• 首先为每一个进程创建一个进程控制块,定义数 据结构,说明进程控制块所包含的内容,有进程 名、进程所需运行时间、已运行时间和进程的状 态以及指针的信息。实现的过程即运用指针指向 某一个进程,判断当前的进程是否是就绪状态 “r”,如果是,则为该进程分配一个时间片,同 时,已运行时间加一且要求运行的时间减一,如 此循环执行,当某一个进程的所需要运行的时间 减少至0时,则将该进程的状态设置为“e”。然 后,将指针指向下一个未运行完成的进程,重复 判断,直至所有的进程都运行结束

时间片轮转调度算法

时间片轮转调度算法

(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);//处理某个等待队列,适时将完成进程移出到后备就绪队列。

操作系统课程设计报告-基于时间片的轮转调度算法[61页].doc

操作系统课程设计报告-基于时间片的轮转调度算法[61页].doc

操作系统课程设计报告选题名称:基于时间片的高优先级调度模拟实现系(院):经济管理学院专业:信息管理与信息系统班级:信管1091设计任务书课题名称基于时间片的高优先级调度模拟实现设计目的1.理解进程调度相关理论。

2.掌握时间片调度原理。

3.掌握高优先级调度原理。

实验环境1.硬件:PC机,奔腾IV以上CPU,512MB以上内存,80G以上硬盘。

2.软件:Windows2000/XP、Microsoft Visual C++ 6.0。

任务要求1.搜集基于时间片的高优先级调度模拟实现可能涉及到的知识和相关资料。

2.应用Microsoft Visual C++ 6.0集成开发环境,设计并实现一个基于时间片的高优先级调度模拟程序。

3.确保基于时间片的高优先级调度模拟程序能正确运行。

4.参加答辩,撰写课程设计报告。

工作进度计划序号起止日期工作内容1 2012.1.1 课题任务下达,查阅文献资料2 2012.1.2~2012.1.3 课题总体设计、素材搜集与处理3 2012.1.4~2012.1.7 课题详细设计、调试、完善设计4 2012.1.8 答辩,撰写报告指导教师(签章):年月日摘要操作系统(Operating System,简称OS)是计算机系统的重要组成部分,是一个重要的系统软件,它负责管理计算机系统的硬、软件资源和整个计算机的工作流程,协调系统部件之间,系统与用户之间、用户与用户之间的关系。

随着操作系统的新技术的不断出现功能不断增加。

操作系统作为一个标准的套装软件必须满足尽可能多用户的需要,于是系统不断膨胀,功能不断增加,并逐渐形成从开发工具到系统工具再到应用软件的一个平台环境。

更能满足用户的需求。

随着计算机技术的不断发展,人们对于计算机系统性能的要求也越来越高,对于操作系统所使用的算法也在不断地发展。

OS对调度分配实质是一种资源分配,因而调度算法要根据不同的系统资源分配策略所规定的来分配算法。

对于不同的系统目标,又必须采用不同的调度算法。

2-时间片轮转rr算法[整理版]

2-时间片轮转rr算法[整理版]

操作系统实验报告一、实验题目时间片轮转算法(RR算法)二、实验目的模拟实现时间片轮转调度算法。

理解时间轮转算法的处理机调度的基本思想。

三、实验要求1.初始化函数,输入各个进程的到达时间以及需要的运行的时间。

2.设置时间片大小,实现进程有等待到运行状态的转换。

3.进程运行时间结束后从进程列表中删除该进程。

四、实验内容在时间片调度算法的模拟实现中,时间片就是分配给进程运行的一段时间。

在轮转法中,系统将所有的可运行(即就绪)进程按先来先服务的原则,排成一个队列,每次调度时把CPU分配给队首进程,并令其执行一个时间片。

当某进程执行的时间片用完时,系统发出信号,通知调度程序,调度程序便据此信号来停止该进程的执行,并将刚运行的进程送到运行队列的末尾,等待下一次执行;然后,把处理机分配给就绪队列中新的队首进程,同时也让它执行一个时间片。

这样就可以保证运行队列中的所有进程,在一个给定的时间内,均能获得一时间片的处理机执行时间。

本实验设计一个有N个进程并发的进程调度程序,采用时间片轮转算法。

每一个进程用一个进程控制块PCB表示。

PCB包含信息有:进程名nme,进程号id,进程状态stte,进程所需运行时间need_time,进程运行时间run_time。

进程运行时间以时间片为单位进行计算。

(程序中以按任意键表示运行一次CPU时间片)每个进程的状态有就绪W,运行R,和完成(撤销进程)。

就绪的进程获得CPU后只能运行一个时间片,运行完运行时间run_time+1。

如果运行一个时间片后,进程的run_time等于need_time(即已经达到所需运行时间),则撤销该进程并提示,如果还未达到,则将其放到队尾,进入就绪状态等待下一次时间片分配。

每一次调度程序都打印一次运行情况,包括:运行的进程,就绪队列的进程,已经所有进程的PCB(不包括已经撤销的进程)。

五、实验结果:六、实验小结由于自己自编写代码方面与他人有一定的差距,因此在做实验的过程中我在网上搜了很多相关的资料,了解实现该算法的原理及各部分实现的代码,同时参考了几个别人写好的源代码,然后自己在理解的基础上不断的根据要求修改写程序,不过其中碰见的很多的问题。

计算机操作系统时间片循环轮转算法

计算机操作系统时间片循环轮转算法

计算机操作系统时间片循环轮转算法实验报告书课程名:«计算机操作系统»题目:时间片循环轮转调度班级:软件081班学号:110831116姓名:陈点点(4) 处置器调度总是选择标志单元指示的进程运转。

由于本实验是模拟处置器调度的功用,所以,对被选中的进程并不实践的启动运转,而是执行:已运转时间+1来模拟进程的一次运转,表示进程曾经运转过一个单位的时间。

请留意:在实践的系统中,当一个进程被选中运转时,必需置上该进程可以运转的时间片值,以及恢复进程的现场,让它占有处置器运转,直到出现等候事情或运转满一个时间片。

在这时省去了这些任务,仅用〝已运转时间+1〞来表示进程曾经运转满一个时间片。

(5) 进程运转一次后,应把该进程的进程控制块中的指针值送到标志单元,以指示下一个轮到运转的进程。

同时,应判别该进程的要求运转时间与已运转时间,假定该进程的要求运转时间 已运转时间,那么表示它尚未执行完毕,应待到下一轮时再运转。

假定该进程的要求运转时间=已运转时间,那么表示它曾经执行完毕,应指点它的形状修正成〝完毕〞〔E〕且参与队列。

此时,应把该进程的进程控制块中的指针值送到前面一个进程的指针位置。

(6) 假定〝就绪〞形状的进程队列不为空,那么重复下面的〔4〕和〔5〕的步骤,直到一切的进程都成为〝完毕〞形状。

(7) 在所设计的顺序中应有显示或打印语句,能显示或打印每次选中进程的进程名以及运转一次后进程队列的变化。

(8) 为五个进程恣意确定一组〝要求运转时间〞,启动所设计的处置器调度顺序,显示或打印逐次被选中的进程名以及进程控制块的静态变化进程。

五、流程图与源顺序int ProcNum; // 总进程个数// 初始化就绪队列void InitPCB(Proc &H) {cout<<"请输入总进程个数: ";cin>>ProcNum; // 进程总个数int Num=ProcNum;H=(Proc)malloc(sizeof(PNode)); // 树立头节点H->next=NULL;Proc p=H; //定义一个指针cout<<"总进程个数为 "<<ProcNum<<" 个,请依次输入相应信息\n\n";while (Num--) {p=p->next=(Proc)malloc(sizeof(PNode));cout<<"进程名总运转时间已运转时间 :";cin>>p->name>>p->All_Time>>p->Runed_Time;p->state='R';p->next=NULL;}p->next=H->next;}//输入运转中的进程信息void DispInfo(Proc H) {Proc p=H->next;do {if (p->state != 'E') //假设该进程的形状不是End的话{cout<<"进程名:"<<p->name<<"\t总运转时间:"<<p->All_Time <<"\t已运转时间:"<<p->Runed_Time<<"\t形状:"<<p->state<<endl;p=p->next;}else p=p->next;} while (p != H->next); // 整个进程链条一直完整,只是形状位有差异}// 时间片轮转法void SJP_Simulator(Proc &H) {cout<<endl<<"-------------------START--------------------\n";int flag=ProcNum; // 记载剩余进程数int round=0; // 记载轮转数Proc p=H->next;while (p->All_Time > p->Runed_Time) { // 即未完毕的进程round++;cout<<endl<<"Round "<<round<<"--正在运转 "<<p->name<<" 进程"<<endl; p->Runed_Time++; // 更矫正在运转的进程的已运转时间DispInfo(H); // 输入此时为就绪形状的进程的信息if (p->All_Time == p->Runed_Time) { // 并判别该进程能否完毕p->state='E';flag--;cout<<p->name<<" 进程已运转完毕,进程被删除!\n";}p=p->next;while (flag && p->All_Time == p->Runed_Time)p=p->next; // 跳过先前已完毕的进程}cout<<endl<<"--------------------END---------------------\n";}void main() {Proc H;InitPCB(H); // 数据初始化DispInfo(H); // 输入此刻的进程形状SJP_Simulator(H); // 时间片轮转法system("pause");}六、测试数据与实验结果七、结果剖析与实验体会时间片轮转算法中,系统将一切的就绪顺序按先来先效劳的原那么排成一个队列,每次调度时,把CPU分配给队首进程,并令其执行一个时间片。

  1. 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。

院学学华夏武汉理工大课程设计报告书操作系统原理课程名称:时间片轮转调度算法题目:系名:信息工程系专业班级:名:姓学号:指导教师司晓梅:2015626日年月武汉理工大学华夏学院信息工程系课程设计任务书课程名称:操作系统原理课程设计指导教师:司晓梅自动化与计算开课系、教研室:班级名称:计算机1131-2机一、课程设计目的与任务操作系统课程设计是《操作系统原理》课程的后续实践课程,旨在通过一周的实践训练,加深学生对理论课程中操作系统概念,原理和方法的理解,加强学生综合运用操作系语言程序设计技术进行实际问题处理的能力,进一步提高学生进统原理、Linux系统、C行分析问题和解决问题的能力,包含系统分析、系统设计、系统实现和系统测试的能力。

学生将在指导老师的指导下,完成从需求分析,系统设计,编码到测试的全过程。

二、课程设计的内容与基本要求1、课程设计题目时间片轮转进程调度模拟算法的实现2、课程设计内容用c/c++语言实现时间片轮转的进程调度模拟算法。

要求:个以上进程5 1.至少要有后,打印出该进程正在运行的相关信息CPU.2进程被调度占有提示:时间片轮转调度算法中,进程调度程序总是选择就绪队列中的第一个进程,也就是说按照先来处理机则仅使用一个时间片。

在使用完一个时间片后,进程还没先服务原则调度,但一旦进程占用有完成其运行,它必须释放出处理机给下一个就绪的进程,而被抢占的进程返回到就绪队列的末尾重新排队等待再次运行。

1)进程运行时,只打印出相关提示信息,同时将它已经运行的时间片加就可以了。

1PCB结构所包含的内容,有进程名、进程所需运行时间、已运行2)为进程设计出PCB结构。

时间和进程的状态以及指针的信息等。

、设计报告撰写格式要求:31设计题目与要求2设计思想3系统结构数据结构的说明和模块的算法流程图45:内容包含如何登录、退出、读、写等操作说明使用说明书(即用户手册)运行结果和结果分析(其中包括实验的检查结果、程序的运行情况)6.7自我评价与总结8附录:程序清单,注意加注释(包括关键字、方法、变量等),在每个模块前加注释;三、课程设计步骤及时间进度和场地安排本课程设计将安排在第17周,现代教育技术中心。

具体安排如下:课程设计集中时间安排:星期三星期四星期一星期二星期五周次第3-6节第2-3节第2-3第17周第2-3节第2-3节节现教地点现教现教现教现教四、课程设计考核及评分标准课程设计考核将综合考虑学生的系统设计方案、运行结果、课程设计报告书的质量、态度、考勤、答辩情况等各因素。

具体评分标准如下:(1)设计方案正确,具有可行性、创新性;30分20)系统开发效果较好;分2(20分(3)设计报告规范、课程设计报告质量高、参考文献充分(4)课程设计答辩时,问题回答正确;20分分5()态度认真、刻苦钻研、遵守纪律;10按上述五项分别记分后求和,总分按五级制记载最后成绩。

6960格,分7970等,分8980好,分90100优秀(~)良(~)中(~)及(~分)分)59~0,不及格(.1、实验概叙1.1实验目的弄明白时间片轮转的工作流程和原理,通过实验让自己更明白切身体会的深!时间片轮转主要是解决处理机调度进程时的优化!正确理解提高处理机的利用率及改善系统性能在很大程度上取决于处理机调度性能的好坏,在操作系统中调度的实质是一种资源分配,调度算法是指根据系统的资源分配策略规定的资源分配算法,对不同的系统和系统目标,应采用不的调度算法。

在多道程序或多任务系统中,系统同时处于就绪状态的进程有若干个。

也就是说能运行的进程数远远大于处理机个数。

为了使系统中的各进程能有条不紊地运行,必须选择某种调度策略,以选择一进程占用处理机。

通过本实验,加深对处理机调度的理解。

弄明白时间片轮转的工作流程和原理,通过实验让自己更明白切身体会的深!1.2实验原理基于时间片轮转调度算法思想用C语言编程实现1.3实验环境(使用的软件)Visual C++6.02、实验思想及内容2.1设计思想按照时间片工作原理:时间片轮转的原则是系统将所有的就绪进程按照先来先服务的原则排成一个队列,每次调度时,把CPU分配对手进程,并令其执行一个时间片,当执行完时,有一个计时器发出时钟中断请求,该进程停止,并被送到就绪队列的末尾,然后再把处理机分配就绪队列的队列进程,同时也让它执行一个时间片!2.2实验原理基于时间片轮转调度算法思想用C语言编程实现2.3系统结构设计时间片大小固定,由用户输入。

进程个数由用户输入。

每个进程用一个PCB表示。

PCB包括进程名,到达时间,运行时间,剩余时间,进程状态,链接指针。

其中,进程名,到达时间和运行时间由用户输入,剩余时间的初值等于运行时间。

为简单起见,进程状态设为三种:就绪,运行和完成。

链接指针指向下一个进程的PCB;按照进程到达的先后顺序排成一个队列。

设置一个队头指针指向队列中第一个进程,并设置一个队尾指针指向队列中的最后一个进程;执行调度时,先选择队首的第一个进程运行。

另外设置一个指向当前运行进程的指针;由于本实验是模拟实验,所以对选中进程并不实际启动运行,而只是执行:被选中进程的状态置为运行态;被选中进程的剩余时间减去时间片大小;按照队列的顺序依次输出每个进程的进程名,到达时间,运行时间,剩余时间,进程状态。

用这三个操作来模拟进程的一次运行;进程运行一次后,以后的调度则将当前指针依次下移一个位置,指向下一个进程,即调整当前运行指针,以指示应运行进程。

同时还应判断该进程的剩余时间是否为0。

如果不为0,则等待下一轮的运行;如果该进程的剩余时间为0,则将该进程的状态置为完成态,并退出队列;步直到所有进程都运行完为止。

e步和第d若处于就绪态的进程不为空,则重复第2.4算法流程图开始初始化PCB,输入进程信息各进程按优先数从高到低排列就绪队列为空?结束就绪队列首进程投入运行时间片到,运行进程已占用CUP时+1间运行进程已占进程完成撤时间CPU用销该进程达到所需运行时间-1使运行进程优先数,把运行进程插入优先队列。

.实验过程(实验步骤、记录、数据、分析)2.5测试用例1:屏幕显示:Please input the process name,arrive time and run time 输入:121<enter>231<enter>322<enter>412<enter>511<enter>测试数据2:112<enter>232<enter>312<enter>431<enter>511<enter>测试数据3:111<enter>222<enter>321<enter>412<enter>511<enter>、结论(结果)33.1测试数据1的运行结果(截图)::的运行结果(截图)2测试数据 3.2.:的运行结果(截图)3测试数据 3.3.4、源程序代码:#include獜摴潩栮#include獜摴楬?屨struct stud{int name;int arrive;int run;int rest;char*state;struct stud*next;};/*pcb结构体*/struct stud*create(){int a,i;struct stud*head,*rear,*p,*q,*t;/*定义各个指针*/ head=rear=NULL;);畮扭牥尺process the input Please printf(scanf(╜層,&a);printf(\Please input the process name,arrive time and run time:\nFor example:12就湜);for(i=0;i<a;i++){p=(struct stud*)malloc(sizeof(struct stud));scanf(╜╤╤層,&p->name,&p->arrive,&p->run);p->rest=p->run;p->state=牜慥祤;if(rear==NULL)/*只有一个进程*/{head=p;p->next=NULL;rear=p;}else{t=NULL;q=head;while(q&&q->arrive<p->arrive){t=q;q=q->next;}if(q==head)/*指向头进程的下一个进程*/{p->next=head;head=p;}else if(t==rear)/*运行到最后一个进程*/{rear->next=p;p->next=NULL;rear=p;}else{t->next=p;p->next=q;}}}return head;}void output(struct stud*head){struct stud*p,*t,*r;int slice;);汳捩?the input Please printf(scanf(╜層,&slice);while(head!=NULL){r=p=head;while(p!=NULL){t=head;p->rest=p->rest-slice;/*剩余时间减去时间片*/ p->state=牜湵楮杮;if(p->rest<0)/*剩余的时间用完了*/p->rest=0;printf(屜湜???????????????????屜屮);printf(湜浡履瑜牡楲敶屜牴湵屜牴獥屴瑜瑳瑡履湜);while(t!=NULL){printf(╜層瑜搥屜?層瑜搥屜?屳湜,t->name,t->arrive,t->run,t->rest,t->state);t=t->next;}if(p->rest==0)/*判断是否删除结点*/{if(p==head){head=p->next;free(p);p=head;}/*删除头结点*/else{r->next=p->next;p=r->next;r=p;}}else{r=p;p->state=牜慥祤;/*如果不删除头结点指针指向下一个,状态变为准备*/p=p->next;}}}}void main(){struct stud*head;head=create();output(head);}5、小结实验中产生的错误及原因分析:5.1程序运行不下去:5.1.1错误分析:链表初始化排序过程中:指针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;}5.1.2进程运行时间大于时间片时,程序进入死循环:当进程所需时间等于时间片时,运行结果正确:进程运行时间大于时间片时,程序进入死循环:错误分析:进程所需剩余时间计算错误;错误修改:将while(p!=NULL){t=head;p->rest=p->run-slice;p->state=牜湵楮杮;修改为:while(p!=NULL){t=head;p->rest=p->rest-slice;p->state=牜湵楮杮;实验的体会及收获:5.2通过这次试验,我对处理机的调度算法---基于时间片轮转调度算法思想有了更深的理解;另外使我对链表的知识有了更深的理解,而且锻炼了我的思维能力,使我能更全面地思考问题,以后还需要多做些这方面的练习。

相关文档
最新文档