ROOT/RDF/RRange.hxx

0001 // Author: Enrico Guiraud, Danilo Piparo CERN  09/2018
0002
0003 /*************************************************************************
0004  * Copyright (C) 1995-2018, Rene Brun and Fons Rademakers.               *
0005  * All rights reserved.                                                  *
0006  *                                                                       *
0007  * For the licensing terms see $ROOTSYS/LICENSE.                         *
0008  * For the list of contributors see $ROOTSYS/README/CREDITS.             *
0009  *************************************************************************/
0010
0011 #ifndef ROOT_RDFRANGE
0012 #define ROOT_RDFRANGE
0013
0014 #include "ROOT/RDF/RLoopManager.hxx"
0015 #include "ROOT/RDF/RRangeBase.hxx"
0016 #include "ROOT/RDF/Utils.hxx"
0017 #include "RtypesCore.h"
0018
0019 #include <cassert>
0020 #include <memory>
0021 #include <string>
0022 #include <string_view>
0023 #include <vector>
0024
0025 namespace ROOT {
0026
0027 // fwd decl
0028 namespace Internal {
0029 namespace RDF {
0030 namespace GraphDrawing {
0031 std::shared_ptr<GraphNode> CreateRangeNode(const ROOT::Detail::RDF::RRangeBase *rangePtr,
0032                                            std::unordered_map<void *, std::shared_ptr<GraphNode>> &visitedMap);
0033 } // ns GraphDrawing
0034 } // ns RDF
0035 } // ns Internal
0036
0037 namespace Detail {
0038 namespace RDF {
0039 namespace RDFGraphDrawing = ROOT::Internal::RDF::GraphDrawing;
0040 class RJittedFilter;
0041
0042 template <typename PrevNodeRaw>
0043 class RRange final : public RRangeBase {
0044    // If the PrevNode is a RJittedFilter, treat it as a more generic RFilterBase: when dealing with systematic
0045    // variations we'll have a RJittedFilter node for the nominal case but other "universes" will use concrete filters,
0046    // so we normalize the "previous node type" to the base type RFilterBase.
0047    using PrevNode_t = std::conditional_t<std::is_same<PrevNodeRaw, RJittedFilter>::value, RFilterBase, PrevNodeRaw>;
0048    const std::shared_ptr<PrevNode_t> fPrevNodePtr;
0049    PrevNode_t &fPrevNode;
0050
0051 public:
0052    RRange(unsigned int start, unsigned int stop, unsigned int stride, std::shared_ptr<PrevNode_t> pd)
0053       : RRangeBase(pd->GetLoopManagerUnchecked(), start, stop, stride, pd->GetLoopManagerUnchecked()->GetNSlots(),
0054                    pd->GetVariations()),
0055         fPrevNodePtr(std::move(pd)), fPrevNode(*fPrevNodePtr)
0056    {
0057       fLoopManager->Register(this);
0058    }
0059
0060    // Rule of five
0061
0062    RRange(const RRange &) = delete;
0063    RRange &operator=(const RRange &) = delete;
0064    RRange(RRange &&) = delete;
0065    RRange &operator=(RRange &&) = delete;
0066    // must call Deregister here, before fPrevNode is destroyed,
0067    // otherwise if fPrevNode is fLoopManager we get a use after delete
0068    ~RRange() final { fLoopManager->Deregister(this); }
0069
0070    /// Ranges act as filters when it comes to selecting entries that downstream nodes should process
0071    bool CheckFilters(unsigned int slot, Long64_t entry) final
0072    {
0073       if (entry != fLastCheckedEntry) {
0074          if (fHasStopped)
0075             return false;
0076          if (!fPrevNode.CheckFilters(slot, entry)) {
0077             // a filter upstream returned false, cache the result
0078             fLastResult = false;
0079          } else {
0080             // apply range filter logic, cache the result
0081             if (fNProcessedEntries < fStart || (fStop > 0 && fNProcessedEntries >= fStop) ||
0082                 (fStride != 1 && (fNProcessedEntries - fStart) % fStride != 0))
0083                fLastResult = false;
0084             else
0085                fLastResult = true;
0086             ++fNProcessedEntries;
0087             if (fNProcessedEntries == fStop) {
0088                fHasStopped = true;
0089                fPrevNode.StopProcessing();
0090             }
0091          }
0092          fLastCheckedEntry = entry;
0093       }
0094       return fLastResult;
0095    }
0096
0097    // recursive chain of `Report`s
0098    // RRange simply forwards these calls to the previous node
0099    void Report(ROOT::RDF::RCutFlowReport &rep) const final { fPrevNode.PartialReport(rep); }
0100
0101    void PartialReport(ROOT::RDF::RCutFlowReport &rep) const final { fPrevNode.PartialReport(rep); }
0102
0103    void StopProcessing() final
0104    {
0105       ++fNStopsReceived;
0106       if (fNStopsReceived == fNChildren && !fHasStopped)
0107          fPrevNode.StopProcessing();
0108    }
0109
0110    void IncrChildrenCount() final
0111    {
0112       ++fNChildren;
0113       // propagate "children activation" upstream
0114       if (fNChildren == 1)
0115          fPrevNode.IncrChildrenCount();
0116    }
0117
0118    /// This function must be defined by all nodes, but only the filters will add their name
0119    void AddFilterName(std::vector<std::string> &filters) final { fPrevNode.AddFilterName(filters); }
0120    std::shared_ptr<RDFGraphDrawing::GraphNode>
0121    GetGraph(std::unordered_map<void *, std::shared_ptr<RDFGraphDrawing::GraphNode>> &visitedMap) final
0122    {
0123       // TODO: Ranges node have no information about custom columns, hence it is not possible now
0124       // if defines have been used before.
0125       auto prevNode = fPrevNode.GetGraph(visitedMap);
0126       const auto &prevColumns = prevNode->GetDefinedColumns();
0127
0128       auto thisNode = RDFGraphDrawing::CreateRangeNode(this, visitedMap);
0129
0130       /* If the returned node is not new, there is no need to perform any other operation.
0131        * This is a likely scenario when building the entire graph in which branches share
0132        * some nodes. */
0133       if (!thisNode->IsNew()) {
0134          return thisNode;
0135       }
0136       thisNode->SetPrevNode(prevNode);
0137
0138       // If there have been some defines between the last Filter and this Range node we won't detect them:
0139       // Ranges don't keep track of Defines (they have no RColumnRegister data member).
0140       // Let's pretend that the Defines of this node are the same as the node above, so that in the graph
0141       // the Defines will just appear below the Range instead (no functional change).
0142       // TODO: Converting the string_views for backward compatibility.
0143       // Since they are names of defined columns, they were added to the
0144       // register of column names of the RLoopManager object by the
0145       // RColumnRegister, so we could also change GetDefinedColumns to return string_views directly
0146       std::vector<std::string_view> colsViews;
0147       colsViews.reserve(prevColumns.size());
0148       for (const auto &col : prevColumns)
0149          colsViews.push_back(col);
0150       thisNode->AddDefinedColumns(colsViews);
0151
0152       return thisNode;
0153    }
0154
0155    std::shared_ptr<RNodeBase> GetVariedFilter(const std::string &variationName) final
0156    {
0157       // nobody should ask for a varied filter for the nominal variation: they can just
0158       // use the nominal filter!
0159       assert(variationName != "nominal");
0160       // nobody should ask for a varied filter for a variation on which this filter does not depend:
0161       // they can just use the nominal filter.
0162       assert(RDFInternal::IsStrInVec(variationName, fVariations));
0163
0164       auto it = fVariedRanges.find(variationName);
0165       if (it != fVariedRanges.end())
0166          return it->second;
0167
0168       auto prevNode = fPrevNodePtr;
0169       if (static_cast<RNodeBase *>(fPrevNodePtr.get()) != static_cast<RNodeBase *>(fLoopManager) &&
0170           RDFInternal::IsStrInVec(variationName, prevNode->GetVariations()))
0171          prevNode = std::static_pointer_cast<PrevNode_t>(prevNode->GetVariedFilter(variationName));
0172
0173       auto variedRange = std::unique_ptr<RRangeBase>(new RRange(fStart, fStop, fStride, std::move(prevNode)));
0174       auto e = fVariedRanges.insert({variationName, std::move(variedRange)});
0175       return e.first->second;
0176    }
0177 };
0178
0179 } // namespace RDF
0180 } // namespace Detail
0181 } // namespace ROOT
0182
0183 #endif // ROOT_RDFRANGE