LRU(最近最少使用淘汰算法)基本實現

LRU(Least Recently Used)

出發點：在頁式存儲管理中，如果一頁很長時間未被訪問，則它在最近一段時間內也不會被訪問，即時間局部性，那我們就把它調出（置換出）內存，相反的，如果一個數據剛剛被訪問過，那么該數據很大概率會在未來一段時間內訪問。

可以使用棧、隊列、鏈表來簡單實現，在InnoDB中，使用適應性hash，來實現熱點頁的查找（因為快速）。

1. 用棧（數組模擬）簡單實現訪頁邏輯：

#include <iostream>
using namespace std;

void conduct(int Size, int Num, int A[100]);//處理函數
void print(int a[], int num);//輸出函數

int main()
{
    int stack_size, num, i, acess[100];
    cout << "輸入棧空間：" ;
    cin >> stack_size;
    cout << "輸入進程數(Max=100):" ;
    cin >> num;

    cout << "輸入進程訪頁順序：" ;
    for(i=0; i<num; i++)
    {
        cin >> acess[i];
    }

    conduct(stack_size, num, acess);

    return 0;
}

void conduct(int Size, int Num, int A[100])
{
    int j, k, Stack[Size];
    for(j=0; j<Size; j++)
    {
        cout << "進入：" << A[j] <<endl;
        Stack[j]=A[j];//先處理前幾個元素
    }
    int locate;bool flag;
    for(j=Size; j<Num; j++)
    {
        flag=false;
        for(k=0; k<Size; k++)
        {
            if(Stack[k]==A[j])
            {
                flag=true;
                locate=k;
            }
        }
        if(flag==true)//有重復
        {
            cout << "重復進程：" << A[j] <<endl;
            cout << "取出再壓棧" <<endl;
            int tempp;
            for(k=locate; k<Size; k++)
            {
                Stack[k]=Stack[k+1];
            }
            Stack[Size-1]=A[j];
            cout << "壓棧完成" <<endl;
            cout << "當前順序：";

            print(Stack, Size);
        }
        else
        {
            cout << "非重復，壓棧：" << A[j] <<endl;
            for(k=0; k<Size-1; k++)
            {
                Stack[k]=Stack[k+1];
            }
            Stack[Size-1]=A[j];
            cout << "置換完成。" <<endl;
            cout << "當前順序：";
            print(Stack, Size);
        }
    }
}

void print(int a[], int num)
{
    int k;
    for(k=0; k<num; k++)
    {
        cout << a[k] << "  ";
    }
    cout << endl;
}
　　Code：：Blocks 17.12 運行通過！

結果：

2. 使用lis容器實現LRU邏輯

#include <iostream>
#include <list>
#include <vector>
using namespace std;

class LRU
{
public:
    LRU();
    ~LRU();
    void insret(int x);
    void printQ();
private:
    list<int> lst;
    int count;//當前頁數
    int max_size = 5;//最大容納頁數
};

LRU::LRU()
{
    this->count = 0;
}

LRU::~LRU()
{
}

//插入算法，先查找，找到先刪除再插入；未找到，直接插入
void LRU::insret(int x)
{
    cout << "訪頁:" << x << " ";
    auto res = find(lst.begin(), lst.end(), x);
    if (res != lst.end())
    {
        cout << "(exist)" << " ";
        lst.erase(res);
        lst.push_front(x);
    }
    else
    {
        lst.push_front(x);
        this->count++;
    }
    if (this->count > this->max_size)
    {
        lst.pop_back();
        this->count--;
    }

    printQ();
}

//打印list
void LRU::printQ()
{
    list<int>::iterator it = this->lst.begin();
    cout << "當前隊列/熱點頁：";
    for (; it != lst.end(); it++)
    {
        cout << *it << " ";
    }
    cout << "\ndone. size -- " << this->count << "  " << " max_size -- " << this->max_size << endl << endl;
}

int main()
{
    LRU lru;
    vector<int> test = {1, 3, 2, 4, 2, 3, 1, 5, 6, 7, 1, 7, 3, 2, 1, 3};
    for (int i : test)
        lru.insret(i);
    return 0;
}

結果：