计算机原理实践_LFU缓存置换算法_笔记

 

#! -*- encoding=utf-8 -*-

from DoubleLinkedList import DoubleLinkedList, Node


class LFUNode(Node):  # 继承Node
    def __init__(self, key, value):
        self.freq = 0  # 用于记录节点的使用频率
        super(LFUNode, self).__init__(key, value)


class LFUCache(object):

    def __init__(self, capacity):
        self.capacity = capacity
        self.map = {}
        # key用来存储频率:value用来存储有相同Node,使用DoubleLinkedList来存储
        self.freq_map = {}
        self.size = 0  # 这里定义size是因为没有一个装有所有node的List,需要size来判断容量是否已满 , 需要在每一次put是做处理
        # self.list = DoubleLinkedList(self.capacity) # 如果定义出来唯一的作用就是 list.size 判断缓存是否已满 ,这里选择删去

    # 更新节点频率的操作 , 此为本算法的核心
    def __update_freq(self, node):
        freq = node.freq

        # 删除
        node = self.freq_map[freq].remove(node)
        if self.freq_map[freq].size == 0:
            del self.freq_map[freq]

        # 更新
        freq += 1
        node.freq = freq
        if freq not in self.freq_map:  # 如果还没有这个频率的双向链表就创建一个
            self.freq_map[freq] = DoubleLinkedList()
        self.freq_map[freq].append(node)

    # 每次使用了某个节点后,节点的使用频率都需要+1,并且需要更换到所更新频率对应的频率链表中
    def get(self, key):
        if key not in self.map:
            return -1
        node = self.map[key]
        self.__update_freq(node)
        return node.value

    def put(self, key, value):
        if self.capacity == 0:
            return
        # 缓存命中
        if key in self.map:  # key已经在缓存中时
            node = self.map.get(key)
            node.value = value
            self.__update_freq(node)  # 修改了值,cpu需要使用缓存时会对此缓存的时效性进行判断,则修改值也算作为一次使用

        # 缓存未命中
        else:  # key未在缓存中
            if self.size >= self.capacity:  # 缓存容量已满,则需要弹出一个最近最少使用的节点
                min_freq = min(self.freq_map)  # 找出最小的key
                node = self.freq_map[min_freq].pop()  # 删除key=min_freq:value=DoubleLinkedList中value里的第一个节点(最先被加入的在头,后加入的在尾部)
                del self.map[node.key]  # 在本地中删除这个node
                self.size -= 1
            node = LFUNode(key, value)  # 缓存容量未满
            node.freq = 1  # 把频率改为1,因为如果被加入缓存中则至少被使用过一次
            self.map[key] = node  # 在确定了freq后就可以被加入map
            # 新的节点需要被加入到freq_map中,频率key=1,value=DoubleLinkedList,若元祖中没有关于key=1,则创建
            if node.freq not in self.freq_map:  # 如果频率中没有关于1的链表
                self.freq_map[node.freq] = DoubleLinkedList()
            self.freq_map[node.freq].append(node)  # 如果已经存在则直接把node加入到此DoubleLinkedList的末尾
            self.size += 1  # 缓存容量+1

    def print(self):
        print("****************************")
        for k, v in self.freq_map.items():  # 遍历freq_map
            print('Freq = %d' % k)  # K既是频率,打印
            # print(self.freq_map[k])  # 这样print只能打印出地址
            self.freq_map[k].print()
        print("*****************************")
        print()


if __name__ == '__main__':
    cache = LFUCache(2)
    cache.put(1, 1)
    cache.print()
    cache.put(2, 2)
    cache.print()
    print(cache.get(1))
    cache.print()

    cache.put(3, 3)
    cache.print()
    print(cache.get(2))
    cache.print()
    print(cache.get(3))
    cache.print()
    cache.put(4, 4)
    cache.print()
    print(cache.get(1))
    cache.print()
    print(cache.get(3))
    cache.print()
    print(cache.get(4))
    cache.print()