Caché genérica de objetos

Question

¿Alguien sabe alguna implementación de un caché de objetos con plantillas?

• se utiliza una clave para encontrar el objeto (el mismo que en std :: mapa <>)
• especifica un número máximo de objetos que pueden estar en el caché al mismo tiempo
• Hay instalaciones para crear un objeto que no se encuentra en la caché
• Hay instalaciones para saber cuando un objeto se descarta de la caché

Por ejemplo:

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); 

... 

Puede ser tan simple como un caché LRU o MRU.

¡Cualquier sugerencia es bienvenida!

Nic

Answer 1

En una aplicación Me cuesta imaginar que aceleraría/Boost de hasta el rendimiento de los objetos de almacén que al parecer puede ser re-creados (cadera: ya que pueden ser descartados automáticamente, cuando la parte superior de caché). Una memoria caché sw requiere una recuperación de memoria a través del código de asociatividad, seguramente más lenta que la asignación de memoria y el constructor en ejecución (principalmente inicializaciones de memoria).

Con la excepción de la configuración manual del usuario para evitar el mecanismo de paginación (precisamente para aumentar el rendimiento, por cierto), la mayoría de OS "almacena" memoria en caché para usted en el disco ... es "paginación", una forma de "alto costo almacenamiento en caché ", porque nada se descarta, y lo hace HW específico, una unidad de subproceso llamada Unidad de administración de memoria ...

Un código de almacenamiento en caché, en general, estaría ralentizando los procesos mientras era redundante.

Answer 2

he reunido una relativamente simple caché LRU construido a partir de un mapa y una lista enlazada:

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; 
    } 
}; 

que creo que cumple con sus criterios. ¿Se necesita agregar o cambiar algo?

Answer 3

Puede usar la biblioteca Boost.MultiIndex. Es fácil de implementar un MRU cache.