DataProxy.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 SGTOOLS_DATAPROXY_H
#define SGTOOLS_DATAPROXY_H
 
// includes
#include <string>
#include <set>
#include <vector>
#include <typeinfo>
#include <memory>
#include <mutex>
#include <atomic>
#include "GaudiKernel/IRegistry.h"
#include "GaudiKernel/ClassID.h"
#include "GaudiKernel/EventContext.h"
#include "AthenaKernel/getMessageSvc.h" /*Athena::IMessageSvcHolder*/
#include "AthenaKernel/IRegisterTransient.h"
#include "SGTools/TransientAddress.h"
#include "SGTools/exceptions.h"
#include "CxxUtils/checker_macros.h"
 
 
// forward declarations:
class DataObject;
class IConverter;
class IResetable;
class IProxyDict;
 
namespace SG {
  class T2pMap;
class DataStore;
 
  class DataProxy : public IRegistry, public IRegisterTransient
  {
 
  public:
    enum ErrNo {ALLOK, NOCNVSVC, NOIOA, CNVFAILED, T2PREGFAILED,
                RECURSIVEREAD, NERRORS};
    //FIXME private typedef IRegistry::name_type name_type;
    //FIXME private typedef IRegistry::id_type id_type;
    typedef std::string name_type;
    typedef std::string id_type;
    typedef TransientAddress::TransientClidSet CLIDCont_t;
    typedef std::vector<std::string> AliasCont_t;
    typedef IStringPool::sgkey_t sgkey_t;
 
    // Constructors
    DataProxy();                      // default constructor
 
    DataProxy(TransientAddress* tAddr, 
              IConverter* pDataLoader,
              bool constFlag=false, bool resetOnly=true);
 
    DataProxy(std::unique_ptr<TransientAddress> tAddr, 
              IConverter* pDataLoader,
              bool constFlag=false, bool resetOnly=true);
 
    DataProxy(TransientAddress&& tAddr,
              IConverter* pDataLoader,
              bool constFlag=false, bool resetOnly=true);
 
    DataProxy(DataObject* dObject, 
              TransientAddress* tAddr,
              bool constFlag=false, bool resetOnly=true);
 
    DataProxy(DataObject* dObject, 
              TransientAddress&& tAddr,
              bool constFlag=false, bool resetOnly=true);
 
    // Destructor
    virtual ~DataProxy();
 
 
    virtual unsigned long addRef() override final;
 
    virtual unsigned long release() override final;
 
    unsigned long refCount() const;
 
    virtual const name_type& name() const override final;
 
    virtual const id_type& identifier() const override final;
 
    virtual DataObject* object ATLAS_NOT_CONST_THREAD_SAFE () const override final;
 
    virtual void setAddress(IOpaqueAddress* ioa) override final;
 
    void setAddress(CxxUtils::RefCountedPtr<IOpaqueAddress> ioa);
 
    virtual IOpaqueAddress* address() const override final;
 
    virtual IDataProviderSvc* dataSvc() const override final;
 
    sgkey_t sgkey() const;
 
    void setSGKey (sgkey_t sgkey);
 
    StoreID::type storeID() const;
 
    bool transientID (CLID id) const;
 
    CLIDCont_t transientID() const;
 
    void setTransientID(CLID id);
 
    AliasCont_t alias() const;
 
    bool hasAlias (const std::string& key) const;
 
    void setAlias(const std::string& key);
 
    bool removeAlias(const std::string& key);
 
    IAddressProvider* provider();
 
    void setProvider(IAddressProvider* provider, StoreID::type storeID);
 
    void setID (CLID id, const std::string& key);
 
 
    void reset (bool hard = false);
    void finalReset(); 
 
    bool isValid() const;
 
    bool isValidAddress() const;
 
    bool isValidObject() const;
 
    bool updateAddress();
 
    void setObject(DataObject* obj, bool doreg = true);
 
    DataObject* accessData();
 
    ErrNo errNo() const;
 
    CLID clID() const;
 
    bool isConst() const;
 
 
    void setConst();
 
 
    void resetOnly(const bool& flag);
 
    bool isResetOnly() const;
 
    bool bindHandle(IResetable* ir);
    void unbindHandle(IResetable* ir);
 
    // cache the t2p
    void setT2p(T2pMap* t2p);
 
    virtual void registerTransient (void* p) override final;
 
    void setStore (IProxyDict* store);
 
    IProxyDict* store();
 
    const IProxyDict* store() const;
 
    void resetBoundHandles (bool hard);
 
    IConverter* loader();
 
 
    std::unique_ptr<DataObject> readData();
 
 
  private:
    friend class SG::DataStore;
 
    DataProxy(const DataProxy&) = delete;
    DataProxy& operator=(const DataProxy&) = delete;
 
 
    DataObject* accessDataOol();
 
 
    bool requestRelease(bool force, bool hard);
 
    void resetRef();
 
    // PLEASE NOTE: The data members of this class are ordered so that
    // the most frequently accessed members are grouped together, within
    // the first cache line.  See the layout at the end of this file.
    // Be aware of this when making changes to the layout of this class.
 
    unsigned int m_refCount;
 
    bool m_resetFlag;        
 
    // Strictly redundant with m_handles below, but put here to speed up the
    // test for m_handles.empty() --- both by eliminating the pointer
    // comparison and by moving the data into the part of DataProxy covered
    // by the first cache line.
    bool m_boundHandles;
 
    std::atomic<bool> m_const;
    bool m_origConst;
 
    std::atomic<DataObject*> m_dObject;
 
    TransientAddress m_tAddress;
 
    IConverter* m_dataLoader;
 
    T2pMap* m_t2p;
 
    typedef std::vector<IResetable*> handleList_t;
    handleList_t m_handles;
 
    // Needs to be recursive since updateAddress can call back
    // into the DataProxy.
    // To prevent deadlocks, the store lock should be acquired
    // before this one.  This implies that we shouldn't call anything
    // that might acquire the store lock while holding m_mutex.
    typedef std::recursive_mutex mutex_t;
    typedef std::lock_guard<mutex_t> lock_t;
    mutable mutex_t m_mutex;
 
    Athena::IMessageSvcHolder m_ims;
    
    std::atomic<IProxyDict*> m_store;
 
    enum ErrNo m_errno;  // protected by m_objMutex
 
 
    // For m_dObject.
    typedef std::recursive_mutex objMutex_t;
    typedef std::lock_guard<objMutex_t> objLock_t;
    mutable objMutex_t m_objMutex; // For m_dObject, m_errno
 
    
    void lock (objLock_t&);
 
 
    std::unique_ptr<DataObject> readData (objLock_t& objLock, ErrNo* errNo);
 
 
    void setObject (objLock_t& objLock, DataObject* obj, bool doreg);
 
 
    const EventContext& contextFromStore() const;
 
  };
 
 
} //end namespace SG
 
 
// DP+ 0: two vptrs
// DP+10: int m_refCount
// DP+14: bool m_resetFlag
// DP+15: bool m_boundHandles
// DP+16: bool m_const
// DP+17: bool m_origConst
// DP+18: DataObject* m_dObject
 
// TA = DP+20
//  + 0:  CLID m_clid
//  + 4:  sgkey_t m_sgkey
//  + 8:  type m_storeID (size 4)
//  + c:  bool m_clearAddress
//  + d:  bool m_consultProvider
//  + e:  padding
//  +10:  IOpaqueAddress* m_address
//  +18:  IAddressProvider* m_pAddressProvider
//  +20:  SG::CachedValue<std::string> m_name <== 2nd cache line starts at +20
//  +48:  vector m_transientID 
//  +60:  vector m_transientAlias       <== 3rd cache line starts at +60
//  +7c..
 
// DP+9c: IConverter* m_dataLoader
// DP+a0: T2PMap* m_t2p
// DP+a8: vector m_handles
// DP+c0: m_mutex                    <== 4th cache line starts at +c0
// DP+e8: IMessageSvc* m_ims
// DP+f0: std::atomic<IProxyDict*> m_store
// DP+f8: ErrNo m_errno
// DP+fc: padding
// DP+100: m_objMutex                <== 5th cache line starts at +100
// DP+128: end
 
 
#include "SGTools/DataProxy.icc"
 
#endif // SGTOOLS_DATAPROXY