ddgggg

最新推荐文章于 2024-08-27 22:07:38 发布
最新推荐文章于 2024-08-27 22:07:38 发布
阅读量80 收藏
点赞数
文章标签： c++ 算法 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_68890903/article/details/130744642
版权

//1.存储管理。
#define TRUE 1
#define FALSE 0
#define INVALID -1
#define NULL  0
#define  total_instruction 320     /*指令流长*/
#define  total_vp  32               /*虚页长*/
#define  clear_period  50           /*清0周期*/
 
typedef struct                      /*页面结构*/
{
    int pn;      //页号 logic number
    int pfn;     //页面框架号 physical frame number
    int counter; //计数器
    int time;    //时间
}pl_type;
 
pl_type pl[total_vp];                      /*页面线性结构---指令序列需要使用地址*/
 
typedef struct pfc_struct                  /*页面控制结构，调度算法的控制结构*/
{                          
    int pn;
    int pfn;
    struct pfc_struct *next;
}pfc_type;
 
 
pfc_type pfc[total_vp], *freepf_head, *busypf_head, *busypf_tail;
 
int diseffect,  a[total_instruction]; /* a[]为指令序列*/
 
int page[total_instruction],  offset[total_instruction];/*地址信息*/
 
int  initialize(int);
int  FIFO(int);
int  LRU(int);
int  LFU(int);
int  NUR(int); //not use recently
int  OPT(int);
 
int main( )
{
    int s,i,j;
 
    srand(10*getpid());                    /*由于每次运行时进程号不同，故可用来作为初始化随机数队列的“种子”*/
 
    s=(float)319*rand( )/32767/32767/2+1;  /*正态分布*/
 
    for(i=0;i<total_instruction;i+=4)        /*产生指令队列*/
    {
        if(s<0||s>319)
        {
            printf("When i==%d,Error,s==%d\n",i,s);
            exit(0);
        } 
        a[i]=s;                                   /*任选一指令访问点m*/
        a[i+1]=a[i]+1;                            /*顺序执行一条指令*/
        a[i+2]=(float)a[i]*rand( )/32767/32767/2; /*执行前地址指令m*/
        a[i+3]=a[i+2]+1;                          /*顺序执行一条指令*/
 
        s=(float)(318-a[i+2])*rand( )/32767/32767/2+a[i+2]+2;
        if((a[i+2]>318)||(s>319))
 
            printf("a[%d+2],a number which is :%d and s==%d\n",i,a[i+2],s);
 
    }
    for (i=0;i<total_instruction;i++) /*将指令序列变换成页地址流*/
    {
        page[i]=a[i]/10;
        offset[i]=a[i]%10;
    }
    for(i=4;i<=32;i++)   /*用户内存工作区从4个页面到32个页面*/
    {
        printf("--%2d page frames   ",i);
        FIFO(i);
        LRU(i);
        LFU(i);
        NUR(i);
        OPT(i);
        
    }
    return 0;
}
 
/*初始化相关数据结构 total_pf表示内存的块数 */
 
int initialize(int total_pf)             
{
    int i;
    diseffect=0;
    for(i=0;i<total_vp;i++)
    {
 
        pl[i].pfn=INVALID;       /*置页面控制结构中的页号，页面为空*/
        pl[i].counter=0;         /*页面控制结构中的访问次数为0*/
        pl[i].time=-1;           /*访问的时间*/
    }
 
    for(i=0;i<total_pf-1;i++)    /*建立pfc[i-1]和pfc[i]之间的链接*/
    {    
        pfc[i].next=&pfc[i+1];
        pfc[i].pfn=i;
    }   
 
    pfc[total_pf-1].next=NULL;
    pfc[total_pf-1].pfn=total_pf-1;
    freepf_head=&pfc[0];         /*空页面队列的头指针为pfc[0]*/
    return 0;
}
 
int FIFO(int total_pf)              /*先进先出算法total_pf:用户进程的内存页面数*/
{
    int i,j;
    pfc_type *p;                    /*中间变量*/
    initialize(total_pf);         /*初始化相关页面控制用数据结构*/
    busypf_head=busypf_tail=NULL; /*忙页面队列头，队列尾链接*/
    for(i=0;i<total_instruction;i++)
    {
        if(pl[page[i]].pfn==INVALID)   /*页面失效*/
        {
            diseffect+=1;                  /*失效次数*/
            if(freepf_head==NULL)         /*无空闲页面*/
            {
                p=busypf_head->next;       
                pl[busypf_head->pn].pfn=INVALID;
                freepf_head=busypf_head;  /*释放忙页面队列的第一个页面*/
                freepf_head->next=NULL;  /*表明还是缺页*/
                busypf_head=p;
            }
            p=freepf_head->next;        
            freepf_head->pn=page[i];
            pl[page[i]].pfn=freepf_head->pfn;
            freepf_head->next=NULL; /*使busy的尾为null*/
            if(busypf_tail==NULL)
            {
                busypf_tail=busypf_head=freepf_head;
            }
            else
            {
                busypf_tail->next=freepf_head;
                busypf_tail=freepf_head;
            }
            freepf_head=p;
        }
    }
    printf("FIFO:%6.4f  ",1-(float)diseffect/320);
    return 0;
}
int LRU (int total_pf)       /*最近最久未使用算法least recently used*/
{
    int min,minj,i,j,present_time; /*minj为最小值下标*/
    initialize(total_pf);
    present_time=0;
    for(i=0;i<total_instruction;i++)
    {
        if(pl[page[i]].pfn==INVALID)             /*页面失效*/
        {
            diseffect++;
            if(freepf_head==NULL)              /*无空闲页面*/
            {
                min=32767;                        /*设置最大值*/
                for(j=0;j<total_vp;j++)            /*找出time的最小值*/
                { 
                    if(min>pl[j].time&&pl[j].pfn!=INVALID)
                    {
                        min=pl[j].time;
                        minj=j;
                    }
                }
                freepf_head=&pfc[pl[minj].pfn];   //腾出一个单元
                pl[minj].pfn=INVALID;
                pl[minj].time=0;
                freepf_head->next=NULL;
            }
            pl[page[i]].pfn=freepf_head->pfn;   //有空闲页面,改为有效
            pl[page[i]].time=present_time;
            freepf_head=freepf_head->next;      //减少一个free 页面
        }
        else
        {
            pl[page[i]].time=present_time;        //命中则增加该单元的访问次数
            present_time++;
        }
    }
    printf("LRU:%6.4f  ",1-(float)diseffect/320);
    return 0;
}
 
int NUR(int  total_pf )                  /*最近未使用算法Not Used recently count表示*/
{ 
int i,j,dp,cont_flag,old_dp;
pfc_type *t;
initialize(total_pf);
dp=0;
 
for(i=0;i<total_instruction;i++)
{ 
    if (pl[page[i]].pfn==INVALID)         /*页面失效*/
    {
        diseffect++;
        if(freepf_head==NULL)               /*无空闲页面*/
        { 
            cont_flag=TRUE;
            old_dp=dp;
            
            while(cont_flag)
            {
                
               if(pl[dp].counter==0&&pl[dp].pfn!=INVALID)
                    cont_flag=FALSE;
                else
                {
                    dp++;
                    if(dp==total_vp)
                        dp=0;
                    if(dp==old_dp)
                        for(j=0;j<total_vp;j++)
                         pl[j].counter=0;
                }
            }
            freepf_head=&pfc[pl[dp].pfn];
            pl[dp].pfn=INVALID;
            freepf_head->next=NULL;
        }
        
        pl[page[i]].pfn=freepf_head->pfn;
        
        freepf_head->pn=page[i];
        
        freepf_head=freepf_head->next;
    }
    else
        pl[page[i]].counter=1;
    if(i%clear_period==0)
        for(j=0;j<total_vp;j++)
            pl[j].counter=0;
}
printf("NUR:%6.4f  ",1-(float)diseffect/320);
return 0;
}
 
int OPT(int total_pf)       /*最佳置换算法*/
{
    int i,j, max,maxpage,d,dist[total_vp];
    pfc_type *t;
    initialize(total_pf);
    for(i=0;i<total_instruction;i++)
    { 
        if(pl[page[i]].pfn==INVALID)      /*页面失效*/
        {
            diseffect++;
            if(freepf_head==NULL)         /*无空闲页面*/
            {
                for(j=0;j<total_vp;j++)
                {
                    if(pl[j].pfn!=INVALID)
                        dist[j]=32767;
                    else
                        dist[j]=0;     
                }
                for(j=0;j<total_vp;j++)           
                {
                    if((pl[j].pfn!=INVALID)&&(dist[j]==32767))
                    {
                        dist[j]=j;
                    }
                }
                max=0;
                for(j=0;j<total_vp;j++)
                    if(max<dist[j])
                    {
                        max=dist[j];
                        maxpage=j;
                    }
                    freepf_head=&pfc[pl[maxpage].pfn];
                    freepf_head->next=NULL;
                    pl[maxpage].pfn=INVALID;
            }
            pl[page[i]].pfn=freepf_head->pfn;
            freepf_head=freepf_head->next;
        }
    }
    printf("OPT:%6.4f\n",1-(float)diseffect/320);
    return 0;
}
/*该算法时根据已知的预测未知的，least frequency  Used是最不经常使用置换法*/
int  LFU(int total_pf)        
{
    int i,j,min,minpage;
    pfc_type *t;
    initialize(total_pf);
    for(i=0;i<total_instruction;i++)
    { 
        if(pl[page[i]].pfn==INVALID)      /*页面失效*/
        { 
            diseffect++;
            if(freepf_head==NULL)          /*无空闲页面*/
            { 
                min=32767;    
                /*获取counter的使用用频率最小的内存*/    
                for(j=0;j<total_vp;j++)
                {
                    if(min>pl[j].counter&&pl[j].pfn!=INVALID)
                    {
                        min=pl[j].counter;
                        minpage=j;
                    }
                }
                freepf_head=&pfc[pl[minpage].pfn];
                pl[minpage].pfn=INVALID;
                pl[minpage].counter=0;
                freepf_head->next=NULL;
            }
            pl[page[i]].pfn=freepf_head->pfn;   //有空闲页面,改为有效
            pl[page[i]].counter++;
            freepf_head=freepf_head->next;      //减少一个free 页面
        }
        else
        {
            pl[page[i]].counter;
            pl[page[i]].counter=pl[page[i]].counter+1;
        }
    }
    printf("LFU:%6.4f  ",1-(float)diseffect/320);
    return 0;
}    
 

biu特否929
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
Android弹出提示框数据进行选择
jjb_584520的博客
10-10 652
Android提示框提醒
【C++】链表
qq_38801607的博客
08-22 570
链表是一种常见的动态数据结构，与数组相比，它在插入和删除操作中具有更高的效率。链表的每个元素称为节点（Node），节点包含两个部分：数据域（存储数据）和指针域（指向下一个节点的指针）。链表的最大特点是节点的内存位置不需要连续，可以通过指针来链接在一起。
C++ 重载运算符和重载函数
lly202406的博客
08-25 482
在C++编程语言中，运算符重载和函数重载是两个非常核心的概念，它们允许开发者扩展或重新定义运算符和函数的行为，以适应特定的数据类型或对象。本文将详细探讨C++中的运算符重载和函数重载，包括它们的基本概念、使用场景、实现方式以及注意事项。
c语言用if语句制作点单程序
2301_81968528的博客
08-20 304
printf("数字1代表喝咖啡，数字2代表喝雪碧:");这里的点单程序是用户输入相应的数字自动出来相应的饮品。puts("您要喝的是咖啡");puts("您要喝雪碧");比如输入1是咖啡，输入2是雪碧。c语言里面，if语句的语法是。
初识顺序表---C语言
weixin_74202161的博客
08-23 343
顺序表是一种以数组为基础的结构，对数组进行封装，实现常用的增删改查等操作的。//销毁。
Dijkstra(c++)
weixin_73378557的博客
08-24 492
迪杰斯特拉算法(Dijkstra)是由荷兰计算机科学家狄克斯特拉于1959年提出的，因此又叫狄克斯特拉算法。是从一个顶点到其余各顶点的最短路径算法，解决的是有权图中最短路径问题。迪杰斯特拉算法主要特点是从起始点开始，采用贪心算法的策略，每次遍历到始点距离最近且未访问过的顶点的邻接节点，直到扩展到终点为止。同时dijkstra算法主要用于解决单源最短路问题（边权为正数），其可以分为两种版本，两种版本各有用处，并不存在好坏之分，接下来我们用n代表点的数量，用m代表边的数量。
C语言01 每日一练01
小蜗的房子
08-24 1256
C语言01 每日一练01
坐牢第三十天（c++）
m0_62828714的博客
08-27 290
提示并输入一个字符串，统计该字符串中字母个数、数字个数、空格个数、其他字符的个数 效果图：
C++：list篇
2301_80894970的博客
08-27 598
我们可以看到，当erase后如果在对it迭代器进行操作，vs则会进行强制检查(根据编译环境不同，处理环境也不相同),则不允许再继续使用,如果想继续使用的话，C++同样也给出了方案，可以看到erase会返回一个迭代器，而返回的迭代器就是下一个链表的位置。那么从上面的begin与end可以看出，使用迭代器遍历list，仅仅只需要解引用迭代器以及++迭代器就能取得我们想要的值与让迭代器走向下一个节点，那么有没有想过一个问题，list的迭代器与vector这种类似数组的迭代器底层是否是一样的呢？
【C++】类与对象
2401_82855612的博客
08-24 347
C++编译器给每个非静态的成员函数增加了一个隐藏的指针参数即this指针让该指针指向当前对象(函数运行时调用该函数的对象)，在函数体中所有“成员变量”的操作，都是通过该指针去访问。只需要计算成员变量的大小（注意内存对齐），不需要计算成员函数的大小，无论定义多少对象，成员函数就只有一个是公用的. 编译器给了空类一个字节来唯一标识这个类的对象。如果嵌套了结构体的情况，嵌套的结构体对齐到自己的最大对齐数的整数倍处，结构体的整 体大小就是所有最大对齐数（含嵌套结构体的对齐数）的整数倍。
c++每日练习记录4-（递归思想）
qq_33867768的博客
08-23 174
递归的思想：反向思考一个问题，由简单推广到复杂，找到规律方程。类似于解决高次的微分方程问题。（暂时不能很好理解可以看。利用利用两个新的指针，一个用于保存输出的初始节点，另外一个用于地址的迭代指向。
C++：类和对象（二）
Harper.Lee的博客
08-27 528
本篇博客介绍内容：构造函数、析构函数、拷贝构造函数、运算符重载和赋值运算符重载，以及一些细节例如：深浅拷贝、传值返回与传引用返回、传值传参与传引用传参等！
【C++ Primer Plus习题】5.1
qq_74047911的博客
08-25 194
【C++ Primer Plus习题】5.1
8月27c++
A111222129的博客
08-27 61
提示并输入一个字符串，统计字符串中字母、数字、空格和其他字符的个数。
《C++魔法：运算符重载的奇妙之旅》
xy520521的博客
08-26 297
但在使用时，我们也需要谨慎考虑，遵循良好的编程规范，以充分发挥其优势，避免潜在的问题。让我们一起在 C++的世界里，用运算符重载创造出更加精彩的代码吧！运算符重载，简单来说，就是赋予已有的运算符新的含义，使其能够作用于自定义的数据类型。例如，我们可以让“+”运算符不仅仅用于基本数据类型的加法运算，还可以用于自定义的类对象之间的特定操作。在 C++的广阔编程世界里，运算符重载就像是一把神奇的钥匙，为程序员打开了更多可能性的大门。它赋予了我们自定义数据类型以更自然、更直观的操作方式，让代码更加简洁高效。
C++ 135类和对象_面像对像_多态
最新发布
cjh16606260986的博客
08-27 204
135类和对象_面像对像_多态 学习内容 1.抽象类 2.虚函数 3.纯虚函数 动态多态满足条件 1.有继承关系 2.子类重写父类函数 3.用父类的函数指针 指向 子类的对象 AnimalBaseModel & animal
【数据结构|C语言】 二分算法 二分查找[初级]
十二_的博客
08-27 124
首先将target目标值与被查找的顺序表中的中间值进行比较，若相等则查找成功；- 若不等，则要查找的target在中间元素以外的左半部分或者右半部分，- 若target大于中间值，则在右半部分继续折半；- 反之则在左半部分继续折半。// 右移 相等于 /2。
【C语言】深入理解指针3（附转移表源码）
2301_81072404的博客
08-27 663
各种指针变量的理解，转移表
【C++ 第十七章】封装 unordered_map / unordered_set
唯有忍受别人不能忍受的，才能享受别人不能享受的
08-26 908
使用 开散列方法的哈希结构 封装进 unordered_map / unordered_set ，实现 哈希表迭代器、哈希函数、哈希表节点
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值