精华内容
下载资源
问答
  • FIFO页面置换算法

    2015-06-06 10:14:41
    FIFO操作系统算法的完整代码,可以直接用。
  • FIFO页面置换算法宣贯.pdf
  • 一、实验描述 二.实验程序 #include<stdio.h>...//页面调度的顺序 int b[3][13],c[13],p=0; b[0][0]=0;//C语言定义数组,初始值不确定 b[1][0]=0; b[2][0]=0; printf(" "); for(i=0;i

    一、实验描述

    二、实验程序

    #include<stdio.h>
    void main()
    {
    	int i,j,k=0;
    	char cc[13];//Y表示发生缺页中断,N表示未发生
    	int a[12]={1,2,3,4,1,2,5,1,2,3,4,5};//页面调度的顺序
    	int b[3][13],c[13],p=0;
    	b[0][0]=0;//C语言定义数组,初始值不确定
    	b[1][0]=0;
    	b[2][0]=0;
    	printf("      ");
    	for(i=0;i<12;i++)
    		printf("%6d",a[i]);
    	printf("\n     ==========================================================================\n");
    	for(i=0;i<12;i++)
    	{
    		if(a[i]==b[0][i]||a[i]==b[1][i]||a[i]==b[2][i])
    		{
    			b[0][i+1]=b[0][i];
    			b[1][i+1]=b[1][i];
    			b[2][i+1]=b[2][i];
    			cc[i]='N';	
    		}
    		else
    		{
    			if(i>2)
    			{
    				c[p]=b[2][i];
    				p++;
    			}
    			b[0][i+1]=a[i];
    			b[1][i+1]=b[0][i];
    			b[2][i+1]=b[1][i];
    			cc[i]='Y';
    			k=k+1;
    		}
    	}
    	for(j=0;j<13;j++)
    		printf("%6d",b[0][j]);
    	printf("\n     --------------------------------------------------------------------------\n");
    	for(j=0;j<13;j++)
    		printf("%6d",b[1][j]);
    	printf("\n     --------------------------------------------------------------------------\n");
    	for(j=0;j<13;j++)
    		printf("%6d",b[2][j]);
    	printf("\n     --------------------------------------------------------------------------\n");
    	printf("      ");
    	for(j=0;j<13;j++)
    	{
    		printf("     ");
    		putchar(cc[j]);
    	}
    	printf("\n缺页中断次数:%3d\n",k);
    	printf("页面淘汰顺序:");
    	for(j=0;j<p;j++)
    		printf("%3d",c[j]);
    	printf("\n\n");
    }

    三、实验结果

    四、写在最后

            很久没写点什么了,回来看C站,变了好多。不再是纯粹的程序员交流社区了。

    展开全文
  • 用一种计算机高级语言来实现请求分页存储管理方式先进先出(FIFO置换算法,设计要求如下: ⑴ 能够输入给作业分配的内存块数; ⑵ 能够输入给定的页面,并计算发生缺页的次数以及缺页率; ⑶ 缺页时,如果发生...
  • 模拟FIFO页面置换算法

    2015-12-03 20:17:10
    用C语言编写的FIFO页面置换算法,较为简易,多多指教
  • FIFO页面置换算法简单实现

    万次阅读 多人点赞 2019-06-09 19:04:43
    FIFO页面置换算法简单实现 先进先出置换算法 (页面置换) 最简单的页面置换算法是先入先出(FIFO)法。这种算法的实质是,总是选择在主存中停留时间最长(即最老)的一页置换,即先进入内存的页,先退出内存。理由是:最...

    FIFO页面置换算法简单实现
    先进先出置换算法
    (页面置换)
    最简单的页面置换算法是先入先出(FIFO)法。这种算法的实质是,总是选择在主存中停留时间最长(即最老)的一页置换,即先进入内存的页,先退出内存。理由是:最早调入内存的页,其不再被使用的可能性比刚调入内存的可能性大。建立一个FIFO队列,收容所有在内存中的页。被置换页面总是在队列头上进行。当一个页面被放入内存时,就把它插在队尾上。

    这种算法只是在按线性顺序访问地址空间 时才是理想的,否则效率不高。因为那些常被访问的页,往往在主存中也停留得最久,结果它们因变"老"而不得不被置换出去。

    FIFO的另一个缺点是,它有一种异常现象,即在增加存储块的情况下,反而使缺页中断率增加了。当然,导致这种异常现象的页面走向实际上是很少见的。
    在这里插入图片描述
    在这里插入图片描述

    #include<iostream>
    #define N 10
    using namespace std;
    
    int main()
    {
       // int ym[]={7,0,1,2,0,3,0,4,2,3,0,3,2,1,2,0,1,7,0,1};
        // int sum=20;
        int ym[]={4,3,2,1,4,3,5,4,3,2,1,5};
    int sum=12;
    //前两行演示FIFO算法,若注释这验证belady现象。
        int allchangetimes=0;
        int fifo[N]={0};
        int n;
        int dq=0;
    
        cout<<"输入页框大小:";
        cin>>n;
        for(int i=n-1;i>=0;i--)
        {
            fifo[i]=ym[dq++];
        }
    
                for(int i=0;i<n ;i++)
            {
                cout<<fifo[i]<<"   ";
            }
            cout<<endl;
    
    
        for(int j=n;j<sum;j++)
        {    int flag=0;
            for(int i=0;i<n;i++)
            {
                if(fifo[i]==ym[j])
                {  flag=1;
    
                    break;
                }
            }
    
            if(flag==0)
            {
                allchangetimes++;
                for(int i=n-1;i>=1;i--)
                {
                    fifo[i]=fifo[i-1];
                }
                    fifo[0]=ym[j];
            }
    
    
            for(int i=0;i<n;i++)
            {
                cout<<fifo[i]<<"   ";
            }
            cout<<endl;
        }
    
        cout<<"缺页"<<allchangetimes+n<<"次,"<<"置换"<<allchangetimes<<endl;
    }
    
    

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

    展开全文
  • 这是一个自己完成软件工程的操作系统课程课程设计题目:此程序用于模拟虚拟磁盘页面置换算法,实现了FIFO页面置换算法和LRU页面置换算法,获得课程设计优秀的好成绩
  • OPT,LRU,FIFO页面置换算法python实现

    千次阅读 2019-11-27 18:32:48
    实验三 请求页式存储管理中常用页面置换算法模拟 【开发语言及实现平台或实验环境】 C++/C# Microsoft Visual Studio 6.0/ Microsoft Visual Studio .NET 2003 【实验目的】 (1)了解内存分页管理策略 (2)掌握调...

    实验三 请求页式存储管理中常用页面置换算法模拟
    实现效果如下:

    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    【开发语言及实现平台或实验环境】
    C++/C#
    Microsoft Visual Studio 6.0/ Microsoft Visual Studio .NET 2003

    【实验目的】
    (1)了解内存分页管理策略
    (2)掌握调页策略
    (3)掌握一般常用的调度算法
    (4)学会各种存储分配算法的实现方法。
    (5)了解页面大小和内存实际容量对命中率的影响。

    【实验要求】
    (1)采用页式分配存储方案,通过分别计算不同算法的命中率来比较算法的优劣,同时也考虑页面大小及内存实际容量对命中率的影响;
    (2)实现OPT 算法 (最优置换算法) 、LRU 算法 (Least Recently) 、 FIFO 算法 (First IN First Out)的模拟;
    (3)会使用某种编程语言。

    【实验原理】
    分页存储管理将一个进程的逻辑地址空间分成若干大小相等的片,称为页面或页。
    在进程运行过程中,若其所要访问的页面不在内存而需把它们调入内存,但内存已无空闲空间时,为了保证该进程能正常运行,系统必须从内存中调出一页程序或数据,送磁盘的对换区中。但应将哪 个页面调出,须根据一定的算法来确定。通常,把选择换出页面的算法称为页面置换算法(Page_Replacement Algorithms)。
    一个好的页面置换算法,应具有较低的页面更换频率。从理论上讲,应将那些以后不再会访问的页面换出,或将那些在较长时间内不会再访问的页面调出。
    一、最佳置换算法OPT(Optimal)
    它是由Belady于1966年提出的一种理论上的算法。其所选择的被淘汰页面,将是以后永不使用的或许是在最长(未来)时间内不再被访问的页面。采用最佳置换算法,通常可保证获得最低的缺页率。但由于人目前还无法预知一个进程在内存的若干个页面中,哪一个页面是未来最长时间内不再被访问的,因而该算法是无法实现的,便可以利用此算法来评价其它算法。
    二、先进先出(FIFO)页面置换算法
    这是最早出现的置换算法。该算法总是淘汰最先进入内存的页面,即选择在内存中驻留时间最久的页面予以淘汰。该算法实现简单只需把一个进程已调入内存的页面,按先后次序链接成一个队列,并设置一个指针,称为替换指针,使它总是指向最老的页面。
    三、最近最久未使用置换算法
    1、LRU(Least Recently Used)置换算法的描述
    FIFO置换算法性能之所以较差,是因为它所依据的条件是各个页面调入内存的时间,而页面调入的先后并不能反映页面的使用情况。最近最久未使用(LRU)置换算法,是根据页面调入内存后的使用情况进行决策的。由于无法预测各页面将来的使用情况,只能利用“最近的过去”作为“最近的将来”的近似,因此,LRU置换算法是选择最近最久未使用的页面予以淘汰。该算法赋予每个页面一个访问字段,用来记录一个页面自上次被访问以来所经历的时间t,,当须淘汰一个页面时,选择现有页面中其t值最大的,即最近最久未使用的页面予以淘汰。

    
    # Init
    M = 4
    N = 17
    
    class page:
        def __init__(self,num,time):      
            # 记录页面号
            self.num = num  
            # 记录调入内存时间
            self.time = time
    
    class main:
        # 初始化内存单元,缓冲区
        def __init__(self):
            # 初始化内存单元
            self.b = [page(-1,M-i-1) for i in range(0,M)]
            # 初始化内存当前状态,缓冲区
            self.c = [[-1 for i in range(0,N)] for j in range(0,M)]
            # 记录调入队列
            self.queue = []
            self.k = -1
            self.flag =-1
            self.process()
    
        def print_string(self):
            print("|---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---|")
    
        # 取得在内存中停留最久的页面,默认状态下为最早点入的页面
        def get_max(self,b):
            max = -1
            flag = 0
            for i in range(0,M):
                if b[i].time >max:
                    max = b[i].time
                    flag = i
            return flag 
    
        # 判断页面是否已在内存中
        def equation(self,fold,b):
            for i in range(0,M):
                if fold == b[i].num:
                    return i
            return -1
        # OPT 算法
        def opt(self,fold,b,index,a):
            max = -1
            val = self.equation(fold,b)
            if val >= 0:
                pass
            else:
                self.queue.append(fold)
                self.k += 1
    
                for j in range(0,M):
                    for k in range(index+1,N):
                        if b[j].num==a[k]:
                            b[j].time = k-j
                        else:
                            b[j].time = 20
    
                for i in range(0, M):
                    if b[i].num ==-1:
                        val = i
                        break;
                    else:
                        if b[i].time > max:
                            max = b[i].time
                            val = i
                b[val].num = fold
        # LRU 算法
        def lru(self, fold, b):
            val = self.equation(fold, b)
            if val >= 0:
                b[val].time = 0
                for i in range(0, M):
                    if i != val:
                        b[i].time += 1
            else:
                self.queue.append(fold)
                self.k += 1
                val = self.get_max(b)
                b[val].num = fold
                b[val].time = 0
                for i in range(0, M):
                    if (i != val):
                        b[i].time += 1
    
        # FIFO 算法
        def fifo(self, fold, b):
            val = self.equation(fold, b)
            if val >= 0:
                pass
            else:
                self.queue.append(fold)
                self.k += 1
                self.flag += 1
                self.flag %= 4
                self.b[self.flag].num = fold
    
    
        # 打印内存状态
        def Myprint(self,a):
            self.print_string()
            for j in range(0, N):
                print("|%2d" % (a[j]), end=" ")
            print("|")
            self.print_string()
            for i in range(0, M):
                for j in range(0, N):
                    if self.c[i][j] == -1:
                        print("|%2c" % (32), end=" ")
                    else:
                        print("|%2d" % (self.c[i][j]), end=" ")
                print("|")
            self.print_string()
            print("调入队列为")
            for i in range(0, self.k + 1):
                print("%2d" % (self.queue[i]), end=" ")
            print("\n缺页次数为:%6d\n缺页率:%16.6f" % (self.k + 1, (float)(self.k + 1) / N))
        # 主程序
        def process(self):
            a = [1,0,1,0,2,4,1,0,0,8,7,5,4,3,2,3,4]
    
            for i in range(0, N):
                self.fifo(a[i], self.b)
                self.c[0][i] = a[i]
    
                # 记录当前的内存单元中的页面
                for j in range(0, M):
                    self.c[j][i] = self.b[j].num
            # 结果输出
            print("fifo算法内存状态为:")
            self.Myprint(a)
    
            # 初始化内存单元
            self.b = [page(-1, M - i - 1) for i in range(0, M)]
            # 初始化内存当前状态,缓冲区
            self.c = [[-1 for i in range(0, N)] for j in range(0, M)]
            # 记录调入队列
            self.queue = []
            self.k = -1
            for i in range(0, N):
                self.lru(a[i], self.b)
                self.c[0][i] = a[i]
    
                # 记录当前的内存单元中的页面
                for j in range(0, M):
                    self.c[j][i] = self.b[j].num
            # 结果输出
            print("lru算法内存状态为:")
            self.Myprint(a)
    
            # opt 算法
            # 初始化内存单元
            self.b = [page(-1, M - i - 1) for i in range(0, M)]
            # 初始化内存当前状态,缓冲区
            self.c = [[-1 for i in range(0, N)] for j in range(0, M)]
            # 记录调入队列
            self.queue = []
            self.k = -1
            for i in range(0, N):
                self.opt(a[i], self.b, i,a)
                self.c[0][i] = a[i]
    
                # 记录当前的内存单元中的页面
                for j in range(0, M):
                    self.c[j][i] = self.b[j].num
    
            # opt 算法输出
            print("opt算法内存状态为:")
            self.Myprint(a)
    if __name__ == "__main__":
        main()
    
    展开全文
  • 操作系统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 = block1;
            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;
    }
    
    展开全文
  • 实验四 模拟FIFO页面置换算法 一、实验目的:用c/c++/java模拟FIFO页面置换算法 二、实验内容:随机一访问串和驻留集的大小,通过模拟程序显示淘汰的页号并统计命中率。示例: 输入访问串:7 0 1 2 0 3 0 4 2 3 0...
  • LRU/最佳/FIFO页面置换算法

    千次阅读 2020-05-04 15:35:22
    一.先了解一下几种算法的定义: ...2. 先进先出(FIFO)页面置换算法FIFO算法是最早出现的置换算法。该算法总是淘汰最先进入内存的页面,即选择在内存中驻留时间最久的页面予以淘汰。 3. LRU(Leas...
  • 该工程具体是在codeblock上面实现了操作系统课程上讲解的页面置换算法,包括先进先出(FIFO)、最佳置换算法(OPT)、最久最近未使用算法(LRU)。 具体实现功能有: 1、建立相应的数据结构 2、在屏幕上显示页面...
  • 该工程具体是在codeblock上面实现了操作系统课程上讲解的页面置换算法,包括先进先出(FIFO)、最佳置换算法(OPT)、最久最近未使用算法(LRU)。 具体实现功能有: 1、建立相应的数据结构 2、在屏幕上显示页面的...
  • csdn小透明对大佬的代码做了一些小改进 仅作学习交流,侵权删除 ...以下是改进后的代码 class page: def __init__(self,num,time... # 记录页面号 self.num = num # 记录调入内存时间 self.time = time class main:
  • FIFO、OPT、LRU页面置换算法实验代码和截图
  • 带有界面的算法,视自己需求下载。 主界面选择使用三种算法的一个。在创建中输入页面数,随机生成页面。在指定物理块中实现置换。点击查看将置换的过程显示出来。
  • FIFO页面置换算法.pdf

    2021-10-04 01:43:07
    FIFO页面置换算法.pdf
  • 课外实践报告 项 目 名 称 所 在 班 级 姓名 小 组 成 员 页面置换算法 学号 组长 指 导 教 师 成 绩 评 定 支丽平 页面置换算法中的先进先出算法 一 实验目的 了解最佳页面置换算法与先进先出 FIFO 页面置换算法并...
  • 上学期操作系统实训中的内容,当时百度的代码基本都用了链表,自己...先进先出置换算法FIFO) #include<stdio.h> void doit(int a[],int b[]){ //实现先进先出置换算法的方法 int i,j,k,z,temp; for(i=0...
  • 算法的实现:FIFO淘汰算法总是淘汰最先进入内存的页面,即选择在内存中驻留时间最久的页面进行淘汰。该算法实现只需把一个进程已调入内存的页面,按访问的时间先后顺序链接成一个队列,并设置一个指针,该指针始终...
  • 使用c++语言编写的模拟实现先进先出页面置换算法,定义了一个FIFO类,FIFO类有一个str数组来存放页面走向;一个base数组表示物理块;一个int型变量来存放最先进入物理块的下标。这是个比较简单的代码,
  • 第一次百度笔试,题目不难,但由于...FIFO页面置换算法: 一个函数,两个参数 public static int countCacheMiss(int max_cache_size, int[] page_requests){} max_cache_size:代表缓冲区个数 page_requests:代表请
  • 该C语言代码实现了操作系统os实验中的三种页面置换算法: 最佳置换算法(OPT)、先进先出算法(FIFO)、最近最久未使用算法(LRU) 输入:物理块和页面大小,可选择自行输入数据或程序随机生成页面号序列 输出:显示三种...
  • 算法实现使用了queue数据结构,实现简单,仅作纪念。 #include<iostream> #include<queue> #include<cstdio> using namespace std; int a[99],m,n; bool paichong(queue<int> q1,int ...
  • 页面置换FIFO算法java

    2013-06-17 21:25:29
    页面置换FIFO算法java,仅供学习和参考!

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 6,726
精华内容 2,690
关键字:

fifo页面置换算法