[RF] Vectorize RooAbsBinning interface for bin index lookups

The `RooAbsBinning` interface for bin index lookups was changed to
enable vectorized implementations. Instead of having the override
`RooAbsBinning::binNumber()`, the binning implementations now have to
override the `RooAbsBinning::binNumbers()` function to evaluate the bin
indices of multiple values in one function call.

The interface of `RooAbsBinning::binNumbers()` is designed to facilitate
the accregation of bin indices over multiple dimensions.

The former `RooAbsBinning::binNumber()` method is now implement in terms
of the vectorized version, such that we automatically get wide test
coverage. It was verified that this doesn't come with a performance
overhead.

This will greatly facilitate the vectorization of the RooHistPdf and
RooHistFunc later.

Author: guitargeek

README/ReleaseNotes/v628/index.md

@@ -175,6 +175,11 @@ The `RooAbsMinimizerFcn` class and its implementation `RooMinimizerFcn` were rem
 These classes are implementation details of the RooMinimizer and should not be used in your code.
 In the unlikely case that this causes any problem for you, please open a GitHub issue requesting to extend the RooMinimizer by the needed functionality.
 
+### Vectorize `RooAbsBinning` interface for bin index lookups
+
+The `RooAbsBinning` interface for bin index lookups was changed to enable vectorized implementations.
+Instead of having the override `RooAbsBinning::binNumber()`, the binning implementations now have to override the `RooAbsBinning::binNumbers()` function to evaluate the bin indices of multiple values in one function call.
+
 ## 2D Graphics Libraries
 
 - Implement the option "File": The current file name is painted on the bottom right of each plot

roofit/roofitcore/inc/RooAbsBinning.h

@@ -25,20 +25,44 @@ class RooAbsReal ;
 class RooAbsBinning : public TNamed, public RooPrintable {
 public:
 
-  RooAbsBinning(const char* name=nullptr) ;
+  RooAbsBinning(const char* name=nullptr) : TNamed{name, name} {}
   RooAbsBinning(const RooAbsBinning& other, const char* name=nullptr) : TNamed(name,name), RooPrintable(other) {
     // Copy constructor
   }
   TObject* Clone(const char* newname=nullptr) const override { return clone(newname) ; }
   virtual RooAbsBinning* clone(const char* name=nullptr) const = 0 ;
-  ~RooAbsBinning() override ;
 
   /// Return number of bins.
   Int_t numBins() const {
     return numBoundaries()-1 ;
   }
   virtual Int_t numBoundaries() const = 0 ;
-  virtual Int_t binNumber(double x) const = 0 ;
+
+  /// Compute the bin indices for multiple values of `x`.
+  ///
+  /// For each element in the input, the corresponding output element will be
+  /// increased by `coef * binIdx`. This is useful for aggregating
+  /// multi-dimensional bin indices inplace.
+  ///
+  /// param[in] x The read-only input array of values of `x`.
+  /// param[out] bins The output array. Note that the initial values don't get
+  ///                 replaced! The result is added to the array elements.
+  /// param[in] n The size of the input and output arrays.
+  /// param[in] coef The multiplication factor that is applied to all calculated bin indices.
+  virtual void binNumbers(double const * x, int * bins, std::size_t n, int coef=1) const = 0 ;
+
+  /// Returns the bin number corresponding to the value `x`.
+  ///
+  /// \note This `inline` function is implemented by calling the vectorized
+  ///       function `RooAbsBinning::binNumbers()`. If you want to calculate
+  ///       the bin indices for multiple values, use that one for better
+  ///       performance.
+  inline int binNumber(double x) const {
+    int out = 0.0;
+    binNumbers(&x, &out, 1);
+    return out;
+  }
+
   virtual double binCenter(Int_t bin) const = 0 ;
   virtual double binWidth(Int_t bin) const = 0 ;
   virtual double binLow(Int_t bin) const = 0 ;

roofit/roofitcore/inc/RooBinning.h

@@ -38,7 +38,7 @@ class RooBinning : public RooAbsBinning {
   Int_t numBoundaries() const override {
     return _nbins+1;
   }
-  Int_t binNumber(double x) const override;
+  void binNumbers(double const * x, int * bins, std::size_t n, int coef) const override;
   Int_t rawBinNumber(double x) const;
   virtual double nearestBoundary(double x) const;
 

roofit/roofitcore/inc/RooLinTransBinning.h

@@ -29,7 +29,7 @@ class RooLinTransBinning : public RooAbsBinning {
   ~RooLinTransBinning() override ;
 
   Int_t numBoundaries() const override { return _input->numBoundaries() ; }
-  Int_t binNumber(double x) const override { return _input->binNumber(invTrans(x)) ; }
+  void binNumbers(double const * x, int * bins, std::size_t n, int coef) const override;
   double binCenter(Int_t bin) const override { return trans(_input->binCenter(binTrans(bin))) ; }
   double binWidth(Int_t bin) const override { return _slope*_input->binWidth(binTrans(bin)) ; }
   double binLow(Int_t bin) const override { if (_slope>0) return trans(_input->binLow(binTrans(bin))) ; else return trans(_input->binHigh(binTrans(bin))) ; }

roofit/roofitcore/inc/RooParamBinning.h

@@ -33,7 +33,7 @@ class RooParamBinning : public RooAbsBinning {
   void setRange(double xlo, double xhi) override ;
 
   Int_t numBoundaries() const override { return _nbins + 1 ; }
-  Int_t binNumber(double x) const override  ;
+  void binNumbers(double const * x, int * bins, std::size_t n, int coef) const override;
 
   double lowBound() const override { return xlo()->getVal() ; }
   double highBound() const override { return xhi()->getVal() ; }

roofit/roofitcore/inc/RooRangeBinning.h

@@ -28,7 +28,7 @@ class RooRangeBinning : public RooAbsBinning {
   ~RooRangeBinning() override ;
 
   Int_t numBoundaries() const override { return 2 ; }
-  Int_t binNumber(double) const override { return 0 ; }
+  void binNumbers(double const * /*x*/, int * /*bins*/, std::size_t /*n*/, int /*coef*/) const override {}
   double binCenter(Int_t) const override { return (_range[0] + _range[1]) / 2 ; }
   double binWidth(Int_t) const override { return (_range[1] - _range[0]) ; }
   double binLow(Int_t) const override { return _range[0] ; }

roofit/roofitcore/inc/RooUniformBinning.h

@@ -31,7 +31,7 @@ class RooUniformBinning : public RooAbsBinning {
   void setRange(double xlo, double xhi) override ;
 
   Int_t numBoundaries() const override { return _nbins + 1 ; }
-  Int_t binNumber(double x) const override  ;
+  void binNumbers(double const * x, int * bins, std::size_t n, int coef) const override;
   bool isUniform() const override { return true ; }
 
   double lowBound() const override { return _xlo ; }

roofit/roofitcore/src/RooAbsBinning.cxx

@@ -34,24 +34,6 @@ This class defines the interface to retrieve bin boundaries, ranges etc.
 using namespace std;
 
 ClassImp(RooAbsBinning);
-;
-
-
-////////////////////////////////////////////////////////////////////////////////
-/// Constructor
-
-RooAbsBinning::RooAbsBinning(const char* name) : TNamed(name,name)
-{
-}
-
-
-
-////////////////////////////////////////////////////////////////////////////////
-/// Destructor
-
-RooAbsBinning::~RooAbsBinning()
-{
-}
 
 
 

roofit/roofitcore/src/RooBinning.cxx

@@ -185,9 +185,11 @@ inline int rawBinNumberImpl(double x, std::vector<double> const& boundaries) {
 /// zero is the first bin with an upper boundary above the lower bound
 /// of the range
 
-Int_t RooBinning::binNumber(double x) const
+void RooBinning::binNumbers(double const * x, int * bins, std::size_t n, int coef) const
 {
-  return std::max(0, std::min(_nbins, rawBinNumberImpl(x, _boundaries) - _blo));
+  for(std::size_t i = 0; i < n; ++i) {
+    bins[i] += coef * (std::max(0, std::min(_nbins, rawBinNumberImpl(x[i], _boundaries) - _blo)));
+  }
 }
 
 ////////////////////////////////////////////////////////////////////////////////

roofit/roofitcore/src/RooLinTransBinning.cxx

@@ -26,6 +26,8 @@ way that RooLinearVar does
 
 #include "RooLinTransBinning.h"
 
+#include <stdexcept>
+
 using namespace std;
 
 ClassImp(RooLinTransBinning);
@@ -113,3 +115,15 @@ void RooLinTransBinning::updateInput(const RooAbsBinning& input, double slope, d
   _offset = offset ;
 }
 
+
+void RooLinTransBinning::binNumbers(double const * x, int * bins, std::size_t n, int coef) const
+{
+  // We are not allowed to modify the input array, so we can't apply the
+  // transformation in-place and then call _input->binNumbers() without
+  // allocating additional memory. That's why we fall back to binNumber() for
+  // now. The RooLinTransBinning is only ever used in the RooLinearVar, so if
+  // this ever becomes a bottleneck this could be optimized.
+  for(std::size_t i = 0; i < n; ++i) {
+    bins[i] += coef * _input->binNumber(invTrans(x[i]));
+  }
+}