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