精华内容
下载资源
问答
  • 分页式存储管理中
    千次阅读
    2018-07-03 11:43:50

    实验五:模拟分页式存储管理中硬件的地址转换和产生缺页中断,然后分别用LRU、FIFO、改进型的CLOCK算法实现分页管理的缺页中断。

    要求:显示每个页面在内存中的绝对地址,页表信息、列出缺页情况等。

    # 实验五:模拟分页式存储管理中硬件的地址转换和产生缺页中断,然后分别用
    # LRU、FIFO、改进型的CLOCK算法实现分页管理的缺页中断。
    # 要求:显示每个页面在内存中的绝对地址,页表信息、列出缺页情况等。
    import random
    import copy
    PAGE_MEMORY = 4
    INTERVAL = 1
    
    def time_up(page_list):
        for p in page_list:
            p['time'] += INTERVAL
    
    def print_list(page_list):
        page_num = []
        for p in page_list:
            page_num.append(int(p['No']))
        print('序列为:',end = '')
        print(page_num)
    
    #################### FIFO置换算法 #############################
    
    def FIFO(pages_):
        pages = copy.deepcopy(pages_)
        print('')
        print('页面请求序列为 8 9 10 7 0 1 2 0 3 0 4 2 3 0 3 2 1 2 0 1 7 0 1')
        print('############ FIFO ################')
        page_list = []
        for p in pages:
            page_list_data = []
            if len(page_list) < PAGE_MEMORY:
                page_list.append(p)
            else:
                #s = [page_['No'] for page_ in page_list]
                for page_ in page_list:
                    page_list_data.append(page_['No'])
    
                if p['No'] in page_list_data:
                    print('----Remind-----: 新页表%d已经在队列中,绝对地址为%d'%(p['No'],1024 * page_list_data.index(p['No'])))
                else:
                    print('----Remind-----: 新页面%d将替换旧页面%d'%(p['No'],page_list[0]['No']))
                    page_list.remove(page_list[0])
                    page_list.append(p)
        #print("目前的队列为[{0[0]},{0[1]},{0[2]}]".format(page_list))
            print_list( page_list)
    
    #################### LRU置换算法 #############################
    
    def LRU(page_):
        print('')
        print('页面请求序列为 8 9 10 7 0 1 2 0 3 0 4 2 3 0 3 2 1 2 0 1 7 0 1')
        print('############ LRU ################')
        pages = copy.deepcopy(page_)
        page_list = []
        for p in pages:
            page_list_data = []
            if len(page_list) < PAGE_MEMORY:
                page_list.append(p)
            else:
                for page_ in page_list:
                    page_list_data.append(page_['No'])
                time_up(page_list)
                if p['No'] in page_list_data:
                    page_list[page_list_data.index(p['No'])]['time'] = 0
                    print('----Remind-----: 页表%d已经在队列中,绝对地址为%d' % (p['No'],1024 * page_list_data.index(p['No'])))
                else:
                    tran = max(page_list, key=lambda t: t['time'])            #原本是应该位置上的元素替换,但是需要占位,于是直接采取了append的方法
                    page_list.remove(tran)
                    page_list.append(p)
                    print('----Remind-----: 新页表%d将替换%d' % (p['No'], tran['No']))
            print_list(page_list)
    
    ####################改进型Clock置换算法#############################
    
    def obsolete_page(page_list):
        while True:
            for page in page_list:
                if page['visited'] == False and page['modified'] == False:
                    return page
            for page_ in page_list:
                if page_['visited'] == False and page_['modified'] == True:
                    return page_
            for _page in page_list:
                _page['visited'] = False
    
    def getIndex(p, page_list):
        i = 0
        for pages_ in page_list:
            if p['No'] == pages_['No']:
                return i
            i += 1
        return 0
    
    def Improved_Clock(pages_):
        pages = copy.deepcopy(pages_)
        print('')
        print('页面请求序列为 8 9 10 7 0 1 2 0 3 0 4 2 3 0 3 2 1 2 0 1 7 0 1')
        print('############ Improved_Clock ################')
        page_list = []
        for p in pages:
            page_list_data = []
            if len(page_list) < PAGE_MEMORY:
                page_list.append(p)
            else:
                for page_ in page_list:
                    page_list_data.append(page_['No'])
                if p['No'] not in page_list_data:
                    _page = obsolete_page(page_list)
                    print('----Remind-----: 新页表%d将会替换页表%d' %(_page['No'], p['No']))
                    page_list.remove(_page)
                    page_list.append(p)
                else:
                    print('----Remind-----: 页表%d已存在,绝对地址为%d'%(page_list[getIndex(p,page_list)]['No'],1024*getIndex(p, page_list)))
                    page_list[getIndex(p,page_list)]['visited'] = True
            print_list(page_list)
    
    def init(pages):
        for p in pages:
            p['time'] = 0
            p['visited'] = False
            a = random.random()
            if a<0.5:
                p['modified'] = False
            else:
                p['modified'] = True            #被访问过
    
    if __name__ == '__main__':
        pages = [
            {'No': 8},{'No': 9},{'No': 10},{'No': 7},{'No': 0},{'No': 1},{'No': 2},
            {'No': 0},{'No': 3},{'No': 0},{'No': 4},{'No': 2},{'No': 3},{'No': 0},
            {'No': 3},{'No': 2},{'No': 1},{'No': 2},{'No': 0},{'No': 1},{'No': 7},
            {'No': 0},{'No': 1}
        ]
    
        init(pages)
    
        FIFO(pages)
    
        LRU(pages)
    
        Improved_Clock(pages)


    更多相关内容
  • 模拟分页式存储管理中硬件的地址转换和产生缺页中断.------很好用的程序和源代码
  • 操作系统 模拟分页式存储管理中硬件的地址转换和产生缺页中断c++
  • 模拟分页式存储管理中硬件的地址转换和产生缺页中断[文].pdf
  • 利用键盘输入本模拟系统的物理块的大小,作业的页表的块号;完成逻辑地址转换成相应的物理地址的过程。 1、建立一张位示图,用来模拟内存的分配情况,利用随机数产生一组0和1的数对应内存的使用情况。 2、输入块...
  • 第一题:模拟分页式存储管理中硬件的地址转换和产生缺页中断。 第二题:用先进先出(FIFO)页面调度算法处理缺页中断。
  • 在第1部分实验基础上实现进程的分页式内存分配和地址转换过程,并进一步实现请求分页式存储分配和地址转换过程。页面置换算法至少应实现先进先出(FIFO)、最近最久未使用(LRU)等算法。
  • 1.模拟分页式存储管理中硬件的地址转换和产生缺页中断。 2.用先进先出(FIFO)页面调度算法处理缺页中断。
  • 模拟分页式存储管理中硬件的地址转换和产生缺页中断。
  • 分页式虚拟存储系统是把作业信息的副本存放在磁盘上,当作业被选中时,可把作业的开始几页先装入主存且启动执行。该程序是模拟存储管理的地址转换代码
  • 分页式存储管理

    2013-05-25 22:53:33
    实现进程的分页式内存分配和地址转换过程,并进一步实现请求分页式存储分配和地址转换过程。页面置换算法至少应实现先进先出(FIFO)、最近最久未使用(LRU)等算法。
  • 操作系统课请求分页存储管理模拟模拟程序,程序相对简单,通过这个模拟程序能够帮助学习者会更好的学习os,供有需要的人学习使用。
  • 1、 多道程序技术的特点 2、 程序、进程、线程的区别 3、 生产者-消费者问题的同步...6、 在分页式存储管理中,什么叫快表,说明其工作原理和过程,画出具有快表的地址变换机构。 7、 系统抖动 8、 临界资源和临界区
  • 分页式虚拟存储管理中,要求通过键盘输入分配给一个作业的物理块数和作业依次访问的10个页面号,采用先进先出(FIFO)页面置换后,顺序输出缺页中断时所淘汰的页面号,并计算缺页中断率。 #include<cstdio> ...

    在分页式虚拟存储管理中,要求通过键盘输入分配给一个作业的物理块数和作业依次访问的10个页面号,采用先进先出(FIFO)页面置换后,顺序输出缺页中断时所淘汰的页面号,并计算缺页中断率。

    #include<cstdio>
    
    using namespace std;
    
    const int maxn = 1e5 + 5;
    
    int page_now;
    int page_num, space_num;
    int flag[maxn], space_array[maxn];
    
    int main()
    {
        int i, j, num, sum;
        while(1)
        {
            num = 0; sum = 0;
    
            printf("请输入进程总页数和系统分配的物理块:");
            scanf("%d %d", &page_num, &space_num);
    
            for(i = 0; i < page_num; i++) flag[i] = 0;
            for(i = 0; i < space_num; i++) space_array[i] = -1;
    
            i = 1;
            printf("请输入调度页面序号(按‘-1’结束):\n");
            while(scanf("%d", &page_now) != 'EOF')
            {
                if(page_now == -1) break;
    
                sum++;
                if(flag[page_now]) printf("第%2d个调度:未发生中断,页面%d已在主存\n", i, page_now);
                else
                {
                    if(space_array[num % space_num] == -1) printf("第%2d个调度:发生缺页中断\n", i);
                    else
                    {
                        printf("第%2d个调度:发生缺页中断,页面%d被调出主存\n", i, space_array[num % space_num]);
                        flag[space_array[num % space_num]] = 0;
                    }
                    space_array[num % space_num] = page_now;
                    flag[page_now] = 1;
                    num++;
                }
                i++;
            }
            printf("缺页中断次数为%d,缺页中断率为%.2f%%\n\n", num, num * 1.0 / sum * 100);
        }
        return 0;
    }
    
    
    展开全文
  • 操作系统——页面置换 模拟分页式存储管理中硬件的地址转换和产生缺页中断
  • 操作系统实验 分页式存储管理-experimental operating system paging storage management
  • 模拟分页式虚拟存储管理中硬件的地址转换和缺页中断,以及用先进先出(FIFO)页面调度算法处理缺页中断。 用高级语言编写和调试一个简单的文件系统,模拟文件管理的工作过程。(题目四) 包含详细实验报告·
  • 本设计通过请求页式存储管理中页面置换算法模拟设计,了解虚拟存储技术的特点,掌握请求页式管理的页面置换算法。 (1)从置换算法中任选 2 种(OPT、 FIFO、LRU、Clock);(2)建立页表;(3) 设计的输入数据要能...
  • 操作系统实验(四):c实现分页式存储管理地址转换和缺页中断

    一、【实验目的】
    ①掌握分页式存储管理地址转换和缺页中断。
    ②理解虚拟存储器概念。
    二、【实验内容】
    1.模拟分页式存储管理中硬件的地址转换和产生缺页中断
    分页式虚拟存储系统是把作业信息的副本存放在磁盘上,当作业被选中时,可把作业的开始几页先装入主存且启动执行。为此,在为作业建立页表时,应说明哪些页已在主存,哪些页尚未装入主存。
    作业执行时,指令中的逻辑地址指出了参加运算的操作存放的页号和单元号,硬件的地址转换机构按页号查页表,若该页对应标志为“1”,则表示该页已在主存,这时根据关系式“绝对地址=块号×块长+单元号”计算出欲访问的主存单元地址。如果块长为2的幕次,则可把块号作为高地址部分,把单元号作为低地址部分,两者拼接而成绝对地址。若访问的页对应标志为“0”,则表示该页不在主存,这时硬件发“缺页中断”信号,由操作系统按该页在磁盘上的位置,把该页信息从磁盘读出装入主存后再重新执行这条指令。
    2.用先进先出(FIFO)页面调度算法处理缺页中断
    在分页式虚拟存储系统中,当硬件发出“缺页中断”后,引出操作系统来处理这个中断事件。如果主存中已经没有空闲块,则可用FIFO页面调度算法把该作业中最先进入主存的一页调出,存放到磁盘上,然后再把当前要访问的页装入该块。调出和装入后都要修改页表中对应页的标志。
    FIFO页面调度算法总是淘汰该作业中最先进入主存的那一页,因此可以用一个数组来
    表示该作业已在主存的页面。假定作业被选中时,把开始的m个页面装入主存,则数组的元素可定为m个。
    三、【实验步骤】
    数据结构

    struct pageTable//页表信息结构体
    {
    int cunzai;//页标志,1表示该页已在内存,0表示该页不在内存
    long block;//块号
    long weizhi;//在磁盘上的位置
    int gengxin;//更新标志
    }pageList[PAGENUM];
    define PAGENUM 100//定义页数大小为100
    define BLOCKSIZE 128//定义块大小为128
    define BLOCKNUM 4//定义块数量为4
    P[BLOCKNUM];//假设内存中最多允许BLOCKNUM个页面

    实验代码

    #include <stdio.h>
    #include <string.h>
    
    #define PAGENUM 100//页大小为100 
    #define BLOCKSIZE 128//块大小为128 
    #define BLOCKNUM 4//块数量为4 
    
    struct PageTable//页表信息结构体
    {
     int cunzai;//页标志,1表示该页已在内存,0表示该页不在内存
     long block;//块号
     long weizhi;//在磁盘上的位置
     int gengxin;//更新标志
    }pageList[PAGENUM];
    long po;//队列标记
    long P[BLOCKNUM];//假设内存中最多允许BLOCKNUM个页面
    void InitVirtual()//内存空间初始化。
    {
     memset(pageList, 0, sizeof(pageList));//内存空间初始化
     /*分页式虚拟存储系统初始化*/
     pageList[0].cunzai = 1;
     pageList[0].block = 5;
     pageList[0].weizhi = 011;
     pageList[1].cunzai = 1;
     pageList[1].block = 8;
     pageList[1].weizhi = 012;
     pageList[2].cunzai = 1;
     pageList[2].block = 9;
     pageList[2].weizhi = 013;
     pageList[3].cunzai = 1;
     pageList[3].block = 1;
     pageList[3].weizhi = 021;
    }
    void AddTrans()
    {//模拟分页式存储管理中硬件的地址转换和产生缺页中断过程
     int stop = 0;
     long p, q;//p为页号,q为页偏移 
     char s[128];
     while(!stop)
     {
      printf("请输入指令的页号和业内偏移:\n");
      printf("注意:若想退出请输入“exit”\n");
      if(scanf("%ld%ld", &p, &q) !=2 )
      {
       scanf("%s", &s);
       if(strcmp(s, "exit") == 0)
       {
        stop = 1;//如果输入的为“exit”那么就退出,进入重选页面
       }
      }
      else
      {
       if(pageList[p].cunzai)//如果该页cunzai标志位为1,说明该页在主存中
       {
        printf("绝对地址=%ld\n", pageList[p].block * BLOCKSIZE + q);//计算出绝对地址,绝对地址=块号*块长(默认128)+单元号
       } 
       else
       {
        printf("*该页%ld不在页表中,产生缺页中断\n", p);//如果该页cunzai标志位为0,表示该页不在主存中,则产生了一次缺页中断
       }
      }
     }
    }
    
    void InitFifo()
    {
    //以下部分为用先进先出(FIFO)页面调度算法处理缺页中断的初始化,其中也包含了对于当前的存储期内容的初始化
     po = 0;
     P[0] = 0;
     P[1] = 1;
     P[2] = 2;
     P[3] = 3;//对内存中的4个页面初始化并使目前排在第一位的为0
     memset(pageList, 0, sizeof(pageList));//内存空间初始化
     pageList[0].cunzai = 1;
     pageList[0].block = 5;
     pageList[0].weizhi = 011;
     pageList[1].cunzai = 1;
     pageList[1].block = 8;
     pageList[1].weizhi = 012;
     pageList[2].cunzai = 1;
     pageList[2].block = 9;
     pageList[2].weizhi = 013;
     pageList[3].cunzai = 1;
     pageList[3].block = 1;
     pageList[3].weizhi = 021;
    }
    
    void Fifo()
    {
     long p = 0;
     long q = 0;
     long i = 0;
     char s[100];
     int stop = 0;
     while(!stop)
     {
      printf("当前数组P的值为:\n");
      for(i = 0; i < BLOCKNUM; i++)
      {//循环输出当前数组的数值,即当前在内存中的页面
       printf("P[%ld]=%ld\n", i, P[i]);
      }
      printf("请输入指令的页号、业内偏移、输入y或n是否为内存指令:\n");
      printf("注意:若想退出请输入“exit”\n");
      if(scanf("%ld%ld", &p, &q) != 2)
      {
       scanf("%s", &s);
       if(strcmp(s, "exit") == 0)
       {
        stop = 1;//如果输入为"exit"那么就退出,进入重选页面
       }
      }
      else
      {
       scanf("%s", &s);
       if(pageList[p].cunzai)
       {//如果该页cunzai标志位为1,说明该页在主存中
        printf("绝对地址=%ld\n", pageList[p].block * BLOCKSIZE + q);//计算绝对地址,绝对地址=块号×块长(128)+单元号
        if(s[0] == 'Y' || s[0] == 'y')
        {//内存指令
         pageList[p].gengxin = 1;//修改标志为1
        }
       }
       else//如果所输入的页不在内存中
       {
        if(pageList[P[po]].gengxin)//当前页面被更新过,把更新后的内容写回外存
        {
         pageList[P[po]].gengxin = 0;//将标志位复0
        }
        pageList[P[po]].cunzai = 0;//将cunzai标志位置0,表示当前页面已被置换出去
        printf("被置换出去的页面为%ld\n", P[po]);//显示根据FIFO算法被置换出去的页面
        printf("被调入的页面为%ld\n", p);//显示根据FTFO算法被调入的页面
        pageList[p].block = pageList[P[po]].block;//块号相同
        pageList[p].cunzai = 1;//将当前页面的标记置为1,表示已在主存中
        P[po] = p;//保存当前页面所在的位置
        po = (po+1) % BLOCKNUM;
       }
      }
     } 
    }
    
    void select()
    {//选择哪种方法进行
     long se;
     char s[128];
     while(1)
     {
      printf("请选择题号(1/2):\n");
      if(scanf("%ld", &se) !=1 )
      {
       scanf("%s", &s);
       if(strcmp(s, "exit") == 0)
       {//如果输入为exit则退出整个程序
        return;
       }
      }
      else
      {
       if(se == 1)
       {//如果se=1说明选择的是模拟分页式存储管理中硬件的地址转换和产生缺页中断
        InitVirtual();//初始化z
        AddTrans();//进行模拟
       }
       if(se == 2)
       {//如果se=2说明选择的是FFO算法来实现页面的置换
        InitFifo();//初始化
        Fifo();//进行模拟
       }
      }
     }
    }
    
    int main()
    {
     select();//选择题号
     return 0;
    }
    

    实验结果自行运行~

    展开全文
  • 请求分页式存储管理

    2012-12-10 18:44:57
    操作系统实验,请求分页式存储管理,无BUG版
  • 请求分页式存储管理.pdf请求分页式存储管理.pdf请求分页式存储管理.pdf请求分页式存储管理.pdf请求分页式存储管理.pdf请求分页式存储管理.pdf请求分页式存储管理.pdf请求分页式存储管理.pdf
  • 请求分页式存储管理.docx请求分页式存储管理.docx请求分页式存储管理.docx请求分页式存储管理.docx请求分页式存储管理.docx请求分页式存储管理.docx请求分页式存储管理.docx请求分页式存储管理.docx
  • 请求分页虚拟存储管理技术是把作业地址空间的全部信息存放在磁盘上。当作业被选中运行时,先把作业的开始几页装入主存并启动运行。为此在为作业建立页表时,应说明哪些页已在主存,哪些页不在主存。
  • 西北工业大学操作系统实验 分页存储管理与虚拟内存

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 45,816
精华内容 18,326
关键字:

分页式存储管理中