[RF] Include evaluateSpan() fallback test in AddPdf benchmark.

When a PDF doesn't provide a fast batch evaluation function
(evaluateSpan() overridden), a slower fallback is used. The benchmark
for Gauss + Exp using AddPdf is extended to include this fallback test.

Further, less iterations are run to speed up the overall execution time,
and parameter sets are precomputed in order to avoid starting and
stopping the benchmark timers.

Co-authored-by: Jonas Rembser <[email protected]>

Author: hageboeck

root/roofit/vectorisedPDFs/SlowRooExponential.h

@@ -0,0 +1,62 @@
+#include "RooAbsPdf.h"
+#include "RooRealProxy.h"
+
+class RooRealVar;
+class RooAbsReal;
+
+/// A slow implementation of RooExponential that doesn't support batch evaluation.
+class SlowRooExponential : public RooAbsPdf {
+public:
+  SlowRooExponential() {}
+  SlowRooExponential(const char *name, const char *title, RooAbsReal& _x, RooAbsReal& _c) :
+    RooAbsPdf(name, title),
+    x("x","Dependent",this,_x),
+    c("c","Exponent",this,_c) { }
+
+  SlowRooExponential(const SlowRooExponential& other, const char* name) :
+    RooAbsPdf(other, name), x("x",this,other.x), c("c",this,other.c) { }
+
+  virtual TObject* clone(const char* newname) const override { return new SlowRooExponential(*this,newname); }
+  inline virtual ~SlowRooExponential() { }
+
+  Int_t getAnalyticalIntegral(RooArgSet& allVars, RooArgSet& analVars, const char* rangeName=0) const override;
+  Double_t analyticalIntegral(Int_t code, const char* rangeName=0) const override;
+
+protected:
+  RooRealProxy x;
+  RooRealProxy c;
+
+  Double_t evaluate() const override;
+};
+
+#include "RooRealVar.h"
+#include "RooBatchCompute.h"
+
+#include <cmath>
+using namespace std;
+
+Double_t SlowRooExponential::evaluate() const{
+  return exp(c*x);
+}
+
+Int_t SlowRooExponential::getAnalyticalIntegral(RooArgSet& allVars, RooArgSet& analVars, const char* /*rangeName*/) const
+{
+  if (matchArgs(allVars,analVars,x)) return 1;
+  if (matchArgs(allVars,analVars,c)) return 2;
+  return 0 ;
+}
+
+Double_t SlowRooExponential::analyticalIntegral(Int_t code, const char* rangeName) const
+{
+  assert(code == 1 || code ==2);
+
+  auto& constant  = code == 1 ? c : x;
+  auto& integrand = code == 1 ? x : c;
+
+  if (constant == 0.0) {
+    return integrand.max(rangeName) - integrand.min(rangeName);
+  }
+
+  return (exp(constant*integrand.max(rangeName)) - exp(constant*integrand.min(rangeName)))
+      / constant;
+}

root/roofit/vectorisedPDFs/benchAddPdf.cxx

@@ -19,8 +19,8 @@
  * Benchmark a simple mock fit model
  *    sum(x) = frac * Gauss(x) + (1-frac) * Exponential(x)
  *
- * Run 6 different workflows:
- * 0. Evaluate fit model for 2 M data events with batch data loading and SIMD (if compiler flags activated).
+ * We can run 6 different workflows:
+ * 0. Evaluate fit model for 1 M data events with batch data loading and SIMD (if compiler flags activated).
  * 1. As above, but use old RooFit strategy of single-value data loading.
  * 2. Compute probabilities for each data event. That is, run step 0 and normalise values.
  * 3. As above, but use old RooFit strategy.
@@ -38,8 +38,10 @@
 #include "RooExponential.h"
 #include "RooDataSet.h"
 #include "RunContext.h"
-
 #include "RooRandom.h"
+
+#include "SlowRooExponential.h"
+
 void randomiseParameters(const RooArgSet& parameters, ULong_t seed=0) {
   auto random = RooRandom::randomGenerator();
   if (seed != 0)
@@ -61,9 +63,10 @@ enum RunConfig_t {runBatchUnnorm = 0, runSingleUnnorm = 1,
 
 
 static void benchAddPdfGaussExp(benchmark::State& state) {
-  RunConfig_t runConfig = static_cast<RunConfig_t>(state.range(0));
-  constexpr std::size_t nParamSets = 30;
-  constexpr std::size_t nEvents = 2000000;
+  const RunConfig_t runConfig = static_cast<RunConfig_t>(state.range(0));
+  const bool useSlowRooExponential = state.range(1);
+  constexpr std::size_t nParamSets = 3;
+  constexpr std::size_t nEvents = 1000000;
 
   // Declare variables x,mean,sigma with associated name, title, initial value and allowed range
   RooRealVar x("x", "x", -1.5, 40.5);
@@ -75,10 +78,15 @@ static void benchAddPdfGaussExp(benchmark::State& state) {
   RooGaussian gauss("gauss", "gaussian PDF", x, mean, sigma);
 
   RooRealVar c1("c1", "Decay constant", -0.5, -10, -0.001);
-  RooExponential ex("Pois", "Poisson PDF", x, c1);
+  std::unique_ptr<RooAbsPdf> ex;
+  if (useSlowRooExponential) {
+    ex = std::make_unique<SlowRooExponential>("Pois", "Poisson PDF", x, c1);
+  } else {
+    ex = std::make_unique<RooExponential>("Pois", "Poisson PDF", x, c1);
+  }
 
   RooRealVar fractionGaus("fractionGaus", "Fraction of Gauss component", 0.5, 0., 1.);
-  RooAddPdf pdf("SumGausPois", "Sum of Gaus and Poisson", RooArgSet(gauss, ex), fractionGaus);
+  RooAddPdf pdf("SumGausPois", "Sum of Gaus and Poisson", RooArgSet(gauss, *ex), fractionGaus);
   // to avoid a warning when computing the   unnormalized RooAddPdf values
   pdf.fixCoefNormalization(x);
 
@@ -92,15 +100,19 @@ static void benchAddPdfGaussExp(benchmark::State& state) {
   RooBatchCompute::RunContext evalData;
   std::vector<double> results(nEvents);
 
+  std::array<RooArgSet, nParamSets> paramSets;
+  unsigned int seed = 1337;
+  for (auto& paramSet : paramSets) {
+    randomiseParameters(parameters, seed++);
+    parameters.snapshot(paramSet);
+  }
+
   for (auto _ : state) {
-    for (unsigned int paramSetIndex=0; paramSetIndex < nParamSets; ++paramSetIndex) {
-      state.PauseTiming();
-      randomiseParameters(parameters, 1337+paramSetIndex);
-      state.ResumeTiming();
+    for (const auto& paramSet : paramSets) {
+      parameters = paramSet;
 
       evalData.clear();
       data->getBatches(evalData, 0, data->numEntries());
-      runConfig = static_cast<RunConfig_t>(runConfig % 6);
 
       if (runConfig == runBatchUnnorm) {
         auto batchResult = pdf.getValues(evalData, nullptr);
@@ -134,14 +146,17 @@ static void benchAddPdfGaussExp(benchmark::State& state) {
   }
 };
 
-BENCHMARK(benchAddPdfGaussExp)->Unit(benchmark::kMillisecond)
-        ->Args({runBatchUnnorm})
-        ->Args({runSingleUnnorm})
-        ->Args({runBatchNorm})
-        ->Args({runSingleNorm})
-        ->Args({runBatchNormLogs})
-        ->Args({runSingleNormLogs})
-    ;
+BENCHMARK(benchAddPdfGaussExp)->Name("Gauss+Exp")->Unit(benchmark::kMillisecond)
+        ->Args({runBatchNorm, false})
+        ->Args({runSingleNorm, false})
+        ->Args({runBatchNormLogs, false})
+        ->Args({runSingleNormLogs, false});
+BENCHMARK(benchAddPdfGaussExp)->Name("Gauss+Exp(evaluateSpan fallback)")->Unit(benchmark::kMillisecond)
+        ->Args({runBatchNorm, true})
+        ->Args({runSingleNorm, true})
+        ->Args({runBatchNormLogs, true})
+        ->Args({runSingleNormLogs, true});
+
 
 
 BENCHMARK_MAIN();