请求式分页存储管理算法（操作系统）C/C++

一、先进先出算法（First in First out）
算法描述：

该算法的实质是选择作业中在主存驻留时间最长的一页淘汰，这种算法容易实现，例如分配一个作业的存储块数为m，则只需建立一张m个元素的队列表Q(0)、Q(1)、…、Q(m-1)和一个替换指针。这个队列是按页调入主存的一页。如图4-1所示，某时刻调入主存四个块，（即m=4），它们按页进入主存的先后顺序为4、5、1、2，当需要置换时，总是淘汰替换指针所指向的那一页。

新调进的页面装入主存后，修改相应的队列元素，然后将替换指针往前移动，使其指向当前最老的一页。

算法实现：

/*
 *请求分页存储管理算法
 *先进先出算法
 */

 #include<stdio.h>
 #include<malloc.h>

 /*
  *定义页面结构
  */
typedef struct page
{
    int head , tail ; //页头与页尾地址
    int x_size ; //页面大小
    struct page *next ; // 指向下一页的指针
} Page ;

/*
 *定义页面管理控制块
 */
typedef struct mcb
{
    Page *head , *tail ; //指向页表的头指针与尾指针
    Page *change ; //替换指针
    int mem_size ; //总内存空间
    int mem_left ; //剩余内存
} MCB ;

/*
 *发起页面大小为x的页面内存空间请求
 *返回false则申请成功
 */
bool resquestPage(MCB *m , int x) ;

/*
 *进行页面淘汰
 */
 void eliminatePage(MCB *m) ;

 /*
  *进行当前内存空间的显示
  */
void displayPage(MCB *m) ;

 /*
  *测试主函数
  */
int main()
{
    int k , x ;
    //定义页面控制块
    MCB *m ;
    m = (MCB*)malloc(sizeof(MCB)) ;

    if(m == NULL)
    {
        exit(0) ;
    }

    //进行初始化
    m->head = m->tail = m->change = NULL ;
    m->mem_size = 128 ;
    m->mem_left = 128 ;

    while(true)
    {
        printf("Wheather go on to deliever memory  (1/0) : ") ;
        scanf("%d" , &k) ;
        if(k)
        {
            printf("Please input the size of page : ") ;
            scanf("%d" , &x) ;
            if(resquestPage(m , x))
            {
                printf("Deliever success ! \n") ;
            }
            else
            {
                exit(0) ;
            }
            displayPage(m) ;
        }
        else
        {
            break ;
        }
    }
    return 0 ;
}

bool resquestPage(MCB *m , int x)
{
    Page *p ;
    p = (Page*)malloc(sizeof(Page)) ;
    if(p == NULL)
    {
        return false ;
    }
    else{
       p->x_size = x ;
       p->next = NULL ;
       while(m->mem_left <= p->x_size)
       {
           eliminatePage(m) ;
       }
       m->mem_left -= p->x_size ;
        if(m->head == NULL)
       {
           m->head = m->tail = p ;
           p->head = 0 ;
           p->tail = p->head + p->x_size - 1 ;
           m->change = m->head ;
       }
       else
       {
       //进行该页的内存分配
       p->head = (m->tail->tail + 1) % m->mem_size ;
       p->tail = (p->head + p->x_size - 1) % m->mem_size ;
       m->tail->next = p ;
       m->tail = p ;
       }
       return true ;
    }
}

void eliminatePage(MCB *m)
{
     if(m->head)
     {
         Page *p ;
         p = m->head ;
         m->head = m->head->next ;
         m->change = m->head ;
         m->mem_left += p->x_size ;
         delete p ;
     }
}

void displayPage(MCB *m)
{
   Page *p ;
   p = m->head ;
   while(p)
   {
       printf("%4d     %4d     %4d \n" , p->head , p->tail , p->x_size) ;
       p = p->next ;
   }
}

二、最近最少使用页面淘汰算法（LRU）
算法描述：

这是一种经常使用的方法，有多种不同的实施方案。这里采用不断调整页表链的方法，即总是淘汰页表链链首的页面，而把新访问的页面插入链尾。如果当前调用页面已在页表内，则把它再次调整到链尾。这样就能保证最近使用的页面总处于靠近链尾部分，而不常使用的页面被移到链首，逐个被淘汰。

算法实现：

/*
 *最近最少未使用算法
 *页面调度
 */
#include<stdio.h>
#include<malloc.h>

//初始化内存空间
int mem_size = 4 ;

//初始化页面大小
int page_size = 1 ;

/*
 *定义页面数据结构
 */
 typedef struct page
 {
     int number ; //页面编号
     int x_size ; //页面大小
     struct page *next ;
 } Page ;

 /*
  *定义页面管理控制块
  */
typedef struct
{
    Page *head , *tail ; //页面队列的头尾指针
    int mem_size ; //内存大小
    int mem_left ; //剩余内存
} MCB ;

/*
 *页面调入
 */
void resquestPage(MCB *m , int num) ;

/*
 *淘汰算法
 */
void eliminatePage(MCB *m) ;

/*
 *进行页面显示
 */
void displayPage(MCB *m) ;
/*
 *测试主函数
 */
int main()
{
  int k , x ;
    //定义页面控制块
    MCB *m ;
    m = (MCB*)malloc(sizeof(MCB)) ;

    if(m == NULL)
    {
        exit(0) ;
    }

    //进行初始化
    m->head = m->tail = NULL ;
    m->mem_size = mem_size ;
    m->mem_left = mem_size ;

    while(true)
    {
        printf("Wheather go on to deliever memory  (1/0) : ") ;
        scanf("%d" , &k) ;
        if(k)
        {
            printf("Please input the number of page : ") ;
            scanf("%d" , &x) ;
            resquestPage(m , x) ;
            printf("Deliever success ! \n") ;
            displayPage(m) ;
        }
        else
        {
            break ;
        }
    }
    return 0 ;
}

void resquestPage(MCB *m , int num)
{
    Page *p ;
    p = (Page*)malloc(sizeof(Page)) ;
    if(p == NULL)
    {
        exit(0) ;
    }
    p->number = num ;
    p->x_size = page_size ;
    p->next = NULL ;

    //判断页表是否为空
    if(m->head == NULL)
    {
        m->head = m->tail = p ;
        m->mem_left -= 1 ;
    }

    //判断该页是否已在内存
    Page *pre = NULL , *current = NULL ;
    bool in = false ;

    //在页表中进行查找
    current = m->head ;
    while(current)
    {
        if(current->number == p->number)
        {
            in = true ;
            break ;
        }
        pre = current ;
        current = current->next ;
    }

    if(in)
    {
        if(current != m->tail)
        {
                m->tail->next = current ;
                m->tail = current ;
            if(current == m->head)
            {
                m->head = current->next ;
            }
            else
            {
                pre->next = current->next ;
            }
             m->tail->next = NULL ;
        }
    }
    else
    {
        //判断内存空间是否足够，不够则进行页面淘汰
        if(m->mem_left <= 0)
        {
            eliminatePage(m) ;
        }
        m->tail->next = p ;
        m->tail = p ;
        m->mem_left -= 1 ;
    }

}

void eliminatePage(MCB *m)
{
      if(m->head)
      {
          Page *p = m->head ;
          m->head = m->head->next ;
          m->mem_size += 1 ;
          delete p ;
      }
}

void displayPage(MCB *m)
{
    Page *p = NULL ;
    p = m->head ;
    while(p)
    {
        printf("%4d      %4d \n" , p->number , p->x_size) ;
        p = p->next ;
    }
}