操作系统课程设计样本.doc

操作系统课程设计

班级 10计科<1>班
学号 10510116
姓名 鞠智明
指引 汤教师
时间 .12.24～.01.06

景德镇陶瓷学院

实验报告一、进程管理设计 2
一、实验目： 2
二、实验内容： 3
实验报告二、单解决机系统进程调度 7
一、实验目： 7
二、实验内容： 7
三、实验实现： 7
实验报告三、基本存储器管理 11
一、实验目： 12
二、实验内容： 12
三、实验实现： 12
实验报告四、祈求分页存储管理（虚拟存储） 17
一、实验目： 17
二、实验内容： 18
三、实验实现： 18
实验报告五、死锁避免 23
一、实验目： 23
二、实验内容： 24
实验报告六、磁盘空间分派与回收 28
一、实验目： 28
二、实验内容： 29
三、实验实现： 29
实验报告七、文献管理 31
一、实验目： 32
二、实验内容： 32
三、实验实现： 32

实验报告一、进程管理设计
实验者：鞠智明 学号：10510116 班级：计科（1）班 实验时间12月
一、 实验目：
1、执行通过进程创立和控制设计来达到如下目：
2、加深对进程概念理解，明确进程和程序区别；
3、进一步结识并发概念，区别顺序执行和并发执行；
4、分析进程争用临界资源现象，学习解决进程互斥办法；
二、实验内容：
（二）在WINDOWS环境下模仿实验：
1、 用C语言编写一程序，来模仿进程创立和撤除，规定通过终端键盘输入三、四作业名称、大小、优先级等。系统为它创立进程，并把进程控制块PCB内容送到终端显示屏上输出。
2、 同步模仿内存空间为作业分派内存空间，并把成果用图形形象地表达出来，同样通过终端输出。
3、 按进程优先级顺序撤除进程，同步通过终端显示PCB撤除过程和内存释放过程。
三、实验实现：
#include<stdio.h>
#include<malloc.h>
#include<stdlib.h>
#define OK 1
#define EVERFLOW -1
#define PCBSIZE 10
#define NULL 0
void main()
{
InitPcb(nullPcb);
//给就绪队列分派空间
readyPcbtail=(PCB*)malloc(sizeof(PCB));
readyPcb=readyPcbtail;
readyPcbtail->id=0;
readyPcbtail->priority=0;
readyPcbtail->time=0;
readyPcbtail->next=NULL;
do
{/*创立程序控制界面*/
printf("******************************\n");
printf("\t1.创立一种PCB进程\n\t2.销毁运营PCB进程\n\t3.就绪队列打印输出\n\t4.退出系统n");
printf("******************************\n");
scanf("%d",&on);//设立快关按钮
switch(on)
{
case 1：p=Create(nullPcb)；InsertReadyPcb(readyPcb,p);break； //执行创立PCB进程
case2:printf("请输入销毁进程id值\n");
scanf("%d",&deleteId);Delete(deleteId,readyPcb,nullPcb);break;
case 3：PrintPCB(readyPcb);break;
case 4：exit(0);
default:
printf("请输入1-4之间序号\n");
}
}while(on!=4);
}
void InitPcb(PCBList &nullPcb)//初始化空闲队列

{
nullPcb=&pcb[0];
for(int i=0;i<PCBSIZE-1;i++){
pcb[i].id=i;
pcb[i].next=&pcb[i+1];
}
pcb[PCBSIZE-1].next=NULL;
printf("进程快初始化成功\n");
}
PCBList Create(PCBList &nullPcb)///创立PCB进程
{
if(nullPcb){//将空闲队列第一种赋值给就绪队列，并将它放置在在就绪队列队尾
pcbP=nullPcb;
nullPcb=nullPcb->next;
printf("请输入创立PCB序号id\n");
scanf("%d",&pcbP->id);
printf("请输入它创立名字\n");
scanf("%s",&pcbP->name);
printf("请输入它优先级\n");
scanf("%d",&pcbP->priority);
printf("请输入它运营所需时间\n");
scanf("%d",&pcbP->time);
pcbP->next=NULL;
}
return pcbP;
}
int Delete(int id,PCBList &readyPcb,PCBList &nullPcb)//销毁PCB进程
{
if(pcbT) {
while(pcbT) {
if(pcbT->id==id) {
pcbF->next=pcbT->next;
pcbT->next=nullPcb;
nullPcb=pcbT;
printf("销毁成功\n");
return OK;
}
pcbT=pcbT->next;
pcbF=pcbF->next;
}
if(!pcbT) {
printf("没有要删除PCB进程\n")；
} }
else{
printf("没有要删除PCB进程\n")；
}
return OK;
}
void PrintPCB(PCBList &readyPcb)//打印PCB就绪队列
{
printf("就绪队列中进程，按照优先级排列序号:\n");
printf("\t\t序号\t名字\t优先级\t运营时间\n");
PCBList pcbP=readyPcb->next;
while(pcbP)
{
printf("\t\t%d\t%s\t%d\t%d\n",pcbP->id,pcbP->name,pcbP->priority,pcbP->time);
pcbP=pcbP->next;
}
}
void InsertReadyPcb(PCBList &readyPcb,PCBList &pcb)
{
PCBList pcbF=readyPcb;
PCBList pcbT=readyPcb->next;
if(pcbT)
{
while(pcbT)
{
if(pcbT->priority<pcb->priority)
{
pcb->next=pcbT;
pcbF->next=pcb;
printf("创立成功并将进程插入到就绪队列中了\n");
return;
}
pcbT=pcbT->next;
pcbF=pcbF->next;
}
if(!pcbT)
{
pcbF->next=pcb;
}
}
else{
pcbF->next=pcb;
printf("创立成功并将进程插入到就绪队列中了\n");
}
}
实验成果

实验报告二、单解决机系统进程调度
实验者：鞠智明 学号：10510116 班级：计科（1）班 实验时间12月
一、实验目：
通过进程创立和控制设计来达到如下目：
1、加深对进程概念理解，明确进程和程序区别
2、进一步理解系统如何组织进程，创立进程
3、进一步结识如何实现解决机调度。
二、实验内容：
（二）在WINDOWS环境下模仿实验：
1、先来先服务调度算法
2、优先数调度算法；
3、时间片轮法调度算法
4、多级反馈队列轮转调度算法
三、实验实现：
#include "stdio.h"
#include <stdlib.h>
#include <conio.h>
#define getpch(type) (type*)malloc(sizeof(type))
#define NULL 0
struct pcb { /* 定义进程控制块PCB */
char name[10];
char state;
int super;
int ntime;
int rtime;
struct pcb* link;
}*ready=NULL,*p;
typedef struct pcb PCB;
sort() /* 建立对进程进行优先级排列函数*/
{
PCB *first，*second;
int insert=0;
if((ready==NULL)||((p->super)>(ready->super))) /*优先级最大者,插入队首*/
{
p->link=ready;
ready=p;
}
else /* 进程比较优先级,插入恰当位置中*/
{
first=ready;
second=first->link;
while(second!=NULL)
{
if((p->super)>(second->super)) /*若插入进程比当迈进程优先数大,*/
{ /*插入到当迈进程前面*/
p->link=second;
first->link=p;
second=NULL;
insert=1;
}
else /* 插入进程优先数最低,则插入到队尾*/
{
first=first->link;
second=second->link;
}
}
if(insert==0) first->link=p;
}
}
input() /* 建立进程控制块函数*/
{
int i,num;
clrscr()；/*清屏*/
printf("\n 请输入进程号?");
scanf("%d",&num);
for(i=0;i<num;i++)
{
printf("\n 进程号No.%d:\n",i);
p=getpch(PCB);
printf("\n 输入进程名:");
scanf("%s",p->name);
printf("\n 输入进程优先数:");
scanf("%d",&p->super);
printf("\n 输入进程运营时间:");
scanf("%d",&p->ntime);
printf("\n");
p->rtime=0;p->state='w';
p->link=NULL;
sort()；/* 调用sort函数*/
}
}
int space()
{
int l=0；PCB* pr=ready;
while(pr!=NULL)
{
l++;
pr=pr->link;
}
return(l);
}
disp(PCB * pr) /*建立进程显示函数,用于显示当迈进程*/
{
printf("\n qname \t state \t super \t ndtime \t runtime \n");
printf("|%s\t",pr->name);
printf("|%c\t",pr->state);
printf("|%d\t",pr->super);
printf("|%d\t",pr->ntime);
printf("|%d\t",pr->rtime);
printf("\n");
}
check() /* 建立进程查看函数 */
{
PCB* pr;
printf("\n **** 当前正在运营进程是:%s",p->name)；/*显示当前运营进程*/
disp(p);
pr=ready;
printf("\n ****当前就绪队列状态为:\n")；/*显示就绪队列状态*/
while(pr!=NULL)
{
disp(pr);
pr=pr->link;
}
}
destroy() /*建立进程撤除函数(进程运营结束,撤除进程)*/
{
printf("\n 进程 [%s] 已完毕.\n",p->name);
free(p);
}
running() /* 建立进程就绪函数(进程运营时间到,置就绪状态*/
{
(p->rtime)++;
if(p->rtime==p->ntime)
destroy()；/* 调用destroy函数*/
else
{
(p->super)--;
p->state='w';
sort()；/*调用sort函数*/
}
}
void main() /*主函数*/
{
int len,h=0;
char ch;
input();
len=space();
while((len!=0)&&(ready!=NULL))
{
ch=getchar();
h++;
printf("\n The execute number:%d \n",h);
p=ready;
ready=p->link;
p->link=NULL;
p->state='R';
check();
running();
printf("\n 按任一键继续......");
ch=getchar();
}
printf("\n\n 进程已经完毕.\n");
ch=getchar();
}
实验成果

实验报告三、基本存储器管理
实验者：鞠智明 学号：10510116 班级：计科（1）班 实验时间12月
一、实验目：
通过进程创立和控制设计来达到如下目：
一种好计算机系统不但要有一种足够容量、存取速度高、稳定可靠主存储器，并且要能合理地分派和使用这些存储空间。当顾客提出申请存储器空间时，存储管理必要依照申请者规定，按一定方略分析主存空间使用状况，找出足够空闲区域分派给申请者。当作业撤离或积极归还主存资源时，则存储管理要收回作业占用主存空间或归还某些主存空间。主存分派和回收实现与主存储器管理方式关于，通过本实验协助学生理解在不同存储管理方式下如何实现主存分派和回收。
二、实验内容：
从下两种存储管理方式主存分派和回收中，选取一种管理方式来实现本次实验任务：
1、在可变（动态）分区管理方式下，采用最先适应算法。
2、在分页式管理方式下，采用位示图来表达主存分派状况和回收状况。
三、实验实现：
#include<stdio.h>
#include<stdlib.h>
struct linkk
{
int size;
int addr;
struct linkk *next;
};
struct jobtab
{
int jno;
int size;
int addr;
int flag;
};
struct linkk *PL,*p,*q,*p1;
struct jobtab tab[20];
int l,m,n,t,addr,length;
void printlink()
{
if (PL!=NULL)
{
printf("\n 进程内存大小 剩余内存\n");
printf("----------------------------\n");
}
q=PL;
while(q!=NULL)
{
printf(" %d %d\n",q->addr,q->size);
q=q->next；
}
printf("---------------------\n");
return;
}
void printtab()
{
int i；int flag=0;
for (i=0;i<20&&flag==0;i++)
if (tab[i].flag==1)flag=1;
if (flag==0)
{
printf("\n 无进程!");
return;
}
printf("\n 进程编号 进程起始地址 进程内存大小\n");
printf("----------------------\n");
for (i=0;i<20;i++)
if (tab[i].flag==1)
printf(" %d %d %d\n",i,tab[i].addr,tab[i].size);
printf("---------------\n");
return;
}
void allocm()
{
printf("\n 输入进程编号:");
scanf("%d",&n);
printf("\n 输入进程内存大小:");
scanf("%d",&l);
if (tab[n].flag==1)
{
printf("\n 该进程被创立!\n");
return;
}
else
{
tab[n].flag=1;tab[n].size=l;
q=PL；p=PL;
}
while (q!=NULL)
{
if (q->size==l)
{
tab[n].addr=q->addr;
p1=q;
if (p1==PL) PL=q->next;
else p->next=q->next;
free(p1);
return;
}
if (q->size>l)
{
tab[n].addr=q->addr;
q->size=q->size-l；q->addr=q->addr+l;
return;
}
p=q；q=q->next;
}
tab[n].flag=0;
printf("\n 没有内存剩余!\n");
return;
}
void freem()
{printf("\n 输入进程编号:")；
scanf("%d",&n);
if(tab[n].flag==0)
{printf("\n 不是该进程!");
return;
}
addr=tab[n].addr；length=tab[n].size;
tab[n].flag=0;
q=PL;
if ((q==NULL)||(addr+length<q->addr))
{p1=(struct linkk *)malloc(sizeof(struct linkk));
p1->size=length；p1->addr=addr;
p1->next=q；PL=p1;
return;
}
if(addr+length==q->addr)
{q->addr=addr；q->size=q->size+length;
return;
}
p=q；q=q->next;
while (q!=NULL)
{if(p->addr+p->size==addr)
{p->size=p->size+length;
if (addr+length==q->addr)
{p->size=p->size+q->size;
p1=q；p->next=q->next;
free(p1);
}
return;
}
if(addr+length==q->addr)
{q->addr=addr；q->size=q->size+length;
return;
}
if(addr+length<q->addr)
{p1=(struct linkk *)malloc(sizeof(struct linkk));
p1->size=length；p1->addr=addr;
p1->next=q；p->next=p1;
return;
}
p=q；q=q->next;
}
if(p->addr+p->size==addr)
{p->size=p->size+length;
return;
}
p1=(struct linkk *)malloc(sizeof(struct linkk));
p1->addr=addr；p1->size=length；p1->next=NULL;
p1->next=p1;
return;
}
main()
{PL=(struct linkk *)malloc(sizeof(struct linkk));
PL->addr=0；PL->next=NULL;
printf("\n输入内存大小:");
scanf("%d",&n)；PL->size=n;
for(int i=0;i<20;i++)
{tab[i].jno=i;
tab[i].flag=0;
}t=0;
do
{printf("\n--------------------------------\n");
printf(" 1--分派内存 2--释放内存\n");
printf(" 3--链接进程号 4--输出_TAB \n");
printf(" 5--Quit\n");
printf("\n--------------------------------\n");
printf(" Select[ ]\b\b");
scanf("%d",&m);
switch(m)
{
case 1：allocm();break;
case 2：freem();break;
case 3：printlink();break;
case 4：printtab();break;
case 5：t=1;
}
}
while (!t);
}
实验成果

实验报告四、祈求分页存储管理（虚拟存储）
实验者：鞠智明 学号：10510116 班级：计科（1）班 实验时间12月
一、实验目：
通过祈求分页存储管理设计，让学生理解虚拟存储器概念和实现办法。进行运营时不需要将所有页面都调入内存，只需将某些调入内存，即可运营，在运营过程中若要访问页面不在内存时，则需求有祈求调入功能将其调入。如果此时若内存没有空白物理块，则通过页面置换功能将一种老不用页面裁减出来，其中裁减算法有各种。
二、实验内容：
模仿仿真祈求分页调度算法，其中裁减算法可选下列其一
1、先进先出算法
2、近来最久算法
3、CLOCK算法
三、实验实现：
#include<iostream>
#include<time.h>
using namespace std；
const int MaxNum=320;//指令数
const int M=5;//内存容量
int PageOrder[MaxNum];//页面祈求
int Simulate[MaxNum][M];//页面访问过程
int PageCount[M],LackNum;//PageCount用来记录LRU算法中最久未使用时间,
LackNum记录缺页数
float PageRate;//命中率
int PageCount1[32]；
bool IsExit(int i)//FIFO算法中判断新页面祈求与否在内存中
{
bool f=false；
for(int j=0;j<M;j++)
{
if(Simulate[i-1][j]==PageOrder[i])//在前一次页面祈求过程中寻找与否存在新页面祈求 {
f=true；
}
}
return f；
}
int IsExitLRU(int i)//LRU算法中判断新页面祈求与否在内存中
{
int f=-1；
for(int j=0;j<M;j++)
{
if(Simulate[i-1][j]==PageOrder[i])
{
f=j；
}
}
return f；
}
int Compare()//LRU算法找出内存中需要置换出来页面
{
int p,q；
p=PageCount[0]；
q=0；
for(int i=1;i<M;i++)
{
if(p<PageCount[i])
{
p=PageCount[i]；
q=i；
}
}
return q;
}
void Init() //初始化页框
{
for(int k=0;k<MaxNum;k++)
{
int n=rand()%320;//随机数产生320次指令
PageOrder[k]=n/10;//依照指令产生320次页面祈求
}
for(int i=0;i<MaxNum;i++)//初始化页面访问过程
{
for(int j=0;j<M;j++)
{
Simulate[i][j]=-1；
}
}
for(int q=0;q<M;q++)//初始化最久未使用数组
{
PageCount[q]=0；
}
}
void OutPut()//输出
{
int i,j；
cout<<"页面访问序列:"<<endl；
for(j=0;j<MaxNum;j++)
{
cout<<PageOrder[j]<<" "；
}
cout<<endl；
cout<<"页面访问过程(只显示前10个):"<<endl；
for(i=0;i<10;i++)
{
for(j=0;j<M;j++)
{
if(Simulate[i][j]==-1)
cout<<" "；
else
cout<<Simulate[i][j]<<" "；
}
cout<<endl；
}
cout<<"缺页数= "<<LackNum<<endl； cout<<"命中率= "<<PageRate<<endl； cout<<"--------------------------------------------------------------"<<endl；
}
void FIFO()//FIFO算法
{
int j,x=0,y=0；
LackNum=0，
Init()；
for(j=0;j<M;j++)//将前五个页面祈求直接放入内存中
{
for(int k=0;k<=j;k++)
{
if(j==k)
Simulate[j][k]=PageOrder[j]；
else
Simulate[j][k]=Simulate[j-1][k]；
}
//LackNum++；
}
for(x=M;x<MaxNum;x++)
{
for(int t=0;t<M;t++)//先将前一次页面访问过程赋值给新页面访问过程 {
Simulate[x][t]=Simulate[x-1][t]；
}
if(!IsExit(x))//依照新访问页面与否存在内存中来更新页面访问过程
{
LackNum++；
Simulate[x][y%M]=PageOrder[x];
y++；
}
}
PageRate=1-((float)LackNum/(float)MaxNum);//算出命中率
OutPut()；}
void LRU()//LRU算法
{
int j,x=0,y=0；
LackNum=0，
Init()；
for(j=0;j<M;j++)//将前五个页面祈求直接放入内存中
{
for(int k=0;k<=j;k++)
{
PageCount[k]++；
if(j==k)
Simulate[j][k]=PageOrder[j]；
else
Simulate[j][k]=Simulate[j-1][k]；
}
LackNum++；
}
for(x=M;x<MaxNum;x++)
{
for(int t=0;t<M;t++)//先将前一次页面访问过程赋值给新页面访问过程
{
Simulate[x][t]=Simulate[x-1][t]；
}
int p=IsExitLRU(x)；
if(p==-1)//依照反回p值来更新页面访问过程
{
int k；
k=Compare()；
for(int w=0;w<M;w++)
{
if(w!=k)
PageCount[w]++；
else
PageCount[k]=1；
}
Simulate[x][k]=PageOrder[x]；
LackNum++；
}
else
{
for(int w=0;w<M;w++)
{
if(w!=p)
PageCount[w]++；
else
PageCount[p]=1；
}
}
PageRate=1-((float)LackNum/(float)MaxNum);//算出命中率
OutPut()；} //近来最不惯用调度算法(LFU)
void LFU()
{
}
void NUR()
{
}
void YourChoice(int choice)
{
switch(choice)
{
case 1： cout<<"----------------------------------------------------------"<<endl；
cout<<"FIFO算法成果如下："<<endl；
FIFO() break；
case 2： cout<<"----------------------------------------------------------"<<endl；
cout<<"LRU算法成果如下："<<endl；
LRU()； break；
case 3： cout<<"----------------------------------------------------------"<<endl；
cout<<"LFU算法成果如下："<<endl；
//LFU()； break;
}
case 4： cout<<"----------------------------------------------------------"<<endl；
cout<<"NUR算法成果如下："<<endl； //NUR()； break；
case 5： break；
default：
cout<<"重新选取算法：1--FIFO 2--LRU 3--LFU 4--NUR 5--退出 "<<endl；
cin>>choice；
YourChoice(choice)；
}
}
void main()
{
int choice,i=1；
while(i)
{
cout<<"请选取算法：1--FIFO 2--LRU 3--LFU 4--NUR 5--退出 "<<endl；
cin>>choice；
if(choice==5)
{
i=0；
}
else
{
YourChoice(choice)；
}
}
}

实验成果

实验报告五、死锁避免
实验者：鞠智明 学号：10510116 班级：计科（1）班 实验时间12月
一、实验目：
在多道程序系统中，各种进程并发执行来改进系统资源运用率，提高系统吞吐量，但也许发生一种危险——死锁。所谓死锁(Deadlock)，是指各种进程在运营过程中因争夺资源而导致一种僵局（DeadlyEmbrace），当进程处在这种状态时，若无外力作用，她们都无法在向前推动。
咱们可以在分派资源时加上限制条件就可以防止死锁，但是，在每一种防止死锁办法之中，都施加了较强限制条件；而在避免死锁办法中，所施加限制条件较弱，有也许获得令人满意系统性能。
二、实验内容：
运用银行家算法来避免死锁发生
三、实验实现：
#include "string.h"
#include "iostream"
using namespace std；
#define FALSE 0
#define TRUE 1
#define W 10
#define R 20
int M ；//总进程数
int N ；//资源种类
int ALL_RESOURCE[W];//各种资源数目总和
int MAX[W][R]；//M个进程对N类资源最大资源需求量
int AVAILABLE[R]；//系统可用资源数
int ALLOCATION[W][R]；//M个进程已经得到N类资源资源量
int NEED[W][R]；//M个进程还需要N类资源资源量
int Request[R]；//祈求资源个数
void showdata()