操作系统页面存储管理系统

最新推荐文章于 2023-02-04 16:50:56 发布
最新推荐文章于 2023-02-04 16:50:56 发布
阅读量822 收藏 1
点赞数
分类专栏： 编程语言 文章标签： 操作系统
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u010749410/article/details/17174847
版权

#include<stdio.h>
#include<stdlib.h>
#include<math.h>
#include<time.h>
#include<iostream>
using namespace std;
#define Maxsize 64                        //进程大小
#define X 64                              //物理块的大小
***** 定义页表结构体 *****
struct Page
{
 int Yh;                          //页表的页号
    int kh;                          //页表的块号
 int State;                       //页表的状态
};
typedef struct node
{
 int data[Maxsize];
 int top;
}SeqStack;        //定义顺序栈

unsigned char RAM[8];                  //用于生成位图                          
int Map[64];                         
int YeHao[X];       //定义访问页号的序列
int Length,Size,kuaisu;                 //定义页表的长度，页块大小，内存块的个数
int C;         //用于计算内存块的大小
int Num;        //定义内存队列节点的个数
int Visit[Maxsize];                     //定义访问过的页面序列号

struct Page   page1[100];    //定义页表结构体数组
struct Page   page2[100];
struct Page   page3[100];
int d;         //定义逻辑地址
int Yh;         //定义页号
int Yd;         //定义相对地址
int v;         //定义访问次数

int n1=0;        //命中次数
int n2=0;                               //定义LRU算法的命中次数

SeqStack *neichun1=(SeqStack *)malloc(sizeof(SeqStack));               
SeqStack *neichun2=(SeqStack *)malloc(sizeof(SeqStack));              
SeqStack *neichun3=(SeqStack *)malloc(sizeof(SeqStack));               
///*******创建位示图******//
//用二进制的一位来表示磁盘中的一个盘块的使用情况
void weishitu()
{
 int k=0;
  srand(time(0));           //种下随机数种子，使每次产生的随机数不同
 for(int i=0;i<8;i++)
 {              //产生8个0-256的数
  RAM[i]=(unsigned char)rand()%256;
 }
 cout<<endl;
 for(int j=0;j<64;j++)
 {
    int x=j%8;int y=j/8;
    unsigned char temp=(unsigned char)pow(2,x);
    if(( unsigned char)(RAM[y]&temp)==temp)             //判断内存空间是否被占用
    Map[j]=1;
    else
    Map[j]=0;
 }
 for(int m=0;m<64;m++)
 {
 cout<<" "<<Map[m];
 if(m%8==7)
 cout<<endl;
 }
}
***********对栈的操作**********
//返回栈尾
void setnull(SeqStack *s)                   
{
 s->top=-1;
}
//判断是否是空栈
int StackIsEmpty(SeqStack *s)
{
   if (s->top == -1)
   return 1;
   else
   return 0;
}
//进栈
void StackPush(SeqStack *s, int x)
{
    s->top++;
    s->data[s->top] = x;    
}
//出栈
int StackPop(SeqStack *s)
{
 s->top--;
 return(s->data[s->top+1]);
}
*****将栈中的最后一个元素删除******
void outStack(SeqStack *s)
{
 int SS[Maxsize];
 int j=0;
 while(!StackIsEmpty(s)&&j<kuaisu)
  {  
     SS[j]=StackPop(s);
     j++;
  }
   for(int i=kuaisu-2;i>=0;i--)
   {  
    StackPush(s,SS[i]);  
   }
}
**********删除栈中的任意元素***********/
void DeleteStack(SeqStack *s,int xx)
{
 int SS[Maxsize];
 int j=0;
 while(!StackIsEmpty(s)&&s->data[s->top]!=xx&&j<kuaisu)
 {
  SS[j]=StackPop(s);
  j++;
 }
 StackPop(s);
 for(int i=j-1;i>=0;i--)
 {
  StackPush(s,SS[i]);
 }  
}
**********将栈中的任意元素放到栈顶***********/
void TopStack(SeqStack *s,int xx)
{
 int SS[Maxsize];
 int j=0;
 while(!StackIsEmpty(s)&&s->data[s->top]!=xx&&j<kuaisu)
 {
  SS[j]=StackPop(s);
  j++;
 }

 StackPop(s);
 for(int i=j-1;i>=0;i--)
 {
  StackPush(s,SS[i]);
 }
  StackPush(s,xx);
}
//输入页表长度及内存块数
void input()
{
 cout<<"   欢迎使用请求分页存储区管理实验        "<<endl; 
 cout<<"                   操作系统课程设计               "<<endl;
 cout<<"                                                    "<<endl;

 cout<<"输入页表长度:"<<endl;
 cin>>Length;
              //初始化页表结构体
 for(int i=0;i<Length;i++)
 {
  page1[i].Yh=i;
  page1[i].kh=-1;
  page1[i].State=0;
 }
 for(int j=0;j<Length;j++)
 {
  page2[j].Yh=j;
  page2[j].kh=-1;
  page2[j].State=0;
 }
 for(int k=0;k<Length;k++)
 {
  page3[k].Yh=k;
  page3[k].kh=-1;
  page3[k].State=0;
 }
              //初始化内存
 setnull(neichun1);
 setnull(neichun2);
 setnull(neichun3);
 cout<<"输入内存块数:"<<endl;
 cin>>kuaisu;

 cout<<"输入块长(k):"<<endl;
 cin>>Size;
 C=Size*1024;
}
//输入物理地址，并计算出逻辑地址   判断地址是否越界
void address()
{
 printf("输入地址: ");
 scanf("%x",&d);
 Yh=d/C;
 Yd=d%C;
 if(Yh>Length-1)
 {
  cout<<"错误!!  地址越界!!"<<endl;
  cout<<"请重新输入逻辑地址:";
  scanf("%x",&d);
  Yh=d/C;
  Yd=d%C;
 }
 printf("页号：%d\n",Yh);
 printf("十进制大小:%d\n",d);
 v++;
 Visit[v-1]=Yh;
}
void output(Page page[10],SeqStack *Memory,int c,float e)             //page为页表，Memory为内存栈，c为物理地址，e为命中次数，f为缺页率
{
 float f;
 cout<<"页号"<<"     "<<"块号"<<"     "<<"状态位"<<endl;
 for(int i=0;i<Length;i++)
 {
  cout<<"  "<<page[i].Yh<<"  "<<page[i].kh<<"    "<<page[i].State<<endl;
 }
 cout<<endl;
 cout<<"内存分配块:"<<endl;
 cout<<"序号"<<"    "<<"页号"<<endl;
    for(int k=0;k<Memory->top+1;k++)
    cout<<"  "<<k<<"      "<<Memory->data[k]<<endl;
    for(int j=Memory->top+1;j<kuaisu;j++)
    cout<<"  "<<j<<"      "<<"-1"<<endl;
 cout<<endl;
 cout<<"物理地址"<<c<<endl;
 cout<<"访问次数"<<v<<endl;
 int h=v-e;
 printf(" 缺页次数：%d  \n ",h);
 f=(1-e/v)*100;
    printf("缺页率:%5.2f%",f);
 cout<<"%"<<endl;

}

void outopt(Page page[10],SeqStack *Memory,int x,float e)
///page为页表，Memory为内存栈，c为物理地址，e为命中次数，
{
 float f;                    //定义f为缺页率
 cout<<"页号"<<"     "<<"块号"<<"     "<<"状态位"<<endl;
 for(int i=0;i<Length;i++)
 {
 cout<<"  "<<page[i].Yh<<"  "<<page[i].kh<<"    "<<page[i].State<<endl;
 }
 printf("内存分配块：\n");
 cout<<"序号"<<"    "<<"页号"<<endl;
   for(int k=0;k<Memory->top+1;k++)
    cout<<"  "<<k<<"      "<<Memory->data[k]<<endl;
    for(int j=Memory->top+1;j<kuaisu;j++)
    cout<<"  "<<j<<"      "<<"-1"<<endl;
 printf(" 访问次数：%d  \n",x);
 int h=x-e;
 printf(" 缺页次数：%d  \n ",h);
 f=(1-e/x)*100;
    printf("缺页率:%5.2f%",f);
 cout<<"%"<<endl;
}

int jisu1(){
 int c1;
 for(int i=kuaisu;i<v;i++)
 {   
        int flag0=0;
  if(Visit[i]==neichun3->data[0])
  {
   flag0=1;
   c1=i;
  }
     if(flag0==1) break;
  if(Visit[i]!=neichun3->data[0])
   c1=Maxsize+3;
 }
 return c1;
}

int jisu2(){
 int c2;
 for(int i=kuaisu;i<v;i++)
 {   
        int flag0=0;
  if(Visit[i]==neichun3->data[1])
  {
   flag0=1;
   c2=i;
  }
        if(flag0==1) break;
   if(Visit[i]!=neichun3->data[1]) c2=Maxsize+2;
 }
  return c2;
}
int jisu3(){
 int c3;
 for(int i=kuaisu;i<v;i++)
 {
        int flag0=0;
  if(Visit[i]==neichun3->data[2])
  {
       flag0=1;
      c3=i;
  }
        if(flag0==1) break;
    if(Visit[i]!=neichun3->data[2]) c3=Maxsize+1;
 }
 return c3;
}

int Max()
{
  int c1=jisu1();
  int c2=jisu2();
  int c3=jisu3();
  int Max0,Max;
  if(c1>c2) Max0=c1;
  else Max0=c2;
  if(Max0>c3)  Max=Max0;
    else Max=c3;
  return Max;
}
*****先进先出（FIFO）算法******/
void FIFO()
{
 if(page1[Yh].State==1)  n1++;
 else {             
            page1[Yh].State=1;
         if(neichun1->top+1<kuaisu)
   {
            int flag=0;
             for(int i=0;i<64;i++)
    {     
              if(Map[i]==0)
     {
                       flag=1;
                    Map[i]=1;
              page1[Yh].kh=i;
              StackPush(neichun1,Yh);
     }
         if(flag==1)  break;
    }        
   }
     else
  {   
       int s=neichun1->data[0];
          page1[Yh].kh=page1[s].kh;
    page1[Yh].State=1;
          page1[s].State=0;
    page1[s].kh=-1; 
    outStack(neichun1);
    StackPush(neichun1,Yh);
  }
 }
 int wl=page1[Yh].kh*C+Yd;
 output(page1,neichun1,wl,n1);
}
*******LRU(最近未使用)*********

void LRU()
{ 
  if(page2[Yh].State==1)
  {
  n2++;
  TopStack(neichun2,Yh);
  }
   else
   { 
          page2[Yh].State=1;
          if(neichun2->top+1<kuaisu)
    {    
             int flag1=0;
             for(int i=0;i<64;i++)
    {     
              if(Map[i]==0)
     {
                      flag1=1;
                   Map[i]=1;
             page2[Yh].kh=i;
             StackPush(neichun2,Yh);
     }
        if(flag1==1) break;
    }       
    }
        else{
            int s=neichun2->data[0];
               page2[Yh].kh=page2[s].kh;
         page2[Yh].State=1;
               page2[s].State=0;
         page2[s].kh=-1; 
         outStack(neichun2);
         StackPush(neichun2,Yh);     
     } 
  }
 int wl=page2[Yh].kh*C+Yd;
 output(page2,neichun2,wl,n2);
}
/*********最佳(OPT)置换算法**********/
void OPT()
{
 int m=0;                          //定义OPT算法的命中次数
 for(int i=0;i<v;i++)
 {
  Yh=Visit[i];
  if(page3[Yh].State==1) m++;
  else
  {
            page3[Yh].State=1;
   if(neichun3->top+1<kuaisu)
   {
     int flag2=0;
     for(int j=0;j<64;j++)
     {
        if(Map[j]==0)
      {
          flag2=1;
          Map[j]=1;
          page3[Yh].kh=j;
          StackPush(neichun3,Yh);
      }
         if(flag2==1) break;     
     }  
   }
   else
    {
       int leaf;          //定义将要删除页号
                   int max=Max();
       if(max==jisu1())  leaf=neichun3->data[0];
       else if(max==jisu2()) leaf=neichun3->data[1];
       else if(max==jisu3()) leaf=neichun3->data[2];
          page3[Yh].kh=page3[leaf].kh;
       page3[Yh].State=1;
       page3[leaf].State=0;
       page3[leaf].kh=-1;
                   DeleteStack(neichun3,leaf);
       StackPush(neichun3,Yh);
    }     
    }  
    output(page3,neichun3,i+1,m);
   }
}

 

void main()
{
 input();
 cout<<"位示图:";
 weishitu();
 cout<<"                                                    "<<endl;
 cout<<" 选择置换算法                   "<<endl;
 cout<<endl;
 cout<<"    FIFO : F            "<<endl;
 cout<<endl;
 cout<<"    LRU: L            "<<endl;
 cout<<endl;
 cout<<"    OPT :O            "<<endl;
 cout<<endl;
 cout<<" 位示图重置:R                "<<endl;

 cout<<"                                                    "<<endl;
 char A;
 while(1){    
     cout<<" 输入算法:"<<endl;
     
     cout<<">";
   cin>>A;
   
     switch(A)
     {
      case 'F':
      case 'f':     address();FIFO(); break;

      case 'L':
      case 'l':        address();LRU();break;

      case 'o':
      case 'O':
     {

     cout<<"访问页号:"<<endl;
         for(int i=0;i<v;i++)
     {
         cout<<Visit[i]<<"   "; 
     }
     cout<<endl;
     OPT();        
     break;
     }

      case 'R':
      case 'r': 
       cout<<"位示图:"<<endl;
       weishitu();
                
       for(int i=0;i<v;i++)
       {
        Visit[i]=NULL;
     }
       v=0;
       setnull(neichun1);
       setnull(neichun2);
       setnull(neichun3);
     }
 }
    
}

龙在江湖aa
关注
专栏目录
linux内核内存管理学习之一（基本概念，分页及初始化）
浩海拾贝
08-14 9985
一、概述 1.虚拟地址空间 内存是通过指针寻址的，因而CPU的字长决定了CPU所能管理的地址空间的大小，该地址空间就被称为虚拟地址空间，因此32位CPU的虚拟地址空间大小为4G，这和实际的物理内存数量无关。 Linux内核将虚拟地址空间分成了两部分： 一部分是用户进程可用的，这部分地址是地址空间的低地址部分，从0到TASK_SIZE，称为用户空间一部分是由内核保留使用的，这部分地址是地
uclinux-2008r1(bf561)内核中内存管理相关的几个结构体
嵌云阁
06-05 1927
 快乐虾http://blog.csdn.net/lights_joy/lights@hb165.com   本文适用于ADI bf561 DSPuclinux-2008r1-rc8 (移植到vdsp5)Visual DSP++ 5.0  欢迎转载，但请保留作者信息 1.1.1   pglist_datapglist_da
页式存储管理（模拟操作系统）
coderlyf的博客
12-30 1万+
最近操作系统课程实践要求，我们模拟页式存储管理，起初自己很没有思路，但是在详细的画出整个的流程的时候自己还是发现了一些规律，并且发现可以数组和队列进行模拟，我在自己写程序的时候用的是数组模拟的，当然在程序中，也会有很多的数组表示各种要记录的东西，这就要求你对页式存储管理要相当的熟悉。 这里我简单的讲述一下其中需要模拟的相关信息 1)首先需要将逻辑地址转换为对应的页号以及页内位移(这里我默认页面
操作系统 实验4【基本分页存储管理】
upward
05-19 1万+
操作系统 实验4【基本分页存储管理】
操作系统原理：页式存储管理
计算机技术博客
10-26 4861
操作系统原理：页式存储管理 内存分区存储管理的一个特点是连续性，每个程序都分有一片连续的内存区域。这种连续性导致碎片问题，包括 固定分区中的内碎片和可变分区中的外碎片。为了解决这些问题，人们又提出了“页式存储管理方案”。它的基本出发点 是打破存储分配的连续性，使一个程序的逻辑地址空间可以分布在若干个离散的内存块上，从而达到充分利用内存，提高 内存利用率的作用。 页式存储管理的基本思路是：
操作系统课程设计--存储管理 源代码及完整报告
05-30
本设计的目的是通过请求页式存储管理中页面置换算法模拟设计，了解虚拟存储技术的特点，掌握请求页式存储管理的页面置换算法。 (1)通过随机数产生一个指令序列，共320条指令。 (2)将指令序列变换成为页地址流。 (3)...
操作系统之存储管理
06-10
存储管理是操作系统的重要组成部分，能否合理有效地利用内存在很大程度上影响着整个计算机的性能。本课程首先介绍存储管理的研究对象和目的，明确存储管理的基本功能和相关的基本概念；然后从实存和虚存两个角度，...
操作系统实验三：存储管理.doc
10-29
操作系统实验报告
操作系统c语言模拟页面调度实验（存储管理实验）
11-12
c语言，运行成功，比较基础，模拟存储管理（页面调度），页面淘汰算法采用先进先出（FIFO）
东华大学 操作系统实验 存储管理 含源代码和报告
02-13
1 实验目标 存储管理的主要功能之一是合理地分配空间 请求页式管理是一种常用的虚拟存储管理技术 本实验的目的是通过请求页式存储管理中页面置换算法模拟设计 了解虚拟存储技术的特点 掌握请求页式管理的页面置换算法 2 实验要求 1 通过随机数产生一个指令序列 共320条指令 指令的地址按下述原则生成： 50%的指令是顺序执行的； 25%的指令是均匀分布在前地址部分 25%的指令是均匀分布在后地址部分 具体的实施办法是： 在[0 319]的指令地址之间随机选取一点m； 顺序执行一条指令 即执行地址为m+1的指令； 在前地址[0 m+1]中随机选取一条指令并执行 该指令的地址为m’； 顺序执行一条指令 其地址为m’+1； 在后地址[m’+2 319]中随机选取一条指令并执行； 重复上述步骤 直到执行320次指令 2 将指令序列变换成页地址流 设： 页面大小为1K； 用户内存容量为4页到32页； 用户虚存容量为32K； 在用户虚存中 按每K存放10条指令排列虚存地址 即320条指令在虚存中的存放方式为： 第0条 9条指令为第0页（对应虚存地址为[0 9]）； 第10条 第19条指令为第一页（对应虚存地址为[10 19]）； 第310条 第319条指令为第31页（对应虚存地址为[310 319]）； 按以上方式 用户指令可组成32页 3 计算并输出下述各种算法在不同内存容量下的命中率 先进先出的算法（FIFO）； 最近最少使用算法（LRR）； 最佳淘汰算法（OPT）；先淘汰最不常用的页地址； 命中率 1 页面失效次数 页地址流长度 在本实验中 页地址流长度为320 页面失效次数为每次访问相应指令时 该指令所对应的页不在内存的次数 ">1 实验目标 存储管理的主要功能之一是合理地分配空间 请求页式管理是一种常用的虚拟存储管理技术 本实验的目的是通过请求页式存储管理中页面置换算法模拟设计 了解虚拟存储技术的特点 掌握请求页式管理的页 [更多]
操作系统二级页表
sometime here
04-15 3939
计算机采用二级页表的分页存储管理方式，按字节编址，页面大小为1024B，每个页表项占2B， 逻辑地址结构为：  若逻辑地址空间的大小为 64K 个页面，则表示整个逻辑地址空间的页目录表中包含的表项的个数至 少为_______ 在解决这个问题前，我们用类比的方式来举一个例子。 假设有一本书，这本书每一页固定大小，最多一页有 1000 个字（页面大小）； 每一页对应有一个目录中的条目，这个条目用 2 个字表示（页表项大小）； 那么我 一页纸 就可以写下 1000/2 = 500 个目录条目； 现在我整本书有
4.1页式存储
最新发布
人生得意须尽欢
02-04 4941
计算机组成原理之页式存储
操作系统实验五 存储管理—页面置换算法模拟
m0_51684972的博客
10-21 1万+
[实验目的] 通过模拟实现请求页式存储管理的几种基本页面置换算法，了解虚拟存储技术的特点，掌握虚拟存储请求页式存储管理中几种基本页面置换算法的基本思想和实现过程，并比较它们的效率。 [实验学时] 4学时 [实验类型] 设计性 [实验内容] 设计一个虚拟分页系统，并使用下述算法计算访问命中率（选择2种算法即可）。 1、最佳淘汰算法（OPT） 2、先进先出的算法（FIFO） 3、最近最久未使用算法（LRU） 命中率＝１－页面失效次数／页地址流长度 本实验的程序设计基本上按照实验内容进行。视能力可以在完整算法模拟
408计算机学科专业基础综合——操作系统
My Blog
11-14 1万+
第1章 操作系统概述 1.1 操作系统的基本概念 操作系统是指控制和管理整个计算机系统的硬件和软件资源，并合理地组织调度计算机的工作和资源的分配，以提供给用户和其他软件方便的接口和环境的程序集合。 并发是指两个多多个事件在同一时间间隔内发生，引入进程的目的是使程序能并发执行。 注意：同一时间间隔（并发）和同一时刻（并行）的区别。微观上这些程序还是分时交替执行。 共享是指系统中的资源可供内存中多个并...
【操作系统】分页存储管理方式
热门推荐
杨森源的博客
12-12 2万+
离散分配方式连续分配存储管理方式产生的问题： 要求连续的存储区 碎片问题 变连续分配为离散分配，允许将作业离散放到多个不相邻接的分区中。 分页式存储管理：离散分配的基本单位是页 分段式存储管理：离散分配的基本单位是段 段页式存储管理：离散分配的基本单位是段、页 页面和物理块空间划分 将一个用户进程的地址空间（逻辑空间）划分成若干个大小相等的区域，称为页或页面，各页从 0 开始编号。 内存空间也分成
操作系统：段页存储
屑狐狸
12-08 574
分页与分段的优缺点 段页存储 作业的地址空间首先被分成若干个逻辑分段，每段都有自己的段号，然后再将每段分成若干个大小相等的页。对于主存空间也分成大小相等的页，主存的分配以页为单位，这种是 段页存储管理方式。如下图所示： 段页存储的逻辑地址结构 段号 页号 页内偏移量 段号的位数决定了每个进程最多可以分成几个段 页号的位数决定了每个段最多可以有多少页 页内偏移量决定了页面大小和内存块大小 ...
操作系统：页存储
屑狐狸
12-08 4768
页存储 为了能知道每个进程的每个页面在内存中的存放位置，操作系统需要为每个进程创建一张页表。 如上图所示页表，记录了页面在内存中对应的内存块号，页表一般存放在内存中。在配置了页表后，进程执行时，通过查找该表，即可找到每页在内存中的内存块号。可见页表作用是实现从页号到内存块号的地址映射。这就是页存储。 页存储的特点： 一个进程对应一个页表 进程的每一页对应一个页表项 每个页表项由“页号”和“块号...
操作系统存储管理：页面调入与内存管理
"页面调入过程-操作系统-存储管理" 在操作系统中，存储管理是确保高效利用内存资源的关键部分，特别是在多道程序设计环境中。页面调入过程是虚拟存储技术的一部分，它涉及到如何将程序的页从外部存储（如硬盘）调入...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

龙在江湖aa

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值