RootDatabase.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2024 CERN for the benefit of the ATLAS collaboration
*/
 
//====================================================================
//
//        Package    : RootStorageSvc (The POOL project)
//
//        Author     : M.Frank
//====================================================================
#ifndef POOL_ROOTSTORAGESVC_ROOTDBASE_H
#define POOL_ROOTSTORAGESVC_ROOTDBASE_H 1
 
// Framework include files
#include "GaudiKernel/SmartIF.h"
#include "StorageSvc/IDbDatabase.h"
#include "StorageSvc/DbDatabase.h"
#include "POOLCore/DbPrint.h"
 
#include <set>
#include <map>
#include <mutex>
#include <unordered_map>
 
// Forward declarations
class StatusCode;
namespace ROOT { class RNTupleReader; }
 
class TFile;
class TTree;
class TBranch;
class IFileMgr;
namespace RootAuxDynIO {
   class IRootAuxDynReader;
}
namespace RootStorageSvc {
   class RNTupleWriterHelper;
}
 
/*
 * POOL namespace declaration
 */
namespace pool  {  
   class RootTreeContainer;
   
   class RootDatabase : public IDbDatabase, public APRMessaging
   {
  public:
    enum { READ_COUNTER = 0, WRITE_COUNTER = 1, OTHER_COUNTER = 2 };
 
  private:
    DbDatabase    m_dbH;
    TFile*        m_file;
    std::string   m_version;
    long long int m_counters[3];
    int           m_defCompression;
    int           m_defCompressionAlg;
    int           m_defSplitLevel;
    int           m_defAutoSave;
    int           m_defBufferSize;
    int           m_maxBufferSize;
    int           m_minBufferEntries;
    int           m_defWritePolicy;
    int             m_branchOffsetTabLen;
    std::string   m_treeNameWithCache;
    int           m_defTreeCacheLearnEvents;
    int           m_rntBufferedWriteEnabled;
    int           m_rntReaderMetricsEnabled;
    int           m_rntWriterMetricsEnabled;
    std::string   m_rntUnsplitFieldList;

    std::string   m_indexMaster;
    uint64_t      m_indexMasterID;

    std::map<TBranch*, uint64_t>   m_indexSizeMap;

    std::set< std::string > m_indexRebuilt;
 
    /* ---  variables used with TREE_AUTO_FLUSH option for
            managing combined TTree::Fill for branch containers
    */
    // TTree names with requested AUTO_FLUSH value
    std::map< std::string, int >        m_autoFlushTrees;
 
    // mapping of opened (for update) branch containers, to their TTree
    typedef    std::set< RootTreeContainer* >   ContainerSet_t;
    std::map< TTree*, ContainerSet_t >  m_containersInTree;
    
    std::map< std::string, int >        m_customSplitLevel;
 
    SmartIF<IFileMgr>     m_fileMgr;
 
    // mutex to prevent concurrent read I/O from AuxDynReader
    std::recursive_mutex  m_iomutex;
 
    std::map<std::string, std::unique_ptr<RootStorageSvc::RNTupleWriterHelper> >  m_ntupleWriterMap;
    std::map<std::string, std::unique_ptr<ROOT::RNTupleReader> >                 m_ntupleReaderMap;
 
    using indexLookup_t = std::unordered_map<uint64_t, uint64_t>;
    std::map<void*, indexLookup_t>                                         m_ntupleIndexMap;
 
  public:
    RootDatabase();

    virtual ~RootDatabase();

    TFile* file()                             { return m_file;    }
    std::string name() const;

    TTree* getTree(const std::string& name);

    const std::string& fmtVersion() const     { return m_version; }


    static bool exists(const std::string& nam);

    virtual long long int size()  const;

    void addByteCount(int which, long long int num_bytes);

    long long int byteCount(int which) const;
 
 
    StatusCode  markBranchContainerForFill(RootTreeContainer*);
    
    void        registerBranchContainer(RootTreeContainer*);
 
    uint64_t    currentIndexMasterID() const   { return m_indexMasterID; }

    uint64_t    indexSize(TBranch *branch) { return m_indexSizeMap[branch]; }

    uint64_t    indexSizeInc(TBranch *branch) { return ++m_indexSizeMap[branch]; }
 

    bool    wasIndexRebuilt(const std::string& treeName)   { return m_indexRebuilt.count(treeName)!=0; }
    void    markIndexRebuilt(const std::string& treeName)  { m_indexRebuilt.insert(treeName); };

    std::recursive_mutex& ioMutex()         { return m_iomutex; }
    

    virtual StatusCode   getOption(DbOption& opt);


    virtual StatusCode   setOption(const DbOption& opt);

    virtual StatusCode   setAutoFlush(const DbOption& opt);


    virtual StatusCode   open(const DbDomain&     domH,
                              const std::string&  nam,
                              DbAccessMode        mode);


    virtual StatusCode   reopen(DbAccessMode mode);


    virtual StatusCode   onOpen(DbDatabase& dbH, DbAccessMode      mode);


    virtual StatusCode   close(DbAccessMode mode);

    virtual StatusCode   transAct(Transaction::Action action);

    ROOT::RNTupleReader* getNTupleReader(const std::string& ntuple_name);
 
    // translate index value to row# for a given RNTuple  
    uint64_t             indexLookup(ROOT::RNTupleReader *ps, uint64_t idx_val);

    RootStorageSvc::RNTupleWriterHelper*  getNTupleWriter(const std::string& ntuple_name, bool create=false);
 
  protected:
    // Execute any pending Fills before commit or flush
    StatusCode           fillBranchContainerTrees();
 
    // Reduce branches' baskets' size to m_maxBufferSize for a give TTree
    void                 reduceBasketsSize(TTree* tree);
 
    void                 increaseBasketsSize(TTree* tree);
 
    StatusCode           close();
 
    void                 printErrno(const char* nam, int err);
   };
 
}       // End namespace pool
#endif  /* POOL_ROOTSTORAGESVC_ROOTDBASE_H */