分页式存储管理页面置换算法——LRU、FIFO、改进型的CLOCK算法

原创 2016年05月30日 14:55:42
(文章原理待更新)

模拟分页式存储管理中硬件的地址转换和产生缺页中断,然后分别用LRU、FIFO、改进型的CLOCK算法实现分页管理的缺页中断。

要求:显示每个页面在内存中的绝对地址,页表信息、列出缺页情况等。

#include<iostream>
#include<cmath>
#include<stdio.h>
#include<algorithm>
#include<string.h>
#include<queue>
#include<stack>
#include<time.h>
#define Max 1024
using namespace std;
int len;
int str[Max];///页面号序列
int block;///系统为进程分配的物理块
int que[Max];///模拟队列
struct Page
{
    int sta;///内存位当前状态
    int A;///访问位
    int M;///修改位
    int tim;///距离上一次访问时长
    int dis;///距离上一次访问距离
} Q[Max];
void init()
{
    printf("请输入页面号序列长度:");
    cin>>len;
    printf("请输入页面号引用串序列:");
    for(int i=1; i<=len; i++) cin>>str[i];
    printf("请输入系统为进程分配的物理块:");
    cin>>block;
    for(int i=0; i<=block; i++)
        que[i]=-1;///初始值置为-1代表当前物理块为空
}
void print(int x)
{

    printf("当前需访问第 %d 页   ",str[x]);
    for(int i=1; i<=block; i++)
    {
        printf("[%3d] ",que[i]);
    }
    puts("");
}
void FIFO()
{
    printf("选择使用FIFO算法进行页面置换\n");
    init();
    int flag=1;///记录要进行页面置换的位置
    for(int i=1; i<=len; i++)
    {
        int j;
        int ok=0;
        for(j=1; j<=block; j++)
        {
            if(str[i]==que[j])
                ok=1;
        }
        if(que[block]==-1&&!ok)
        {
            for(j=1; j<=block; j++)
            {
                if(que[j]==-1)
                {
                    que[j]=str[i];
                    break;
                }
            }
        }
        else if(que[block]!=-1&&!ok)
        {
            printf("产生缺页中断\n");
            que[flag]=str[i];
            flag++;
            if(flag>block)
                flag=1;
        }
        print(i);
    }
    puts("");
    printf("算法执行结束\n\n");
}
void LRU()
{
    printf("选择使用LRU算法进行页面置换\n");
    init();
    for(int i=1; i<=len; i++)
    {
        int ok=0,j;
        for(j=1; j<=block; j++)
        {
            if(str[i]==que[j])
                ok=1;
        }
        if(que[block]==-1&&!ok)///内存中没有,并且内存未满
        {
            for(j=1; j<=block; j++)
            {
                if(que[j]==-1)
                {
                    que[j]=str[i];
                    break;
                }
            }
        }
        else if(que[block]!=-1&&!ok)///内存中没有,但是内存已满需要置换
        {
            printf("产生缺页中断\n");
            for(j=2; j<=block; j++) que[j-1]=que[j];
            que[block]=str[i];
        }
        else if(que[block]==-1&&ok)///内存中有,但是内存未满,只需要调换位置类型1
        {
            int k;///记录与当前页面好匹配的页面号位置
            for(j=1; j<=block; j++)
            {
                if(que[j]==str[i])
                {
                    k=j;
                }
            }
            for(j=k+1; j<=block; j++)
            {
                if(que[j]==-1)
                    break;
                else
                    que[j-1]=que[j];
            }
            que[j-1]=str[i];
        }
        else if(que[block]!=-1&&ok)///内存中有,但是内存已满,只需要调换位置类型2
        {
            int k;///记录与当前页面好匹配的页面号位置
            for(j=1; j<=block; j++)
            {
                if(que[j]==str[i])
                {
                    k=j;
                }
            }
            for(j=k+1; j<=block; j++)
                que[j-1]=que[j];
            que[block]=str[i];
        }
        print(i);
    }
    puts("");
    printf("算法执行结束\n\n");
}
///判断页面是否已经被修改
bool change()
{
    if((rand()%2+1) == 1 )
    {
        printf("该页面被修改!\n");
        return true;
    }
    else
        return false;
}
///检测页号是否在内存中并把访问位和修改位置1
bool inblock(int num)
{
    for(int i=1; i<=block; i++)
    {
        if(Q[i].sta == str[num])
        {
            if(change())
            {
                Q[i].A=1;
                Q[i].M=1;
            }
            else
            {
                Q[i].A=1;
                Q[i].M=0;
            }
            return true;
        }
    }
    return false;
}
int Search()
{
    int j;
    for(j=1;j<=block;j++)
    {
        if(Q[j].A==0&&Q[j].M==0)
            return j;
    }
    for(j=1;j<=block;j++ )
    {
        if(Q[j].A==0&&Q[j].M==1)
            return j;
        Q[j].A=0;
    }
    for(j=1;j<=block;j++ )
    {
        Q[j].A=0;
    }
    return Search();
}
void SNRU()
{
    printf("选择使用改进型Clock算法进行页面置换\n");
    init();
    int j;
    for(int i=1; i<=block; i++)
    {
        Q[i].sta=-1;
        Q[i].A=0;
        Q[i].M=0;
    }
    for(int i=1; i<=len; i++)
    {
        printf("当前需访问的页面为 %d !\n",str[i]);
        if(inblock(i))///页面已存在于内存中
        {
            printf("该页面已存在于内存中\n");
        }
        else if(Q[block].sta!=-1)///页面未存在于内存中并且内存已满
        {
            j=Search();
            Q[j].sta=str[i];
            Q[j].A=1;
        }
        else ///内存未满,并且页面未存在于内存中
        {
            for(int k=1;k<=block;k++)
            {
                if(Q[k].sta==-1){
                    Q[k].sta=str[i];
                    break;
                }
            }
        }
        for(int k=1;k<=block;k++)
        {
            printf("[ %3d ] ",Q[k].sta);
        }
        puts("");
    }
    puts("");
    printf("算法执行结束\n\n");
}
int main()
{
    while(1)
    {
        printf("请选择要使用的页面置换算法或选择退出:\n");
        printf("***************************************************************\n");
        printf("1.FIFO置换算法   2.LRU置换算法   3.改进型Clock算法    4.退出\n");
        printf("***************************************************************\n");
        int tmp;
        cin>>tmp;
        if(tmp==1) FIFO();
        else if(tmp==2) LRU();
        else if(tmp==3) SNRU();
        else if(tmp==4) break;
        else
        {
            printf("输入有错误,请重新选择!\n");
        }
    }
    return 0;
}

/*
20
7 0 1 2 0 3 0 4 2 3 0 3 2 1 2 0 1 7 0 1
3

11
4 7 0 7 1 0 1 2 1 2 6
5
*/


版权声明:本文为博主原创文章,未经博主允许不得转载。

改进型Clock算法

算法过程: 改进型的Clock算法需要综合考虑某一内存页面的访问位和修改位来判断是否置换该页面。在实际编写算法过程中,同样可以用一个等长的整型数组来标识每个内存块的修改状态。访问位A和修改位M可...
  • u012432778
  • u012432778
  • 2015年06月16日 16:15
  • 2626

改进型clock算法--页面置换算法

改进Clock算法——页面置换算法算法描述: 在将一个页面换出时,如果该页已被修改过,便须将该页重新写回到磁盘上;但如果该页未被修改过,则不必将它拷回磁盘。在改进型Clock算法中,除须考虑...
  • u013006139
  • u013006139
  • 2016年06月17日 13:45
  • 3570

常用页面置换算法总结

进程运行时,若其访问的页面不在内存而需将其调入,但内存已无空闲空间时,就需要从内存中调出一页程序或数据,送入磁盘的对换区。 选择调出页面的算法就称为页面置换算法。好的页面置换算法应有较低的页面更...
  • a724888
  • a724888
  • 2017年04月10日 22:46
  • 6102

FIFO先进先出页面置换实现请求分页

FIFO页面淘汰算法,实现请求分页。基本分页是实存管理方式,请求分页是虚存管理方式。虚存是是指具有请求调入功能和置换功能, 能从逻辑上对内存容量加以扩充的一种存储器系统。它避免了一次性将程序全部调入内...
  • qq_27483535
  • qq_27483535
  • 2016年11月26日 11:48
  • 912

简单Clock算法

算法过程:          简单Clock算法需要根据页面内存是否被访问来决定是否置换该页面。实际编程中,与最近最久未置换算法类似,用整型数组来表示当前每个内存页面是否被访问,其中1代表被访问...
  • u012432778
  • u012432778
  • 2015年06月16日 16:05
  • 7745

页面置换算法(最佳,FIFO,LRU,随机,简单CLOCK,改进CLOCK)

  • 2012年05月15日 11:11
  • 19KB
  • 下载

几种置换算法

地址映射过程中,若在页面中发现所要访问的页面不再内存中,则产生缺页中断。当发生缺页中断时操作系统必须在内存选择一个页面将其移出内存,以便为即将调入的页面让出空间。而用来选择淘汰哪一页的规则叫做页面置换...
  • xiuquanhuadie
  • xiuquanhuadie
  • 2015年10月18日 20:57
  • 1417

操作系统课程设计(Clock页面置换算法模拟)

  • 2011年09月09日 15:30
  • 4.59MB
  • 下载

【操作系统-存储器管理】简单的clock置换算法的实现

分析:clock置换算法是利用循环队列来实现的。操作系统课本上的讲解时这样的 代码实现: #include using namespace std; typedef struct number...
  • wodeai1625
  • wodeai1625
  • 2015年04月19日 14:45
  • 782

ceph存储 缓存淘汰算法--LRU算法

 1. LRU 1.1. 原理 LRU(Least recently used,最近最少使用)算法根据数据的历史访问记录来进行淘汰数据,其核心思想是“如果数据最近被访问过,那么将来被访问的几...
  • skdkjxy
  • skdkjxy
  • 2016年04月25日 17:05
  • 732
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:分页式存储管理页面置换算法——LRU、FIFO、改进型的CLOCK算法
举报原因:
原因补充:

(最多只允许输入30个字)