电子科技大学---操作系统课程实验（一）

 电子科技大学—操作系统课程实验（一）

系统化思维模式下计算机操作系统进程与资源管理设计

1.实验目的：

设计和实现进程与资源管理，并完成Test shell的编写，以建立系统的进程管理、调度、资源管理和分配的知识体系，从而加深对操作系统进程调度和资源管理功能的宏观理解和微观实现技术的掌握。

2.实验内容:

在实验室提供的软硬件环境中，设计并实现一个基本的进程与资源管理器。该管理器能够完成进程的控制，如进程创建与撤销、进程的状态转换；能够基于优先级调度算法完成进程的调度，模拟时钟中断，在同优先级进程中采用时间片轮转调度算法进行调度；能够完成资源的分配与释放，并完成进程之间的同步。该管理器同时也能完成从用户终端或者指定文件读取用户命令，通过Test shell模块完成对用户命令的解释，将用户命令转化为对进程与资源控制的具体操作，并将执行结果输出到终端或指定文件中。

3.实验环境：

设计平台和语言不限，平台可为Linux或Windows, 语言可为C，C++，Java等。

4.实验要求：

要求学生熟悉掌握计算机操作系统进程管理和资源管理的基本原理和关键技术，包含进程控制、进程调度、进程同步及资源管理，在此基础上设计和实现进程和资源管理器。具体步骤包括：了解功能需求、完成系统总统设计、相关的数据结构定义和具体函数设计。
同时要求设计与实现驱动程序（test shell）：驱动该管理器工作，即将命令语言（即用户要求）转换成对与内核函数（如create, request等）的调用。

5.实验过程：

5.1总体设计

系统总体架构如图1所示，最右边部分为进程与资源管理器，属于操作系统内核的功能。该管理器具有如下功能：完成进程创建、撤销和进程调度；完成多单元 (multi_unit)资源的管理；完成资源的申请和释放；完成错误检测和定时器中断功能。

图1 系统总体结构
图1中间绿色部分为驱动程序test shell, 设计与实现test shell，该test shell将调度所设计的进程与资源管理器来完成测试。Test shell的应具有的功能：
-从终端或者测试文件读取命令；
-将用户需求转换成调度内核函数（即调度进程和资源管理器）；
-在终端或输出文件中显示结果：如当前运行的进程、错误信息等。

图1最左端部分为：通过终端（如键盘输入）或者测试文件来给出相应的用户命令，以及模拟硬件引起的中断

5.2Test shell设计

---

Test_shell的功能如4.1所述，代码示例如图1中绿色部分。
Test shell要求完成的命令（Mandatory Commands）
-init
-cr (=1 or 2) // create process
-de // delete process
-req <# of units> // request resource
-rel <# of units> // release resource
-to // time out

可选实现的命令
-list all processes and their status
-list all resources and their status
-provide information about a given process

Test shell 输出示例：
＊ Process init is running //the running process create new process
＊ ….
shell> cr A 1 // this command is from terminal and indicates creating process A with priority 1.Test shell will invoke kernel function: create
＊ Process A is running //display
shell> cr B 2 // A create process B with priority 2
＊ Process B is running
shell> cr C 1 // B create process C with priority 1, C is at the end of ready list
＊ Process B is running //Because C’s priority is lower than B’s

5.3 进程管理设计

5.3.1 进程状态与操作
进程状态： ready/running/blocked
进程操作：
 创建(create)： (none) -> ready
 撤销(destroy)： running/ready/blocked -> (none)
 请求资源(Request): running -> blocked (当资源没有时，进程阻塞)
 释放资源(Release): blocked -> ready (因申请资源而阻塞的进程被唤醒)
 时钟中断(Time_out): running -> ready
 调度：ready -> running / running ->ready

5.3.2 进程控制块结构（PCB）
• PID（name）
• CPU state — not used
• Memory — not used
• Open_Files — not used
• Other_resources //: resource which is occupied
• Status: Type & List// type: ready, block, running…., //List: RL(Ready list) or BL(block list)
• Creation_tree: Parent/Children
• Priority: 0, 1, 2 (Init, User, System)

图2 PCB结构示意

就绪进程队列：Ready list (RL)

图3 Ready list 数据结构

3个级别的优先级，且优先级固定无变化
2 =“system”
1 = “user”
0 = “init”
每个PCB要么在RL中，要么在block list中 。当前正在运行的进程，根据优先级，可以将其放在RL中相应优先级队列的首部。

5.3.3 主要函数
 创建进程：
Create(initialization parameters)// initialization parameters可以为进程的ID和优先级，优先级：初始进程0、用户进程1和系统进程2。
{
create PCB data structure
initialize PCB using parameters //包括进程的ID，优先级、状态等
link PCB to creation tree /连接父亲节点和兄弟节点，当前进程为 父亲节点，父亲节点中的子节点为兄弟节点/
insert(RL, PCB)//插入就绪相应优先级队列的尾部
Scheduler()
}
Init进程在启动时创建，可以用来创建第一个系统进程或者用户进程。新创建的进程或者被唤醒的进程被插入到就绪队列（RL）的末尾。
示例：
图4中，虚线表示进程A为运行进程，在进程A运行过程中，创建用户进程B：cr B 1，数据结构间关系图4所示

图4 进程数据结构间关系
(为了简单起见，A和B分别指向RL的链接可以不要)
 撤销进程

Destroy (pid)
{
get pointer p to PCB using pid
Kill_Tree(p)
Scheduler() //调度其他进程执行
}
Kill_Tree(p)
{
for all child processes q Kill_Tree(q) //嵌套调用，撤销所有子孙进程
free resources //和release调用类似的功能
delete PCB and update all pointers
}
Process can be destroyed by any of its ancestors or by itself (exit)

###5.4资源管理设计
5.4.1 主要数据结构
资源的表示：设置固定的资源数量，4类资源，R1，R2，R3，R4，每类资源Ri有i个
资源控制块Resource control block (RCB) 如图5所示
RID: 资源的ID
Status: 空闲单元的数量
Waiting_List: list of blocked process
  ![这里写图片描述](http://img.blog.youkuaiyun.com/20170514181446756?watermark/2/text/aHR0cDovL2Jsb2cuY3Nkbi5uZXQvc3ByaW5nY29kZXI=/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70/gravity/SouthEast)
图5 资源数据结构RCB


5.4.2请求资源
所有的资源申请请求按照FIFO的顺序进行
情况一：当一类资源数量本身只有一个

Request(rid)
{
       r = Get_RCB(rid);
       if (r->Status == 'free') //只有一个资源时可以用free和allocated来表示资源状态
        {
              r->Status = 'allocated‘;
          insert(self->Other_Resources, r);//self 为当前请求资源的进程PCB，insert以后r为self进程占有的资源, 参PCB结构图
          } else {
                 self->Status.Type = 'blocked'; 
                 self->Status.List = r;//point to block list, self is blocked by r
                         remove(RL, self);// remove self from the ready list(self can be put at the head of RL when it is running).
     insert(r->Waiting_List, self);// 将进程self插入到资源r的等待队列尾部
   Scheduler(); 
}
｝况二：一类资源有多个的情况（multi_unit）
Request(rid, n) // n为请求资源数量
{
   r = Get_RCB(rid);
   if (u ≥ n) // u为r->Status.u, 即可用资源数量，参资源数据结构图
{
      u-n;
      insert(self->Other_Resources, r, n);//self 为当前请求资源的进程PCB，insert以后n 个r为self进程占有的资源, 参PCB结构图
   } 
else 
{
  if (n>k) exit;//k为资源r的总数，申请量超过总数时，将打印错误信息并退出
     self->Status.Type = 'blocked'; //只要u<n, 就不分配，进程阻塞
     self->Status.List = r;//point to block list 注意：此时block list 是n个 r
     remove(RL, self);// remove self from the ready list，因为运行进程位于绪队列首部，所以此时将它从就绪队列移除
     insert(r->Waiting_List, self);// 将进程self插入到资源r的等待队列尾部
     Scheduler(); 
}
｝

 情况二：一类资源有多个的情况（multi_unit）

Request(rid, n) // n为请求资源数量
{
   r = Get_RCB(rid);
   if (u ≥ n) // u为r->Status.u, 即可用资源数量，参资源数据结构图
{
      u-n;
      insert(self->Other_Resources, r, n);//self 为当前请求资源的进程PCB，insert以后n 个r为self进程占有的资源, 参PCB结构图
   } 
else 
{
  if (n>k) exit;//k为资源r的总数，申请量超过总数时，将打印错误信息并退出
     self->Status.Type = 'blocked'; //只要u<n, 就不分配，进程阻塞
     self->Status.List = r;//point to block list 注意：此时block list 是n个 r
     remove(RL, self);// remove self from the ready list，因为运行进程位于绪队列首部，所以此时将它从就绪队列移除
     insert(r->Waiting_List, self);// 将进程self插入到资源r的等待队列尾部
     Scheduler(); 
}
｝

5.4.3释放资源
 情况一：一类资源只有1个的情况

Release(rid) 
{
   r = Get_RCB(rid);
   remove(self->Other_Resources, r);//将r从进程self占用的资源中移走
   if (r->Waiting_List == NIL) //没有进程在等待资源r
{
     r->Status = 'free';
   } 
else 
{ 
     remove(r->Waiting_List, q);//q为waiting_list中第一个阻塞进程
     q->Status.Type = 'ready';
     q->Status.List = RL;//就绪队列
insert(q->Other_Resources, r);  
insert(RL, q); //q插入就绪队列中相应优先级队列的末尾
Scheduler(); 
}
}

 情况二：一类资源有多个的情况

Release(rid,n) //rid为资源ID，n为释放的资源数量
{
r = Get_RCB(rid);

/*remove r from self->other_resources, and u= u + n，将资源r从当前进程占用的资源列表里移除，并且资源r的可用数量从u变为u+n*/
remove(self->Other_Resources, r, n);

/*如果阻塞队列不为空, 且阻塞队列首部进程需求的资源数req小于等于可用资源数量u，则唤醒这个阻塞进程，放入就绪队列*/
while (r->Waiting_List != NIL && u>=req_num) 
{
     u=u- req_num; //可用资源数量减少
     remove(r->Waiting_List, q); // 从资源r的阻塞队列中移除
     q->Status.Type = 'ready';
     q->Status.List = RL;
     insert(q->Other_Resources, r); //插入r到q所占用的资源中
 insert(RL, q); // 插入q到就绪队列
｝
 Scheduler(); //基于优先级的抢占式调度策略，因此当有进程获得资源时，需要查看当前的优先级情况并进行调度

}

5.5 进程调度与时钟中断设计

调度策略
 基于3个优先级别的调度：2，1，0
 使用基于优先级的抢占式调度策略，在同一优先级内使用时间片轮转（RR）
 基于函数调用来模拟时间共享
 初始进程(Init process)具有双重作用：
虚设的进程：具有最低的优先级，永远不会被阻塞
进程树的根

Scheduler:
Called at the end of every kernel call

Scheduler() {
      find highest priority process p 
      if (self->priority < p->priority ||
          self->Status.Type != 'running' ||
     self == NIL) 
     preempt(p, self)//在条件(3)(4)(5)下抢占当前进程
}



Condition (3): called from create or release, 即新创建进程的优先级或
资源释放后唤醒进程的优先级高于当前进程优先级
Condition (4): called from request or time-out， 即请求资源使得当前运行进程阻塞或者时钟中断使得当前运行进程变成就绪
Condition (5): called from destroy，进程销毁
Preemption: //抢占，将P变为执行，输出当前运行进程的名称
• Change status of p to running (status of self already changed to ready/blocked)
• Context switch—output name of running process

 时钟中断（Time out）：模拟时间片到或者外部硬件中断

Time_out() 
{
    find running process q; //当前运行进程q
    remove(RL, q);// remove from head? yes
    q->Status.Type = 'ready';
    insert(RL, q);// insert into tail? yes
    Scheduler();
}

5.6 系统初始化设计

启动时初始化管理器：
具有3个优先级的就绪队列RL初始化；
Init进程；
4类资源，R1，R2，R3，R4，每类资源Ri有i个

5.7 测试示例

输入测试命令或将测试命令放在测试文件input.txt中，内容为：
cr x 1
cr p 1
cr q 1
cr r 1
to
req R2 1
to
req R3 3
to
req R4 3
to
to
req R3 1
req R4 2
req R2 2
to
de q
to
to

输出结果应为：init x x x x p p q q r r x p q r x x x p x

转载注明地址：http://blog.youkuaiyun.com/springcoder/article/details/72047344

下一篇 电子科技大学—操作系统课程实验（二）