RCUObject.h

Go to the documentation of this file.

// This file's extension implies that it's C, but it's really -*- C++ -*-.
 
/*
  Copyright (C) 2002-2025 CERN for the benefit of the ATLAS collaboration
*/
#ifndef ATHENAKERNEL_RCUOBJECT_H
#define ATHENAKERNEL_RCUOBJECT_H
 
 
#include "GaudiKernel/ThreadLocalContext.h"
#include "GaudiKernel/EventContext.h"
#include <atomic>
#include <deque>
#include <vector>
#include <memory>
#include <mutex>
 
 
namespace Athena {
 
 
class IRCUSvc;
template <class T> class RCURead;
template <class T> class RCUReadQuiesce;
template <class T> class RCUUpdate;
 
 
struct RCUObjectGraceSets;
 
 
class IRCUObject
{
public:
  enum NoObjectEnum { NoObject };
 
 
  IRCUObject (IRCUSvc& svc);
 
 
  IRCUObject (size_t nslots);
 
 
  IRCUObject (IRCUObject&& other);
 
 
  // Make these explicit to prevent warnings from coverity.
  // (copy/assign are implicitly deleted due to the mutex member.)
  IRCUObject (const IRCUObject&) = delete;
  IRCUObject& operator= (const IRCUObject&) = delete;
  IRCUObject& operator= (IRCUObject&&) = delete;
 
 
  virtual ~IRCUObject();
 
 
  void quiescent();
 
 
  void quiescent (const EventContext& ctx);
 
 
protected:
  typedef std::mutex mutex_t;
  typedef std::unique_lock<mutex_t> lock_t;
 
 
  bool endGrace (lock_t& lock,
                 const EventContext& ctx);
 
 
  void setGrace (lock_t& /*lock*/);
 
 
  mutex_t& mutex();
 
 
  virtual void clearAll (lock_t& /*lock*/) = 0;
 
 
  virtual bool clearOld (lock_t& /*lock*/, size_t nold) = 0;
 
 
  void makeOld (lock_t& lock, size_t garbageSize);
 
 
private:
  void quiescentOol (const EventContext& ctx);
 
 
  std::mutex m_mutex;
 
  IRCUSvc* m_svc;
 
  std::unique_ptr<RCUObjectGraceSets> m_graceSets;
 
  size_t m_nold;
 
  std::atomic<bool> m_dirty;
};
 
 
template <class T>
class RCUObject
  : public IRCUObject
{
public:
  typedef RCURead<T> Read_t;
  typedef RCUReadQuiesce<T> ReadQuiesce_t;
  typedef RCUUpdate<T> Update_t;
 
 
  template <typename... Args>
  RCUObject (IRCUSvc& svc, Args&&... args);
 
 
  template <typename... Args>
  RCUObject (size_t nslots, Args&&... args);
 
 
  RCUObject (IRCUSvc& svc, NoObjectEnum);
 
 
  RCUObject (RCUObject&& other);
 
 
  // Make these explicit to prevent warnings from coverity.
  // (copy/assign are implicitly deleted due to the mutex member.)
  RCUObject (const RCUObject&) = delete;
  RCUObject& operator= (const RCUObject&) = delete;
  RCUObject& operator= (RCUObject&&) = delete;
 
 
  Read_t reader() const;
 
 
  ReadQuiesce_t readerQuiesce();
 
 
  ReadQuiesce_t readerQuiesce (const EventContext& ctx);
  ReadQuiesce_t readerQuiesce (const EventContext&& ctx) = delete;
 
 
  Update_t updater();
 
 
  Update_t updater (const EventContext& ctx);
  Update_t updater (const EventContext&& ctx) = delete;
 
 
  void discard (std::unique_ptr<const T> p);
 
 
protected:
  void discard (lock_t& /*lock*/, std::unique_ptr<const T> p);
 
 
private:
  virtual void clearAll (lock_t& /*lock*/) override;
 
 
  virtual bool clearOld (lock_t& /*lock*/, size_t nold) override;
 
 
private:
  template <class U> friend class RCUReadQuiesce;
  template <class U> friend class RCURead;
  template <class U> friend class RCUUpdate;
 
  std::unique_ptr<T> m_objref;
 
  std::atomic<const T*> m_obj;
 
  std::deque<std::unique_ptr<const T> > m_garbage;
};
 
 
template <class T>
class RCURead
{
public:
  RCURead (const RCUObject<T>& rcuobj);
 
 
  operator bool() const { return m_obj != nullptr; }
 
 
  const T& operator*() const;
 
 
  const T* operator->() const;
 
  
private:
  const T* m_obj;
};
 
 
template <class T>
class RCUReadQuiesce
  : public RCURead<T>
{
public:
  RCUReadQuiesce (RCUObject<T>& rcuobj);
 
 
  RCUReadQuiesce (RCUObject<T>& rcuobj, const EventContext& ctx);
  RCUReadQuiesce (RCUObject<T>& rcuobj, const EventContext&& ctx) = delete;
 
 
  ~RCUReadQuiesce();
 
 
private:
  RCUObject<T>& m_rcuobj;
 
  const EventContext& m_ctx;
};
 
 
template <class T>
class RCUUpdate
{
public:
  RCUUpdate (RCUObject<T>& rcuobj);
 
  
  RCUUpdate (RCUObject<T>& rcuobj, const EventContext& ctx);
  RCUUpdate (RCUObject<T>& rcuobj, const EventContext&& ctx) = delete;
 
  
  const T& operator*() const;
 
 
  const T* operator->() const;
 
 
  void update (std::unique_ptr<T> ptr);
 
 
private:
  RCUObject<T>& m_rcuobj;
 
  const EventContext& m_ctx;
 
  std::unique_lock<std::mutex> m_g;
};
 
 
} // namespace Athena
 
 
#include "AthenaKernel/RCUObject.icc"
 
 
#endif // not ATHENAKERNEL_RCUOBJECT_H