精华内容
下载资源
问答
  • 页面置换算法之CLOCK算法
    2021-06-07 17:07:14

    中文名:时钟置换算法
    以下是作者对CLOCK算法的肤浅见解,如有错误之处,欢迎指出,十分感谢!

    定义

    时钟置换算法可以认为是一种最近未使用算法,即逐出的页面都是最近没有使用的那个。它和LRU算法有类似之处,只不过clock算法会有一个用于记录访问次数的数组,然后再根据第一个最小访问次数来进行替换处理,当访问到缓存中的页面时,访问次数有限制的加1,不改变队列顺序,替换是原位替换,如4,5,6,访问到页面2。如果访问次数6比4和5要多1且4和5访问次数相等,那么替换后的队列为4,2,6。

    这里想给大家一个实例演示的,不过仔细想想,可能运行结果会更加直观一些。

    C语言代码

    #include<stdio.h>
    #define MAX 3//缓存最大页面容量 
    
    typedef struct clock{
    	
    	int clock[MAX];//存放页面号 
    	int sign[MAX];//存放访问次数,初值为0 
    	
    }CLOCK;
    
    int compare( int a[MAX] )//作用是看任意两个页面的访问次数有没有相同,有则返回1;否则,返回0 。 
    {
    	int s = a[0],d = 0;
    	for(int i = 0; i < MAX; i++)
    	{
    		for(int j = i; j < MAX-1; j++)
    		{
    			if(a[i] == a[j+1])
    			d=1;
    		}
    	}
    	return d;
    }
    
    int	 Min( int a[MAX] )//作用是返回缓存中最小的页面号 
    {
    	int min;
    	min = a[0];
    	for(int i = 1; i < MAX; i++)
    	{
    		if(min > a[i])
    		min = a[i];
    	}
    	return min;
    }
    int	 Max( int a[MAX] )//作用是返回缓存中最大的页面号 
    {
    	int max;
    	max = a[0];
    	for(int i = 1; i < MAX; i++)
    	{
    		if(max < a[i])
    		max = a[i];
    	}
    	return max;
    }
    int	 i_value( int a[MAX] )//作用是返回缓存中最小的页面号的地址 
    {
    	int ivalue,temp = 0;
    	ivalue = a[0];
    	for(int i = 1; i < MAX; i++)
    	{
    		if(ivalue > a[i])
    		{
    			ivalue = a[i];
    			temp = i;
    		}
    	}
    	return temp;
    }
    int	 I_value( int a[MAX] )//作用是返回缓存中最大的页面号的地址 
    {
    	int Ivalue,temp = 0;
    	Ivalue = a[0];
    	for(int i = 1; i < MAX; i++)
    	{
    		if(Ivalue < a[i])
    		{
    			Ivalue = a[i];
    			temp = i;
    		}
    	}
    	return temp;
    }
    int main()
    {
    	int flag = 0;//0表示访问的这个页面是一个新页面,1表示访问的这个页面已存在于缓存中 
    	int data;//页面号 
    	int mid = 0;//充当中间变量,暂时缓存一个值
    	clock c;
    	for(int i = 0; i < MAX; i++)
    	{
    		c.clock[i] = -1;
    		c.sign[i] = 0;
    	}
    	for(int i = 0; i < MAX; i++)
    	{
    		flag = 0;
    		printf("请输入第%d个页面号:",i);
    		scanf("%d",&data);
    		for(int j = 0; j < MAX; j++)
    		{
    			if(data == c.clock[j])//如果这个页面已存在于缓存中 
    			flag = 1;
    		}
    		if(flag != 1)//如果这个页面不存在于缓存中 
    		c.clock[i] = data;
    		else//如果这个页面已存在于缓存中 
    		{
    			printf("对不起,你输入的页面也存在,请重新输入!\n");
    			i--;
    		}
    	}
    	printf("开始页面分别为\n");
    	printf("\n");
    	for(int i = MAX-1; i >= 0; i--)
    	{
    		if( i == MAX-1 )
    		printf("缓存页面->");
    		printf("%d \t",c.clock[i]);
    	}
    	printf("\n\n访问次数->%d \t%d \t%d\n\n",c.sign[2],c.sign[1],c.sign[0]);//打印访问次数
    	
    	while(true)
    	{
    		flag = 0;
    		mid = 0;
    		printf("请输入一个新的页面:");
    		scanf("%d",&data);
    		for(int i = 0; i < MAX; i++)
    		{
    			if(data == c.clock[i])//如果这个页面已存在于缓存中
    			{
    				c.sign[i]++;//访问次数加1 
    				flag = 1;
    				break;
    			}
    			else
    			flag = 0;
    		}
    		while(   true   )//用于更改访问次数的错误记录
    		{
    			if(     (Max(c.sign) - Min(c.sign)) > 1   &&   compare(c.sign)    )
    			c.sign[ I_value(c.sign) ]--;
    			else break;
    		}
    		
    		if( flag == 0 )//替换页面 
    		{
    			mid = i_value(c.sign);
    			c.clock[mid] = data;
    			c.sign[mid]++;
    		}
    		//else不替换页面 
    		
    		printf("换替换后的页面结果为\n");
    		printf("\n");
    		for(int i = MAX-1; i >= 0; i--)
    		{
    			if( i == MAX-1 )
    			printf("缓存页面->");
    			printf("%d \t",c.clock[i]);
    		}
    		
    		printf("\n\n访问次数->%d \t%d \t%d\n\n",c.sign[2],c.sign[1],c.sign[0]);//打印访问次数 
    		
    	}
    	return 0;
    }
    
    

    执行结果

    请输入第0个页面号:6
    请输入第1个页面号:5
    请输入第2个页面号:4
    开始页面分别为
    
    缓存页面->4     5       6
    
    访问次数->0     0       0
    
    请输入一个新的页面:3
    换替换后的页面结果为
    
    缓存页面->4     5       3
    
    访问次数->0     0       1
    
    请输入一个新的页面:5
    换替换后的页面结果为
    
    缓存页面->4     5       3
    
    访问次数->0     1       1
    
    请输入一个新的页面:4
    换替换后的页面结果为
    
    缓存页面->4     5       3
    
    访问次数->1     1       1
    
    请输入一个新的页面:3
    换替换后的页面结果为
    
    缓存页面->4     5       3
    
    访问次数->1     1       2
    
    请输入一个新的页面:6
    换替换后的页面结果为
    
    缓存页面->4     6       3
    
    访问次数->1     2       2
    
    请输入一个新的页面:
    

    没啥总结好说的,了解还比较短浅,有待更新博客。
    如有错误,欢迎告知!
    转载需说明,十分感谢!

    更多相关内容
  • 改进clock算法...

    2019-01-28 11:10:27
    在改进的Clock增加了一个M位, M=0 表示该页未被修改过,M=1 表示该页被修改过。..................
  • 可以体现Clock算法和LRU算法的的思想,用于操作系统的课程实训。 任务要求 从置换算法中任选1种(OPT、LRU、Clock); 建立页表 设计的输入数据要能体现算法的思想 模拟缺页中断过程; 求出各置换算法中的缺页...
  • 操作系统Clock算法

    千次阅读 2021-05-07 23:36:42
    Clock算法 Clock算法的简介 由于LRU算法对于硬件要求很高,它的近似算法通常是更好的选择,Clock算法就是用的比较多的一种LRU近似算法。 Clock算法的理解 话不多说,直接进入正题! 简单Clock置换算法 例题:页面流 ...

    Clock算法

    Clock算法的简介

    由于LRU算法对于硬件要求很高,它的近似算法通常是更好的选择,Clock算法就是用的比较多的一种LRU近似算法。

    Clock算法的理解

    话不多说,直接进入正题!

    简单Clock置换算法

    例题:页面流 7 0 1 2 0 3 0 4 2 3 0 3 2 1 2 0 1 7 0 1 在3个物理块下的置换过程。
    相比起其他算法,Clock算法需要一个指针,简单理解就是指针指向哪里页面就优先插入哪里。
    比如在初始状态时指针指向第一个物理块,页面7便插入第一个物理块,同时指针下移,那么什么时候指针要下移呢?很简单,当插入成功后指针移到插入位置的下一位。
    除了指针还需要给每个在物理块中的页面标个号(0或1),刚插入的或者已经在物理块中又被访问的页面标为1。这个标号有什么用呢,你可以理解为一个一次性的“免换金牌”,当被指针指着要被换出的时候,如果标号是1,就改为0,然后按顺序判断下一个位置,直到循环下去找到一个0,把标号0的页面换出去,同时指针移到换出位置的下一位。
    例题的流程便是这样的(这里我用*表示标号为1,没有则为0):
    在这里插入图片描述

    改进Clock置换算法

    由于在实际系统使用中页面不仅会被访问还会被修改,所以改进型Clock算法就是把页面分成四种情况:
    1.最近既没修改也没访问
    2.最近没访问但修改了
    3.最近访问了但没修改
    4.最近即访问又修改了
    按照类似简单Clock算法(使用两个标号)来依次判断有没有情况1的页面,如果有就换出,如果没有就判断有没有情况2的页面,注意,当判断完后还是没有并不是去判断情况3和4,而是把所有访问标号都重置为0,再依次判断1和2,这样就能找到最适合换出的页面。

    总结

    Clock算法相较于其他页面置换算法比较复杂,但是只要掌握原理,用例题练几遍就能很熟练啦~

    展开全文
  • 王道操作系统CLOCK算法理解 最近复习到操作系统的CLOCK算法,虽然这个算法看起来简单,但在做题时却十分费解,尤其是指针的位置,本文针对王道课后相关习题做以解释说明。 21版王道操作系统3.2.9第11题 对于了解...

    王道操作系统CLOCK算法理解

    最近复习到操作系统的CLOCK算法,虽然这个算法看起来简单,但在做题时却十分费解,尤其是指针的位置,本文针对王道课后相关习题做以解释说明。

    21版王道操作系统3.2.9第11题

    上图为具体问题的图片

    对于了解FIFO、LRU算法以及CLOCK算法的同学不难做出结果,但本人在计算CLOCK算法时,得出的结果却是虚拟页号为1的页(答案为虚拟页号为2,页帧号为0的帧),在看课后习题时亦百思不得其解,刚开始本人的理解如下:

    1. 首先根据CLOCK算法,在指针摆动的过程中,所遇到第一个访问位为0的页面即换出页面;
    2. 如何判断指针位置呢,由于最近访问时间最靠前的虚拟页号为2和1的页的访问位均为0,故判断指针当前位置在虚拟页号为2号的页帧上,刚将该帧的访问位置0;
    3. 故接下来指针顺序摆动,将表中第三行和第四行的页帧访问位置0,随后回到虚拟页号为1的页帧处,此时结束第一轮指针搜寻;
    4. 随后指针发现当前所在页帧的访问位为0,故换出;

    想必此时对CLOCK算法十分了解的同学已经发现了问题所在。是的,在CLOCK算法中,指针的摆动顺序并非按照最近访问时间来排,而是按照页帧的装入时间来进行排序循环(此处容易理解:最近访问时间是实时动态变化的,而指针的摆动顺序却是在页帧装入时变更后,无页帧更换变化便不进行更新的)。所以正确的解法应如下:

    1. 首先根据CLOCK算法,在指针摆动的过程中,所遇到第一个访问位为0的页面即换出页面;
    2. 其次判断指针位置。根据装入时间可知,指针的摆动顺序为(3021–虚拟页号顺序)而此时3号和0号均为1,可知此时指针位置有两种可能性,第一种为在指向2号页时产生缺页中断,故循环寻找访问位为0的页帧,未找到后再次循环判断,并将跳过的页面访问位置0,所以此时指针在0号页(刚刚将1号页的访问位置0,顺延指向0号页);第二种可能为,系统刚过163的时间,即指针刚刚将3号页帧的访问位置1,随后指向后面一个页,即2号页,并发生缺页中断;
    3. 现在对以上两种可能性进行分别分析。第一种可能性下,由于指针置0的起始位置在2号帧,故循环置零后再次进行访问位判断,此时2号页为第一个访问位为0的页,故被换出(此处区别CLOCK算法和改进的CLOCK算法);第二种可能性下,由于此时指针开始循环寻找访问位为0的页面换出,此时2号页为第一个判断项,且访问位为0,故被换出;
    4. 综上,使用NRU算法时被换出的虚拟页号为2。

    在解题过程中,同学们应特别注意题中要求使用的是CLOCK算法(即NRU算法)还是改进的CLOCK算法,其次,对于指针的摆动顺序是根据装入时间来确定的这一隐藏规则要牢记。

    展开全文
  • clock算法模拟.doc

    2022-05-06 15:17:24
    clock算法模拟.doc
  • 页面置换算法之FIFO、LRU、OPT和Clock算法及其实现 页面置换 页面置换:页面置换是请求调页的基础,它完成了逻辑内存和物理内存之间的分离,采用这种机制,较小的物理内存能为程序员提供巨大的虚拟内存。 在页码被...

    页面置换算法之FIFO、LRU、OPT和Clock算法及其实现

    页面置换

    页面置换:页面置换是请求调页的基础,它完成了逻辑内存和物理内存之间的分离,采用这种机制,较小的物理内存能为程序员提供巨大的虚拟内存。

    在页码被调入的时候,会有三种情况发生:
    a. 类似初始化状态,内存未满,但是没有该页码,需要从磁盘中直接引入。
    b. 内存已满,产生缺页错误,需要请求调页。
    c. 内存已满,但是存在改页码,可以直接使用,不需要调页,也不会产生缺页错误。

    所以针对这三种情况,设计如下四种页面置换算法:

    FIFO页面置换

    FIFO 是最简单的页面置换算法,它为每一个页面记录了调到内存的时间,当必须置换页面时,将选择最旧的页面。具体实现的话,我们并不需要记录调入页面的具体时间,只需要创建一个FIFO队列,来管理所有的内存页面,置换的是队列的首个页面,当需要调入页面到内存时,就将它加入到队列的尾部。

    OPT页面置换

    这个算法具有所有算法的最低的缺页错误率。并且不会遭受Belady异常,被称为OPT或者MIN。
    OPT为置换最长时间不使用的页面,他与LRU算法不同的是需要向后看,寻找最不经常使用的页码,所以我们只需要向后看,有两种情况则可以结束前进:

    1. 找到了(最大帧数-1)个页码号,则剩下的那一个页码即为我们要替换的页码
    2. 找到了最后,都没有找到(最大帧数-1)个页码,这就按FIFO算法将没有找到的页码踢掉。

    LRU页面置换

    同为采用队列实现,LRU与FIFO不同的地方,需要更新不断出现的元素,将它重新插入一遍,所以对应于上面的三种情况中的c,这时所需要的页码在内存中已经存在,不能只是简单的直接调用进程,还需要将该页码更新一下,以证明最近使用过(找到页码所对应的位置,将它在队列中删掉,重新插入一遍)。

    Clock算法

    Clock又叫第二次机会算法,通过一个visit数组来实现第二次访问,利用循环队列相应的知识,在FIFO的基础上,在开辟一个与之对应的数组,其索引必须相呼应,两者具体关系如下:
    a. 页码刚被调入,设置其页码对应的visit为1;
    b. 访问过一次,则将其visit设置为0;
    c. 页码被替换,对应的visit也要更新为1。
    总之,将visit与队列实现同步操作即可。

    具体代码如下:

    #include<iostream>
    #include<algorithm>
    #include<stdlib.h>
    #include<stack>
    #include<queue>
    #include<vector>
    #include<cmath>
    #include<time.h>
    
    using namespace std;
    
    #define N 20    //Page_Name
    #define M 3     //Frame_Max_name
    
    int in(vector<int> map,int num){             //判断新进来的元素是否已经存在与内存里面
        int flag = 0; 
        vector<int>::iterator v = map.begin();
        while( v != map.end()) {
            if(num == *v){
                flag = 1;
                break;
            }
            v++;
        }
        return flag;
    }
    
    int return_index(vector<int> map,int num){     //因为栈、队列等数据结构没有遍历的功能,所以写这个函数来直接定位某个元素的索引
        int index = 0;
        vector<int>::iterator v = map.begin();
        while( v != map.end()) {
            if(num == *v){
                break;
            }
            v++;
            index++;
        }
        return index;
    }
    int main(){
        int arr[N];//= {7,0,1,2,0,3,0,4,2,3,0,3,2,1,2,0,1,7,0,1};
        vector<int> map;   //判断是否在stack or queue中
        int num = 0;       //缺页数
        int num1,num2,num3,num4,num5;
        srand((unsigned int)(time(NULL)));
        for(int i=0;i<N;i++){ //随机生成arr数组 表示接下来要应用的页码
            
            arr[i] = rand()%10;
            //cout << arr[i] << " ";
        }
        cout << endl;
        queue<int> FIFO;
        stack<int> LRU;
    
        //FIFO alforithm :
        cout << "FIFO序列如下: " << endl;
        map.clear();
        for(int i=0;i<N;i++){
            if(in(map,arr[i])){          //如果页码在内存中已经存在,输出true
                cout << "true" << endl;
                continue;
            }
                
            else{
                if(map.size()>=M){       //如果页码在内存中不存在,并且不是刚开始帧什么都没有的情况
                    //int index = return_index(map,arr[i]);
                    //cout << "index : " << index << endl;
                    //FIFO.pop();
                    //FIFO.push(arr[i]);
                    map.erase(map.begin());   //头部出队列
                    map.push_back(arr[i]);    //尾插
                }
                else{                    //初始状态,帧里面什么都没有,直接入队即可
                    //FIFO.push(arr[i]);
                    map.push_back(arr[i]);
                }
                num++;
                vector<int>::iterator v = map.begin();
                while( v != map.end()) {
                    cout << *v << " ";
                    v++;
                }
                cout << endl;
            }
        }
        num1 = num;
        cout << "总页数为: " << N << endl << "FIFO算法缺页数: " << num << endl;
    
    
        //LRU alaorithm :
        cout << endl << "LRU序列如下: " << endl;
        map.clear();
        num = 0;
        for(int i=0;i<N;i++){
            if(in(map,arr[i])){
                int index = return_index(map,arr[i]);   //与FIFO不同的地方,需要更新不断出现的元素,将它重新插入一遍
                map.erase(map.begin()+index);
                map.push_back(arr[i]);
                cout << "true" << endl;
                continue;
            }
            else{
                if(map.size()>=M){
                    map.erase(map.begin());
                    map.push_back(arr[i]);
                }
                else{
                    map.push_back(arr[i]);
                }
                num++;
                vector<int>::iterator v = map.begin();
                while( v != map.end()) {
                    cout << *v << " ";
                    v++;
                }
                cout << endl;
            }
        }
        num2 = num;
        cout << "总页数为: " << N << endl << "LRU算法缺页数: "  << num << endl;
    
    
    
        //OPT alaorithm :
        cout << endl << "OPT序列如下: " << endl;
        map.clear();
        num = 0;
        
        for(int i=0;i<N;i++){
            if(in(map,arr[i])){
                // int index = return_index(map,arr[i]);
                // map.erase(map.begin()+index);
                // map.push_back(arr[i]);
                cout << "true" << endl;
                continue;
            }
            else{
                if(map.size()>=M){
                    int pass = 0;
                    int vis[M];
                    for(int x=0;x<M;x++){
                        vis[x] = 0;
                    }
                    for(int j=i+1;j<N;j++){
                        for(int k=0;k<M;k++){
                            if(arr[j] == map[k]){
                                //cout << "i am " << arr[j] << endl;
                                int ind = return_index(map,arr[j]);
                                //cout << "index : " << ind << endl;
                                //cout << "arr : " << arr[j]  << endl;
                                if(vis[ind] == 1){
                                    break;
                                }
                                else{
                                    vis[ind] = 1;
                                }
                                pass++;
                                if(pass==M-1){
                                    //cout << "pass = " << pass << "  goto !" << endl; 
                                    goto This;
                                }
                                continue;
                            }
                        }
                    }
    This:           for(int j=0;j<M;j++){
                        if(vis[j] == 0){
                            //cout << "j == : " << j << endl;
                            map.erase(map.begin()+j);
                            map.push_back(arr[i]);
                            break;
                        }
                    }
                    
                }
                else{
                    map.push_back(arr[i]);
                }
                num++;
                vector<int>::iterator v = map.begin();
                while( v != map.end()) {
                    cout << *v << " ";
                    v++;
                }
                cout << endl;
            }
        }
        num3 = num;
        cout << "总页数为: " << N << endl << "OPT算法缺页数: "  << num << endl;
    
    
    
        
    
        //Clock alaorithm 2.0 版本(循环队列) :
        cout << endl << "Clock序列如下: " << endl;
        map.clear();
        num = 0;
        vector<int> visit;
        
        int index = 0;
        for(int i=0;i<N;i++){
            if(in(map,arr[i])){
                int ind = return_index(map,arr[i]);
                //map.erase(map.begin()+index);
                visit[ind] = 1;
                //map.push_back(arr[i]);
                cout << "true" << endl;
                continue;
            }
            else{
                if(map.size()>=M){
                    //int x = 0;
                    while(1){
                        if(visit[index] == 0){
                            map[index] = arr[i];
                            visit[index] = 1;
                            index = (index+1) % M;
                            // map.erase(map.begin()+x);
                            // map.push_back(arr[i]);
                            // visit.erase(visit.begin()+x);
                            // visit.push_back(1);
                            break;
                        }
                        else{
                            visit[index] = 0;
                            index = (index+1) % M;
                        }
                    }
                }
                else{
                    map.push_back(arr[i]);
                    visit.push_back(1);
                }
                num++;
                //cout << "元素 : ";
                vector<int>::iterator v = map.begin();
                while( v != map.end()) {
                    cout << *v << " ";
                    v++;
                }
                //cout << endl;
                //cout << "visit : "; 
                // vector<int>::iterator y = visit.begin();
                // while( y != visit.end()) {
                //     cout << *y << " ";
                //     y++;
                // }
                
                cout << endl;
            }
        }
        num4 = num;
        cout << "总页数为: " << N << endl << "Clock算法缺页数: "  << num << endl << endl;
    
    
    
        //Clock alaorithm 2.0 (FIFO为基础):
        cout << endl << "自创Clock序列如下: " << endl;
        map.clear();
        num = 0;
        visit.clear();
        for(int i=0;i<N;i++){
            if(in(map,arr[i])){
                int index = return_index(map,arr[i]);
                //map.erase(map.begin()+index);
                visit[index] = 1;
                //map.push_back(arr[i]);
                cout << "true" << endl;
                continue;
            }
            else{
                if(map.size()>=M){
                    int x = 0;
                    while(1){
                        if(visit[x] == 0){
                            map.erase(map.begin()+x);
                            map.push_back(arr[i]);
                            visit.erase(visit.begin()+x);
                            visit.push_back(1);
                            break;
                        }
                        else{
                            visit[x] = 0;
                            x = (x+1) % M;
                        }
                    }
                }
                else{
                    map.push_back(arr[i]);
                    visit.push_back(1);
                }
                num++;
                //cout << "元素 : ";
                vector<int>::iterator v = map.begin();
                while( v != map.end()) {
                    cout << *v << " ";
                    v++;
                }
                //cout << endl;
                //cout << "visit : "; 
                // vector<int>::iterator y = visit.begin();
                // while( y != visit.end()) {
                //     cout << *y << " ";
                //     y++;
                // }
                
                cout << endl;
            }
        }
        num5 = num;
        cout << "总页数为: " << N << endl << "自创Clock算法缺页数: "  << num << endl << endl;
    
    
    
        cout << "综上所述 :" << endl;
        cout << "页码进入顺序为:" <<endl;
        for(int i=0;i<N;i++){ 
            cout << arr[i] << " ";
        }
        cout << endl;
        cout << "总页数为:" << N << endl;
        cout << "FIFO算法缺页数: "  << num1 << endl;
        cout << "LRU算法缺页数: "  << num2 << endl;
        cout << "OPT算法缺页数: "  << num3 << endl;
        cout << "Clock算法缺页数: "  << num4 << endl;
        cout << "自创Clock算法缺页数: "  << num5 << endl;
    
        return 0;
    }
    
    展开全文
  • 页面置换算法之 改进型Clock算法

    千次阅读 2020-12-05 20:37:38
    改进型Clock算法 由 访问位A 和 修改位M 可以组合成下面四种类型的页面: 1类(A=0, M=0):表示该页最近既未被访问,又未被修改,是最佳淘汰页。 2类(A=0, M=1):表示该页最近未被访问,但已被修改,并不是很好的...
  • 2.掌握近似 LRU 算法的原理,即 clock 算法 在存储分块表(或页表)中设一个“引用位”,当存储分块表中的某一页被访问时,该 位由硬件自动置 1,并由页面管理软件周期性把所有引用位置 0。这样,在一个时间周期
  • CLOCK算法 C语言 操纵系统
  • 操作系统os 页面置换算法 (java实现) Clock.java Lru.java Opt.java Fifo.java
  • 简单Clock算法

    万次阅读 2015-06-16 16:05:58
     简单Clock算法需要根据页面内存是否被访问来决定是否置换该页面。实际编程中,与最近最久未置换算法类似,用整型数组来表示当前每个内存页面是否被访问,其中1代表被访问过,0代表未访问过。每次置换,指针循环...
  • C语言改进的CLOCK算法

    2012-11-20 11:01:06
    比较清楚的显示了其运行的结果,程序较简单易懂...
  • 改进型clock算法--页面置换算法

    万次阅读 2016-06-17 13:45:23
    改进Clock算法——页面置换算法算法描述: 在将一个页面换出时,如果该页已被修改过,便须将该页重新写回到磁盘上;但如果该页未被修改过,则不必将它拷回磁盘。在改进型Clock算法中,除须考虑页面的使用情况外,...
  • 简单地实现clock算法~,可以模拟页面替换的过程,但并为涉及修改位的问题
  • 而该作者Leslie Lamport,同时也是共识算法Paxos的发明者,也是Latex的创作者,是一位非常可敬的牛人。   此文不长,主要以提出算法和数学证明为主。在这里我主要记录算法的主要思想,具体证明过程请参考原文深入...
  • 改进型Clock算法

    万次阅读 2015-06-16 16:15:50
    改进型的Clock算法需要综合考虑某一内存页面的访问位和修改位来判断是否置换该页面。在实际编写算法过程中,同样可以用一个等长的整型数组来标识每个内存块的修改状态。访问位A和修改位M可以组成一下四种类型的页面...
  • clock算法的源码

    2011-06-28 18:02:56
    #include"StdAfx.h" #include #include #include #define M 3 //内存物理块数 #define N 20 //虚拟内存尺寸
  • 操作系统实验 Clock算法 Clock算法 Clock算法
  • 改良后的Clock算法 考虑到如果某一调入内存的页没有被修改过,则不必将它拷回到磁盘。.1.严蔚敏数据结构的也有配套的c语言版带光盘的书是有卖的。 2.我开始学的时候也就是先指针,再结构体分解了去一块...
  • 关于操作系统 OS 的clock算法,C++编写
  • java实现的页面置换算法中的clock算法,带有详细注释
  • 模拟分页式存储管理中硬件的地址转换和产生缺页中断,然后分别用LRU、FIFO、改进型的CLOCK算法实现分页管理的缺页中断。 要求:显示每个页面在内存中的绝对地址,页表信息、列出缺页情况等。 #include #include #...
  • 二次机会法(或者enhanced clock) 改进型的CLOCK算法 思路:减少修改页的缺页处理开销 修改Clock算法,使它允许脏页总是在一次时钟头扫描中保留下来,同时使用脏位(dity bit,也叫写位)和使用位来指导置换 算法...
  • Forward初学操作系统——虚拟内存程序模拟实现,使用VC编写Clock算法,希望对大家有所帮助
  • 页面置换算法-CLOCK置换算法及其改进版算法

    万次阅读 多人点赞 2018-12-29 13:31:51
    页面置换算法中的LRU算法最接近理想情况下的OPT算法,但是实现起来比较困难且开销较大,所以很多设计者试图用开销比较小的算法接近LRU算法,CLOCK算法就是其中一种。 1.简单的CLOCK算法是通过给每一个访问的页面...
  • 设有5个进程P1、P2、P3、P4和P5,它们到达时间和要求服务时间如下表(单位为ms),请按时间片轮转调度算法完成,时间片大小为3。 Process: P1 P2 P3 P4 P5 到达相对时刻: 0 3 5 9 13 执行或服务时间: 7 6 10 8 2 ...
  • Clock简单算法自我理解总结,超详细

    千次阅读 2021-04-29 20:03:57
    Clock简单算法自我理解总结。 当页面队列的队头页面需要进入物理块时: 先检查物理块: ①若在物理块(内存)中能找到,则指针的位置不能变,将物理块中对应的页面的访问位设置为 1。 ②若在物理块中找不到(缺页)...
  • CLOCK置换算法: 是一种LRU的近似算法,是一种性能和开销较均衡的算法。由于LRU算法需要较多的硬件支持,采用CLOCK置换算法只需相对较少的硬件支持。又称为最近未用算法(NRU) 简单的CLOCK置换算法 1.实现方法:...
  • Clock置换算法

    千次阅读 2020-07-22 14:32:55
    当利用简单的Clock算法时,只需为每页设置一位访问位,再将内存中的所有页面都通过链接指针链成一个循环队列。当某页被访问时,其访问位置为1。置换算法在选择一页淘汰时,只需检查页的访问位。如果是0,就选择该页...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 46,895
精华内容 18,758
关键字:

clock算法

友情链接: RNDE_code.zip