CondCont.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2023 CERN for the benefit of the ATLAS collaboration
*/
#ifndef ATHENAKERNEL_CONDCONT_H
#define ATHENAKERNEL_CONDCONT_H
 
#include "AthenaKernel/ClassID_traits.h"
#include "AthenaKernel/CLASS_DEF.h"
#include "AthenaKernel/BaseInfo.h"
#include "AthenaKernel/RCUUpdater.h"
#include "AthenaKernel/IConditionsCleanerSvc.h"
#include "AthenaKernel/CondObjDeleter.h"
#include "CxxUtils/ConcurrentRangeMap.h"
#include "CxxUtils/ConcurrentPtrSet.h"
#include "CxxUtils/SimpleUpdater.h"
#include "CxxUtils/checker_macros.h"
 
#include "GaudiKernel/EventIDBase.h"
#include "GaudiKernel/EventIDRange.h"
#include "GaudiKernel/DataObjID.h"
#include "GaudiKernel/StatusCode.h"
#include "GaudiKernel/ServiceHandle.h"
#include "boost/preprocessor/facilities/overload.hpp"
 
#include <iostream>
#include <set>
#include <vector>
#include <typeinfo>
#include <mutex>
#include <type_traits>
 
 
namespace SG {
  class DataProxy;
}
namespace Athena {
  class IRCUSvc;
}
 
 
enum class CondContStatusCode : StatusCode::code_t
{
  FAILURE           = 0,
  SUCCESS           = 1,
  RECOVERABLE       = 2,
 
  // Attempt to insert an item in a CondCont with a range duplicating
  // an existing one.  The original contents of the container are unchanged,
  // and the new item has been deleted.
  // This is classified as Success.
  DUPLICATE         = 10,
 
  // Attempt to insert an item in a CondCont with a range that partially
  // overlaps with an existing one.
  // This is classified as Success.
  OVERLAP           = 11,
 
  // Attempt to insert an item in a CondCont where the new range is an extension
  // of the last range.  That is, the start time of the new range matches
  // that of the last range in the container, and the end time of the new range
  // is larger than that of the last range in the container.  The end time
  // of the last range has been extended to match the new range.
  // The payload of the existing range is unchanged, and the new
  // item has been deleted.
  EXTENDED          = 12
};
STATUSCODE_ENUM_DECL (CondContStatusCode)
 
 
 
class CondContBase
{
public:
  class Category : public StatusCode::Category
  {
  public:
    typedef StatusCode::code_t code_t;
 
    virtual const char* name() const override;
 
    virtual std::string message (code_t code) const override;
 
    virtual bool isSuccess (code_t code) const override;
 
    static bool isDuplicate (code_t code);
    static bool isDuplicate (StatusCode code);
 
    static bool isOverlap (code_t code);
    static bool isOverlap (StatusCode code);
 
    static bool isExtended (code_t code);
    static bool isExtended (StatusCode code);
  };
 
 
  enum class KeyType
  {
    SINGLE,
 
    TIMESTAMP,
 
    RUNLBN,
 
    MIXED,
  };
 
 
  typedef void Payload;
 
  
  typedef uint64_t key_type;
 
 
  virtual ~CondContBase() {};
 
 
  CLID clid() const;
 
 
  KeyType keyType() const;
 
 
  const DataObjID& id() const;
 
 
  SG::DataProxy* proxy();
 
 
  const SG::DataProxy* proxy() const;
 
 
  void setProxy(SG::DataProxy*);
 
 
  virtual
  void list (std::ostream& ost) const = 0;
 
 
  void print() const;
 
  
  virtual size_t entries() const;
 
  
  virtual
  std::vector<EventIDRange> ranges() const = 0;
 
 
  virtual
  StatusCode typelessInsert (const EventIDRange& r,
                             void* obj,
                             const EventContext& ctx = Gaudi::Hive::currentContext()) = 0;
 
 
  virtual
  bool valid( const EventIDBase& t) const = 0;
 
 
  virtual
  bool range (const EventIDBase& t, EventIDRange& r) const = 0;
 
 
  virtual
  StatusCode erase (const EventIDBase& t,
                    const EventContext& ctx = Gaudi::Hive::currentContext()) = 0;
 
 
  virtual
  size_t trim (const std::vector<key_type>& runLbnKeys, const std::vector<key_type>& TSKeys);
 
 
  void clear();
 
 
  void quiescent (const EventContext& ctx = Gaudi::Hive::currentContext());
 
 
  size_t nInserts() const;
 
 
  size_t maxSize() const;
 
 
  virtual
  StatusCode extendLastRange (const EventIDRange& newRange,
                              const EventContext& ctx = Gaudi::Hive::currentContext()) = 0;
 
 
  static
  key_type keyFromRunLBN (const EventIDBase& b);
 
 
  static
  key_type keyFromTimestamp (const EventIDBase& b);
 
 
  struct RangeKey
  {
    RangeKey();
 
    RangeKey (const EventIDRange& r,
              key_type start,
              key_type stop);
 
 
    key_type m_start;
 
    key_type m_stop;
 
    EventIDRange m_range;
  };
 
 
  struct Compare
  {
    bool operator() (const RangeKey& r1, const RangeKey& r2) const
    { return r1.m_start < r2.m_start; }
    bool operator() (key_type t, const RangeKey& r2) const
    { return t < r2.m_start; }
    bool inRange (key_type t, const RangeKey& r) const
    {
      return t >= r.m_start && t< r.m_stop;
    }
 
 
    int overlap (const EventContext& ctx,
                 const RangeKey& oldRange, RangeKey& newRange) const;
 
 
    int extendRange (RangeKey& range, const RangeKey& newRange) const;
  };
 
 
  void addDep (CondContBase* dep);
 
 
  std::vector<CondContBase*> getDeps();
 
 
  static void setCleanerSvcName ATLAS_NOT_THREAD_SAFE (const std::string& name);
 
  
protected:
  typedef CxxUtils::ConcurrentRangeMap<RangeKey, key_type, void, Compare,
    Athena::RCUUpdater>
    CondContSet;
 
  typedef CondContSet::Updater_t Updater_t;
  typedef CondContSet::delete_function delete_function;
 
  CondContBase (Athena::IRCUSvc& rcusvc,
                KeyType keytype,
                CLID clid,
                const DataObjID& id,
                SG::DataProxy* proxy,
                std::shared_ptr<CondContSet::IPayloadDeleter> payloadDeleter,
                size_t capacity);
                
 
  StatusCode insertBase (const EventIDRange& r,
                         CondContSet::payload_unique_ptr t,
                         const EventContext& ctx = Gaudi::Hive::currentContext());
 
 
  StatusCode eraseBase (const EventIDBase& t,
                        const EventContext& ctx = Gaudi::Hive::currentContext());
 
 
  StatusCode
  extendLastRangeBase (const EventIDRange& newRange,
                       const EventContext& ctx = Gaudi::Hive::currentContext());
 
 
  const void* findBase (const EventIDBase& t,
                        EventIDRange const** r) const;
 
 
  const void* cast (CLID clid, const void* ptr) const;
 
 
  virtual const void* doCast (CLID clid, const void* ptr) const = 0;
 
 
  template <class FUNC>
  void forEach (const FUNC& func) const;
 
 
  StatusCode inserted (const EventContext& ctx);
 
 
  void insertError (CLID usedCLID) const;
 
 
  delete_function* delfcn() const;
 
 
  std::string title() const;
 
 
private:
  std::atomic<KeyType> m_keyType;
 
  CLID m_clid;
 
  DataObjID m_id;
 
  SG::DataProxy* m_proxy;
 
  CondContSet m_condSet;
 
  ServiceHandle<Athena::IConditionsCleanerSvc> m_cleanerSvc;
 
  using DepSet = CxxUtils::ConcurrentPtrSet<CondContBase, CxxUtils::SimpleUpdater>;
  DepSet m_deps;
 
  static std::string s_cleanerSvcName ATLAS_THREAD_SAFE;
};
 
 
CLASS_DEF( CondContBase , 34480459 , 1 )
 
 
 
 
 
class CondContSingleBase
  : public CondContBase
{
public:
  virtual
  void list (std::ostream& ost) const override final;
 
 
  virtual
  std::vector<EventIDRange> ranges() const override final;
 
 
  virtual
  StatusCode typelessInsert (const EventIDRange& r,
                             void* obj,
                             const EventContext& ctx = Gaudi::Hive::currentContext()) override final;
 
 
  virtual
  bool valid( const EventIDBase& t) const override final;
 
 
  virtual
  bool range (const EventIDBase& t, EventIDRange& r) const override final;
 
 
  virtual
  StatusCode erase (const EventIDBase& t,
                    const EventContext& ctx = Gaudi::Hive::currentContext()) override final;
 
 
  virtual
  StatusCode extendLastRange (const EventIDRange& newRange,
                              const EventContext& ctx = Gaudi::Hive::currentContext()) override final;
 
 
protected:
  CondContSingleBase (Athena::IRCUSvc& rcusvc,
                      CLID clid,
                      const DataObjID& id,
                      SG::DataProxy* proxy,
                      std::shared_ptr<CondContSet::IPayloadDeleter> payloadDeleter,
                      size_t capacity);
};
 
 
 
 
template <class T> class CondCont;
 
 
template <typename T>
class CondContBaseInfo
{
public:
  typedef CondContSingleBase Base;
};
 
 
namespace SG {
template <typename T>
struct Bases<CondCont<T> >
{
  using bases = BaseList<CondContBase>;
};
} // namespace SG
 
 
 
 
#define CONDCONT_BASE(D, B)       \
template <>                       \
class CondContBaseInfo<D>         \
{                                 \
public:                           \
  typedef CondCont<B> Base;       \
};                                 \
SG_BASES(CondCont<D>, CondCont<B>);\
SG_BASES(D, B)
  
 
 
 
template <typename T>
class CondCont : public CondContBaseInfo<T>::Base
{
public:
  typedef typename CondContBaseInfo<T>::Base Base;
 
  typedef typename Base::CondContSet CondContSet;
 
  typedef T Payload;
 
  typedef CondContBase::key_type key_type;
 
 
  CondCont (Athena::IRCUSvc& rcusvc,
            const DataObjID& id,
            SG::DataProxy* proxy = nullptr,
            size_t capacity = 16);
 
 
  virtual ~CondCont();
 
  CondCont (const CondCont&) = delete;
  CondCont& operator= (const CondCont&) = delete;
 
 
  StatusCode insert (const EventIDRange& r,
                     std::unique_ptr<T> obj,
                     const EventContext& ctx = Gaudi::Hive::currentContext());
 
 
  bool find (const EventIDBase& t,
             T const*& obj,
             EventIDRange const** r = nullptr) const;
 
 
  const T* find (const EventIDBase& t) const;
 
 
protected:
  CondCont (Athena::IRCUSvc& rcusvc,
            CLID clid,
            const DataObjID& id,
            SG::DataProxy* proxy,
            std::shared_ptr<typename CondContSet::IPayloadDeleter> payloadDeleter,
            size_t capacity);
 
 
  const void* cast (CLID clid, const void* ptr) const;
 
 
  virtual const void* doCast (CLID clid, const void* ptr) const override;
 
 
public:
  static void registerBaseInit();
};
 
 
 
 
class CondContMixedBase
  : public CondContBase
{
public:
  virtual
  void list (std::ostream& ost) const override final;
 
 
  virtual size_t entries() const override final;
 
 
  virtual
  std::vector<EventIDRange> ranges() const override final;
 
 
  virtual
  StatusCode typelessInsert (const EventIDRange& r,
                             void* obj,
                             const EventContext& ctx = Gaudi::Hive::currentContext()) override final;
 
 
  virtual
  bool valid( const EventIDBase& t) const override final;
 
 
  virtual
  bool range (const EventIDBase& t, EventIDRange& r) const override final;
 
 
  virtual
  StatusCode erase (const EventIDBase& t,
                    const EventContext& ctx = Gaudi::Hive::currentContext()) override final;
 
 
  virtual
  StatusCode extendLastRange (const EventIDRange& newRange,
                              const EventContext& ctx = Gaudi::Hive::currentContext()) override final;
 
 
protected:
  CondContMixedBase (Athena::IRCUSvc& rcusvc,
                     CLID clid,
                     const DataObjID& id,
                     SG::DataProxy* proxy,
                     std::shared_ptr<CondContSet::IPayloadDeleter> payloadDeleter,
                     size_t capacity);
 
 
  StatusCode insertMixed (const EventIDRange& r,
                          CondContBase::CondContSet::payload_unique_ptr t,
                          const EventContext& ctx = Gaudi::Hive::currentContext());
 
 
  const void* findMixed (const EventIDBase& t,
                         EventIDRange const** r) const;
 
 
  delete_function* payloadDelfcn() const;
 
 
private:
  Athena::IRCUSvc& m_rcusvc;
 
  std::shared_ptr<CondContSet::IPayloadDeleter> m_payloadDeleter;
 
  std::mutex m_mutex;
};
 
 
 
 
template <class T> class CondContMixed;
 
 
template <typename T>
class CondContMixedBaseInfo
{
public:
  typedef CondContMixedBase Base;
};
 
 
namespace SG {
template <typename T>
struct Bases<CondContMixed<T> >
{
  using bases = BaseList<CondContBase>;
};
} // namespace SG
 
 
#define CONDCONT_MIXED_BASE(D, B)                                          \
template <>                                                                \
class CondContMixedBaseInfo<D>                                             \
{                                                                          \
public:                                                                    \
  static_assert (std::is_base_of_v<CondContMixed<B>, CondCont<B> >,        \
                 "CondCont<" #B "> is not a mixed conditions container."); \
  typedef CondCont<B> Base;                                                \
};                                                                         \
SG_BASES(CondContMixed<D>, CondCont<B>);                                   \
SG_BASES(D, B)
  
 
 
 
template <typename T>
class CondContMixed : public CondContMixedBaseInfo<T>::Base
{
public:
  typedef typename CondContMixedBaseInfo<T>::Base Base;
 
  typedef typename Base::CondContSet CondContSet;
 
  typedef T Payload;
 
  typedef CondContBase::key_type key_type;
 
 
  virtual ~CondContMixed();
 
  CondContMixed (const CondContMixed&) = delete;
  CondContMixed& operator= (const CondContMixed&) = delete;
 
 
  StatusCode insert (const EventIDRange& r,
                     std::unique_ptr<T> obj,
                     const EventContext& ctx = Gaudi::Hive::currentContext());
 
 
  bool find (const EventIDBase& t,
             T const*& obj,
             EventIDRange const** r = nullptr) const;
 
 
  const T* find (const EventIDBase& t) const;
 
 
protected:
  CondContMixed (Athena::IRCUSvc& rcusvc,
                 CLID clid,
                 const DataObjID& id,
                 SG::DataProxy* proxy,
                 std::shared_ptr<typename CondContSet::IPayloadDeleter> payloadDeleter,
                 size_t capacity);
 
 
  CondContMixed (Athena::IRCUSvc& rcusvc,
                 CLID clid,
                 const DataObjID& id,
                 SG::DataProxy* proxy,
                 size_t capacity);
 
 
  const void* cast (CLID clid, const void* ptr) const;
 
 
  virtual const void* doCast (CLID clid, const void* ptr) const override;
 
 
public:
  static void registerBaseInit();
};
 
 
 
 
#include "AthenaKernel/CondCont.icc"
#include "AthenaKernel/CondContMaker.h"
 
#define CONCATUNF_(x,y) x##y
#define CONCATUNF(x,y) CONCATUNF_(x,y)
#define UNIQUEVARNAME CONCATUNF(CONCATUNF(REGCCM_,__COUNTER__),__LINE__)
 
 
// For a conditions container not deriving from another, do
//    CONDCONT_DEF(TYPE, CLID);
//
// For a conditions container with a payload deriving from BASE, do
//    CONDCONT_DEF(TYPE, CLID, BASE);
//
#define CONDCONT_DEF_2(T, CLID_)    \
  CLASS_DEF( CondCont<T>, CLID_, 1) \
  static CondContainer::CondContMaker<T> maker_ ## CLID_ {}
#define CONDCONT_DEF_3(T, CLID_, BASE)           \
  CONDCONT_BASE(T, BASE);                        \
  CONDCONT_DEF_2(T, CLID_)
#define CONDCONT_DEF(...)  \
  BOOST_PP_OVERLOAD(CONDCONT_DEF_, __VA_ARGS__)(__VA_ARGS__)
 
 
// For a conditions container not deriving from another, do
//    CONDCONT_MIXED_DEF(TYPE, CLID);
//
// For a conditions container with a payload deriving from BASE, do
//    CONDCONT_MIXED_DEF(TYPE, CLID, BASE);
//
// The BASE class must have earlier been named in another CONDCONT_MIXED_DEF.
//
#define CONDCONT_MIXED_DEF_2(T, CLID_)                                   \
  template<> class CondCont<T> : public CondContMixed<T> {               \
  public:                                                                \
    CondCont (Athena::IRCUSvc& rcusvc, const DataObjID& id,              \
              SG::DataProxy* proxy =nullptr, size_t capacity = 16)       \
      : CondContMixed<T> (rcusvc, CLID_, id, proxy, capacity) {}         \
  protected:                                                             \
    CondCont (Athena::IRCUSvc& rcusvc, CLID clid, const DataObjID& id,   \
              SG::DataProxy* proxy,                                      \
              std::shared_ptr<typename CondContSet::IPayloadDeleter> payloadDeleter, \
              size_t capacity = 16)                                      \
      : CondContMixed<T> (rcusvc, clid, id, proxy,                       \
                          payloadDeleter, capacity) {}                   \
  };                                                                     \
  CLASS_DEF( CondCont<T>, CLID_, 1)                                      \
  SG_BASES(CondCont<T>, CondContMixed<T>);                               \
  static CondContainer::CondContMaker<T> maker_ ## CLID_ {}
#define CONDCONT_MIXED_DEF_3(T, CLID_, BASE)                             \
  CONDCONT_MIXED_BASE(T, BASE);                                          \
  CONDCONT_MIXED_DEF_2(T, CLID_)
#define CONDCONT_MIXED_DEF(...)                                          \
  BOOST_PP_OVERLOAD(CONDCONT_MIXED_DEF_, __VA_ARGS__)(__VA_ARGS__)
 
  
#endif // not ATHENAKERNEL_CONDCONT_H