操作系统实验八综合实验代码

#pragma warning (disable:4786)
#include
#include
#include
#include
#include

定义
typedef struct page_clock
{
int num;
int visit;
}Page_clock;
//用于改进的CLOCK 算法的页面定义
typedef struct page
{
int num; //页面号
int visit; //是否访问
int modify; //是否修改
}Page;
Page_clock b_clock[M]; //内存单元数 Clock
Page b[M]; //updating_clock
int opt[M]; //opt
int ran[M]; //random replacement
int fifo[M]; //FIFO
int c[M][N]; //存储每个阶段状态
//访问序列随机生成e 个，e 是工作集中包含的页数，m 是工作集移动率
void generate_list(int *list, int e, int m, int t)
{
int i, j = 0, q =P, r;
srand((unsigned)time(NULL));
while (j < e)
{
for (i = j;i < j + m;i++)
{
if (i == e)
break;
list[i] = (q + rand() % e) % N; /*保证在虚拟内存的页号内*/
}
j = i;
r = rand() % 100;
if (r < t)
q = rand() % N;
else
q = (q + 1) % N;
}
}
//随机生产是否被修改的情况，prop(0...100)，prop/100 的概率未被修改
void generate_modify(int *mo, int e, int prop)
{
int i, t;
for (i = 0;i < e;i++)
{
t = rand() % 100;
if (t > prop)
mo[i] = 0;
else
mo[i] = 1;
}
}
//格式输出
void print_format(int e)
{
int i;
printf(" ");
for (i = 1;i < e;i++)
printf(" ");
printf(" \n");
}
//结果输出
void print(int e,int *a)
{
int j, i;
print_format(e);
for(j = 0;j < e;j++)
{
printf(" %2d ",a[j]); //读入内存顺序
}
printf(" \n");
printf("置换过程：");
print_format(e);
for(i = 0;i < M;i++)
{
for(j = 0;j < e;j++)
{
if(c[i][j] == -1)
printf(" %c ",' ');
else
printf(" %2d ",c[i][j]);
}
printf(" \n");
}
print_format(e);
}
//Clock 算法初始化
void Init_Clock(Page_clock *b_clock)
{
nin = 0;
int i, j;
for(i = 0;i < M;i++)
{
b_clock[i].num = -1;
b_clock[i].visit = 0;
}
for(i = 0;i < M;i++)
{
for(j = 0;j < N;j++)
{
c[i][j] = -1;
}
}
}
//改进的Clock 算法初始化
void Init_updatingClock(Page *b)
{
nin = 0;
int i, j;
for(i = 0;i < M;i++)
{
b[i].num = -1;
b[i].visit = 0;
b[i].modify = 0;
}
for(i = 0;i < M;i++)
{
for(j = 0;j < N;j++)
{
c[i][j] = -1;
}
}
}
//Clock 算法
void Clock(int fold,Page_clock *b_clock)
{
int i, val = -1, p = 0; //p 为查询指针
for (i = 0;i < M;i++)
{
if (fold == b_clock[i].num)
val = i;
}
//页面在内存中
if (val >= 0)
{
b_clock[val].visit = 1;
for(i = 0;i < M;i++)
{
if (i != val)
{
b_clock[i].visit = 0;
}
}
}
else
{
nin++;
//初始化内存
for (i = 0;i < M;i++)
{
if (b_clock[i].num == -1)
{
val = i;
break;
}
}
while (val < 0)
{
if (b_clock[p].visit == 0)
val = p;
else
b_clock[p].visit = 0;
p = (p + 1) % M;
}
b_clock[val].num = fold;
b_clock[val].visit = 1;
for(i = 0;i < M;i++)
{
if (i != val)
{
b_clock[i].visit = 0;
}
}
}
}
//改

进的Clock 算法
void Updating_Clock(int fold,int modiff, Page *b)
{ int i, p = -1; //p 是查询指针
int val = -1;
//找是否在内存中
for(i = 0;i < M;i++)
{
if (fold == b[i].num)
val = i;
}
if (val >= 0)
{
b[val].visit = 1; //被访问
b[val].modify = modiff;
for(i = 0;i < M;i++)
{
if (i != val)
{
b[i].visit = 0;
}
}
}
else
{
nin++;
//初始化内存
for (i = 0;i < M;i++)
{
if (b[i].num == -1)
{
val = i;
break;
}
}
while (val < 0)
{
//第一步扫描
for (i = 0;i < M;i++)
{
p = (p + 1) % M;
if ((b[p].modify == 0) && (b[p].visit == 0))
{
val = p;
break;
}
}
//第二步扫描
if (val < 0)
{
for (i = 0;i < M;i++)
{
p = (p + 1) % M;
if ((b[p].modify == 1) && (b[p].visit == 0))
{
val = p;
break;
}
else
{
b[p].visit = 0;
}
}
}
}
//找到后，其他设置为未访问
b[val].num = fold;
b[val].modify = modiff;
b[val].visit = 1;
for(i = 0;i < M;i++)
{
if (i != val)
{
b[i].visit = 0;
}
}
}
}
void Clock()
{
int a[N];
int mo[N];
int i,j;
//产生随机访问串及是否修改串
P = 1;
int e, m, prop, t;
printf("请输入工作集中包含的页数e 和工作集移动率m:\n");
scanf("%d %d",&e,&m);
t = 50;
generate_list(a, e, m, t);
printf("请输入页面被修改的概率(*100):\n");
scanf("%d",&prop);
generate_modify(mo, e, prop);
//Clock 算法实现
Init_Clock(b_clock);
for(i = 0;i < e;i++)
{
Clock(a[i],b_clock);
for(j = 0;j < M;j++)
{
c[j][i] = b_clock[j].num;
}
}
printf("Clock 算法的内存状态为：\n");
print(e, a);
nin = nin - M;
printf("缺页次数为：%d\n 缺页率：%.2f\n",nin,nin * 1.0 / e);
printf("\n");
//改进的Clock 算法实现
Init_updatingClock(b);
for(i = 0;i < e;i++)
{
Updating_Clock(a[i], mo[i], b);
for(j = 0;j < M;j++)
{
c[j][i] = b[j].num;
}
}
printf("改进的Clock 算法的内存状态为：\n");
print(e, a);
for(j = 0;j < e;j++)
{
printf(" %2d ",mo[j]); //是否修改序列串
}
printf(" \n");
print_format(e);
nin = nin - M;
printf("缺页次数为：%d\n 缺页率：%.2f\n",nin,nin * 1.0 / e);
printf("\n");
}
void M_clock()
{
int a[N];
int mo[N];
int i,j;
//产生随机访问串及是否修改串
P = 1;
int e, m, prop, t;
printf("请输入工作集中包含的页数e 和工作集移动率m:\n");
scanf("%d %d",&e,&m);
t = 50;
generate_list(a, e, m, t);
printf("请输入页面被修改的概率(*100):\n");
scanf("%d",&prop);
generate_modify(mo, e, prop);
//Clock 算法实现
Init_Clock(b_clock);
for(i = 0;i < e;i++)
{
Clock(a[i],b_clock);
for(j = 0;j < M;j++)
{
c[j][i] = b_clock[j].num;
}
}
printf("Clock 算法的内存状态为：\n");
print(e, a);
nin = nin - M;
printf("缺页次数为：%d\n 缺页率：%.2f\n",nin,nin * 1

.0 / e);
printf("\n");
//改进的Clock 算法实现
Init_updatingClock(b);
for(i = 0;i < e;i++)
{
Updating_Clock(a[i], mo[i], b);
for(j = 0;j < M;j++)
{
c[j][i] = b[j].num;
}
}
printf("改进的Clock 算法的内存状态为：\n");
print(e, a);
for(j = 0;j < e;j++)
{
printf(" %2d ",mo[j]); //是否修改序列串
}
printf(" \n");
print_format(e);
nin = nin - M;
printf("缺页次数为：%d\n 缺页率：%.2f\n",nin,nin * 1.0 / e);
printf("\n");
}
//fcfs*************************************************************
class node
{
public:
int name;
int arrtime;//到达时间
//int round;
//int cputime;
int needtime;//服务时间
//int count;
//char state;
node& operator= (const node& s);
bool operator<(const node &t) const
{
if (arrtime!= t.arrtime)
return arrtime < t.arrtime;
else
return false;
}
}PCB;
node& node::operator= (const node& s)
{
name=https://www.360docs.net/doc/001435259.html, ;
arrtime=s.arrtime;
needtime=s.needtime;
return *this;
}
class MinHeap
{
private:
node *heapArray;//存放堆数据的数组
int CurrentSize; //当前堆中元素的数目
int MaxSize; //堆所能容纳的最大元素数目
void swap(int pos_x,int pos_y); //交换位置 x 和y
void BuildHeap(); //创建堆
public:
MinHeap(node arr[], int n);
MinHeap(int n);//构造函数，表示初始化堆的最大元素数目
~MinHeap(){delete [] heapArray;}
bool isLeaf(int pos); //如果是叶节点返回 true
int leftchild(int pos);//返回左儿子的位置
int rightchild(int pos); //返回右儿子的位置
int parent(int pos); //返回父节点的位置
bool Remove(int pos, node & node);//删除指定下标的元素
bool Insert(node & newNode); //向堆中插入新元素newNode
node & RemoveMin(); //从堆顶删除最小值
void SiftUp(int position); //从position 向上开始调整，使序列成为堆
void SiftDown(int parent); //筛选法函数，参数left 表示开始处理的数组下标
void scanHeap(); //浏览最小堆中的元素
};
//构造函数
MinHeap::MinHeap(int n)
{
while(n<=0)
{
cout<<"输入错误,重输：";
cin>>n;
cout<}
CurrentSize=0;
MaxSize=n; //初始化堆容量
heapArray=new node[MaxSize]; //创建堆空间
BuildHeap();
}
MinHeap::MinHeap(node arr[], int n)
{
MaxSize = n;
CurrentSize = n;
heapArray = arr;
int currentPos = (n-1)/2;//currentPos为CurrentSize的父节点位置
while(currentPos>=0)//当currentPos不为根节点时循环
{
SiftDown(currentPos);//从currentPos处向下调整堆
currentPos--;
}
}
//判断指定位置的元素是否为叶子
bool MinHeap::isLeaf(int pos)
{
return(pos>=CurrentSize/2)&&(pos}
//交换堆顶和最后一个元素
void MinHeap::swap(

int pos_x, int pos_y)
{
node temp=heapArray[pos_x];
heapArray[pos_x]=heapArray[pos_y];
heapArray[pos_y]=temp;
}
//创建最小堆
void MinHeap::BuildHeap()
{
for(int i=CurrentSize/2-1;i>=0;i--) //反复调用筛选函数
SiftDown(i);
}
//返回左儿子的位置
int MinHeap::leftchild(int pos)//左儿子在pos的
{
return 2*pos+1;
}
//返回右儿子的位置
int MinHeap::rightchild(int pos)
{
return 2*pos+2;
}
//返回父节点的位置
int MinHeap::parent(int pos)
{
return (pos-1)/2;
}
//向堆中插入新元素 newNode
bool MinHeap::Insert(node &newNode)
{
if(CurrentSize==MaxSize)
return false;
heapArray[CurrentSize]=newNode;
SiftUp(CurrentSize);
CurrentSize++;
return true;
}
//从position 向上开始调整，使序列成为堆
void MinHeap::SiftUp(int position)
{
int temppos=position; //存储现在的位置
node temp=heapArray[temppos]; //获得现在位置元素的值
//现在位置大于0 并且该元素的值小于其父节点
while((temppos>0)&&( temp{
heapArray[temppos]=heapArray[parent(temppos)]; //将父节点值赋值给该结点
temppos=parent(temppos); //将现在位置指向父节点位置
}
heapArray[temppos]=temp; //最后的父节点位置的值为temp
}
//从parent位置向下调整堆
void MinHeap::SiftDown(int parent)
{
int i=parent;//标识父节点
int j=leftchild(i); //标志左孩子
node temp=heapArray[i];//temp存储父节点的值
while(j{
//如果左儿子的下标小于当前位置下标并且右儿子小于左孩子
if((jj++; //指向右儿子
if(heapArray[j]{
heapArray[i]=heapArray[j];//把右孩子的值赋予其父节点
i=j;//标记下一层父节点
j=leftchild(j);//继续找再下一层的左孩子
}
else
break;
}
heapArray[i]=temp;//把原父节点的值赋予其右孩子
}
//从堆顶删除最小值
node & MinHeap::RemoveMin()
{
/* if(CurrentSize==0) //堆中没有元素退出
{
cout<<"无进程"<exit(1);
}*/
swap(0,--CurrentSize);//交换堆顶和最后一个元素同时堆的现有大小减去 1
if(CurrentSize>1)
SiftDown(0); //从堆顶开始向下筛选
return heapArray[CurrentSize]; //返回最后
}
//删除给定下标的元素
bool MinHeap::Remove(int pos, node & nod)
{
if((pos<0)||(pos>=CurrentSize)) //如果下标越界返回 false
return false;
node temp = heapArray[pos]; //暂存要删除的元素值
heapArray[pos]=heapArray[--CurrentSize]; //将最后一个元素放在要删除的元素的位置上
SiftUp(pos);
SiftDown(pos);
nod=temp;

return true;
}
//浏览最小堆中的所有元素
void MinHeap::scanHeap()
{
cout<<"进程名称"<<" "<<"到达时间:"<<" "<<"需要时间:"<for(int i=0;i{
cout<<<}
}
void FCFS()
{
node *heap2,temp;
int i,n,time=0,arrtime;
char flag='y',aFlag;
int name;
while(flag=='y'||flag=='Y')
{
cout<<"输入进程数：";
cin>>n;
heap2 = new node[n];
for(i=0;i{
cout<<"ID\\arrivetime\\needtime：";
cin>>heap2[i].name;
cin>>heap2[i].arrtime;
cin>>heap2[i].needtime;
}
MinHeap heap(heap2,n);
heap.scanHeap();
for(i=0;i{
temp=heap.RemoveMin();
cout<<"时间:"<time+=temp.needtime;
}
cout <<"是否改变到达时间:";
cin>>aFlag;
while(aFlag=='y'||aFlag=='Y')
{
cout<<"输入要改变到达时间的进程号、到达时间：";
cin>>name;
cin>>arrtime;
for(i=0;i{
if(heap2[i].name==name)
{
heap2[i].arrtime=arrtime;
break;
}
}
cout<<"是否继续改变到达时间:";
cin>>aFlag;
}
if(i)
{
MinHeap heap1(heap2,n);
heap1.scanHeap();
for(i=0;i{
temp=heap1.RemoveMin();
cout<<"时间:"<time+=temp.needtime;
}
}
cout<<"是否继续:";
cin>>flag;
}
}
//deletepc*********************************************************************
pnode *proot; //system process tree root
pnode *plink; //system process link head
void deletepc(pnode *parent,pnode *currect)
{
if (currect->sub==NULL) //判断当前节点是否有子进程

{
if(parent->sub==currect)//如果父节点指向的子进程是当前要删除的节点
{
parent->sub=currect->brother;//将sub指针指向删除节点的兄弟节点
}
else
{
//如果父节点的子节点为删除节点的兄弟节点，把当前节点的兄弟节点重置
for (pnode *p=parent->sub;p->brother!=currect;p=p->brother)
p->brother=currect->brother;
}
pnode *tempperent;
for (tempperent=plink;tempperent;tempperent=tempperent->next)

{
//找到要删除的节点，把此节点前的节点next指针指向删除节点的后一个节点
if (tempperent->next->node->pid==currect->node->pid)
{
tempperent->next=tempperent->next->next;
break;
}
}
}
else
{
deletepc(currect,currect->sub);//如果

删除的节点，有子节点继续调用
deletepc(parent,currect);
}
}
int createpc(int *para) //create process
{
//add your code here
pnode *p,*p1,*pp;
int pflag;//用于标记父进程是否存在
pflag=0;
for(p=plink;p;p=p->next)
{
if(p->node->pid == para[0]) //判断要创建的进程是否存在
{
printf("pid %d is already exist!\n",para[0]);
return -1;
}
if(p->node->pid == para[1]) //判断要创建的进程是否为父进程
{
pflag=1;
pp = p;
}
}
if(!pflag)
{
printf("parent id %d is not exist!\n",para[1]);
return -2;
}
//init new pcb
p1 = new pnode;
p1->node=new pcb;
p1->node->pid = para[0];
p1->node->ppid = para[1];
p1->node->prio = para[2];
p1->sub=NULL;
p1->next=NULL;
p1->brother=NULL;
//如果当前节点没有子进程，新的进程就作为父进程的子进程
if(!pp->sub)
pp->sub=p1;
else
{
//如果有，便作为兄弟节点
for(p=pp->sub;p->brother;p=p->brother);
p->brother=p1;
}
// 添加至链表
for(p=plink;p->next;p=p->next);
p->next=p1;
return 0;
}
//show process detail
void showdetail()
{
pnode *p,*p1;
p=plink;
for(;p;) //P节点不为空时，跳到下一个节点
{
printf("%d(prio %d): ",p->node->pid,p->node->prio);
p1 = p->sub;
for(;p1;) //显示父进程的子进程信息
{
printf("%d(prio %d) ",p1->node->pid,p1->node->prio);
p1 = p1->brother;
}
printf("\n");
p = p->next;
}
printf("\n");
}
void Del()
{
initerror();
short cflag,pflag;
char cmdstr[32];
proot = new pnode;
proot->node=new pcb;
proot->node->pid=0;
proot->node->ppid=-1;
proot->node->prio=0;
proot->next=NULL;
proot->sub=NULL;
proot->brother=NULL;
plink=proot;
for(;;)//死循环，无限显示CMD：
{
cflag=0;
pflag=0;
printf("cmd:");
scanf("%s",cmdstr);
if(!strcmp(cmdstr,"exit")) //推出程序
break;
if(!strcmp(cmdstr,"showdetail"))//显示进程信息
{
cflag = 1;
pflag = 1;
showdetail();
}
else
{
int *para;
char *s,*s1,*s2;
s = strstr(cmdstr,"createpc"); //建立进程
s2 = strstr(cmdstr,"deletepc"); //删除进程
if(s)
{
cflag=1;
para = (int *)malloc(3);
//getparameter
s1 = substr(s,instr(s,'(')+1,strlen(s)-2); //调用去掉逗号的字符串函数
para=strtoarray(s1); //调用字符串转换整数型函数
createpc(para); //调用建立进程函数
pflag=1;\
}
else if (s2)
{
cflag=1;
para = (int *)malloc(2);
//getparameter
s1 = substr(s2,instr(s2,'(')+1,strlen(s2)-2); //调用去掉逗号的字符串函数
para=strtoarray(s1); //调用字符串转换整数型函数
pnode *pp=plink;//PP指向链表头节点
pnode *pc=plink;//PC指向链表头节点
pnode *p,*p1;
bool findflag=false;//是否找到删除节点的标志
for (p=plink;p;p=p->next)
{
if((p->node->pid)==para[0])//找到要删除

的节点

{
for (p1=plink;p1;p1=p1->next)//P1指向删除节点的父节点
{
if((p1->node->pid)==p->node->ppid) //P1的节点进程号==P节点父进程号说明P1是P的父进程

{
pp=p1;
pc=p;
break;
}
}
findflag=true;
break;
}
}
if (findflag)
{
if (pp==pc) //是不是同一个节点
{
printf("you cann't delete the 0 process!\n");
}
else
deletepc(pp,pc); //调用删除进程函数
}
else
geterror(2);
pflag=1;
}
}
if(!cflag)
geterror(0);
else if(!pflag)
geterror(1);
}
}
//p.v*****************************************************************
semphore sem[5];
pnode * pr[20];
//wait operation
void wait(char * sname,int pid)
{
int fflag,pflag;
pnode *p,*p1;
semphore *s;//所需的信号量
fflag=0;//标志是否找信号量
pflag=0;//标志是否找到进程
for(int i=0;i<5;i++)
{
if(!strcmp(sem[i].name,sname))//找到信号量
{
s=&sem[i];//取出这个信号量
fflag=1;
break;
}
}
for(int j=0;j<20;j++) //寻找进程号
{
if(pr[j]->node->pid == pid)
{
p1 = pr[j];//P1指向进程号
pflag=1;
break;
}
}
if(!fflag) //如果信号量不存在
{
printf("the semphore '%s' is not exist!\n",sname);
return;
}
if(!pflag) //如果进程号不存在
{
printf("the process '%d' is not exist!\n",pid);
return;
}
s->count--; //信号量值-1
if(s->count>=0) //如果计数值存在
s->curpid = p1->node->pid;//进程号申请到信号量
else
{
if(s->wlist) //如果等待链表中有序列存在，放入队列末尾
{
for(p=s->wlist;p->next;p=p->next);
p->next=p1;
}
else //如果等待链表没有序列，就成为第一个序列
s->wlist=p1;
}

}
void signal(char *sname)
{
int fflag=0;//标志是否找到该信号量
int i;
for(i=0;i<5;i++)
{
if(!strcmp(sem[i].name,sname)) //找到所需信号量
{
fflag=1;
break;
}
}
if(fflag) //如果找到
{
sem[i].count++;
if(sem[i].wlist) //该信号量的存在等待序列
{
sem[i].curpid = sem[i].wlist->node->pid;//把等待序列中的PID作为当前信号量进程
sem[i].wlist = sem[i].wlist->next;//等待序列前移
}
}
else
printf("the semphore '%s' is not exist!\n",sname);

}
//show semphore infomation
void pv_showdetail()
{
int i;
pnode *p;
printf("\n");
for(i=0;i<5;i++)
{
if(sem[i].count<=0)
{
printf("%s (curp %d): ",sem[i].name,sem[

i].curpid);
p=sem[i].wlist;
while(p)
{
printf("wait %5d",p->node->pid);
p=p->next;
}
}
else
printf("%s : ",sem[i].name);
printf("\n");
}
}
/*****************************************************************************/
/* don't change */
void init()//初始化信号量
{
//init semaphore
strcat(sem[0].name,"s0");
strcat(sem[1].name,"s1");
strcat(sem[2].name,"s2");
strcat(sem[3].name,"s3");
strcat(sem[4].name,"s4");
for(int i=0;i<5;i++)
{
sem[i].wlist=NULL;//没有等待序列
sem[i].count=1;//计数值制为1
}
//init process
for(int j=0;j<20;j++)//设立20个进程
{
pr[j] = new pnode;
pr[j]->node=new pcb;
pr[j]->node->pid=j;
pr[j]->brother=NULL;
pr[j]->next=NULL;
pr[j]->sub=NULL;
}

}
void P_V()
{
short cflag,pflag;
char cmdstr[32];
char *s,*s1,*s2;
initerror();
init();
for(;;)
{
cflag=0;
pflag=0;
printf("cmd:");
scanf("%s",cmdstr);
if(!strcmp(cmdstr,"exit")) //exit the program
break;
if(!strcmp(cmdstr,"showdetail"))
{
cflag = 1;
pflag = 1;
pv_showdetail();
}
else
{
s = strstr(cmdstr,"wait"); //create process
if(s)
{
cflag=1;
s1 = substr(s,instr(s,'(')+1,instr(s,',')-1);//信号量
s2 = substr(s,instr(s,',')+1,instr(s,')')-1);//进程号
if(s1 && s2)
{
wait(s1,atoi(s2));
pflag=1;
}
}
else
{
s=strstr(cmdstr,"signal");//delete process
if(s)
{
cflag=1;
s1 = substr(s,instr(s,'(')+1,instr(s,')')-1);
if(s1)
{
signal(s1);
pflag=1;
}
}
}
}
if(!cflag)
geterror(0);
else if(!pflag)
geterror(1);
}
}
int main(void)
{
int sel;
Show();
while(scanf("%d",&sel))
{
switch(sel)
{
case 1:
Del();
break;
case 2: Del();
break;
case 3:P_V();
break;
case 4:M_clock();
break;
case 5:M_scan();
break;
case 6:FCFS();
break;
}
Show();
}
return 0;
}