码迷,mamicode.com
首页 > 其他好文 > 详细

实验二 作业调度模拟程序

时间:2015-05-09 01:17:52      阅读:255      评论:0      收藏:0      [点我收藏+]

标签:

一,实验目的 

1,加深对作业调度算法的理解;

2,进行程序设计的训练。

 

二,实验内容和要求

用高级语言编写一个或多个作业调度的模拟程序。

单道批处理系统的作业调度程序。作业一投入运行,它就占有计算机的一切资源直到作业完成为止,因此调度作业时不必考虑它所需要的资源是否得到满足,它所运行的时间等因素。

作业调度算法:

1) 采用先来先服务(FCFS)调度算法,即按作业到达的先后次序进行调度。总是首先调度在系统中等待时间最长的作业。

2) 短作业优先 (SJF) 调度算法,优先调度要求运行时间最短的作业。

3)  响应比高者优先(HRRN)调度算法,为每个作业设置一个优先权(响应比),调度之前先计算各作业的优先权,优先数高者优先调度。RP (响应比)= 作业周转时间 / 作业运行时间=1+作业等待时间/作业运行时间

每个作业由一个作业控制块JCB表示,JCB可以包含以下信息:作业名、提交(到达)时间、所需的运行时间、所需的资源、作业状态、链指针等等。

作业的状态可以是等待W(Wait)、运行R(Run)和完成F(Finish)三种之一。每个作业的最初状态都是等待W。

 

三、主要程序及其解释

  1 #include<stdio.h>
  2 #include<string.h>
  3 #include<conio.h>
  4 #define N 100
  5 
  6 struct ajob
  7 {
  8     char name[10];
  9 
 10     float requesttime;
 11     float arrivetime;
 12     float starttime;
 13     float finishtime;
 14     float turnroundtime;
 15     float turnroundxs;
 16 
 17     float rp;
 18     char status;
 19 };
 20 
 21 typedef struct ajob JOB;
 22 
 23 int input(JOB job[],int n);
 24 void output(JOB job[],int n);
 25 void select(JOB job[],int n);
 26 void FCFS(JOB job[],int n);
 27 void SJF(JOB job[],int n);
 28 void HRRN(JOB job[],int n);
 29 
 30 int main(void)
 31 {
 32    JOB job [N];  
 33    int n;  
 34    
 35    n=input(job,n);
 36    output(job,n);
 37    
 38    select(job,n);
 39    output(job,n);
 40 
 41    getch();
 42    return 0;
 43 }
 44 
 45 int input(JOB job[],int n)
 46 {
 47     int i;
 48 
 49     printf("n:");
 50     scanf("%d",&n);
 51 
 52     for(i=0;i<n;i++)
 53     {
 54         printf("\nname:",i+1);
 55         scanf("%s",job[i].name);
 56 
 57         printf("\narrivetime:",i+1);
 58         scanf("%f",&job[i].arrivetime);
 59 
 60         printf("\nrequesttime:",i+1);
 61         scanf("%f",&job[i].requesttime);
 62 
 63         job[i].status=n;
 64         job[i].starttime=0;
 65         job[i].finishtime=0;
 66     }
 67     printf("\n");
 68     return n;
 69 }
 70 
 71 void output(JOB job[],int n)
 72 {
 73     int i;
 74     printf("\tname    arrivetime    requesttime    starttime    finishtime    turnroundtime    turnroundxs");
 75     for(i=0;i<n;i++)
 76     {
 77         printf("\nname%d",i+1);
 78         printf("\t %s",job[i].name);
 79         printf("\t %.2f",job[i].arrivetime);
 80         printf("\t %.2f",job[i].requesttime);
 81         printf("\t %.2f",job[i].starttime);
 82         printf("\t %.2f",job[i].finishtime);    
 83         printf("\t %.2f",job[i].turnroundtime);
 84         printf("\t %.2f",job[i].turnroundxs);    
 85     }
 86     printf("\n");
 87 }
 88 
 89 void select(JOB job[],int n)
 90 {
 91     int k;
 92 
 93     printf("\n select:\n 1:先来先服务FCFS 2:短作业优先SJF 3:最高响应比优先HRRN\n");
 94     scanf("%d",&k);
 95     
 96     switch(k)          
 97     {
 98     //选择"1"的时候调用的是FCFS算法 
 99     case 1:FCFS(job,n);
100         break;
101         
102     //选择"2"的时候调用的是SJF算法 
103     case 2:SJF(job,n);
104         break; 
105 
106     //选择"3"的时候调用的是HRN算法
107     case 3:HRRN(job,n);
108         break; 
109     default:printf("\n wrong!");
110     }
111 };
112    
113 void move(JOB *pa,JOB *pb)
114 {
115     strcpy(pa->name,pb->name);
116     pa->arrivetime=pb->arrivetime;
117     pa->requesttime=pb->requesttime;
118     pa->starttime=pb->starttime;
119     pa->finishtime=pb->finishtime;
120     pa->turnroundtime=pb->turnroundtime;
121     pa->turnroundxs=pb->turnroundxs;
122 }
123 
124 void arrivetimesort(JOB job[],int n)
125 {
126     int i,j;
127     JOB jobtemp;
128     for(j=1;j<n;j++)
129         for(i=0;i<n-j;i++)
130             if(job[i].arrivetime>job[i+1].arrivetime)
131             {
132                 move(&jobtemp,&job[i]);
133                 move(&job[i],&job[i+1]);
134                 move(&job[i+1],&jobtemp);
135             }
136 }
137 
138 void FCFS(JOB job[],int n)
139 {
140     int i;
141     int now=0;
142     arrivetimesort(job,n);
143     for(i=0;i<n;i++)
144     {
145         if(job[i].arrivetime<=now)
146             job[i].starttime=now;
147         else
148             job[i].starttime=job[i].arrivetime;
149         now=job[i].starttime+job[i].requesttime;
150         job[i].finishtime=now;
151         job[i].turnroundtime=job[i].finishtime-job[i].arrivetime;
152         job[i].turnroundxs=job[i].turnroundtime/job[i].requesttime;
153     };
154 };
155 
156 JOB *nextSJF(JOB job[],int n,int *now)
157 {
158     JOB *p;
159     int i;
160     for(i=0;i<n;i++)
161         if(job[i].status==n)
162         {
163             p=&job[i];
164             break;
165         }
166         if(job[i].arrivetime>*now)
167             *now=job[i].arrivetime;
168         for( ;i<n;i++)
169         {
170             if((job[i].arrivetime<=*now)&&(job[i].status==n)&&(job[i].requesttime<p->requesttime))
171                 p=&job[i];
172         }
173         return p;
174 };
175 
176 void SJF(JOB job[],int n)
177 {
178     JOB *jobrun[N];
179     int i,j;
180     int now=0;
181 
182     arrivetimesort(job,n);
183     for(i=0;i<n;i++)
184     {
185         jobrun[i]=nextSJF(job,n,&now);
186         jobrun[i]->starttime=now;
187         now+=jobrun[i]->requesttime;
188         jobrun[i]->finishtime=now;
189         jobrun[i]->turnroundtime=jobrun[i]->finishtime-jobrun[i]->arrivetime;
190         jobrun[i]->turnroundxs=jobrun[i]->turnroundtime/jobrun[i]->requesttime;
191         jobrun[i]->status=f;
192     }
193 };
194 
195 JOB *nextHRRN (JOB job[],int n,int *now)
196 {
197     JOB *p;
198     int i;
199     float rp;
200     for(i=0;i<n;i++)
201         if(job[i].status==n)
202         {
203             p=&job[i];
204             break;
205         }
206         if(job[i].arrivetime>*now)
207             *now=job[i].arrivetime;
208 
209         rp=1;
210         while(job[i].arrivetime<=*now){
211             job[i].rp=1+(*now-job[i].arrivetime)/job[i].requesttime;
212             i++;
213             if(job[i].rp>rp)
214             {
215                 rp=job[i].rp;
216                 p=&job[i];
217             }
218         }
219         return p;
220 };
221 
222 void HRRN(JOB job[],int n)
223 {
224     JOB *jobrun[N];
225     int i;
226     int now=0;
227     arrivetimesort(job,n);
228     for(i=0;i<n;i++)
229     {
230         jobrun[i]=nextHRRN(job,n,&now);
231         jobrun[i]->starttime=now;
232         now+=jobrun[i]->requesttime;
233         jobrun[i]->finishtime=now;
234         jobrun[i]->turnroundtime=jobrun[i]->finishtime-jobrun[i]->arrivetime;
235         jobrun[i]->turnroundxs=jobrun[i]->turnroundtime/jobrun[i]->requesttime;
236         jobrun[i]->status=f;
237     }
238 };

运行结果

技术分享

技术分享

技术分享

四,实验总结

纠结甚久,甚至不知道我需要做些什么,百度看书看代码,方法有很多不同的,但总有些代码自己不理解,不过百度里的代码倒是让我学会一种输入输出的方法,也不算无所得了。照着自己的理解,写出零零散散的代码,这里想用数组,那里用指针,很乱。

后来老师给我们讲解了一个代码,思路清晰了很多,按着老师的方法把自己写的零散的东西修改了过来,不过这个过程也找出了好一些问题,百度和询问学霸后终于成功运行。时间花的多,不过也值得。

这个代码给我印象最深的是运用了冒泡法排序,并不是因为它的难度,而是这是我们学过的知识,没有老师的提醒下,我却压根没想到,这是不懂的温故和运用,我认为这很值得自己反省。

实验二 作业调度模拟程序

标签:

原文地址:http://www.cnblogs.com/zhengyh/p/4467959.html

(0)
(0)
   
举报
评论 一句话评论(0
登录后才能评论!
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码!