【第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近似。

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