操作系统课程设计 设备管理实现 源代码.docx

#include <stdio.h>
#include "iostream.h"
#include "stdlib.h"
#include "string.h"
struct PCB{
int id;
char name[10];
int size;
struct PCB *next;
};

struct PCB *running;
struct PCB *ready;
struct PCB *blocked;
struct PCB *q;
struct PCB *p;
int id=1;
int size;
char name[10];
//////////////////////////////////////////////////////////////////////////////////////
struct DCT{ //设备
char name[10];
int busy;
PCB * occupied;
PCB * waiting;
struct DCT *next;
struct COCT* coct; //上级控制器
};

struct COCT{ //控制器
char name[10];
int busy;
PCB * occupied;
PCB * waiting;
struct COCT *next;
struct CHCT* chct; //控制器的上级通道
};

struct CHCT{ //通道
char name[10];
int busy;
PCB * occupied;
PCB * waiting;
struct CHCT *next;
};

//////////////////////////////////////////////////////////////////////////////////////
struct DCT * dcts;
struct COCT *cocts;
struct CHCT *chcts;

void enqueue(int id,char *name,int size,struct PCB *head){
struct PCB *node=(struct PCB *)malloc(sizeof(struct PCB));
node->next=0;
node->id=id;
strcpy(node->name,name);
node->size=size;
struct PCB *tmp=head;
while(tmp->next!=0)
tmp=tmp->next;
tmp->next=node;
}

struct PCB * dequeue(struct PCB *head){
struct PCB * tmp=head->next;
if(head->next!=0){
head->next=head->next->next;
tmp->next=0;
}
return(tmp);
}

void createProcess(){
printf("\nname: ");
scanf("%s",name);
printf("size: ");
scanf("%d",&size);
printf("\n");

enqueue(id++,name,size,ready);
if(running==0){
running=dequeue(ready);
}
}

void switchProcess(){
if(running!=0&&ready->next!=0)
{
enqueue(running->id,running->name,running->size,ready);
running=dequeue(ready);
}
else
printf("没有可切换的进程\n");
}

void blockProcess(){
if(running==0)
printf("没有可阻塞的进程\n");
else
{
enqueue(running->id,running->name,running->size,blocked);
running=0;
if(ready->next==0)
printf("没有可执行的进程\n");
else
running=dequeue(ready);
}

}

void wakeupProcess(){
if(blocked->next==0)
printf("没有可激活的进程");
else
{
enqueue(blocked->next->id,blocked->next->name,blocked->next->size,ready);
dequeue(blocked);
if(running==0)
running=dequeue(ready);
}
}

void terminateProcess(){ //结束进程
if(running==0){
printf("没有需要结束的进程\n");
}
else{
running=dequeue(ready);
}
}

void displayProcessstatus(){

printf("--------就绪态--------\n");
if(ready->next==0)
printf("当前没有进程在该状态\n");
if(ready->next!=0)
{
q=ready->next;
while(ready->next!=0)
{
printf("%s",ready->next->name);
printf(" %d\n",ready->next->size);
ready->next=ready->next->next;
}
ready->next=q;
}
printf("--------执行状态--------\n");
if(running==0) printf("当前没有进程在该状态\n");
if(running!=0)
{
printf("%s",running->name);
printf(" %d\n",running->size);
}
printf("--------阻塞状态--------\n");
if(blocked->next==0) printf("当前没有进程在该状态\n\n");
if(blocked->next!=0)
{
p=blocked->next;
while(blocked->next!=0)
{
printf("%s",blocked->next->name);
printf(" %d\n",blocked->next->size);
blocked->next = blocked->next->next;
}
blocked->next=p;
}

}
//////////////////////////////////////////////////////////////////////////////////

struct DCT * findDCT(char name[]) //设备分配时找到要添加的设备
{
struct DCT *temp = dcts;
while(temp->next!=NULL)
{
temp = temp->next;
if(strcmp(temp->name,name)==0)
return temp;
}
return NULL;
}

struct CHCT * findChannel(char name[])
{
struct CHCT *temp = chcts;
while(temp->next!=NULL)
{
temp = temp->next;
if(strcmp(temp->name,name)==0)
return temp;
}
return NULL;
}

struct COCT * findController(char name[])
{
struct COCT *temp = cocts;
while(temp->next!=NULL)
{
temp = temp->next;
if(strcmp(temp->name,name)==0)
return temp;
}
return NULL;
}

void addProcesstoWaiting(struct PCB * waiting,struct PCB *p)//进入进程等待队列
{

struct PCB *temp = waiting;
while(temp->next!=NULL)
{
temp = temp->next;
}
//temp->next = p;
//+++++++++++++++++++++++++++++++++++++++++++++++++
temp->next = new struct PCB;
temp->next->id = p->id;
strcpy(temp->next->name,p->name);
temp->next->size = p->size;
temp->next->next = NULL;
//++++++++++++++++++++++++++++++++++++++++++++++++++

}

void add(struct PCB * head,struct PCB * node){ //入队列
struct PCB *tmp=head;
while(tmp->next!=0)
tmp=tmp->next;
tmp->next=node;
}

struct PCB * getFirst(struct PCB *head){ //获得队列里的第一个进程
return head->next;
}

void allocateCHCT(struct CHCT* chct,PCB *p)//分配CHCT
{
if(chct->occupied!=0)
{
printf("不能分配通道\n");
addProcesstoWaiting(chct->waiting,p);
}
else
{
chct->occupied=p;
printf("分配成功！\n");
}
add(blocked,p);
if(ready!=0)
running=dequeue(ready);
else
running=0;
}

//**************************************************
void allocateCOCT(struct COCT* coct,PCB *p)
{
if(coct->occupied!=0){
printf("不能分配控制器\n");
addProcesstoWaiting(coct->waiting,p);
add(blocked,p);
if(ready!=0)
running=dequeue(ready);
else
running=0;
return;
}else{
coct->occupied=p;
allocateCHCT(coct->chct,p);
}
}

void allocateDCT(){
char nameDCT[10];
printf("请输入设备名称：");
scanf("%s",nameDCT);
struct DCT * dct=findDCT(nameDCT);
struct PCB * p = running;
if(dct!=NULL&&p!=NULL)
{
if(dct->occupied!=0){
printf("不能分配设备\n");
addProcesstoWaiting(dct->waiting,p);
add(blocked,p);
if(ready!=0)
running=dequeue(ready);
else
running=0;
return;
}else{
dct->occupied=p;
allocateCOCT(dct->coct,p);
//++++++++++++++++++++++++++++
/*add(blocked,p);
if(ready!=0)
running=dequeue(ready);
else
running=0;
return;*/
//+++++++++++++++++++++++++++++
}
}
else
printf("发生错误!\n");
}

void releaseCHCT(char *name,struct CHCT* chct,struct PCB* p) //??????
{
if(p!=NULL)
addProcesstoWaiting(chct->waiting,p);
if(strcmp(name,chct->occupied->name)==0)
{
if(chct->waiting->next!=NULL)
{
chct->occupied = dequeue(chct->waiting);
}
else
{
chct->occupied = NULL;
}
}
}

void releaseCOCT(char *name,struct COCT* coct,struct PCB* p)
{
if(p!=NULL)
addProcesstoWaiting(coct->waiting,p);
if(strcmp(name,coct->occupied->name)==0)
{
if(coct->waiting->next!=NULL)
{
coct->occupied = dequeue(coct->waiting);
}
else
{
coct->occupied = NULL;
}
releaseCHCT(name,coct->chct,coct->occupied);
}
}

void releaseDCT()
{
char nameDCT[10];
printf("请输入要释放的设备名称：\n");
scanf("%s",nameDCT);
char nameP[10];
printf("请输入要释放的进程名称：\n");
scanf("%s",nameP);
struct DCT *temp = findDCT(nameDCT);
if(strcmp(temp->occupied->name,nameP)==0)
{
if(temp->waiting->next!=NULL)
{
temp->occupied = dequeue(temp->waiting);
}
else
{
temp->occupied = NULL;
}
releaseCOCT(nameP,temp->coct,temp->occupied);
}
else
{
printf("没有对应的设备和进程！");
}

}

void addChannel(char name[]){
struct CHCT * temp=(struct CHCT *)malloc(sizeof(struct CHCT));
strcpy(temp->name,name);
temp->next=0;
temp->busy=0;
temp->waiting = new struct PCB;
temp->waiting->next = NULL;
//temp->waiting=0;
temp->occupied=0;
struct CHCT * head=chcts; //进入了chcts队列
while(head->next!=0)
head=head->next;
head->next=temp;
}

void addController(char *name,struct CHCT * chct){ //增加控制器
struct COCT * temp=(struct COCT *)malloc(sizeof(struct COCT));
strcpy(temp->name,name);
temp->next=0;
temp->busy=0;
temp->waiting = new struct PCB;
temp->waiting->next = NULL;
//temp->waiting=0; //+
temp->occupied=0;
temp->chct= chct;
struct COCT * head=cocts; //进入了cocts队列
while(head->next!=0)
head=head->next;
head->next=temp;
}

void addDevice(char *name,struct COCT * coct){ //增加设备
struct DCT * temp=(struct DCT *)malloc(sizeof(struct DCT));
strcpy(temp->name,name);
temp->next=0;
temp->busy=0;
temp->waiting = new struct PCB;
temp->waiting->next = NULL;
//temp->waiting=0;
temp->occupied=0;
temp->coct= coct;
struct DCT * head=dcts;
while(head->next!=0)
head=head->next;
head->next=temp;
}
//添加设备++++++++++++++++++++++++++++++++++
void add_dct(){
char newDCT[10];
printf("请输入新设备的名字:\n");
scanf("%s",newDCT);
char newCOCT[10];
printf("请输入要添加到的控制器的名字:\n");
scanf("%s",newCOCT);
addDevice(newDCT,findController(newCOCT));
}
//添加控制器
void add_coct(){
char newCOCT[10];
printf("请输入新控制器的名字:\n");
scanf("%s",newCOCT);
char newCHCT[10];
printf("请输入要添加到的通道的名字:\n");
scanf("%s",newCHCT);
addController(newCOCT,findChannel(newCHCT));
}
//添加通道
void add_chct(){
char newCHCT[10];
printf("请输入新的通道的名字:\n");
scanf("%s",newCHCT);
addChannel(newCHCT);

}
//++++++++++++++++++++++++++++++++++
//+++++++++++++++++删除操作++++++++++++++++++++
//删除设备
void deleteDCT(char nameDCT[]){
//char nameDCT[10];
//int i=0;
//printf("请输入要删除DCT的名字:");
//scanf("%s",nameDCT);
struct DCT * temp = findDCT(nameDCT);
struct DCT * head = dcts;
if(temp==NULL){
printf("没有对应的设备!\n");
return ;
}
else

while(head->next!=0)
{
if(strcmp(temp->name,head->next->name)==0)
{
if(temp->occupied!=NULL)
printf("此设备现在正在使用不能删除\n");
else
head->next=head->next->next;
//i++;
break;
}
else
head=head->next;
}

}
//删除控制器
void deleteCOCT(char nameCOCT[]){
struct COCT *temp=findController(nameCOCT);
struct COCT *head=cocts;
if(temp==NULL){
printf("没有对应的控制器\n");
return;
}
else
while(head->next!=0)
{
if(strcmp(temp->name,head->next->name)==0){
if(temp->occupied!=NULL)
printf("此控制器现在正在使用不能删除\n");
else{
// deleteDCT(temp->);
head->next=head->next->next;
}
break;
}
head=head->next;
}
}
//删除通道
void deleteCHCT(char nameCHCT[]){
struct CHCT *temp=findChannel(nameCHCT);
struct CHCT *head=chcts;
if(temp==NULL){
printf("没有对应的通道\n");
return;
}
else
while(head->next!=0)
{
if(strcmp(temp->name,head->next->name)==0){
if(temp->occupied!=NULL)
printf("此通道现在正在使用不能删除\n");
else{
// deleteDCT(temp->);
head->next=head->next->next;
}
//i++;
break;
}
head=head->next;
}
}
//+++++++++++++++++++++++++++++++++++++++++++

void displayDCT()
{
struct DCT * dct;
struct COCT *coct;
struct CHCT *chct = chcts;
struct PCB *pcb;
//------------------------------
while(chct->next!=NULL)
{
chct = chct->next;
printf(" %s(",chct->name);
if(chct->occupied!=0)
printf("%s",chct->occupied->name);
printf(")");
pcb = chct->waiting->next;//waiting是头结点，pcb指向队列第一个进程
while(pcb!=NULL)
{
printf("[%s]",pcb->name);
pcb = pcb->next;
}
printf("\n");
//----------------------------------------------------
coct = cocts;
while(coct->next!=NULL)
{
coct = coct->next;
if(strcmp(coct->chct->name,chct->name)==0)
{
printf(" %s(",coct->name);
if(coct->occupied!=0)
printf("%s",coct->occupied->name);
printf(")");
pcb = coct->waiting->next;
while(pcb!=NULL)
{
printf("[%s]",pcb->name);
pcb = pcb->next;
}
printf("\n");
//-----------------------------------------
dct = dcts;
while(dct->next!=NULL)
{
dct = dct->next;
if(strcmp(dct->coct->name,coct->name)==0)
{
printf(" %s(",dct->name);
if(dct->occupied!=0)
printf("%s",dct->occupied->name);
printf(")");
pcb = dct->waiting->next;
while(pcb!=NULL)
{
printf("[%s]",pcb->name);
pcb = pcb->next;
}
printf("\n");
}
}
}
}
}
}

//////////////////////////////////////////////////////////////////////
void main(){

dcts=(struct DCT *)malloc(sizeof(struct DCT));
dcts->next=0;
cocts=(struct COCT *)malloc(sizeof(struct COCT));
cocts->next=0;
chcts=(struct CHCT *)malloc(sizeof(struct CHCT));
chcts->next=0;

addChannel("chct1");
addChannel("chct2");
addController("coct1",findChannel("chct1"));
addController("coct2",findChannel("chct1"));
addController("coct3",findChannel("chct2"));
addDevice("dct1",findController("coct1"));
addDevice("dct2",findController("coct1"));
addDevice("dct3",findController("coct2"));
//addDevice("dct4",findController("coct2"));
addDevice("dct4",findController("coct3"));

ready=(struct PCB *)malloc(sizeof(struct PCB));
blocked=(struct PCB *)malloc(sizeof(struct PCB));
ready->next=0;
blocked->next=0;

A:while(1)
{
int choice;
int function;
printf("1:创建进程\n");
printf("2:切换进程\n");
printf("3:阻塞进程\n");
printf("4:唤醒进程\n");
printf("5:结束进程\n");
printf("6:显示进程\n");
printf("7:设备管理\n");
printf("0:exit\n");
scanf("%d",&choice);
switch(choice)
{
case 1:createProcess();break;
case 2:switchProcess();break;
case 3:blockProcess();break;
case 4:wakeupProcess();break;
case 5:terminateProcess();break;
case 6:displayProcessstatus();break;
case 7:
while(1)
{
printf("1:设备分配\n");
printf("2:设备释放\n");
printf("3:显示\n");
printf("4:添加新的设备\n");
printf("5:添加新的控制器\n");
printf("6:添加新的通道\n");
printf("7:删除设备\n");
printf("8:删除控制器\n");
printf("9:删除通道\n");
printf("0:返回主界面\n");
scanf("%d",&function);
switch(function)
{
case 1:allocateDCT();break;
case 2:releaseDCT();break;
case 3:displayDCT();break;
case 4:add_dct();break;
case 5:add_coct();break;
case 6: add_chct();break;
case 7:
char nameDCT[10];
printf("请输入要删除DCT的名字:\n");
scanf("%s",nameDCT);
deleteDCT(nameDCT);break;
case 8:
char nameCOCT[10];
printf("请输入要删除COCT的名字:\n");
scanf("%s",nameCOCT);
deleteCOCT(nameCOCT);break;
case 9:
char nameCHCT[10];
printf("请输入要删除CHCT的名字:\n");
scanf("%s",nameCHCT);
deleteCHCT(nameCHCT);break;
case 0:goto A;break;
}
}
case 0:exit(0);break;
}
}
}