报告封面

测量实习报告

姓名

班级学号

指导教师

2015年01月12日

实验一进程管理

1. 目的和要求

加强对进程概念的理解。

2. 实验内容

至少包括：创建新的进程，查看运行进程，换出某个进程，强制暂停运行进程，以及进程之间通信等功能。

3. 实验环境

PC、Windows、TC语言

4. 实验提示

PCB结构通常包括以下信息；进程名，进程优先级，轮转时间片，进程所占用的CPU 时间，进程的状态，当前队列指针等。根据实验的不同，可对PCB结构的内容做适量增删。

5. 主体程序

#include "stdio.h"

#include "stdlib.h"

#include "string.h"

struct process_type

{

int pcbid;

int priorityNum;

int daxiao;

char xiaoxi[100];

};

struct process_type zhucun[20];

int shumu=0,pcbid_1=0;

void create() /*创建一个进程的示例*/

{

if(shumu>=20)

{

printf("\n内存已满，请先结束或换出进程");

}

else

{

printf("请输入新的进程pcbid:");

scanf("%d",&zhucun[shumu].pcbid);

printf("请输入新进程的优先级:");

scanf("%d",&zhucun[shumu].priorityNum);

printf("请输入新进程的大小:");

scanf("%d",&zhucun[shumu].daxiao);

printf("请输入新进程的消息:");

scanf("%s",&zhucun[shumu].xiaoxi);

shumu++;

}

}

void clrscr() /*清屏*/

{

system("cls");

}

void run()

{

if(shumu==0)

printf("当前没有进程运行\n");

else

{

printf("当前运行进程的情况为\n");

printf("\t进程标识符:%d\n",zhucun[pcbid_1].pcbid);

printf("\t优先级:%d\n",zhucun[pcbid_1].priorityNum);

printf("\t大小:%d\n",zhucun[pcbid_1].daxiao);

printf("\t消息:%s\n",zhucun[pcbid_1].xiaoxi);

}

}

void kill() /*终止进程*/

{

if(shumu==0)

printf("当前没有进程运行\n");

else

{

int i;

for(i=shumu-1;i>pcbid_1;i--)

{

zhucun[i-1].pcbid=zhucun[i].pcbid;

zhucun[i-1].priorityNum=zhucun[i].priorityNum;

zhucun[i-1].daxiao=zhucun[i].daxiao;

strcpy(zhucun[i-1].xiaoxi,zhucun[i].xiaoxi);

}

shumu--;

}

}

int xunzhao(int pcbid)

{

int i;

for(i=0;i

{

if(zhucun[i].pcbid==pcbid)

return i;

}

return -1;

}

void tongxun() /*进程间通信*/

{

int fasong,jieshou;

int i,j;

printf("请输入发送信息的进程编号:");

scanf("%d",&fasong);

if((i=xunzhao(fasong))==-1)

{

printf("该进程编号不存在\n");

return;

}

printf("请输入接受信息的进程编号:");

scanf("%d",&jieshou);

if((j=xunzhao(jieshou))==-1)

{

printf("该进程编号不存在\n");

return;

}

strcpy(zhucun[j].xiaoxi,zhucun[i].xiaoxi);

}

void chakan() /*查看当前所有进程运行状况*/

{

int i;

if(shumu==0)

printf("当前没有进程运行\n");

else

printf("pcbid 优先级大小消息\n");

for(i=0;i

{

printf("%-8d",zhucun[i].pcbid);

printf("%-10d",zhucun[i].priorityNum);

printf("%-9d",zhucun[i].daxiao);

printf("%s",zhucun[i].xiaoxi);

printf("\n");

}

}

void ShowMenu() /*显示屏幕菜单*/

{

printf("\n 进程演示系统\n");

printf("\n 1.创建新进程 2.查看运行进程\n");

printf("\n 3.查看所有进程 4.终止所有进程\n");

printf("\n 5.进程之间通信 6.退出系统\n");

printf("请选择(1~6):");

}

void main() /*主程序*/

{

char c;

clrscr();

while(1)

{

ShowMenu();

fflush(stdin); //清空缓存

c=getchar();

switch(c)

{

case '1':

create();

break;

case '2':

run();

break;

case '3':

chakan();

break;

case '4':

kill();

break;

case '5':

tongxun();

break;

case '6':

exit(0);

}

}

}

结果如下：

实验二进程调度算法

1. 目的和要求

通过程序设计语言来模拟处理机管理中几种常见进程调度算法。

2. 实验内容

（1）时间片轮转调度算法：所有就绪队列按照先来先服务的原则，排成一个队列，每次调度时，分配CPU给队首进程，并令其执行一个时间片，当时间片用完时，停止该进程的执行，并将它送入就绪队列的末尾等待下一个时间片的到来，然后把CPU分配给下一个队首进程。

（2）先来先服务调度算法：该算法总是从后备队列中选择一个或者多个最先进入该队列的作业，将其调入内存，为它们分配资源、创建进程，然后放入就绪队列中。

3. 实验环境

PC、Windows、TC语言

4. 主体程序

#include

#include

#include

#include

#include

#include

enum STATUS{RUN,READY,WAIT,FINISH};

struct PCBNode

{

int processID; //进程ID

enum STATUS status;

int priorityNum; //优先级

int reqTime; //总的需要运行时间

int remainTime; //剩下需要运行时

int arriveTime; //进入就绪队列时

int startTime; //开始运行时间

int finishTime; //结束运行时间

int totalTime; //周转时间

float weightTotalTime; //带权周转时间

};

struct QueueNode

{ int ID; //进程ID

struct QueueNode * next; //队列中下一个进程指针

};

struct LinkQueue

{

struct QueueNode * head; //队首

};

void Fcfs(LinkQueue& Q,int& totalTimeSum,int& weightTotalTimeSum,PCBNode* ProcessTable)

{

totalTimeSum=0;

weightTotalTimeSum=0; //平均周转时间

struct QueueNode * p;

struct QueueNode * q;

p=Q.head->next;

if (p!=NULL)

{

ProcessTable[p->ID].startTime=ProcessTable[p->ID].arriveTime;

ProcessTable[p->ID].finishTime=ProcessTable[p-

>ID].arriveTime+ProcessTable[p->ID].reqTime;

}

for(q=p->next;q!=NULL;q=q->next)

{

if (ProcessTable[q->ID].arriveTimeID].finishTime)

{

ProcessTable[q->ID].startTime=ProcessTable[p->ID].finishTime;

ProcessTable[q->ID].finishTime=ProcessTable[p-

>ID].finishTime+ProcessTable[q->ID].reqTime;

}

p=q;

}

for(q=Q.head->next;q!=NULL;q=q->next)

{

ProcessTable[q->ID].totalTime=ProcessTable[q->ID].finishTime-

ProcessTable[q->ID].arriveTime;

ProcessTable[q->ID].weightTotalTime=ProcessTable[q-

>ID].totalTime/ProcessTable[q->ID].reqTime;

totalTimeSum+=ProcessTable[q->ID].totalTime;

weightTotalTimeSum+=ProcessTable[q->ID].weightTotalTime;

}

int t=0;

for(q=Q.head->next;q!=NULL;q=q->next)

{

cout <<"***********************"<

while(tID].finishTime)

{

cout <<"时刻"<ID<<"活动"<

t++;

}

if(q->next!=NULL)

{

cout<<"时刻"<ID<<"结束活动，开始下一个进程."<

cout<<"进程"<ID<<"的周转时间为："<ID].totalTime<ID<<"的带权周转时间为："<ID].weightTotalTime<

}

else

{

cout <<"时刻"<ID<<"结束活动."<

cout<<"进程"<ID<<"的周转时间为："<ID].totalTime<ID<<"的带权周转时间为："<ID].weightTotalTime<

}

}

cout<<"所有进程结束活动."<

p=Q.head;

for(q=p->next;q!=NULL;q=q->next)

{

delete p;

p=q;

}

}

bool RR_Run(LinkQueue& Q,QueueNode* q,QueueNode* p,const int Round,int& currentTime,PCBNode* ProcessTable)

{

if(ProcessTable[q->ID].remainTime<=Round)

//在此时间片内能够执行完毕之后退出进程调度

{

ProcessTable[q->ID].finishTime=currentTime+ProcessTable[q->ID].remainTime; ProcessTable[q->ID].totalTime+=ProcessTable[q->ID].remainTime;

ProcessTable[q->ID].weightTotalTime=ProcessTable[q-

>ID].totalTime/ProcessTable[q->ID].reqTime;

currentTime=ProcessTable[q->ID].finishTime;

p->next=q->next;

cout<

cout<<"进程"<ID<<"完成！"<

return true;

}

else //此时间片内进程执行不完

{

ProcessTable[q->ID].remainTime=ProcessTable[q->ID].remainTime-Round;

ProcessTable[q->ID].totalTime+=Round;

currentTime+=Round;

return 0;

}

}

void RoundRobin(LinkQueue &Q,const int Round,int &totalTimeSum,int &weightTotalTimeSum,PCBNode * ProcessTable)

{

totalTimeSum=0; //总的周转时间

weightTotalTimeSum=0; //平均周转时间

int currentTime=0; //当前时间

QueueNode * p;

QueueNode * q;

QueueNode * r;

bool finish=false; //调用RR_Run后,该进程是否已经执行结束并退出

p=Q.head;

q=p->next;

while(q!=NULL) //从队首开始依次分配时间片

{

do

{

cout<<"*****************"<

cout<<"在时间片"<<(currentTime+1)/Round<<"内,活动进程为:"<ID<ID<<"现在需要的时间片" <ID].remainTime<

finish=RR_Run(Q,q,p,Round,currentTime,ProcessTable);

// 分配时间片给q进程

cout<

if(!finish) //若进程在本时间片内做完，则跳出do...while循环

{

if(q->next==NULL)

{

r=Q.head->next;

}

else

{

r=q->next;

}

}

else //否则计算周转时间和带权周转时间

{

totalTimeSum+=ProcessTable[q->ID].totalTime;

weightTotalTimeSum+=ProcessTable[q->ID].weightTotalTime;

delete q; //从队列中删除q进程

q=p;

}

}while(!finish &&(ProcessTable[r->ID].arriveTime>currentTime+Round)); //下一个进程很晚才进入队列，则继续给当前进程分配时间片

p=q;

q=q->next;

if(q==NULL && Q.head->next!=NULL)

{

p=Q.head;

q=p->next;

}

delete Q.head;

Q.head=NULL;

}

}

void InitialQueue(LinkQueue& Q,PCBNode * ProcessTable,const int processnum) {

//初始化

int i;

for(i=0;i

{

ProcessTable[i].processID=i;

ProcessTable[i].reqTime=ProcessTable[i].remainTime;

ProcessTable[i].finishTime=0;

ProcessTable[i].startTime=0;

ProcessTable[i].status=WAIT;

ProcessTable[i].totalTime=0;

ProcessTable[i].weightTotalTime=0;

}

Q.head=new QueueNode;

Q.head->next=NULL;

QueueNode * p;

QueueNode * q;

for (i=0;i

{

p=new QueueNode;

p->ID=i;

p->next=NULL;

if(i==0)

{

Q.head->next=p;

q=p;

}

}

}

void Input(PCBNode * ProcessTable,const int processnum)

{

FILE * fp;

//读入线程的相关内容

if((fp=fopen("D:\\input.txt","r"))==NULL)

{

cout<<"can not open file!"<

exit(0);

}

for(int i=0;i

{

fscanf(fp,"%d%d %d",&ProcessTable[i].arriveTime,&ProcessTable[i].remainTime,&P rocessTable[i].priorityNum);

}

fclose(fp);

}

int main()

{

LinkQueue Q;

Q.head=NULL;

const int processnum=2; //进程数

const int Round=1; //时间片大小

int totalTimeSum=0; //周转时间

int WeightTotalTimeSum=0; //带权周转时间

PCBNode * ProcessTable=new PCBNode[processnum]; //进程表

Input (ProcessTable,processnum);

InitialQueue(Q,ProcessTable,processnum);

RoundRobin(Q,Round,totalTimeSum,WeightTotalTimeSum,ProcessTable);

cout <<"时间片轮转调度的平均周转时间为："<

Input(ProcessTable,processnum);

InitialQueue(Q,ProcessTable,processnum);

Fcfs(Q,totalTimeSum,WeightTotalTimeSum,ProcessTable);

cout <<"先来先服务的平均周转时间为："<

cout <<"先来先服务的带权平均周转时间为："<

delete[] ProcessTable;

return 0;

}

实验结果如下：

实验三存储管理

1. 目的和要求

通过程序设计语言来模拟请求页式存储管理中几种页面置换算法。

2. 实验内容

（1）Optimal算法：最佳置换算法，其所选择的被淘汰页面，将是以后永不使用的页面，或是在最长（未来）时间内不再被访问的页面。

（2）FIFO算法：先进先出置换算法，该算法总是淘汰最先进入内存的页面，即选择在内存中驻留时间最久的页面予以淘汰。

（3）LRU算法：最近最久未使用置换算法，该算法赋予每个页面一个访问字段，用来记录一个页面自上次被访问以来所经历的时间T，当须淘汰一个页面时，选择现有页面中T 值最大的页面给予淘汰。

3. 实验环境

PC、Windows、TC语言

4. 主体程序

#include "iostream.h"

#define Bsize 3

#define Psize 20

struct pageInfor

{

int content;

int timer;

};

class PRA

{

public:

PRA(void);

int findSpace(void);

int findExist(int curpage);

int findReplace(void);

void display(void);

void FIFO(void);

void LRU(void);

void Optimal(void);

void BlockClear();

pageInfor * block;

pageInfor * page;

};

PRA::PRA(void)

{

int QString[20]={4,0,3,2,1,5,8,4,2,3,0,3,2,1,6,8,9,7,0,1};

block=new pageInfor[Bsize];

for(int i=0;i

{

block[i].content=-1;

block[i].timer=0;

}

page=new pageInfor[Psize];

for(int j=0;j

{

page[j].content=QString[j];

page[j].timer=0;

}

}

int PRA::findSpace(void)

{

for(int i=0;i

if(block[i].content==-1)

return i;

return -1;

}

int PRA::findExist(int curpage)

{

for(int i=0;i

{

if(block[i].content==page[curpage].content)

return i;

return -1;

}

}

int PRA::findReplace(void)

{

int pos=0;

for(int i=0;i

if(block[i].timer>=block[pos].timer)

pos=i;

return pos;

}

void PRA::display(void)

{

for(int i=0;i

if(block[i].content!=-1)

cout<

cout<

}

void PRA::Optimal(void)

{

int exist,space,position;

for(int i=0;i

{

exist=findExist(i);

if(exist!=-1)

{

cout<<"不缺页"<

}

else

{

space=findSpace();

if(space!=-1)

{

block[space].content=page[i].content;

block[space].timer=page[i].timer;

display();

}

else

{

for(int k=0;k

for(int j=0;j

{

if(block[k].content!=page[j].content)

{

block[k].timer=1000;

}

else

{

block[k].timer=j;

break;

}

}

position=findReplace();

block[position].content=page[i].content;

block[position].timer=page[i].timer;

display();

}

}

}

}

void PRA::LRU(void)

{

int exist,space,position;

for(int i=0;i

{

exist=findExist(i);

if(exist!=-1)

{

cout<<"不缺页"<

block[exist].timer=-1;

}

else

{

space=findSpace();

if(space!=-1)

{

block[space].content=page[i].content;

block[space].timer=page[i].timer;

display();

}

else

{

position=findReplace();

block[position].content=page[i].content;

block[position].timer=page[i].timer;

display();

}

}

for(int j=0;j

block[j].timer++;

}

}

void PRA::FIFO(void)

{

int exist,position,space;

for(int i=0;i

{

exist=findExist(i);

if(exist!=-1)

{

cout<<"不缺页"<

}

else

{

space=findSpace();

if(space!=-1)

{

block[space].content=page[i].content;

block[space].timer=page[i].timer;

display();

}

else

{

position=findReplace();

block[position].content=page[i].content;

block[position].timer=page[i].timer;

display();

}

}

for(int j=0;j

{

block[j].timer++;

}

}

}

void PRA::BlockClear()

{

for(int i=0;i

{

block->content=-1;

block->timer=0;

}

}

int main(void)

{

cout<<"---------------------页面置换算法----------------------"<

cout<<"页面号引用串:4,0,3,2,1,5,8,4,2,3,0,3,2,1,6,8,9,7,0,1"<

cout<<"选择<1>引用FIFO算法"<

cout<<"选择<2>引用Optimal算法"<

cout<<"选择<3>引用LRU算法"<

cout<<"选择<0>退出"<

int select;

PRA test;

while(1)

{

cin>>select;

switch(select)

{

case 0:

return 0;

case 1:

cout<<"FIFO算法结果如下:"<

test.FIFO();

test.BlockClear();

cout<<"--------------------------------"<

break;

case 2:

cout<<"Optimal算法结果如下:"<

test.Optimal();

test.BlockClear();

cout<<"--------------------------------"<

break;

case 3:

cout<<"LRU算法结果如下:"<

test.LRU();

test.BlockClear();

cout<<"--------------------------------"<

break;

default:

cout<<"请正确输入功能号:"<

break;

}

}

return 0;

}

实验结果如下：