精华内容
下载资源
问答
  • 2021-01-07 23:31:00
    #include <iostream>
    #include<string.h>
    using namespace::std;
    struct page{
        int pagenum;
        int A;
        int M;
    };
    
    int run(page *a,int num){
        page b[5];
        int count=0;
        for (int i=0; i<5; i++) {
            b[i].pagenum=0;
            b[i].A=0;
            b[i].M=0;
        }
        for (int i=0; i<num; i++) {
            cout<<"now page "<<a[i].pagenum<<" get in"<<endl;
            int flag=1;
            int same=0;
            for (int j=0; j<5; j++) {
                if (a[i].pagenum==b[j].pagenum) {
                    flag=0;
                    same=j;
                }
            }
            if (flag==0){
                if (count==5) {
                    for (int j=0; j<5; j++) {
                        b[j].A=0;
                    }
                }
                cout<<"page "<<a[i].pagenum<<" exitsing"<<endl;
                b[same].A=a[i].A;
                b[same].M=a[i].M;
            }
            if (flag) {
                if (count<5) {
                    b[count].pagenum=a[i].pagenum;
                    b[count].A=a[i].A;
                    b[count].M=a[i].M;
                    count++;
                }
                else {
                    for (int j=0; j<5; j++) {
                        b[j].A=0;
                    }
                    for (int j=0; j<5; j++) {
                        if (b[j].A==0&&b[j].M==0) {
                            b[j].pagenum=a[i].pagenum;
                            b[j].A=a[i].A;
                            b[j].M=a[i].M;
                            goto outside;
                        }
                        else if (j==4){
                            for (j=0; j<5; j++) {
                                if (b[j].A==0&&b[j].M==1) {
                                    b[j].pagenum=a[i].pagenum;
                                    b[j].A=a[i].A;
                                    b[j].M=a[i].M;
                                    goto outside;
                                }
                                else if (j==4){
                                    for (j=0; j<5; j++) {
                                        if (b[j].A==1&&b[j].M==0) {
                                            b[j].pagenum=a[i].pagenum;
                                            b[j].A=a[i].A;
                                            b[j].M=a[i].M;
                                            goto outside;
                                        }
                                        else if (j==4){
                                            for (j=0; j<5; j++) {
                                                if (b[j].A==1&&b[j].M==1) {
                                                    b[j].pagenum=a[i].pagenum;
                                                    b[j].A=a[i].A;
                                                    b[j].M=a[i].M;
                                                    goto outside;
                                                }
                                            }
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
            outside:
                same=0;
            }
            cout<<"pagenum use change"<<endl;
            for (int j=0; j<5; j++) {
                cout<<b[j].pagenum<<"      "<<b[j].A<<"      "<<b[j].M<<endl;
            }
            cout<<""<<endl;
        }
        return 0;
    }
    
    int change(page *a,int num,int changepagenum,int changepagenumto,int changea,int changem){
        a[changepagenum].pagenum=changepagenumto;
        a[changepagenum].A=changea;
        a[changepagenum].M=changem;
        return 0;
    }
    
    int showdetail(page *a,int num){
        cout<<"pagenum use change:"<<endl;
        for (int i=0; i<num; i++) {
            cout<<a[i].pagenum<<"      "<<a[i].A<<"      "<<a[i].M<<endl;
        }
        return 0;
    }
    
    int main(){
        page a[20];
        int num;
        int flag=1;
        string choice;
        cout<<"please input the number of the pages:";
        cin>>num;
        cout<<"please input use order(num) and if change(0/1) of the pages:"<<endl;
        for (int i=0; i<num; i++) {
            cin>>a[i].pagenum;
            a[i].A=1;
            cin>>a[i].M;
        }
        while (flag) {
            cout<<"please input next:";
            cin>>choice;
            if (choice=="showdetail") {
                showdetail(a, num);
            }
            else if (choice=="run") {
                run(a, num);
            }
            else if (choice=="change"){
                int changepagenum=0;
                int changepagenumto=0;
                int changea=0;
                int changem=0;
                cout<<"please input num"<<endl;
                cin>>changepagenum;
                cout<<"please input new pagenum A M"<<endl;
                cin>>changepagenumto;
                cin>>changea;
                cin>>changem;
                change(a, num,changepagenum,changepagenumto,changea,changem);
            }
            else if (choice=="exit") {
                flag=0;
            }
        }
        return 0;
    }
    
    
    更多相关内容
  • clock页面置换算法

    2013-06-22 08:47:31
    简单的clock页面置换算法 采用CLOCK置换算法仿真请求分页系统 1、设计目的:用高级语言编写和调试一个内存分配程序,加深对内存分配算法的理解。 2、设计要求: 1) 实现请求分页存储管理方式的页面置换算法:...
  • CLOCK页面置换算法

    千次阅读 2020-11-23 20:00:29
    页面置换算法 1 时钟置换算法 CLOCK 1.1 代码实现 原谅我的无聊,偏要写一下代码实现以下 给定驻留集大小 访问串 计算每次内存中页面,并最终计算缺页率 BLOCKS = 3 # 驻留集大小 PAGE_ACCESS = [3, 4, 2, 6, 4...

    页面置换算法

    1 时钟置换算法 CLOCK

    在这里插入图片描述

    1.1 代码实现

    原谅我的无聊,偏要写一下代码实现以下

    • 给定驻留集大小
    • 访问串
      计算每次内存中页面,并最终计算缺页率
    BLOCKS = 3  # 驻留集大小
    PAGE_ACCESS = [3, 4, 2, 6, 4, 3, 7, 4, 3, 6, 3, 4, 8, 4, 6]  # 输入串
    
    
    class Clock(object):
        def __init__(self, BLOCKS, PAGE_ACCESS):
            self.BLOCKS = BLOCKS
            self.PAGE_ACCESS = PAGE_ACCESS
            self.CList = [None for i in range(self.BLOCKS)]  # 循环链表
            self.index = 0  # 指针
            self.access = [0 for i in range(self.BLOCKS)]  # 访问位
    
        def fix_index(self):
            if self.index >= self.BLOCKS:
                self.index = 0
    
        def run(self):
            counter = 0
            for outer_index, page in enumerate(self.PAGE_ACCESS):
                have_page = None
                have_page_index = None
                for _index, exist_page in enumerate(self.CList):
                    if exist_page == page:
                        have_page = exist_page
                        have_page_index = _index
    
                # 如果不缺页
                if have_page:
                    # 指针不变
                    # 对应页的访问位置为 1
                    self.access[have_page_index] = 1
                else:  # 缺页的情况
                    print(outer_index)
                    counter += 1
                    # # 如果内存中的页表修改为全为 1,则需要全部置为 0,指针指向第一个页面
                    # 这个做法是错误的,当内存中两个页面为 1,一个页面为 0 时,若此时进来的页面不导致缺页,
                    # 把 0 的位置进行了换页,那么指针的位置不一定会指向第一个页面
                    # if all(self.access):
                    #     self.access = [0 for i in range(self.BLOCKS)]
                    #     self.index = 0
    
                    # 问题在于,如果 self.index 为 2的时候,只跑一遍,可以设置一个值,每一轮必须找到一个页面
                    flag = 0
    
                    for inner_index in range(self.index, len(self.CList)):
                        # 经过的访问位为 1 则修改为 0
                        if self.access[inner_index] == 1:
                            self.access[inner_index] = 0
                            self.index = inner_index + 1
                            self.fix_index()
                        else:  # 经过的访问位为 0 则进行换页
                            self.CList[inner_index] = page
                            self.access[inner_index] = 1
                            self.index = inner_index + 1  # 指针指向下一个
                            self.fix_index()  # 修正指针的值
                            flag = 1
                            break
    
                    if not flag:
                        for inner_index in range(self.index, 3):
                        # 经过的访问位为 1 则修改为 0
                            if self.access[inner_index] == 1:
                                self.access[inner_index] = 0
                                self.index = inner_index + 1
                                self.fix_index()
                            else:  # 经过的访问位为 0 则进行换页
                                self.CList[inner_index] = page
                                self.access[inner_index] = 1
                                self.index = inner_index + 1  # 指针指向下一个
                                self.fix_index()  # 修正指针的值
                                break
                print(self.CList)
            print(f"缺页率 -> {counter/len(self.PAGE_ACCESS)}")
    
    
    class ClockPlus(object):
        def __init__(self, BLOCKS, PAGE_ACCESS):
            self.PAGE_ACCESS = PAGE_ACCESS
            self.BLOCKS = BLOCKS
            # (访问位, 修改位)
            self.site = [(0, 0) for i in range(self.BLOCKS)]
            
    
        def run(self):
            # 四次遍历 --> 写成两次
            for index in range(len(self.data)):
                tup = self.data[index]
                if tup[0] == 0 and tup[1] == 0:
                    pass    
    
    
    if __name__ == '__main__':
        clock = Clock(BLOCKS, PAGE_ACCESS)
        clock.run()
    

    2 改进型时钟置换算法

    在这里插入图片描述

    展开全文
  • Clock页面置换算法

    2008-12-10 11:38:52
    模拟操作系统中的Clock页面置换算法。。。。。。。。
  • Clock页面置换算法(简单和改进)

    千次阅读 2020-12-06 10:34:18
    Clock页面置换算法(简单和改进简单的Clock置换算法改进型Clock算法 简单的Clock置换算法 简单的Clock置换算法,是一种LRU置换算法的近似算法。 思想:当利用简单的Clock算法的时候,需要给每一个页面添加一位...

    Clock页面置换算法(简单和改进

    简单的Clock置换算法

    • 简单的Clock置换算法,是一种LRU置换算法的近似算法。

    • 思想:当利用简单的Clock算法的时候,需要给每一个页面添加一位访问位,再将内存中的所有页面链接成一个环形队列,方便循环访问,一开始访问位都是 0,在被访问之后,访问位设置为 1。
      在进程当中,如果页面的访问位为 0,则可以将其换出,如果是 1,将其访问位变为 0,接着找下一个,。直到找到最后,循环下一次。

    • 举例在这里插入图片描述一开始全为0,可能有问题,因为都被访问过,应该设置为1的,但是已经满了,还是要循环,最后下面又变为0,相当于偷懒吧。如果有问题,请指正。

    改进型Clock算法

    • 改进型Clock算法,为啥要改进?
      在将一个页面换出的时候,如果该页面已经被修改,则要将该页面重新回写到磁盘,如果该页面未被修改,则不需要将它拷回磁盘,就是说,如果这个页面在置换之前已经被修改过了,相比未修改过的页面需要花费更大的开销。

    • 思想:除了访问位,再添加一个修改位,具体的置换规则:

      (0,0):最近没有使用使用也没有修改,最佳状态!

      (0,1):修改过但最近没有使用,第二考虑的状态

      (1,0):使用过但没有被修改,该页面可能再次被访问

      (1,1):使用过也修改过,该页面可能再次被访问

    • 举例:
      参考https://blog.csdn.net/zhuixun_/article/details/85336417?utm_medium=distribute.pc_relevant.none-task-blog-utm_term-2&spm=1001.2101.3001.4242

    展开全文
  • 实验六改进型Clock页面置换算法实现.doc
  • 适合学习过操作系统的学生下载学习,用C++语言和MFC写的,可以很好的模拟操作系统的页面置换算法,图形界面,内附实验源码+报告书。
  • 一、课程设计目的《操作系统》是一门重要的专业基础课,是涉及较多硬件知识的计算机系统软件课程。...操作系统课程设计的主要任务是研究计算机操作系统的基本原理和算法,掌握操作系统的进程管理、存储管...

    一、课程设计目的

    《操作系统》是一门重要的专业基础课,是涉及较多硬件知识的计算机系统软件课程。在计算机软硬件课程的设置上,它起着承上启下的作用。操作系统对计算机系统资源实施管理,是所有其他软件与计算机硬件的唯一接口,所有用户在使用计算机时都要得到操作系统提供的服务。

    操作系统课程设计的主要任务是研究计算机操作系统的基本原理和算法,掌握操作系统的进程管理、存储管理、文件管理和设备管理的基本原理与主要算法。目的是使学生掌握常用操作系统(如DOS、Windows或Linux)的一般管理方法,了解它是如何组织和运作的,对操作系统的核心概念和算法有一个透彻的理解,并对系统运行的机制有一个全面的掌握,从而充分理解系统调用与程序设计之间的关系。

    进行操作系统课程设计主要是在学习操作系统课程的基础上,在完成操作系统各部分实验的基础上,对操作系统的整体进行一个模拟,通过实践加深对各个部分的管理功能的认识,还能进一步分析各个部分之间的联系,最后达到对完整系统的理解。同时,可以提高运用操作系统知识解决实际问题的能力;锻炼实际的编程能力、创新能力及团队组织、协作开发软件的能力;还能提高调查研究、查阅技术文献、资料以及编写软件设计文档的能力。

    二、课程设计内容与要求

    2.1 设计内容

    采用CLOCK置换算法仿真请求分页系统

    18702784-d89ecc4545aef541.png

    点击此处下载文档和源码

    展开全文
  • 页面置换算法CLOCK算法

    千次阅读 2021-06-07 17:07:14
    时钟置换算法可以认为是一种最近未使用算法,即逐出的页面都是最近没有使用的那个。它和LRU算法有类似之处,只不过clock算法会有一个用于记录访问次数的数组,然后再根据第一个最小访问次数来进行替换处理,当访问到...
  • 1.前言缓冲池是数据库最终的概念,数据库可以将一部分数据页放在内存中形成缓冲池,当需要一个数据页时,首先检查内存中的缓冲池是否有这个页面,如果有则直接命中返回,没有则从磁盘中读取这一页,然后缓存到内存并...
  • 一、Opt(最佳置换算法):(不排序)       写法:上老下新(下面的是最新访问的)       思想:往后看,替换那个未来不使用或者未来最长时间内不被...
  • Clock页面置换算法; 6)动态给出页面调用序列并进行调度; 7)输出置换结.C++编程要?考试用 哪位大侠 帮帮 快点 谢谢了这很简单啊,要打字太多了。不过网上这类算法举例很少,就看你怎么理解了。改良后的Clock算法 ...
  • 页面置换算法-CLOCK置换算法及其改进版算法

    万次阅读 多人点赞 2018-12-29 13:31:51
    本文主要介绍页面置换算法中的CLOCK置换算法。页面置换算法中的LRU算法最接近理想情况下的OPT算法,但是实现起来比较困难且开销较大,所以很多设计者试图用开销比较小的算法接近LRU算法,CLOCK算法就是其中一种。 1...
  • 一个页面置换算法性能比较程序,包括了最佳置换,先进先出,LRU,随机置换,简单时钟和改进时钟六个算法。使用了队列,链表,循环链表等数据结构。随机产生请求页号,计算六种算法的缺页率。
  • 该工程具体是在codeblock上面实现了操作系统课程上讲解的页面置换算法,包括先进先出(FIFO)、最佳置换算法(OPT)、最久最近未使用算法(LRU)。 具体实现功能有: 1、建立相应的数据结构 2、在屏幕上显示页面的...
  • 置换算法在选择一页淘汰时,只需检查页的访问位。如果是0,将该页换出;若为1,将该页重新置0,暂不换出,给予该页第二次驻留内存的机会,再检查下一个页面。 当检查到队列的最后一个页面时,若访问位仍为1,则返回...
  • 页面置换Clock置换算法

    千次阅读 2019-11-17 11:14:22
    1、简单的Clock置换算法 当采用简单Clock算法时,只需为每页设置一位访问位,再将内存中的所有页面都通过链接指针链接成一个循环队列。当某页被访问时,其访问位被置1。置换算法在选择一页淘汰时,只需检查页的访问...
  • 该工程具体是在codeblock上面实现了操作系统课程上讲解的页面置换算法,包括先进先出(FIFO)、最佳置换算法(OPT)、最久最近未使用算法(LRU)。 具体实现功能有: 1、建立相应的数据结构 2、在屏幕上显示页面...
  • 时钟(CLOCK)置换算法

    万次阅读 多人点赞 2018-12-28 21:44:19
    用于选择淘汰页面的算法称为页面置换算法,置换算法的好坏,将直接影响到请求分页系统的性能。 FIFO置换算法和LRU置换算法的思想都比较容易理解,页面置换的推导也是简单的。但是CLOCK置换算法比较难从书上获取准确...
  • 操作系统-CLOCK置换算法

    千次阅读 2022-05-09 19:08:20
    CLOCK置换算法: 是一种LRU的近似算法,是一种性能和开销较均衡的算法。由于LRU算法需要较多的硬件支持,采用CLOCK置换算法只需相对较少的硬件支持。又称为最近未用算法(NRU) 简单的CLOCK置换算法 1.实现方法:...
  • 一、页面置换算法 请求分页 存储管理与 基本分页 存储管理的主要区别: ①、在程序执行过程中,当所访问的信息不在内存时,由操作系统负责将所需信息从外存调入内存【操作系统要提供请求调页功能,将缺失页面从外存...
  • C#源码
  • 页面置换算法之 改进型Clock算法

    千次阅读 2020-12-05 20:37:38
    改进型Clock算法 由 访问位A 和 修改位M 可以组合成下面四种类型的页面: 1类(A=0, M=0):表示该页最近既未被访问,又未被修改,是最佳淘汰页。 2类(A=0, M=1):表示该页最近未被访问,但已被修改,并不是很好的...
  • 操作系统os 页面置换算法 (java实现) Clock.java Lru.java Opt.java Fifo.java
  • 全面的页面置换算法(opt、fifo、lru、clock),很全。
  • 模拟操作系统页面置换的过程,具体实现了四种经典算法,即OPT、LRU、FIFO、CLOCK,并且利用Java中的图形库制作了一个好看的图形化界面
  • 最佳置换算法、随机置换算法、先进先出置换算法、最近最久未使用置换算法、简单Clock置换算法及改进型Clock置换算法;通过支持页面访问序列随机发生实现有关算法的测试及性能比较。

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 3,894
精华内容 1,557
关键字:

clock页面置换算法

友情链接: 19990444.rar