计算机操纵系统实验：历程调度实验

目次


前言
二、实验目标
三、实验要求
四、实验原理
五、实验过程
六、代码详解
总结

---

前言

计算机操纵系统是管理计算机硬件和软件资源的核心软件，它负责为用户提供一个友爱、高效、安全的使用环境。历程调度是操纵系统的一个重要功能，它决定了历程在处理惩罚器上的执行顺序和时间，从而影响了系统的性能和用户的体验。本实验旨在通过模仿差别的历程调度算法，比力它们的优缺点，加深对操纵系统原理和设计的理解和把握。

---

一、开辟语言及实验平台
C++/JAVA
Turbo C / Microsoft Visual Studio 6.0 / Microsoft Visual Studio .NET 2010
在本文中使用的是c语言（？），使用的平台是devc++
二、实验目标

（1）加深对历程的概念及历程调度算法的理解；
（2）在了解和把握历程调度算法的基础上，体例历程调度算法通用步伐，将调试结果显示在计算机屏幕上，并检测机算和笔算的一致性。
三、实验要求

（1）了解历程调度；
（2）理解使用历程调度算法进行调度的原理；
（3）使用某种编程语言进行算法模仿。
四、实验原理

• 例题：设计一个有N个历程的历程调度算法。
  

历程调度算法：采用最高优先数的调度算法（即把处理惩罚机分配给优先数最高的历程）。
每个历程有一个历程控制块（PCB）表示。历程控制块可以包含如下信息：历程名、优先数、到达时间、需要运行时间、已用CPU时间、历程状态等等。
历程的优先数及需要的运行时间可以事先人为的指定（也可以由随机数产生）。历程的到达时间为历程的输入的时间。历程的运行时间以时间片为单位进行计算。
每个历程的状态可以是停当W（Wait）、运行R（Run）、或完成F（Finish）三种状态之一。停当历程获得CPU后都只能运行一个时间片。用已占用CPU时间加1表示。
如果运行一个时间片后，历程的已占用CPU时间已达到所需要的运行时间，则撤销该历程，如果运行一个时间片后，历程的已占用CPU时间还未达到所需要的运行时间，也就是历程还需要继承运行，此时应该将历程的优先数减1（即降低一级），然后把它插入停当队列等待CPU。
每进行一次调度步伐都打印一次运行历程、停当队列、以及各个历程的PCB，以便进行检查。
重复以上过程，直到所要的历程都完成为止。
分析:
使用固定队列与静动态优先级结合，每个优先级为0~0xFF,而且以小的数字为高优先级，大的数字为低优先级，每次皆使用循环得到最高优先级的历程并执行，然后将其动态优先级设置为最低，并将其他历程动态优先级提高，以使得每个历程都有时机运行。历程的优先级与运行时间由随机数产生。

五、实验过程

代码如下：

1. #include <stdlib.h>
2. #include <stdio.h>
3. #include <time.h>
5. /*常量和状态定义*/
6. #define        PRO_NUM        0x05
7. #define        MAX_TIME    0xFF
8.    /*状态宏*/
9. #define        WAIT        0x01
10. #define        RUN            0x02
11. #define        FINISH        0x03
13. #define        ID_ERROR    0x10
15. #define        MIN_PRIOR    0xFF //255
16. #define        MAX_PRIOR    0x00 0
19. typedef unsigned int    Uint32;
21. /*进程PCB*/
22. struct PCB_Info
23. {
24.    Uint32    s_id;
25.    Uint32    s_static_prior;
26.    Uint32    s_dynamic_prior;
27.    Uint32    s_start_time;
28.    Uint32    s_need_time;
29.    Uint32    s_used_time;
30.    Uint32    s_state;
31. };
33. /*进程队列*/
34. PCB_Info    g_queue[5];
35. Uint32        g_time = 0;
36. /*模拟进程执行函数*/
37. void Simulator();
38. /*初始化5个进程函数*/
39. void Init_Process();
40. /*初始化进程队列函数*/
41. void Init_Queue();
42. /*创建进程函数*/
43. Uint32 Create_Process(Uint32 pri,Uint32 needtime);
44. /*系统运行函数*/
45. void Run_Process();
46. /*得到最高优先级进程 ID函数*/
47. Uint32 Get_PriProcess();
48. /*进程时间片执行函数*/
49. void    Work_Process(Uint32 id);
50. /*改变进程状态和优先级函数*/
51. void    Change_Process(Uint32 id);
52. /*打印进程状态函数*/
53. void    Print_State();
54. /*结束系统函数*/
55. void End_Process();
56. /*入口函数*/
57. int main( int argc, char *argv[ ])
58. {
59.    Simulator();
60.    return 0;
61. }
62. void Simulator()
63. {
64.    Init_Process();
65.    Run_Process();
66.    End_Process();
67. }
69. void Init_Process()
70. {
71.    int i;
72.    Uint32 id;
73.    srand( (unsigned)time( NULL ) );
74.    Init_Queue();
75.    for(i=0;i<PRO_NUM;++i)
76.    {
77.        /*在这里修改随机数的范围，建议优先级取值为0到4之间，进程工作总时间为1到10之间*/
78.        id=Create_Process(rand()%5, 1+rand()%10);
79.        if(id!=ID_ERROR)
80.        {
81.            printf("**********************************\n");
82.            printf("创建进程成功\n");
83.            printf("进程ID号为:%d\n",id);
84.            printf("进程的静态优先权为:%d\n",g_queue[id].s_static_prior);
85.            printf("进程的动态优先权为:%d\n",g_queue[id].s_dynamic_prior);
86.            printf("进程的到达时间为:%d\n",g_queue[id].s_start_time);
87.            printf("进程需要时间为:%d\n",g_queue[id].s_need_time);
88.            printf("进程已用CPU时间为:%d\n",g_queue[id].s_used_time);
89.            printf("进程的状态为:%d\n",g_queue[id].s_state);
90.            printf("\n");
91.        }
92.        else
93.        {
94.            printf("创建进程失败\n");
95.        }
96.    }
97. }
99. void Init_Queue()
100. {
101.    int i;
102.    for(i=0;i<PRO_NUM;++i)
103.    {
104.        g_queue[i].s_id=i;
105.        g_queue[i].s_dynamic_prior=MIN_PRIOR; //255
106.        g_queue[i].s_need_time=0;
107.        g_queue[i].s_start_time=0;
108.        g_queue[i].s_static_prior=MIN_PRIOR;
109.        g_queue[i].s_used_time=0;
110.        g_queue[i].s_state=FINISH;
111. //g_queue[i].s_state=Sart;//这里有一个错误，在这里Sart并没有被定义，根据上下文，这里应该是想将进程的状态设置为START或者WAIT，根据上面的宏定义，将这里改成WAIT
112.    }
113. }
115. Uint32 Create_Process(Uint32 pri,Uint32 needtime)
116. {
117.    int i=0;
118.    Uint32 id=ID_ERROR;
119.    for(i=0;i<PRO_NUM;++i)
120.    {
121.        if(g_queue[i].s_state ==FINISH)
122.        {
123.            id=g_queue[i].s_id;
124.            g_queue[i].s_dynamic_prior=MIN_PRIOR;
125.            g_queue[i].s_need_time=needtime;
126.            g_queue[i].s_start_time=g_time;
127.            g_queue[i].s_state=WAIT;
128.            g_queue[i].s_static_prior=pri;
129.            g_queue[i].s_used_time=0x0;
130.            break;
131.        }
132.    }
133.    return id;
134. }
136. void Run_Process()
137. {
138.    Uint32 id;   
139.    while((id=Get_PriProcess())!=ID_ERROR)
140.    {
141.        Work_Process(id);
142.        Change_Process(id);
143.    }
144. }
146. void    Print_State()
147. {
148.    int i;
149.    printf("时间 进程ID\t状态 已用时间 需要时间 开始时间 静优先级 动优先级\n");
150.    for(i=0;i<PRO_NUM;++i)
151.    {        
152.        printf("%d\t%d\t%d\t%d\t%d\t%d\t%d\t%d\n",g_time,g_queue[i].s_id,g_queue[i].s_state,g_queue[i].s_used_time,g_queue[i].s_need_time,
153.            g_queue[i].s_start_time,g_queue[i].s_static_prior,g_queue[i].s_dynamic_prior);
154.    }
155. }
157. Uint32 Get_PriProcess()
158. {
159.    Uint32 id=ID_ERROR;
160.    int  i, prev_id=ID_ERROR;
161.    Uint32 prior=MIN_PRIOR*2, temp_prior;
162.    for(i=0;i<PRO_NUM;++i)
163.    {
164.        if(g_queue[i].s_state!=FINISH)
165.        {
166.            temp_prior=g_queue[i].s_dynamic_prior+g_queue[i].s_static_prior;
167.            if(temp_prior<=prior)
168.            {
169.                id=i;
170.                prior=temp_prior;
171.            }
172.        }
173.    }
174.    return id;
175. }
177. void    Work_Process(Uint32 id)
178. {
179.    ++g_time;
180.    g_queue[id].s_state=RUN;
181.    ++g_queue[id].s_used_time;
182.    Print_State();
183. }
185. void    Change_Process(Uint32 id)
186. {
187.    int i;
188.    if(g_queue[id].s_need_time==g_queue[id].s_used_time)
189.    {
190.        g_queue[id].s_state=FINISH;
191.    }
192.    else
193.    {
194.        g_queue[id].s_dynamic_prior=MIN_PRIOR;
195.        g_queue[id].s_state=WAIT;
196.       
197.    }
198.    for(i=0;i<PRO_NUM;++i)
199.    {
200.        if((i!=id)&&(g_queue[i].s_state!=FINISH))
201.        {
202.            g_queue[i].s_dynamic_prior >0 ?--g_queue[i].s_dynamic_prior:g_queue[i].s_dynamic_prior=0;
203.        }
204.    }
205. }
208. void End_Process()
209. {
210.    printf("所有进程结束状态:\n");
211.    Print_State();
212.    printf("所有进程已经结束!\n");
213. }

复制代码

六、代码详解

这是一段C语言的历程调度步伐，现在来表明一下这段代码：
这段代码是一个简单的历程调度步伐，它使用优先级调度算法来模仿历程的执行。步伐中界说了一些常量和状态，包括历程数量、最大时间、等待状态、运行状态和完成状态。它还界说了一个PCB_Info布局体，用来表示历程的PCB（历程控制块），其中包含了历程的ID、静态优先级、动态优先级、开始时间、需要时间、已使用时间和状态。
代码中还界说了一个全局变量g_queue，用来表示历程队列，以及一个全局变量g_time，用来表示当前时间。此外，还界说了一些函数原型，包括模仿历程执行函数Simulator()，初始化5个历程函数Init_Process()，初始化历程队列函数Init_Queue()，创建历程函数Create_Process()，系统运行函数Run_Process()，得到最高优先级历程ID函数Get_PriProcess()，历程时间片执行函数Work_Process()，改变历程状态和优先级函数Change_Process()，打印历程状态函数Print_State()和竣事系统函数End_Process()。
在main()函数中调用了Simulator()函数来模仿整个系统的运行。Simulator()函数中依次调用了Init_Process()函数来初始化5个历程，Run_Process()函数来运行系统，并在末了调用End_Process()函数来竣事系统。
Init_Process()函数用来初始化5个历程。在这个函数中，起首调用了Init_Queue()函数来初始化历程队列，然后使用for循环来创建5个历程。在循环中，使用rand()函数来天生随机数，作为创建历程的优先级和需要时间的参数。然后调用Create_Process()函数来创建历程，并根据返回值判断是否创建成功。如果创建成功，则打印出历程的相干信息；否则，打印出创建失败的信息。
Init_Queue()函数用来初始化历程队列。在这个函数中，使用for循环来遍历历程队列中的每一个元素，并对其进行初始化。初始化包括设置历程的ID、动态优先级、需要时间、开始时间、静态优先级、已使用时间和状态。
Create_Process()函数用来创建历程。在这个函数中，起首遍历历程队列，寻找一个状态为FINISH的历程。如果找到了，则将其ID赋值给id变量，并对其进行初始化，包括设置动态优先级、需要时间、开始时间、状态、静态优先级和已使用时间。末了返回id变量的值。
Run_Process()函数用来运行系统。在这个函数中，起首调用Get_PriProcess()函数来获取最高优先级的历程ID。如果返回值不等于ID_ERROR，则调用Work_Process()函数来执行该历程，并调用Change_Process()函数来改变该历程的状态和优先级。然后继承循环，直到Get_PriProcess()函数返回ID_ERROR为止。
Get_PriProcess()函数用来获取最高优先级的历程ID。在这个函数中，起首界说了一个id变量并初始化为ID_ERROR，然后使用for循环来遍历历程队列中的每一个元素。对于每一个元素，如果它的状态不为FINISH，则计算它的优先级（静态优先级+动态优先级），并与当前最高优先级进行比力。如果它的优先级小于等于当前最高优先级，则更新id变量和当前最高优先级。末了返回id变量的值。
Work_Process()函数用来执行历程。在这个函数中，起首将全局变量g_time加1，然后将指定历程的状态设置为RUN，并将其已使用时间加1。末了调用Print_State()函数来打印历程状态。
Change_Process()函数用来改变历程状态和优先级。在这个函数中，起首判断指定历程是否已经完成（即已使用时间等于需要时间）。如果已经完成，则将其状态设置为FINISH；否则，将其动态优先级设置为MIN_PRIOR，并将其状态设置为WAIT。然后使用for循环来遍历历程队列中的其他元素，并对它们的动态优先级进行更新。
End_Process()函数用来竣事系统。在这个函数中，起首打印出所有历程竣事状态的信息，然后调用Print_State()函数来打印历程状态。末了打印出所有历程已经竣事的信息。
效果如下：

 以上。

---

总结

本实验通过编写一个C语言的历程调度步伐，来模仿优先级调度算法的过程和效果。步伐中界说了历程的PCB布局体，包含了历程的ID、静态优先级、动态优先级、开始时间、需要时间、已使用时间和状态等信息。步伐还界说了一些函数，用来初始化历程队列、创建历程、运行系统、获取最高优先级历程、执行历程、改变历程状态和优先级、打印历程状态和竣事系统等功能。步伐使用了随机数来天生历程的优先级和需要时间，并使用循环来遍历历程队列，找到最高优先级的历程并执行，然后降低其动态优先级，并提高其他历程的动态优先级，以保证每个历程都有时机运行。步伐在每次执行一个历程后，都会打印出当前的时间和所有历程的状态，以便观察和检查。步伐在所有历程都完成后，会打印出最终的结果，并竣事系统。
通过本实验，加深了对历程调度算法的理解和把握，熟悉了C语言的编程技巧和调试方法，提高了分析问题息争决问题的本领。

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。