CachedValue.icc

Go to the documentation of this file.

/*
  Copyright (C) 2002-2023 CERN for the benefit of the ATLAS collaboration
*/
/**
 * @file CxxUtils/CachedValue.icc
 * @author scott snyder <snyder@bnl.gov>
 * @date Sep, 2017
 * @brief Cached value with atomic update.
 */
 
 
#include "CxxUtils/AthUnlikelyMacros.h"
 
 
namespace CxxUtils {
 
 
/**
 * @brief Default constructor.  Sets the value to invalid.
 */
template <class T>
inline
CachedValue<T>::CachedValue()
  : m_val (),
    m_cacheValid (INVALID)
{
}
 
 
/**
 * @brief Constructor from a value.
 */
template <class T>
inline
CachedValue<T>::CachedValue (const T& val)
  : m_val (val),
    m_cacheValid (VALID)
{
}
 
 
/**
 * @brief Move constructor from a value.
 */
template <class T>
inline
CachedValue<T>::CachedValue (T&& val) noexcept
  : m_val (std::move (val)),
    m_cacheValid (VALID)
{
}
 
 
/**
 * @brief Copy constructor.
 */
template <class T>
inline
CachedValue<T>::CachedValue (const CachedValue& other)
  : m_val(),
    m_cacheValid (INVALID)
{
  // If the source is in the middle of an update, set this value
  // to invalid.  Don't copy the value itself unless the source is valid.
  if (other.m_cacheValid == VALID) {
    m_cacheValid = VALID;
    m_val = other.m_val;
  }
}
 
 
/**
 * @brief Move constructor.
 *        No concurrent operations on OTHER are possible.
 */
template <class T>
inline
CachedValue<T>::CachedValue (CachedValue&& other) noexcept
  : m_val(),
    m_cacheValid (INVALID)
{
  if (other.m_cacheValid == VALID) {
    // If we get here, m_val should be properly initialized.
    // But sometimes gcc12 has trouble proving that.
    // Suppress a maybe-uninitialized warning here.
#if __GNUC__ >= 12
#pragma GCC diagnostic push    
#pragma GCC diagnostic ignored "-Wmaybe-uninitialized"
#endif
    m_val = std::move (other.m_val);
#if __GNUC__ >= 12
#pragma GCC diagnostic pop
#endif
    other.m_cacheValid = INVALID;
    m_cacheValid = VALID;
  }
}
 
 
/**
 * @brief Copy constructor from other type.
 */
template <class T>
template <class U>
inline
CachedValue<T>::CachedValue (const CachedValue<U>& other)
  : m_cacheValid (INVALID)
{
  // If the source is in the middle of an update, set this value
  // to invalid.  Don't copy the value itself unless the source is valid.
  if (other.m_cacheValid == VALID) {
    m_cacheValid = VALID;
    m_val = other.m_val;
  }
  else {
    m_val = T();
  }
}
 
 
/**
 * @brief Assignment.
 */
template <class T>
inline
CachedValue<T>& CachedValue<T>::operator= (const CachedValue& other)
{
  if (this != &other) {
    if (other.m_cacheValid == VALID) {
      m_cacheValid = VALID;
      m_val = other.m_val;
    }
    else {
      m_cacheValid = INVALID;
    }
  }
  return *this;
}
 
 
/**
 * @brief Move.
 *        No concurrent operations on OTHER are possible.
 */
template <class T>
inline
CachedValue<T>& CachedValue<T>::operator= (CachedValue&& other) noexcept
{
  if (this != &other) {
    if (other.m_cacheValid == VALID) {
      m_val = std::move (other.m_val);
      other.m_cacheValid = INVALID;
      m_cacheValid = VALID;
    }
    else {
      m_cacheValid = INVALID;
    }
  }
  return *this;
}
 
 
/// Helper for setting the value in an exception-safe manner.
struct CacheLock
{
  /// If the cache is currently INVALID, then switch to UPDATING.
  /// In that case, then this object will evaluate as true, and the
  /// state will be changed to VALID when this object is destroyed.
  /// Otherwise, this object will evaluate as false, and the cache state
  /// will not be changed.
  CacheLock (std::atomic<CacheState>& flag)
    : m_flag (flag),
      m_vflag (INVALID)
  {
    flag.compare_exchange_strong (m_vflag, UPDATING);
  }
  operator bool() const { return m_vflag == INVALID; }
  ~CacheLock() { if (m_vflag == INVALID) m_flag = VALID; }
 
  std::atomic<CacheState>& m_flag;
  CacheState m_vflag;
};
 
 
/**
 * @brief Set the value, assuming it is currently invalid.
 * Otherwise, this method will do nothing.
 * The value will be valid once this returns.
 */
template <class T>
inline
void CachedValue<T>::set (const T& val) const
{
  // Interlocked assignment of the cached value,
  // only if the current state is INVALID.
  {
    CacheLock lock (m_cacheValid);
    if (lock) {
      m_val = val;
    }
    else {
      // Spin if another thread is currently updating.
      while (m_cacheValid == UPDATING) {
        CxxUtils::stall();
      }
    }
  }
}
 
 
/**
 * @brief Set the value by move, assuming it is currently invalid.
 * Otherwise, this method will do nothing.
 * The value will be valid once this returns.
 */
template <class T>
inline
void CachedValue<T>::set (T&& val) const noexcept
{
  // Interlocked assignment of the cached value,
  // only if the current state is INVALID.
  {
    CacheLock lock (m_cacheValid);
    if (lock) {
      m_val = std::move (val);
    }
    else {
      // Spin if another thread is currently updating.
      while (m_cacheValid == UPDATING) {
        CxxUtils::stall();
      }
    }
  }
}
 
 
/**
 * @brief Test to see if the value is valid.
 *        May spin if another thread is currently updating the value.
 */
template <class T>
inline
bool CachedValue<T>::isValid() const
{
  CacheState stat = m_cacheValid;
  if (ATH_LIKELY(stat == VALID)) return true;
  // Get the state flag.
  // Spin if another thread is currently updating.
  while ((stat = m_cacheValid) == UPDATING) {
    CxxUtils::stall();
  }
  return stat == VALID;
}
 
 
/**
 * @brief Return a pointer to the cached value.
 *        Should not be called unless isValid() has returned true or set()
 *        has returned.
 */
template <class T>
inline
const T* CachedValue<T>::ptr() const
{
  return &m_val;
}
 
 
/**
 * @brief Store a new value to the value.
 */
template <class T>
inline
void CachedValue<T>::store (const T& val)
{
  m_cacheValid = VALID;
  m_val = val;
}
 
/**
 * @brief Store a new value to the value, by move.
 */
template <class T>
inline
void CachedValue<T>::store (T&& val) noexcept
{
  m_cacheValid = VALID;
  m_val = std::move (val);
}
 
/**
 * @brief Reset the value to invalid.
 */
template <class T>
inline
void CachedValue<T>::reset()
{
  m_cacheValid = INVALID;
}
 
 
} // namespace CxxUtils