操作系统原理短作业优先算法报告附源代码
- 格式:doc
- 大小:63.50 KB
- 文档页数:8
实验6 进程调度算法设计一、实验室名称:进程调度实验二、实验内容:1、验证、理解进程调度算法的设计(短进程优先调度SPF)2、根据SPF代码实现先来先服务调度算法三、实验原理:在多道程序系统中,一个作业被提交后必须经过处理机调度后,方能获得处理机执行。
对调度的处理又都可采用不同的调度方式和调度算法。
调度算法是指:根据系统的资源分配策略所规定的资源分配算法。
短进程优先调度算法是指对短进程优先调度的算法,它是从后备队列中选择一个或者若干个进程,将处理机分配给它,使它立即执行并一直执行到完成,或发生某事件而被阻塞放弃处理机时再重新调度。
四、实验目的:通过实现SPF算法深入了解进程调度机制,加深理解。
五、实验内容:1. 编写SPF算法:●进程通过定义一个进程控制块的数据结构(PCB)来表示;●每个进程需要赋予进程ID、进程到达时间、进程需要运行的总时间的属性;2. 调试无误后运行;3. 输入需要请求调入的页号;4. 查看执行结果,根据执行结果判断实验是否成功;六、实验器材(设备、元器件):1.基本环境要求①宽敞整洁专用实验室②必备的基本实验工具2.最低设备要求①计算机CPU不小于800MHZ;②计算机内存不小于128M;3.软硬件要求①实验平台Visual c++ 6.0七、实验步骤:代码如下:#include<stdio.h>#define n 5#define num 5#define max 65535typedef struct pro{int PRO_ID;int arrive_time;int sum_time;int flag;}Pro;//整数排序int bubble(int temp[]){int i,j,tem=0;int lastX;for(i=1;i<num;i++){lastX=1;for(j=0;j<num-i;j++){if(temp[j]>temp[j+1]){tem=temp[j];temp[j]=temp[j+1];temp[j+1]=tem;lastX=0;}}if(lastX==1) break;}return temp[0];}//进程排序Pro bubble2(Pro p[]){int i,j;Pro temp={0};Pro s[num];for(i=0;i<num;i++){s[i]=p[i];}for(i=1;i<num;i++){int lastX=1;for(j=0;j<num-i;j++){if(s[j].sum_time>s[j+1].sum_time){temp=s[j];s[j]=s[j+1];s[j+1]=temp;lastX=0;}}if(lastX==1) break;}return s[0];}void SPF(int p){if(n>0){int i,j,k,l,tc=0;Pro seq[n];Pro temp_seq[n];int temp[num];printf("短进程优先调度算法SPF\n");printf("请依次输入5个进程的进程号、到达时间和执行时间\n");printf("成员变量用逗号隔开;进程间用回车隔开\n");for(i=0;i<n;i++){scanf("%d,%d,%d",&seq[i].PRO_ID,&seq[i].arrive_time,&seq[i].sum_time);}printf("调度顺序是:\n");//初始化tcfor(i=0;i<num;i++){temp[i]=seq[i].arrive_time;}tc=bubble(temp);//tc是断点啊//flag 表示对应i的pro的队列情况//-1表示未进入过队列,0表示在队列中,1表示被清除了for(i=0;i<n;i++){seq[i].flag=-1;}for(i=0;i<n;i++){for(j=0;j<n;j++){if(seq[j].flag!=1&&seq[j].arrive_time<=tc){seq[j].flag=0;}}for(j=0;j<n;j++){temp_seq[j]=seq[j];if(seq[j].flag!=0){temp_seq[j].sum_time=max;}}l=bubble2(temp_seq).PRO_ID;for(j=0;j<n;j++){if(l==seq[j].PRO_ID){k=j;}}tc=tc+bubble2(temp_seq).sum_time;seq[k].flag=1;printf("%d",l);}printf("\n");}}void main(){SPF(n);}结果截图:实例1实例2八、实验数据及结果分析:/*算法详细设计:进程(PRO_ID,arrive_time,sum_time,flag)1.比较停顿时间点,小于等于当前停顿时间点tc的到达时间点seq[i].arrive_time的进程seq[i]的PRO_ID加入到队列中;2.在现有更新后的队列temp_seq中,用bubble选出最短执行时间的进程的PRO_ID;3.选进程(算法核心L=bubble(int temp[])),更新下一个停顿时间点tc 就是当前停顿时间点tc+L的执行时间sum_time;4.将X踢出队列。
短作业(进程)优先调度算法:短作业调度算法是从后备队列中选择一个或者若干个估计运行时间最短的作业,将他们调入内存运行。
而短进程优先调度算法则是从就绪队列中选出一个估计运行时间最短的进程,将处理机分配给它,使它立即执行并一直执行到完成,或者发生某事件而被阻塞放弃处理机时再重新调度。
短进程优先调度源代码:#include "stdio.h"struct sjf{char name[10];float arrivetime;float servicetime;float starttime;float finishtime;float zztime;float dqzztime;};sjf a[100];void input(sjf *p,int N){ int i;printf("intput the process's name & arrivetime & servicetime:\nfor exmple: a 0 100\n");for(i=0;i<=N-1;i++){printf("input the %dth process's information:\n",i+1);scanf("%s%f%f",&p[i].name,&p[i].arrivetime,&p[i].servicetime);}}void Print(sjf *p,float arrivetime,float servicetime,float starttime,float finishtime,float zztime,float dqzztime,int N){int k;printf("run order:");printf("%s",p[0].name);for(k=1;k<N;k++){printf("-->%s",p[k].name);}printf("\nthe process's information:\n");printf("\nname\tarrive\tservice\tstart\tfinish\tzz\tdqzz\n");for(k=0;k<=N-1;k++){ printf("%s\t%-.2f\t%-.2f\t%-.2f\t%-.2f\t%-.2f\t%-.2f\t\n",p[k].name,p[k].arrivetime,p[k].servicet ime,p[k].starttime,p[k].finishtime,p[k].zztime,p[k].dqzztime);}}//排序void sort(sjf *p,int N){for(int i=0;i<=N-1;i++)for(int j=0;j<=i;j++)if(p[i].arrivetime<p[j].arrivetime){sjf temp;temp=p[i];p[i]=p[j];p[j]=temp;}}//运行阶段void deal(sjf *p, float arrivetime,float servicetime,float starttime,float finishtime,float &zztime,float &dqzztime,int N){ int k;for(k=0;k<=N-1;k++){if(k==0){p[k].starttime=p[k].arrivetime;p[k].finishtime=p[k].arrivetime+p[k].servicetime;}else{p[k].starttime=p[k-1].finishtime;p[k].finishtime=p[k-1].finishtime+p[k].servicetime;}}for(k=0;k<=N-1;k++){p[k].zztime=p[k].finishtime-p[k].arrivetime;p[k].dqzztime=p[k].zztime/p[k].servicetime;}}void sjff(sjf *p,int N){float arrivetime=0,servicetime=0,starttime=0,finishtime=0,zztime=0,dqzztime=0;//对结构进行初始化sort(p,N);for(int m=0;m<N-1;m++){if(m==0)p[m].finishtime=p[m].arrivetime+p[m].servicetime;elsep[m].finishtime=p[m-1].finishtime+p[m].servicetime;int i=0;for(int n=m+1;n<=N-1;n++){if(p[n].arrivetime<=p[m].finishtime)//判断内存中每次完成之后有多少到达的进程i++;}float min=p[m+1].servicetime;int next=m+1;//m+1=nfor(int k=m+1;k<m+i;k++) //找出到达后的进程中最小的进程{if(p[k+1].servicetime<min){min=p[k+1].servicetime;next=k+1;}}sjf temp;temp=p[m+1];p[m+1]=p[next];p[next]=temp;}deal(p,arrivetime,servicetime,starttime,finishtime,zztime,dqzztime,N);Print(p,arrivetime,servicetime,starttime,finishtime,zztime,dqzztime,N);}void main(){ int N;printf("------短作业优先调度算法------\n");printf("input the process's number:\n");scanf("%d",&N);input(a,N);sjf *b=a;sjf *c=a;sjff(b,N);}。
操作系统实验_先来先服务的调度算法及短作业优先1.引言操作系统的调度算法是指在多进程环境中,操作系统为进程分配CPU 的顺序和策略。
先来先服务(FCFS)调度算法是最简单的调度算法之一,它按照进程到达的顺序为其分配CPU。
而短作业优先(SJF)调度算法是根据进程的执行时间来为其分配CPU,执行时间越短的进程越先执行。
本文将分别介绍FCFS调度算法和SJF调度算法,并对其进行评价和比较。
2.先来先服务(FCFS)调度算法2.1调度原理FCFS调度算法的原理非常简单,按照进程到达的顺序为其分配CPU。
当一个进程进入就绪队列后,如果CPU空闲,则立即为其分配CPU。
如果CPU正忙,则进程进入等待队列,等待CPU空闲后再分配。
在该算法中,进程的运行时间不考虑,只考虑进程到达的时间。
2.2优点与缺点FCFS调度算法的主要优点是实现简单,无需对进程的运行时间进行估计。
但FCFS算法存在一定的缺点。
首先,长作业在短作业前面等待的时间较长,可能导致长作业的响应时间过长。
其次,如果有一个进程出现阻塞或响应时间过长,其后面的进程也会受到影响,造成整个系统的性能下降。
3.短作业优先(SJF)调度算法3.1调度原理短作业优先(SJF)调度算法是根据进程的执行时间来为其分配CPU。
当一个进程进入就绪队列后,如果其执行时间比当前正在运行的进程短,则优先为该进程分配CPU。
如果当前没有运行的进程或者当前运行的进程执行完毕,则立即为该进程分配CPU。
在该算法中,进程的到达时间不考虑,只考虑进程的执行时间。
3.2优点与缺点SJF调度算法的主要优点是可以最大程度地减少平均等待时间,提高系统的吞吐量。
短作业可以快速执行完毕,从而让更多的作业得以执行。
但SJF算法存在一定的缺点。
首先,需要对进程的执行时间有一个准确的估计,对于实时系统或动态系统来说,估计执行时间可能会有一定的误差。
其次,在长作业激增的情况下,短作业可能会一直得不到CPU的分配,造成长时间的等待。
先来先服务调度和最短作业优先调度算法实验报告实验报告一、实验目的本实验旨在通过编写代码实现先来先服务调度算法和最短作业优先调度算法,以深入理解和掌握这两种调度算法的原理和实现方法。
二、实验方法和原理1.先来先服务调度算法(FCFS)2.最短作业优先调度算法(SJF)最短作业优先调度算法是根据作业所需的运行时间进行调度的。
当一个作业到达并获得CPU后,系统会选择剩余运行时间最短的作业进行处理,这样可以最大化地提高系统的吞吐量。
三、实验过程与结果1.先来先服务调度算法的实现我们先定义一个作业类Job,其中包含作业名称、到达时间和运行时间等属性。
首先根据到达时间对作业队列进行排序,然后按照顺序执行作业,记录每个作业的开始时间、结束时间和周转时间等指标。
下面是先来先服务调度算法的代码实现部分:```pythonclass Job: = namedef fcfs_scheduler(jobs):for job in sorted_jobs:#创建作业队列jobs =Job("Job1", 0, 3),Job("Job2", 1, 4),Job("Job3", 2, 2),Job("Job4", 4, 1)#调度作业fcfs_scheduler(jobs)#输出结果for job in jobs:```运行以上代码,会得到作业的开始时间、结束时间和周转时间等信息。
2.最短作业优先调度算法的实现最短作业优先调度算法需要知道每个作业的运行时间,而这个信息在实际情况中是未知的。
因此,我们可以先按到达时间对作业队列进行排序,然后在每个时间片中选择剩余运行时间最短的作业进行执行。
下面是最短作业优先调度算法的代码实现部分:```pythondef sjf_scheduler(jobs):while True:if not remaining_jobs:break#创建作业队列jobs =Job("Job1", 0, 3),Job("Job2", 1, 4),Job("Job3", 2, 2),Job("Job4", 4, 1)#调度作业sjf_scheduler(jobs)#输出结果for job in jobs:```运行以上代码,会得到相应的作业调度结果。
#ifndef PCH_H#define PCB_Hstruct pcb{int num;char name[10];int in_time;int server_time;int finish_time;int cur_time;float power_cur_time;};#endifList.h:#ifndef LIST_H__#define LIST_H__#include"pcb.h"typedef struct list{struct pcb _pcb;struct list *next;}List,*pList;void InitList(List **pHead);void InsertHead( List **pHead,int _num,char *_name,int _in_time,int _server_time); void Delete(List *phead,List *p);void Insert(List *phead,List *p);List * FindMin(List *phead);List * FindShort(List *phead);void InsertArriver(List *phead,List *desHead,int time);static List *BuyNode();void Print(List *phead);#endif#include<stdio.h>#include<assert.h>#include"list.h"#include<malloc.h>#include<string.h>#include<iostream>using namespace std;void InitList(List **pHead){*pHead=BuyNode();(*pHead)->next = NULL;}void InsertHead(List **pHead,int _num,char *_name,int _in_time,int _server_time) {List *p=BuyNode();assert( *pHead != NULL );assert(p!=NULL);(p->_pcb).num=_num;strcpy((p->_pcb).name,_name);(p->_pcb).in_time=_in_time;(p->_pcb).server_time=_server_time;p->next=(*pHead)->next;(*pHead)->next=p;}void Delete(List *phead,List *p){List *pre=phead;while(pre->next != p){pre=pre->next ;}pre->next=pre->next ->next ;}void Insert(List *phead,List *p){List *pre=phead;//List *pInsert=while(pre->next!= NULL&&pre->next != p ){pre=pre->next ;}p->next =pre->next ;pre->next =p;}static List *BuyNode(){List *p=(List *)malloc(sizeof(List));assert(p!=NULL);return p;}List * FindMin(List *phead){assert(phead != NULL && phead->next != NULL);int min_intime=phead->next ->_pcb.in_time;List *p=phead->next;List *pdes=p;while(p!=NULL){if(p->_pcb.in_time <min_intime){min_intime=p->_pcb.in_time;pdes=p;}p=p->next ;}return pdes;}List * FindShort(List *phead){assert(phead != NULL && phead->next != NULL);int min_intime=phead->next ->_pcb.server_time;List *p=phead->next;List *pdes=p;while(p!=NULL){if(p->_pcb.server_time <min_intime){min_intime=p->_pcb.server_time;pdes=p;}p=p->next ;}return pdes;}void InsertArriver(List *phead,List *desHead,int time) {assert(phead != NULL && phead->next !=NULL);List *pcur=phead->next ;List *p=pcur;while(pcur!=NULL ){if(pcur->_pcb.in_time <= time){p=pcur;pcur=pcur->next;Delete(phead,p);Insert(desHead,p);}else{pcur=pcur->next;}}}void Print(List *phead){if(phead!=NULL && phead->next != NULL){List *pcur=phead->next;while(pcur!=NULL){cout<<"num " <<pcur->_pcb.num<<endl;cout<<"name "<<pcur->_;cout<<"intime " <<pcur->_pcb.in_time<<endl;cout<<"servertime " <<pcur->_pcb.server_time<<endl;cout<<"finish " <<pcur->_pcb.finish_time<<endl;cout<<"curtime " <<pcur->_pcb.cur_time<<endl;cout<<"power_cur_time "<<pcur->_pcb.power_cur_time<<endl;cout<<endl;pcur=pcur->next ;}}}Spf.h:#ifndef __SPF__#define __SPF__void spf(List *phead,List *pheadAccom);#endifSpf.cpp:#include"list.h"#include<stdio.h>#include"spf.h"void spf(List *phead,List *pheadAccom){List *ArriveHead=NULL;InitList(&ArriveHead);int finish_time=0;int lastAccom_time=0;List *p=NULL;while(phead->next != NULL || ArriveHead->next !=NULL){if(phead->next != NULL){InsertArriver(phead,ArriveHead,finish_time);}p=FindShort(ArriveHead);finish_time=lastAccom_time+p->_pcb .server_time ;p->_pcb .finish_time=finish_time;lastAccom_time=finish_time;p->_pcb .cur_time=p->_pcb.finish_time -p->_pcb .in_time ;p->_pcb.power_cur_time=float(p->_pcb.cur_time )/float( p->_pcb.server_time);Delete(ArriveHead,p);Insert(pheadAccom,p);}}Fcfs.h:#ifndef FCFS__#define FCFS__void Fcfs(List *phead,List *pheadAccom);#endifFcfs.cpp:#include<stdio.h>#include"list.h"#include"Fcfs.h"void Fcfs(List *phead,List *pheadAccom){List *p=NULL;int min_intime=0;int finish_time=0;int lastAccom_time=0;while(phead->next != NULL){p=FindMin(phead);finish_time=lastAccom_time+p->_pcb .server_time ;p->_pcb .finish_time=finish_time;lastAccom_time=finish_time;p->_pcb .cur_time=p->_pcb.finish_time -p->_pcb .in_time ;p->_pcb .power_cur_time =float(p->_pcb.cur_time )/float( p->_pcb.server_time);Insert(pheadAccom,p);Delete(phead,p);}}Main.cpp:#include<stdio.h>#include<string.h>#include<iostream>#include"list.h"#include"Fcfs.h"#include"SPF.H"using namespace std;int main(){char name[10]={0};int in_time=0;int server_time=0;int i=1;char x=0;List *head=NULL;List *SPFAccom=NULL;List *FCFSAccom=NULL;InitList(&head);InitList(&SPFAccom);InitList(&FCFSAccom);printf("请输入进程的信息\n");printf("进程名到达时间服务时间\n");while(true){printf("请输入第%d个进程信息\n",i);fgets(name,10,stdin);scanf("%d",&in_time);scanf("%d",&server_time);InsertHead(&head,i,name,in_time,server_time);i++;printf("contiue? 按q停止,按任意键继续\n");scanf("%c",&x);scanf("%c",&x);if(x == 'q'){break;}else{continue;}}Fcfs(head,FCFSAccom);spf(head,SPFAccom);cout<<"先来先服务的结果"<<endl;Print(FCFSAccom);cout<<"短作业优先的结果"<<endl;Print(SPFAccom);return 0;}。
《Visual FoxPro实用教程》电子实验报告题目:求三角形的面积日期2012.9.24姓名陈庆庆实验环境:PC机,Windows XP,Visual FoxPr6.0实验目的:1.熟悉VFP的集成开发环境。
2.掌握主窗口,菜单,工具栏和命令窗口的使用方法。
3.掌握查找帮助主题的方法。
实验内容:1.理论描述:短作业优先算法即若干个进程运行,也可能是同一时间到达,也可能是不同的时间到达,同样不同的进程所需要的时间也不一样,短作业优先即比较每个进程所需要的服务时间,如果进程是同一时间到达,那么所需服务时间最短的进程最先被执行,即服务时间由小到大排序,得出的顺序即为进程先后被执行的顺序。
若进程不是同一时间到达,则需比较到达时间的先后以及所需时间的大小,通过这两者的时间来进行排序,从而找出进程先后被执行的顺序。
2.设计思想:此算法简单来说即是对每个进程的到达时间以及所需的服务时间从而找出进程先后被执行的顺序,因此简单来说有两种情况:(1)每个进程的到达时间相同,此种情况只需对每个进程所需要的服务时间进行比较,之后输出进程被执行的先后顺序。
(2)每个进程的到达时间不同,所需要的服务时间也不同,此种情况需要对进程的到达时间和所需的服务时间同时进行比较,从而得出进程被执行的先后顺序。
3.画出流程图。
4.写出源程序调试并运行通过。
#include<iostream>using namespace std;struct pcb{char pno;//到达时间int come_time;开始输入要创建的进程数i输入进程名,到达时间按,服务时间输出进程被执行的顺寻根据进程到达时间、服务时间对进程进行排序结束//服务时间int run_time;};float fcfs(pcb pro[],int n){struct pcb;int i;//time为当前时间float time=0;//temp=(pcb)malloc(sizeof(pcb));cout<<"进程调度情况如下:"<<endl;cout<<"进程号到达时间服务时间:"<<endl;for(i=0;i<n;i++){ time+=pro[i].run_time;cout<<pro[i].pno<<" "<<pro[i].come_time<<""<<pro[i].run_time<<endl;}return 0;}float sjp(pcb pro[],int n){int i,first=0,count,flag[20],k,min;float time=0;//调度第一个到达内存的进程for(i=0;i<n;i++){if(pro[first].come_time!=pro[i].come_time){if(pro[first].come_time>pro[i].come_time) first=i;}else if(pro[first].run_time>pro[i].run_time) first=i;flag[i]=0;}flag[first]=0;time=(float)pro[first].run_time;cout<<pro[first].pno<<" "<<pro[first].come_time<<""<<pro[first].run_time<<endl;//pro_temp[0]=pro[first];count=n-1;while(count){k=0;//设置一个较大的阈值min=32767;//找到一个未被访问的,作业较短的且已经到达内存的作业调度,for(i=0;i<n;i++)if((i!=first)&&(flag[i]==0)&&(time>=pro[i].come_time)&&(min>pro[i].run_time)) {k=i;min=pro[i].run_time;}//访问后置标记为访问flag[k]=1;time+=pro[k].run_time;cout<<pro[k].pno<<" "<<pro[k].come_time<<""<<pro[k].run_time<<endl;//每调度一个作业,count减1count--;}return 0;}int main(){int i,j;pcb pro[100];cout<<"输入进程数i:"<<endl;cin>>i;for(j=0;j<i;j++){cout<<"输入进程:";cin>>pro[j].pno>>pro[j].come_time>>pro[j].run_time; }cout<<fcfs(pro,j)<<endl;cout<<sjp(pro,j)<<endl;}出现的问题:(本部分详细列出在编写程序的过程中出现的问题)1.根据提示输入进程后,如果进程同一时间到达,最先输入的进程最先被执行,其余进程是排序后显示。
短作业优先调度算法(SJF)假设有n项作业位于就绪队列中,这些作业的提交时间⽤数组requestTimes按照提交时间的先后顺序存储,对应的作业服务时间(持续时间)⽤数组durations存储。
采⽤SJF算法,计算n项作业的平均等待时间。
当存在多个相同长度的短作业时,按照提交时间的先后顺序进⾏调度。
假设0<= n <= 100。
求出所有作业的平均等待时间。
函数原型:void minWaitingTime(int requestTimes[],int durations[],int n)测试⽤例:输⼊40 2 4 57 4 1 4输出:4.01 #include <stdio.h>2 #include <stdlib.h>3 #include <string.h>45#define MAX 0x7FFFFFFF67void minWaitingTime(int requestTimes[],int durations[],int n)8 {9int i,time,j,k;10float res;11int index,arriveTime,indextemp;12int *done = (int *)malloc(sizeof(int) * n); //表⽰作业是否执⾏过,1表⽰执⾏完毕,0表⽰未执⾏13int *wait = (int *)malloc(sizeof(int) * n); //表⽰等待时间14for(i = 0; i < n; ++i){15 wait[i] = 0;16 done[i] = 0;17 }1819 time = 0; //time表⽰总作业执⾏时间20for(i = 0; i < n; i++){21if(i == 0){ //执⾏第⼀个作业22 time += durations[i];23 done[i] = 1;24for(j = 1; j < n; j++){25if(requestTimes[j] < time)26 wait[j] = time - requestTimes[j];27 }28 }29else{30 index = GetMin(durations,done,n);31//判断是否有多个最短作业,如有选择其中先到达的32 arriveTime = requestTimes[index];33for(indextemp = index + 1; indextemp < n; indextemp++){34if(done[indextemp] == 0 && durations[indextemp] == durations[index] &&35 requestTimes[indextemp] < arriveTime)36 index = indextemp;37 }3839 time += durations[index];40 done[index] = 1;41//执⾏选出的最短作业,并更新其它作业的等待时间42for(indextemp = 0; indextemp < n && i < n-1; indextemp++)43if(done[indextemp] == 0 &&requestTimes[indextemp] < time)44 wait[indextemp] = time - requestTimes[indextemp];45 }46 }4748 res = 0.0;49for(i = 0; i < n; i++)50 res += wait[i];5152 printf("%f\n",res / n);5354 }55//每次取出服务时间最短且⽰执⾏过的作业56int GetMin(int durations[],int done[],int n)57 {58int i,j,min = MAX;59for(i = 0; i < n; i++)60if(durations[i] < min && done[i] == 0){61 min = durations[i];62 j = i;63 }64return j;65 }6667int main()68 {69int requestTimes[100];70int durations[100];71int i,n;72 scanf("%d",&n);73for(i = 0; i < n; i++)74 scanf("%d",&requestTimes[i]);75for(i = 0; i < n; i++)76 scanf("%d",&durations[i]);7778 minWaitingTime(requestTimes,durations,n); 7980 system("pause");81return0;82 }。
【操作系统】先来先服务和短作业优先算法(C语⾔实现)【操作系统】先来先服务算法和短作业优先算法实现介绍:1.先来先服务 (FCFS: first come first service)如果早就绪的进程排在就绪队列的前⾯,迟就绪的进程排在就绪队列的后⾯,那么先来先服务(FCFS: first come first service)总是把当前处于就绪队列之⾸的那个进程调度到运⾏状态。
也就说,它只考虑进程进⼊就绪队列的先后,⽽不考虑它的下⼀个CPU周期的长短及其他因素。
FCFS算法简单易⾏,是⼀种⾮抢占式策略,但性能却不⼤好。
简单来说,先来先服务就是那个进程到达时间最早,那么CPU就先处理哪个进程。
2.短作业优先(SJF, Shortest Job First)对预计执⾏时间短的作业(进程)优先分派处理机。
通常后来的短作业不抢先正在执⾏的作业。
也就是说,不但要考虑进程的到达时间,还要考虑进程需要运⾏的时间。
当⼀个进程正在运⾏时,假如有其他的进程到达,那么这些到达的进程就需要按照其需要运⾏的时间长短排序,运⾏时间短的在前,运⾏时间长的在后。
3.例⼦:4.运⾏截图1.先来先服务2.短作业优先5.话不多说,直接上代码。
第⼀次写,有很多不⾜的地⽅。
希望⼤家看到可以帮忙纠正⼀下,谢谢⼤家。
#include <stdio.h>#include <stdlib.h>#define MAX 10typedef struct PCB {int id,arrive_time,service_time,start_time,finish_time; //进程id、到达时间、服务时间、开始时间、完成时间float zhouzhuan_time,daiquanzhouzhuan_time; //周转时间、带权周转时间。
只能说我的拼英。
emm,。
尴尬。
int status;}PCB;typedef enum {OK,ERROR}Status;typedef enum {FALSE,TRUE}Bool;typedef PCB datatype;typedef struct LinkQueue {int front;int rear;int length;datatype* base;}quene;int arrive[MAX]; // 记录每个作业的到达时间int service[MAX]; //记录每个作业的服务时间int num; //输⼊的进程个数quene init(){quene q_pcb;q_pcb.base = (datatype *)malloc(sizeof(datatype)*MAX);q_pcb.front = q_pcb.rear = 0;q_pcb.length = 0;return q_pcb;}Bool isFull(quene *q) {if ((q->rear + 1) % MAX == q->front) {return TRUE;}return FALSE;}Bool isEmpty(quene *q) {if (q->rear == q->front) {return TRUE;}return FALSE;}Status rudui(quene *q,datatype p){ //⼊队。
最短作业优先调度算法一、前言最短作业优先调度算法(Shortest Job First,简称SJF)是一种常见的进程调度算法,主要用于处理多个进程同时请求资源的情况。
SJF算法的核心思想是优先调度执行时间最短的进程,以提高系统的响应速度和效率。
二、SJF算法的原理SJF算法是一种非抢占式调度算法,即一旦一个进程被分配到CPU上运行,它将一直运行直到完成或者被阻塞。
该算法基于每个进程的执行时间来进行排序,并按照顺序依次执行。
三、SJF算法的实现1. 首先需要获取所有待调度进程的执行时间,并按照从小到大的顺序进行排序。
2. 将排序后的进程依次加入就绪队列中。
3. 从就绪队列中选择执行时间最短的进程,并将其分配给CPU进行运行。
4. 如果该进程在运行过程中发生阻塞,则将其移到阻塞队列中等待唤醒。
5. 当一个进程完成时,检查就绪队列中是否还有未完成的进程,如果有,则重复步骤3;否则结束调度。
四、SJF算法存在的问题1. SJF算法假设能够准确地知道每个进程的执行时间,但实际上这是很难做到的。
如果估算不准,可能会导致进程等待时间过长或者资源浪费。
2. SJF算法容易出现“饥饿”现象,即某些进程由于执行时间较长而一直无法被调度执行。
3. SJF算法可能会导致运行时间较短的进程优先级过高,而忽略了其他因素如优先级、进程类型等。
五、SJF算法的改进针对SJF算法存在的问题,可以采取以下措施进行改进:1. 引入抢占式调度机制,在某些情况下可以强制中断正在运行的进程,并将CPU分配给更紧急的任务。
2. 采用动态优先级调度策略,将每个进程的优先级根据其等待时间进行动态调整。
当一个进程等待时间越长时,其优先级越高。
3. 综合考虑多种因素来确定每个进程的优先级。
除了执行时间外,还应考虑其他因素如I/O操作、内存需求、用户优先级等。
六、总结SJF算法是一种简单有效的调度算法,在处理大量短作业请求时具有较好的性能表现。
但是,由于其存在的问题,需要根据实际情况进行合理的改进和调整,以提高系统的性能和稳定性。
短作业优先调度和时间片轮转调度算法Prepared on 22 November 2020电子科技大学实验报告学生姓名:胡钟文学号:指导教师:罗惠琼一、实验室名称:主楼A2-412二、实验项目名称:进程调度算法的设计三、实验原理:短作业(进程)优先调度算法:短作业调度算法是从后备队列中选择一个或者若干个估计运行时间最短的作业,将他们调入内存运行。
而短进程优先调度算法则是从就绪队列中选出一个估计运行时间最短的进程,将处理机分配给它,使它立即执行并一直执行到完成,或者发生某事件而被阻塞放弃处理机时再重新调度。
时间片轮转法:系统将所有的就绪进程按先来先服务的原则排成一个队列,每次调度时,把CPU分配给队首进程,并令其执行一个时间片。
当执行的时间片用完时,由一个计时器发出时钟中断请求,调度程序便据此信号来停止该进程的执行,并将它送往就绪队列的队尾;然后,再把处理机分配给就绪队列中的新的队首进程,同时也让它执行一个时间片。
这样就可以保证就绪队列中的所有进程在一个给定的时间内均能获得一时间片的处理机执行时间。
四、实验目的:通过对进程调度算法的设计,深入理解进程调度的原理五、实验内容:1.编写程序实现SJ(P)F算法2.编写程序实现RR算法六、实验器材(设备、元器件):装有VC++的PC机一台七、实验步骤:1.打开VC,设计编写程序的源代码2.编译运行程序的源代码3.分析检验程序的结果是否正确4.总结实验结果及结论短进程优先调度源代码:#include ""struct sjf{char name[10];float arrivetime;float servicetime;float starttime;float finishtime;float zztime;float dqzztime;};sjf a[100];void input(sjf *p,int N){ int i;printf("intput the process's name & arrivetime & servicetime:\nfor exmple: a 0 100\n"); for(i=0;i<=N-1;i++){printf("input the %dth process's information:\n",i+1);scanf("%s%f%f",&p[i].name,&p[i].arrivetime,&p[i].servicetime);}}void Print(sjf *p,float arrivetime,float servicetime,float starttime,float finishtime,float zztime,float dqzztime,int N){int k;printf("run order:");printf("%s",p[0].name);for(k=1;k<N;k++){printf("-->%s",p[k].name);}printf("\nthe process's information:\n");printf("\nname\tarrive\tservice\tstart\tfinish\tzz\tdqzz\n");for(k=0;k<=N-1;k++){ printf("%s\t%\t%\t%\t%\t%\t%\t\n",p[k].name,p[k].arrivetime,p[k].servicetime,p[k].starttime ,p[k].finishtime,p[k].zztime,p[k].dqzztime);}}rrivetime<p[j].arrivetime){sjf temp;temp=p[i];p[i]=p[j];p[j]=temp;}}tarttime=p[k].arrivetime;p[k].finishtime=p[k].arrivetime+p[k].servicetime;}else{p[k].starttime=p[k-1].finishtime;p[k].finishtime=p[k-1].finishtime+p[k].servicetime;}}for(k=0;k<=N-1;k++){p[k].zztime=p[k].finishtime-p[k].arrivetime;p[k].dqzztime=p[k].zztime/p[k].servicetime;}}void sjff(sjf *p,int N){floatarrivetime=0,servicetime=0,starttime=0,finishtime=0,zztime=0,dqzztime=0;inishtime=p[m].arr ivetime+p[m].servicetime;elsep[m].finishtime=p[m-1].finishtime+p[m].servicetime;int i=0;for(int n=m+1;n<=N-1;n++){if(p[n].arrivetime<=p[m].finishtime)ervicetime;int next=m+1;ervicetime<min){min=p[k+1].servicetime;next=k+1;}}sjf temp;temp=p[m+1];p[m+1]=p[next];p[next]=temp;}deal(p,arrivetime,servicetime,starttime,finishtime,zztime,dqzztime,N); Print(p,arrivetime,servicetime,starttime,finishtime,zztime,dqzztime,N); }void main(){ int N;printf("------短作业优先调度算法------\n");printf("input the process's number:\n");scanf("%d",&N);input(a,N);sjf *b=a;sjf *c=a;sjff(b,N);}时间片轮转法源代码:#include <>#define M 5 D=-1;}}int GetNum()D!=-1){j++;}}return j;}int GetReach(int time)eachTime<=time){a[i].ReachTime=100;return i;}}return -1;}int GetInsert()D==-1)return i;}return -1;}void Forward(int num)D=A[i+1].ID;A[i].TotalTime=A[i+1].TotalTime;}A[num-1].ID=-1;}void Process()D;K++;A[0].TotalTime--;=A[0].ID;=A[0].TotalTime;}void main(){int i;int time;int t=0;int reach;int insert;int num;printf("RR算法\n\n");INIT();for(i=0;i<M;i++){printf("请输入进程ID:");scanf("%d",&a[i].ID);printf("请输入到达时间:");scanf("%d",&a[i].ReachTime);printf("请输入服务时间:");scanf("%d",&a[i].TotalTime);}for(i=0;i<M;i++)otalTime;}for(i=0;i<50;i++)D=a[reach].ID;A[insert].TotalTime=a[reach].TotalTime;num=GetNum();if(num==1)continue;D=;A[num-1].TotalTime=;}}}elseD=-1;}}else if(num==0)continue;D=;A[num-1].TotalTime=;}}}}printf("\n");printf("调度顺序为:\n");Myprintf;for(i=0;i<50;i++){if(queue[i]!=-1)printf("|%2d ",queue[i]);}printf("|\n");Myprintf;printf("\n");}八、实验数据及结果分析:短作业优先调度算法的实验结果:时间片轮转调度算法结果:九、实验结论:本次实验成功的完成了短作业优先调度算法和轮转时间片调度算法的模拟,通过本次实验我们了解到短作业优先调度算法不利于长作业的处理,因为长作业将长期得不到处理,而轮转时间片调度算法则解决了这一问题。
中国地质大学(北京)操作系统原理实习报告实习题目:1、2、实习人员:学号姓名(组长)学号姓名一、题目分析在批处理系统中,短作业优先算法是一种比较好的算法,其主要的不足之处是长作业的运行得不到保证。
于是我们想到了一种办法解决这个问题,就是引用动态优先权、并使作业的优先级随着等待时间的增加而以速率a提高,长作业在等待一定的时间后,必然有机会分配到处理机,这样长作业也得到了运行。
设计并实现一个采用高响应比算法的进程调度演示程序,响应比R 定义如下:RWT/T1W/T 其中T 为该作业估计需要的执行时间,为作业在后备状态队列中的等待时W间。
每当要进行作业调度时,系统计算每个作业的响应比,选择其中R最大者投入执行。
这样,即使是长作业,随着它等待时间的增加,W/T 也就随着增加,也就有机会获得调度执行。
这种算法是介于FCFS 和SJF 之间的一种折中算法。
由于长作业也有机会投入运行,在同一时间内处理的作业数显然要少于SJF 法,从而采用HRRN 方式时其吞吐量将小于采用SJF 法时的吞吐量。
另外,由于每次调度前要计算响应比,系统开销也要相应增加。
二、数据结构结构体数组path[k]实现对进程响应比的计算Path[max] 实现对进程响应比的排序Path[ii] 实现程序的各阶段运行状况的输出三、算法流程图程序设计流程图高响应比函数执行过程流程图四、重难点分析计算每一个进程的动态优先权,需要在每执行一个进程之后计算一遍未执行进程的优先权,从中选出优先权最高的一个执行。
五、运行测试(截图)六、分工编码:实验报告:七、总结本次演算实验主要对最高响应比算法的理解和对进程调度的功能以及进程调度算法有了深入的理解。
在这次的课程设计中,计算每一个进程的动态优先权,需要在每执行一个进程之后计算一遍未执行进程的优先权,从中选出优先权最高的一个执行,因为疏忽导致了响应比的计算错误,从而加大了完成代码的时间量。
对于这次出现的这个问题,使我有了对程序设计的严谨性,课本基础知识的理解程度上有了更深刻的认识,也让我明白到了基础知识的重要性。
先来先服务FCFS和短作业优先SJF进程调度算法_实验报告材料一、实验目的本实验的目的是通过编写程序模拟先来先服务(FCFS)和短作业优先(SJF)进程调度算法,并对其效果进行评估,从而对两种算法有一个更直观的认识。
二、实验原理2. 短作业优先(Shortest-Job-First, SJF)进程调度算法:根据进程的执行时间进行调度,选择执行时间最短的进程先执行。
三、实验步骤1. 设计进程类Process,包含进程名称、到达时间、执行时间等属性,并重载比较运算符以便后续排序。
2. 设计FCFS调度算法函数fcfs_scheduling,实现进程按照先来先服务的规则进行调度。
3. 设计SJF调度算法函数sjf_scheduling,实现进程按照执行时间最短的规则进行调度。
4. 编写主函数,分别调用fcfs_scheduling和sjf_scheduling函数,并根据实际情况输出结果,比较两种算法的效果。
四、实验结果与分析1.输入样例:进程A:到达时间0,执行时间3进程B:到达时间1,执行时间4进程C:到达时间2,执行时间2进程D:到达时间4,执行时间12.输出结果:FCFS调度结果:A->B->C->D,平均等待时间为(0+3+7+9)/4=4.75SJF调度结果:A->C->B->D,平均等待时间为(0+1+3+6)/4=2.53.结果分析:从结果可以看出,短作业优先(SJF)进程调度算法能够更好地减少进程的等待时间,因为它根据进程的执行时间进行调度,优先执行执行时间较短的进程。
与之相比,先来先服务(FCFS)进程调度算法无法对不同进程的执行时间进行判断,可能导致执行时间较短的进程等待时间长。
五、实验总结通过本次实验,我对先来先服务(FCFS)和短作业优先(SJF)进程调度算法有了更深入的了解。
先来先服务(FCFS)算法简单直观,但无法保证最优解;短作业优先(SJF)算法可以减少进程的等待时间,但需要预知每个进程的执行时间。
操作系统实验_先来先服务的调度算法和短作业优先先来先服务(FCFS)调度算法是一种非抢占式调度算法,在这种算法中,进程按照到达系统的先后顺序执行,并且在一个进程执行完毕之前,不会有其他进程执行。
如果一个进程没有执行完成,后续进程需要等待。
FCFS调度算法的优点是实现简单,公平性好。
由于按照到达时间先后顺序执行进程,能够保证所有进程都能够得到执行的机会。
然而,FCFS调度算法容易出现“饥饿”现象,即如果一个进程占用了较长的CPU时间,其他进程可能需要等待较长时间。
短作业优先(SJF)调度算法是一种非抢占式调度算法,它选择下一个执行的进程是根据预计的执行时间最短的进程。
在SJF调度算法中,进程按照预计的执行时间进行排序,并按照顺序执行。
SJF调度算法的优点是能够最大程度地减少平均等待时间。
因为进程按照预计的执行时间最短的顺序执行,执行时间短的进程优先执行,可以最大限度地减少其他进程等待的时间。
然而,SJF调度算法需要预先知道所有进程的执行时间,并且如果一个进程执行时间长,其他进程需要等待的时间可能会很长。
FCFS调度算法和SJF调度算法都有各自的优点和局限性。
FCFS调度算法适用于进程执行时间相对均匀的情况,可以保证所有进程都能够得到执行的机会。
但是,如果一个进程执行时间很长,可能会导致其他进程等待的时间非常长,容易出现“饥饿”现象。
SJF调度算法适用于进程执行时间差异较大的情况,可以最大程度地减少平均等待时间。
但是,SJF调度算法需要预先知道所有进程的执行时间,而且在实际应用中,很难准确预测进程的执行时间。
在实验中,可以通过编写相应的模拟程序来实现FCFS调度算法和SJF调度算法。
可以设定一个进程队列,每个进程有自己的到达时间和执行时间。
按照FCFS算法,按照到达时间先后顺序执行进程;按照SJF算法,按照执行时间从小到大的顺序执行进程。
通过模拟进程的调度过程,可以观察到FCFS算法和SJF算法的效果差异。
操作系统实验_先来先服务的调度算法和短作业优先操作系统中的进程调度算法是实现多道程序设计的关键,作为操作系统中的调度器,它决定了进程在CPU上执行的顺序,直接影响到系统的性能和响应时间。
本文将重点介绍两种常用的进程调度算法:先来先服务调度算法(FCFS)和短作业优先调度算法(SJF)。
先来先服务调度算法是一种最简单、最基础的调度算法,其实现非常简单:按照进程到达CPU的先后顺序,将其依次调入CPU执行。
当一个进程进入就绪队列后,在CPU空闲的时候,就将其调入CPU执行,直到进程执行完成或者主动放弃CPU时间片。
这种调度算法的优势在于实现简单、公平性好;但其缺点也很明显,由于没有考虑进程的执行时间长短,如果一个长时间的进程先到达就绪队列,则会造成其他进程的等待时间过长,导致系统的响应时间较长。
与FCFS相对的是短作业优先调度算法(Shortest Job First, SJF)。
SJF调度算法会根据进程的相对执行时间长短来进行调度,即将执行时间最短的进程优先调度进入CPU执行。
SJF算法的关键在于如何估计进程的执行时间,通常有两种方法:预测和历史信息。
预测方法是根据进程的相关信息,如进程的大小、执行时间等进行预测;而历史信息方法是根据以往同类任务的执行时间的平均值或历史执行时间进行估算。
在实际操作中,通常采用后者进行调度。
SJF调度算法的优势在于可以最大程度地减少平均等待时间,提高系统的响应效率。
然而,该算法也存在一些问题,如如何准确估算进程的执行时间、对长时间任务不够友好等。
两种调度算法各自都有其优势和劣势,因此在实际操作中需要根据具体的情况选择适用的调度算法。
如果系统中存在大量长时间任务,可以考虑使用FCFS来保证公平性;而如果系统中的任务短且繁琐,可以优先考虑SJF算法来减少平均等待时间。
此外,还有一些改进版的调度算法,如最短剩余时间优先调度算法(Shortest Remaining Time First, SRTF)和多级反馈队列调度算法(Multi-Level Feedback Queue, MLFQ)等,它们在一定程度上兼顾了FCFS和SJF的优势,更适用于实际的操作系统。
非抢占短作业优先算法源代码(C语言)#include <stdio.h>#include <stdlib.h>#define MAX 5 //进程数/*短作业优先算法*/struct pro{int num; //进程名int arriveTime; //到达时间int burst; //运行时间;struct pro *next;};//函数声明struct pro* creatList();void insert(struct pro *head,struct pro *s);struct pro* searchByAT(struct pro *head,int AT);void run(struct pro *head);void del(struct pro* p);int getCount(struct pro *head,int time);struct pro* creatList() //创建链表,按照进程的到达时间排列{struct pro* head=(struct pro*)malloc(sizeof(struct pro));head->next=NULL;struct pro* s;int i;for(i=0;i<MAX;i++){s=(struct pro*)malloc(sizeof(struct pro));printf("请输入进程名:\n");scanf("%d",&(s->num));printf("请输入到达时间:\n");scanf("%d",&(s->arriveTime));printf("请输入运行时间:\n");scanf("%d",&(s->burst));s->next=NULL;insert(head,s);}return head;}void insert(struct pro *head,struct pro *s) //插入节点{struct pro *p=searchByAT(head,s->arriveTime);s->next=p->next;p->next=s;return;}struct pro* searchByAT(struct pro *head,int AT) //查找第一个到达时间大于等于AT的节点,返回其前一个指针{struct pro *p,*q;p=head;q=head->next;while(q!=NULL&&q->arriveTime<=AT){p=q;q=q->next;}return p;}void del(struct pro* p) //删除p的下一个节点{struct pro *tmp;tmp=p->next;p->next=tmp->next;free(tmp);return;}int getCount(struct pro *head,int time) //察看当前就绪队列中的进程数{int count=0;struct pro *p,*q;p=head;q=p->next;while(q!=NULL&&q->arriveTime<=time){count++;p=q;q=q->next;}return count;}struct pro* SJF(struct pro *head,int count) //在头节点后的count个节点中选择burst最小的,返回其前一个节点的指针{int min;struct pro *p,*q,*flag;p=head;q=p->next;min=q->burst;flag=p; //flag记录返回指针while(count>0){if(q->burst<min){min=q->burst;flag=p;}count--;p=q;q=q->next;}return flag;}void run(struct pro *head) //按短作业优先算法调度进程,并输出其运行情况{int time=0,count;struct pro *s,*t;while(head->next!=NULL){count=getCount(head,time);if(count==0) //如果当前就绪队列中没有进程,时间自增time++;else if(count==1) //如果就绪队列中只有1个进程,则必定是第一个节点{t=head;s=t->next;printf("进程名:%d\n",s->num);printf("到达时间:%d\n",s->arriveTime);printf("运行开始时间:%d\n",time);printf("响应时间:%d\n",time-s->arriveTime);time+=s->burst;printf("运行结束时间:%d\n",time);printf("周转时间:%d\n",time-s->arriveTime);printf("*********************************\n");del(t);}else //如果就绪队列中的进程数>=2,则在head后的count个节点中进行短作业优先调度{t=SJF(head,count);s=t->next;printf("进程名:%d\n",s->num);printf("到达时间:%d\n",s->arriveTime);printf("运行开始时间:%d\n",time);printf("响应时间:%d\n",time-s->arriveTime);time+=s->burst;printf("运行结束时间:%d\n",time);printf("周转时间:%d\n",time-s->arriveTime);printf("*********************************\n");del(t);}}}void main(){struct pro *head=creatList();printf("按短作业优先算法调度运行结果如下:\n");run(head);。
中国地质大学(北京)
操作系统原理
实习报告
实习题目:1、
2、
实习人员:学号姓名(组长)
学号姓名
一、题目分析
在批处理系统中,短作业优先算法是一种比较好的算法,其主要的不足之处是长作业的运行得不到保证。
于是我们想到了一种办法解决这个问题,就是引用动态优先权、并使作业的优先级随着等待时间的增加而以速率a提高,长作业在等待一定的时间后,必然有机会分配到处理机,这样长作业也得到了运行。
设计并实现一个采用高响应比算法的进程调度演示程序,响应比 R 定义如下:RWT/T1W/T 其中 T 为该作业估计需要的执行时间,为作业在后备状态队列中的等待时 W间。
每当要进行作业调度时,系统计算每个作业的响应比,选择其中 R最大者投入执行。
这样,即使是长作业,随着它等待时间的增加,W/T 也就随着增加,也就有机会获得调度执行。
这种算法是介于 FCFS 和 SJF 之间的一种折中算法。
由于长作业也有机会投入运行,在同一时间内处理的作业数显然要少于SJF 法,从而采用 HRRN 方式时其吞吐量将小于采用 SJF 法时的吞吐量。
另外,由于每次调度前要计算响应比,系统开销也要相应增加。
二、数据结构
结构体数组path[k]实现对进程响应比的计算
Path[max] 实现对进程响应比的排序
Path[ii] 实现程序的各阶段运行状况的输出
三、算法流程图
程序设计流程图
高响应比函数执行过程流程图
四、重难点分析
计算每一个进程的动态优先权,需要在每执行一个进程之后计算一遍未执行进程的优先权,从中选出优先权最高的一个执行。
五、运行测试(截图)
六、分工
编码:
实验报告:
七、总结
本次演算实验主要对最高响应比算法的理解和对进程调度的功能以及进程调度算法有了深入的理解。
在这次的课程设计中,计算每一个进程的动态优先权,需要在每执行一个进程之后计算一遍未执行进程的优先权,从中选出优先权最高的一个执行,因为疏忽
导致了响应比的计算错误,从而加大了完成代码的时间量。
对于这次出现的这个问题,使我有了对程序设计的严谨性,课本基础知识的理解程度上有了更深刻的认识,也让我明白到了基础知识的重要性。
完成此次课程实际之后,我对进程调度模拟设计的各种算法有了更进一步的理解,在编写程序中所遇到的问题让我有了对操作系统有了迫切要更深层次的掌握,并且感受到操作系统这门课程实在是很重要的一门课程。
通过本次实验对用高响应比算法的优先调度算法有了更深入的理解和掌握,进一步巩固和复习操作系统的基础知识,更进一步的了解了结构化模块化程序设计的方法,提高了调试程序的技巧。
八、附件:源代码
#include <iostream>
#include <cstring>
#include <algorithm>
#define MAXN 1500
using namespace std;
struct node
{
bool vis;//是否已执行
char name;//进程名称
int come;//到达时间
int ser;//服务时间
int st;//开始时间
int end;//结束时间
int zhouzhuan;//周转时间
double right, youxianji;//带全周转时间,动态优先权,
} path[MAXN];
int main()
{
int n;
int ans[MAXN];
cout << "请输入进程的数目: ";
cin >> n;
cout << "请依次输入每个进程的名字、到达时间、服务时间: " << endl;
for(int i = 0; i < n; ++i)
{
cin >> path[i].name >> path[i].come >> path[i].ser;
path[i].vis = false;
}
double sum = 0;
int inde = 0;
int now = 0;
for(int i = 0; i < n; ++i)
{
int j;
for(j = 0; j < n; ++j)
{
if(path[j].come > now && path[j].vis == false)
{
break;
}
}
double MAX = -9999;
int max;
for(int k = 0; k < j; ++k)
{
if(path[k].vis == false)
{
path[k].youxianji = (now - path[k].come + path[k].ser)/(1.0 * path[k].ser);
if(MAX < path[k].youxianji)
{
MAX = path[k].youxianji;
max = k;
}
}
}
path[max].st = now;
now += path[max].ser;
path[max].end = now;
path[max].zhouzhuan = (path[max].end - path[max].come);
path[max].right = (path[max].zhouzhuan*1.0/ path[max].ser);
ans[inde++] = max;
path[max].vis = true;
}
cout << "进程开始时间结束时间周转时间带权周转时间" << endl;
for(int i = 0; i < n; ++i)
{
sum += path[i].right;
cout << path[i].name << " " <<
path[i].st << " " << path[i].end << " " << path[i].zhouzhuan << " " << path[i].right<<endl;
}
cout << "平均带权时间: " << sum*1.0/n;
return 0;
}。