操作系统实验 设备管理汇总

操作系统实验

名称实验六设备管理

姓名

专业

学号

日期 2015年12月01日指导老师

一、实验目的

1.理解设备管理的概念和任务。

2.掌握独占设备的分配、回收等主要算法的原理并编程实现。

二、实验内容与要求

1.在Windows系统中，编写程序实现对独占设备的分配和回收的模拟，该程序中包括：建立设备类表和设备表、分配设备和回收设备的函数。

三、实验原理

1.独占设备的分配、回收等主要算法的原理。

为了提高操作系统的可适应性和可扩展性，现代操作系统中都毫无例外地实现了设备独立性，又叫做设备无关性。设备独立性的含义是：应用程序独立于具体使用的物理设备。

为了实现独占设备的分配，系统设置数据表格的方式也不相同，在实验中只要设计合理即可。这里仅仅是一种方案，采用设备类表和设备表。

（1）数据结构

操作系统设置“设备分配表”，用来记录计算机系统所配置的独占设备类型、台数以及分配情况。设备分配表可由“设备类表”和“设备表”两部分组成，如下

设备类表设备表

控制器表通道表

设备队列队首指针。凡因请求本设备而未得到满足的进程，其PCB都应按照一定的策略排成一个队列，称该队列为设备请求队列或简称设备队列。其队首指针指向队首PCB。在有的系统中还设置了队尾指针。

设备状态。当设备自身正处于使用状态时，应将设备的忙/闲标志置“1”。若与该设备相连接的控制器或通道正忙，也不能启动该设备，此时则应将设备的等待标志置“1”。

与设备连接的控制器表指针。该指针指向该设备所连接的控制器的控制表。在设备到主机之间具有多条通路的情况下，一个设备将与多个控制器相连接。此时，在DCT中还应设置多个控制器表指针。

（2）设备分配

1)当进程申请某类设备时，系统先查“设备类表”。

2)如果该类设备的现存台数可以满足申请要求，则从该类设备的“设备表”始址开始依次查该类设备在设备表中的登记项，找出“未分配”的设备分配给进程。

3)分配后要修改设备类表中的现存台数，把分配给进程的设备标志改为“已分配”且填上占用设备的进程名。

4)然后，把设备的绝对号与相对号的对应关系通知用户，以便用户在分配到的设备上装上存储介质。

（3）设备回收

当进程执行结束撤离时应归还所占设备，系统根据进程名查设备表，找出进程占用设备的登记栏，把标志修改为“未分配”，清除进程名。同时把回收的设备台数加到设备类表中的现存台数中。

设备分配程序的改进

增加设备的独立性：为了获得设备的独立性，进程应使用逻辑设备名I/O。这样，系统首先从SDT中找出第一个该类设备的DCT。若该设备忙，又查找第二个该类设备的DCT，仅当所有该类设备都忙时，才把进程挂在该类设备的等待队列上，而只要有一个该类设备可用，系统便进一歩计算分配该设备的安全性。

四、程序流程图

设备独立性

五、实验程序

#include

using namespace std;

//数据结构

typedef struct node

{

char name[10];

char devname[10];

struct node *next;

}PCB;//进程

PCB * run;//执行队列

//

typedef struct Node

{

char identify[10];//标识

int state;//设备状态

PCB *blocking;//阻塞队列指针}CHCT;//通道控制表

CHCT * CH1, * CH2;//设置两个通道为ch1,ch2

//

typedef struct NOde

{

char identify[10];//标识

int state;//设备状态

CHCT * chct;//CHCT

PCB *blocking;//阻塞队列指针

struct NOde *next;

}COCT;//控制器控制表

COCT * cohead;

typedef struct NODe

{

char identify[10];//标识

char type;//设备类型

int state;//设备状态

int times;//重复执行次数

PCB *blocking;//阻塞队列指针

COCT * coct;//COCT

}DCT;//设备控制表

typedef struct NODE

{

char type;//类别

char identify[10];//标识

DCT * dct;//DCT设备控制表

//驱动入口地址

struct NODE *next;

}SDT;

//系统设备表

SDT * head;

SDT * checkdel;

void Init()

{

PCB * ch1block,* ch2block,* co1block,* co2block,* co3block,* d1block,* d2block,* d3block,* d4block;//进程控制块

COCT * CO1,* CO2,* CO3;

DCT *d1,*d2,*d3,*d4;

SDT *s1,*s2,*s3,*s4;

//=================================================

run=(PCB *)malloc(sizeof(PCB));

run->next=NULL;

CH1=(CHCT *)malloc(sizeof(CHCT));

CH2=(CHCT *)malloc(sizeof(CHCT));

strcpy(CH1->identify,"ch1");

strcpy(CH2->identify,"ch2");

CH1->state=0;

CH2->state=0;

ch1block=(PCB *)malloc(sizeof(PCB));

ch1block->next=NULL;

ch2block=(PCB *)malloc(sizeof(PCB));

ch2block->next=NULL;

CH1->blocking=ch1block;

CH2->blocking=ch2block;

cohead=(COCT *)malloc(sizeof(COCT));

cohead->next=NULL;

CO1=(COCT *)malloc(sizeof(COCT));

cohead->next=CO1;

CO1->next=NULL;

CO2=(COCT *)malloc(sizeof(COCT));

CO1->next=CO2;

CO2->next=NULL;

CO3=(COCT *)malloc(sizeof(COCT));

CO2->next=CO3;

CO3->next=NULL;

CO1->state=0;

CO2->state=0;

CO3->state=0;

co1block=(PCB *)malloc(sizeof(PCB));

co1block->next=NULL;

co2block=(PCB *)malloc(sizeof(PCB));

co2block->next=NULL;

co3block=(PCB *)malloc(sizeof(PCB));

co3block->next=NULL;

strcpy(CO1->identify,"co1");

strcpy(CO2->identify,"co2");

strcpy(CO3->identify,"co3");

CO1->chct=CH1;

CO2->chct=CH1;

CO3->chct=CH2;

CO1->blocking=co1block;

CO2->blocking=co2block;

CO3->blocking=co3block;

//===================================================== d1block=(PCB *)malloc(sizeof(PCB));

d2block=(PCB *)malloc(sizeof(PCB));

d3block=(PCB *)malloc(sizeof(PCB));

d4block=(PCB *)malloc(sizeof(PCB));

d1block->next=NULL;

d2block->next=NULL;

d3block->next=NULL;

d4block->next=NULL;

d1=(DCT *)malloc(sizeof(DCT));

strcpy(d1->identify,"P");//p表示打印机设备d2=(DCT *)malloc(sizeof(DCT));

strcpy(d2->identify,"T");//t表示显示器设备d3=(DCT *)malloc(sizeof(DCT));

strcpy(d3->identify,"K");//k表示键盘设备d4=(DCT *)malloc(sizeof(DCT));

strcpy(d4->identify,"M");//m表示鼠标设备d1->coct=CO1; //控制器

d2->coct=CO2;

d3->coct=CO3;

d4->coct=CO3;

d1->state=0;//状态

d2->state=0;

d3->state=0;

d4->state=0;

d1->type='o';//o表示输出设备output

d2->type='o';

d3->type='i';//i表示输入设备

d4->type='i';

d1->blocking=d1block;

d2->blocking=d2block;

d3->blocking=d3block;

d4->blocking=d4block;

//================================

head=(SDT *)malloc(sizeof(SDT));

head->next=NULL;

s1=(SDT *)malloc(sizeof(SDT));

s2=(SDT *)malloc(sizeof(SDT));

s3=(SDT *)malloc(sizeof(SDT));

s4=(SDT *)malloc(sizeof(SDT));

head->next=s1;

s1->next=s2;

s2->next=s3;

s3->next=s4;

s4->next=NULL;

s1->dct=d1;

s2->dct=d2;

s3->dct=d3;

s4->dct=d4;

strcpy(s1->identify,"P");

strcpy(s2->identify,"T");

strcpy(s3->identify,"K");

strcpy(s4->identify,"M");

s1->type='o';

s2->type='o';

s3->type='i';

s4->type='i';

//test

SDT *temp=head->next;

}

//============================================ //添加设备时候，添加新控制器，把控制器加到最后void Addcotrol (COCT *temp)//添加控制器函数{

COCT *cotemp=cohead;

while(cotemp->next!=NULL)

{

cotemp=cotemp->next;

}

cotemp->next=temp;

temp->next=NULL;

}

//查看所有控制器，选择所要连接的控制器

void Showallco()

{

COCT *temp=cohead->next;

while(temp!=NULL)

{

cout<identify<<" ";

temp=temp->next;

}

cout<

}

//查找要连接的控制器

COCT * Findco(char a[])

{

COCT * temp=cohead->next;

while(temp!=NULL)

{

if(!strcmp(temp->identify,a))

{

return temp;

}

temp=temp->next;

}

return temp;

}

//删除设备时候，判断是不是同时删除控制器,等于1删，0不删

int sf_deleteco(char a[],char b[])

{

SDT *temp;

temp=head->next;

while(temp!=NULL)

{

if((strcmp(temp->identify,a))&&((!strcmp(temp->dct->coct->identify,b)))) {

return 0;

}

temp=temp->next;

}

return 1;

}

//删除设备的时候同时删除控制器

void Deletecotrol(COCT *te)

{

COCT * temp=cohead;

while(temp->next!=te)

{

temp=temp->next;

}

temp->next=te->next;

delete(te);

}

//添加设备，查找设备是不是已经存在

int sf_exist(char a[])

{

SDT *temp;

if(head->next==NULL)

{

return 0;

}

else

{

temp=head->next;

while(temp!=NULL)

{

if(!strcmp(a,temp->identify))

{

checkdel=temp;

return 1;

}

temp=temp->next;

}

return 0;

}

}

//申请设备时候，如果忙，将设备挂到等待队列void Addwaitpcb(PCB * p1,PCB * p2)

{

PCB *temp=p1;

while(temp->next!=NULL)

{

temp=temp->next;

}

temp->next=p2;

p2->next=NULL;

}

//回收设备时候，对PCB的操作

void Deletepcb(char a[])

{

PCB * temp2=run->next,* temp=run;

while(temp2!=NULL)

{

if(!strcmp(temp2->devname,a))

{

temp->next=temp2->next;

delete(temp2);

break;

}

temp=temp2;

temp2=temp->next;

}

}

//判断等待队列是不是空

int sf_pcbnull(PCB *temp)

{

if(temp->next==NULL)

{

return 0;

}

else return 1;

}

//查看所有设备状态

void Showmenu()

{

PCB * ptemp=run->next;

SDT * temp=head->next;

DCT * dtemp;

COCT * cotemp;

CHCT * chtemp;

cout<<"SDT"<<" i/o"<<" COCT"<<" CHCT"<

while(temp!=NULL)

{

dtemp=temp->dct;

cotemp=dtemp->coct;

chtemp=cotemp->chct;

cout<identify<<"["<state<<"]"<<"\t"<type<<"\t"<identify<<"["<state<<"]"<<"

\t"<identify<<"["<state<<"]"<

temp=temp->next;

}

while(ptemp!=NULL)

{

cout<<"进程"<name<<"申请了设备"<devname<

ptemp=ptemp->next;

}

cout<

}

//设备独立性时候查找要查找的类型是不是存在

int sf_typeexist(char ch)

{

SDT *temp;

if(head->next==NULL)

{

return 0;

}

else

{

temp=head->next;

while(temp!=NULL)

{

if(temp->type==ch)

{

return 1;

}

else temp=temp->next;

}

}

return 0;

}

//增加设备

void Adddevice()

{

cout<<"增加设备"<

SDT * stemp,* s2temp;

COCT *cotemp;

DCT *temp;

char temptype;

PCB *tempblock,* cotempblock;

char choice;

char eqary[10],coary[10];

cin>>eqary;

//此处查找SDT，看是否所要添加的设备已经存在if(sf_exist(eqary)==1)

{//设备已经存在

cout<<"设备已存在"<

}

else

{//设备不存在

tempblock=(PCB *)malloc(sizeof(PCB));

tempblock->next=NULL;

temp=(DCT *)malloc(sizeof(DCT));

strcpy(temp->identify,eqary);

temp->blocking=tempblock;

temp->state=0;

cout<<"输入设备类型"<

cin>>temptype;

temp->type=temptype;

stemp=(SDT *)malloc(sizeof(SDT));

stemp->next=NULL;

stemp->dct=temp;

stemp->type=temptype;

strcpy(stemp->identify,eqary);

s2temp=head;

while(s2temp->next!=NULL)

{

s2temp=s2temp->next;

}

s2temp->next=stemp;

stemp->next=NULL;

cout<<"是否添加控制器?(y/n)"<

cin>>choice;

if((choice=='y')||(choice=='Y'))

{ //添加新控制器

cout<<"输入控制器名称："<

cin>>coary;

cotempblock=(PCB *)malloc(sizeof(PCB));

cotempblock->next=NULL;

cotemp=(COCT *)malloc(sizeof(COCT));

cotemp->next=NULL;

strcpy(cotemp->identify,coary);

cotemp->state=0;

cotemp->blocking=cotempblock;

Addcotrol(cotemp);

temp->coct=cotemp;

cout<<"请选择连接的通道:1/2"<

int i;

cin>>i;

if(i==1)

{

cotemp->chct=CH1;

}

else

{

cotemp->chct=CH2;

}

}

else

{//不添加控制器

Showallco();

cout<<"输入连接控制器的名称:"<

cin>>coary;

cotemp=Findco(coary);

temp->coct=cotemp;

}

cout<<"设备"<

}

}

//删除设备

void Deletedevice()

{//删除设备的时候同时删除pcb Deletepcb

cout<<"删除设备"<

COCT * temp;

SDT * stemp;

char chary[10];

char tempary[10];

cin>>chary;

if(sf_exist(chary)==0)

{

cout<<"删除设备不存在!"<

}

else if(checkdel->dct->state==1)

{

cout<<"设备正在使用无法删除"<

}

else

{//sf_deleteco();

Deletepcb(chary);

strcpy(tempary,checkdel->dct->coct->identify);

if(sf_deleteco(chary,tempary))

{//删除控制器

temp=checkdel->dct->coct;

Deletecotrol(temp);

}

stemp=head;

while(stemp->next!=checkdel)

{

stemp=stemp->next;

}

stemp->next=checkdel->next;

delete(checkdel);

cout<<"设备"<

}

}

//申请设备

void Applydevice()

{

cout<<"申请设备"<

PCB *ptemp;

DCT *dtemp;

COCT *cotemp;

CHCT *chtemp;

char pname[10],eqname[10];

cin>>pname>>eqname;

if(sf_exist(eqname)==0)

{

cout<<"设备不存在!"<

}

else

{//checkdel(对应要申请设备的指针)

ptemp=(PCB *)malloc(sizeof(PCB));

strcpy(ptemp->name,pname);

ptemp->next=NULL;

dtemp=checkdel->dct;

//====================此处是否要考虑状态的改变========================

if(dtemp->state==1)

{//设备忙

Addwaitpcb(dtemp->blocking,ptemp);

cout<<"进程"<name<<"被挂在设备"<identify<<"的等待队列上!"<

}

else

{//设备不忙

cotemp=dtemp->coct;

if(cotemp->state==1)

{//控制器忙

Addwaitpcb(cotemp->blocking,ptemp);

cout<<"进程"<name<<"被挂在控制器"<identify<<"的等待队列上!"<

}

else

{//控制器不忙

chtemp=cotemp->chct;

if(chtemp->state==1)

{//通道忙

Addwaitpcb(chtemp->blocking,ptemp);

cout<<"进程"<name<<"被挂在通道

"<identify<<"的等待队列上!"<

}

else

{//通道不忙

Addwaitpcb(run,ptemp);

dtemp->state=1;

cotemp->state=1;

chtemp->state=1;

strcpy(ptemp->devname,eqname);

cout<<"进程"<

}

}

}

}

//回收设备

void Recycledevice()

{

cout<<"回收设备"<

// char ch;

char eqname[10];

DCT *dtemp;

COCT *cotemp;

CHCT *chtemp;

PCB *pctemp1,*pctemp2;

cin>>eqname;

if(sf_exist(eqname)==0)

{//设备不存在

cout<<"要回收的设备不存在!"<

}

else if(checkdel->dct->state==0)

{//设备存在，但是不需要回收

cout<<"设备处于闲状态，不需要回收!"<

}

else

{//需要回收

Deletepcb(eqname);//

dtemp=checkdel->dct;

cotemp=dtemp->coct;

chtemp=cotemp->chct;

dtemp->state=0;

cotemp->state=0;

chtemp->state=0;

if(sf_pcbnull(chtemp->blocking))

{//如果通道等待队列不空

pctemp1=chtemp->blocking;

pctemp2=pctemp1->next;

pctemp1->next=pctemp2->next;

pctemp2->next=NULL;

strcpy(pctemp2->devname,eqname);

Addwaitpcb(run,pctemp2);

dtemp->state=1;

cotemp->state=1;

chtemp->state=1;

}

else

if(sf_pcbnull(cotemp->blocking))

{//如果控制器的等待队列不空

pctemp1=cotemp->blocking;

pctemp2=pctemp1->next;

pctemp1->next=pctemp2->next;

pctemp2->next=NULL;

strcpy(pctemp2->devname,eqname);

Addwaitpcb(run,pctemp2);

dtemp->state=1;

cotemp->state=1;

chtemp->state=1;

}

else

{

if(sf_pcbnull(dtemp->blocking))

{//如果设备的等待队列不空

pctemp1=dtemp->blocking;

pctemp2=pctemp1->next;

pctemp1->next=pctemp2->next;

pctemp2->next=NULL;

strcpy(pctemp2->devname,eqname);

Addwaitpcb(run,pctemp2);

dtemp->state=1;

cotemp->state=1;

chtemp->state=1;

}

}

}

cout<<"设备"<

}

}

//设备独立性=======

void Independence()

{

cout<<"设备独立性--申请设备:"<

//cout<<"申请设备"<

char type;

char pname[10];

SDT * temp,* temp2;

PCB *ptemp;

DCT *dtemp;

COCT *cotemp;

CHCT *chtemp;