精华内容
下载资源
问答
  • fifo页面置换算法c语言
    2022-05-10 10:27:54

    网上资源虽多,但是要想把这两个算法的细节理解的透彻,还得是自己写

    1.FIFO

    #include <stdio.h>
    #include <stdlib.h>
    #include <time.h>
    //主要数据结构
    #define total_instrucion 15//总的页面访问次数
    #define max_block_num 10//最大内存分配
    
    int Access_Series[total_instrucion];//内存访问序列
    char Lack[total_instrucion];//记录是否缺页
    struct one_block {//一个物理块
        int page_no;//物理块内的页面号
        int cnt;//计数,用于确定最先进入的页面(FIFO)
    }blocks[max_block_num];
    int table[max_block_num][total_instrucion];//显示矩阵
    void FIFO(int block_num){
        int diseffect;//缺页数
        for (int i = 0; i < total_instrucion; i++)
            Lack[i] = 'N';//初始化不缺页
        //数据结构blocks的初始化
        for (int i = 0; i < block_num; i++) {
            blocks[i].page_no = -1;//初始化页号为-1,当前有空闲页面
            blocks[i].cnt = 0;//初始化计数
        }
        //开始访问页面
        for (int i = 0; i < total_instrucion; i++) {
            char full = 'T';//是否内存满
            char hit = 'F';//是否命中
            for (int j = 0; j < block_num; j++) {
                if (blocks[j].page_no == Access_Series[i]) {//命中的情况
                    hit = 'T';
                    break;
                }else if (blocks[j].page_no == -1) {//未命中,且内存未满的情况
                    blocks[j].page_no = Access_Series[i];
                    blocks[j].cnt = j + 1;
                    Lack[i] = 'Y';//缺页
                    diseffect++;
                    full = 'F';//内存未满
                    break;
                }
            }
            if (full == 'T') {//内存已满
                if (hit == 'F') {//若未命中
                    diseffect++;
                    Lack[i] = 'Y';
                    int target = -1;//选中替换目标
                    for (int j = 0; j < block_num; j++) {
                        blocks[j].cnt--;//发生页面置换
                        if (blocks[j].cnt == 0)
                            target = j;
                    }
                    blocks[target].page_no = Access_Series[i];
                    blocks[target].cnt = block_num;
                }
            }
            for (int j = 0; j < block_num; j++)
                table[j][i] = blocks[j].page_no;
        }
    
        /*输出运行过程及结果*/
        printf("采用FIFO页面置换算法结果如下:");
        printf("\n");
        printf("页号:");
        for (int i = 0; i < total_instrucion; i++)
            printf("%3d", Access_Series[i]);
        printf("\n");
        printf("-----------------------------------------------------\n");
        for (int i = 0; i < block_num; i++) {
            printf("块%2d:", i+1);
            for (int j = 0; j < total_instrucion; j++)
                printf("%3d", table[i][j]);
            printf("\n");
        }
        printf("-----------------------------------------------------\n");
        printf("缺页:");
        for (int i = 0; i < total_instrucion; i++)
            printf("%3c", Lack[i]);
        printf("\n");
        printf("-----------------------------------------------------\n");
        printf("\t缺页次数:%d\t缺页率:%d/%d\n", diseffect, diseffect, total_instrucion);
        printf("-----------------------------------------------------\n");
    }
    int main(){
        //初始化
        //父进程随机产生内存访问页面序列,存于数组Acess_Series[total_instruction]中
        srand((unsigned)time(NULL));
        for (int i = 0; i < total_instrucion; i++)
            Access_Series[i] = rand() % total_instrucion;
        int block_num;
        while(1){
            printf("请输入分配的物理块数(-1退出):");
            scanf("%d",&block_num);
            if(block_num==-1) break;
            FIFO(block_num);
        }
        return 0;
    }
    

    2.LRU

    #include <stdio.h>
    #include <stdlib.h>
    #include <time.h>
    //主要数据结构
    #define total_instrucion 15//总的页面访问次数
    #define max_block_num 10//最大内存分配
    
    int Access_Series[total_instrucion];//内存访问序列
    char Lack[total_instrucion];//记录是否缺页
    struct one_block {//一个物理块
        int page_no;//物理块内的页面号
        int tim;//计时,用于确定最近最久未使用的页面(LRU)
    }blocks[max_block_num];
    int table[max_block_num][total_instrucion];//显示矩阵
    void LRU(int block_num){
        int diseffect;//缺页数
        for (int i = 0; i < total_instrucion; i++)
            Lack[i] = 'N';//初始化不缺页
        //数据结构blocks的初始化
        for (int i = 0; i < block_num; i++) {
            blocks[i].page_no = -1;//初始化页号为-1,当前有空闲页面
            blocks[i].tim = 0;//初始化计时
        }
        //开始访问页面
        for (int i = 0; i < total_instrucion; i++) {
            char full = 'T';//是否内存满
            char hit = 'F';//是否命中
            for (int j = 0; j < block_num; j++)
                blocks[j].tim++;//计时器加1
            for (int j = 0; j < block_num; j++) {
                if (blocks[j].page_no == Access_Series[i]) {//命中的情况
                    hit = 'T';
                    blocks[j].tim=0;//刚刚访问,值变为0
                    break;
                }else if (blocks[j].page_no == -1) {//未命中,且内存未满的情况
                    blocks[j].page_no = Access_Series[i];
                    blocks[j].tim=0;//刚刚访问,值变为0
                    Lack[i] = 'Y';//缺页
                    diseffect++;
                    full = 'F';//内存未满
                    break;
                }
            }
            if (full == 'T') {//内存已满
                if (hit == 'F') {//若未命中
                    diseffect++;
                    Lack[i] = 'Y';
                    int target = 0;//选中替换目标
                    for (int j = 1; j < block_num; j++) {
                        if (blocks[j].tim>blocks[target].tim)
                            target = j;
                    }
                    blocks[target].page_no = Access_Series[i];
                    blocks[target].tim=0;//刚刚访问,值变为0
                }
            }
            for (int j = 0; j < block_num; j++)
                table[j][i] = blocks[j].page_no;
        }
    
        /*输出运行过程及结果*/
        printf("采用LRU页面置换算法结果如下:");
        printf("\n");
        printf("页号:");
        for (int i = 0; i < total_instrucion; i++)
            printf("%3d", Access_Series[i]);
        printf("\n");
        printf("-----------------------------------------------------\n");
        for (int i = 0; i < block_num; i++) {
            printf("块%2d:", i+1);
            for (int j = 0; j < total_instrucion; j++)
                printf("%3d", table[i][j]);
            printf("\n");
        }
        printf("-----------------------------------------------------\n");
        printf("缺页:");
        for (int i = 0; i < total_instrucion; i++)
            printf("%3c", Lack[i]);
        printf("\n");
        printf("-----------------------------------------------------\n");
        printf("\t缺页次数:%d\t缺页率:%d/%d\n", diseffect, diseffect, total_instrucion);
        printf("-----------------------------------------------------\n");
    }
    int main(){
        //初始化
        //父进程随机产生内存访问页面序列,存于数组Acess_Series[total_instruction]中
        srand((unsigned)time(NULL));
        for (int i = 0; i < total_instrucion; i++)
            Access_Series[i] = rand() % total_instrucion;
        int block_num;
        while(1){
            printf("请输入分配的物理块数(-1退出):");
            scanf("%d",&block_num);
            if(block_num==-1) break;
            LRU(block_num);
        }
        return 0;
    }
    

    更多相关内容
  • opt、FIFO、LRU/LFU、简单clock、改进型clock等算法实现页面置换
  • 操作系统FIFO页面置换算法C语言

    千次阅读 2019-11-22 23:42:17
    先进先出(FIFO)页面置换算法: 这是最早出现的置换算法。该算法总是淘汰最先进入内存的页面,即选择在内存中驻留时间最久的页面予以淘汰。该算法实现简单只需把一个进程已调入内存的页面,按先后次序存入一个时间...

    先进先出(FIFO)页面置换算法: 这是最早出现的置换算法。该算法总是淘汰最先进入内存的页面,即选择在内存中驻留时间最久的页面予以淘汰。该算法实现简单只需把一个进程已调入内存的页面,按先后次序存入一个时间数组,并将其中时间值最大的页面进行淘汰,并替换入新的页面就可以实现。

    这里取了个巧,用到了循环单链表结构
    在替换时,确保指针old指向的总是将要被替换的;
    因为要FIFO替换的总是先进来的,而且后续就算命中也不会因此改变置换顺序
    所以一开始old就是指向第一个结点即最先装载的页面,只有当没有命中时才替换当前页面,并且old = old->next;一直循环,直到所有待访问页面执行完;
    check用来遍历查找是否命中,命中无操作,否则替换,并且old=old->next;

    #include <stdio.h>
    #include <stdlib.h>
    #define maxpagenum 100
    typedef struct page
    {
        int pagenum;
        struct page *next;
    }Page;
    int FIFO(Page *block,int pages[maxpagenum],int pagenum,int blocknum)
    {
        int i = 0,j = 0;
        int time = 0;
        Page *old = block,*check = NULL;
        while(i<pagenum){
            check = block;
            j = 0;
            while(j < blocknum){
                if(pages[i]==check->pagenum)// 命中
                    break;
                check = check->next;
                j++;
            }
            if(j == blocknum){//没有命中,替换
                old->pagenum = pages[i];
                old = old->next;
                time += 1; //缺页次数+1
            }
            i++;
        }
        return time;
    }
    Page* creatblock(int blocknum)
    {
        int i;
        Page *head = NULL,*cur = NULL,*tail = NULL;
        for(i = 0;i < blocknum;i++){
            if(!head){
                cur = (Page*)malloc(sizeof(Page));
                cur->pagenum = -1;
                cur->next = NULL;
                head = tail = cur;
            }
            else{
                cur = (Page*)malloc(sizeof(Page));
                cur->pagenum = -1;
                tail->next = cur;
                tail = cur;
            }
        }
        tail->next = head;
        return head;
    }
    int main()
    {
        int time;
        int pages[maxpagenum];
        int i,blocknum,pagenum;
        Page *head=NULL;
        printf("请输入块号:\n");
        scanf("%d",&blocknum);
        head = creatblock(blocknum);
        printf("请输入待访问的页面数量:\n");
        scanf("%d",&pagenum);
        printf("请输入待访问的页面号:\n");
        for(i=0;i<pagenum;i++){
            scanf("%d",&pages[i]);
        }
        time = FIFO(head,pages,pagenum,blocknum);
        printf("缺页次数:%d,中断率:%.2f%%\n",time,time*1.0/pagenum*100);
        return 0;
    }
    
    展开全文
  • 第 PAGE 8 页 共 NUMPAGES13 页 操作系统原理 上机作业报告 作业 页 面 淘 汰 算 法 作业编号 6 题目 页面淘汰/置换算法 作业要求 题目要求通过模拟实现请求页式存储管理的几种基本页面置换算法了解虚拟存储技术的...
  • 广东工业大学 操作系统实验 实验内容 假设每个页面中可存放...如果4个内存块均已装入该作业,则需进行页面置换,最后显示其物理地址,并转下一条指令。在所有320指令执行完毕后,请计算并显示作业运行过程中发生的缺页

    广东工业大学 操作系统实验

    实验内容

    假设每个页面中可存放10条指令,分配给作业的内存块数为4。用C语言模拟一个作业的执行过程,该作业共有320条指令,即它的地址空间为32页,目前它的所有页都还未调入内存。在模拟过程中,如果所访问的指令已在内存,则显示其物理地址,并转下一条指令。如果所访问的指令还未装入内存,则发生缺页,此时需记录缺页的次数,并将相应页调入内存。如果4个内存块均已装入该作业,则需进行页面置换,最后显示其物理地址,并转下一条指令。在所有320指令执行完毕后,请计算并显示作业运行过程中发生的缺页率。

    置换算法:采用先进先出(FIFO)页面置换算法。

    通过随机数产生一个指令序列,共320条指令:
    1)指令的地址按下述原则生成:
    ① 50%的指令是顺序执行的;
    ② 25%的指令是均匀分布在前地址部分;
    ③ 25%的指令是均匀分布在后地址部分;
    具体的实施方法是:
    ① 在[0,319]的指令地址之间随机选取一起点m;
    ② 顺序执行一条指令,即执行序号为m+1的指令;
    ③ 在前地址[0,m-1]中随机选取一条指令并执行,该指令的序号为m1;
    ④ 顺序执行一条指令,其序号为m1+1的指令;
    ⑤ 在后地址[m1+2,319]中随机选取一条指令并执行,该指令的序号为m2;
    ⑥ 顺序执行一条指令,其序号为m2+1的指令;
    重复上述步骤①~⑥,直到执行320次指令。
    2)将指令序列变换为页地址流
    设页面大小为1K, 用户虚存容量为32K。在用户虚存中,按每K存放10条指令排列虚存地址,即320条指令在虚存中的存放方式为:
    第0条~第9条指令为第0页(对应虚存地址为[0,9]);
    第10条~第19条指令为第1页(对应虚存地址为[10,19]);
    ……
    ……
    第310条~第319条指令为第31页(对应虚存地址为[310,319])。
    按以上方式,用户指令可组成32页。

    代码实现

    #include <stdio.h>
    #include <stdlib.h>
    
    float count = 0; //缺页次数
    
    typedef struct Data //数据域
    {
        int pageNum; //装进的用户虚存页号
        int blockNum; //块号
    } Data;
    
    typedef struct BlockNode //单向循环链表
    {
        Data data;
        struct BlockNode *next;
    } Block, *BlockList;
    
    //定义内存块
    BlockList block1;
    BlockList block2;
    BlockList block3;
    BlockList block4;
    Block *p;
    
    void initialize() //初始化
    {
        block1 = (BlockList)malloc(sizeof(Block));
        block2 = (BlockList)malloc(sizeof(Block));
        block3 = (BlockList)malloc(sizeof(Block));
        block4 = (BlockList)malloc(sizeof(Block));
        p = block1;
    
        block1->data.pageNum = -1;
        block2->data.pageNum = -1;
        block3->data.pageNum = -1;
        block4->data.pageNum = -1;
    
        block1->data.blockNum = 0;
        block2->data.blockNum = 1;
        block3->data.blockNum = 2;
        block4->data.blockNum = 3;
    
        block1->next = block2;
        block2->next = block3;
        block3->next = block4;
        block4->next = block1;
    }
    
    int FIFO(int pageNum, int virAddr) //先进先出页面置换算法
    {
        BlockList q = p; //存储p原来的位置
    
        for(int i = 0; i < 4; i++) //判断块中内存是否均已加载数据并且指令是否已在内存中
        {
            if(p->data.pageNum == -1) //块为空闲
            {
                p->data.pageNum = pageNum;
                count++; //缺页次数+1
                printf("指令未装入内存!页面置换完成!\n用户指令第%d页第%d条的物理地址为:第%d块第%d条 \n\n", pageNum, (virAddr % 10), p->data.blockNum, (virAddr % 10));
                p = block1; //指向最先被分配的块1;
    
                return 1;
            }
    
            if(p->data.pageNum == pageNum)
            {
                printf("指令已在内存中!\n用户指令第%d页第%d条的物理地址为:第%d块第%d条 \n\n", pageNum, (virAddr % 10), p->data.blockNum, (virAddr % 10));
                p = q;//页面没有发生置换,指针指向原最老的页面
    
                return 1;
            }
    
            p = p->next;
        }
    
        p->data.pageNum = pageNum;
        count++;
        printf("指令未装入内存且内存块已满!页面置换完成!\n用户指令第%d页第%d条的物理地址为:第%d块第%d条 \n\n", pageNum, (virAddr % 10), p->data.blockNum, (virAddr % 10));
    
        p = p->next; //指向最老的页面
    
        return 1;
    }
    
    void calculate() //生成页地址流并计算缺页率
    {
        for(int i = 0; i < 320; )
        {
            int m = rand() % 320;
            printf("指令地址为:%d \n", (m + 1));
            FIFO(((m + 1) / 10), m + 1);
            i++;
    
            int m1 = rand() % (m - 1);
            printf("指令地址为:%d \n", m1);
            FIFO((m1 / 10), m1);
            i++;
    
            printf("指令地址为:%d \n", (m1 + 1));
            FIFO(((m1 + 1) / 10), m1 + 1);
            i++;
    
            int m2 = rand() % (319 - m1 - 1) + m1 + 2;
            printf("指令地址为:%d \n", m2);
            FIFO((m2 / 10), m2);
            i++;
    
            printf("指令地址为:%d \n", (m2 + 1));
            FIFO(((m2 + 1) / 10), m2 + 1);
            i++;
        }
    
        printf("\n");
        printf("缺页次数:%.0f\n", count);
        printf("计算得到的缺页率为:%.4f \n", count / 320);
    }
    
    int main()
    {
        printf("----------先进先出页面置换算法----------\n\n");
    
        initialize();
        calculate();
    
        return 0;
    }
    
    展开全文
  • OPT算法FIFO算法、LRU算法、LFU算法的具体实现
  • 页面置换算法C语言实现(先进先出FIFO、最近最久未使用LRU C语言实现)

    1. 实现效果

    在这里插入图片描述
    在这里插入图片描述

    2. 源代码

    #include<iostream>
    #include<process.h>
    #include<stdlib.h>
    #include<ctime>
    #include<conio.h>
    #include<stdio.h>
    #include<string.h>
    using namespace std;
    
    #define Myprintf printf("|---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---|\n")/*表格控制*/
    #define bsize 4 //物理块大小
    #define psize 16 //进程大小
     void chushihua();//初始化函数
     void ymzh();
     void yemianzhihuan ();
     void changeaddr(struct Page p[], int logaddr);
     void dizhizhuanhuan();
     void menu();
     int wang();
    
     int yemianliu[32]={0};//全局变量数组,地址流
     int p;
     struct Page  {
         int pno;//页号
         int flag;//标志位
         int cno;//主存号
         int modf;//修改位
         int addr;//外存地址
    }Page;  //全局变量p是一共有多少地址流
    
     typedef struct pagel
     {
         int num; /*记录页面号*/
         int time;  /*记录调入内存时间*/
     }Pagel;  /*页面逻辑结构,方便算法实现*/
    
     Pagel b[bsize]; /*内存单元数*/
     int c[bsize][psize];/*保存内存当前的状态:缓冲区*/
     int queue[100];/*记录调入队列*/
     int k;/*调入队列计数变量*/
     int phb[bsize]={0};//物理块标号
     int pro[psize]={0};//进程序列号
     int flag[bsize]={0};//进程等待次数(存放最久未被使用的进程标志)*/
     int i=0,j=0;//i表示进程序列号,j表示物理块号*/
     int m =-1,n =-1;//物理块空闲和进程是否相同判断标志*/
     int mmax=-1, maxflag=0;//标记替换物理块进程下标*/
     int count =0; //统计页面缺页次数
    
     void chushihua() //初始化函数
    {
         int t;
         srand(time(0));//随机产生指令序列
             p=12+rand()%32;
         cout<<"地址流序列:";
         cout<<endl;
         for(i=0; i<p; i++)
         {
             t=1+rand()%9;
             yemianliu[i]=t;//将随机产生的指令数存入页面流
        }
        for (i=p-1;i>=0;i--)
        {
            cout<<yemianliu[i]<<" ";
        }
        cout<<endl;
    }
    void ymzh()
    {
        chushihua();
         yemianzhihuan();
    }
    
     void yemianzhihuan()
     {
          int a;
         printf("----------------------------------\n");
         printf("☆☆欢迎使用分页模拟实验系统☆☆\n");
         printf("----------------------------------");
         printf("☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆\n");
         printf("☆☆1.进入硬件地址变换算法  ☆☆\n");
         printf("☆☆------------------------☆☆\n");
         printf("☆☆2.进入页面置换算法      ☆☆\n");
         printf("☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆\n");
         printf("请输入您的选择:");
     switch(a)
     {
         case 1:
             ymzh();
             break;
         case 2:
             wang();
             break;
         default:
         cout<<"输入有误,请重新输入!"<<endl;
         break;
     }
    }
    
     void changeaddr(struct Page p[], int logaddr){//地址变换
         int j=logaddr/64;//对应的块号
         int k=logaddr%64; //对应的偏移量
         int flag=0;
         int addr;
         for(int i=0;i<8;i++)
         {
            if(p[i].pno==j)//找到对应的页号
            {
                if(p[i].flag==1)//页面标志为1
                {
                 addr=p[i].cno*64+k;
                 cout<<"物理地址为:"<<addr<<endl;
                 cout<<"详细信息:"<<"\t页面号:"<<p[i].pno<<"\t 主存号:"<<p[i].cno<<"\t偏移量:"<<k<<endl;
                 flag=1;
                 break;
                }
            }
        }
    
            if(flag==0)
                cout<<"该页不在主存,产生缺页中断"<<endl;
        }
    
     void dizhizhuanhuan()
     {
         int a;
         int ins;//指令逻辑地址
         struct Page p[8];
        p[0].pno=0;p[0].flag=1;p[0].cno=5;p[0].modf=1;p[0].addr=011;
        p[1].pno=1;p[1].flag=1;p[1].cno=8;p[1].modf=1;p[1].addr=012;
        p[2].pno=2;p[2].flag=1;p[2].cno=9;p[2].modf=0;p[2].addr=013;
        p[3].pno=3;p[3].flag=1;p[3].cno=10;p[3].modf=0;p[3].addr=015;
        p[4].pno=4;p[4].flag=0;p[4].addr=017;
        p[5].pno=5;p[5].flag=0;p[5].addr=025;
        p[6].pno=6;p[6].flag=0;p[6].addr=212;
        p[7].pno=7;p[7].flag=0;p[7].addr=213;
         printf("\t\t\t--------------------------------\n");
         printf("\t\t\t☆☆欢迎使用分页模拟实验系统☆☆\n");
         printf("\t\t\t---------------------------------\n");
         printf("\t\t\t☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆\n");
         printf("\t\t\t☆☆1.输入指令              ☆☆\n");
         printf("\t\t\t☆☆------------------------☆☆\n");
         printf("\t\t\t☆☆2.进入页面置换算法      ☆☆\n");
         printf("\t\t\t☆☆------------------------☆☆\n");
         printf("\t\t\t☆☆0.EXIT                  ☆☆\n");
         printf("\t\t\t☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆\n");
     while(a!=0)
     {
        cout<<endl<<"请输入您的选择:";
         cin>>a;
    
        cout<<"页号"<<"标记位"<<"外存地址"<<"主存号"<<endl;
         for(int i=0;i<8;i++)
         {
             cout<<p[i].pno<<"\t"<<p[i].flag<<"\t"<<p[i].addr<<"\t";
             if(p[i].flag)
             cout<<p[i].cno;
             cout<<endl;
        }
    
     switch(a)
     {
         case 0:printf("\t\t\t再见!\t\t\t\n"); break;
         case 1:
             cout<<"请输入指令的逻辑地址:";
             cin>>ins;
             changeaddr(p, ins);break;
         case 2: system("CLS"); a=wang();break;
         default:cout<<"输入有误,请重新输入!"<<endl;break;
        }
    }
    }
    
     void menu()
     {
     int a;
         printf("\t\t\t--------------------------------\n");
         printf("\t\t\t☆☆欢迎使用分页模拟实验系统☆☆\n");
         printf("\t\t\t---------------------------------\n");
         printf("\t\t\t☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆\n");
         printf("\t\t\t☆☆1.输入指令              ☆☆\n");
         printf("\t\t\t☆☆------------------------☆☆\n");
         printf("\t\t\t☆☆2.进入页面置换算法      ☆☆\n");
         printf("\t\t\t☆☆------------------------☆☆\n");
         printf("\t\t\t☆☆0.EXIT                  ☆☆\n");
         printf("\t\t\t☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆\n");
         printf("请选择所要执行的操作:");
         scanf("%d",&a);
         switch(a)
         {
         case 0: printf("\t\t\t-再见!-\t\t\t\n");break;
         case 1: dizhizhuanhuan (); break;
         case 2: wang (); break;
         default:cout<<"输入有误,请重新输入!"<<endl;break;
        }
    }
    int main()
     {
         menu();
    }
    
    //****************随机产生序列号函数
     int* build()
     {
         printf("随机产生一个进程序列号为:\n");
         int i=0;
         for(i=0; i<psize; i++)
         {
             pro[i]=10*rand()/(RAND_MAX+1)+1;
             printf("%d ", pro[i]);
    }
         printf("\n");
         return(pro);
    }
    
    //***************************************查找空闲物理块
     int searchpb()
     {
         for (j=0;j<bsize; j++)
         {
             if(phb[j] == 0)
             {
                   m=j;
                 return m;
                 break;
            }
        }
         return -1;
    }
    //************************************查找相同进程
     int searchpro()
     {
         for(j=0;j< bsize;j++)
         {
             if(phb[j] =pro[i])
             {
                 n=j;
                 return j;
            }
        }
     return -1;
    }
    
    //*************************初始化内存
    void empty()
     {
         for(i=0;i<bsize;i++)
             phb[i]=0;
         count=0;   //计数器置零
    }   //******先进先出页面置换算法
     void FIFO()
    {
         for( i=0; i<psize; i++)
         {
    //     m=searchpb();
    //     n=searchpro();
            //找到第一个空闲的物理快
            for(j=0;j<bsize;j++) {
                if(phb[j] == 0){
                    m=j;
                    break;
                }
            }
            //找与进程相同的标号
            for(j=0;j<bsize;j++) {
                if(phb[j] == pro[i]){
                    n=j;
                }
            }
    
     //找flag值最大的
         for(j=0;j<bsize;j++)
        {
             if(flag[j]>maxflag)
             {
                 maxflag = flag[j];
                 mmax = j;
            }
        }
    
        if(n == -1)//不存在相同进程
        {
            if(m != -1)//存在空闲物理块
            {
                phb[m]=pro[i];//进程号填入该空闲物理块
    //             count++;
                 flag[m]=0;
                 for (j=0;j<=m; j++)
                 {
                     flag[j]++;
                }
                m=-1;
            }
             else//不存在空闲物理块
             {
                 phb[mmax] =pro[i];
                 flag[mmax] =0;
                 for (j=0;j<bsize;j++)
                {
                     flag[j]++;
                }
                 mmax = -1;
                 maxflag = 0;
                 count++;
            }
        }
        else//存在相同的进程
        {
             phb[n] = pro[i];
             for(j=0;j<bsize;j++)
            {
                 flag[j]++;
            }
            n=-1;
        }
         for(j=0;j < bsize;j++)
         {
            printf("%d ", phb[j]);
        }
             printf("\n");
        }
         printf("缺页次数为:%d\n",count);
         printf("缺页率 :%16. 6f",(float)count/psize);
         printf("\n");
    }
    /*初始化内存单元、缓冲区*/
     void Init(Pagel *b,int c[bsize][psize])
     {
         int i,j;
         for (i=0;i<psize;i++)
         {
             b[i].num=-1;
             b[i].time=psize-i-1;
    }
     for(i=0;i<bsize;i++)
         for(j=0;j<psize;j++)
            c[i][j]=-1;
    }
    /*取得在内存中停留最久的页面,默认状态下为最早调入的页面*/
     int GetMax(Pagel *b)
     {
         int i;
         int max=-1;
         int tag=0;
         for(i=0;i<bsize;i++)
         {
             if(b[i].time>max)
             {
                 max=b[i].time;
                 tag= i;
            }
        }
         return tag;
    }
    
    /*判断页面是否已在内存中*/
     int Equation(int fold, Pagel *b)
     {
         int i;
        for(i=0;i<bsize;i++)
        {
             if(fold==b[i]. num)
                 return i;
        }
         return -1;
    }
    /*LRU核心部分*/
     void Lruu(int fold, Pagel *b)
     {
         int i;
         int val;
         val=Equation(fold, b);
         if (val>=0)
         {
             b[val].time=0;
             for(i=0;i<bsize;i++)
                 if (i!=val)
                     b[i].time++;
        }
         else
         {
             queue[++k]=fold;/*记录调入页面*/
             val=GetMax(b);
             b[val].num=fold;
             b[val].time=0;
             for (i=0;i<bsize;i++){
    
    //         URLcount++;
                 if (i!=val)
                     b[i].time++;
            }
        }
    }
    
     void LRU()
     {
         int i,j;
         k=0;
         Init(b, c);
         for(i=0; i<psize; i++)
         {
             Lruu(pro[i],b);
             c[0][i]=pro[i];
            /*记录当前的内存单元中的页面*/
             for(j=0;j<bsize;j++)
                c[j][i]=b[j].num;
        }
    
        /*结果输出*/
         printf("内存状态为:\n");
         Myprintf;
        for(j=0;j<psize;j++)
             printf("|%2d", pro[j]);
         printf("|\n");
         Myprintf;
    
         for(i=0;i<bsize;i++)
         {
             for(j=0; j<psize; j++)
             {
                 if(c[i][j]==-1)
                     printf("|%2c",32);
                  else
                     printf("|%2d",c[i][j]);
            }
             printf("|\n");
        }
    
         Myprintf;
    //     printf("\n调入队列为:");
    //    for(i=0;i<k;i++)
    //        printf("%3d", queue[i]);
    
        printf("\n缺页次数为:%6d\n   缺页率 :%16. 6f", k+1,(float)(k+1)/psize);
    }
    
    //********主函数
     int wang()
     {
         int sel;
         do{
         printf("\t\t\t--------------------------------\n");
         printf("\t\t\t☆☆欢迎使用分页模拟实验系统☆☆\n");
         printf("\t\t\t---------------------------------\n");
         printf("\t\t\t☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆\n");
         printf("\t\t\t☆☆       虚拟内存         ☆☆\n");
         printf("\t\t\t☆☆------------------------☆☆\n");
         printf("\t\t\t☆☆1.产生随机序列          ☆☆\n");
         printf("\t\t\t☆☆------------------------☆☆\n");
         printf("\t\t\t☆☆2.最近最久未使用        ☆☆\n");
         printf("\t\t\t☆☆------------------------☆☆\n");
         printf("\t\t\t☆☆3.先进先出              ☆☆\n");
         printf("\t\t\t☆☆------------------------☆☆\n");
         printf("\t\t\t☆☆0.退出                  ☆☆\n");
         printf("\t\t\t☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆\n");
         printf("请选择所要执行的操作:");
         scanf("%d",&sel);
         switch(sel)
        {
             case 0: printf("\t\t\t再见!t\t\t\n"); break;
             case 1: build(); break;
             case 2: printf("最近最久未使用\n"); LRU();empty(); printf("\n");break;
             case 3: printf("先进先出算法\n"); FIFO();empty();printf("\n");break;
             default:printf("请输入正确的选项号!");printf("\n\n");break;
        }
    }while(sel !=0 );
         return sel;
    }
    
    展开全文
  • 该工程具体是在codeblock上面实现了操作系统课程上讲解的页面置换算法,包括先进先出(FIFO)、最佳置换算法(OPT)、最久最近未使用算法(LRU)。 具体实现功能有: 1、建立相应的数据结构 2、在屏幕上显示页面...
  • 操 作 系 统 实 验 报 告 页面置换算法模拟 OFTFIFO 和 LRU 算法 班级2013 级软件工程 1 班 学号X X X 姓名萧氏一郎 开始载入序列 开始 载入序列号从第 0 个得到页号 将页号放入物理地址中编号 s 根据选择的置换算法...
  • 设计一个虚拟存储区和内存工作区,编程序演示下述算法的具体实现过程,并计算访问命中率: 要求设计主界面以灵活选择某算法,且以下算法都要实现 1)先进先出算法(FIFO) ...3)最佳置换算法(OPT)
  • 2.先进先出置换算法(FIFO):是最简单的页面置换算法。这种算法的基本思想是:当需要淘汰一个页面时,总是选择驻留主存时间最长的页面进行淘汰,即先进入主存的页面先淘汰。其理由是:最早调入主存的页面不再被使用...
  • 一个页面置换算法性能比较程序,包括了最佳置换,先进先出,LRU,随机置换,简单时钟和改进时钟六个算法。使用了队列,链表,循环链表等数据结构。随机产生请求页号,计算六种算法的缺页率。
  • a:最佳置换算法(OPT):将以后永不使用的或许是在最长(未来)时间内不再被访问的页面换出。 b: 先进先出算法(FIFO):淘汰最先进入内存的页面,即选择在内存中驻留时间最久的页面予以淘汰。 c:最近最久未使用算法(LRU)...
  • 页面置换算法(fifo,lru,opt) C语言编写

    热门讨论 2009-07-02 16:04:57
    页面置换算法(fifo,lru,opt) C语言编写 是我操作系统课程设计的题目,自己完成的
  • C语言操作系统——页面置换算法FIFO/LRU)

    万次阅读 多人点赞 2018-06-03 21:42:44
    由于本学期学习操作系统所以需要用代码实现一些算法,本人大二由于对C语言掌握的不太好,所以一直逼着自己用C语言写代码,还好写出来了,在这里与大家分享。首先建立一个工程文件,本人喜欢建立一个头文件,一个功能...
  • C语言实现页面置换算法

    千次阅读 2021-05-20 10:50:47
    本文实例为大家分享了C语言实现页面置换算法的具体代码,供大家参考,具体内容如下操作系统实验页面置换算法(FIFO、LRU、OPT)概念:1.最佳置换算法(OPT)(理想置换算法):从主存中移出永远不再需要的页面;如无这样的...
  • 用一种计算机高级语言来实现请求分页存储管理方式先进先出(FIFO置换算法,设计要求如下: ⑴ 能够输入给作业分配的内存块数; ⑵ 能够输入给定的页面,并计算发生缺页的次数以及缺页率; ⑶ 缺页时,如果发生...
  • 操作系统页面置换LRU,FIFO,OPT,LFU算法实现代码,使用C#动态实现,有TLB快表,可设置页面数量、驻留集大小、自动生成十六进制地址码,分析页号,可设置TLB时间,访问内存时间。
  • 实验报告五 实验名称: 模拟页面置换算法 FIFOLRU 的实现 日期2015-12-9 班级13 级计科 一 实验目的 学号: 姓名 了解页面置换的概念理解页面置换的算法加深对页面置换算法的理解 二 实验内容 Java 编程语言实现 FIFO ...
  • C语言代码实现了操作系统os实验中的三种页面置换算法: 最佳置换算法(OPT)、先进先出算法(FIFO)、最近最久未使用算法(LRU) 输入:物理块和页面大小,可选择自行输入数据或程序随机生成页面号序列 输出:显示三种...
  • 编程实现页面置换算法,最少实现两种算法,比较算法的优劣,并将调试结果显示在计算机屏幕上,检测机算和笔算的一致性。 (1)采用页式分配存储方案,通过分别计算不同算法的命中率来比较算法的优劣,同时也考虑页面...
  • C语言实现FIFO、OPT、LRU三种页面置换算法
  • 页面置换算法C语言 精品文档 精品文档 收集于网络如有侵权请联系管理员删除 收集于网络如有侵权请联系管理员删除 精品文档 收集于网络如有侵权请联系管理员删除 页面置换算法 一题目要求 通过实现页面置换算法的FIFO...
  • 无论是采用什么页面置换算法,都要经过下面的判断 b.页面不在内存中,但是此时内存还未满,那就将页面存到内存中,然后输出,缺页次数++ c.页面不在内存中,且此时内存已满,需要把页面置换,缺页次数++,置换次数++ ...
  • 一个请求分页管理系统,按字节编址,逻辑地址及物理地址的有效位均为32位(二进制),页面大小为4KB。假设一次内存访问时间为100ns,处理一次缺页的平均时间105 ns(已含更新页表的时间,缺页中断中不更新快表)。
  • 基于C语言FIFO和LRU算法的实现。
  • FIFO页面置换算法详解

    2022-09-20 15:18:55
    FIFO置换算法
  • 模拟FIFO页面置换算法

    2015-12-03 20:17:10
    C语言编写的FIFO页面置换算法,较为简易,多多指教
  • 先进先出(FIFO页面置换算法 【注】本代码数据及思路方法参考自《计算机操作系统(第四版)》汤小丹等 编著的教材。 #include <iostream> int accessPage[20] = { 7,0,1,2,0,3,0,4,2,3,0,3,2,1,2,0,1,7,0,1...
  • 三种页面置换算法的分析及C语言代码-附件资源

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 973
精华内容 389
关键字:

fifo页面置换算法c语言