LRU(Least Recently Used)最近未使用置换算法--c实现

在OS中，一些程序的大小超过内存的大小（比如好几十G的游戏要在16G的内存上跑），便产生了虚拟内存的概念

我们通过给每个进程适当的物理块（内存），只让经常被调用的页面常驻在物理块上，不常用的页面就放在外存，等到要用的时候再从外存调入，从而实现虚拟内存

但是因为给的每个进程的物理块大小不可能是无限的，如果该进程的物理块用完了这时候又要调入新的页面进来的话，就需要用到置换算法，其中的一个算法就叫

————>LRU(Least Recently Used)最近未使用置换算法

一、代码思想

这个算法的思想就是把已经很久没用过的页面，调出物理块然后加入新的准备调入进来的页面，对于每个物理块有两个元素

【页面号丨此页面至上次被访问以来的时间t】

我用了二维数组buffer[][2]来实现，buffer[i][0]表示的是在第i个物理块里的页面号，buffer[i][1]示的是在第i个物理块里的页面号已经有多久没用被调用过了

二，全部代码

#include <iostream>
using namespace std;

int max(int arr[][2], int n)
{
    int ans = 0;
    for (int i = 0; i < n; i++)
    {
        if (arr[i][1] > arr[ans][1])
        {
            ans = i;
        }
    }
    return ans;
}

void check(int buffer[][2],int n)
{
    for (int i = 0; i < 3; i++)
    {
        cout << buffer[i][0] << ' ';
    }
    cout << endl << "--------" << endl;
}

int exist_page_in_buffer(int buffer[][2], int page, int buffer_size)
{
    for (int i = 0; i < buffer_size; i++)
    {
        if (buffer[i][0] == page)
        {
            return i;
        }
    }
    return -1;
}

void one_turn(int buffer[][2], int i)
{
    for (int k = 0; k < i; k++)
    {
        buffer[k][1]++;
    }
}

void least_recently_used(int buffer[][2], int page[], int buffer_size, int page_size)
{
    for (int i = 0; i < buffer_size; i++)//初始化buffer
    {
        buffer[i][0] = -1;
        buffer[i][1] = 0;
    }
    for(int i = 0, j = 0; j < page_size;)//当页面全部调用完成时（j >= page_size），算法结束
    {
        //i是当前物理块中已经有多少页面了，j是已经有多少页面进行过置换了
        if (exist_page_in_buffer(buffer, page[j], i) != -1 )//当前的页面page[j]已经存在于物理块buffer之中
        {
            one_turn(buffer, i); //过了一个调用周期
            buffer[exist_page_in_buffer(buffer, page[j], i)][1] = 0;//这个page又被调用一次，所以t为0
            check(buffer, i);
            j++;
        }
        else//当前的页面page[j]不存在于物理块buffer之中
        {
            if (i < buffer_size)//如果物理块还没有满的话，直接加一个页面进来，就不进行置换了
            {
                buffer[i][0] = page[j];
                one_turn(buffer, i);
                check(buffer, i);
                i++; //当前物理块中的页面个数加一，因为buffer没满，加到满为止
                j++;
            }
            else//物理块已经满了，进行LRU的查找置换
            {
                int temp = max(buffer, buffer_size);//找一个最久没有被调用的页面进行置换
                buffer[temp][0] = page[j];
                one_turn(buffer, buffer_size);
                buffer[temp][1] = 0;//这个page被置换进来调用一次，所以t为0
                check(buffer, i);
                j++;
            }
        }
    }
}

int main()
{
    int page[] = { 7,0,1,2,0,3,0,4,2,3,0,3,2,1,2,0,1,7,0,1 };
    int buffer[3][2];
    int n = sizeof(page)/sizeof(int);
    least_recently_used(buffer, page, 3, 20);
}

三、代码解释

首先主函数调用LRU算法，函数least_recently_used进入函数栈，page的数据来源我会在下面给出例题

int main()
{
    int page[] = { 7,0,1,2,0,3,0,4,2,3,0,3,2,1,2,0,1,7,0,1 };
    int buffer[3][2];
    int n = sizeof(page)/sizeof(int);
    least_recently_used(buffer, page, 3, 20);
}

然后调用函数least_recently_used，首先进行对于buffer的初始化，然后进行循环调用页面，当页面全部调用完成时（j >= page_size），算法结束

void least_recently_used(int buffer[][2], int page[], int buffer_size, int page_size)
{
    for (int i = 0; i < buffer_size; i++)//初始化buffer
    {
        buffer[i][0] = -1;
        buffer[i][1] = 0;
    }
    for(int i = 0, j = 0; j < page_size;)//当页面全部调用完成时（j >= page_size），算法结束
    {
        //i是当前物理块中已经有多少页面了，j是已经有多少页面进行过置换了
        if (exist_page_in_buffer(buffer, page[j], i) != -1 )//当前的页面page[j]已经存在于物理块buffer之中
        {
            one_turn(buffer, i); //过了一个调用周期
            buffer[exist_page_in_buffer(buffer, page[j], i)][1] = 0;//这个page又被调用一次，所以t为0
            check(buffer, i);
            j++;
        }
        else//当前的页面page[j]不存在于物理块buffer之中
        {
            if (i < buffer_size)//如果物理块还没有满的话，直接加一个页面进来，就不进行置换了
            {
                buffer[i][0] = page[j];
                one_turn(buffer, i);
                check(buffer, i);
                i++; //当前物理块中的页面个数加一，因为buffer没满，加到满为止
                j++;
            }
            else//物理块已经满了，进行LRU的查找置换
            {
                int temp = max(buffer, buffer_size);//找一个最久没有被调用的页面进行置换
                buffer[temp][0] = page[j];
                one_turn(buffer, buffer_size);
                buffer[temp][1] = 0;//这个page被置换进来调用一次，所以t为0
                check(buffer, i);
                j++;
            }
        }
    }
}

再解释一下每个函数的作用

max，这个就是从buffer里找到最久没用调用过的页面，返回他的所在物理块的位置

int max(int arr[][2], int n)
{
    int ans = 0;
    for (int i = 0; i < n; i++)
    {
        if (arr[i][1] > arr[ans][1])
        {
            ans = i;
        }
    }
    return ans;
}

check，检查函数的运行情况

void check(int buffer[][2],int n)
{
    for (int i = 0; i < 3; i++)
    {
        cout << buffer[i][0] << ' ';
    }
    cout << endl << "--------" << endl;
}

exist_page_in_buffer，每次调入页面时，都先检查一遍这个页面有没有已经被调入到当前的物理块中，如果在，返回此页面在物理块中的位置，如果不在，返回-1

int exist_page_in_buffer(int buffer[][2], int page, int buffer_size)
{
    for (int i = 0; i < buffer_size; i++)
    {
        if (buffer[i][0] == page)
        {
            return i;
        }
    }
    return -1;
}

one_turn，过了一个调用周期（主要就是为了让其他的page距离上次被调用的时间t++）

void one_turn(int buffer[][2], int i)
{
    for (int k = 0; k < i; k++)
    {
        buffer[k][1]++;
    }
}

四、书上例题和运行结果

 运算结果如下

7 -1 -1
--------
7 0 -1
--------
7 0 1
--------
2 0 1
--------
2 0 1
--------
2 0 3
--------
2 0 3
--------
4 0 3
--------
4 0 2
--------
4 3 2
--------
0 3 2
--------
0 3 2
--------
0 3 2
--------
1 3 2
--------
1 3 2
--------
1 0 2
--------
1 0 2
--------
1 0 7
--------
1 0 7
--------
1 0 7
--------