操作系统毕业课程设计总结报告.docx

操作系统毕业课程设计总结报告.docx

《操作系统毕业课程设计总结报告.docx》由会员分享，可在线阅读，更多相关《操作系统毕业课程设计总结报告.docx（28页珍藏版）》请在冰豆网上搜索。

操作系统毕业课程设计总结报告

（此文档为word格式，下载后您可任意编辑修改！

）

本学期开设了操作系统课程，主要学习了计算机操作系统方面的知识（进程控制、进程调度、请求分页存储管理、设备管理、文件管理），了解了操作系统的相关应用。

以下是课程设计五个设计内容的总结。

一、进程控制

1.1目的

通过简单的结构和控制方法，完成模拟进程结构、进程状态和进程控制，掌握进程控制的实现。

1.2完成的内容

1、用PCB表示整个进程实体，利用随机数方法或键盘控制方法模拟进程执行中产生的事件操作控制进程管理内容。

2、定义PCB：

包括理论PCB中的基本内容，如内部ID、外部ID、进程状态、队列指针。

由于无法实现真正的进程创建功能，在实验中只需建立PCB，用它代表完整的进程。

3、定义进程状态转换方式：

进程的状态转换是由进程内部操作或操作系统的控制引起，由于无法实现这些功能，采用随机数方法或键盘控制方法模拟，并实现对应的控制程序。

随机方法指产生1－6的随机数，分别代表创建进程（c）、结束进程（e）、进程阻塞（b）、激活进程（w）、调度进程（p）、时间片到（t）等事件；键盘模拟方法指定义6种按键代表以上6种事件。

4、根据事件处理就绪队列、阻塞队列和当前执行进程的状态。

每次事件处理后应形象地显示出当前系统中的执行进程是哪一个，就绪队列和阻塞队列分别包含哪些进程。

1.3主要数据结构

voidcreate（）{新建

structPCB*temp;

charname[10];

printf（"processname:

"）;

scanf（"%s",name）;

temp=（structPCB*）malloc（sizeof（structPCB））;

strcpy（temp->name,name）;拷贝

temp->next=NULL;

add（ready,temp）;

if（running==NULL）{

running=removeFirst（ready）;

}

}

voidinterupt（）{中断

if（running!

=NULL）{

add（ready,running）;

running=removeFirst（ready）;

}

}

voidblock（）{阻塞

if（running!

=NULL）{

add（blocked,running）;

running=removeFirst（ready）;

}

}

voidwakeup（）{唤醒

if（blocked->next!

=NULL）{

add（ready,removeFirst（blocked））;

}

if（running==NULL）{

running=removeFirst（ready）;

}

}

voidfinished（）{终止

if（running!

=NULL）{

free（running）;

running=removeFirst（ready）;

}

}

1.4算法设计及流程图

建立三个链表分别表示就绪队列、执行队列、阻塞队列；

根据不同的命令对相应的队列进行增删改；

1.5小结

（如何实现的？

可以以关键部分流程图、主要数据结构、程序整体框架等内容表示。

）

二、请求分页存储器管理

2.1目的

通过在第1部分实验基础上实现进程的分页式内存分配和地址转换过程，完成请求分页式存储分配和地址转换过程，掌握页面置换算法:

先进先出（FIFO）、最近最久未使用（LRU）等算法。

2.2完成的内容

1、建立一个位示图，用来模拟内存的分配情况，位示图的位数与设定的物理块个数相同。

程序启动时可利用一组随机0和1填充位示图，表示内存已被占用情况。

2、创建进程时输入进程大小，并根据程序中设定的物理块大小为进程分配物理块，同时建立页表。

3、输入当前执行进程所要访问的逻辑地址，并将其转换成相应的物理地址。

4、进程退出时，根据其页表内容向位示图反向回填“1”。

5、扩充页表，将其变成支持请求和置换功能的二维页表（增加存在位等）。

创建进程时可装入固定的前三页（或键盘输入初始装入页数，不同进程的装入个数可以不同），其余页装入到置换空间内。

6、分别采用FIFO和LRU置换算法对地址转换过程中遇到的缺页现象进行页面置换，可将多次地址转换过程中所涉及到的页号视为进程的页面访问序列，从而计算置换次数和缺页率.

2.3主要数据结构

structpage_table_item

{

intpagenum;

intblocknum;

intexist;存在位

intmodify;修改位

intswap_add;

};

2.4算法设计及流程图

voidterminate（）

{

inti,j,p,q;

if（running==NULL）

{

printf（"已结束所有进程!

!

!

"）;

}

if（running!

=NULL）

{

j=ceil（running->size,PAGE_SIZE）;

if（j>3）

{

for（i=0;i<3;i++）

{

printf（"aaaaa\n"）;

p=（*（running->pagetable+i））.blocknum8;

q=（*（running->pagetable+i））.blocknum%8;

printf（"%d",p）;

setbit（&bitmap[p],q,0）;

}

for（i=3;i

{

printf（"bbbb\n"）;

p=（*（running->pagetable+i））.blocknum8;

q=（*（running->pagetable+i））.blocknum%8;

printf（"%d%d\n",p,q）;

printf（"%d",p）;

setbit（&changemap[p],q,0）;

}

}

else

{

for（i=0;i

{

p=（*（running->pagetable+i））.blocknum8;

q=（*（running->pagetable+i））.blocknum%8;

setbit（&bitmap[p],q,0）;

}

}

free（running）;

}

if（ready!

=NULL）

{

running=removeFirst（ready）;

}

}

voidtranslate（）{逻辑地址转换成物理地址

if（running==NULL）

{

printf（"没有执行进程"）;

}

else

{

intlogical;

intpagenum,offset;

intblocknum;

printf（"请输入逻辑地址:

\n"）;

scanf（"%d",&logical）;

pagenum=（int）（logicalPAGE_SIZE）;

offset=logical%PAGE_SIZE;

blocknum=（running->pagetable+pagenum）->blocknum;

blocknum=*（running->pagetable+pagenum）;

printf（"物理地址:

%d",blocknum*PAGE_SIZE+offset）;

printf（"\n"）;

}blockno=*（running->pagetable+pageno）;

}

voiddispagetable（）显示执行进程页表

{

inti;

if（running==NULL）

{printf（"没有执行进程"）;

return;

}

for（i=0;isize,BLOCK_SIZE）;i++）

printf（"%d%d%d%d%d\n",（*（running->pagetable+i））.pagenum,（*（running->pagetable+i））.blocknum,（*（running->pagetable+i））.exist,（*（running->pagetable+i））.modify,（*（running->pagetable+i））.swap_add）;

}

2.5小结

三、设备管理

3.1目的

通过在前面的实验基础上,完成设备管理功能的模拟，掌握包括通道和控制器的添加和删除，设备的添加、删除，设备的分配和回收。

3.2完成的内容

1、设备管理子系统涉及到系统设备表（SDT）、通道控制表（CHCT）、控制器控制表（COCT）和设备控制表（DCT）来体现输入输出系统的四级结构和三级控制。

2、实现上述设备、控制器以及通道的层次关系，同时能够添加或删除新的设备、控制器或通道。

3、通过键盘命令模拟进程执行过程中提出的设备分配或释放请求，并为此请求分配或释放设备。

分配设备成功后可将进程状态调整为阻塞，释放设备后变为就绪状态。

4、分配设备时应如果该设备已被其它进程占用，则设备分配失败，请求进程进入阻塞状态，同时等待该设备的释放。

如果设备空闲，进程占用设备的同时还应提出申请控制器请求，直到与设备相关的通道都已申请成功为止。

5、设备、控制器或通道的释放应引起对应节点的等待队列中的第一个阻塞进程被唤醒。

如果被唤醒的进程还未完成申请操作，应继续执行上级节点的申请操作。

3.3主要数据结构

structNode*DCTs,*COCTs,*CHCTs;添加头结点，设备，控制器，通道

structNode*addNode（char*name,structNode*parent,structNode*tmp->next;

}

3.4算法设计及流程图

intget_child_count（structNode*node,structNode*childs_count;

}

structNode*findByName（char*name,structNode*tmp;

tmp=tmp->next;

}

printf（"%cError:

can'tfind%s!

\n",BEEP,name）;名为name的节点未找到

returnNULL;

}

voidremoveNode（char*name,structNode*",BEEP,name）;

return;

}

tmp1=tmp2;

tmp2=tmp2->next;

}

printf（"%cError:

can'tfind%s!

\n",BEEP,name）;

}

structNode*addNode（char*name,structNode*parent,structNode*queue）

*voidremoveNode（char*name,structNode*queue）{

}*

voidadd_devices（）{添加设备

inti;

charname[10],parent[10];

while

（1）{

printf（"1:

adddevice\n"）;设备

printf（"2:

addcontroller\n"）;控制器

printf（"3:

addchannel\n"）;通道

printf（"0:

return\n"）;返回主程序

scanf（"%d",&i）;i变量读菜单

if（i!

=0）{

printf（"name:

"）;

scanf（"%s",name）;

}

if（i==1||i==2）{

printf（"parentname:

"）;

scanf（"%s",parent）;

}

switch（i）{

case1:

addNode（name,findByName（parent,COCTs）,DCTs）;所添加的设备名在name里，通过parent名在COCT队列中找到父节点，之后以这个节点，这个名称为参数在DCT队列中添加一个新结点

break;

case2:

addNode（name,findByName（parent,CHCTs）,COCTs）;

break;

case3:

addNode（name,NULL,CHCTs）;通道没有父节点

break;

case0:

return;

}

}

}

voidremove_devices（）{

inti;

charname[10];

structNode*tmp;

while

（1）{

printf（"1:

removedevice\n"）;

printf（"2:

removecontroller\n"）;

printf（"3:

removechannel\n"）;

printf（"0:

return\n"）;

scanf（"%d",&i）;

if（i!

=0）{

printf（"name:

"）;

scanf（"%s",name）;

}

switch（i）{

case1:

removeNode（name,DCTs）;

break;

case2:

tmp=findByName（name,COCTs）;

if（tmp==NULL）

printf（"%cError:

can'tfind%s!

\n",BEEP,name）;

elseif（get_child_count（tmp,DCTs）>0）子节点个数

printf（"%cError:

can'tremove%s!

\n",BEEP,name）;

else

removeNode（name,COCTs）;

break;

case3:

tmp=findByName（name,CHCTs）;

if（tmp==NULL）

printf（"%cError:

can'tfind%s!

\n",BEEP,name）;

elseif（get_child_count（tmp,COCTs）>0）

printf（"%cError:

can'tremove%s!

\n",BEEP,name）;

else

removeNode（name,CHCTs）;

break;

case0:

return;

}

}}

voidallocate_channel（structNode*node,structPCB*p）{

if（p==NULL）

return;

if（node->process==NULL）{

node->process=p;

block（blocked,p）;

}

else

block（node->ready,p）;

}

voidallocate_controller（structNode*node,structPCB*p）{

if（p==NULL）

return;

if（node->process==NULL）{

node->process=p;

allocate_channel（node->parent,p）;

}

else

block（node->ready,p）;

}

voidallocate_device（structNode*node,structPCB*p）{

if（p==NULL）

return;

if（node->process==NULL）{

node->process=p;

allocate_controller（node->parent,p）;

}

else

block（node->ready,p）;

}

voidallocate（）{

charname[10];

structNode*node;

if（running==NULL）

return;

printf（"devicename:

"）;

scanf（"%s",name）;

node=findByName（name,DCTs）;

if（node==NULL）{

printf（"Can'tfind%s!

\n",name）;

return;

}

allocate_device（node,running）;

}

voidrelease_channel（structNode*node,structPCB*p）{

if（node->process==p）{

node->process=NULL;

allocate_channel（node,removeFirst（node->ready））;

add（ready,remove_process（blocked,p））;

if（running==NULL）

running=removeFirst（ready）;

}

else{

add（ready,remove_process（node->ready,p））;

if（running==NULL）

running=removeFirst（ready）;

}

}

voidrelease_controller（structNode*node,structPCB*p）{

if（node->process==p）{

node->process=NULL;

allocate_controller（node,removeFirst（node->ready））;

release_channel（node->parent,p）;

}

else{

add（ready,remove_process（node->ready,p））;

if（running==NULL）

running=removeFirst（ready）;

}

}

voidrelease（）{

charname[10];

structNode*node;

structPCB*p;

printf（"devicename:

"）;

scanf（"%s",name）;

node=findByName（name,DCTs）;

if（node==NULL||node->process==NULL）

return;

p=node->process;

node->process=NULL;

allocate_device（node,removeFirst（node->ready））;

release_controller（node->parent,p）;

}

voiddisplay_process_status（structNode*node）{显示节点的占用进程以及等待进程信息

structPCB*p=node->ready->next;

if（node->process!

=NULL）

printf（"<--%s",node->process->name）;

while（p!

=NULL）{

printf（"<--%s",p->name）;

p=p->next;

}

printf（"\n"）;

}

voiddisplay_status（）{显示设备状态

structNode*chct=CHCTs->next,*coct,*dct;

while（chct!

=NULL）{

printf（"%s",chct->name）;

display_process_status（chct）;

coct=COCTs->next;

while（coct!

=NULL）{

if（coct->parent==chct）{

printf（"\t%s",coct->name）;

display_process_status（coct）;

dct=DCTs->next;

while（dct!

=NULL）{

if（dct->parent==coct）{

printf（"\t\t%s",dct->name）;

display_process_status（dct）;

}

dct=dct->next;

}

}

coct=coct->next;

}

chct=chct->next;

}

}

3.5小结

四、文件管理

4.1目的

通过利用磁盘文件，完成操作系统的文件管理功能，掌握包括目录结构的管理、外存空间的分配与释放以及空闲空间管理三部分。

4.2完成的内容

1、通过初始化操作建立一个模拟外存空间的虚拟磁盘文件，在该文件中保存目录和文件内容。

创建该文件时应创建初始的根目录内容、文件分配表。

2、文件目录项（可以采用FCB格式）应包括类型（目录or文件）、创建日期、大小、第一个磁盘块块号。

3、显示命令提示符“$”，并根据输入命令完成相应的文件操作：

⏹MD（创建子目录）：

创建目录文件，并在父目录文件中增加目录项。

⏹CD（切换工作目录）：

根据当前目录切换到指定目录。

⏹RD（删除子目录）：

搜索所要删除的目录是否为空目录，若是则删除。

⏹MK（创建空文件）：

创建指定大小的文件（如输入命令“mktest2000”，表示创建大小为2000字节的test文件），并在父目录中添加文件名称；还应对FAT表进行适当修改。

⏹DEL（删除文件）：

如果所要删除的文件存在，则删除，同时修改父目录内容；还应对FAT表进行适当修改。

⏹DIR：

列出当前目录的所有目录项。

⏹FORMAT：

根据进一步的虚拟磁盘文件名和块个数信息创建出虚拟磁盘文件。

4.3主要数据结构

structFCB{

charname[8];

intsize;

intfirst_block;

chardatetime[15];

chartype;

};

charcurrent_directory[256]="";当前目录

charformated_file_name[32];虚拟磁盘文件名

intcurrent_directory_block_no=0;当前目录块号

4.4算法设计及流程图

voidmd（char*name）{

if（!

is_valid_name（name））

return;

s