电子科大计算机操作系统实验报告级Word格式.docx

电子科大计算机操作系统实验报告级Word格式.docx

《电子科大计算机操作系统实验报告级Word格式.docx》由会员分享，可在线阅读，更多相关《电子科大计算机操作系统实验报告级Word格式.docx（24页珍藏版）》请在冰点文库上搜索。

2、将用户需求转换成调度内核函数（即调度进程和资源管理器）；

3、在终端或输出文件中显示结果：

如当前运行的进程、错误信息等。

（三）进程管理设计

1、进程状态与操作

2、进程控制块结构PCB

3、主要函数：

创建进程、撤销进程

（四）资源管理设计

1、主要数据结构RCB

2、请求资源

3、释放资源

（五）进程调度与时钟中断设计

关键：

使用基于优先级的抢占式调度策略，在同一优先级内使用时间片轮转算法。

参考课上ppt：

五、实验目的：

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

六、实验内容：

设计与实现一个简单的进程与资源管理器，要求具有如下功能：

通过编写测试脚本（testshell）来完成对进程与资源管理器的测试。

七、实验环境（设备、元器件）：

Windows7、VisualStudio2015

八、实验步骤：

（一）系统功能需求分析：

（二）总体框架设计：

1、具体原理和总体工作流程分析：

首先，通过testshell从测试文件中读入各种命令。

然后，对命令进行分析，将用户的需求转换成调度内核函数，也就是说，通过调度进程和资源管理器，实现创建进程、撤销进程、进程调度、对资源进行管理、申请和释放资源、检测错误和定时器中断等功能，从而模拟一个操作系统对进程进行调度和对资源进行管理的过程。

最后，在终端或者输出文件中，把一系列操作后的结果显示出来，包括当前运行的进程、错误信息等。

2、相关方法和算法：

（1）C语言中的结构struct，用来实现PCB、RCB等

（2）C语言中的指针、链表操作，用来实现将PCB和RCB加入队列尾部、从队列中删除、转移至阻塞队列等操作，以及进程的调度执行等。

本实验中我们采用的带头结点的链表来实现各种操作。

（3）基于优先级的调度算法、时间片轮转调度算法、抢占式调度算法的综合应用。

3、模块调用关系：

本实验中，我们组共编写了三个头文件（pcb.h、rcb.h、test_shell_data.h）和四个源文件（main.c、pcb.c、rcb.c、test_shell_data.c），因此可以分为主函数设计模块、进程管理设计模块、资源管理设计模块和testshell设计模块。

在主函数模块中，需要调用其他三个模块，如创建进程、展示父子子进程等操作，需要调用进程管理设计模块；

调度算法的执行、展示各种队列等，需要调用testshell设计模块；

在进程管理设计模块中，像销毁PCB等操作，需要执行对RCB的释放，则需调用testshell设计模块；

在资源管理设计模块中，提供一些最小的操作，不调用其他模块；

在testshell设计模块中，设计到对资源和进程的各种操作，需要调用资源管理设计模块和进程管理设计模块。

（三）进程管理设计模块详细设计（本部分我负责实现）

我们的计划是在在进程管理设计模块中，实现关于进程的各种最基础的结构和操作，具体包括：

实现PCB结构体、PCB链表、PCB子节点链表；

实现对PCB链表的初始化、对子节点链表的初始化、新建PCB、对PCB链表中进行删除、插入、移除（不free）、从等待和阻塞队列中获取PCB得知、打印当前PCB父节点、打印当前PCB父节点、打印当前PCB子节点链表、插入子队列的尾部、从子队列尾部删除。

（1）进程状态

共ready/running/blocked三种状态,通过结构struct实现，代码如下：

struct{

intrunning;

intblocked;

intready;

}PCB_STATUS;

//定义pcb状态的三种情况

（2）进程操作：

在本次实验中，将会读进程进行以下操作，结合这些操作的具体内容和所学知识，很容易考虑到通过链表来实现这些操作。

创建（create）：

（none）->

ready

撤销（destroy）：

running/ready/blocked->

（none）

请求资源（Request）:

running->

blocked（当资源没有时，进程阻塞）

释放资源（Release）:

blocked->

ready（因申请资源而阻塞的进程被唤醒）

时钟中断（Time_out）:

调度：

ready->

running/running->

ready

2、主要数据结构实现：

（1）进程控制块结构PCB

进程控制块PCB是进程存在的唯一标识，并且常驻内存，进程控制块中有许多信息，在本次实验中，根据我们的需求，所设计的进程控制块结构如下：

结合实验指导书，我们通过结构struct实现进程控制块结构PCB，包含以下信息：

PID（name）

Other_resources//:

resourcewhichisoccupied

Status:

Type&

List//type:

ready,block,running….,//List:

RL（Readylist）orBL（blocklist）

Creation_tree:

Parent/Children

Priority:

0,1,2（Init,User,System）

主要代码及注释如下：

structPCB{//pcb结构体

charname[64];

//Pname

unsignedintpid;

//Pid

structRCB_LIST*rcb_list;

//Otherresources

structPCB_LIST*parent_pcb;

//父进程

structCHILD_PCB_LIST*child_pcb;

//子进程

intstate;

//Type&

List

intpriority;

//0,1,2

};

（3）实现一个PCB的链表，方便后面的操作：

structPCB_LIST{//pcb链表

structPCBpcb;

structPCB_LIST*next_pcb;

（4）实现PCB的子节点链表：

structCHILD_PCB_LIST{//pcb子节点链表

structPCB_LIST*node;

structCHILD_PCB_LIST*next_node;

3、主要操作设计实现过程

（1）初始化PCB链表（添加了头结点）:

voidinit_pcb_list（structPCB_LIST**list）{

if（*list）{

return;

}

structPCB_LIST*p=（structPCB_LIST*）malloc（sizeof（structPCB_LIST））;

p->

next_pcb=NULL;

memset（p,NULL,sizeof（structPCB））;

*list=p;

}

（2）初始化子节点链表：

voidinit_child_pcb_list（structCHILD_PCB_LIST**list）{

structCHILD_PCB_LIST*p=（structCHILD_PCB_LIST*）malloc（sizeof（structCHILD_PCB_LIST））;

next_node=NULL;

memset（p,NULL,sizeof（structCHILD_PCB_LIST））;

（3）创建一个新的PCB:

structPCB_LIST*create_pcb（char*name,unsignedintpid,intstate,unsignedintpriority,structPCB_LIST*parent_pcb）{

strcpy（pcb.name,name,strlen（name））;

pcb.pid=pid;

pcb.rcb_list=NULL;

pcb.state=state;

pcb.priority=priority;

pcb.parent_pcb=parent_pcb;

pcb.child_pcb=NULL;

structPCB_LIST*pcb_node=（structPCB_LIST*）malloc（sizeof（structPCB_LIST））;

pcb_node->

pcb=pcb;

returnpcb_node;

（4）从PCB链表中进行删除:

voiddestory_from_pcb_list（structPCB_LIST*list,char*name）

{

structPCB_LIST*pr_temp,*temp;

pr_temp=temp=list;

intret=1;

while（temp）

{

if（!

strcmp（name,temp->

pcb.name）&

&

ret）

release_resource（temp）;

ret=0;

pcb.name））

pr_temp->

next_pcb=temp->

next_pcb;

free（temp）;

pr_temp=temp;

temp=temp->

（5）插入pcb链表：

voidinsert_into_pcb_list（structPCB_LIST**list,structPCB_LIST*node）

*list）

init_pcb_list（list）;

structPCB_LIST*pr_temp,*temp;

pr_temp=temp=*list;

next_pcb=node;

（5）从PCB链表中移除，并不释放该PCB占用的空间：

voiddelete_from_pcb_list（structPCB_LIST*list,char*name）

（6）从等待和阻塞队列中获取PCB的地址：

structPCB_LIST*get_pcb（char*name）

structPCB_LIST*temp;

for（inti=2;

i>

=0;

i--）{

temp=READY_LIST[i]->

while（temp）{

strcmp（temp->

pcb.name,name））

returntemp;

if（BLOCKED_LIST）

temp=BLOCKED_LIST->

returnNULL;

（7）打印当前PCB的父节点

voidshow_pcb_parent（structPCB_LIST*node）

printf（"

%sparentnodeis%s\n"

node->

pcb.name,node->

pcb.parent_pcb->

pcb.name）;

（8）打印当前PCB的子节点链表

voidshow_pcb_child（structPCB_LIST*node）

%schildis"

structCHILD_PCB_LIST*temp=node->

pcb.child_pcb;

if（temp）

next_node;

-->

|%s|"

temp->

node->

\n"

）;

（9）插入子队列的尾部

voidinsert_into_child_pcb_list（structCHILD_PCB_LIST**list,structPCB_LIST*node）

init_child_pcb_list（list）;

structCHILD_PCB_LIST*pr_temp,*temp;

node=node;

next_node=p;

（10）从子队列尾部进行删除

voiddelete_from_child_pcb_list（structCHILD_PCB_LIST*list,char*name）

structCHILD_PCB_LIST*pr_temp,*temp;

list）

pr_temp=list;

temp=pr_temp->

next_node=temp->

（四）其他模块设计（组内其他人设计）

1、Testshell设计

Testshell将调度我们设计的进程与资源管理器，从而完成测试，具有以下功能：

（1）从终端或者测试文件读取命令；

（2）将用户需求转换成调度内核函数（即调度进程和资源管理器）；

（3）在终端或输出文件中显示结果：

2、资源管理设计

与进程管理设计的思路和流程相似，首先是设计好各类数据结构，包括RCB结构体、RCB等待队列链表、系统RCB结构体、系统RCB链表、RCB链表。

之后是实现好各类与RCB有关的基础操作，包括初始化前面设计的各种链表、新建RCB，以及对链表进行插入、删除、移除等操作，还有显示RCB队列的操作。

3、实验进程调度与时钟中断设计

核心思想即时间片轮转调度算法、优先级调度算法、抢占式算法的综合应用，设计到对前面各模块的调用。

九、实验数据及结果分析：

将实验指导书中给出的测试命令放到测试文件test.txt中，程序从该文件读取命令，并将执行结果输出到屏幕，如下图所示：

上图结果与试验指导书中给出的预期输出结果是一致的，说明实验成功。

具体的结果分析：

为了更易于观察，我们可以注释掉读文件的操作，让程序从键盘输入读取命令，每步命令的解释及相关执行结果截图如下：

crx1//创建优先级为1的进程x，应显示“*thexisrunning”

crp1//创建优先级为1的进程p，应显示“*thexisrunning”

crq1//创建优先级为1的进程q，应显示“*thexisrunning”

crr1//创建优先级为1的进程r，应显示“*thexisrunning”

经过以上四条指令，就绪队列中优先级1的队列中应依次为x、p、q、r，可用资源数应该都是总的资源数，执行结果、就绪队列、资源队列情况见下图：

to//一个时间片结束，应去执行p，显示“*thepisrunning”

同时，x进程PCB将进入优先级为0的就绪队列，如下图：

req21//为当前进程x申请1个R2资源，显示不变

输出显示不变，但是可用资源数目会发生变化，如下图：

to//一个时间片结束，应去执行q，显示“*theqisrunning”

reqR33//为当前进程q申请3个R3资源，显示不变

过程中截图如下，可用资源数目进一步减小：

to//一个时间片结束，应去执行r，显示“*therisrunning”

reqR43//为当前进程x申请3个R4资源，显示不变

to//一个时间片结束，应去执行优先级为0的就绪队列中的第一个进程x，显示“*thexisrunning”

to指令后截图如下，包括此时就绪队列的情况，所有进程的PCB都在优先级为0的就绪队列中：

to//一个时间片结束，应去执行p，显示“*thepisrunning”，x移到优先级0就绪队列的结尾

新的优先级为0的就绪队列截图如下：

下面的两条指令分别为当前进程申请资源，申请不到足够的资源，相应进程则会进入阻塞队列。

reqR31//p申请1个R3，但R3已经全部给了q，因此p被阻塞，进入阻塞队列，当前转去执行原来在p后的q进程，显示“*theqisrunning”

显示及阻塞队列如下：

reqR42//q申请2个R4，但R4已经只剩下1个，因此q被阻塞，进入阻塞队列，当前转去执行原来在q后的r进程，显示“*therisrunning”

reqR22//r申请2个R2，但R2已经只剩下1个，因此r被阻塞，进入阻塞队列，当前转去执行原来在r后的x进程，显示“*thexisrunning”

以上两步过后，阻塞队列及就绪队列截图如下：

to//一个时间片结束，就绪队列中只有x，因此仍然执行x，显示“*thexisrunning”

deq//撤销q进程，将释放q进程占用的3个R3资源，前面因为申请不到R3资源而被阻塞的p进程将重新回到就绪队列，位于x的后面，显示不变

to//一个时间片结束，应去执行x，显示“*thexisrunning”

经过以上四条指令，就绪队列中优先级0的队列中应依次为x、p，阻塞队列中应该只有r，如下图：

至此，详细的每步分析完毕，实验成功。

十、实验结论：

本次实验过程中，我组成员分工明确，在熟练掌握课堂知识的基础上，使用c语言模拟了操作系统对进程和资源的管理，成功地实现了基于优先级和时间片轮转的抢占式调度算法，实验结果与预期相同，很好地完成了本次实验

十一、总结及心得体会：

（1）链表、指针的掌握和应用十分重要；

（2）将总的任务划分成各个模块，实现各个模块后再总体实现，可以提高效率；

（3）在程序中增加一些出错处理的提示信息，有利于提高调试过程的效率。

十二、对本实验过程及方法、手段的改进建议：

可以增加难度更大的功能，如模拟进程中断后，返回断点继续执行等。

报告评分：

指导教师签字：

2014666666666指导教师：

主楼A2-413实验时间：

2017年6月2日

内存地址转化实验

（一）逻辑地址到线性地址的转换

1、逻辑地址、段标识符、索引号、GDT、LDT、T1字段、段描述符、Base字段、线性地址等概念；

2、GDTR、LDTR等相关寄存器知识；

（以上两条在实验指导书中很详细，篇幅较长，不做粘贴了）

3、逻辑地址到线性地址的转换过程

从逻辑地址到线性地址的转换过程，如下图所示（以T1=1为例，此时从段选择符中分离出段描述符和T1字段，T1=1，表明段描述符存放在LDT中）；

（1）从GDTR中获得GDT的地址，从LDTR中获得LDT在GDT中的偏移量，查找GDT，从中获取LDT的起始地址；

（2）从DS中的高13位获取DS段在LDT中索引位置，查找LDT，获取DS段的段描述符，从而获取DS段的基地址；

（3）根据DS段的基地址＋段内偏移量，获取所需单元的线性地址。

、

（二）线性地址到物理地址的转换

1、物理地址的概念；

（不做粘贴了）

2、将线性地址转换成物理地址的步骤：

（1）、因为页目录表的地址放在CPU的cr3寄存器中，因