计算机组成-存储系统Cache中主存块替换算法（C++模拟LRU替换算法）_lru替换策略计算过程

1.Cache中主存块替换算法

如果主存与Cache之间采用全相联映射或者组相联映射方式，从主存向Cache传送一个新块。当Cache空间被占满后，需要使用替换算法置换Cache行。

注意：如果采用的直接映射方式，一个主存块只能放到固定的Cache行上（类似哈希方式），所以这种情况当Cache空间满了，不需要考虑替换算法。

常用的替换算法如下：

1. 随机算法（RAND）:随机确定替换的Cache块（未依据程序访问局部性原则，命中率一般比较低）
2. 先进先出算法（FIFO）:选择最早调入的行进行替换，比较容易实现（未依据程序访问局部性原则，命中率一般比较低）。
3. 近期最少使用算法（LRU）：依据程序局部性原则，选择近期内长久未访问过的Cache块进行替换（命中率比较高，属于堆栈类算法）
4. 最不经常使用算法（LFU）:将一段时间内被访问次数最少的存储行换出。每行需要设置计数器。每个Cache行开始计数为0，被访问一次计数器+1，需要替换时，替换计数器最小的。

需要注意：
LFU方式会导致在Cache块中的数据无法及时换出。eg：切换运行程序后，Cache块内的数据需要加载新的程序，但是原来的数据计数器很大，使用这种算法不容易换出，所以LFU算法不是很优秀的替换算法。

2. LRU缓存淘汰算法

算法思路

Cache行设置一个计数器。用来记录主存块的使用情况，并根据计算数值淘汰某个块，计数值的位数与Cache组的数目有关（2路的话只需要1位LRU位，4路需要2位LRU位）。

计数器变化规则：

1. 如果Cahce命中A块Cache，A块的计数器清0。比A块的计数器数量小的块计数器+1。比A块的计数器大的块计数器不变
2. 如果Cache未命中且Cache中存在空余行，将这块加载到Cache中，计数器设置位0，其余块的计数器都+1
3. 如果未命中且Cache已满，替换计数器数目最大的块，并且将新替换的Cache块计数器设置为0.

eg:
Cache采用4路组相联映射设有5块主存块{1，2，3，4，5}，主存访问序列为{1，2，3，4，1，2，5，1}采用LRUCache缓存淘汰算法，替换过程如下：

需要注意：
当集中访问的存储区超过Cache组的大小时，LRU的命中率可能会变的非常低。这种现象称为抖动。
eg:
Cache采用4路组相联映射设有5块主存块{1，2，3，4，5}，主存访问序列为{1，2，3，4，5，1，2，3，4，5}采用LRUCache缓存淘汰算法命中率经过画图计算可知为0

C++模拟LRU算法

题目链接

这个设计的难点是时间复杂度与空间复杂度都是O(1)

思路：

1. 使用unordered_map解决查找O(1)。
2. Cache使用链表(带头双向循环)的形式组织，命中的话，把这个节点移动到链表头部。
3. Cache替换，替换的是链表尾节点。更新LRU计数器只要移动链表节点即可。
4. unordered_map中保存的pair是key和链表指针，为了能直接通过key值找打链表节点，保证了O(1)找到链表节点。
5. 链表节点的值为pair值，pair保存Cache的数值和计数器值。

class LRUCache {
public:
    LRUCache(int capacity) {
        this->capacity=capacity;
    }
    
    int get(int key) {
        auto pos=_lruHash.find(key);
        if(pos!=_lruHash.end()){
            //Cache命中，调整计数器 更新key对应的节点的位置
            list<pair<int,int>>::iterator ptr=pos->second;
            //转移节点库函数std::list::splice
            //void splice (iterator position, list& x, iterator i);
            //Transfers elements from x into the container, inserting them at position.
            //将x的第i个节点转移带position位置上
            _lruCacheList.splice(_lruCacheList.begin(),_lruCacheList,ptr);
            return pos->second->second;
        }
        return -1;
    }
    
    void put(int key, int value) {
        auto pos=_lruHash.find(key);
        if(pos!=_lruHash.end()){
            //更新Cache，更新对应节点的位置
            list<pair<int,int>>::iterator ptr=pos->second;
            ptr->second=value;//更新数据
            _lruCacheList.splice(_lruCacheList.begin(),_lruCacheList,ptr);//转移节点
        }
        else{
            //新增Cache
            if(capacity==_lruHash.size()){
                //满了，替换删除尾上的数据
                pair<int,int>&back=_lruCacheList.back();
                _lruHash.erase(back.first);
                _lruCacheList.pop_back();
            }
            _lruCacheList.push_front(make_pair(key,value));
            _lruHash[key]=_lruCacheList.begin();
        }
    }
private:
     unordered_map<int,list<pair<int,int>>::iterator>_lruHash;//方便查找
     list<pair<int,int>>_lruCacheList;//保存数据
     size_t capacity;
};

/**
 * Your LRUCache object will be instantiated and called as such:
 * LRUCache* obj = new LRUCache(capacity);
 * int param_1 = obj->get(key);
 * obj->put(key,value);
 */
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53