zoukankan html css js c++ java

实验三进程调度模拟程序

实验三 进程调度模拟程序

1. 目的和要求

1.1. 实验目的

用高级语言完成一个进程调度程序，以加深对进程的概念及进程调度算法的理解。

1.2. 实验要求

1.2.1例题：设计一个有 N个进程并发执行的进程调度模拟程序。

进程调度算法：采用最高优先级优先的调度算法（即把处理机分配给优先级最高的进程）和先来先服务（若优先级相同）算法。

(1). 每个进程有一个进程控制块（PCB）表示。进程控制块包含如下信息：进程名、优先级、到达时间、需要运行时间、已用CPU时间、进程状态等等。

(2). 进程的优先级及需要的运行时间可以事先人为地指定，进程的运行时间以时间片为单位进行计算。

(3). 每个进程的状态可以是就绪 r（ready）、运行R（Running）、或完成F（Finished）三种状态之一。

(4). 就绪进程获得 CPU后都只能运行一个时间片。用已占用CPU时间加1来表示。

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

(6). 每进行一次调度程序都打印一次运行进程、就绪队列中各个进程的 PCB，以便进行检查。　　

(7). 重复以上过程，直到所要进程都完成为止。

思考：作业调度与进程调度的不同？

1.2.2实验题A：编写并调试一个模拟的进程调度程序，采用“最高优先数优先”调度算法对N（N不小于5）个进程进行调度。

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

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

(2). 动态优先数是指进程的优先数在创建进程时可以给定一个初始值，并且可以按一定规则修改优先数。例如：在进程获得一次CPU后就将其优先数减少1，并且进程等待的时间超过某一时限（2个时间片时间）时增加其优先数等。

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

(4). （**）在进行模拟调度过程可以创建（增加）进程，其到达时间为进程输入的时间。

0．

1.2.3实验题B：编写并调试一个模拟的进程调度程序，采用“基于时间片轮转法”调度算法对N（N不小于5）个进程进行调度。 “轮转法”有简单轮转法、多级反馈队列调度算法。

(1). 简单轮转法的基本思想是：所有就绪进程按 FCFS排成一个队列，总是把处理机分配给队首的进程，各进程占用CPU的时间片长度相同。如果运行进程用完它的时间片后还未完成，就把它送回到就绪队列的末尾，把处理机重新分配给队首的进程。直至所有的进程运行完毕。（此调度算法是否有优先级？）

(2). 多级反馈队列调度算法的基本思想是：

将就绪队列分为N级（N＝3～5），每个就绪队列优先数不同并且分配给不同的时间片：队列级别越高，优先数越低，时间片越长；级别越小，优先数越高，时间片越短。

系统从第一级调度，当第一级为空时，系统转向第二级队列，.....当处于运行态的进程用完一个时间片，若未完成则放弃CPU，进入下一级队列。

当进程第一次就绪时，进入第一级队列。

(3). （**）考虑进程的阻塞状态B（Blocked）增加阻塞队列。进程的是否阻塞和阻塞的时间由产生的“随机数”确定（阻塞的频率和时间长度要较为合理）。注意进程只有处于运行状态才可能转换成阻塞状态，进程只有处于就绪状态才可以转换成运行状态。

2. 实验内容

根据指定的实验课题：A（1），A（2），B（1）和B（2）

完成设计、编码和调试工作，完成实验报告。

注：带**号的条目表示选做内容。

3. 实验环境

可以选用Turbo C作为开发环境。也可以选用Windows下的VB，CB等可视化环境，利用各种控件较为方便。自主选择实验环境。

4. 实验原理及核心算法参考程序段

动态优先数（优先数只减不加）：

  1 #include<sdio.h>
  2 #include<string.h>
  3 void shuru();
  4 void readfiles();
  5 void ran();
  6 void sort(int choose);//1为到达时间排序，2为服务时间排序，3为HRRF排序，4为优先级排序
  7 void FinishProcess();
  8 typedef struct Process
  9 {
 10     char name[10];
 11     char status;    //状态：开始s，等待d，就绪j
 12     int id;
 13     int arrtime;    //到达时间
 14     int reqtime;    //要求服务时间
 15     int startime;    //开始时间
 16     int finitime;    //完成时间
 17     int dotime;        //已经工作时间
 18 
 19     float TAtime,TAWtime;    //周转时间、带权周转时间
 20     float prio;        //优先级
 21     float HRRF;            //响应比
 22 
 23 }Process;
 24 
 25 
 26 Process Processes[100]; //最多100个作业
 27 int systime=0,bfsum,add,del;
 28 int intarr,infin,intjob,sumProcess;
 29 char T='A';              //T的默认值是A
 30 
 31 void RunProcess()
 32 {
 33     int i=1;
 34     sort(4);//按prio排序
 35     printf("
————开始运行————
");
 36     for(i=1;i<=sumProcess;i++)
 37     {
 38         printf("
	Process %s	%f
",Processes[i].name,Processes[i].prio);
 39     }
 40     Processes[1].dotime++;
 41     if(Processes[1].dotime==Processes[1].reqtime)
 42     {
 43         FinishProcess();
 44     }
 45     Processes[1].prio--;
 46 }
 47 
 48 void FinishProcess()
 49 {
 50     int i,j;
 51     Process temp;
 52     for(i=1;i<=sumProcess;i++)
 53     {
 54         j=i-1;
 55                     strcpy(temp.name,Processes[i].name);
 56                     temp.status=Processes[i].status;
 57                     temp.arrtime=Processes[i].arrtime;
 58                     temp.reqtime=Processes[i].reqtime;
 59                     temp.startime=Processes[i].startime;
 60                     temp.finitime=Processes[i].finitime;
 61                     temp.TAtime=Processes[i].TAtime;
 62                     temp.TAWtime=Processes[i].TAWtime;
 63                     temp.prio=Processes[i].prio;
 64                     temp.id=Processes[i].id;
 65                     temp.HRRF=Processes[i].HRRF;
 66                     temp.dotime=Processes[i].dotime;
 67 
 68                     strcpy(Processes[i].name,Processes[j].name);
 69                     Processes[i].status=Processes[j].status;
 70                     Processes[i].arrtime=Processes[j].arrtime;
 71                     Processes[i].reqtime=Processes[j].reqtime;
 72                     Processes[i].startime=Processes[j].startime;
 73                     Processes[i].finitime=Processes[j].finitime;
 74                     Processes[i].TAtime=Processes[j].TAtime;
 75                     Processes[i].TAWtime=Processes[j].TAWtime;
 76                     Processes[i].prio=Processes[j].prio;
 77                     Processes[i].id=Processes[j].id;
 78                     Processes[i].HRRF=Processes[j].HRRF;
 79                     Processes[i].dotime=Processes[j].dotime;
 80 
 81                     strcpy(Processes[j].name,temp.name);
 82                     Processes[j].status=temp.status;
 83                     Processes[j].arrtime=temp.arrtime;
 84                     Processes[j].reqtime=temp.reqtime;
 85                     Processes[j].startime=temp.startime;
 86                     Processes[j].finitime=temp.finitime;
 87                     Processes[j].TAtime=temp.TAtime;
 88                     Processes[j].TAWtime=temp.TAWtime;
 89                     Processes[j].prio=temp.prio;
 90                     Processes[j].id=temp.id;
 91                     Processes[j].HRRF=temp.HRRF;
 92                     Processes[j].dotime=temp.dotime;
 93     }
 94     sumProcess--;
 95 }
 96 
 97 
 98 
 99 void sort(int choose)  //排序
100 {
101     int i,j;
102     Process temp;
103     for(i=1;i<=sumProcess;i++)
104     {
105         for(j=i+1;j<=sumProcess;j++)
106         {
107             if(choose==1)
108             {
109                 if(Processes[i].arrtime>Processes[j].arrtime)
110                 {
111                     strcpy(temp.name,Processes[i].name);
112                     temp.status=Processes[i].status;
113                     temp.arrtime=Processes[i].arrtime;
114                     temp.reqtime=Processes[i].reqtime;
115                     temp.startime=Processes[i].startime;
116                     temp.finitime=Processes[i].finitime;
117                     temp.TAtime=Processes[i].TAtime;
118                     temp.TAWtime=Processes[i].TAWtime;
119                     temp.prio=Processes[i].prio;
120                     temp.id=Processes[i].id;
121                     temp.HRRF=Processes[i].HRRF;
122                     temp.dotime=Processes[i].dotime;
123 
124                     strcpy(Processes[i].name,Processes[j].name);
125                     Processes[i].status=Processes[j].status;
126                     Processes[i].arrtime=Processes[j].arrtime;
127                     Processes[i].reqtime=Processes[j].reqtime;
128                     Processes[i].startime=Processes[j].startime;
129                     Processes[i].finitime=Processes[j].finitime;
130                     Processes[i].TAtime=Processes[j].TAtime;
131                     Processes[i].TAWtime=Processes[j].TAWtime;
132                     Processes[i].prio=Processes[j].prio;
133                     Processes[i].id=Processes[j].id;
134                     Processes[i].HRRF=Processes[j].HRRF;
135                     Processes[i].dotime=Processes[j].dotime;
136 
137                     strcpy(Processes[j].name,temp.name);
138                     Processes[j].status=temp.status;
139                     Processes[j].arrtime=temp.arrtime;
140                     Processes[j].reqtime=temp.reqtime;
141                     Processes[j].startime=temp.startime;
142                     Processes[j].finitime=temp.finitime;
143                     Processes[j].TAtime=temp.TAtime;
144                     Processes[j].TAWtime=temp.TAWtime;
145                     Processes[j].prio=temp.prio;
146                     Processes[j].id=temp.id;
147                     Processes[j].HRRF=temp.HRRF;
148                     Processes[j].dotime=temp.dotime;
149                 }
150             }
151             else if(choose==2)
152             {
153                 if(Processes[i].reqtime>Processes[j].reqtime)
154                 {
155                     strcpy(temp.name,Processes[i].name);
156                     temp.status=Processes[i].status;
157                     temp.arrtime=Processes[i].arrtime;
158                     temp.reqtime=Processes[i].reqtime;
159                     temp.startime=Processes[i].startime;
160                     temp.finitime=Processes[i].finitime;
161                     temp.TAtime=Processes[i].TAtime;
162                     temp.TAWtime=Processes[i].TAWtime;
163                     temp.prio=Processes[i].prio;
164                     temp.id=Processes[i].id;
165                     temp.HRRF=Processes[i].HRRF;
166                     temp.dotime=Processes[i].dotime;
167 
168                     strcpy(Processes[i].name,Processes[j].name);
169                     Processes[i].status=Processes[j].status;
170                     Processes[i].arrtime=Processes[j].arrtime;
171                     Processes[i].reqtime=Processes[j].reqtime;
172                     Processes[i].startime=Processes[j].startime;
173                     Processes[i].finitime=Processes[j].finitime;
174                     Processes[i].TAtime=Processes[j].TAtime;
175                     Processes[i].TAWtime=Processes[j].TAWtime;
176                     Processes[i].prio=Processes[j].prio;
177                     Processes[i].id=Processes[j].id;
178                     Processes[i].HRRF=Processes[j].HRRF;
179                     Processes[i].dotime=Processes[j].dotime;
180 
181                     strcpy(Processes[j].name,temp.name);
182                     Processes[j].status=temp.status;
183                     Processes[j].arrtime=temp.arrtime;
184                     Processes[j].reqtime=temp.reqtime;
185                     Processes[j].startime=temp.startime;
186                     Processes[j].finitime=temp.finitime;
187                     Processes[j].TAtime=temp.TAtime;
188                     Processes[j].TAWtime=temp.TAWtime;
189                     Processes[j].prio=temp.prio;
190                     Processes[j].id=temp.id;
191                     Processes[j].HRRF=temp.HRRF;
192                     Processes[j].dotime=temp.dotime;
193                 }
194             }
195             else if(choose==3)
196             {
197                 if(Processes[i].HRRF<Processes[j].HRRF)
198                 {
199                     strcpy(temp.name,Processes[i].name);
200                     temp.status=Processes[i].status;
201                     temp.arrtime=Processes[i].arrtime;
202                     temp.reqtime=Processes[i].reqtime;
203                     temp.startime=Processes[i].startime;
204                     temp.finitime=Processes[i].finitime;
205                     temp.TAtime=Processes[i].TAtime;
206                     temp.TAWtime=Processes[i].TAWtime;
207                     temp.prio=Processes[i].prio;
208                     temp.id=Processes[i].id;
209                     temp.HRRF=Processes[i].HRRF;
210                     temp.dotime=Processes[i].dotime;
211 
212                     strcpy(Processes[i].name,Processes[j].name);
213                     Processes[i].status=Processes[j].status;
214                     Processes[i].arrtime=Processes[j].arrtime;
215                     Processes[i].reqtime=Processes[j].reqtime;
216                     Processes[i].startime=Processes[j].startime;
217                     Processes[i].finitime=Processes[j].finitime;
218                     Processes[i].TAtime=Processes[j].TAtime;
219                     Processes[i].TAWtime=Processes[j].TAWtime;
220                     Processes[i].prio=Processes[j].prio;
221                     Processes[i].id=Processes[j].id;
222                     Processes[i].HRRF=Processes[j].HRRF;
223                     Processes[i].dotime=Processes[j].dotime;
224 
225                     strcpy(Processes[j].name,temp.name);
226                     Processes[j].status=temp.status;
227                     Processes[j].arrtime=temp.arrtime;
228                     Processes[j].reqtime=temp.reqtime;
229                     Processes[j].startime=temp.startime;
230                     Processes[j].finitime=temp.finitime;
231                     Processes[j].TAtime=temp.TAtime;
232                     Processes[j].TAWtime=temp.TAWtime;
233                     Processes[j].prio=temp.prio;
234                     Processes[j].id=temp.id;
235                     Processes[j].HRRF=temp.HRRF;
236                     Processes[j].dotime=temp.dotime;
237                 }
238             }
239             else if(choose==4)
240             {
241                 if(Processes[i].prio<Processes[j].prio)
242                 {
243                     strcpy(temp.name,Processes[i].name);
244                     temp.status=Processes[i].status;
245                     temp.arrtime=Processes[i].arrtime;
246                     temp.reqtime=Processes[i].reqtime;
247                     temp.startime=Processes[i].startime;
248                     temp.finitime=Processes[i].finitime;
249                     temp.TAtime=Processes[i].TAtime;
250                     temp.TAWtime=Processes[i].TAWtime;
251                     temp.prio=Processes[i].prio;
252                     temp.id=Processes[i].id;
253                     temp.HRRF=Processes[i].HRRF;
254                     temp.dotime=Processes[i].dotime;
255 
256                     strcpy(Processes[i].name,Processes[j].name);
257                     Processes[i].status=Processes[j].status;
258                     Processes[i].arrtime=Processes[j].arrtime;
259                     Processes[i].reqtime=Processes[j].reqtime;
260                     Processes[i].startime=Processes[j].startime;
261                     Processes[i].finitime=Processes[j].finitime;
262                     Processes[i].TAtime=Processes[j].TAtime;
263                     Processes[i].TAWtime=Processes[j].TAWtime;
264                     Processes[i].prio=Processes[j].prio;
265                     Processes[i].id=Processes[j].id;
266                     Processes[i].HRRF=Processes[j].HRRF;
267                     Processes[i].dotime=Processes[j].dotime;
268 
269                     strcpy(Processes[j].name,temp.name);
270                     Processes[j].status=temp.status;
271                     Processes[j].arrtime=temp.arrtime;
272                     Processes[j].reqtime=temp.reqtime;
273                     Processes[j].startime=temp.startime;
274                     Processes[j].finitime=temp.finitime;
275                     Processes[j].TAtime=temp.TAtime;
276                     Processes[j].TAWtime=temp.TAWtime;
277                     Processes[j].prio=temp.prio;
278                     Processes[j].id=temp.id;
279                     Processes[j].HRRF=temp.HRRF;
280                     Processes[j].dotime=temp.dotime;
281                 }
282             }
283             else 
284                 printf("Error!
");
285         }
286     }
287 }
288 void ins()    //插入
289 {
290     int i;
291     while(T!='E'&&T!='e')
292     {
293             printf("'I'nsert or 'D'elete or 'E'xit?
");
294             getchar();
295             scanf("%c",&T);
296             if(T=='I'||T=='i')
297             {
298                 printf("你想插入多少个作业?
");
299                 scanf("%d",&add);
300                 bfsum=sumProcess;
301                 sumProcess=sumProcess+add;
302                 for(i=bfsum+1;i<=sumProcess;i++)
303                 {
304                     printf("
第%d个作业:
",i);
305                     getchar();
306                     printf("输入作业名:
");
307                     gets(Processes[i].name);
308                     printf("到达时间:
");
309                     scanf("%d",&Processes[i].arrtime);
310                     printf("要求服务时间:
");
311                     scanf("%d",&Processes[i].reqtime);
312                 }
313             }
314             else if(T=='D'||T=='d')
315             {
316                 printf("你想删除第几组?");
317                 scanf("%d",&del);
318                 for(i=del;i<=sumProcess-1;i++)
319                 {
320                     strcpy(Processes[i].name,Processes[i+1].name);
321                     Processes[i].arrtime=Processes[i+1].arrtime;
322                     Processes[i].reqtime=Processes[i+1].reqtime;
323                 }
324                 sumProcess--;
325             }
326     }
327 }
328 
329 
330 void printarr()    //打印
331 {
332     int i;
333     printf("		name	artime	rqtime
");
334     for(i=1;i<=sumProcess;i++)
335     {
336         printf("N  %d	",i);
337         printf("	%s",Processes[i].name);
338         printf("	%d",Processes[i].arrtime);
339         printf("	%d
",Processes[i].reqtime);
340     }
341     printf("						现在系统时间%d
",systime);
342     
343 }
344 void printz()
345 {
346     int i;
347     float sum1=0,sum2=0;    //计算平均周转时间、平均带权周转时间
348     printf("		name	artime	rqtime	stime	ftime	TAtime		TAWtime
");
349     for(i=1;i<=sumProcess;i++)
350     {
351         printf("N  %d	",i);
352         printf("	%s",Processes[i].name);
353         printf("	%d",Processes[i].arrtime);
354         printf("	%d",Processes[i].reqtime);
355         printf("	%d",Processes[i].startime);
356         printf("	%d",Processes[i].finitime);
357         printf("	%f",Processes[i].TAtime);
358         printf("	%f
",Processes[i].TAWtime);
359     }
360     for(i=1;i<=sumProcess;i++)
361     {
362         sum1=sum1+Processes[i].TAtime;
363     }
364     for(i=1;i<=sumProcess;i++)
365     {
366         sum2=sum2+Processes[i].TAWtime;
367     }
368     printf("
平均周转时间=%f
",sum1/sumProcess);
369     printf("
平均带权周转时间=%f
",sum2/sumProcess);
370     printf("						现在系统时间%d
",systime);
371 }
372 void sumofthey()
373 {
374     int i;
375     Processes[1].startime=Processes[1].arrtime;
376     Processes[1].finitime=Processes[1].arrtime+Processes[1].reqtime;
377     Processes[1].TAtime=(float)(Processes[1].finitime-Processes[1].arrtime);
378     Processes[1].TAWtime=(float)(Processes[1].TAtime/Processes[1].reqtime);
379     Processes[1].HRRF=(float)(Processes[1].TAtime/Processes[1].reqtime);
380     for(i=2;i<=sumProcess;i++)
381     {
382         Processes[i].startime=Processes[i-1].finitime;
383         Processes[i].finitime=Processes[i].startime+Processes[i].reqtime;
384         Processes[i].TAtime=(float)(Processes[i].finitime-Processes[i].arrtime);
385         Processes[i].TAWtime=(float)(Processes[i].TAtime/Processes[i].reqtime);
386         Processes[i].HRRF=(float)(Processes[i].TAtime/Processes[i].reqtime);
387     }
388 }
389 void startit()
390 {
391     int n;
392     printf("
");
393     printf("			**************************
");
394     printf("			**1.调用文本写入数据******
");
395     printf("			**2.调用伪随机数产生数据**
");
396     printf("			**3.调用自己输入模拟数据**
");
397     printf("			**************************
");
398     scanf("%d",&n);
399     switch(n)
400     {
401     case 1:
402         readfiles();
403         sumofthey();
404         break;
405     case 2:
406         ran();
407         sumofthey();
408         break;
409     case 3:
410         shuru();
411         sumofthey();
412         break;
413     default:
414         {
415         printf("输入有误，请重新输入");
416         break;
417         }
418     }
419 }
420 void ran()
421 {
422     int i;
423     srand((unsigned)time(0));  //参数seed是rand()的种子，用来初始化rand()的起始值。
424     sumProcess=rand()%3+5;
425     for(i=1;i<=sumProcess;i++)
426     {
427         itoa(i,Processes[i].name,2);
428      
429         Processes[i].arrtime=rand()%29+1;
430     
431         Processes[i].reqtime=rand()%7+1;
432 
433         Processes[i].prio=rand()%10+1;
434     }
435     printf("
 	id    	作业到达时间     	作业运行所需要时间     	优先级
");
436     for(i=1; i<=sumProcess; i++)
437     {
438         printf("
	%s	%12d	%15d	%25f",Processes[i].name,Processes[i].arrtime,Processes[i].reqtime,Processes[i].prio);
439     }
440    printf("
");
441 }
442 
443 void readfiles()
444 {
445     char szTest[1000] = {0};int i=0,n;
446     FILE *fp=fopen("D:\File1.txt","r");
447     //FILE *fout=fopen("D:\File2.txt","w");
448     if(fp == NULL)
449     {
450         printf("ERROR!
");
451         exit(0);
452     }
453     //fscanf(fp,"Processesum=%d
",%n);
454     while(!feof(fp))  
455     {
456         fscanf(fp,"%d%d%d",&Processes[i].id,&Processes[i].arrtime,&Processes[i].reqtime);  //fscanf()函数将数据读入
457         printf("
%3d%12d%15d
",Processes[i].id,Processes[i].arrtime,Processes[i].reqtime);  //输出到屏幕
458         itoa(Processes[i].id,Processes[i].name,10);
459         i++;
460         /*memset(szTest, 0, sizeof(szTest));
461         fscanf(fp,"@id=%d|",&i);
462         fgets(fp,"name=%s|",Processes[i].name);
463         fscanf(fp,"arrtime=%d|reqtime=%d
",&Processes[i].arrtime,&Processes[i].reqtime);
464         */
465     //fscanf(fp,"%d",)
466     }
467     sumProcess=i;
468     fclose(fp);
469 }
470 void shuru()
471 {
472     int i;
473     printf("作业个数:
");
474     scanf("%d",&sumProcess);
475     for(i=1;i<=sumProcess;i++)
476     {
477         printf("
第%d个作业:
",i);
478         getchar();
479         printf("输入作业名:
");
480         gets(Processes[i].name);
481         printf("到达时间:
");
482         scanf("%d",&Processes[i].arrtime);
483         printf("要求服务时间:
");
484         scanf("%d",&Processes[i].reqtime);
485     }
486     sumofthey();
487 }
488 void choosesort()
489 {
490     int n;
491     printf("			*****************************
");
492     printf("			*******1.FCFS算法调度********
");
493     printf("			*******2.SJF算法调度*********
");
494     printf("			*******3.HRRF算法调度********
");
495     printf("			*******4.调用系统清屏********
");
496     printf("			*******5.退出算法调度********
");
497     printf("			*****************************
");
498     scanf("%d",&n);
499     switch(n)
500     {
501     case 1:
502         printf("运行先来先服务算法FCFS
");
503         sort(1);
504         printf("
经按到达时间排序后，未达到队列是
");
505         printz();
506         break;
507     case 2:
508         printf("运行最短作业优先算法FJS
");
509         sort(2);
510         printf("
经按到达时间排序后，未达到队列是
");
511         printz();
512         break;
513     case 3:
514         printf("运行最高响应比优先算法HRRF
");
515         sort(3);
516         printf("
经按到达时间排序后，未达到队列是
");
517         printz();
518         break;
519     case 4:
520         system("cls");
521         break;
522     case 5:
523         exit(0);
524         break;
525     }
526 }
527 void main()
528 {
529     startit();
530 //    choosesort();
531     while(sumProcess!=0)
532     {
533         RunProcess();
534     }
535 
536 }

  1 #include<stdio.h>
  2 #include<string.h>
  3 void shuru();
  4 void readfiles();
  5 void ran();
  6 void sort(int choose);//1为到达时间排序，2为服务时间排序，3为HRRF排序，4为优先级排序
  7 void FinishProcess();
  8 typedef struct Process
  9 {
 10     char name[10];
 11     char status;    //状态：开始s，等待d，就绪j
 12     int id;
 13     int arrtime;    //到达时间
 14     int reqtime;    //要求服务时间
 15     int startime;    //开始时间
 16     int finitime;    //完成时间
 17     int dotime;        //已经工作时间
 18 
 19     float TAtime,TAWtime;    //周转时间、带权周转时间
 20     float prio;        //优先级
 21     float HRRF;            //响应比
 22 
 23 }Process;
 24 
 25 
 26 Process Processes[100]; //最多100个作业
 27 int systime=0,bfsum,add,del;
 28 int intarr,infin,intjob,sumProcess;
 29 char T='A';              //T的默认值是A
 30 
 31 void RunProcess()
 32 {
 33     int timeflag=0;
 34     int timepiece=2;
 35     int T;
 36     int k;
 37     char ch;
 38     int i=1;
 39 
 40     printf("
请输入时间片：");
 41     scanf("%d",&T);
 42 
 43     sort(1);//按FCFS排序
 44     printf("
————开始运行————
");
 45     while(sumProcess>=0)
 46     {
 47         if(timeflag==T)
 48         {
 49             timeflag=0;
 50             if(Processes[0].reqtime==0)
 51             {
 52             printf("————进程%s已完成————
",Processes[0].name);
 53             
 54 
 55             if(sumProcess!=0){
 56                 sort(1);
 57                 printf("当前正在运行进程是:%s————
",Processes[0].name);
 58             }
 59             if(sumProcess>=1)
 60                 for(k=1;k<sumProcess;k++)
 61                 printf("————进程%s正在等待————
",Processes[k].name);
 62             if(sumProcess==0){
 63                 Processes[0].reqtime--;
 64                 sumProcess--;
 65             }
 66             }
 67             else{
 68                 sort(1);
 69                 if(sumProcess!=0){
 70                 //sort();
 71                 printf("当前正在运行进程是:%s————
",Processes[0].name);
 72                 }
 73                 if(sumProcess>=1)
 74                 for(k=1;k<sumProcess;k++)
 75                 printf("————进程%s正在等待————
",Processes[k].name);
 76             }              
 77         }
 78         else{
 79             if(Processes[0].reqtime==0)
 80             {
 81             printf("————进程%s已完成————
",Processes[0].name);
 82             if(sumProcess!=0){
 83                 sort(1);
 84                 printf("————进程%s正在运行————
",Processes[0].name);
 85             }
 86             if(sumProcess>=1)
 87                 for(k=1;k<sumProcess;k++)
 88                 printf("————进程%s正在等待————
",Processes[k].name);
 89             }
 90             else{
 91                 Processes[0].reqtime--;
 92                 if(sumProcess!=0)
 93                 printf("————进程%s正在运行————
",Processes[0].name);
 94             
 95                 if(sumProcess>=1)
 96                 for(k=1;k<sumProcess;k++)
 97                 printf("————进程%s正在等待————
",Processes[k].name);
 98             }
 99         }
100         timeflag++;
101         printf("
 按任回车继续......"); 
102         ch=getchar(); 
103         ch=getchar();
104     }
105      printf("

 全部进程已经完成.
"); 
106 /*
107     for(i=1;i<=sumProcess;i++)
108     {
109         printf("
	Process %s	%f
",Processes[i].name,Processes[i].prio);
110     }
111     Processes[1].dotime++;
112     if(Processes[1].dotime==Processes[1].reqtime)
113     {
114         FinishProcess();
115     }
116     Processes[1].prio--;*/
117 }
118 
119 void FinishProcess()
120 {
121     int i,j;
122     Process temp;
123     for(i=1;i<=sumProcess;i++)
124     {
125         j=i-1;
126                     strcpy(temp.name,Processes[i].name);
127                     temp.status=Processes[i].status;
128                     temp.arrtime=Processes[i].arrtime;
129                     temp.reqtime=Processes[i].reqtime;
130                     temp.startime=Processes[i].startime;
131                     temp.finitime=Processes[i].finitime;
132                     temp.TAtime=Processes[i].TAtime;
133                     temp.TAWtime=Processes[i].TAWtime;
134                     temp.prio=Processes[i].prio;
135                     temp.id=Processes[i].id;
136                     temp.HRRF=Processes[i].HRRF;
137                     temp.dotime=Processes[i].dotime;
138 
139                     strcpy(Processes[i].name,Processes[j].name);
140                     Processes[i].status=Processes[j].status;
141                     Processes[i].arrtime=Processes[j].arrtime;
142                     Processes[i].reqtime=Processes[j].reqtime;
143                     Processes[i].startime=Processes[j].startime;
144                     Processes[i].finitime=Processes[j].finitime;
145                     Processes[i].TAtime=Processes[j].TAtime;
146                     Processes[i].TAWtime=Processes[j].TAWtime;
147                     Processes[i].prio=Processes[j].prio;
148                     Processes[i].id=Processes[j].id;
149                     Processes[i].HRRF=Processes[j].HRRF;
150                     Processes[i].dotime=Processes[j].dotime;
151 
152                     strcpy(Processes[j].name,temp.name);
153                     Processes[j].status=temp.status;
154                     Processes[j].arrtime=temp.arrtime;
155                     Processes[j].reqtime=temp.reqtime;
156                     Processes[j].startime=temp.startime;
157                     Processes[j].finitime=temp.finitime;
158                     Processes[j].TAtime=temp.TAtime;
159                     Processes[j].TAWtime=temp.TAWtime;
160                     Processes[j].prio=temp.prio;
161                     Processes[j].id=temp.id;
162                     Processes[j].HRRF=temp.HRRF;
163                     Processes[j].dotime=temp.dotime;
164     }
165     sumProcess--;
166 }
167 
168 
169 
170 void sort(int choose)  //排序
171 {
172     int i,j;
173     Process temp;
174     for(i=1;i<=sumProcess;i++)
175     {
176         for(j=i+1;j<=sumProcess;j++)
177         {
178             if(choose==1)
179             {
180                 if(Processes[i].arrtime>Processes[j].arrtime)
181                 {
182                     strcpy(temp.name,Processes[i].name);
183                     temp.status=Processes[i].status;
184                     temp.arrtime=Processes[i].arrtime;
185                     temp.reqtime=Processes[i].reqtime;
186                     temp.startime=Processes[i].startime;
187                     temp.finitime=Processes[i].finitime;
188                     temp.TAtime=Processes[i].TAtime;
189                     temp.TAWtime=Processes[i].TAWtime;
190                     temp.prio=Processes[i].prio;
191                     temp.id=Processes[i].id;
192                     temp.HRRF=Processes[i].HRRF;
193                     temp.dotime=Processes[i].dotime;
194 
195                     strcpy(Processes[i].name,Processes[j].name);
196                     Processes[i].status=Processes[j].status;
197                     Processes[i].arrtime=Processes[j].arrtime;
198                     Processes[i].reqtime=Processes[j].reqtime;
199                     Processes[i].startime=Processes[j].startime;
200                     Processes[i].finitime=Processes[j].finitime;
201                     Processes[i].TAtime=Processes[j].TAtime;
202                     Processes[i].TAWtime=Processes[j].TAWtime;
203                     Processes[i].prio=Processes[j].prio;
204                     Processes[i].id=Processes[j].id;
205                     Processes[i].HRRF=Processes[j].HRRF;
206                     Processes[i].dotime=Processes[j].dotime;
207 
208                     strcpy(Processes[j].name,temp.name);
209                     Processes[j].status=temp.status;
210                     Processes[j].arrtime=temp.arrtime;
211                     Processes[j].reqtime=temp.reqtime;
212                     Processes[j].startime=temp.startime;
213                     Processes[j].finitime=temp.finitime;
214                     Processes[j].TAtime=temp.TAtime;
215                     Processes[j].TAWtime=temp.TAWtime;
216                     Processes[j].prio=temp.prio;
217                     Processes[j].id=temp.id;
218                     Processes[j].HRRF=temp.HRRF;
219                     Processes[j].dotime=temp.dotime;
220                 }
221             }
222             else if(choose==2)
223             {
224                 if(Processes[i].reqtime>Processes[j].reqtime)
225                 {
226                     strcpy(temp.name,Processes[i].name);
227                     temp.status=Processes[i].status;
228                     temp.arrtime=Processes[i].arrtime;
229                     temp.reqtime=Processes[i].reqtime;
230                     temp.startime=Processes[i].startime;
231                     temp.finitime=Processes[i].finitime;
232                     temp.TAtime=Processes[i].TAtime;
233                     temp.TAWtime=Processes[i].TAWtime;
234                     temp.prio=Processes[i].prio;
235                     temp.id=Processes[i].id;
236                     temp.HRRF=Processes[i].HRRF;
237                     temp.dotime=Processes[i].dotime;
238 
239                     strcpy(Processes[i].name,Processes[j].name);
240                     Processes[i].status=Processes[j].status;
241                     Processes[i].arrtime=Processes[j].arrtime;
242                     Processes[i].reqtime=Processes[j].reqtime;
243                     Processes[i].startime=Processes[j].startime;
244                     Processes[i].finitime=Processes[j].finitime;
245                     Processes[i].TAtime=Processes[j].TAtime;
246                     Processes[i].TAWtime=Processes[j].TAWtime;
247                     Processes[i].prio=Processes[j].prio;
248                     Processes[i].id=Processes[j].id;
249                     Processes[i].HRRF=Processes[j].HRRF;
250                     Processes[i].dotime=Processes[j].dotime;
251 
252                     strcpy(Processes[j].name,temp.name);
253                     Processes[j].status=temp.status;
254                     Processes[j].arrtime=temp.arrtime;
255                     Processes[j].reqtime=temp.reqtime;
256                     Processes[j].startime=temp.startime;
257                     Processes[j].finitime=temp.finitime;
258                     Processes[j].TAtime=temp.TAtime;
259                     Processes[j].TAWtime=temp.TAWtime;
260                     Processes[j].prio=temp.prio;
261                     Processes[j].id=temp.id;
262                     Processes[j].HRRF=temp.HRRF;
263                     Processes[j].dotime=temp.dotime;
264                 }
265             }
266             else if(choose==3)
267             {
268                 if(Processes[i].HRRF<Processes[j].HRRF)
269                 {
270                     strcpy(temp.name,Processes[i].name);
271                     temp.status=Processes[i].status;
272                     temp.arrtime=Processes[i].arrtime;
273                     temp.reqtime=Processes[i].reqtime;
274                     temp.startime=Processes[i].startime;
275                     temp.finitime=Processes[i].finitime;
276                     temp.TAtime=Processes[i].TAtime;
277                     temp.TAWtime=Processes[i].TAWtime;
278                     temp.prio=Processes[i].prio;
279                     temp.id=Processes[i].id;
280                     temp.HRRF=Processes[i].HRRF;
281                     temp.dotime=Processes[i].dotime;
282 
283                     strcpy(Processes[i].name,Processes[j].name);
284                     Processes[i].status=Processes[j].status;
285                     Processes[i].arrtime=Processes[j].arrtime;
286                     Processes[i].reqtime=Processes[j].reqtime;
287                     Processes[i].startime=Processes[j].startime;
288                     Processes[i].finitime=Processes[j].finitime;
289                     Processes[i].TAtime=Processes[j].TAtime;
290                     Processes[i].TAWtime=Processes[j].TAWtime;
291                     Processes[i].prio=Processes[j].prio;
292                     Processes[i].id=Processes[j].id;
293                     Processes[i].HRRF=Processes[j].HRRF;
294                     Processes[i].dotime=Processes[j].dotime;
295 
296                     strcpy(Processes[j].name,temp.name);
297                     Processes[j].status=temp.status;
298                     Processes[j].arrtime=temp.arrtime;
299                     Processes[j].reqtime=temp.reqtime;
300                     Processes[j].startime=temp.startime;
301                     Processes[j].finitime=temp.finitime;
302                     Processes[j].TAtime=temp.TAtime;
303                     Processes[j].TAWtime=temp.TAWtime;
304                     Processes[j].prio=temp.prio;
305                     Processes[j].id=temp.id;
306                     Processes[j].HRRF=temp.HRRF;
307                     Processes[j].dotime=temp.dotime;
308                 }
309             }
310             else if(choose==4)
311             {
312                 if(Processes[i].prio<Processes[j].prio)
313                 {
314                     strcpy(temp.name,Processes[i].name);
315                     temp.status=Processes[i].status;
316                     temp.arrtime=Processes[i].arrtime;
317                     temp.reqtime=Processes[i].reqtime;
318                     temp.startime=Processes[i].startime;
319                     temp.finitime=Processes[i].finitime;
320                     temp.TAtime=Processes[i].TAtime;
321                     temp.TAWtime=Processes[i].TAWtime;
322                     temp.prio=Processes[i].prio;
323                     temp.id=Processes[i].id;
324                     temp.HRRF=Processes[i].HRRF;
325                     temp.dotime=Processes[i].dotime;
326 
327                     strcpy(Processes[i].name,Processes[j].name);
328                     Processes[i].status=Processes[j].status;
329                     Processes[i].arrtime=Processes[j].arrtime;
330                     Processes[i].reqtime=Processes[j].reqtime;
331                     Processes[i].startime=Processes[j].startime;
332                     Processes[i].finitime=Processes[j].finitime;
333                     Processes[i].TAtime=Processes[j].TAtime;
334                     Processes[i].TAWtime=Processes[j].TAWtime;
335                     Processes[i].prio=Processes[j].prio;
336                     Processes[i].id=Processes[j].id;
337                     Processes[i].HRRF=Processes[j].HRRF;
338                     Processes[i].dotime=Processes[j].dotime;
339 
340                     strcpy(Processes[j].name,temp.name);
341                     Processes[j].status=temp.status;
342                     Processes[j].arrtime=temp.arrtime;
343                     Processes[j].reqtime=temp.reqtime;
344                     Processes[j].startime=temp.startime;
345                     Processes[j].finitime=temp.finitime;
346                     Processes[j].TAtime=temp.TAtime;
347                     Processes[j].TAWtime=temp.TAWtime;
348                     Processes[j].prio=temp.prio;
349                     Processes[j].id=temp.id;
350                     Processes[j].HRRF=temp.HRRF;
351                     Processes[j].dotime=temp.dotime;
352                 }
353             }
354             else 
355                 printf("Error!
");
356         }
357     }
358 }
359 void ins()    //插入
360 {
361     int i;
362     while(T!='E'&&T!='e')
363     {
364             printf("'I'nsert or 'D'elete or 'E'xit?
");
365             getchar();
366             scanf("%c",&T);
367             if(T=='I'||T=='i')
368             {
369                 printf("你想插入多少个作业?
");
370                 scanf("%d",&add);
371                 bfsum=sumProcess;
372                 sumProcess=sumProcess+add;
373                 for(i=bfsum+1;i<=sumProcess;i++)
374                 {
375                     printf("
第%d个作业:
",i);
376                     getchar();
377                     printf("输入作业名:
");
378                     gets(Processes[i].name);
379                     printf("到达时间:
");
380                     scanf("%d",&Processes[i].arrtime);
381                     printf("要求服务时间:
");
382                     scanf("%d",&Processes[i].reqtime);
383                 }
384             }
385             else if(T=='D'||T=='d')
386             {
387                 printf("你想删除第几组?");
388                 scanf("%d",&del);
389                 for(i=del;i<=sumProcess-1;i++)
390                 {
391                     strcpy(Processes[i].name,Processes[i+1].name);
392                     Processes[i].arrtime=Processes[i+1].arrtime;
393                     Processes[i].reqtime=Processes[i+1].reqtime;
394                 }
395                 sumProcess--;
396             }
397     }
398 }
399 
400 
401 void printarr()    //打印
402 {
403     int i;
404     printf("		name	artime	rqtime
");
405     for(i=1;i<=sumProcess;i++)
406     {
407         printf("N  %d	",i);
408         printf("	%s",Processes[i].name);
409         printf("	%d",Processes[i].arrtime);
410         printf("	%d
",Processes[i].reqtime);
411     }
412     printf("						现在系统时间%d
",systime);
413     
414 }
415 void printz()
416 {
417     int i;
418     float sum1=0,sum2=0;    //计算平均周转时间、平均带权周转时间
419     printf("		name	artime	rqtime	stime	ftime	TAtime		TAWtime
");
420     for(i=1;i<=sumProcess;i++)
421     {
422         printf("N  %d	",i);
423         printf("	%s",Processes[i].name);
424         printf("	%d",Processes[i].arrtime);
425         printf("	%d",Processes[i].reqtime);
426         printf("	%d",Processes[i].startime);
427         printf("	%d",Processes[i].finitime);
428         printf("	%f",Processes[i].TAtime);
429         printf("	%f
",Processes[i].TAWtime);
430     }
431     for(i=1;i<=sumProcess;i++)
432     {
433         sum1=sum1+Processes[i].TAtime;
434     }
435     for(i=1;i<=sumProcess;i++)
436     {
437         sum2=sum2+Processes[i].TAWtime;
438     }
439     printf("
平均周转时间=%f
",sum1/sumProcess);
440     printf("
平均带权周转时间=%f
",sum2/sumProcess);
441     printf("						现在系统时间%d
",systime);
442 }
443 void sumofthey()
444 {
445     int i;
446     Processes[1].startime=Processes[1].arrtime;
447     Processes[1].finitime=Processes[1].arrtime+Processes[1].reqtime;
448     Processes[1].TAtime=(float)(Processes[1].finitime-Processes[1].arrtime);
449     Processes[1].TAWtime=(float)(Processes[1].TAtime/Processes[1].reqtime);
450     Processes[1].HRRF=(float)(Processes[1].TAtime/Processes[1].reqtime);
451     for(i=2;i<=sumProcess;i++)
452     {
453         Processes[i].startime=Processes[i-1].finitime;
454         Processes[i].finitime=Processes[i].startime+Processes[i].reqtime;
455         Processes[i].TAtime=(float)(Processes[i].finitime-Processes[i].arrtime);
456         Processes[i].TAWtime=(float)(Processes[i].TAtime/Processes[i].reqtime);
457         Processes[i].HRRF=(float)(Processes[i].TAtime/Processes[i].reqtime);
458     }
459 }
460 void startit()
461 {
462     int n;
463     printf("
");
464     printf("			**************************
");
465     printf("			**1.调用文本写入数据******
");
466     printf("			**2.调用伪随机数产生数据**
");
467     printf("			**3.调用自己输入模拟数据**
");
468     printf("			**************************
");
469     scanf("%d",&n);
470     switch(n)
471     {
472     case 1:
473         readfiles();
474         sumofthey();
475         break;
476     case 2:
477         ran();
478         sumofthey();
479         break;
480     case 3:
481         shuru();
482         sumofthey();
483         break;
484     default:
485         {
486         printf("输入有误，请重新输入");
487         break;
488         }
489     }
490 }
491 void ran()
492 {
493     int i;
494     srand((unsigned)time(0));  //参数seed是rand()的种子，用来初始化rand()的起始值。
495     sumProcess=rand()%3+5;
496     for(i=1;i<=sumProcess;i++)
497     {
498         itoa(i,Processes[i].name,2);
499      
500         Processes[i].arrtime=rand()%29+1;
501     
502         Processes[i].reqtime=rand()%7+1;
503 
504         Processes[i].prio=rand()%10+1;
505     }
506     printf("
 	id    	作业到达时间     	作业运行所需要时间     	优先级
");
507     for(i=1; i<=sumProcess; i++)
508     {
509         printf("
	%s	%12d	%15d	%25f",Processes[i].name,Processes[i].arrtime,Processes[i].reqtime,Processes[i].prio);
510     }
511    printf("
");
512 }
513 
514 void readfiles()
515 {
516     char szTest[1000] = {0};int i=0,n;
517     FILE *fp=fopen("D:\File1.txt","r");
518     //FILE *fout=fopen("D:\File2.txt","w");
519     if(fp == NULL)
520     {
521         printf("ERROR!
");
522         exit(0);
523     }
524     //fscanf(fp,"Processesum=%d
",%n);
525     while(!feof(fp))  
526     {
527         fscanf(fp,"%d%d%d",&Processes[i].id,&Processes[i].arrtime,&Processes[i].reqtime);  //fscanf()函数将数据读入
528         printf("
%3d%12d%15d
",Processes[i].id,Processes[i].arrtime,Processes[i].reqtime);  //输出到屏幕
529         itoa(Processes[i].id,Processes[i].name,10);
530         i++;
531         /*memset(szTest, 0, sizeof(szTest));
532         fscanf(fp,"@id=%d|",&i);
533         fgets(fp,"name=%s|",Processes[i].name);
534         fscanf(fp,"arrtime=%d|reqtime=%d
",&Processes[i].arrtime,&Processes[i].reqtime);
535         */
536     //fscanf(fp,"%d",)
537     }
538     sumProcess=i;
539     fclose(fp);
540 }
541 void shuru()
542 {
543     int i;
544     printf("作业个数:
");
545     scanf("%d",&sumProcess);
546     for(i=1;i<=sumProcess;i++)
547     {
548         printf("
第%d个作业:
",i);
549         getchar();
550         printf("输入作业名:
");
551         gets(Processes[i].name);
552         printf("到达时间:
");
553         scanf("%d",&Processes[i].arrtime);
554         printf("要求服务时间:
");
555         scanf("%d",&Processes[i].reqtime);
556     }
557     sumofthey();
558 }
559 void choosesort()
560 {
561     int n;
562     printf("			*****************************
");
563     printf("			*******1.FCFS算法调度********
");
564     printf("			*******2.SJF算法调度*********
");
565     printf("			*******3.HRRF算法调度********
");
566     printf("			*******4.调用系统清屏********
");
567     printf("			*******5.退出算法调度********
");
568     printf("			*****************************
");
569     scanf("%d",&n);
570     switch(n)
571     {
572     case 1:
573         printf("运行先来先服务算法FCFS
");
574         sort(1);
575         printf("
经按到达时间排序后，未达到队列是
");
576         printz();
577         break;
578     case 2:
579         printf("运行最短作业优先算法FJS
");
580         sort(2);
581         printf("
经按到达时间排序后，未达到队列是
");
582         printz();
583         break;
584     case 3:
585         printf("运行最高响应比优先算法HRRF
");
586         sort(3);
587         printf("
经按到达时间排序后，未达到队列是
");
588         printz();
589         break;
590     case 4:
591         system("cls");
592         break;
593     case 5:
594         exit(0);
595         break;
596     }
597 }
598 void main()
599 {
600     startit();
601 //    choosesort();
602     while(sumProcess!=0)
603     {
604         RunProcess();
605     }
606 
607 }

查看全文

相关阅读:
LeetCode_326. Power of Three
LeetCode_303. Range Sum Query
LeetCode_299. Bulls and Cows
LeetCode_292. Nim Game
LeetCode_290. Word Pattern
LeetCode_283. Move Zeroes
LeetCode_278. First Bad Version
LeetCode_268. Missing Number
LeetCode_263. Ugly Number
LeetCode_258. Add Digits

原文地址：https://www.cnblogs.com/mxdmxdmxd78/p/5446543.html

实验三 进程调度模拟程序

1. 目的和要求

2. 实验内容

3. 实验环境

4. 实验原理及核心算法参考程序段

实验三进程调度模拟程序