时间片轮转法

合集下载

电大操作系统简答题

电大操作系统简答题

操作系统简答题简述操作系统的定义。

答:操作系统是控制和管理计算机系统内各种硬件和软件资源、有效地组织多道程序运行的系统软件(或程序集合),是用户与计算机之间的接口。

在计算机系统中操作系统处于什么地位?答:操作系统是裸机之上的第一层软件,与硬件关系尤为密切。

它不仅对硬件资源直接实施控制、管理,而且其很多功能的完成是与硬件动作配合实现的,如中断系统。

操作系统的运行需要有良好的硬件环境。

这种硬件配置环境往往称作硬件平台。

?操作系统是整个计算机系统的控制管理中心,其他所有软件都建立在操作系统之上。

操作系统对它们既具有支配权力,又为其运行建造必备环境。

因此,在裸机之上每加一层软件后,用户看到的就是一台功能更强的机器,通常把经过软件扩充功能后的机器称为“虚拟机”。

在裸机上安装了操作系统后,就为其他软件的运行和用户使用提供了工作环境。

往往把这种工作环境称作软件平台。

操作系统的主要功能有哪些?答:操作系统的主要功能包括:存储管理,进程和处理机管理,文件管理,设备管理以及?用户接口管理。

操作系统一般为用户提供了哪三种界面?各有什么特点?答:操作系统一般为用户提供的三种界面是:图形用户接口、命令行接口和程序接口。

?图形用户接口:用户利用鼠标、窗口、菜单、图标等图形界面工具,可以直观、方便、有效地使用系统服务和各种应用程序及实用工具。

?命令行接口:在提示符之后用户从键盘上输入命令,命令解释程序接收并解释这些命令,然后把它们传递给操作系统内部的程序,执行相应的功能。

?程序接口:也称系统调用接口。

系统调用是操作系统内核与用户程序、应用程序之间的接口。

在UNIX/Linux系统中,系统调用以C函数的形式出现。

操作系统主要有哪三种基本类型?各有什么特点?答:根据系统运行的方式分类,操作系统的基本类型有三种:批处理系统、分时系统和实时系统。

批处理操作系统的特点是:多道和成批处理。

?分时系统具有多路性、交互性、“独占”性和及时性的特征。

操作系统实验三 时间片轮转法完成进程调度

操作系统实验三 时间片轮转法完成进程调度

实验三:时间片轮转法完成进程调度一、实验目的:(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.下列指令中哪些只能在核心态运行?(l)读时钟日期;(2)访管指令;(3)设时钟日期;(4)加载PSW; (5)置特殊寄存器:(6)改变存储器映象图;(7)启动I/O指令。

答:( 3 ) , ( 4 ) , ( 5 ) , ( 6 ) , ( 7 ) .2 假设有一种低级调度算法是让“最近使用处理器较少的进程”运行,试解释这种算法对“I/O 繁重”型作业有利,但并不是永远不受理“处理器繁重”型作业。

答:因为I/O繁忙型作业忙于I/O,所以它CPU 用得少,按调度策略能优先执行。

同样原因一个进程等待CPU 足够久时,由于它是“最近使用处理器较少的进程”,就能被优先调度,故不会饥饿。

3 并发进程之间有什么样的相互制约关系?下列日常生活中的活动是属哪种制约关系:(1)踢足球,(2)吃自助餐,(3)图书馆借书,(4)电视机生产流水线工序。

答:并发进程之间的基本相互制约关系有互斥和同步两种。

其中(1)、(3)为互斥问题.(2)、(4)为同步问题。

4 在按动态优先数调度进程的系统中,每个进程的优先数需定时重新计算。

在处理器不断地在进程之间交替的情况下,重新计算进程优先数的时间从何而来?答:许多操作系统重新计算进程的优先数在时钟中断处理例程中进行,由于中断是随机碰到哪个进程,就插入哪个进程中运行处理程序,并把处理时间记在这个进程的账上。

5 若后备作业队列中等待运行的同时有三个作业J1 、J2、J3 ,已知它们各自的运行时间为a 、b 、c,且满足a < b <c,试证明采用短作业优先算法调度能获得最小平均作业周转时间。

答:采用短作业优先算法调度时,三个作业的总周转时间为:Tl = = a + ( a +b ) + ( a + b + c ) = 3a + 2b + c ①若不按短作业优先算法调度,不失一般性,设调度次序为:J2 、J1 、J3 。

则三个作业的总周转时间为:T2=b+(b+a ) +(b+a + c ) = 3b + 2a + c ②令②-①式得到:T2 - Tl = b- a> 0可见,采用短作业优先算法调度才能获得最小平均作业周转时间。

处理机调度算法的比较

处理机调度算法的比较

处理机调度算法的比较计算机科学学院计算机科学与技术2009摘要:处理机调度基本概念、调度算法优劣的评价准则、多种处理机调度算法的介绍引言操作系统是处理计算机硬件的一层软件和作为计算机用户与计算机硬件的中间的协调者。

操作系统的CPU调度器负责给各个任务分发CPU带宽资源。

调度算法负责管理当前执行任务等额顺序和性能3 内容:3.1 处理机调度的基本概念高/中/低级调度1. 高级调度(作业调度)决定把外存上处于后备队列中的哪些作业调入内存,并为它们创建进程、分配必要的资源,准备执行。

2. 低级调度(进程调度)决定就绪队列中的哪个进程应获得处理机,然后再由分派程序执行把处理机分配给该进程的具体操作。

非抢占方式和抢占方式3. 中级调度决定把又具备运行条件的挂起进程重新调入内存,挂到就绪队列上,准备执行。

3.2 调度算法优劣的评价准则衡量和比较调度算法性能优劣主要有一下几个因素:(1)CPU利用率。

CPU是计算机系统中最重要的资源,所以应尽可能使CPU保持忙,使这一资源利用率最高。

(2)吞吐量。

CPU运行时表示系统正处于工作状态,工作量的大小是以每单位时间所完成的作业数目来描述的,这就叫吞吐量。

(3)周转时间。

指从作业提交到作业完成所经过的时间,包括作业等待,在就绪队列中排队,在处理机上运行以及进行输入/输出操作所花时间的总和。

(4)等待时间。

处理机调度算法实际上并不影响作业执行或输入/输出操作的时间,只影响作业在就绪队列中等待所花的时间。

因此,衡量一个调度算法优劣常常简单的考察等待时间。

(5)响应时间。

指从作业提交到系统作出相应所经过的时间。

在交互式系统中,作业的周转时间并不一定是最好的衡量准则,因此,常常使用另一种度量准则,即相应时间。

从用户观点看,响应时间应该快一点好,但这常常要牺牲系统资源利用率为代价。

(6)公平性——确保每个用户每个进程获得合理的 CPU 份额或其他资源份额,不会出现饿死情况。

当然,这些目标本身就存在着矛盾之处,操作系统在设计时必须根据其类型的不同进行权衡,以达到较好的效果。

时间片轮转RR进程调度算法

时间片轮转RR进程调度算法

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

【实验内容】问题描述:设计程序模拟进程的时间片轮转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)输出:要求输出计算出来的每个进程的周转时间,带权周转时间,所有进程的平均周转时间,带权平均周转时间。

【源程序】#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;}LinkQueue;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[MaxNum];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:";cin>>n;while(n<0||n>100){cout<<"输入的n值不正确,请重新输入!"<<endl;cin>>n;}cout<<"请输入各个进程的到达时间:";for(int i=0;i<n;i++)cin>>ArrivalTime[i];cout<<"请输入各个进程的服务时间:";for( i=0;i<n;i++)cin>>ServiceTime[i];cout<<"请输入时间片q:";cin>>q;while(q<0||q>200){cout<<"输入的q值不正确,请重新输入!"<<endl;cin>>q;}RR(ArrivalTime,ServiceTime,n,q,Q);}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;}InitQueue(Q);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||S Time!=0&&i!=e&&ArrivalTime[i]==countTime){EnQueue(Q,i);pushed[i]=1;}}if(STime[e]>0){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)<<WeightWhol eTime[i]<<" ";cout<<endl;cout<<"平均周转时间为:"<<Average_WT<<endl;cout<<"平均带权周转时间为:"<<Average_WWT<<endl; DestroyQueue(Q);}Status InitQueue(LinkQueue &Q){Q.front=Q.rear=(QueuePtr)malloc(sizeof(QNode));if(!Q.front)exit(OVERFLOW);Q.front->next=NULL;return OK;}Status 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;}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;}bool QueueEmpty(LinkQueue &Q){if(Q.front==Q.rear)return true;else return false;}【实例截图】小结:通过这次实验,感觉时间片轮转RR进程调度算法还是挺复杂的,关键要掌握队列的特点,也就是顺序要清楚,哪个时刻对应运行哪一实用标准文案个进程要明白,再者就是要熟悉算法和进程调度的执行过程,多动手,多思考,就可以解决。

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

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

学号:课程设计课程名字系统软件开发实训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 根据选择的调度算法计算平均周转时间和平均带权周转时间。

操作系统-第3章习题解析

操作系统-第3章习题解析

操作系统-第3章习题解析第三章习题解析1.⾼级调度不低级调度的主要任务是什么?为什么要引⼊中级调度?答:⾼级调度的主要任务是根据某种算法,把外存上处于后备队列中的那些作业调⼊内存。

低级调度是保存处理机的现场信息,按某种算法先取进程,再把处理器分配给进程。

引⼊中级调度的主要⽬的是为了提⾼内存利⽤率和系统吞吐量。

使那些暂时不能运⾏的进程不再占⽤内存资源,将它们调⾄外存等待,把进程状态改为就绪驻外存状态或挂起状态。

2.处理机调度算法的共同⽬标是什么?批处理系统的调度⽬标⼜是什么?答:共同⽬标:资源利⽤率,公平性,平衡性,策略强制执⾏。

批处理系统的调度⽬标:平均周转时间短,系统吞吐量⾼,处理机利⽤率⾼。

3.何谓作业、作业步和作业流?答:作业包含通常的程序和数据,还配有作业说明书。

系统根据该说明书对程序的运⾏进⾏控制。

批处理系统中是以作业为基本单位从外存调⼊内存。

作业步是指每个作业运⾏期间都必须经过若⼲个相对独⽴相互关联的顺序加⼯的步骤。

作业流是指若⼲个作业进⼊系统后依次存放在外存上形成的输⼊作业流;在操作系统的控制下,逐个作业进程处理,于是形成了处理作业流。

4.在什么情况下需要使⽤作业控制块JCB?其中包含了哪些内容?答:每当作业进⼊系统时,系统便为每个作业建⽴⼀个作业控制块JCB,根据作业类型将它插⼊到相应的后备队列中。

JCB包含的内容通常有:1)作业标识 2)⽤户名称 3)⽤户账户 4)作业类型(CPU繁忙型、I/0芳名型、批量型、终端型) 5)作业状态 6)调度信息(优先级、作业已运⾏) 7)资源要求 8)进⼊系统时间 9)、开始处理时间 10)作业完成时间 11)作业退出时间 12)资源使⽤情况等5.在作业调度中应如何确定接纳多少个作业和接纳哪些作业?答:作业调度每次接纳进⼊内存的作业数,取决于多道程序度。

应将哪些作业从外存调⼊内存,取决于采⽤的调度算法。

最简单的是先来服务调度算法,较常⽤的是短作业优先调度算法和基于作业优先级的调度算法。

南京邮电大学操作技巧系统课后习题集标准答案

南京邮电大学操作技巧系统课后习题集标准答案

《操作系统教程》南邮正式版习题解答第三章进程管理与调度习题1、什么是多道程序设计?多道程序设计利用了系统与外围设备的并行工作能力,从而提高工作效率,具体表现在哪些方面?答:让多个计算问题同时装入一个计算机系统的主存储器并行执行,这种设计技术称“ 多道程序设计”,这种计算机系统称“多道程序设计系统” 或简称“多道系统”。

在多道程序设计的系统中,主存储器中同时存放了多个作业的程序。

为避免相互干扰,必须提供必要的手段使得在主存储器中的各道程序只能访问自己的区域。

提高工作效率,具体表现在:•提高了处理器的利用率;•充分利用外围设备资源:计算机系统配置多种外围设备,采用多道程序设计并行工作时,可以将使用不同设备的程序搭配在一起同时装入主存储器,使得系统中各外围设备经常处于忙碌状态,系统资源被充分利用;•发挥了处理器与外围设备以及外围设备之间的并行工作能力;从总体上说,采用多道程序设计技术后,可以有效地提高系统中资源的利用率,增加单位时间内的算题量,从而提高了吞吐率。

2、请描述进程的定义和属性。

答:进程是具有独立功能的程序关于某个数据集合上的一次运行活动,是系统进行资源分配、调度和保护的独立单位。

进程的属性有:结构性•共享性•动态性•独立性•制约性•并发性3、请描述进程与程序的区别及关系。

答:程序是静止的,进程是动态的。

进程包括程序和程序处理的对象(数据集),进程能得到程序处理的结果。

进程和程序并非一一对应的,一个程序运行在不同的数据集上就构成了不同的进程。

通常把进程分为“系统进程”和“用户进程”两大类,把完成操作系统功能的进程称为系统进程,而完成用户功能的进程则称为用户进程。

4、进程有哪三种基本状态?三种进程状态如何变化?答:通常,根据进程执行过程中不同时刻的状态,可归纳为三种基本状态:·等待态:等待某个事件的完成;·就绪态:等待系统分配处理器以便运行;·运行态:占有处理器正在运行。

进程调度先来先服务时间片轮转法优先服务调

进程调度先来先服务时间片轮转法优先服务调

进程调度先来先服务时间片轮转法优先服务调度处理器调度免费下载C或C++/*标题:设计一:进程调度设计目的:进程管理是操作系统中的重要功能,用来创建进程、撤消进程、实现进程状态转换,它提供了在可运行的进程之间复用CPU的方法。

在进程管理中,进程调度是核心,因为在采用多道程序设计的系统中,往往有若干个进程同时处于就绪状态,当就绪进程个数大于处理器数目时,就必须依照某种策略决定哪些进程优先占用处理器。

本实验模拟在单处理器情况下的进程调度,目的是加深对进程调度工作的理解,掌握不同调度算法的优缺点。

设计题目:设计一个按先来先服务,算法时间片轮转法,优先数调度算法实现处理器调度的程序。

*//*亲爱的同学们,大家好。

欢迎访问我的百度空间,在此我向大家提供免费的资料,这是我们实习要做的。

主要是因为我看到很多下载都要金币,而我自己没有金币,不爽。

现在我提供免费下载,做个好人。

复制到VC++时可能有些格式问题,稍微修改一下就OK了,程序本身不存在问题的。

大三第一个学期实习的哦*//*先来先服务:是一种最简单的调度算法,每次调度都从后备作业或者进程当中选择一个或者多个最先进入该队列的作业或进程,将它们调入内存,为它们分配资源、创建进程,然后放入就绪队列。

当调用FCFS算法时,系统为它们分配处理机,让它们运行。

该算法的优点是比较利于长作业(进程),而缺点是不利于短作业(进程)。

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

当执行完时间片时,计时器就会发出中断请求,调度程序就会停止该进程的执行,并把它送往就绪队列的末尾;然后再把处理机分配给就绪队列中新的队首进程,同时也分配时间片给它。

这样保证就绪队列中的所有进程在一个给定的时间片当中都能够获得一个时间片的处理机执行时间。

而时间片的大小最好取适中的,即略大于一次典型的交互所需时间。

优先数调度算法:该方法又分成两种算法分支,分别是非抢占式优先权算法和抢占式优先权调度算法。

操作系统练习题及答案之欧阳治创编

操作系统练习题及答案之欧阳治创编

一、填空P15 填空题1.设计现代OS的主要目的是提高资源利用率和方便用户。

2.单道批处理系统是在解决人机矛盾和CPU与I/O设备速度不匹配的矛盾中发展起来的。

3.在单处理机环境下的多道程序设计具有多道、宏观上同时运行和微观上交替运行的特点。

4.现在操作系统的两个最基本的特征是并发和资源共享,除此之外,它还具有虚拟性和异步性的特征。

5.从资源管理的角度看,操作系统具有四大功能:处理机管理、存储器管理、设备管理和文件管理;为了方便用户,操作系统还必须提供友好的用户接口。

6.操作系统的基本类型主要有批处理系统、分时系统和实时系统。

7.批处理系统的主要优点是资源利用率高和系统吞吐量大;主要缺点是无交互作用能力和作业平均周转时间长。

8.实现分时系统的关键问题他是人机交互,为此必须引入时间片的概念,并采用时间片轮转调度算法。

9.分时系统的基本特征是多路性、独立性、交互性和及时性。

10.若干事件在同一时间间隔内发生称为并发;若干事件在同一时刻发生称为并行。

11.实时系统可分为实时信息处理系统和实时控制系统两种类型;民航销售系统属于实时信息处理系统;而导弹飞行控制系统则属于实时控制系统。

12.为了使实时系统高度可靠和安全,通常不强求资源利用率。

13.当前比较流行的微内核的操作系统结构,是建立在层次化结构的基础上的,而且还采用了客户机/服务器模式和面向对象程序设计技术。

P56 填空题1.在单用户单任务环境下,用户独占全机,此时机内资源的状态,只能由运行程序的操作加以改变,此时的程序执行具有封闭性和可再现性特征。

2.并发程序之间的相互制约,是由于它们的共享资源和相互合作而产生的,因而导致程序在并发执行时具有间断性或异步性特征。

3.程序并发执行与顺序执行时相比产生了一些新特征,分别是间断性、失去封闭性和不可再现性。

4.引入进程的目的是使程序能正确地并发执行,以提高资源利用率和系统吞吐量,而引入线程的目的是减少并发执行的开销,提高程序执行的并发程度。

操作系统教程_孙钟秀课后习题答案

操作系统教程_孙钟秀课后习题答案

首页入门学习程序员计算机考研计算机电子书下载硬件知识网络知识专业课程答案下载视频教程下载第一章作者:佚名来源:网络1、有一台计算机,具有IMB 内存,操作系统占用200KB ,每个用户进程各占200KB 。

如果用户进程等待I/O 的时间为80 % ,若增加1MB 内存,则CPU 的利用率提高多少?答:设每个进程等待I/O 的百分比为P ,则n 个进程同时等待刀O 的概率是Pn ,当n 个进程同时等待I/O 期间CPU 是空闲的,故CPU 的利用率为1-Pn。

由题意可知,除去操作系统,内存还能容纳4 个用户进程,由于每个用户进程等待I/O的时间为80 % , 故:CPU利用率=l-(80%)4 =若再增加1MB 内存,系统中可同时运行9 个用户进程,此时:cPu 利用率=l-(1-80%)9 =故增加IMB 内存使CPU 的利用率提高了47 % :87 %/59 %=147 %147 %-100 % = 47 %2 一个计算机系统,有一台输入机和一台打印机,现有两道程序投入运行,且程序A 先开始做,程序B 后开始运行。

程序A 的运行轨迹为:计算50ms 、打印100ms 、再计算50ms 、打印100ms ,结束。

程序B 的运行轨迹为:计算50ms 、输入80ms 、再计算100ms ,结束。

试说明(1 )两道程序运行时,CPU有无空闲等待?若有,在哪段时间内等待?为什么会等待?( 2 )程序A 、B 有无等待CPU 的情况?若有,指出发生等待的时刻。

答:画出两道程序并发执行图如下:(1)两道程序运行期间,CPU存在空闲等待,时间为100 至150ms 之间(见图中有色部分)(2)程序A 无等待现象,但程序B 有等待。

程序B 有等待时间段为180rns 至200ms 间(见图中有色部分)3 设有三道程序,按A 、B 、C优先次序运行,其内部计算和UO操作时间由图给出。

试画出按多道运行的时间关系图(忽略调度执行时间)。

时间片轮转法

时间片轮转法

时间片轮转法
时间片轮转法是操作系统调度算法的一种。

它是一种多任务处理的方法,根据一定规则决定执行那个任务。

它的基本原理是,将所有需要被调度运行的作业划分成若干个时间片,每个时间片只运行一个作业,按照一定的顺序依次运行,同一作业在一个时间段内可以被多次调度到CPU上运行,直至完成。

时间片轮转法是一种简单有效的操作系统调度算法,它把任务划分成若干个时间片,每一时间片待完成的任务都是固定的,可以保证公平的给每一个任务分配到处理器资源,而且它也可以有效的利用空闲的处理器资源。

3.5 基于时间片的调度算法

3.5 基于时间片的调度算法
作业、进程 非抢占 简单 无视特殊要求
SJF
作业 两者均可 利于短作业 易导致饥饿
HRRF
作业 非抢占 均衡调度 计算耗时
RR
进程 抢占 响应及时 切换开销大
9/136
假如它们按P1、P2、P3的顺序执行,且不可剥夺, 则三进程各自的周转时间分别为20、24、 26个单位时间, 平均周转时间是23.33个时间单位。
2/136

算法举例:有三个进程P1、P2、P3先后到达,分别需要20、4和2个 单位时间运行完毕,假如用时间片轮转原则的剥夺调度方式,时间片 为2个时间单位。则各进程的周转时间和平均周转时间。
0
2
4
6
8
10 12
14
16
18
20
22
24
26
p1 p2 p3 p1 p2 p1 p1 p1 p1 p1 p1 p1 p1 P1、P2、P3的周转时间分别为26、10、6 平均周转时间为(26ƴ

算法优缺点:


算法主要针对分时系统,适用于进程调度;
对用户的响应及时、快速; 时间片的长度确定比较困难; 进程切换开销比较大。
CH 3.5 基于时间片的调度算法
3.5.1 时间片轮转法(Round-Robin)

算法基本思想: 系统按照固定的时间片依次轮流执行就 绪队列中的各个进程。 B
C
A
D
1/136

算法举例:有三个进程P1、P2、P3先后到达,它们分别需要20、4和2
个单位时间运行完毕。假如它们按P1、P2、P3的顺序执行,且不可剥 夺,则三进程各自的周转时间、平均周转时间是多少个时间单位。
程被唤醒时,进入原来的就绪队列;当进程第一次就绪

时间片轮转调度算法实验报告

时间片轮转调度算法实验报告

实验概述:【实验目的及要求】用C 语言编程实现时间片轮转调度算法【实验原理】基于时间片轮转调度算法思想用C 语言编程实现【实验环境】(使用的软件)Visual C++6.0 实验内容:本实验模拟在单处理机情况下处理机调度,用C 语言编程实现先来先服务和最短作业优先调度算法。

【实验方案设计】时间片大小固定,由用户输入。

进程个数由用户输入。

a. 每个进程用一个PCB 表示。

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

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

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

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

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

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

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

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

如果不为0,则等待下一轮的运行;如果该进程的剩余时间为0,则将该进程的状态置为完成态,并退出队列;f. 若处于就绪态的进程不为空,则重复第d步和第e步直到所有进程都运行完为止。

【实验过程】(实验步骤、记录、数据、分析)测试用例1:屏幕显示:Please input the process name, arrive time and run time 输入:1 2 1<enter>2 3 2<enter>3 4 3<enter>屏幕显示:Please input the slice1<enter>屏幕输出结果:name arrive run rest state1 2 1 0 running2 3 2 2 ready3 4 3 3 readyname arrive run rest state2 3 2 1 running3 4 3 3 readyname arrive run rest state2 3 2 1 ready3 4 3 2 runningname arrive run rest state2 3 2 0 running3 4 3 2 readyname arrive run rest state3 4 3 1 runningname arrive run rest state3 4 3 0 running测试数据2:2 3 11 2 35 4 2 测试数据3:【结论】(结果)测试数据1 的运行结果(截图):测试数据2 的运行结果:幸* 斗 ********* 承*3∣C* ******** 承*** ********** name arrive run rest State1 2 3 2 ready2 3 1 O runningL 4 2 2 Ieady**************************************running**3fα}c*********************************D ∖wi∩c201O4∖CYuYan ,∙bin ∖;VwtemPeXePIeaSe input the PrOCeSS number:3PIeaSe input example: 132FOr 2 1 1 the 1 2 PrOCeSS name, arrive time and run time :1 name arrive run rest State1 2 3 2 running2 3 1 L ready1 42 2 readyslice :1PIeaSe inpUt **⅛*********************************** amethe LJname arrive run 2 3 rest 2 Statereadyname arrive run 2 3 4 2 rest Staterunningreadyarrive 24 run rest Statereadyrunningame arrive run2 rest StaterunningPreSS any continue.to测试数据3 的运行结果:源程序代码:#include "stdio.h"#include "stdlib.h"struct stud{int name;int arrive;int run; intrest;char *state;}void output( struct stud *head){ struct stud *p, *t, *r; int slice;printf( "Please input the slice:" ); scanf( "%d" ,&slice); while (head != NULL){ r=p=head;while (p!= NULL){t =head;p-> rest =p-> rest - slice; p-> state = "running" ; if (p -> rest < 0)p-> rest =0;printf( "\n **************************************\n)";printf( "name\tarrive\trun\trest\tstate\n" ); while (t != NULL){printf( "%d\t%d\t%d\t%d\t%s\n" ,t-> name,t -> arrive,t -> run,t -> rest,t -> t=t -> next;state);}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 = "ready" ; p=p-> next;}}}}void main(){struct stud *head; head =create(); output(head) ;}【小结】实验中产生的错误及原因分析: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; }2、进程运行时间大于时间片时,程序进入死循环:当进程所需时间等于时间片时,运行结果正确:进程运行时间大于时间片时,程序进入死循环:错误分析:进程所需剩余时间计算错误;错误修改:将while(p!=NULL) {t =head;p-> rest =p ->run- slice;p-> state ="running" ;修改为:while (p!= NULL){t =head;p-> rest =p ->rest- slice;p-> state ="running" ; 错误3:测试数据:1 2 1 3 1 3 Slice=2 结果为:实验的体会及收获:通过这次试验,我对处理机的调度算法---基于时间片轮转调度算法思想有了更深的理解;另外使我对链表的知识有了更深的理解,而且锻炼了我的思维能力,使我能更全面地思考问题,以后还需要多做些这方面的练习。

进程调度实验报告源码

进程调度实验报告源码

一、实验目的本次实验旨在通过模拟进程调度过程,加深对进程调度算法的理解,并掌握进程调度程序的设计与实现方法。

实验内容主要包括:创建进程、进程调度、进程执行、进程结束等。

二、实验环境操作系统:Linux编程语言:C/C++三、实验内容1. 进程调度算法本实验采用三种进程调度算法:FIFO(先进先出)、时间片轮转法、多级反馈队列调度算法。

2. 进程调度程序设计进程调度程序主要由以下部分组成:(1)进程控制块(PCB)PCB用于描述进程的基本信息,包括进程名、到达时间、需要运行时间、已运行时间、进程状态等。

(2)就绪队列就绪队列用于存储处于就绪状态的进程,按照进程的优先级或到达时间进行排序。

(3)进程调度函数进程调度函数负责从就绪队列中选择一个进程进行执行,并将CPU分配给该进程。

(4)进程执行函数进程执行函数负责模拟进程的执行过程,包括进程的创建、执行、结束等。

四、实验源码```c#include <stdio.h>#include <stdlib.h>#include <time.h>#define MAX_PROCESSES 10typedef struct PCB {int pid;int arrival_time;int need_time;int used_time;int priority;int state; // 0: 等待 1: 运行 2: 完成} PCB;PCB processes[MAX_PROCESSES];int process_count = 0;typedef struct Queue {PCB queue;int front;int rear;int size;} Queue;Queue ready_queue;void init_queue(Queue q) {q->queue = (PCB )malloc(sizeof(PCB) MAX_PROCESSES); q->front = q->rear = 0;q->size = 0;}void enqueue(Queue q, PCB p) {if (q->size == MAX_PROCESSES) {printf("Queue is full.\n");return;}q->queue[q->rear] = p;q->rear = (q->rear + 1) % MAX_PROCESSES; q->size++;}PCB dequeue(Queue q) {if (q->size == 0) {printf("Queue is empty.\n");return NULL;}PCB p = &q->queue[q->front];q->front = (q->front + 1) % MAX_PROCESSES; q->size--;return p;}int is_empty(Queue q) {return q->size == 0;}void print_queue(Queue q) {printf("Queue: ");for (int i = 0; i < q->size; i++) {PCB p = &q->queue[(q->front + i) % MAX_PROCESSES];printf("PID: %d, Arrival Time: %d, Need Time: %d, Used Time: %d, Priority: %d, State: %d\n",p->pid, p->arrival_time, p->need_time, p->used_time, p->priority, p->state);}}void init_processes() {for (int i = 0; i < MAX_PROCESSES; i++) {processes[i].pid = i;processes[i].arrival_time = rand() % 10;processes[i].need_time = rand() % 10 + 1;processes[i].used_time = 0;processes[i].priority = rand() % 3;processes[i].state = 0;}}void schedule() {int time = 0;while (process_count > 0) {for (int i = 0; i < process_count; i++) {PCB p = &processes[i];if (p->arrival_time == time) {enqueue(&ready_queue, p);p->state = 1;}}if (!is_empty(&ready_queue)) {PCB p = dequeue(&ready_queue);p->used_time++;printf("Process %d is running.\n", p->pid);if (p->used_time == p->need_time) {p->state = 2;printf("Process %d is finished.\n", p->pid); }}time++;}}int main() {srand(time(NULL));init_queue(&ready_queue);init_processes();process_count = rand() % MAX_PROCESSES + 1;schedule();print_queue(&ready_queue);return 0;}```五、实验结果与分析1. FIFO调度算法实验结果表明,FIFO调度算法按照进程的到达时间进行调度,可能导致短作业等待时间长,效率较低。

时间片轮转调度.pptx

时间片轮转调度.pptx

同步
利用信号量进行同步
• 9、春去春又回,新桃换旧符。在那桃花盛开的地方,在这醉人芬芳的季节,愿你生活像春天一样阳光,心情像桃花一样美丽,日子像桃子一样甜蜜。20. 12.320.12.3Thursday, December 03, 2020
• 10、人的志向通常和他们的能力成正比例。14:17:3814:17:3814:1712/3/2020 2:17:38 PM
• 17、一个人如果不到最高峰,他就没有片刻的安宁,他也就不会感到生命的恬静和光荣。下午2时17分38秒下午2时17分14:17:3820.12.3
谢谢观看
• 14、Thank you very much for taking me with you on that splendid outing to London. It was the first time that I had seen the Tower or any of the other famous sights. If I'd gone alone, I couldn't have seen nearly as much, because I wouldn't have known my way about.
• 11、夫学须志也,才须学也,非学无以广才,非志无以成学。20.12.314:17:3814:17Dec-203-Dec-20
• 12、越是无能的人,越喜欢挑剔别人的错儿。14:17:3814:17:3814:17Thursday, December 03, 2020
• 13、志不立,天下无可成之事。20.12.320.12.314:17:3814:17:38December 3, 2020
时间片轮转调度

实验一___处理器调度(设计一个按时间片轮转法实现处理器调度的程序)介绍

实验一___处理器调度(设计一个按时间片轮转法实现处理器调度的程序)介绍

实验一处理器调度一、实验内容选择一个调度算法,实现处理器调度。

二、实验目的在采用多道程序设计的系统中,往往有若干个进程同时处于就绪状态。

当就绪进程个数大于处理器数时,就必须依照某种策略来决定哪些进程优先占用处理器。

本实习模拟在单处理器情况下的处理器调度,帮助学生加深了解处理器调度的工作。

三、实验题目第二题:设计一个按时间片轮转法实现处理器调度的程序。

[提示]:(1)假定系统有五个进程,每一个进程用一个进程控制块PCB来代表。

进程控制块的格式为:其中,Q1,Q2,Q3,Q4,Q5。

指针——进程按顺序排成循环队列,用指针指出下一个进程的进程控制块的首地址最后一个进程的指针指出第一个进程的进程控制块首地址。

要求运行时间——假设进程需要运行的单位时间数。

已运行时间——假设进程已经运行的单位时间数,初始值为“0”。

状态——有两种状态,“就绪”和“结束”,初始状态都为“就绪”,用“R”表示。

当一个进程运行结束后,它的状态为“结束”,用“E”表示。

(2) 每次运行所设计的处理器调度程序前,为每个进程任意确定它的“要求运行时间”。

(3) 把五个进程按顺序排成循环队列,用指针指出队列连接情况。

另用一标志单元记录轮到运行的进程。

例如,当前轮到P2执行,则有:标志单元K1K2K3K4K5PCB1 PCB2 PCB3 PCB4 PCB5(4)处理器调度总是选择标志单元指示的进程运行。

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

请同学注意:在实际的系统中,当一个进程被选中运行时,必须置上该进程可以运行的时间片值,以及恢复进程的现场,让它占有处理器运行,直到出现等待事件或运行满一个时间片。

在这时省去了这些工作,仅用“已运行时间+1”来表示进程已经运行满一个时间片。

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

单片机时间片任务调度_概述说明以及概述

单片机时间片任务调度_概述说明以及概述

单片机时间片任务调度概述说明以及概述1. 引言1.1 概述本文将详细探讨单片机时间片任务调度的概念和实践。

随着技术的不断进步,嵌入式系统在各个领域的应用越来越广泛,而单片机作为其中重要的组成部分之一,在任务调度方面起着至关重要的作用。

时间片任务调度是一种常见且有效的任务调度算法,通过合理地分配处理器资源给各个任务,实现多个任务之间更加公平高效地运行。

1.2 文章结构本文将分为五个部分进行阐述。

首先,在引言部分将对文章的内容进行概述说明,明确本文的目标和结构。

接下来,第二部分将对单片机时间片任务调度进行概述说明,主要包括单片机与时间片任务调度两方面的基础知识介绍。

第三部分将深入探讨几种常见的时间片任务调度算法,并详细解析其原理和特点。

第四部分将通过实际应用场景与案例分析,展示单片机时间片任务调度算法在工业自动化、嵌入式系统以及物联网领域中的实践应用,并对其效果进行评估和总结。

最后,第五部分将对整篇文章进行结论和展望,总结研究结果并提出未来发展的建议。

1.3 目的本文旨在深入探讨单片机时间片任务调度算法,并通过实际应用案例给读者展示其重要性和实际效果。

同时,本文还将分析该领域的研究现状和发展趋势,为相关从业人员提供一些有益的参考和建议,推动该领域的进一步发展。

通过阅读本文,读者将能够全面了解单片机时间片任务调度算法相关知识,并应用于实际工程项目中,提高系统的性能和效率。

2. 单片机时间片任务调度概述说明:2.1 单片机概述单片机(Microcontroller)是一种集成电路,包含了处理器核心、存储器和外设接口等功能模块。

它具备高度的集成度、低功耗特性以及强大的计算能力,在各个领域得到广泛应用。

单片机通过执行程序来完成特定的任务,因此需要进行任务调度。

2.2 时间片任务调度概述时间片任务调度是指将系统中的不同任务按照一定规则进行分时执行,使得每个任务都有足够的执行时间,从而保证系统稳定运行。

在单片机中,由于资源有限和多个任务同时存在的情况,时间片任务调度可以提高系统的效率和响应速度。

时间片轮转调度算法

时间片轮转调度算法

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

  1. 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
cout<<"进程名 总运行时间 已运行时间 :";
cin>>p->name>>p->All_Time>>p->Runed_Time;
p->state='R';
p->next=NULL;
}
}
void main() {
Proc H;
InitPCB(H); // 数据初始化
DispInfo(H); // 输出此刻的进程状态
SJP_Simulator(H); // 时间片轮转法
system("pause");
p->next=H->next;
}
//输出运行中的进程信息
void DispInfo(Proc H) {
Proc p=H->next;
do {
if (p->state != 'E') //如果该进程的状态不是End的话
while (flag && p->All_Time == p->Runed_Time)
p=p->next; // 跳过先前已结束的进程 Nhomakorabea}
cout<<endl<<"--------------------END---------------------\n";
{
cout<<"进程名:"<<p->name<<"\t总运行时间:"<<p->All_Time
<<"\t已运行时间:"<<p->Runed_Time
<<"\t状态:"<<p->state<<endl;
H->next=NULL;
Proc p=H; //定义一个指针
cout<<"总进程个数为 "<<ProcNum<<" 个,请依次输入相应信息\n\n";
while (Num--) {
p=p->next=(Proc)malloc(sizeof(PNode));
}
p=p->next;
}
else p=p->next;
} while (p != H->next); // 整个进程链条始终完整,只是状态位有差异
}
// 时间片轮转法
void SJP_Simulator(Proc &H) {
int All_Time; // 定义总运行时间
int Runed_Time; // 定义已运行时间
char state; // 定义进程状态 Ready / End
}* Proc; // 指向该PCB的指针
int ProcNum; // 总进程个数
p->state='E';
flag--;
cout<<p->name<<" 进程已运行结束,进程被删除!\n";
}
p=p->next;
// 初始化就绪队列
void InitPCB(Proc &H) {
cout<<"请输入总进程个数: ";
cin>>ProcNum; // 进程总个数
int Num=ProcNum;
H=(Proc)malloc(sizeof(PNode)); // 建立头节点
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) { // 并判断该进程是否结束
#include <iostream>
#include <cstdlib>
using namespace std;
typedef struct PNode { // PCB
struct PNode *next; // 定义指向下一个节点的指针
char name[10]; // 定义进程名,并分配空间
cout<<endl<<"-------------------START--------------------\n";
int flag=ProcNum; // 记录剩余进程数
int round=0; // 记录轮转数
Proc p=H->next;
相关文档
最新文档