zoukankan      html  css  js  c++  java
  • c模拟 页式管理页面置换算法之FIFO

    写的操作系统作业。。。。

    放上来给需要的小伙伴

    需要注意的地方:

    1.该算法只涉及单进程

    2.只是用c模拟FIFO的思想

    FIFO思想:选择在内存中存活时间最久的页面淘汰

    关于该算法我的理解:

    一个进程可以分为多个页面,页面大小一致,每个页面需要占用一个相同大小的内存块,在进程的页面较多而内存块较少的情况下,比如5个页面,3个内存块,这种情况内存块肯定是不够用的,当前面三个页面都有了自己的内存块之后,现在已经没有空的内存块了,第四个页面想要进入内存块中,就要从占用内存块的页面中淘汰一个,那么就需要定义一个淘汰的规则:我们这里使用的淘汰规则:FIFO规则,选择在内存中存活时间最久的页面淘汰

    代码分析:

    假设一共有一个进程,该进程可以分为5个不同的页面

    假设有3个内存块

    一共三个表

    第一个表:页面执行顺序数组表(表中存放的是页面的编号,意思是先执行2号页面,然后执行4号页面,再执行3号页面...........................最后又执行4号页面)(重复执行某个页面是因为代码需要重用,比如函数多次调用)

    2 4 3 0 1 2 4

    第二个表:页表(页表中的页号和上面的页面顺序执行表中的存的页号是对应的)

    页号 页面在内存块中的地址 页面在内存中存活的时间
    0 -1(最开始默认-1) 0(最开始默认0)
    1 -1 0
    2 0 3
    3 2 1
    4 1 2

    第三个表:内存块信息表(存放的是占用该内存块的页号)

    2 4 3

    现在执行顺序数组中的前面3个页面都有了内存块(2号页面,4号页面,3号页面)且内存块中已经没有了空闲的内存块,当页面执行顺序表中的0号页面要进入内存块的时候,就必须淘汰一个占用内存块的页面,按照FIFO的淘汰规则,存活时间最长的2号页面将被淘汰(2号页面存活时间为3秒)所以现在表回产生变化:

    页号 页面在内存块中的地址 页面在内存中存活的时间
    0 0 1
    1 -1 0
    2 -1 0
    3 2 2(时间滚动,增加1秒)
    4 1 3
    0(此时0号页面占用该内存块) 4(此时还是4号页面占用该内存块) 3此时还是3号页面占用该内存块)

    根据我们FIFO的淘汰规则:淘汰了2号页面,将2号页面占用的内存块交给了0号页面使用,现在页面执行顺序数组执行到了第4个,后面的依次类推,按照FIFO淘汰规则进行淘汰

    代码如下:

    #include <stdio.h>
    #include <stdlib.h>
    //数据结构  页式管理 FIFO 先进先出  单进程
    
    #define MEMORY_MAX_BLOCKS 10//定义物理块最大数量
    #define PROGRESS_MAX_PAGE 20  //定义虚拟页面的最大数量
    #define PROGRESS_MAX_LENGTH 30  //定义进程的最大长度
    
    //当前进程的相关信息
    int curProPages;//当前进程虚拟页
    int curMemoryBlocks;//当前进程物理块
    int proLength;// 进程执行长度
    int proSort[PROGRESS_MAX_LENGTH];//虚拟页执行顺序数组
    
    typedef struct PageItem
    {
        int vpage;//虚拟页的编号
        int mblock;//对应的物理号  默认不存在对应的内存块-1
        int loadTime;//该页面在内存中存在的时间
    } PageItem;
    
    PageItem pageList[PROGRESS_MAX_PAGE];//页表:
    
    int memoryAllocInfo[MEMORY_MAX_BLOCKS];//内存物理块分配信息,某个内存块放某个页面
    
    //初始化函数
    void init()
    {
        int i=0;
        curProPages=5;//虚拟页面数量
        curMemoryBlocks=3;//内存块数量
        proLength=7;//虚拟页执行顺序数组长度
        proSort[0]=2;//存放的是虚拟页的编号
        proSort[1]=4;
        proSort[2]=3;
        proSort[3]=0;
        proSort[4]=1;
        proSort[5]=2;
        proSort[6]=4;
        for(i=0; i<curProPages; i++) //页表的初始化
        {
            pageList[i].vpage=i;
            pageList[i].mblock=-1;
            pageList[i].loadTime=0;
        }
        for(i=0; i<curMemoryBlocks; i++) //内存块的初始化
        {
            memoryAllocInfo[i]=-1;
        }
    }
    
    void showInfo()
    {
        //页表信息打印
        printf("-------------------------------------------------------------
    ");
        printf("页表信息:
    ");
        printf("页号	页对应的内存块编号	页面在内存中存活的时间
    ");
        int i;
        for(i=0; i<curProPages; i++)
        {
            printf("%d		%d			%d
    ",pageList[i].vpage,pageList[i].mblock,pageList[i].loadTime);
        }
        printf("
    ");
        printf("内存块信息表:
    ");
        printf("内存块地址	存放在此的页面
    ");
        for(i=0; i<curMemoryBlocks; i++)
        {
            printf("%d		%d
    ",i,memoryAllocInfo[i]);
        }
        printf("-------------------------------------------------------------
    
    
    ");
    }
    
    //页表中已经存在于内存的虚拟页的时间加一个点
    void extnedTime()
    {
        int i=0;
        for(i=0; i<curProPages; i++)
        {
            if(pageList[i].mblock!=-1)
            {
                pageList[i].loadTime+=1;
            }
    
        }
    }
    
    //检查物理内存中是否有空闲的块
    int  findFreeBlock()
    {
        int i=0;
        for(i=0; i<curMemoryBlocks; i++)
        {
            if(memoryAllocInfo[i]==-1)
            {
                return i;
            }
        }
        return -1;//返回-1表示不存在空闲内存块
    }
    
    //FIFO淘汰
    //找到在内存块中存活时间最久的页面
    int fifoPage()
    {
    
        int i=0;
        int maxTime=-1;
        int vpage=-1;
        for(i=0; i<curProPages; i++)
        {
            if(pageList[i].mblock==-1)
            {
                continue;
            }
            if(pageList[i].loadTime>maxTime)
            {
                maxTime=pageList[i].loadTime;
                vpage=i;
            }
        }
        return vpage;
    }
    
    void fifo()
    {
        //开始程序执行,调用虚拟机
        int index;
        int vpage;
        int fpage;
        int freeIndex;
        for(index=0; index<proLength; index++)
        {
            vpage=proSort[index];
            //检查是否已经分配物理页
            if(pageList[vpage].mblock!=-1)
            {
                //对于已经存在于内存的虚拟页都必须加一个时间点
                extnedTime();
            }
            else
            {
                //说明虚拟页没有在内存中
                //检查内存中是否有空闲块
                freeIndex=findFreeBlock();
                if(freeIndex!=-1)
                {
                    memoryAllocInfo[freeIndex]=vpage;
                    pageList[vpage].mblock=freeIndex;
                    extnedTime();
                }
                else
                {
                    //空闲区没有
                    //查页表:淘汰最长时间
                    fpage=fifoPage();
                    //找到在内存中所占有的物理块
                    freeIndex=pageList[fpage].mblock;
                    //更新淘汰的虚拟页的相关信息
                    pageList[fpage].loadTime=0;
                    pageList[fpage].mblock=-1;
                    //更新分配情况
                    memoryAllocInfo[freeIndex]=vpage;
                    //更新当前调到内存中的虚页的信息
                    pageList[vpage].mblock=freeIndex;
                    extnedTime();
                }
            }
            showInfo();
        }
    }
    
    int main()
    {
        //初始化(交互)
        init();
        //显示()
        showInfo();
        //核心逻辑()
        fifo();
        return 0;
    }

    运行结果如下:

    运行结果符合预期

    希望能给看到此博文的你一点小小的帮助!

  • 相关阅读:
    Python 通过最低位判断数字是偶数还是奇数
    C语言 windows下Ansi和UTF-8编码格式的转换
    C语言 Ubuntu系统 UTF-8 文字处理
    C语言 使用char字符实现汉字处理
    C# GUI应用 实现 2048游戏
    Docker部署Minio
    Ubuntu18.04开启root
    Ubuntu18.04安装Docker
    docker安装mysql
    idea启动项目端口被占用
  • 原文地址:https://www.cnblogs.com/yinbiao/p/9084213.html
Copyright © 2011-2022 走看看