Read event provenance data promptly as well

Author: makortel

FWCore/Framework/interface/ProductProvenanceRetriever.h

@@ -32,13 +32,15 @@ namespace edm {
                                      ModuleCallingContext const* moduleCallingContext,
                                      unsigned int transitionIndex,
                                      std::atomic<const std::set<ProductProvenance>*>& writeTo) const noexcept = 0;
+
+    virtual void unsafe_fillProvenance(unsigned int transitionIndex) const;
   };
 
   class ProductProvenanceRetriever : public ProductProvenanceLookup {
   public:
     explicit ProductProvenanceRetriever(unsigned int iTransitionIndex);
     ProductProvenanceRetriever(unsigned int iTransitionIndex, edm::ProductRegistry const&);
-    explicit ProductProvenanceRetriever(std::unique_ptr<ProvenanceReaderBase> reader);
+    explicit ProductProvenanceRetriever(unsigned int iTransitionIndex, std::unique_ptr<ProvenanceReaderBase> reader);
 
     ProductProvenanceRetriever& operator=(ProductProvenanceRetriever const&) = delete;
 
@@ -52,10 +54,13 @@ namespace edm {
 
     void readProvenanceAsync(WaitingTaskHolder task, ModuleCallingContext const* moduleCallingContext) const noexcept;
 
+    // Used in prompt reading mode to fill the branch at the same time
+    // when all event data is read
+    void unsafe_fillProvenance();
+
   private:
     std::unique_ptr<const std::set<ProductProvenance>> readProvenance() const final;
     const ProductProvenanceLookup* nextRetriever() const final { return nextRetriever_.get(); }
-    void setTransitionIndex(unsigned int transitionIndex) { transitionIndex_ = transitionIndex; }
 
     edm::propagate_const<std::shared_ptr<ProductProvenanceRetriever>> nextRetriever_;
     std::shared_ptr<const ProvenanceReaderBase> provenanceReader_;

FWCore/Framework/src/ProductProvenanceRetriever.cc

@@ -10,18 +10,21 @@
 */
 
 namespace edm {
+  void ProvenanceReaderBase::unsafe_fillProvenance(unsigned int transitionIndex) const {}
+
   ProductProvenanceRetriever::ProductProvenanceRetriever(unsigned int iTransitionIndex)
       : ProductProvenanceLookup(), nextRetriever_(), provenanceReader_(), transitionIndex_(iTransitionIndex) {}
 
   ProductProvenanceRetriever::ProductProvenanceRetriever(unsigned int iTransitionIndex,
                                                          edm::ProductRegistry const& iReg)
       : ProductProvenanceLookup(iReg), nextRetriever_(), provenanceReader_(), transitionIndex_(iTransitionIndex) {}
 
-  ProductProvenanceRetriever::ProductProvenanceRetriever(std::unique_ptr<ProvenanceReaderBase> reader)
+  ProductProvenanceRetriever::ProductProvenanceRetriever(unsigned int iTransitionIndex,
+                                                         std::unique_ptr<ProvenanceReaderBase> reader)
       : ProductProvenanceLookup(),
         nextRetriever_(),
         provenanceReader_(reader.release()),
-        transitionIndex_(std::numeric_limits<unsigned int>::max()) {
+        transitionIndex_(iTransitionIndex) {
     assert(provenanceReader_);
   }
 
@@ -86,5 +89,9 @@ namespace edm {
     parentProcessRetriever_ = &provRetriever;
   }
 
+  void ProductProvenanceRetriever::unsafe_fillProvenance() {
+    provenanceReader_->unsafe_fillProvenance(transitionIndex_);
+  }
+
   ProvenanceReaderBase::~ProvenanceReaderBase() {}
 }  // namespace edm

IOPool/Input/src/RootFile.cc

@@ -70,6 +70,7 @@
 #include <algorithm>
 #include <cassert>
 #include <list>
+#include <iostream>
 
 namespace edm {
 
@@ -1555,16 +1556,18 @@ namespace edm {
 
     // We're not done ... so prepare the EventPrincipal
     eventTree_.insertEntryForIndex(principal.transitionIndex());
+    auto provRetriever = makeProductProvenanceRetriever(principal.streamID().value());
     if (readAllProducts) {
       eventTree_.rootDelayedReader()->readAllProductsNow(&principal);
+      provRetriever->unsafe_fillProvenance();
     }
     auto history = processHistoryRegistry_->getMapped(evtAux.processHistoryID());
     principal.fillEventPrincipal(evtAux,
                                  history,
                                  std::move(eventSelectionIDs),
                                  std::move(branchListIndexes),
                                  eventToProcessBlockIndexes_,
-                                 *(makeProductProvenanceRetriever(principal.streamID().value())),
+                                 *provRetriever,
                                  eventTree_.resetAndGetRootDelayedReader());
 
     // If this next assert shows up in performance profiling or significantly affects memory, then these three lines should be deleted.
@@ -2175,7 +2178,7 @@ namespace edm {
     if (!eventProductProvenanceRetrievers_[iStreamID]) {
       // propagate_const<T> has no reset() function
       eventProductProvenanceRetrievers_[iStreamID] = std::make_shared<ProductProvenanceRetriever>(
-          provenanceReaderMaker_->makeReader(eventTree_, daqProvenanceHelper_.get()));
+          iStreamID, provenanceReaderMaker_->makeReader(eventTree_, daqProvenanceHelper_.get()));
     }
     eventProductProvenanceRetrievers_[iStreamID]->reset();
     return eventProductProvenanceRetriever(iStreamID);
@@ -2189,6 +2192,8 @@ namespace edm {
 
     std::set<ProductProvenance> readProvenance(unsigned int) const override;
 
+    void unsafe_fillProvenance(unsigned int) const override;
+
   private:
     void readProvenanceAsync(WaitingTaskHolder task,
                              ModuleCallingContext const* moduleCallingContext,
@@ -2294,8 +2299,15 @@ namespace edm {
                             rootTree_->rootDelayedReader()->postEventReadFromSourceSignal());
   }
 
+  //
+  void ReducedProvenanceReader::unsafe_fillProvenance(unsigned int transitionIndex) const {
+    ReducedProvenanceReader* me = const_cast<ReducedProvenanceReader*>(this);
+    me->rootTree_->fillBranchEntry(
+        me->provBranch_, me->rootTree_->entryNumberForIndex(transitionIndex), me->pProvVector_);
+  }
+
   std::set<ProductProvenance> ReducedProvenanceReader::readProvenance(unsigned int transitionIndex) const {
-    {
+    if (provVector_.empty()) {
       std::lock_guard<std::recursive_mutex> guard(*mutex_);
       ReducedProvenanceReader* me = const_cast<ReducedProvenanceReader*>(this);
       me->rootTree_->fillBranchEntry(
@@ -2321,6 +2333,9 @@ namespace edm {
         retValue.emplace(BranchID(prov.branchID_), parentageIDLookup_[prov.parentageIDIndex_]);
       }
     }
+    //The results of this call are cached by the caller
+    const_cast<ReducedProvenanceReader*>(this)->provVector_.clear();
+
     return retValue;
   }