编写单通路IO系统中的设备分配程序实验报告.docx
《编写单通路IO系统中的设备分配程序实验报告.docx》由会员分享，可在线阅读，更多相关《编写单通路IO系统中的设备分配程序实验报告.docx（36页珍藏版）》请在冰豆网上搜索。
编写单通路IO系统中的设备分配程序实验报告
合肥学院
计算机科学与技术系
实验报告
2009～2010学年第1学期
课程
操作系统原理
实验名称
编写单通路I/O系统中的
设备分配程序
学生姓名
冯阿雷毕秋平
高健宁阳
专业班级
07计本
（1）班
指导教师
屠菁
2000年12月
一、实验目的
熟练掌握单通路I/O系统中的设备分配方法。
二、实验内容
本实验要求实现模拟单通路I/O系统中的设备分配程序，有如下要求：
1、设计系统设备表SDT、设备控制表DCT、控制器表COCT、通道表CHCT和逻辑设备表LUT。
2、提供给用户各表目的初态。
3、回答信息：
能够分配时，给出设备号、控制器号、通道号，
否则，给出无法分配的回答，插入相应的等待队列。
三、实验步骤
1、任务分析
为单通路I/O系统设计系统设备表SDT、设备控制表DCT、控制器表COCT、通道表CHCT和逻辑设备表LUT五张表。
用户可以查看各表目的内容，另外，程序为用户进程分配设备，并且输出分配结果，如果能够分配，则给出设备号、控制器号、通道号，否则，给出无法分配的回答，插入相应的等待队列。
2、概要设计
为实现本次实验任务要求，首先，定义SDT、DCT、COCT、CHCT、LUT五张表，调用input（）函数初始化各表内容；其次，调用print（）函数，实现对上述四张表的输出显示；最后，调用add_process（）函数，为用户进程申请设备，如果分配成功，给出设备号、控制器号、通道号，否则，给出无法分配的原因，并将该进程插入相应的等待队列中。
本程序包含如下3个模块：
（1）主模块，由函数main（）组成。
（2）显示表目模块，由函数print（）组成。
（3）分配设备模块，由函数add_process（）、process_run（）等函数组成。
绘制流程图如下：
流程图
3、详细设计和编码
通过以上的分析和初步设计，已经对本程序作了初步了解。
下面将对本程序的各个模块作详细的讲解。
（1）主函数模块
对各个表就行初始化，设置好各个表的状态，以及对各个步骤进行函数调用来实现本实验的要求。
（2）显示表目模块
调用print（）函数，显示出SDT系统设备表、DCT设备控制表、COCT控制器控制表、CHCT通道表和LUT逻辑设备表五张表目，直接显示各表中的设备类型、设备名称和设备状态等信息。
（3）分配设备模块
在此模块中，首先调用add_process（）函数，要求用户输入所要申请的逻辑设备名称，然后根据逻辑设备名称查看LUT表中的该设备是否存在，若不存在，则直接退出分配，输出分配失败原因，若存在，则继续如下分析：
a.分配设备。
根据LUT表找到设备表，然后根据SDT表中指向DCT表该设备的指针，检索到DCT设备控制表中该物理设备，检查该设备的状态信息Busy。
若忙，则将要求I/O的进程插入到该设备的等待队列中等待；若不忙，则继续步骤（b）。
b.分配控制器。
根据设备控制表DCT中的控制器表指针，可找到与此设备相连的控制器表COCT，通过检查该表中的状态信息Busy。
若忙，则将要求I/O的进程插入到等待该控制器的队列中等待；若不忙，则把该控制器分配给进程，继续步骤（c）。
c.分配通道。
首先根据控制器表COCT中的通道表指针找到与此控制器相连的通道表CHCT，从中了解此通道的状态信息Busy。
若为忙，则把该进程插入等待通道的队列CHL中;若通道空闲，则表明本次I/O请求所需之I/O设备和相应的控制器、通道都能得到，于是便可启动I/O设备开始数据传送。
调用add_process（）函数来实现上述步骤。
分配完成后，将相应的设备、控制器和通道的状态信息Busy置1。
结束分配程序。
4、调试分析
本次程序设计的核心内容在于设备的分配过程，一次分配只有在设备、控制器和通道三者都分配成功时，这次分配才算成功。
该程序的核心逻辑关系是先分配设备再分配控制器最后分配通道。
当三者都空闲并安全时，才可分配，最终启动该I/O设备进行数据传送。
5、测试结果
运行程序后，运行结果如下图1。
图1
进行初始化，运行结果如下图2
图2
图3
各表的初始化状态如图3。
图3
进程分配设备结果如图3
四、实验总结
通过本次实验，充分的理解了单通道I/O设备分配程序，知道了设备表，控制器表，通道表以及其他表的数据结构，加深了对课本知识的理解，明白了设备分配的过程：
先分配设备，接下来分配控制器，然后再分配通道，若成功就可以启动该I/O设备进行数据传送了。
同时，通过和同学一起做这个实验，从中学习到了合作的经验，为以后的工作打下基础。
经过编写程序，复习了C语言程序。
五、附录
源程序：
#include
#include
#include
#include
#defineNAME_NUM10
typedefstruct_COCT_list
{
charname[NAME_NUM];
struct_COCT_list*next;
}COCT_list;
typedefstruct_CHCT
{
charname[NAME_NUM];//
intstate;//
COCT_list*COCT_head;
COCT_list*COCT_tail;
struct_CHCT*next;
}CHCT;
typedefstruct_DCT_list
{
charname[NAME_NUM];//等待控制器队列的设备名字
struct_DCT_list*next;
}DCT_list;
typedefstruct_COCT
{
charname[NAME_NUM];//
intstate;//
CHCT*CHCT;//
DCT_list*DCT_head;//等待控制器队列的队首指针
DCT_list*DCT_tail;//
struct_COCT*next;
}COCT;
//设备控制表
typedefstruct_Process
{
char*name[NAME_NUM];//进程名字
//intnum;//进程标志号
struct_Process*next;
}Process;
typedefstruct_DCT
{
charname[NAME_NUM];//设备名字
chartype[NAME_NUM];//设备类型
intadr;//设备地址
intstate;//设备状态
COCT*coct;//指向控制器表的指针
Process*process_head;//等待进程的队首指针
Process*process_tail;//等待进程的队尾指针
intrepeat;//重复次数
struct_DCT*next;
}DCT;
//系统设备表SDT
typedefstruct_SDT
{
charname[NAME_NUM];
chartype[NAME_NUM];//设备类型
DCT*DCT;//DCT指针
longadr;//驱动程序入口
}SDT;
typedefstruct_LUT
{
charname[NAME_NUM];
chardct_name[NAME_NUM];
intadr;
struct_LUT*next;
}LUT;
//默认状态下初始化书中p113的单通道I/O
DCT*main_DCT;
COCT*main_COCT;
CHCT*main_CHCT;
LUT*main_LUT;
voidinit_1（）;
voidinit（）
{
puts（"-----------------------------------------------"）;
puts（"进行初始化工作,请您输入相关内容"）;
//puts（"\n如:
与"设备1"有关的控制器名为"控制器1",通道名为"通道1",您应如下输入:
"）;
puts（"\n如:
与\"设备1\"有关的控制器名为\"控制器1\",通道名为\"通道1\",您应如下输入:
"）;
puts（"\n请输入设备号:
（此处输入:
设备1）"）;
puts（"请输入控制器号:
（此处输入:
控制器1）"）;
puts（"请输入通道号:
（此处输入:
通道1）"）;
puts（"这样完成一次输入"）;
puts（"\n注意:
当设备号为-1时,退出输入"）;
puts（"-----------------------------------------------"）;
init_1（）;
}
voidinit_1（）
{
DCT*dct;
COCT*coct;
CHCT*chct;
LUT*lut;
dct=（DCT*）malloc（sizeof（DCT））;
main_DCT=dct;
dct->next=NULL;
coct=（COCT*）malloc（sizeof（COCT））;
main_COCT=coct;
coct->next=NULL;
chct=（CHCT*）malloc（sizeof（CHCT））;
main_CHCT=chct;
chct->next=NULL;
lut=（LUT*）malloc（sizeof（LUT））;
main_LUT=lut;
lut->next=NULL;
}
voidinput（）
{
DCT*dct;
DCT*dct_1;
DCT*dct_2;
COCT*coct;
COCT*coct_1;
CHCT*chct;
CHCT*chct_1;
LUT*lut;
LUT*lut_1;
charname[NAME_NUM];
inta;
while
（1）
{
a=0;
puts（"\n++++++++++++++++++++++++++++++++++++++++++++++\n"）;
printf（"请输入设备号:
"）;
scanf（"%s",name）;
if（!
strcmp（name,"-1"））
break;
dct_2=main_DCT;
dct_1=main_DCT->next;
while（dct_1!
=NULL）
{
if（!
strcmp（dct_1->name,name））
{
printf（"\n该设备已存在,请重新输入:
"）;
scanf（"%s",name）;
dct_1=main_DCT->next;
dct_2=main_DCT;
continue;
}
//if（dct_1->next!
=NULL）
dct_1=dct_1->next;
dct_2=dct_2->next;
//if（dct_1->next==NULL）
//break;
}
if（dct_1==NULL）
dct_1=dct_2;
dct=（DCT*）malloc（sizeof（DCT））;
if（dct_1==NULL）
{
dct_1=main_DCT;
}
dct_1->next=dct;
dct->next=NULL;
strcpy（dct->name,name）;
dct->adr=（int）&dct;
dct->process_head=NULL;
dct->process_tail=NULL;
dct->repeat=5;
dct->state=0;
strcpy（dct->type,"输入设备"）;
printf（"\n请输入控制器号:
"）;
scanf（"%s",name）;
coct_1=main_COCT->next;
while（coct_1!
=NULL）
{
if（!
strcmp（coct_1->name,name））
{
dct->coct=coct_1;
coct=coct_1;
a=1;
break;
}
//if（coct_1->next!
=NULL）
coct_1=coct_1->next;
//if（coct_1->next==NULL）
//break;
}
if（coct_1==NULL）
{
coct=（COCT*）malloc（sizeof（COCT））;
dct->coct=coct;
strcpy（coct->name,name）;
coct->DCT_head=NULL;
coct->DCT_tail=NULL;
coct->next=NULL;
coct->state=0;
coct_1=main_COCT;
while（coct_1->next!
=NULL）
{
coct_1=coct_1->next;
}
coct_1->next=coct;
}
if（a==1）
{
puts（"控制器存在，不能指定通道。
输入任意键进行下一设备的设置！
"）;
getch（）;
continue;
}
printf（"\n请输入通道号:
"）;
scanf（"%s",name）;
chct_1=main_CHCT->next;
while（chct_1!
=NULL）
{
if（strcmp（chct_1->name,name））
{
coct->CHCT=chct_1;
chct=chct_1;
break;
}
//if（chct_1->next!
=NULL）
chct_1=chct_1->next;
//if（chct_1->next==NULL）
//break;
}
if（chct_1==NULL）
{
chct=（CHCT*）malloc（sizeof（CHCT））;
coct->CHCT=chct;
strcpy（chct->name,name）;
chct->COCT_tail=NULL;
chct->next=NULL;
chct->COCT_head=NULL;
chct->state=0;
chct_1=main_CHCT;
while（chct_1->next!
=NULL）
{
chct_1=chct_1->next;
}
chct_1->next=chct;
}
}
puts（"为各设备确定逻辑设备名!
\n"）;
dct=main_DCT->next;
while（dct!
=NULL）
{
printf（"请输入设备号为%s的逻辑设备名:
",dct->name）;
scanf（"%s",name）;
lut=main_LUT->next;
lut_1=main_LUT;
while（lut!
=NULL）
{
if（!
strcmp（lut->name,name））
{
printf（"\n该设备名已近存在，请重新输入！
\n"）;
printf（"请输入设备号为%s的逻辑设备名:
",dct->name）;
scanf（"%s",name）;
lut=main_LUT->next;
lut_1=main_LUT;
break;
}
lut=lut->next;
lut_1=lut_1->next;
}
lut=lut_1;
lut_1=（LUT*）malloc（sizeof（LUT））;
lut->next=lut_1;
strcpy（lut_1->name,name）;
strcpy（lut_1->dct_name,dct->name）;
lut_1->next=NULL;
dct=dct->next;
}
}
voidprint（）
{
DCT*dct;
CHCT*chct;
COCT*coct;
Process*process;
DCT_list*dct_list;
COCT_list*coct_list;
LUT*lut;
dct=main_DCT->next;
puts（"\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n"）;
puts（"---------------------------------------------------------------------------"）;
puts（"\nDCT表\n"）;
puts（"---------------------------------------------------------------------------"）;
puts（"|_设备标志符_||_设备类型_||_设备地址_||_控制表指针_||_重复次数_||_状态_|"）;
while（dct!
=NULL）
{
printf（"\n|%10s|%10s|%10d|%10s|%10d|%10d|",dct->name,dct->type,dct->adr,dct->coct->name,dct->repeat,dct->state）;
if（dct->process_tail==NULL）
printf（"\n\n设备%s等待队列为空\n",dct->name）;
if（dct->process_tail!
=NULL）
{
printf（"\n\n设备%s的进程等待队列的进程号为:
\n",dct->name）;
process=dct->process_head;
while（process!
=NULL）
{
//printf（"|_%10s_|_%10d_|",process->name,process->num）;
printf（"|_%10s_|",process->name）;
process=process->next;
}
}
dct=dct->next;
}
puts（"\n"）;
puts（"---------------------------------------------------------------------------"）;
puts（"\nCOCT表\n"）;
puts（"---------------------------------------------------------------------------"）;
puts（"|_控制器名称_||_控制器状态_||_对应通道名称_|"）;
coct=main_COCT->next;
while（coct!
=NULL）
{
printf（"\n|%10s|%10d|%10s|",coct->name,coct->state,coct->CHCT->name）;
if（coct->DCT_tail==NULL）
printf（"\n\n控制器%s等待队列为空！
\n",coct->name）;
if（coct->DCT_tail!
=NULL）
{
dct_list=coct->DCT_head;
printf（"\n\n控制器%s的等待队列的设备号是:
\n",coct->name）;
while（dct_list!
=NULL）
{
printf（"|_%10s_|",dct_list->name）;
dct_list=dct_list->next;
}
}
coct=coct->next;
}
puts（"\n"）;
puts（"---------------------------------------------------------------------------"）;
puts（"\nCHCT表\n"）;
puts（"---------------------------------------------------------------------------"）;
puts（"|_通道名称_||_通道状态_|"）;
chct=main_CHCT->next;
while（chct!
=NULL）
{
printf（"\n|%10s|%10d|\n",chct->name,chct->state）;
if（chct->COCT_tail==NULL）
printf（"\n\n通道%s的等待队列为空！
",chct->name）;
if（chct->COCT_tail!
=NULL）
{
coct_list=chct->COCT_head;
printf（"\n\n通道%s的等待队列是:
\n",chct->name）;
while（coct_list!
=NULL）
{
printf（"|_%10s_|",coct_list->name）;
coct_list=coct_list->next;
}
}
chct=chct->next;
}
puts（"\n"）;
puts（"---------------------------------------------------------------------------"）;
puts（"\nLUT表\n"）;
puts（"---------------------------------------------------------------------------"）;
lut=main_LUT->next;
printf（"|_逻辑设备名_||_物理设备名_|"）;
while（lut!
=NULL）
{
printf（"\n|_
升级会员 