对象的通用缓存

Question

有谁知道对象模板化缓存的任何实现吗？

• 您使用键来查找对象（与 std::map<> 中相同）
• 您指定可以同时在缓存中的对象的最大数量
• 有工具可以创建在缓存中找不到的对象
• 有是了解对象何时从缓存中丢弃的工具

例如：

typedef cache<int, MyObj*> MyCache;
MyCache oCache;
oCache.SetSize(1);
oCache.Insert(make_pair(1, new MyObj());
oCache.Touch(1);
MyObj* oldObj = oCache.Delete(1);

...

它可以像 LRU 或 MRU 缓存一样简单。

欢迎任何建议！

尼克

Answer 1

在应用程序中，我很难想象它会加速/提高存储显然可以重新创建的对象的性能（时髦：因为当缓存达到顶峰时，它们可以自动丢弃）。
sw 缓存需要通过关联性代码获取内存，这肯定比内存分配和构造函数运行（主要是内存初始化）慢。

除了手动用户配置以避免分页机制（顺便说一句，正是为了提高性能）之外，大多数操作系统都会在磁盘上为您“缓存”内存......这是“分页”，一种“高成本缓存”的形式，因为没有任何东西会被丢弃，它是由特定的硬件（称为内存管理单元的子处理单元）完成的……

从大的角度来看，缓存代码会减慢进程，同时又是多余的。

Answer 2

我已经将一个由映射和链表构建的相对简单的 LRU 缓存放在一起：

template<typename K, typename V, typename Map = std::unordered_map<K, typename std::list<K>::iterator>>
class LRUCache
{
    size_t maxSize;
    Map data;
    std::list<K> usageOrder;
    std::function<void(std::pair<K, V>)> onEject = [](std::pair<K, V> x){};

    void moveToFront(typename std::list<K>::iterator itr)
    {
        if(itr != usageOrder.begin())
            usageOrder.splice(usageOrder.begin(), usageOrder, itr);
    }


    void trimToSize()
    {
        while(data.size() > maxSize)
        {
            auto itr = data.find(usageOrder.back());

            onEject(std::pair<K, V>(itr->first, *(itr->second)));
            data.erase(usageOrder.back());
            usageOrder.erase(--usageOrder.end());
        }
    }

public:
    typedef std::pair<const K, V> value_type;
    typedef K key_type;
    typedef V mapped_type;


    LRUCache(size_t maxEntries) : maxSize(maxEntries)
    {
        data.reserve(maxEntries);
    }

    size_t size() const
    {
        return data.size();
    }

    void insert(const value_type& v)
    {
        usageOrder.push_front(v.first);
        data.insert(typename Map::value_type(v.first, usageOrder.begin()));

        trimToSize();
    }

    bool contains(const K& k) const
    {
        return data.count(k) != 0;
    }

    V& at(const K& k)
    {
        auto itr = data.at(k);
        moveToFront(itr);
        return *itr;
    }


    void setMaxEntries(size_t maxEntries)
    {
        maxSize = maxEntries;
        trimToSize();
    }

    void touch(const K& k)
    {
        at(k);
    }

    template<typename Compute>
    V& getOrCompute(const K& k)
    {
        if(!data.contains(k)) insert(value_type(k, Compute()));
        return(at(k));
    }

    void setOnEject(decltype(onEject) f)
    {
        onEject = f;
    }
};

我相信这符合您的标准。 有什么需要补充或者改变的吗？

Answer 3

您可以使用 Boost.MultiIndex 库。
实现 MRU 缓存。