Кэширование дорогостоящих данных на C++ - статическая статистика с функциями с изменяемыми переменными-членами

Question

У меня относительно дорогостоящая операция извлечения данных, которую я хочу кэшировать. Эта операция вызывается из const методов, примерно так:

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

Я хотел бы остаться AdjustDataconst, но я хочу, чтобы кэшировать из фактора, так что я только принести его в первый раз. В настоящее время я использую mutable map<int, double>, чтобы сохранить результат (карта от key до factor), но я думаю, что использование статического элемента с функциональными возможностями может быть лучшим решением - этот фактор необходим только этой функции и не имеет отношения к остальной части класса.

Это похоже на хороший способ пойти? Есть ли лучшие варианты? О чем я могу думать, особенно в отношении безопасности потоков.

Спасибо,

Dom

Answer 1

Я бы обернул реализацию LongRunningOperationToFetchFactor чем-то вроде этого. Я использую блокировки с помощью Boost, но вы можете сделать что-то подобное с другими блокировками.

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

Если это действительно длинная работа, стоимость блокировки Mutex должна быть минимальной.

Вопрос был не совсем ясен, но если функция LongRunningOperationToFetchFactor является функцией-членом вашего класса, то вы хотите, чтобы карта была изменчивой в том же классе. Я один статический мьютекс для доступа все еще достаточно быстро, хотя.

Answer 2

Если я не понимаю, это кажется очевидным, что вы хотите сделать это статическим:

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

Таким образом, вы только выборку фактора один раз.

Answer 3

Вы можете использовать singleton pattern (1) с классом, который выполняет длительную операцию и кэширует результат. Затем этот экземпляр можно использовать в константных функциях других классов. Рассмотрите взаимное исключение для защиты вставок и выделений из структуры данных карты для обеспечения безопасности потоков. Если многопоточная производительность представляет собой огромную проблему, вы можете пометить находящиеся в настоящий момент клавиши, чтобы предотвратить одновременное вычисление одного и того же ключа несколькими потоками.

#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) Одноэлементный шаблон может быть грубо пропустил. Поэтому, пожалуйста, воздержитесь от сумасшествия, если вы впервые увидите его.

Answer 4

Я бы не сделать этот кеш локальным статическим. Измененная карта - это решение для получения кеширования. В противном случае это сделает вашу функцию бесполезной, так как разные объекты вашего класса будут использовать один и тот же кеш, поскольку локальный статический кеш одинаковый для всех объектов. Вы можете использовать локальный статический, если результат не зависит от объекта. Но тогда я бы спросил, почему функция является нестационарным членом вашего объекта, если ему не нужно получить доступ к какому-либо состоянию.

Как вы говорите, он должен быть потокобезопасным - если разные потоки могут вызывать функцию-член на одном и том же объекте, вы, вероятно, захотите использовать мьютекс.boost::thread - хорошая библиотека для использования.