clock算法
㈠ 怎么样实现分页管理的缺页调度clock算法C语言代码
这个程序我做过,现在给你!!写了很久的!!
#include<stdafx.h>
#include<stdlib.h>
#include<stdio.h>
#define n 64//实验中假定主存的长度
#define m 4//实验中假定每个作业分得主存块块数
int p[m];//定义页
int head=0;
struct
{
short int lnumber;//页号
short int flag;//表示该页是否在主存，"1"表示在主存，"0"表示不在主存
short int pnumber;//该页所在主存块的块号
short int write;//该页是否被修改过，"1"表示修改过，"0"表示没有修改过
short int dnumber;//该页存放在磁盘上的位置，即磁盘块号
short int times;//被访问的次数，用于LRU算法
}page[n];//定义页表
//各个函数的实现如下：
void computer()
{
int i;
for(i=0;i<n;i++)
{
page[i].lnumber = i;
page[i].flag = 0;
page[i].pnumber = 10000;//用10000表示为空
page[i].write = 0;
page[i].dnumber = i;
page[i].times = 0;
}//初始化页表
for(i=0;i<m;i++)
{
page[i].pnumber = i;
}
for(i=0;i<m;i++)
{
p[i] = i;
page[i].flag = 1;
}//初始化页
}
void showpagelist()
{
int i;
printf("\n页号\t是否在主存中\t块 号\t是否被修改过\t磁盘块号\t访问次数\n");
for(i=0;i<n;i++)
{
printf("%d\t%d\t\t%d\t\t%d\t\t%d\t\t%d\n",page[i].lnumber,page[i].flag,page[i].pnumber,page[i].write,page[i].dnumber,page[i].times);
}
}
void showpage()
{
int i;
for(i=0;i<m;i++)
{
printf("\t%d\n",p[i]);
}
}
void transformation() //缺页中断处理
{
unsigned logicAddress,logicNumber,innerAddress,physicsAddress,physicsNumber;
int i, fail = 0;
int method,temppage=0;
short int times = 10000;
printf("请输入一个逻辑地址（四位十六进制数）:");
scanf("%x",&logicAddress);//读入逻辑地址
logicNumber = logicAddress >> 10;//得到页号
printf("页号为:%ld\n",logicNumber);
innerAddress = logicAddress & 0x03ff;//得到页内地址
printf("页内地址为:%ld\n",innerAddress);
for(i=0;i<n;i++)
{
if(logicNumber==(unsigned)page[i].lnumber)
{
if(page[i].flag == 1)
{
printf("请求的页面在主存中!\n");
page[i].times++;
physicsNumber = page[i].pnumber;//由页号得到块号
printf("请求的主存块号为:%ld\n",physicsNumber);
physicsAddress = physicsNumber << 10 |innerAddress;//得到物理地址
printf("请求的物理地址为:%ld",physicsAddress);//输出物理地址
break;
}
else
{
printf("请求的页面不在主存中! 将进行缺页中断处理!\n请选择算法!\n");
printf("1.先进先出\n2.最近最少用\n请选择置换算法:");
scanf("%d",&method);
if(method == 1) //采用先进先出算法
{
printf("采用先进先出算法!\n");
fail = p[head];
printf("第%d页将被替换!\n",fail);
p[head] = logicNumber;
head = (head+1) % m;
if(page[fail].write == 1)
printf("第%d页曾被修改过!\n",fail);
page[fail].flag = 0;
page[logicNumber].flag = 1;
page[logicNumber].write = 0;
page[logicNumber].pnumber = page[fail].pnumber;
page[fail].pnumber = 10000;
page[logicNumber].times++;
break;
}
else if(method == 2) //采用最近最少用算法
{
printf("采用最近最少用算法!\n");
for(i=0;i<n;i++)
{
if(page[i].flag == 1)
{
if(page[i].times<times)
{
times = page[i].times;
temppage = page[i].lnumber;
}
}
}
printf("第%d页将被替换!\n",temppage);
for(i=0;i<m;i++)
{
if(p[i] == temppage)
{
p[i] = logicNumber;
}
}
if(page[temppage].write == 1)
printf("第%d页曾被修改过!\n",temppage);
page[temppage].flag = 0;
page[logicNumber].flag = 1;
page[logicNumber].write = 0;
page[logicNumber].pnumber = page[temppage].pnumber;
page[temppage].pnumber = 10000;
page[logicNumber].times++;
break;
}
else
{
printf("你输入有误，即将退出!");
exit(1);
}
}
}
}
}
void main()
{
char c,d,flag='y';
printf("页表正在初始化中...，3秒钟后为你显示页和页表！\n");
computer();
showpage();
showpagelist();
while(flag == 'y' || flag == 'Y')
{
transformation();
printf("是否显示页和页表？(Y/N)");
c = getchar();
c = getchar();
if(c=='Y'||c=='y')
{
showpage();
showpagelist();
}
else
{
while(c=='N'||c=='n')
{
printf("\n是否继续进行请求分页？（Y/N）");
d = getchar();
d = getchar();
if(d=='Y'||d=='y')
{
transformation();
printf("\n是否显示页和页表？（Y/N）");
c = getchar();
c = getchar();
if(c=='Y'||c=='y')
{
showpage();
showpagelist();
}
}
else if (d=='N'||d=='n')
exit(1);
else
printf("输入错误！\n");
}
}
printf("\n是否继续进行请求分页？（Y/N）");
flag = getchar();
flag = getchar();
}
}
㈡ C++编程，clock置换算法
#include<iostream>
#include<stdlib.h>
#include<time.h>
#define N 20 //虚拟内存尺寸
using namespace std;
int P;
int const blockCount=3 ;//内存中的物理块数
int count = 0;
int block[blockCount];
int const PageCount=15;//总的页面数
int Page[PageCount];
int state[blockCount];//clock置换算法中，内存中的每个页面号对应的状态
int state2[blockCount][2];// 二维数组，第一行第一列为访问位，第一行的第二列为修改位
double lost= 0.0;
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;
}
}
//检测页号是否在内存中
bool inblock(int num)
{
for(int i=0; i<blockCount;i++)
{
if(block[i] == Page[num])
{
state[i] = 1;
return true;
}
}
return false;
}
//判断页面是否已经被修改
bool change()
{
if((rand()%2+1) == 1 )
{
printf("该页面被修改!\n");
return true;
}
else
return false;
}
//用于改进型clock置换算法，检测页号是否在内存中并把访问位和修改位置1
bool inblock2(int num)
{
for(int i=0;i<blockCount;i++){
if(block[i] == Page[num]){
if(change()){
state2[i][0] = 1;
state2[i][1] = 1;
}
else{
state2[i][0] = 1;
}
return true;
}
}
return false;
}
//用于改进型clock置换算法，判断内存中第几个需要被置换
int whichpage(){
int j;
for(j=0;j<blockCount;j++)
{
if(state2[j][0] == 0&&state2[j][1] == 0)
{
return j;
}
}
for(j=0;j<blockCount;j++ )
{
if(state2[j][0] == 0&&state2[j][1] == 1)
{
return j;
}
state2[j][0] = 0 ;
}
for(j=0;j<blockCount;j++ )
{
state2[j][0] =0 ;
}
return whichpage();
}
//简单Clock置换算法
void CLOCK(int num)
{
int j;
if(inblock(num))
{
printf("命中!\n");
lost++;
for(int i=0;i<blockCount;i++)
printf("物理块%d#中内容:%d\n",i,block [i]);
}
else
if(count == blockCount)
{
//lost++;
for(j=0;j<blockCount; )
{
if(state[j] == 0)
{
break;
}
else{
state[j] = 0;
}
j++;
j = j%3;
}
block[j] = Page[num];
state[j] = 1;
for(int i=0;i<blockCount;i++)
printf("物理块%d#中内容:%d\n",i,block[i]);
}
else{
block[count] = Page[num];
count++;
for(int i=0;i<blockCount;i++)
printf("物理块%d#中内容:%d\n",i,block[i]);
}
}
//改进型clock置换算法
void LCLOCK(int num)
{
int j;
if(inblock2(num))
{
printf("命中!\n");
lost++;
for(int i=0;i<blockCount;i++)
printf("物理块%d#中内容:%d\n",i,block[i]);
}
else
if(count == blockCount)
{
//lost++;
j = whichpage();
block[j] = Page[num];
state2[j][0] = 1;
for(int i=0;i<blockCount;i++)
printf("物理块%d#中内容:%d\n",i,block[i]);
}
else{
block[count] = Page[num];
count++;
for(int i=0;i<blockCount;i++)
printf("物理块%d#中内容:%d\n",i,block[i]);
}
}
int main()
{
int a[N];
int mo[N];
int A=10;
int e,m,prop,t,j;
printf("页面走向为：");
generate_list(a, e,m,t);
generate_modify(mo,e,prop);
for(int i = 0;i<PageCount;i++)
{
Page[i] =rand()%9 + 1;
printf("%d ",Page[i]);
}
char ch ;
printf("\n");
printf("\t\t1 Clock置换算法\n");
printf("\t\t2 改进型Clock置换算法\n");
printf("\t\t3 退出!\n\n");
printf("请输入算法序号:\t\n");
while(1){
scanf("%c",&ch);
switch(ch){
case '1':{
lost=0;
count=0;
for(int m=0;m<blockCount;m++)
{
state[m] = 0;
}
for(int j=0;j<blockCount;j++)
{
block[j]=0;
}
for(int i=0;i<PageCount;i++)
{
printf("读入Page[%d]\n",i);
CLOCK(i);
}
printf("页面访问次数: %d\n缺页次数: %0.lf\n",PageCount,PageCount-lost);
printf("缺页率为:%0.001f\n",(PageCount-lost)/PageCount);
printf("\n请输入算法序号:\t");
}break;
case '2':{
lost = 0;
count = 0;
for(int m = 0; m < blockCount; m++)
{
for(int n = 0; n < 2;n++)
state2[m][n] = 0;
}
for(int j = 0; j < blockCount; j++)
{
block[j] = 0;
}
for(int i = 0; i < PageCount; i++)
{
printf("读入Page[%d]\n",i);
LCLOCK(i);
}
printf("页面访问次数: %d\n缺页次数: %0.lf\n",PageCount,PageCount-lost);
printf("缺页率为:%0.001f\n",(PageCount-lost)/PageCount);
printf("\n请输入算法序号:\t");
}break;
case '3':{
exit(0);
}
}
}
return 0;
}
㈢ OPT算法，FIFO算法，CLOCK算法和LRU算法
其实这种题目是非常简单的：
页号：2,3,2,1,4,5,2,4,5,1,3,2,5,2
O: 1 3 4 1 共有4次中断
F: 2 3 1 4 5 2 1 共有7次中断
C: 3 2 1 2 4 5 1 共有7次中断
L: 3 1 2 4 5 1 共有6次中断
㈣ 操作系统，什么是clock算法
clock()是C/C++中的计时函数，而与其相关的数据类型是clock_t。在MSDN中，查得对clock函数定义如下：
clock_t clock(void) ;
简单而言，就是该程序从启动到函数调用占用CPU的时间。这个函数返回从“开启这个程序进程”到“程序中调用clock()函数”时之间的CPU时钟计时单元（clock tick）数，在MSDN中称之为挂钟时间（wal-clock）；若挂钟时间不可取，则返回-1。其中clock_t是用来保存时间的数据类型。
㈤ 操作系统CLOCK置换算法的题目，急求解！！
因为一个目录文件最多可以由4个磁盘块组成，读目录和下级目录的时候，在最好的情况下，总能在第一个磁盘块上就能找到所需的下级目录信息，所以ADKQ四个目录读四次就可以了，此后是读文件，理想情况下所需页面可以通过前10个索引直接找到，此时只需再读一次就能读到所需页了，结果最少共用5次
最坏情况下，每个目录都存放在4个磁盘块的最后一个上，因此每个目录都得读四次，一共4*4=16次，而找到文件后，所需页面又得通过2级索引去找，这样一来2级索引表读一次，1级索引表又读一次，页面本身内容再读一次，又需2+1=3次，所以最坏情况就是16+3=19次
㈥ 试说明改进形clock页面置换算法的基本原理
这很简单啊，要打字太多了。不过网上这类算法举例很少，就看你怎么理解了。
改良后的Clock算法
考虑到如果某一调入内存的页没有被修改过，则不必将它拷回到磁盘。于是在改进的Clock增加了一个M位， M=0 表示该页未被修改过。这样我们选择页面换出时，既要最近未访问过的页面，又要未被修改过的页面。其执行过程分一下三步：
第一步：从开始位置循环扫描队列，寻找A=0、M=O的第一类面，找到立即置换。另外，第一次扫描期间不改变访问位A。
第二步：如果第一步失败，则开始第二轮扫描，寻找A=0且M=1的第二类页面，找到后立即置换，并将所有扫描过的A都置0。
第三步：如果第二步也失败，则返回指针开始位置，然后重复第一步，必要时再重复第二步，此时必能找到淘汰页。
㈦ nru算法----改进型"clock"算法
CLOCK算法的性能比较接近LRU，而通过增加使用的位数目，可以使得 CLOCK算法更加高效。在使用位的基础上再增加一个修改位，则得到改进型的 CLOCK置换算法。这样，每一帧都处于以下四种情况之一：
1）最近未被访问，也未被修改（u=0，m=0）
2）最近被访问，但未被修改（u=1，m=0）。
3）最近未被访问，但被修改（u=0，m=1）
4）最近被访问，被修改（u=1，m=1）
算法执行如下操作步骤：
1）从指针的当前位置开始，扫描帧缓冲区。在这次扫描过程中，对使用位不做任何修改。选择遇到的第一个帧（u=0，m=0）用于替换。
2）如果第1）步失败，则重新扫描，查找（u=0，m=1）的帧。选择遇到的第一个这样的帧用于替换。在这个扫描过程中，对每个跳过的帧，把它的使用位设置成0。
3）如果第2）步失败，指针将回到它的最初位置，并且集合中所有帧的使用位均为0。重复第1步，并且如果有必要，重复第2步。这样将可以找到供替换的帧。
改进型的 CLOCK算法优于简单CLOC算法之处在于替换时首选没有变化的页。由于修改过的页在被替换之前必须写回，因而这样做会节省时间。
㈧ C#语言写的CLOCK算法模拟
你好。
很幸运看到你的问题。
但是又很遗憾到现在还没有人回答你的问题。也可能你现在已经在别的地方找到了答案，那就得恭喜你啦。
对于你的问题我爱莫能助！
可能是你问的问题有些专业了。或者别人没有遇到或者接触过你的问题，所以帮不了你。建议你去问题的相关论坛去求助，那里的人通常比较多，也比较热心，可能能快点帮你解决问题。
希望我的回答也能够帮到你！
快过年了，
最后祝您全家幸福健康快乐每一天！
㈨ clock算法扫描顺序是怎样的，也就是说“时钟”的刻度是怎样个顺序
如果没有明确指明，一般按页装入顺序绘制clock，指针指向最先装入的页面。
㈩ 谁能给个详细的clock置换算法如题,看了网上有好多版本,指针有的移动有的不移动.谁能给个确定的
我也很郁闷，去年那道标准答案和书上说的就不一样。哎，考试的时候写清楚算法，我想改卷老师应该会酌情给分的