操作系统上机实验报告

操作系统上机实验报告

实验一：

题目：N个进程的调度程序

算法：采用最高优先数优先的调度算法和先来先服务算法

具体要求：

1、为每个进程建立一个进程控制块(PCB)，信息包括：进

程名、优先数、到达时间、需要运行时间、已用CPU时

间、进程状态等；

2、进程的优先数及需要的运行时间可以事先人为地指定，进程到达时间为进程输入的时

间。进程的运行时间以时间片为单位进行计算，每个进程

的状态可以是就绪 W (Wait)、

运行R (Run)、或完成F (Finish)三种状态之一。

3、就绪进程获得CPU后都只能运行一个时间片，已运行时间加1来表示。如果运行一个

时间片后，进程的已运行时间已达到所需要的运行时间，则撤消该进程；如果运行一个时间片后进程的已占用CPU时间还未达所需要的运行时间，此时应将进程的优先数减1，然后把它插入就绪队列等待CPU。每进行一次调度程序都打印一次运行进程、就绪队列、以及各个进程的PCB，以便进行检查。重复以上过程，直到所要进程都完成为止

主要函数功能及实现方法：

1、void Pbuild()创建进程，提示要创建的进程数和输入进程PCB的有关信息。并且每创建好一个进程都调用void Sort()，将该进程插入到就绪队列的正确位置。

2、void Sort() 将新到的进程按优先级插入就绪队列，用一链表存放就绪队列，当链表为空时，则将链表头尾指针都指向该新到的进程。链表非空，则优先级最大者,插入队首；优先级最低的插入队尾，若需要插入到链表中间则从链表的第2项开始查找，当查到当前查找进程的优先级小于新到进程时，则将新进程插入到查找进程前面。

3、void Run()按要求3运行进程，且每运行一个时间片询问是否要加入新的进程。

4、void Display()打印进程运行信息。链表头表示正在运行的进程，第2项以后的都是就绪队列中的内容。

主要流程图：

1、void Pbuild()的流程图 main （）流程图：

Sort()的流程图：

Run （）的流程图：

开始

队列为空或者优先级 >队首？ N

Y

该进程作为队首

来了一个需要出入就绪队列的进程P

优先级小于队尾N

Y 该进程作为队尾

p1，p2分别指向队首和第2项

P2非空？ Y

P 优先级>p2?

N

P 插入到p2前面

Y

p1，p2后移

结束

输入需创建进程的条数

开始

输入一进程的PCB 信息

所有进程输入

结束

Y

N

开始

调用Pbuild()函数

调用Run()函数

结束

主要源代码：

void Pbuild() // 建立进程控制块函数 { int i,num;

cout<<"\nPlease input the number of progress : "; cin>>num;

for(i=0;i

of

progress

"<

cout<<"Progress name : "; cin>>p->pname;

开始

就绪队列为空？

结束

N

队首进程投入运行 时间片到，已运行时间加1

需加入新进程？

Y

调用函数Pbuild （）

运行时间到达所需时间

N

进程优先级减1，插入就绪队列

进程完成，撤消该进程

Y

打印运行信息

cout<<"Progress priority : ";

cin>>p->prior;

cout<<"Progress needtime : ";

cin>>p->needt;

p->runt=0;p->pstate='W'; p->arrivet=T;

p->next=NULL;

Sort(); //调用排序函数，将新来的进程按优先级插入就绪队列

} }

void Sort() //将进程按优先数从高到低排列{ PCB *p1,*p2;

if(head==NULL) //若队列为空则将新到达的进程作为队首

{ head=p;

tail=p; head->next=NULL; tail->next=NULL;

}

else if((head->prior)<(p->prior)) //优先级最大者,插入队首

{ p->next=head; head=p; }

else

if(head->next==NULL||p->prior<=tail->prior){//优先级最低的插入队尾

tail->next=p; tail=p;

tail->next=NULL; }

else //查找插入位置

{ p1=head; p2=head->next;

while(p2!=NULL) {

if(p->prior>p2->prior)

{ p->next=p2; p1->next=p; }

p1=p1->next; p2=p2->next;

} } }

void Run() //进程运行函数

{ p=head;

while(p!=NULL)

{ head=head->next; T++;

cout<<"\n-------------------------------------

------------------------";

cout<<"\nThe progress being run is :"<pname;

p->pstate='R';

cout<<"\n Name \t state \t prior\t needtime \t runtime \t arrivetime\n";

cout<pname<<"\t "<pstate<<"\t\t"

<prior<<" \t\t"<needt<<"

\t\t"<runt<<" \t\t"<arrivet<

Display();

p->runt++;

if(p->needt==p->runt) //进程完成，撤消进程 { cout<<"Progress "<pname<<" is finished!\n";

free(p); }

else{ p->prior--; p->pstate='W';

Sort();} //将该进程插入到就绪队列适当的位置

printf("\n----------------------------------------------------------------");

printf("\nTime up!Press 'y' to add new progress,any other key to continue……\n");

char a;

a=getchar();

if(a=='y') Pbuild();

p=head;

}}

运行结果：

实验二：

题目：设计一个请求页式存储管理方案，并编写模拟程序实现

具体要求：

1、产生一个需要访问的指令地址流，为不失一般性，可以适当地（用人工指定地方法或用随机数产生器）生成这个序列，使得50％的指令是顺序执行的。25％的指令均匀地散布在前地址部分，25％的地址是均匀地散布在后地址部分

页面淘汰算法采用 FIFO页面淘汰算法，并且在淘汰一页时，只将该页在页表中抹去。而不再判断它是否被改写过，也不

将它写回到辅存

3、产生一个需要访问的指令地址流；指定合适的页面尺寸（例如以1K或2K为1页；指定内存页表的最大长度，并对页表进行初始化

4、每访问一个地址时，首先要计算该地址所在的页的页号，然后查页表，判断该页是否在主存。如果该页已在主存，则打印页表情况；如果该页不在主存且页表未满，则调入一页并打印页表情况；如果该页不在主存且页表已满，则按 FIFO 页面淘汰算法淘汰一页后调入所需的页，打印页表情况。逐个地址访问，直到所有地址访问完毕

主要函数功能及实现方法：

void Display() 打印内存页表情况，即将链表中的内容输出。

void main() 产生随机的指令流，对页表初始化，并顺序访问该产生的指令流，

主要流程图：

主要源代码：

void main()

{ int ad,i,size,L,s=0,n,flag;

int A[Maxsize];

cout<<"请输入指令地址个数 : "; cin>>ad;

cout<<"\n随机产生指令地址流为 :\n";

A[0]=rand()%10+200000; cout<

for(i=1;i

{ A[i]=A[i-1]+M; cout<

{ A[i]=rand()%20000; cout<

{ A[i]=rand()%10+400000; cout<>L;

cout<<"\n请指定内存页表最大长度 : "; cin>>size; for(i=0;i

{ s++; flag=0; n=A[i]/L;

if(head==0)

{ p1=(paget*)malloc(sizeof(paget));

p1->p=n; p1->b=p1->p*1024;

p1->c=i; head=p1;

tail=p1; head->next=0;

tail->next=0;

}

else{

while(p1!=0)

{ if(n==p1->p) flag=1; p1=p1->next;

}

if(flag==0)

{ p1=(paget*)malloc(sizeof(paget));

p1->p=n; p1->b=p1->p*1024;

p1->c=i; tail->next=p1;

tail=p1; tail->next=0;

} } }

for(i=0;i

{ n=A[i]/L; flag=0;

cout<<"\n指令地址 "<

p1=head;

while(p1!=0)

{ if(n==p1->p) flag=1;

p1=p1->next;

}

if(flag==1) { cout<<"\n所访问页已经在内存中!"; Display(); }

else

if(s<=size)

{ cout<<"\n??该页不在内存中，且页表未满，直接调入所需页";

s++;

p1=(paget *)malloc(sizeof(paget));

p1->p=n; p1->b=p1->p*1024; p1->c=i;

tail->next=p1;

tail=p1;

tail->next=0;

Display();

}

else

{ cout<<"\n?该页不在内存中，且页表已满，须进行页面置换！";

head->p=n; head->b=n*1024;

tail->next=head; tail=head;

head=head->next; tail->next=0;

Display();

}

}

cout<<"\n所有指令地址已经访问完毕!\n";

}

运行结果：

实验三：

题目：银行家算法

具体要求：屏幕提示：输入申请资源的进程和各资源数目，程序通过对预先输入的资源的矩阵分析。给出当前系统是否安全的提示，若安全，给出安全序列。

主要函数功能及实现方法：

void inition() 从文件中读入各进程对每类资源的最大需求和已分配的资源数目，并求出还需要分配的资源数目。并调用Display()函数打印当前资源信息供用户申请资源参考。void Display()打印资源分配表和系统当前的还可供分配的

资源数目。

int compare(int x[max],int y[max]) 比较两个数组对应的元素，当有x[i]>y[i]时返回0，否则返回1。

void arrayadd(int x[max],int y[max]) 数组相加函数，执行x[i]=x[i]+y[i]操作。

void arraysub(int x[max],int y[max]) 数组相减函数，执行x[i]=x[i]-y[i]操作。

int Safecheck() 安全检查函数，检查一次分配是否存在安全序列。存在返回1，不存在则返回0

int SAsign(int Req[max],int h) 资源分配函数。compare(Req,Need[h]为0表示申请资源出错，因为申请的资源数目已超过其最大需要。compare(Req,Available)为0表示申请的资源数目超出系统的可分配资源。若不是以上的两种情况则尝试分配资源并调用int Safecheck() 安全检查函数检查此次资源分配是否安全。

主要流程图：

int Safecheck()的流程图： int SAsign(int Req[max],int h)的流程图：

主要源代码：

void inition()//从文件中读入资源状况 { int i,j; FILE *fp;

fp=fopen("1.txt","r+"); fscanf(fp,"%d",&N); fscanf(fp,"%d",&M); for(i=0;i

{fscanf(fp,"%d,%d,%d,%d,%d,%d,%d\n",&Pname[i],&Ma x[i][0],&Max[i][1],&Max[i][2],&Allocation[i][0],&Al location[i][1],&Allocation[i][2] ); for(j=0;j

Need[i][j]=Max[i][j]-Allocation[i][j];

for(i=0;i

fscanf(fp,"%d",&Available[i]);

Display();

}

int Safecheck()//安全检查函数

{

int Work[max],num=0,i,flag;

bool Finish[max];

for(i=0;i

Work[i]=Available[i];

for(i=0;i

Finish[i]=false;

L: for(i=0;i

{ flag=0;

if(Finish[i]==false&&compare(Need[i],Work)) {

arrayadd(Work,Allocation[i]);

Finish[i]=true;

Xulie[num++]=Pname[i]; flag=1;

}