进程调度模拟程序设计

合集下载

进程调度模拟程序

进程调度模拟程序
time+=p2->needtime;
p2->state='R';
p2->ftime=time;
p2->zztime=p2->ftime-p2->tijiaotime;
p2->dzztime=p2->zztime/p2->needtime;
pzztime=p2->zztime+pzztime;
printf("\n 进程名:");
scanf("%s",&p->name);
printf("\n 优先级:");
scanf("%d",&p->super);
printf("\n 运行时间:");
scanf("%d",&p->needtime);
printf("\n提交时间:");
first->link=p;
second=NULL;
insert=1;
}
else
{
first=first->link;
second=second->link;
}
}
if(insert==0) first->link=p;
if(p->state!='C')
{
printf("正在运行:%s\n",p->name);
p->runtime--;
if(p->runtime!=0) //进程没有运行完,放入队列最后

进程调度模拟设计

进程调度模拟设计

进程调度模拟设计1 需求分析设计一个程序模拟进程调度,能够处理以下情形:(1)能够选择不同的调度算法,如优先法和非强占式短进程优先算法;(2)能够输入进程的基本信息,如进程名、优先级、到达时间和运行时间等;(3)根据选择的调度算法显示进程调度队列;(4)根据选择的调度算法计算平均周转时间和平均带权周转时间。

2 功能设计用结构体类型定义进程,采用链表结构存储进程。

新建进程链表后将链表按到达时间从小到大排列,然后选择不同算法进行进程调度。

运行完当前进程之后,对运行期间到达的进程按算法要求重新排列,再读取下一个进程,循环以上步骤直至所有进程执行完毕。

根据动态排列后运行完毕的进程链表输出进程调度队列。

计算平均周转时间和平均带权周转时间并输出。

3 开发平台Microsoft Visual Studio 20084 源程序的主要部分4.1 数据结构定义一个PCB的结构体类型,存储进程的信息,包括进程名、优先级、到达时间、运行时间、实际开始运行时间、实际完成时间。

其中非强占式短进程优先算法不考虑优先级。

具体定义如下:struct PCB{string name;//进程名int priority;//优先级,数值越小越优先float atime;//进程到达时间float time;//进程运行时间float stime;//进程实际开始运行时间float ftime;//进程实际完成时间PCB *next;};4.2 模块说明定义一个单链表的类,使用链表来存储不同的进程。

类中包含的主要功能函数有建立进程函数、进程调度函数、排序函数、输出函数。

私有数据成员为记录进程个数的count,头指针first。

具体类定义如下:class process{public:process(){first=new PCB;};PCB *getHead()const{return first;}//取头指针void input(int n,int m);//创建进程队列并按到达时间排序int sort(int m,PCB *x,float T);//排序函数void run(int m);//进程调度函数void process::output(int m);//输出调用过程,private:int count;//进程个数PCB *first;};4.3 成员函数说明4.3.1 创建进程列表函数创建进程列表函数为void input(int n,int m)。

进程调度模拟程序设计

进程调度模拟程序设计

进程调度模拟程序设计编写一个进程调度程序,允许多个进程共享进程调度程序。

进程调度算法:采用最高优先数优先的调度算法(即把处理机分配给优先数最高的进程)和先来先服务算法。

每个进程有一个进程控制块( PCB)表示。

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

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

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

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

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

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

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

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

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

重复以上过程,直到所要进程都完成为止模拟进程调度算法用C++的代码描述:#include "iostream.h"//define pcbtypedef struct pcb{char name[10]; //进程名char state; //状态w(就绪)r(运行)f(结束)int id; //id号int super; //优先级int ntime; //需运行的时间int rtime; //已运行的时间struct pcb *next;}*pcb1;pcb1 s,w;//define two publiced linknode ,one is s(ready queue),one is w(blocked queue)//initialize two queuesvoid init(pcb1 &r){r=NULL;//both queues is the kind of head index}//print the information of the ready queuevoid print(){pcb1 p;cout<<"您现在查看的是就绪队列的信息:" ;cout<<"进程号 "<<"进程名 "<<"优先级 "<<"状态"<<"已运行时间 "<<"需运行时间"<<endl;for(p=s;p!=NULL;p=p->next){cout<<p->id<<" "<<p->name<<" "<<p->super<<" "<<p->state<<""<<p->rtime<<" "<<p->ntime<<endl; }}//print the information of the blocked queuevoid print1(){pcb1 p;cout<<"您现在查看的是阻塞队列的信息";cout<<"进程号 "<<"进程名 "<<"优先级 "<<"状态 "<<"已运行时间 "<<"需运行时间"<<endl;for(p=w;p!=NULL;p=p->next){cout<<p->id<<" "<<p->name<<" "<<p->super<<" "<<p->state<<""<<p->rtime<<" "<<p->ntime<<endl; }}//check the queue if emptyint empty(pcb1 &r){if(r==NULL)return 0;elsereturn 1;}//check the first process of the ready queue if finshedint check(){pcb1 p;p=s;if(p->rtime==p->ntime){p->state='F';//if one process finshed then change ti's statecout<<"进程"<<p->id<<" 已经结束"<<endl;return 0;}elsereturn 1;}//sort process according to the super of the process and insert to the ready(blocked) queuevoid sort(pcb1 &r,pcb1 p){pcb1 p1,p2;int in=0;if(r==NULL)//the queue is empty{r=p;}else{if(p->super>=r->super)//the super of the process which wait insert to the queue is highter than the super of the first process of the queue {p->next=r;r=p;}else{p1=r;p2=r->next;if(p2==NULL)//only one process in the queue{r->next=p;}else{while(in==0&&p2!=NULL)//insert to the middle of the queueif(p->super>=p2->super){p->next=p2;p1->next=p;in=1;}else{p1=p1->next;p2=p2->next;}}}if(in==0)//link to the last of ready queuep1->next=p;}}}//block one process and insert to block queuevoid block(){if(empty(s)){if(s->next==NULL){sort(w,s);s=s->next;}else{pcb1 p1;p1=s;s=s->next;p1->next=NULL;sort(w,p1);}}else{cout<<"现在就绪队列已经为空,再没有进程需要阻塞"<<endl; }}//wake one process of block queue and insert to ready queue void wake(){if(empty(w)){pcb1 p1;p1=w;w=w->next;p1->next=NULL;sort(s,p1);}else{cout<<"阻塞队列已经为空,没有进程再需要唤醒"<<endl; }}//runingvoid runing(){if(empty(s)){pcb1 p;p=s;if(check())//check the first process of the queue if finished {//nos=s->next;p->rtime++;p->super--;p->next=NULL;sort(s,p);}else{//yess=s->next;}}else{cout<<"就绪队列已经为空"<<endl; }}//creat processvoid input(){pcb1 p2;p2=new pcb;cout<<"请输入进程号、进程名、进程优先级、需要运行时间";cin>>p2->id>>p2->name>>p2->super>>p2->ntime;p2->rtime=0;p2->state='W';p2->rtime=0;p2->next=NULL;sort(s,p2);}//main functionvoid main(){char ch;init(s);init(w);cout<<"*****************************进程调度模拟程序开始*******************************"<<endl;cout<<"----w/唤醒进程-----r/运行进程-----z/阻塞进程----q/退出程序--"<<endl;cout<<"--------c/创建进程---------s /查看就绪进程---------l/查看阻塞队列----"<<endl;while(ch!='q'){cout<<"请输入一个字符"<<endl;cin>>ch;switch(ch){case 'c':input(); break;case 'r':runing(); break;case 's':print(); break;case 'w':wake(); break;case 'l':print1(); break;case 'z':block(); break;} }。

操作系统实验报告之进度调度模拟程序

操作系统实验报告之进度调度模拟程序

目录进程调度程序设计一、实验目的和要求 (1)二、实验内容及原理 (2)三、实验仪器设备 (4)四、操作方法与实验步骤 (4)五、实验数据记录和处理 (5)六、实验结果与分析 (12)七、实验感想 (14)实验一进程调度程序设计一、实验目的和要求1、目的进程是操作系统最重要的概念之一,进程调度是操作系统的主要内容。

理解操作系统进程管理中进行进程调度的过程和编程方法,掌握先来先服务调度算法和最高优先数优先的调度算法,创建进程控制块PCB。

理解进程的状态及变化,动态显示每个进程的当前状态及进程的调度情况。

通过实验,加深对进程调度和各种调度算法的认识与了解。

2、要求(1)设计一个有几个进程并发执行的进程调度程序,每个进程由一个进程控制块(PCB)表示,进程控制块通常应包括下述信息:进程名,进程优先数,进程需要运行的时间,占用CPU的时间以及进程的状态等,且可按照调度算法的不同而增删。

(2)调度程序应包含2—3种不同的调度算法,运行时可以任选一种,以利于各种方法的分析和比较。

(3)系统应能显示或打印各进程状态和参数的变化情况,便于观察二、实验内容及原理编写并调试一个模拟的进程调度程序,采用“多级反馈队列”调度算法对五个进程进行调度。

多级反馈队列调度算法的基本思想是:当一个新进程进入内存后,首先将它放入第一队列的末尾,按FCFS原则排队等待调度.当轮到该进程执行时,如它能在该时间片内完成,便可准备撤离系统;如果它在一个时间片结束时尚未完成,调度程序便将该进程转入第二队列的末尾,再同样地按FCFS原则等待调度执行,以此类推。

1、设置多个就绪队列,并给队列赋予不同的优先级数,第一个最高,依次递减。

2、赋予各个队列中进程执行时间片的大小,优先级越高的队列,时间片越小。

3、当一个新进程进入内存后,首先将其放入一个对列末尾,如果在一个时间片结束时尚未完成,将其转入第二队列末尾。

4、当一个进程从一个对列移至第n个队列后,便在第n个队列中采用时间片轮转执行完。

进程调度算法模拟程序设计C++

进程调度算法模拟程序设计C++

(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)分析程序运行的结果,谈一下自己的认识。

实验代码#include "iostream.h"#include "windows.h"//#define N 3typedef struct{int ID;int PRIORITY;int CPUTIME;int ALLTIME;int STARTBLOCK;int BLOCKTIME;int STATE;//0-运行1-阻塞2-就绪3-结束4-未到达int REACH;int TIME;}PROCESS;void textcolor (int color){SetConsoleTextAttribute (GetStdHandle (STD_OUTPUT_HANDLE), color ); }void main(){int i,time,max,l,l1,time1,flag=0,total=0,N,server[10],sum=0;PROCESS pro[10];textcolor(13);cout<<"注意:本程序中状态代表如下"<<endl<<"0-运行1-阻塞2-就绪3-结束4-未到达"<<endl<<endl;textcolor(15);cout<<"请输入进程数:";cin>>N;cout<<"请设置时间片长度:";cin>>time;cout<<"请输入各进程初始状态:"<<endl;cout<<"ID PRIORITY REACH ALLTIME STARTBLOCK BLOCKTIME"<<endl;for(i=0;i<N;i++){pro[i].CPUTIME=0;pro[i].TIME=0;cin>>pro[i].ID>>pro[i].PRIORITY>>pro[i].REACH;cin>>pro[i].ALLTIME>>pro[i].STARTBLOCK>>pro[i].BLOCKTIME;server[i]=pro[i].ALLTIME;if(pro[i].REACH==0) pro[i].STATE=0;else pro[i].STATE=4;}do{cout<<endl<<"当前时刻为:"<<total;textcolor(12);cout<<endl<<"========================各进程状态为======================"<<endl;textcolor(15);cout<<"ID PRIORITY CPUTIME ALLTIME STARTBLOCK BLOCKTIME STATE"<<endl;for(i=0;i<N;i++){cout<<pro[i].ID<<" "<<pro[i].PRIORITY<<" "<<pro[i].CPUTIME<<" ";cout<<pro[i].ALLTIME<<" "<<pro[i].STARTBLOCK<<" "<<pro[i].BLOCKTIME<<" "<<pro[i].STATE;cout<<endl;}total+=time;for(i=0;i<N;i++){if(pro[i].STATE==4&&pro[i].REACH<total){pro[i].STATE=1;}}for(i=0;i<N;i++){time1=pro[i].ALLTIME;if(pro[i].STATE==0){if(pro[i].ALLTIME<=time){//pro[i].CPUTIME+=time1;pro[i].ALLTIME=0;pro[i].STATE=3;pro[i].TIME=total-time+time1;}else{//pro[i].CPUTIME+=time;pro[i].ALLTIME-=time;pro[i].STARTBLOCK--;if(pro[i].STARTBLOCK==0){pro[i].STATE=1;pro[i].BLOCKTIME=time1;pro[i].STARTBLOCK=time1;}pro[i].PRIORITY-=3;pro[i].TIME=total;}}if(pro[i].STATE==1){pro[i].BLOCKTIME--;if(pro[i].BLOCKTIME==0) pro[i].STATE=2;pro[i].TIME=total;}if(pro[i].STATE==2){//pro[i].CPUTIME+=time;pro[i].PRIORITY++;pro[i].TIME=total;}}max=-100;l1=-1;l=-1;for(i=0;i<N;i++){if(pro[i].PRIORITY>max&&(pro[i].STATE==0||pro[i].STATE==2)){ l=i;max=pro[i].PRIORITY;}if(pro[i].STATE==0) l1=i;}if(l!=-1&&l!=l1) pro[l].STATE=0;if(l1!=-1) pro[l1].STATE=2;flag=0;for(i=0;i<N;i++){if(pro[i].STATE!=3){flag=1;break;}}if(flag==0) break;}while(1);cout<<endl<<"当前时刻:"<<total;textcolor(12);cout<<endl<<"========================各进程状态为======================"<<endl;textcolor(15);cout<<"ID PRIORITY CPUTIME ALLTIME STARTBLOCKBLOCKTIME STATE"<<endl;for(i=0;i<N;i++){cout<<pro[i].ID<<" "<<pro[i].PRIORITY<<" "<<pro[i].CPUTIME<<" ";cout<<pro[i].ALLTIME<<" "<<pro[i].STARTBLOCK<<" "<<pro[i].BLOCKTIME<<" "<<pro[i].STATE;cout<<endl;}cout<<endl<<"各进程运行结束!"<<endl;cout<<"进程号到达时间结束时间周转时间带权周转时间"<<endl;textcolor(10);for(i=0;i<N;i++){cout<<" "<<pro[i].ID<<" "<<pro[i].REACH<<" "<<pro[i].TIME<<" "<<pro[i].TIME-pro[i].REACH<<" "<<(float)(pro[i].TIME-pro[i].REACH)/server[i]<<endl;sum+=pro[i].TIME-pro[i].REACH;}cout<<"平均周转时间为:"<<(float)sum/N<<endl;textcolor(15);}实验结果注意:本程序中状态代表如下0-运行1-阻塞2-就绪3-结束4-未到达请输入进程数:3请设置时间片长度:2请输入各进程初始状态:ID PRIORITY REACH ALLTIME STARTBLOCK BLOCKTIME1 4 5 7 8 32 6 0 7 2 87 3 2 6 2 6当前时刻为:0========================各进程状态为======================ID PRIORITY CPUTIME ALLTIME STARTBLOCK BLOCKTIME STATE1 4 0 7 8 3 42 6 0 7 2 8 07 3 0 6 2 6 4当前时刻为:2========================各进程状态为======================ID PRIORITY CPUTIME ALLTIME STARTBLOCK BLOCKTIME STATE1 4 0 7 8 3 42 3 0 5 1 8 27 3 0 6 2 6 4当前时刻为:4========================各进程状态为======================ID PRIORITY CPUTIME ALLTIME STARTBLOCK BLOCKTIME STATE1 4 0 7 8 3 42 4 0 5 1 8 07 3 0 6 2 5 1当前时刻为:6========================各进程状态为======================ID PRIORITY CPUTIME ALLTIME STARTBLOCK BLOCKTIME STATE1 4 0 7 82 12 1 03 54 17 3 0 6 2 4 1当前时刻为:8========================各进程状态为======================ID PRIORITY CPUTIME ALLTIME STARTBLOCK BLOCKTIME STATE1 4 0 7 8 1 12 1 03 5 3 17 3 0 6 2 3 1当前时刻为:10========================各进程状态为======================ID PRIORITY CPUTIME ALLTIME STARTBLOCK BLOCKTIME STATE1 5 0 7 8 0 02 1 03 5 2 17 3 0 6 2 2 1当前时刻为:12========================各进程状态为======================ID PRIORITY CPUTIME ALLTIME STARTBLOCK BLOCKTIME STATE1 2 0 5 7 0 22 1 03 5 1 17 3 0 6 2 1 1当前时刻为:14========================各进程状态为======================ID PRIORITY CPUTIME ALLTIME STARTBLOCK BLOCKTIME STATE1 3 0 5 7 0 22 2 03 5 0 27 4 0 6 2 0 0当前时刻为:16========================各进程状态为======================ID PRIORITY CPUTIME ALLTIME STARTBLOCK BLOCKTIME STATE1 4 0 5 7 0 02 3 0 3 5 0 27 1 0 4 1 0 2当前时刻为:18========================各进程状态为======================ID PRIORITY CPUTIME ALLTIME STARTBLOCK BLOCKTIME STATE1 1 0 3 6 0 22 4 03 5 0 07 2 0 4 1 0 2当前时刻为:20========================各进程状态为======================ID PRIORITY CPUTIME ALLTIME STARTBLOCK BLOCKTIME STATE1 2 0 3 6 0 22 1 0 1 4 0 27 3 0 4 1 0 0当前时刻为:22========================各进程状态为======================ID PRIORITY CPUTIME ALLTIME STARTBLOCK BLOCKTIME STATE1 3 0 3 6 0 02 2 0 1 4 0 27 0 0 2 4 3 1当前时刻为:24========================各进程状态为======================ID PRIORITY CPUTIME ALLTIME STARTBLOCK BLOCKTIME STATE1 0 0 1 5 0 22 3 0 1 4 0 07 0 0 2 4 2 1当前时刻为:26========================各进程状态为======================ID PRIORITY CPUTIME ALLTIME STARTBLOCK BLOCKTIME STATE1 1 0 1 5 0 02 3 0 0 4 0 37 0 0 2 4 1 1当前时刻为:28========================各进程状态为======================ID PRIORITY CPUTIME ALLTIME STARTBLOCK BLOCKTIME STATE1 1 0 0 5 0 32 3 0 0 4 0 37 1 0 2 4 0 0当前时刻:30========================各进程状态为======================ID PRIORITY CPUTIME ALLTIME STARTBLOCK BLOCKTIME STATE1 1 0 0 5 0 32 3 0 0 4 0 37 1 0 0 4 0 3各进程运行结束!进程号到达时间结束时间周转时间带权周转时间1 5 27 22 3.142862 0 25 25 3.571437 2 30 28 4.66667平均周转时间为:25Press any key to continue#include "iostream.h"#include "windows.h"//#define N 3typedef struct{int ID; //进程标识数int PRIORITY; //进程优先数int CPUTIME; //进程已占用CPU时间int ALLTIME; //进程还需用CPU时间int STARTBLOCK; //进程阻塞时间int BLOCKTIME; //进程被阻塞时间int STATE; //进程状态0-运行1-阻塞2-就绪3-结束4-未到达int REACH; //进程到达时间int TIME; //}PROCESS;void textcolor (int color){SetConsoleTextAttribute (GetStdHandle (STD_OUTPUT_HANDLE), color );}void main(){int i,time,max,l,l1,time1,flag=0,total=0,N,server[10],sum=0;PROCESS pro[10];textcolor(13);cout<<"注意:本程序中状态代表如下"<<endl<<"0-运行1-阻塞2-就绪3-结束4-未到达"<<endl<<endl;textcolor(15);cout<<"请输入进程数:";cin>>N;cout<<"请设置时间片长度:";cin>>time;cout<<"请输入各进程初始状态:"<<endl;cout<<"ID PRIORITY REACH ALLTIME STARTBLOCK BLOCKTIME"<<endl;for(i=0;i<N;i++){pro[i].CPUTIME=0;pro[i].TIME=0;cin>>pro[i].ID>>pro[i].PRIORITY>>pro[i].REACH;cin>>pro[i].ALLTIME>>pro[i].STARTBLOCK>>pro[i].BLOCKTIME;server[i]=pro[i].ALLTIME;if(pro[i].REACH==0) pro[i].STA TE=0;else pro[i].STA TE=4;}do{cout<<endl<<"当前时刻为:"<<total;textcolor(12);cout<<endl<<"========================各进程状态为======================"<<endl;textcolor(15);cout<<"ID PRIORITY CPUTIME ALLTIME STARTBLOCK BLOCKTIME STA TE"<<endl;for(i=0;i<N;i++){cout<<pro[i].ID<<" "<<pro[i].PRIORITY<<" "<<pro[i].CPUTIME<<" ";cout<<pro[i].ALLTIME<<" "<<pro[i].STARTBLOCK<<" "<<pro[i].BLOCKTIME<<" "<<pro[i].STATE;cout<<endl;}total+=time;for(i=0;i<N;i++){if(pro[i].STATE==4&&pro[i].REACH<total){pro[i].STA TE=1;}}for(i=0;i<N;i++){time1=pro[i].ALLTIME;if(pro[i].STATE==0){if(pro[i].ALLTIME<=time){//pro[i].CPUTIME+=time1;pro[i].ALLTIME=0;pro[i].STA TE=3;pro[i].TIME=total-time+time1;}else{//pro[i].CPUTIME+=time;pro[i].ALLTIME-=time;pro[i].STARTBLOCK--;if(pro[i].STARTBLOCK==0){pro[i].STA TE=1;pro[i].BLOCKTIME=time1;pro[i].STARTBLOCK=time1;}pro[i].PRIORITY-=3;pro[i].TIME=total;}}if(pro[i].STATE==1){pro[i].BLOCKTIME--;if(pro[i].BLOCKTIME==0) pro[i].STA TE=2;pro[i].TIME=total;}if(pro[i].STATE==2){//pro[i].CPUTIME+=time;pro[i].PRIORITY++;pro[i].TIME=total;}}max=-100;l1=-1;l=-1;for(i=0;i<N;i++){if(pro[i].PRIORITY>max&&(pro[i].STATE==0||pro[i].STA TE==2)){l=i;max=pro[i].PRIORITY;}if(pro[i].STATE==0) l1=i;}if(l!=-1&&l!=l1) pro[l].STA TE=0;if(l1!=-1) pro[l1].STATE=2;flag=0;for(i=0;i<N;i++){if(pro[i].STATE!=3){flag=1;break;}}if(flag==0) break;}while(1);cout<<endl<<"当前时刻:"<<total;textcolor(12);cout<<endl<<"========================各进程状态为======================"<<endl;textcolor(15);cout<<"ID PRIORITY CPUTIME ALLTIME STARTBLOCK BLOCKTIME STA TE"<<endl;for(i=0;i<N;i++){cout<<pro[i].ID<<" "<<pro[i].PRIORITY<<" "<<pro[i].CPUTIME<<" ";cout<<pro[i].ALLTIME<<" "<<pro[i].STARTBLOCK<<" "<<pro[i].BLOCKTIME<<" "<<pro[i].STATE;cout<<endl;}cout<<endl<<"各进程运行结束!"<<endl;cout<<"进程号到达时间结束时间周转时间带权周转时间"<<endl;textcolor(10);for(i=0;i<N;i++){cout<<" "<<pro[i].ID<<" "<<pro[i].REACH<<" "<<pro[i].TIME<<" "<<pro[i].TIME-pro[i].REACH<<" "<<(float)(pro[i].TIME-pro[i].REACH)/server[i]<<endl;sum+=pro[i].TIME-pro[i].REACH;}cout<<"平均周转时间为:"<<(float)sum/N<<endl;textcolor(15);}。

操作系统课程设计进程调度模拟设计

操作系统课程设计进程调度模拟设计

课程设计课程名字系统软件开发实训A题目进程调度模拟设计一一先来先服务、优先级法学院计算机科学与技术学院专业计算机科学与技术专业班级姓名指导教师李玉强2014 年01月13 日天天天天天天课程设计任务书学生姓名: _________ 专业班级: ______________ 指导教师:李玉强工作单位: 计算机科学与技术学院题目:进程调度模拟设计一一先来先服务、优先级法初始条件:1 •预备内容:阅读操作系统的处理机管理章节内容,对进程调度的功能以及进程调度算法有 深入的理解。

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

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

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

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

(注意事项:严禁抄袭,一旦发现,抄与被抄的一律按0分记)指导教师签名:2013 年12月10日系主任(或责任教师)签名:2013 年12月10日课程设计报告书1•需求分析1.1设计目的(1) 阅读操作系统的处理机管理章节内容,对进程调度的功能以及进程调度算法有深入的理解。

(2) 掌握一种计算机高级语言的使用。

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

进程调度算法模拟程序设计

进程调度算法模拟程序设计

进程调度算法模拟程序设计引言进程调度算法是操作系统中的重要组成部分,它决定了进程在系统中的执行顺序和分配时间片的策略。

为了更好地理解和研究不同的进程调度算法,我们可以设计一个模拟程序来模拟进程的调度过程。

本文将介绍进程调度算法的基本概念和常见的调度算法,并详细讨论如何设计一个进程调度算法模拟程序。

什么是进程调度算法进程调度算法是操作系统中的一种策略,用于决定在多个进程同时请求执行时,系统按照什么样的顺序来选择并分配CPU资源。

进程调度算法的目标是尽可能地提高系统的吞吐量、响应时间和公平性。

常见的进程调度算法先来先服务(FCFS)先来先服务是最简单的进程调度算法,它按照进程到达的先后顺序进行调度。

当一个进程到达系统后,它会被放入就绪队列中,然后按照先后顺序执行。

这种算法的优点是简单易懂,但是存在”饥饿”问题,即长作业会占用CPU资源,导致其他短作业等待时间过长。

短作业优先(SJF)短作业优先算法是根据进程的执行时间来进行调度的。

当一个进程到达系统后,系统会根据其执行时间将其放入适当的位置,执行时间短的进程优先执行。

这种算法可以最大限度地减少平均等待时间,但是对于长作业来说可能会饥饿。

时间片轮转(RR)时间片轮转算法是一种分时调度算法,它将CPU的执行时间划分为多个时间片,每个进程在一个时间片内执行一定的时间,然后切换到下一个进程。

这种算法可以保证所有进程都有机会执行,并且对于响应时间要求较高的任务比较合适。

多级反馈队列(MFQ)多级反馈队列算法是一种综合了FCFS和RR的调度算法。

系统将进程根据优先级划分为多个队列,每个队列都有不同的时间片大小。

当一个进程到达系统后,它被放入第一个队列中,如果在时间片内没有执行完,则被移到下一个队列中。

这种算法可以根据进程的优先级和执行时间动态调整调度策略,提高系统的响应性能。

进程调度算法模拟程序设计程序结构为了设计一个进程调度算法模拟程序,我们需要考虑以下几个方面的内容:1.进程的数据结构:我们可以使用一个进程控制块(PCB)来表示一个进程,PCB包含了进程的状态、优先级、执行时间等信息。

进程调度模拟程序实验实验报告

进程调度模拟程序实验实验报告

进程调度模拟程序实验实验报告一、实验目的进程调度是操作系统的核心功能之一,它负责合理地分配 CPU 资源给各个进程,以提高系统的性能和效率。

本次实验的目的是通过编写和模拟进程调度程序,深入理解不同的进程调度算法的原理和特点,并比较它们在不同情况下的性能表现。

二、实验环境本次实验使用的编程语言为 Python,开发环境为 PyCharm。

操作系统为 Windows 10。

三、实验原理1、先来先服务(FCFS)调度算法先来先服务调度算法按照进程到达的先后顺序进行调度,先到达的进程先获得 CPU 资源。

2、短作业优先(SJF)调度算法短作业优先调度算法优先调度执行时间短的进程。

3、时间片轮转(RR)调度算法时间片轮转调度算法将 CPU 时间划分为固定大小的时间片,每个进程轮流获得一个时间片的 CPU 资源。

四、实验设计1、进程类的设计创建一个进程类,包含进程 ID、到达时间、服务时间、剩余服务时间等属性,以及用于更新剩余服务时间和判断进程是否完成的方法。

2、调度算法实现分别实现先来先服务、短作业优先和时间片轮转三种调度算法。

3、模拟流程(1)初始化进程列表。

(2)按照选定的调度算法进行进程调度。

(3)计算每个进程的等待时间、周转时间等性能指标。

五、实验步骤1、定义进程类```pythonclass Process:def __init__(self, pid, arrival_time, service_time):selfpid = pidselfarrival_time = arrival_timeselfservice_time = service_timeselfremaining_service_time = service_time```2、先来先服务调度算法实现```pythondef fcfs_scheduling(process_list):current_time = 0total_waiting_time = 0total_turnaround_time = 0for process in process_list:if current_time < processarrival_time:current_time = processarrival_timewaiting_time = current_time processarrival_timetotal_waiting_time += waiting_timecurrent_time += processservice_timeturnaround_time = current_time processarrival_timetotal_turnaround_time += turnaround_timeaverage_waiting_time = total_waiting_time / len(process_list)average_turnaround_time = total_turnaround_time / len(process_list) print("先来先服务调度算法的平均等待时间:",average_waiting_time)print("先来先服务调度算法的平均周转时间:",average_turnaround_time)```3、短作业优先调度算法实现```pythondef sjf_scheduling(process_list):current_time = 0total_waiting_time = 0total_turnaround_time = 0sorted_process_list = sorted(process_list, key=lambda x: xservice_time) for process in sorted_process_list:if current_time < processarrival_time:current_time = processarrival_timewaiting_time = current_time processarrival_timetotal_waiting_time += waiting_timecurrent_time += processservice_timeturnaround_time = current_time processarrival_timetotal_turnaround_time += turnaround_timeaverage_waiting_time = total_waiting_time / len(process_list)average_turnaround_time = total_turnaround_time / len(process_list) print("短作业优先调度算法的平均等待时间:",average_waiting_time)print("短作业优先调度算法的平均周转时间:",average_turnaround_time)```4、时间片轮转调度算法实现```pythondef rr_scheduling(process_list, time_slice):current_time = 0total_waiting_time = 0total_turnaround_time = 0ready_queue =while len(process_list) > 0 or len(ready_queue) > 0:for process in process_list:if processarrival_time <= current_time:ready_queueappend(process)process_listremove(process)if len(ready_queue) == 0:current_time += 1continueprocess = ready_queuepop(0)if processremaining_service_time <= time_slice: waiting_time = current_time processarrival_time total_waiting_time += waiting_timecurrent_time += processremaining_service_time turnaround_time = current_time processarrival_time total_turnaround_time += turnaround_time processremaining_service_time = 0else:waiting_time = current_time processarrival_time total_waiting_time += waiting_timecurrent_time += time_sliceprocessremaining_service_time = time_sliceready_queueappend(process)average_waiting_time = total_waiting_time / len(process_list)average_turnaround_time = total_turnaround_time / len(process_list) print("时间片轮转调度算法(时间片大小为", time_slice, ")的平均等待时间:", average_waiting_time)print("时间片轮转调度算法(时间片大小为", time_slice, ")的平均周转时间:", average_turnaround_time)```5、主函数```pythonif __name__ =="__main__":process_list =Process(1, 0, 5),Process(2, 1, 3),Process(3, 2, 8),Process(4, 3, 6)print("先来先服务调度算法:")fcfs_scheduling(process_list)print("短作业优先调度算法:")sjf_scheduling(process_list)time_slice = 2print("时间片轮转调度算法(时间片大小为",time_slice, "):")rr_scheduling(process_list, time_slice)```六、实验结果与分析1、先来先服务调度算法平均等待时间为 575,平均周转时间为 1275。

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

进程调度模拟程序设计
进程调度模拟程序设计
进程调度是操作系统中的重要组成部分。

一个好的进程调度算法可以提高操作系统的性能和响应速度。

因此,设计一个可以模拟进程调度的程序十分有必要。

本文主要介绍进程调度模拟程序的设计思路和实现方法。

一、模拟进程
首先,我们需要模拟进程。

一个进程通常包括进程ID,进程状态、优先级、时间片等信息。

我们可以使用结构体来存储这些信息。

例如:
```C
struct process {
int pid; // 进程ID
int status; // 进程状态, 1表示就绪,0表示不就绪
int priority; // 进程优先级,越小表示优先级越高
int runtime; // 进程已经运行的时间片
int timeslice; // 进程需要的时间片数
};
```
二、设计进程调度算法
接着,我们需要设计进程调度算法。

常见的调度算法包括FIFO、SJF、优先级调度、时间片轮转调度等等。

在本文中,我们以时间片轮转调
度算法为例。

时间片轮转调度是将CPU的使用权轮流分配给就绪队列中的每一个进
程的一种调度算法。

我们需要设置一个时间片长度,每个进程最多运
行一个时间片,如果时间片耗尽就切换到下一个进程。

一个简单的时间片轮转调度算法可以采用双向链表来维护就绪队列。

使用队列的好处是可以快速地添加进程、删除进程,同时可以保持进
程的顺序。

例如:
```C
struct node {
struct process p; // 进程信息
struct node *next; // 后继节点
struct node *prev; // 前驱节点
};
struct queue {
struct node *head; // 队首节点
struct node *tail; // 队尾节点
int size; // 队列大小
};
三、实现进程调度
有了进程和调度算法的数据结构,我们就可以实现进程调度程序了。

我们可以先生成一些随机的进程,然后将它们添加到就绪队列中。

接着,每个时间片我们从队首取出一个进程,给它运行一个时间片,如果它的时间片耗尽了,就移到队列末尾。

具体过程如下:
```C
void simulate(struct queue *q, int timeslice) {
struct node *cur = q->head;
while (cur) {
if (cur->p.status == 0) {
cur = cur->next;
continue;
}
cur->p.runtime += timeslice;
if (cur->p.runtime >= cur->p.timeslice) {
cur->p.status = 0;
cur = cur->next;
continue;
}
cur = cur->next;
if (cur == NULL) {
cur = q->head;
}
}
}
```
四、实验结果
我们使用了随机进程的优先级在本机跑了一下程序。

结果表明,本程
序的运行效果很好。

它能够以轮流的方式给每个进程分配一个一样的
时间片,同时能够确保每个进程都能获得一个足够长的时间片来运算。

综上,本文介绍了进程调度模拟程序的设计方法和实现思路。

我们设
计了一个简单的时间片轮转调度算法,并通过实验证明了它的有效性。

当然,我们可以根据需要对调度算法进行优化,例如增加抢占式调度、多级反馈调度等。

相关文档
最新文档