Use separate TTreeCache for auxiliary branch

Author: Dr15Jones

IOPool/Input/src/RootTree.cc

@@ -410,6 +410,23 @@ namespace edm {
       return treeCache_.get();
     }
   }
+  TTreeCache* RootTree::getAuxCache(TBranch* auxBranch) const {
+    if (not auxCache_ and cacheSize_ > 0) {
+      tree_->SetCacheSize(1 * 1024 * 1024);
+      auxCache_.reset(dynamic_cast<TTreeCache*>(filePtr_->GetCacheRead(tree_)));
+      if (auxCache_) {
+        auxCache_->SetEnablePrefetching(enablePrefetching_);
+        auxCache_->SetEnablePrefetching(false);
+        filePtr_->SetCacheRead(nullptr, tree_);
+        auxCache_->SetLearnEntries(0);
+        auxCache_->StartLearningPhase();
+        auxCache_->SetEntryRange(0, tree_->GetEntries());
+        auxCache_->AddBranch(auxBranch->GetName(), kTRUE);
+        auxCache_->StopLearningPhase();
+      }
+    }
+    return auxCache_.get();
+  }
 
   void RootTree::getEntryForAllBranches() const {
     filePtr_->SetCacheRead(rawTreeCache_.get(), tree_);
@@ -420,8 +437,11 @@ namespace edm {
   }
 
   void RootTree::getEntry(TBranch* branch, EntryNumber entryNumber) const {
+    getEntryUsingCache(branch, entryNumber, selectCache(branch, entryNumber));
+  }
+
+  inline void RootTree::getEntryUsingCache(TBranch* branch, EntryNumber entryNumber, TTreeCache* cache) const {
     try {
-      TTreeCache* cache = selectCache(branch, entryNumber);
       filePtr_->SetCacheRead(cache, tree_);
       branch->GetEntry(entryNumber);
       filePtr_->SetCacheRead(nullptr, tree_);
@@ -529,6 +549,7 @@ namespace edm {
     rawTreeCache_.reset();
     triggerTreeCache_.reset();
     rawTriggerTreeCache_.reset();
+    auxCache_.reset();
     // We give up our shared ownership of the TFile itself.
     filePtr_.reset();
   }

IOPool/Input/src/RootTree.h

@@ -150,7 +150,8 @@ namespace edm {
     template <typename T>
     void fillAux(T*& pAux) {
       auxBranch_->SetAddress(&pAux);
-      getEntry(auxBranch_, entryNumber_);
+      auto cache = getAuxCache(auxBranch_);
+      getEntryUsingCache(auxBranch_, entryNumber_, cache);
       auxBranch_->SetAddress(nullptr);
     }
 
@@ -213,6 +214,8 @@ namespace edm {
     void setTreeMaxVirtualSize(int treeMaxVirtualSize);
     void startTraining();
     void stopTraining();
+    void getEntryUsingCache(TBranch* branch, EntryNumber entry, TTreeCache*) const;
+    TTreeCache* getAuxCache(TBranch* auxBranch) const;
 
     std::shared_ptr<InputFile> filePtr_;
     // We use bare pointers for pointers to some ROOT entities.
@@ -228,6 +231,7 @@ namespace edm {
     // So, we make sure to it is detached before closing the TFile so there is no double delete.
     std::shared_ptr<TTreeCache> treeCache_;
     std::shared_ptr<TTreeCache> rawTreeCache_;
+    CMS_SA_ALLOW mutable std::shared_ptr<TTreeCache> auxCache_;
     //All access to a ROOT file is serialized
     CMS_SA_ALLOW mutable std::shared_ptr<TTreeCache> triggerTreeCache_;
     CMS_SA_ALLOW mutable std::shared_ptr<TTreeCache> rawTriggerTreeCache_;