Caching teure Daten in C++ - Funktionsbereich Statik vs veränderbare Member-Variablen

Question

Ich habe eine relativ teure Daten holen Operation, die ich die Ergebnisse von cachen wollen. Dieser Vorgang wird von const Methoden aufgerufen, in etwa wie folgt aus:

double AdjustData(double d, int key) const { 
    double factor = LongRunningOperationToFetchFactor(key); 
    return factor * d; 
} 

I AdjustDataconst bleiben möchte, aber ich möchte den Faktor zwischenzuspeichern, so das erste Mal hole ich es nur. Zur Zeit verwende ich eine mutable map<int, double>, um das Ergebnis zu speichern (die Karte ist von key bis factor), aber ich denke, mit einem Funktionsumfang statisch könnte eine bessere Lösung sein - dieser Faktor wird nur von dieser Funktion benötigt, und ist irrelevant für den Rest der Klasse.

Scheint das ein guter Weg zu gehen? Gibt es bessere Möglichkeiten? Was soll ich denken, besonders im Hinblick auf die Fadensicherheit?

Danke,

Dom

Answer 1

Ich würde die Implementierung von LongRunningOperationToFetchFactor mit etwas wie diesem umhüllen. Ich benutze Boost Scoped Locks, aber Sie können so etwas mit anderen Sperrgerüsten ähnlich.

#include <boost/thread/thread.hpp> 
#include <boost/thread/mutex.hpp> 
#include <map> 

using namespace std; 

static boost::mutex myMutex; 
static map<int,double> results; 

double CachedLongRunningOperationToFetchFactor(int key) 
{ 

    { 
     boost::mutex::scoped_lock lock(myMutex); 

     map<int,double>::iterator iter = results.find(key); 
     if (iter != results.end()) 
     { 
      return (*iter).second; 
     } 
    } 
    // not in the Cache calculate it 
    result = LongRunningOperationToFetchFactor(key); 
    { 
     // we need to lock the map again 
     boost::mutex::scoped_lock lock(myMutex); 
     // it could be that another thread already calculated the result but 
     // map assignment does not care. 
     results[key] = result; 
    } 
    return result; 
} 

Wenn dies wirklich ein langwieriger Vorgang ist, sollten die Kosten für die Verriegelung des Mutex minimal sein.

Es war nicht ganz klar von Ihnen Frage, aber wenn die Funktion LongRunningOperationToFetchFactor eine Memberfunktion Ihrer Klasse ist, dann möchten Sie die Karte die veränderbare Karte in der gleichen Klasse sein. Ich single statischen Mutex für den Zugriff ist aber immer noch schnell genug.

Answer 2

Es sei denn, ich verstehe nicht, es scheint mir offensichtlich, dass Sie dies eine statische machen wollen:

double AdjustData(double d) const { 
    static const double kAdjustFactor = LongRunningOperationToFetchFactor(); 
    return kAdjustFactor * d; 
} 

diese Weise können Sie nur holen den Faktor Einmal.

Answer 3

Sie können die singleton pattern (1) mit einer Klasse verwenden, die die lang andauernde Operation ausführt und das Ergebnis zwischenspeichert. Diese Instanz könnte dann in Konstantenfunktionen anderer Klassen verwendet werden. Ziehen Sie einen gegenseitigen Ausschluss in Betracht, um Einfügungen und Extraktionen aus der Kartendatenstruktur für die Threadsicherheit zu schützen. Wenn die Multithread-Leistung ein großes Problem darstellt, können Sie Schlüssel im Verlauf markieren, um zu verhindern, dass mehrere Threads denselben Schlüssel gleichzeitig berechnen.

#include <cstdlib> 
#include <iostream> 
#include <map> 

using namespace std; 

class FactorMaker { 
    map<int, double> cache; 

    double longRunningFetch(int key) 
    { 
     const double factor = static_cast<double> (rand())/RAND_MAX; 
     cout << "calculating factor for key " << key << endl; 
     // lock 
     cache.insert(make_pair(key, factor)); 
     // unlock 
     return factor; 
    } 

public: 
    double getFactor(int key) { 
     // lock 
     map<int, double>::iterator it = cache.find(key); 
     // unlock 
     return (cache.end() == it) ? longRunningFetch(key) : it->second; 
    } 
}; 

FactorMaker & getFactorMaker() 
{ 
    static FactorMaker instance; 
    return instance; 
} 

class UsesFactors { 
public: 
    UsesFactors() {} 

    void printFactor(int key) const 
    { 
     cout << getFactorMaker().getFactor(key) << endl; 
    } 
}; 

int main(int argc, char *argv[]) 
{ 
    const UsesFactors obj; 

    for (int i = 0; i < 10; ++i) 
     obj.printFactor(i); 

    for (int i = 0; i < 10; ++i) 
     obj.printFactor(i); 

    return EXIT_SUCCESS; 
} 

(1) Die Singletonmuster grob übersehen werden. Also, bitte unterlasse es nicht damit, wenn du es zum ersten Mal siehst.

Answer 4

Ich würde nicht machen diesen Cache eine lokale statische. Die veränderbare Map ist die Lösung für das Zwischenspeichern von Ergebnissen. Andernfalls wird Ihre Funktion unbrauchbar, da sich verschiedene Objekte Ihrer Klasse denselben Cache teilen, da der lokale statische Cache für alle Objekte gleich ist. Sie können die lokale Statistik verwenden, wenn das Ergebnis nicht vom Objekt abhängt. Aber dann würde ich mich fragen, warum die Funktion ein nicht-statisches Mitglied Ihres Objekts ist, wenn es nicht auf einen Zustand davon zugreifen muss.

Wie Sie sagen, sollte es threadsicher sein - wenn verschiedene Threads die Memberfunktion für dasselbe Objekt aufrufen können, möchten Sie wahrscheinlich einen Mutex verwenden.boost::thread ist eine gute Bibliothek zu verwenden.