Cache.h

Go to the documentation of this file.

// Mantid Repository : https://github.com/mantidproject/mantid
//
// Copyright © 2007 ISIS Rutherford Appleton Laboratory UKRI,
//   NScD Oak Ridge National Laboratory, European Spallation Source,
//   Institut Laue - Langevin & CSNS, Institute of High Energy Physics, CAS
// SPDX - License - Identifier: GPL - 3.0 +
#pragma once
 
//----------------------------------------------------------------------
// Includes
//----------------------------------------------------------------------
#include "MantidKernel/DllConfig.h"
#include "MantidKernel/MultiThreaded.h"
#include <map>
 
#include <mutex>
 
namespace Mantid {
namespace Kernel {
template <class KEYTYPE, class VALUETYPE> class DLLExport Cache {
public:
  Cache() : m_cacheHit(0), m_cacheMiss(0), m_cacheMap(), m_mutex() {}
 
  Cache(const Cache<KEYTYPE, VALUETYPE> &src)
      : m_cacheHit(src.m_cacheHit), m_cacheMiss(src.m_cacheMiss), m_cacheMap(src.m_cacheMap),
        m_mutex() // New mutex which is unlocked
  {}
 
  Cache<KEYTYPE, VALUETYPE> &operator=(const Cache<KEYTYPE, VALUETYPE> &rhs) {
    if (this == &rhs)
      return *this; // handle self-assignment
    m_cacheHit = rhs.m_cacheHit;
    m_cacheMiss = rhs.m_cacheMiss;
    m_cacheMap = rhs.m_cacheMap;
    // mutex is untouched
    return *this;
  }
 
  void clear() {
    std::lock_guard<std::mutex> lock(m_mutex);
    m_cacheHit = 0;
    m_cacheMiss = 0;
    m_cacheMap.clear();
  }
 
  int size() { return static_cast<int>(m_cacheMap.size()); }
 
  int hitCount() { return m_cacheHit; }
  int missCount() { return m_cacheMiss; }
  double hitRatio() {
    double hitRatio = 0.0;
    if ((m_cacheHit + m_cacheMiss) > 0) {
      hitRatio = 100.0 * (m_cacheHit * 1.0) / (m_cacheHit + m_cacheMiss);
    }
    return hitRatio;
  }
 
  void setCache(const KEYTYPE &key, const VALUETYPE &value) {
    std::lock_guard<std::mutex> lock(m_mutex);
    m_cacheMap[key] = value;
  }
 
  bool getCache(const KEYTYPE &key, VALUETYPE &value) const {
#ifdef USE_CACHE_STATS
    bool found = getCacheNoStats(key, value);
    if (found) {
      PARALLEL_ATOMIC
      m_cacheHit++;
    } else {
      PARALLEL_ATOMIC
      m_cacheMiss++;
    }
    return found;
#else
    return getCacheNoStats(key, value);
#endif
  }
 
  void removeCache(const KEYTYPE &key) {
    std::lock_guard<std::mutex> lock(m_mutex);
    m_cacheMap.erase(key);
  }
 
private:
  bool getCacheNoStats(const KEYTYPE key, VALUETYPE &value) const {
    std::lock_guard<std::mutex> lock(m_mutex);
    auto it_found = m_cacheMap.find(key);
    bool isValid = it_found != m_cacheMap.end();
 
    if (isValid) {
      value = it_found->second;
    }
 
    return isValid;
  }
 
  mutable int m_cacheHit;
  mutable int m_cacheMiss;
  std::map<KEYTYPE, VALUETYPE> m_cacheMap;
  mutable std::mutex m_mutex;
  using CacheMapIterator = typename std::map<KEYTYPE, VALUETYPE>::iterator;
  using CacheMapConstIterator = typename std::map<KEYTYPE, VALUETYPE>::const_iterator;
};
 
} // namespace Kernel
} // namespace Mantid