进程调度模拟程序设计

合集下载

进程调度模拟程序

进程调度模拟程序
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。

操作系统课程设计——进程调度模拟算法(5种)

操作系统课程设计——进程调度模拟算法(5种)

福建农林大学计算机与信息学院课程设计报告课程名称:操作系统实习题目:进程调度算法模拟姓名:***系:计算机专业:计算机科学与技术年级:2011级学号:**指导教师:***职称:***2014年1月16日福建农林大学计算机与信息学院信息工程类课程设计报告结果评定目录1.进程调度算法模拟课程设计的目的 (1)2.进程调度算法模拟课程设计的要求 (1)3.进程调度算法模拟课程设计报告内容 (1)3.1前言 (1)3.2进程调度算法模拟设计的环境 (1)3.3系统流程图及各模块 (2)4.总结 (18)参考文献 (19)参考网站 (19)进程调度算法模拟1.进程调度算法模拟课程设计的目的和意义2013-2014学年,在学习了《操作系统》这门课后,对当中的进程调度算法产生了浓厚的兴趣。

各种调度算法,理论上比较好理解。

为了加深印象,我决定把各种调度算法用C语言写出来。

于是便产生这份从头到尾都让我绞尽脑汁的课程设计。

做这份课程设计,对从事系统开发的人员来说,是必要的,可以在一定程度上为自己以后的发展铺路。

虽然用处不是特别明显,但对加深系统调用算法的理解无疑用处是巨大的。

2.进程调度算法模拟课程设计的要求1.用C语言写出至少两种进程调度算法。

2.画出大概流程图。

3.对算法过程出现的bug进行调试。

4.展示最后的算法结果3.1前言:目前比较常见的几种进程调度算法有:1.先到先服务(FCFS)2.短进程优先(非抢占和抢占)算法(SPF)3.高响应比优先算法4.时间片轮转算法我选出其中三种即先到先服务,短进程优先(2种)和时间片轮转算法进行C语言描述以加深对这三种算法的理解。

3.2进程调度算法模拟设计的环境VC++6.0及CodeBlocks,32位计算机WIN7操作系统。

3.3流程图定义进程结构体:struct Pro{int num; //进程号int time_in; //进程到达时间int work_time; //进程服务时间int btime;//用于抢占式进程优先记录该进程开始时间int l_w_time;//用于抢占式进程优先记录剩余服务时间int end_time; //记录该进程结束时间,(需要时时监测)int judge; //用于需要时的标记}pro[10]; //进程结构体1先到先服务算法描述:把所有进程按到达先后排序,每次取最先到的进程执行后淘汰,再取下一个,直到所有进程调度完毕。

模拟进程调度的程序

模拟进程调度的程序

①编写并调试一个模拟的进程调度程序,采用“最高优先数优先”调度算法对五个进程进行调度。

“最高优先数优先”调度算法的基本思想是把CPU分配给就绪队列中优先数最高的进程。

静态优先数是在创建进程时确定的,并在整个进程运行期间不再改变。

动态优先数是指进程的优先数在创建进程时可以给定一个初始值,并且可以按一定原则修改优先数。

例如:在进程获得一次CPU后就将其优先数减少1。

或者,进程等待的时间超过某一时限时增加其优先数的值,等等②编写并调试一个模拟的进程调度程序,采用“轮转法”调度算法对五个进程进行调度。

轮转法可以是简单轮转法、可变时间片轮转法,或多队列轮转法。

简单轮转法的基本思想是:所有就绪进程按FCFS排成一个队列,总是把处理机分配给队首的进程,各进程占用CPU的时间片相同。

如果运行进程用完它的时间片后还为完成,就把它送回到就绪队列的末尾,把处理机重新分配给队首的进程。

直至所有的进程运行完毕。

整个程序都是模拟“最高优先级”进程调度算法的程序#include<algorithm>#include<iomanip>#include<conio.h>using namespace std;struct PCB{string p_name;//程序名int super;//优先级double ndtime;//需要时间double runtime;//运行时间string state;//状态bool operator<(const PCB& nd){return super>nd.super ;}};int main(){int n,i,j,nn=0;cout<<"\n请输入进程总个数?";cin>>n;PCB *PB=new PCB[n];for(i=0;i<n;i++){cout<<"\n\n进程号No."<<i<<":"<<endl;cout<<"\n输入进程名:";cin>>PB[i].p_name ;cout<<"\n输入进程优先级数<0~99>:";cin>>PB[i].super ;cout<<"\n输入进程运行时间:";cin>>PB[i].ndtime ;nn +=PB[i].ndtime ;PB[i].runtime =0;PB[i].state ="完成}sort(PB,PB+n);int k=PB[0].super ;queue<PCB> *que=new queue<PCB>[k+1];for(i=0;i<n;i++)que[PB[i].super ].push (PB[i]);cout<<setfill(' ');cout<<setiosflags(ios::left);for(i=0;i<nn;i++){PCB PP=que[k].front() ;int kk;for(kk=0;kk<n;kk++)if(PP.p_name ==PB[kk].p_name) break;PB[kk].state ="R";cout<<"\n\n按任意键继续......";getch();cout<<"\n\n*-*-*-*-*-*-*-* The excute number:"<<i+1<<" *-*-*-*-*-*-*-*";cout<<"\n\n*-*-*-*-*-*-* 当前正在运行的进程是: "<<PP.p_name <<"*-*-*-*-*-*-*";cout<<"\n\np_name state super ndtime runtime";cout<<"\n |"<<setw(10)<<PP.p_name <<" |"<<setw(6)<<PB[kk].state <<" |"<<setw(6)<<PP.super <<" |"<<setw(11)<<PP.ndtime <<" |"<<PP.runtime ;PP.runtime -1;PB[kk].runtime -1;if(PB[kk].super >0) PB[kk].super -=1;que[k].pop ();cout<<"\n\n*-*-*-*-*-*-* 当前就绪队列状态为: *-*-*-*-*-*-*";for(j=0;j<n;j++)if(PB[j].state =="W"){cout<<"\n\np_name state super ndtime runtime";cout<<"\n |"<<setw(10)<<PB[j].p_name <<" |"<<setw(6)<<PB[j].state <<" |"<<setw(6)<<PB[j].super <<" |"<<setw(11)<<PB[j].ndtime <<" |"<<PB[j].runtime ;}if(PP.runtime ==PP.ndtime ){PB[kk].state ="F";cout<<"\n\n时间片到期,此时进程["<<PB[kk].p_name <<"]已完成.";if(que[k].empty ()&&k>0) k--;}else{PB[kk].state ="W";if(k>0) que[k-1].push (PB[kk]);else que[k].push (PB[kk]);if(que[k].empty ()&&k>0) k--;}}cout<<"\n\n进程已全部完成."<<endl<<endl;return 0;}。

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

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

进程调度算法模拟程序设计一、背景介绍进程调度算法是操作系统中的一个重要概念,它决定了操作系统如何分配CPU时间片给不同的进程。

不同的调度算法有不同的优缺点,需要根据具体情况进行选择。

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

二、程序设计思路1. 定义进程结构体首先需要定义一个进程结构体,包含进程ID、到达时间、服务时间、开始时间、完成时间等信息。

这些信息是模拟程序中需要用到的基本信息。

2. 选择调度算法接下来需要选择要模拟的调度算法,常见的有先来先服务(FCFS)、最短作业优先(SJF)、时间片轮转(RR)等。

不同的算法对应着不同的实现方法和数据结构。

3. 实现调度算法对于每种调度算法,都需要实现相应的函数来进行模拟。

比如对于FCFS算法,可以按照到达时间从小到大排序,然后依次执行每个进程;对于SJF算法,则需要按照服务时间从小到大排序,在每个时刻选择服务时间最短的进程执行;对于RR算法,则需要使用队列来保存就绪队列中的所有进程,并按照时间片轮转的方式依次执行。

4. 输出结果最后需要输出每个进程的开始时间、完成时间、周转时间、带权周转时间等信息,以便进行比较和分析。

三、程序设计实现1. 定义进程结构体```c++struct Process {int pid; // 进程IDint arriveTime; // 到达时间int serviceTime; // 服务时间int startTime; // 开始时间int finishTime; // 完成时间};```2. 选择调度算法这里我们选择实现FCFS算法。

FCFS算法的实现比较简单,只需要按照到达时间从小到大排序,然后依次执行每个进程即可。

3. 实现调度算法```c++void fcfs(vector<Process>& processes) {sort(processes.begin(), processes.end(), [](const Process& a, const Process& b) {return a.arriveTime < b.arriveTime;});int currentTime = 0;for (int i = 0; i < processes.size(); i++) {if (currentTime < processes[i].arriveTime) {currentTime = processes[i].arriveTime;}processes[i].startTime = currentTime;processes[i].finishTime = currentTime +processes[i].serviceTime;currentTime = processes[i].finishTime;}}```4. 输出结果```c++void printResult(const vector<Process>& processes) {double totalTurnaroundTime = 0, totalWeightedTurnaroundTime = 0;cout << "进程ID\t到达时间\t服务时间\t开始时间\t完成时间\t 周转时间\t带权周转时间" << endl;for (const auto& p : processes) {int turnaroundTime = p.finishTime - p.arriveTime;double weightedTurnaroundTime =(double)turnaroundTime / p.serviceTime;totalTurnaroundTime += turnaroundTime;totalWeightedTurnaroundTime += weightedTurnaroundTime;printf("%d\t%d\t%d\t%d\t%d\t%d\t%.2f\n", p.pid,p.arriveTime, p.serviceTime, p.startTime,p.finishTime, turnaroundTime, weightedTurnaroundTime);}int n = processes.size();printf("平均周转时间:%.2f\n", (double)totalTurnaroundTime / n);printf("平均带权周转时间:%.2f\n", totalWeightedTurnaroundTime / n);}```四、总结通过以上程序设计实现,我们可以更好地理解和掌握进程调度算法。

(完整word版)进程调度模拟程序设计

(完整word版)进程调度模拟程序设计

进程调度模拟程序设计一、实验目的按优先数调度算法或时间片轮转法模拟处理器调度,从而进一步理解处理器调度的原理。

二、实验内容1.设计思路(1)数据结构定义(a)对于不同的调度算法,定义不同的PCB结构体typedef struct PCB_type1 {char name[10]; //进程名char state;//进程状态R—-就绪状态E——结束状态int need_time; //运行需要的CPU时间(需运行的时间片个数)int priority;}PCB_P; //按优先数调度算法的PCB结构体typedef struct PCB_type2 {char name[10];//进程名int state; //进程状态R-—就绪状态E——结束状态int need_time; //运行需要的CPU时间(需运行的时间片个数)int used_time; //}PCB_T;//按时间片轮转算法的PCB结构体(b)用全局变量choice来指明当前应用的调度算法int choice;(c)为了模拟调度,可以利用STL定义队列deque<PCB_P> q1;queue〈PCB_T〉q2;(2)程序主要模块一共有三个自定义函数,分别是:start_state() 提示用户选择调度算法,初始化进程信息。

dispatch()模拟调度(a)对于优先数调度算法,每次调度前对队列里的进程按优先数从大到小排序,然后调度选中队首的进程,将其出队列,并将进程优先数和需要运行时间减1。

如果此进程的需要运行时间不为0,则继续将此进程入队;如果此进程的需要运行时间为0了,则将其状态置为结束状态。

重复上述过程直至队列为空.(b)对于时间片轮转算法,调度选中队首的进程,将其出队列,并将进程已用时间加1。

如果此进程要求运行时间已运行时间,则尚未执行结束,继续将此进程入队;如果此进程的要求运行时间=已运行时间,则已经执行结束,将其状态置为结束状态。

操作系统实验进程调度程序设计

操作系统实验进程调度程序设计

操作系统实验进程调度程序设计实验目的:1.了解进程调度的原理和实现方式;2.掌握操作系统中进程调度算法的设计和实现方法;3.实现一个简单的进程调度程序,模拟不同的调度算法。

实验内容:在操作系统中,进程调度是一项重要的任务。

它负责决定哪些进程可以运行,以及在什么时间运行。

进程调度的主要目标是提高计算机系统的资源利用率和吞吐量,以及减少用户的响应时间。

本次实验的目标是设计一个简单的进程调度程序,并实现不同的调度算法。

你需要完成以下任务:1. 了解调度算法的基本概念和原理,如先来先服务(FCFS)、最短进程优先(SJF)、优先级调度(Priority Scheduling)、时间片轮转(Round Robin)等;2. 设计一个进程控制块(Process Control Block, PCB),用于存储进程的相关信息,包括进程的标识符、优先级、到达时间、执行时间等;3.实现以上调度算法中的任意一种。

你可以选择自己感兴趣或熟悉的调度算法进行实现。

如果你不确定,可以选择先来先服务(FCFS)算法,这是最简单的调度算法之一;4.编写测试程序,模拟多个进程的到达和执行过程。

你可以根据需要设置不同的进程到达时间和执行时间,并观察不同调度算法下的执行效果。

实验步骤:1.了解调度算法的原理和实现方式。

可以通过查阅相关教材、资料或网络资源来获得更多信息;2. 设计进程控制块(Process Control Block, PCB),其中包括进程的标识符、优先级、到达时间、执行时间等信息;3.根据选择的调度算法,编写相应的调度程序。

你可以选择使用C、C++或其他编程语言来实现;4.编写测试程序,模拟多个进程的到达和执行过程。

可以通过使用随机数生成器来模拟进程到达时间和执行时间;5.运行测试程序,观察不同调度算法下的执行效果。

可以比较各个算法的平均周转时间、平均等待时间等指标,并分析结果;6.根据需要进行调整和优化,再次运行测试程序,并观察结果;7.总结实验过程和结果,撰写实验报告。

进程调度模拟程序

进程调度模拟程序

进程调度模拟程序一、引言进程调度是操作系统中的重要组成部分,它负责决定哪个进程能够获得CPU的使用权,以及何时、多久获得。

进程调度算法的设计直接影响到系统的性能和效率。

为了评估和比较不同调度算法的性能,我们需要进行进程调度模拟程序的开发。

二、背景在操作系统中,进程调度是为了合理、高效地利用CPU资源,提高系统的吞吐量和响应时间。

进程调度算法的选择和实现需要考虑多个因素,如进程的优先级、进程的等待时间、进程的执行时间等。

为了更好地理解和评估不同的调度算法,我们需要开发一个进程调度模拟程序。

三、目的本文档的目的是详细描述进程调度模拟程序的标准格式,包括程序的输入、输出、功能和实现细节。

通过本文档,读者将了解到如何使用该模拟程序进行不同进程调度算法的模拟,并根据模拟结果评估不同算法的性能。

四、程序输入1. 进程信息:模拟程序需要输入一组进程信息,包括进程ID、到达时间、执行时间和优先级等。

可以通过读取文件或手动输入的方式提供进程信息。

2. 调度算法选择:模拟程序需要用户选择要使用的调度算法,如先来先服务(FCFS)、最短作业优先(SJF)、优先级调度等。

3. 其他参数设置:模拟程序可能需要用户设置其他参数,如时间片大小(对于时间片轮转调度算法)、优先级范围等。

五、程序输出1. 进程调度顺序:模拟程序将输出进程按照调度算法执行的顺序,包括进程ID和执行时间等。

2. 平均等待时间:模拟程序将输出平均等待时间,用于评估调度算法的性能。

3. 其他评价指标:根据具体的调度算法,模拟程序可能还输出其他评价指标,如响应时间、周转时间等。

六、程序功能1. 进程调度模拟:模拟程序根据输入的进程信息和调度算法,模拟执行进程调度过程,并输出调度结果。

2. 性能评估:模拟程序根据调度结果,计算出各种评价指标,用于评估不同调度算法的性能。

七、实现细节1. 数据结构:模拟程序可以使用适当的数据结构来表示进程信息和调度队列,如数组、链表、优先队列等。

《高级语言程序设计》课程设计--进程调度模拟

《高级语言程序设计》课程设计--进程调度模拟

《高级语言程序设计》课程设计报告题目:进程调度模拟目录1 1 设计目的及要求 (3)1.1 设计目的 (3)1.2 课程设计的实验环境 (3)1.3 课程设计的预备知识 (3)1.4 课程设计要求 (3)2 课程设计内容 (3)2.1程序功能介绍 (3)2.2程序整体设计说明 (4)2.2.1设计思路 (4)2.2.2数据结构设计及用法说明 (5)2.2.3程序结构(流程图) (5)2.2.4各模块的功能及程序说明 (6)2.2.5程序运行结果 (7)3 总结 (9)参考资料 (11)程序源代码 (12)1 设计目的及要求1.1 设计目的本课程设计是计算机科学与技术专业重要的实践性环节之一,是在学生学习完《程序设计语言(C)》课程后进行的一次全面的综合练习。

本课程设计的目的和任务:1. 巩固和加深学生对C语言课程的基本知识的理解和掌握2. 掌握C语言编程和程序调试的基本技能3. 利用C语言进行基本的软件设计4. 掌握书写程序设计说明文档的能力5. 提高运用C语言解决实际问题的能力1.2 课程设计的实验环境硬件要求能运行Windows 2000/XP操作系统的微机系统。

C语言程序设计及相应的开发环境。

1.3 课程设计的预备知识熟悉C语言及C语言开发工具。

1.4 课程设计要求1. 分析课程设计题目的要求2. 写出详细设计说明3. 编写程序代码,调试程序使其能正确运行4. 设计完成的软件要便于操作和使用5. 设计完成后提交课程设计报告2课程设计内容2.1程序功能介绍在多道程序环境下,进程数目往往多于处理机数目,致使他们争用处理机。

这就要求系统能按某种算法,动态地把处理机分配给就绪队列中的一个进程,使之运行。

分配处理机的任务是由进程调度程序完成的。

一个进程被建立后,系统为了便于对进程进行管理,将系统中的所有进程按其状态,将其组织成不同点进程队列。

于是系统中有运行进程队列、就绪队列和各种事件的进程等待队列。

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

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

操作系统进程调度模拟程序实验报告一、实验目的本次实验旨在通过编写一个模拟操作系统进程调度的程序,以加深对进程调度算法的理解。

二、实验内容1. 实现进程相关的数据结构:进程PCB(Process Control Block)。

2.实现进程的创建、撤销以及调度等操作函数。

3. 实现常见的进程调度算法:先来先服务(FCFS)、最短作业优先(SJF)、轮转调度(RR)、优先级调度(Priority)。

4.编写测试程序,验证实现的进程调度算法在不同场景下的表现。

三、实验过程及结果1.进程PCB的设计与实现进程PCB是进程的核心数据结构,用于存储和管理进程相关的信息,包括进程状态(就绪、运行、阻塞)、优先级、执行时间等。

2.进程的创建、撤销及调度函数的实现(1)进程创建函数:实现进程的创建,包括为其分配空间、初始化进程PCB等。

可以根据实际需求,设定进程的优先级、执行时间等属性。

(2)进程撤销函数:实现进程的撤销,包括释放其占用的资源、回收其使用的空间等。

(3)进程调度函数:根据不同的调度算法,实现进程的调度。

可以通过设置时间片大小、优先级设定等方式,实现不同调度算法的效果。

3.进程调度算法的设计与实现(1)先来先服务(FCFS)调度算法:按照进程到达的先后顺序,依次进行调度。

(2)最短作业优先(SJF)调度算法:根据进程的执行时间,选择执行时间最短的进程进行调度。

(3)轮转调度(RR)算法:按照时间片的大小进行调度,每个进程在一个时间片内执行,超过时间片后,暂停并进入等待队列,让其他进程执行。

(4)优先级调度(Priority)算法:根据进程的优先级,选择优先级最高的进程进行调度。

4.测试程序编写测试程序,模拟不同的进程到达顺序、执行时间和优先级等场景,验证不同调度算法的表现。

四、实验结果与分析通过测试程序的运行结果,观察不同调度算法的特点和效果。

可以得出以下结论:1.FCFS算法适用于进程到达时间差异较大的场景,保证了先到先服务。

  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;
}
}
}
```
四、实验结果
我们使用了随机进程的优先级在本机跑了一下程序。

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

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

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

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

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

相关文档
最新文档