[C++] c++ 虚拟存储管理器的页面调度(FIFO LRU LFU OPT) →→→→→进入此内容的聊天室

来自 , 2019-10-14, 写在 C++, 查看 160 次.
URL http://www.code666.cn/view/b432f34c
  1. #include<stdio.h>
  2. #include<string.h>
  3. #include<iostream.h>
  4.  
  5. /************************************************************
  6. 页面调度算法主要有:FIFO,最近最少使用调度算法(LRU),最近最不常用调度算法(LFU),最佳算法(OPT)
  7. 此程序包括 :FIFO ,最近最少使用调度算法( LRU ),最近最不常用调度算法( LFU ) 第二次机会算法
  8. ************************************************************/
  9.  
  10. const int MAXSIZE=1000;//定义最大页面数
  11. const int MAXQUEUE=3;//定义页框数
  12.  
  13. typedef struct node
  14. {
  15.         int loaded;
  16.         int hit;
  17. } page;
  18.  
  19. page pages[MAXQUEUE]; //定义页框表
  20. int queue[MAXSIZE];
  21. int quantity;
  22.  
  23. //初始化结构函数
  24. void initial()
  25. {
  26.         int i;
  27.  
  28.         for ( i=0; i<MAXQUEUE; i++ )
  29.         {
  30.                 pages[i].loaded=-1;
  31.                 pages[i].hit=0;
  32.         }
  33.         for ( i=0; i<MAXSIZE; i++ )
  34.         {
  35.                 queue[i]=-1;
  36.         }
  37.  
  38.         quantity=0;
  39. }
  40.  
  41. //初始化页框函数
  42. void init()
  43. {
  44.         int i;
  45.  
  46.         for ( i=0; i<MAXQUEUE; i++ )
  47.         {
  48.                 pages[i].loaded=-1;
  49.                 pages[i].hit=0;
  50.         }
  51. }
  52.  
  53. //读入页面流
  54. void readData()
  55. {
  56.         FILE *fp;
  57.         char fname[20];
  58.  
  59.         int i;
  60.  
  61.         cout<<"请输入页面流文件名:";
  62.         cin>>fname;
  63.  
  64.         if ( ( fp=fopen ( fname,"r" ) ) ==NULL )
  65.         {
  66.                 cout<<"错误,文件打不开,请检查文件名";
  67.         }
  68.         else
  69.         {
  70.                 while ( !feof ( fp ) )
  71.                 {
  72.                         fscanf ( fp,"%d ",&queue[quantity] );
  73.                         quantity++;
  74.                 }
  75.         }
  76.  
  77.         cout<<"读入的页面流:";
  78.         for ( i=0; i<quantity; i++ )
  79.         {
  80.                 cout<<queue[i]<<" ";
  81.         }
  82. }
  83.  
  84. //FIFO调度算法
  85.  
  86. void FIFO()
  87. {
  88.         int i,j,p,flag;
  89.         int absence=0;
  90.  
  91.         p=0;
  92.  
  93.         cout<<endl<<"----------------------------------------------------"<<endl;
  94.         cout<<"FIFO调度算法页面调出流:";
  95.         for ( i=0; i<quantity; i++ )
  96.         {
  97.                 flag=0;
  98.                 for ( j=0; j<MAXQUEUE; j++ )
  99.                 {
  100.                         if ( pages[j].loaded==queue[i] )
  101.                         {
  102.                                 flag=1;
  103.                         }
  104.                 }
  105.                 if ( flag==0 )
  106.                 {
  107.                         if ( absence>=MAXQUEUE )
  108.                         {
  109.                                 cout<<pages[p].loaded<<" ";
  110.                         }
  111.                         pages[p].loaded=queue[i];
  112.                         p= ( p+1 ) %MAXQUEUE;
  113.                         absence++;
  114.                 }
  115.         }
  116.         absence-=MAXQUEUE;
  117.         cout<<endl<<"总缺页数:"<<absence<<endl;
  118.  
  119. }
  120.  
  121.  
  122. //最近最少使用调度算法(LRU)
  123. void LRU()
  124. {
  125.         int absence=0;
  126.         int i,j;
  127.         int flag;
  128.  
  129.  
  130.         for ( i=0; i<MAXQUEUE; i++ )
  131.         {
  132.                 pages[i].loaded=queue[i];
  133.         }
  134.  
  135.         cout<<endl<<"----------------------------------------------------"<<endl;
  136.         cout<<"最近最少使用调度算法(LRU)页面流:";
  137.  
  138.         for ( i=MAXQUEUE; i<quantity; i++ )
  139.         {
  140.                 flag=-1;
  141.                 for ( j=0; j<MAXQUEUE; j++ )
  142.                 {
  143.                         if ( queue[i]==pages[j].loaded )
  144.                         {
  145.                                 flag=j;
  146.                         }
  147.                 }
  148. //CAUTION pages[0]是队列头
  149.                 if ( flag==-1 )
  150.                 {
  151. //缺页处理
  152.                         cout<<pages[0].loaded<<" ";
  153.                         for ( j=0; j<MAXQUEUE-1; j++ )
  154.                         {
  155.                                 pages[j]=pages[j+1];
  156.                         }
  157.                         pages[MAXQUEUE-1].loaded=queue[i];
  158.                         absence++;
  159.                 }
  160.                 else
  161.                 {
  162. //页面已载入
  163.                         pages[quantity]=pages[flag];
  164.                         for ( j=flag; j<MAXQUEUE-1; j++ )
  165.                         {
  166.                                 pages[j]=pages[j+1];
  167.                         }
  168.                         pages[MAXQUEUE-1]=pages[quantity];
  169.                 }
  170.  
  171.  
  172.         }
  173.  
  174.         cout<<endl<<"总缺页数:"<<absence<<endl;
  175. }
  176.  
  177.  
  178. //最近最不常用调度算法(LFU)
  179. void LFU()
  180. {
  181.         int i,j,p;
  182.         int absence=0;
  183.         int flag;
  184.  
  185.         for ( i=0; i<MAXQUEUE; i++ )
  186.         {
  187.                 pages[i].loaded=queue[i];
  188.         }
  189.  
  190.         cout<<endl<<"----------------------------------------------------"<<endl;
  191.         cout<<"最近最不常用调度算法(LFU)页面流:";
  192.  
  193.         for ( i=MAXQUEUE; i<quantity; i++ )
  194.         {
  195.                 flag=-1;
  196.                 for ( j=0; j<MAXQUEUE; j++ )
  197.                 {
  198.                         if ( pages[j].loaded==queue[i] )
  199.                         {
  200.                                 flag=1;
  201.                                 pages[j].hit++;
  202.                         }
  203.                 }
  204.                 if ( flag==-1 )
  205.                 {
  206. //缺页中断
  207.                         p=0;
  208.                         for ( j=0; j<MAXQUEUE; j++ )
  209.                         {
  210.                                 if ( pages[j].hit<pages[p].hit )
  211.                                 {
  212.                                         p=j;
  213.                                 }
  214.                         }
  215.                         cout<<pages[p].loaded<<" ";
  216.                         pages[p].loaded=queue[i];
  217.                         for ( j=0; j<MAXQUEUE; j++ )
  218.                         {
  219.                                 pages[j].hit=0;
  220.                         }
  221.                         absence++;
  222.                 }
  223.         }
  224.         cout<<endl<<"总缺页数:"<<absence<<endl;
  225. }
  226.  
  227. //第二次机会算法
  228. void second()
  229. {
  230.         int i,j,t;
  231.         int absence=0;
  232.         int flag,temp;
  233.  
  234.         for ( i=0; i<MAXQUEUE; i++ )
  235.         {
  236.                 pages[i].loaded=queue[i];
  237.         }
  238.  
  239.         cout<<endl<<"----------------------------------------------------"<<endl;
  240.         cout<<"第二次机会算法页面流:";
  241.  
  242.         for ( i=MAXQUEUE; i<quantity; i++ )
  243.         {
  244.                 flag=-1;
  245.                 for ( j=0; j<MAXQUEUE; j++ )
  246.                 {
  247.                         if ( pages[j].loaded==queue[i] )
  248.                         {
  249.                                 flag=1;
  250.                                 pages[j].hit=1;
  251.                         }
  252.                 }
  253.                 if ( flag==-1 )
  254.                 {
  255. //缺页处理
  256.                         t=0;
  257.                         while ( t==0 )
  258.                         {
  259.                                 if ( pages[0].hit==0 )
  260.                                 {
  261.                                         cout<<pages[0].loaded<<" ";
  262.                                         for ( j=0; j<MAXQUEUE-1; j++ )
  263.                                         {
  264.                                                 pages[j]=pages[j+1];
  265.                                         }
  266.                                         pages[MAXQUEUE-1].loaded=queue[i];
  267.                                         pages[MAXQUEUE-1].hit=0;
  268.  
  269.  
  270.                                         t=1;
  271.                                 }
  272.                                 else
  273.                                 {
  274.                                         temp=pages[0].loaded;
  275.                                         for ( j=0; j<MAXQUEUE-1; j++ )
  276.                                         {
  277.                                                 pages[j]=pages[j+1];
  278.                                         }
  279.                                         pages[MAXQUEUE-1].loaded=temp;
  280.                                         pages[MAXQUEUE-1].hit=0;
  281.                                 }
  282.                         }
  283.                         absence++;
  284.                 }
  285.         }
  286.         cout<<endl<<"总缺页数:"<<absence<<endl;
  287. }
  288.  
  289. //显示版权信息函数
  290. void version()
  291. {
  292.         cout<<endl<<endl;
  293.  
  294.         cout<<" ┏━━━━━━━━━━━━━━━━━━━━━━━┓"<<endl;
  295.         cout<<" ┃     虚拟存储管理器的页面调度       ┃"<<endl;
  296.         cout<<" ┠───────────────────────┨"<<endl;
  297.         cout<<" ┃   (c)All Right Reserved Neo       ┃"<<endl;
  298.         cout<<" ┃      sony006@163.com          ┃"<<endl;
  299.         cout<<" ┃     version 2004 build 1122      ┃"<<endl;
  300.         cout<<" ┗━━━━━━━━━━━━━━━━━━━━━━━┛"<<endl;
  301.  
  302.         cout<<endl<<endl;
  303. }
  304.  
  305. void main()
  306. {
  307.         version();
  308.         initial();
  309.  
  310.         readData();
  311.  
  312.         FIFO();
  313.         init();
  314.  
  315.         LRU();
  316.         init();
  317.  
  318.         LFU();
  319.         init();
  320.  
  321.         second();
  322.  
  323. }
  324.  

回复 "c++ 虚拟存储管理器的页面调度(FIFO LRU LFU OPT)"

这儿你可以回复上面这条便签

captcha