[df] Avoid unnecessary duplication of JIT lines

When accumulating code to JIT for Define, Filter and Vary nodes, the
current logic embeds the name of e.g. the new column to define as part
of the function body that will go into the accumulated code to JIT. This
in turn means that every time we call a Define, there will be a
corresponding code to JIT, as well as a corresponding function body that
will go into the newly created cache for the JIT node registrators.

This can be optimised by avoiding to store the names as part of the
function body, thus allowing a much more aggressive caching. In a simple
example such as:

```
ROOT::RDataFrame root(1);
std::vector<ROOT::RDF::RResultPtr<double>> dfs;
const auto n = 10000;
for (auto i = 0u; i < n; i++) {
    const auto column = "x" + std::to_string(i);
    auto define = root.Define(column, "42.f");
    auto filter = define.Filter(column + " > 0.f");
    auto sum = filter.Sum(column);
    dfs.emplace_back(sum);
}
dfs[n - 1].GetValue();
```

This commit changes the previous situation that would have had 10K JIT
function bodies, i.e. one per Define with a different column name, down
to one function body to JIT for the lambda returning 42.f.

Author: vepadulano

tree/dataframe/inc/ROOT/RDF/InterfaceUtils.hxx

@@ -469,7 +469,7 @@ void AddDSColumns(const std::vector<std::string> &requiredCols, ROOT::Detail::RD
 
 // this function is meant to be called by the jitted code generated by BookFilterJit
 template <typename F>
-void JitFilterHelper(F &&f, const ColumnNames_t &cols, std::string_view name, RColumnRegister &colRegister,
+void JitFilterHelper(F &&f, const ColumnNames_t &cols, RColumnRegister &colRegister,
                      ROOT::Detail::RDF::RLoopManager &lm, ROOT::Detail::RDF::RJittedFilter *jittedFilter) noexcept
 {
    if (!jittedFilter) {
@@ -493,7 +493,7 @@ void JitFilterHelper(F &&f, const ColumnNames_t &cols, std::string_view name, RC
       AddDSColumns(cols, lm, *ds, ColTypes_t(), colRegister);
 
    jittedFilter->SetFilter(
-      std::unique_ptr<RFilterBase>(new F_t(std::forward<F>(f), cols, prevNode, colRegister, name)));
+      std::unique_ptr<RFilterBase>(new F_t(std::forward<F>(f), cols, prevNode, colRegister, jittedFilter->GetName())));
 }
 
 namespace DefineTypes {
@@ -521,7 +521,7 @@ auto MakeDefineNode(DefineTypes::RDefinePerSampleTag, std::string_view name, std
 // This function is meant to be called by jitted code right before starting the event loop.
 // If colsPtr is null, build a RDefinePerSample (it has no input columns), otherwise a RDefine.
 template <typename RDefineTypeTag, typename F>
-void JitDefineHelper(F &&f, const ColumnNames_t &cols, std::string_view name, RColumnRegister &colRegister,
+void JitDefineHelper(F &&f, const ColumnNames_t &cols, RColumnRegister &colRegister,
                      ROOT::Detail::RDF::RLoopManager &lm, ROOT::Detail::RDF::RJittedDefine *jittedDefine) noexcept
 {
 
@@ -543,15 +543,14 @@ void JitDefineHelper(F &&f, const ColumnNames_t &cols, std::string_view name, RC
    const auto dummyType = "jittedCol_t";
    // use unique_ptr<RDefineBase> instead of make_unique<NewCol_t> to reduce jit/compile-times
    std::unique_ptr<RDefineBase> newCol{
-      MakeDefineNode(RDefineTypeTag{}, name, dummyType, std::forward<F>(f), cols, colRegister, lm)};
+      MakeDefineNode(RDefineTypeTag{}, jittedDefine->GetName(), dummyType, std::forward<F>(f), cols, colRegister, lm)};
    jittedDefine->SetDefine(std::move(newCol));
 }
 
 template <bool IsSingleColumn, typename F>
-void JitVariationHelper(F &&f, const ColumnNames_t &inputColNames, std::string_view variationName,
-                        RColumnRegister &colRegister, ROOT::Detail::RDF::RLoopManager &lm,
-                        RJittedVariation *jittedVariation, const ColumnNames_t &variedColNames,
-                        const ColumnNames_t &variationTags) noexcept
+void JitVariationHelper(F &&f, const ColumnNames_t &inputColNames, RColumnRegister &colRegister,
+                        ROOT::Detail::RDF::RLoopManager &lm, RJittedVariation *jittedVariation,
+                        const ColumnNames_t &variedColNames, const ColumnNames_t &variationTags) noexcept
 {
 
    if (!jittedVariation) {
@@ -568,9 +567,9 @@ void JitVariationHelper(F &&f, const ColumnNames_t &inputColNames, std::string_v
       AddDSColumns(inputColNames, lm, *ds, ColTypes_t(), colRegister);
 
    // use unique_ptr<RDefineBase> instead of make_unique<NewCol_t> to reduce jit/compile-times
-   std::unique_ptr<RVariationBase> newVariation{
-      new RVariation<std::decay_t<F>, IsSingleColumn>(variedColNames, variationName, std::forward<F>(f), variationTags,
-                                                      jittedVariation->GetTypeName(), colRegister, lm, inputColNames)};
+   std::unique_ptr<RVariationBase> newVariation{new RVariation<std::decay_t<F>, IsSingleColumn>(
+      variedColNames, jittedVariation->GetVariationName(), std::forward<F>(f), variationTags,
+      jittedVariation->GetTypeName(), colRegister, lm, inputColNames)};
    jittedVariation->SetVariation(std::move(newVariation));
 }
 

tree/dataframe/inc/ROOT/RDF/RVariationBase.hxx

@@ -39,7 +39,8 @@ namespace RDF {
 class RVariationBase {
 protected:
    std::vector<std::string> fColNames;       ///< The names of the varied columns.
-   std::vector<std::string> fVariationNames; ///< The names of the systematic variation.
+   std::vector<std::string> fVariationNames; ///< The tags of the systematic variation.
+   std::string fVariationName;               ///< The name of the systematic variation.
    std::string fType;                        ///< The type of the custom column as a text string.
    std::vector<Long64_t> fLastCheckedEntry;
    RColumnRegister fColumnRegister;
@@ -66,6 +67,7 @@ public:
    virtual const std::type_info &GetTypeId() const = 0;
    const std::vector<std::string> &GetColumnNames() const;
    const std::vector<std::string> &GetVariationNames() const;
+   const std::string &GetVariationName() const;
    std::string GetTypeName() const;
    /// Update the value at the address returned by GetValuePtr with the content corresponding to the given entry
    virtual void Update(unsigned int slot, Long64_t entry) = 0;

tree/dataframe/src/RDFInterfaceUtils.cxx

@@ -643,7 +643,6 @@ BookFilterJit(std::shared_ptr<RDFDetail::RNodeBase> prevNode, std::string_view n
                     << "std::shared_ptr<void> *) {\n";
    filterInvocation << "   ROOT::Internal::RDF::JitFilterHelper(" << funcName << ", "
                     << "colNames, "
-                    << "\"" << name << "\", "
                     << "colRegister, "
                     << "lm, "
                     << "reinterpret_cast<ROOT::Detail::RDF::RJittedFilter*>(jittedFilter)"
@@ -682,7 +681,6 @@ std::shared_ptr<RJittedDefine> BookDefineJit(std::string_view name, std::string_
    defineInvocation << "   ROOT::Internal::RDF::JitDefineHelper<ROOT::Internal::RDF::DefineTypes::RDefineTag>("
                     << funcName << ", "
                     << "colNames, "
-                    << "\"" << name << "\", "
                     << "colRegister, "
                     << "lm, "
                     << "reinterpret_cast<ROOT::Detail::RDF::RJittedDefine *>(jittedDefine)"
@@ -716,7 +714,6 @@ std::shared_ptr<RJittedDefine> BookDefinePerSampleJit(std::string_view name, std
    defineInvocation << "   ROOT::Internal::RDF::JitDefineHelper<ROOT::Internal::RDF::DefineTypes::RDefinePerSampleTag>("
                     << funcName << ", "
                     << "colNames, "
-                    << "\"" << name << "\", "
                     << "colRegister, "
                     << "lm, "
                     << "reinterpret_cast<ROOT::Detail::RDF::RJittedDefine *>(jittedDefine)"
@@ -768,7 +765,6 @@ BookVariationJit(const std::vector<std::string> &colNames, std::string_view vari
       << "   ROOT::Internal::RDF::JitVariationHelper<" << (isSingleColumn ? "true" : "false") << ">(" << funcName
       << ", "
       << "inputColNames, "
-      << "\"" << variationName << "\", "
       << "colRegister, "
       << "lm, "
       << "reinterpret_cast<ROOT::Internal::RDF::RJittedVariation *>(jittedVariation), "

tree/dataframe/src/RVariationBase.cxx

@@ -27,13 +27,19 @@ namespace RDF {
 RVariationBase::RVariationBase(const std::vector<std::string> &colNames, std::string_view variationName,
                                const std::vector<std::string> &variationTags, std::string_view type,
                                const RColumnRegister &colRegister, RLoopManager &lm, const ColumnNames_t &inputColNames)
-   : fColNames(colNames), fVariationNames(variationTags), fType(type),
-     fLastCheckedEntry(lm.GetNSlots() * CacheLineStep<Long64_t>(), -1), fColumnRegister(colRegister), fLoopManager(&lm),
-     fInputColumns(inputColNames), fIsDefine(inputColNames.size())
+   : fColNames(colNames),
+     fVariationNames(variationTags),
+     fVariationName(variationName),
+     fType(type),
+     fLastCheckedEntry(lm.GetNSlots() * CacheLineStep<Long64_t>(), -1),
+     fColumnRegister(colRegister),
+     fLoopManager(&lm),
+     fInputColumns(inputColNames),
+     fIsDefine(inputColNames.size())
 {
    // prepend the variation name to each tag
    for (auto &tag : fVariationNames)
-      tag = std::string(variationName) + ':' + tag;
+      tag = std::string(fVariationName) + ':' + tag;
 
    const auto nColumns = fInputColumns.size();
    for (auto i = 0u; i < nColumns; ++i)
@@ -52,6 +58,11 @@ const std::vector<std::string> &RVariationBase::GetVariationNames() const
    return fVariationNames;
 }
 
+const std::string &RVariationBase::GetVariationName() const
+{
+   return fVariationName;
+}
+
 std::string RVariationBase::GetTypeName() const
 {
    return fType;