计算机组成-存储系统Cache中主存块替换算法(C++模拟LRU替换算法)

文章目录

  • 1.Cache中主存块替换算法
  • 2. LRU缓存淘汰算法
    • 算法思路
    • C++模拟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中主存块替换算法(C++模拟LRU替换算法)_第1张图片

需要注意:
当集中访问的存储区超过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算法

题目链接

计算机组成-存储系统Cache中主存块替换算法(C++模拟LRU替换算法)_第2张图片

这个设计的难点是时间复杂度与空间复杂度都是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);
 */

计算机组成-存储系统Cache中主存块替换算法(C++模拟LRU替换算法)_第3张图片

你可能感兴趣的:(计算机组成,c++,算法)