【第6章】进程调度【一】

     之前的进程调度策略是时间片轮转的策略,每发生一次时钟中断,CPU控制权就切换到PCB表中的下一个进程中,每个进程平分CPU的资源。可我们知道,凡事都有个轻重缓急,吃大锅饭已被证明是行不通的。学过操作系统理论的同学都知道,现在的调度策略中一般都给每个进程分配一个优先级,优先级高的进程获得CPU的关照就越多。

     我们前面实现的Milli_Delay函数可以做到这一点,优先级高的进程延时少一点,优先级低的进程延时得多一点,为了更好的观察结果,我们新加入一个进程C,也来顺便回顾一下添加一个新的进程的过程。

     首先准备进程C的执行体Proc_C,在proc.c中添加:

Code:
  1. void Proc_C()   
  2. {   
  3.     while(1)   
  4.     {   
  5.         Disp_Color_Str("C",0xe);   
  6.         Disp_Int(Get_Ticks());   
  7.         Disp_Color_Str(".",0xe);   
  8.         Milli_Delay(1000);   
  9.     }   
  10. }  

     在proto.h中添加声明:

Code:
  1. void Proc_C();  

     接着是进程C的堆栈空间并修改进程个数的宏,在proc.h中添加:

Code:
  1. #define PROC_NUM                3
  2. #define PROC_C_STACK_SIZE       0x8000   
  3. #define PROC_STACK_SIZE_TOTAL       (PROC_A_STACK_SIZE + /   
  4.                                      PROC_B_STACK_SIZE + /   
  5.                                      PROC_C_STACK_SIZE)  

     在global.c中修改:

Code:
  1. TASK Task_Tables[PROC_NUM] = { {Proc_A,PROC_A_STACK_SIZE},   
  2.                                {Proc_B,PROC_B_STACK_SIZE},   
  3.                                {Proc_C,PROC_C_STACK_SIZE}   
  4.                              };  

     OK,编译链接运行,结果如图所示:

===========================================================

     接着我们就来为各进程分配优先级吧,进程A:进程B:进程C = 5 : 3 :1,数字越大优先级越高,那么就修改各进程的执行体:

Code:
  1. void Proc_A()   
  2. {   
  3.     while(1)   
  4.     {   
  5.         Disp_Color_Str("A",0xc);   
  6.         Milli_Delay(300);   
  7.     }   
  8. }   
  9.   
  10. void Proc_B()   
  11. {   
  12.     while(1)   
  13.     {   
  14.         Disp_Color_Str("B",0xd);   
  15.         Milli_Delay(900);   
  16.     }   
  17. }   
  18.   
  19. void Proc_C()   
  20. {   
  21.     while(1)   
  22.     {   
  23.         Disp_Color_Str("C",0xe);   
  24.         Milli_Delay(1500);   
  25.     }   
  26. }  

     运行,结果如图所示:

     由图我们可以看到,A的打印次数明显最多,B次之,C最少,我们需要统计一下ABC这3个字母分别被打印了多少次。用眼睛来数显然傻了些,我好歹也是初级程序员啊。BOCHS提供了一个SNAPSHOT的功能,可以把当前屏幕上的字符抓成文本形式,我们就把这个文本文件命名为snapshot.txt,OK,我们再写个程序来进行统计工作,自然用C来写咯:

Code:
  1. #include "stdio.h"   
  2. #include "stdlib.h"   
  3.   
  4. int main(int ac,char **av)   
  5. {   
  6.     int exit_status = EXIT_SUCCESS;   
  7.     FILE *input;   
  8.     char *file_name = "snapshot.txt";   
  9.     int c;   
  10.     int a_num = 0;   
  11.     int b_num = 0;   
  12.     int c_num = 0;   
  13.        
  14.     input = fopen(file_name,"r");   
  15.     if(input == NULL)   
  16.     {   
  17.         perror(file_name);   
  18.         exit_status = EXIT_FAILURE;   
  19.     }   
  20.        
  21.     while((c = fgetc(input)) != EOF)   
  22.     {   
  23.         switch(c)   
  24.         {   
  25.             case 'A':   
  26.                 a_num++;   
  27.                 break;   
  28.             case 'B':   
  29.                 b_num++;   
  30.                 break;   
  31.             case 'C':   
  32.                 c_num++;   
  33.                 break;   
  34.             default:   
  35.                 break;   
  36.         }   
  37.     }   
  38.        
  39.     if(fclose(input) != 0)   
  40.     {   
  41.         perror("fclose");   
  42.         exit(EXIT_FAILURE);   
  43.     }   
  44.        
  45.     printf("A number is %d/n",a_num);   
  46.     printf("B number is %d/n",b_num);   
  47.     printf("C number is %d/n",c_num);   
  48.        
  49.     return exit_status;   
  50. }  

     运行结果如下:

     A与B的个数比为1286:445 = 2.88:1,跟进程B与进程A的延迟时间比3:1近似;A与C的个数比为1286:269 =  4.78:1,跟进程C与进程A的延迟时间5:1近似。

     这样的输出在我们意料之中吧,这很好的模仿了进程的优先级。但这样做不是很好,明天再谈。

评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值