Schema di memorizzazione nella cache plug-in generalizzato?

Question

Dato che è uno di the hard things in computer science, qualcuno sa come impostare una strategia di memorizzazione nella cache plug-in?

Quello che sto pensando mi permetterebbe di scrivere un programma con un minimo di pensiero su ciò che deve essere memorizzato nella cache (ei usano una specie di schema di caldaia, schema di basso/nessun costo che non compila nulla in nessun luogo dove posso voglio caching) e poi quando le cose vanno avanti e so dove ho bisogno di fare il caching, posso aggiungerlo senza fare cambiamenti di codice invasivi.

Come un'idea del tipo di soluzione che sto cercando; Sto lavorando con lo D programing language (ma a metà strada del C++ andrebbe bene) e mi piace il modello.

Answer 1

La cosa più vicina che mi viene in mente è la memoizzazione per le funzioni pure. Forse anche interessante per te potrebbe essere questo libro Pattern Oriented Software Architecture Patterns Management che contiene un modello di cache.

Answer 2

Potrebbe interessarti come Drizzle fa questo genere di cose con diversi backend di memorizzazione e memorizzazione nella cache. In breve, fornisce un'interfaccia che può essere utilizzata da un'applicazione madre per interagire con MySQL, memcached, ecc.

Answer 3

Non sono sicuro di quale misura debba essere "generalizzata" e "plug-in", ma se lo può permettere refactoring di utilizzo dei tuoi cache (funzione che sostituisce le chiamate con l'uso diretto di una variabile), quindi prendere in considerazione la seguente:

//works for any CopyConstructible type of cache and any function 
//which result should be cached 
//(the arguments of the function have to be properly binded) 
/** 
* caching + lazy initialization 
* we shouldn't allow copying of lazy<T>, because every copy initializes its own cache 
* and this is not what intended most of the time 
* T must be CopyConstructible 
*/ 
template<class T> 
class lazy: private boost::noncopyable 
{ 
public: 
    lazy(boost::function0<T> _creator) 
     : creator(_creator) {} 
    /** 
    * aka is_cashed 
    */ 
    bool is_initialized() 
    { 
     return val; 
    } 
    operator T&() 
    { 
     if(!val) 
      val = creator(); 
     return *val; 
    } 
    T& operator*() 
    { 
     if(!val) 
      val = creator(); 
     return *val; 
    } 
    /** 
    * resets cache to update it next time it is used 
    */ 
    void reset() 
    { 
     val.reset(); 
    } 
private: 
    boost::function0<T> creator; 
    boost::optional<T> val; 
}; 
//usage 
    //initialize caching and updating strategy 
    lazy<WebPage> cached_page(boost::bind(&Server::getPage, server)); 
    server->OnPageUpdate = boost::bind(&OnPageUpdate, cached_page); 
    ..... 

    //use cached_page everywhere as if it were regular variable of WebPage type 
    showPage(cached_page); 
//-------------- 
void OnPageUpdate(lazy<WebPage>& page) 
{ 
    page.reset(); 
} 

Se si desidera rimuovere l'inizializzazione pigra, quindi modificare in modo che si crea la cache nel costruttore e nel metodo reset().

Answer 4

c'è un C++ 0x soluzione generica Memoizzazione automatico (vedi risposta qui: What are reasonable ways to improve solving recursive problems?)