[Math] Move TimingScope to ROOT::Math::Util

Move TimingScope to `ROOT::Math::Util` in MathCore to avoid code
duplication while at the same time not introducing new dependencies
(MathCore is the only dependency that Minuit2 is allowed to have because
of the standalone build possibility).

Author: guitargeek

math/mathcore/CMakeLists.txt

@@ -189,6 +189,7 @@ ROOT_STANDARD_LIBRARY_PACKAGE(MathCore
     src/TRandomGen.cxx
     src/TStatistic.cxx
     src/UnBinData.cxx
+    src/Util.cxx
     src/VectorizedTMath.cxx
   LIBRARIES
     ${MATHCORE_LIBRARIES}

math/mathcore/inc/Math/Util.h

@@ -13,12 +13,12 @@
 #ifndef ROOT_Math_Util
 #define ROOT_Math_Util
 
-#include <string>
-#include <sstream>
-
 #include <cmath>
+#include <functional>
 #include <limits>
 #include <numeric>
+#include <sstream>
+#include <string>
 
 
 // This can be protected against by defining ROOT_Math_VecTypes
@@ -36,12 +36,25 @@
 
 namespace ROOT {
 
-   namespace Math {
+namespace Math {
 
-   /**
-      namespace defining Utility functions needed by mathcore
-   */
-   namespace Util {
+/**
+   namespace defining Utility functions needed by mathcore
+*/
+namespace Util {
+
+class TimingScope {
+
+public:
+   TimingScope(std::function<void(std::string const&)> printer, std::string const &message);
+
+   ~TimingScope();
+
+private:
+   void *fBegin;
+   std::function<void(std::string const&)> fPrinter;
+   const std::string fMessage;
+};
 
    /**
       Utility function for conversion to strings

math/mathcore/src/Util.cxx

@@ -0,0 +1,68 @@
+#include "Math/Util.h"
+
+#include <chrono>
+
+ROOT::Math::Util::TimingScope::TimingScope(std::function<void(std::string const &)> printer, std::string const &message)
+   : fPrinter{printer}, fMessage{message}
+{
+   using std::chrono::steady_clock;
+   fBegin = new steady_clock::time_point{steady_clock::now()};
+}
+
+namespace {
+
+template <class T>
+std::string printTime(T duration)
+{
+   std::stringstream ss;
+   // Here, nanoseconds are represented as "long int", so the maximum value
+   // corresponds to about 300 years. Nobody will wait that long for a
+   // computation to complete, so for timing measurements it's fine to cast to
+   // nanoseconds to keep things simple.
+   double ns = std::chrono::duration_cast<std::chrono::nanoseconds>(duration).count();
+   bool forceSeconds = false;
+   // The largest unit that we consider for pretty-printing is days.
+   if (ns >= 24 * 60 * 60e9) {
+      auto days = std::floor(ns / (24 * 60 * 60e9));
+      ss << days << " d ";
+      ns -= days * 24 * 60 * 60e9; // subtract the days to print only the rest
+      // to avoid printouts like "1 d 4 h 23 min 324 ns", we force to print
+      // seconds if we print either days, hours, or minutes
+      forceSeconds = true;
+   }
+   if (ns >= 60 * 60e9) {
+      auto hours = std::floor(ns / (60 * 60e9));
+      ss << hours << " h ";
+      ns -= hours * 60 * 60e9;
+      forceSeconds = true;
+   }
+   if (ns >= 60e9) {
+      auto minutes = std::floor(ns / 60e9);
+      ss << minutes << " min ";
+      ns -= minutes * 60e9;
+      forceSeconds = true;
+   }
+   if (ns >= 1e9 || forceSeconds) {
+      ss << (1e-9 * ns) << " s";
+   } else if (ns >= 1e6) {
+      ss << (1e-6 * ns) << " ms";
+   } else if (ns >= 1e3) {
+      ss << (1e-3 * ns) << " μs";
+   } else {
+      ss << ns << " ns";
+   }
+   return ss.str();
+}
+
+} // namespace
+
+ROOT::Math::Util::TimingScope::~TimingScope()
+{
+   using std::chrono::steady_clock;
+   auto *begin = reinterpret_cast<steady_clock::time_point *>(fBegin);
+   steady_clock::time_point end = steady_clock::now();
+   std::stringstream ss;
+   ss << fMessage << " " << printTime(end - *begin);
+   fPrinter(ss.str());
+   delete begin;
+}

math/minuit2/inc/Minuit2/MnPrint.h

@@ -13,12 +13,12 @@
 #include "Minuit2/MnConfig.h"
 
 #include <cassert>
-#include <chrono>
 #include <ios>
 #include <iostream>
 #include <sstream>
 #include <string>
 #include <utility>
+#include <functional>
 
 namespace ROOT {
 namespace Minuit2 {
@@ -143,19 +143,6 @@ class MnPrint {
       Log(eTrace, args...);
    }
 
-   class TimingScope {
-
-   public:
-      TimingScope(MnPrint &mnPrint, std::string const &message);
-
-      ~TimingScope();
-
-   private:
-      std::chrono::steady_clock::time_point fBegin;
-      MnPrint &fMnPrint;
-      const std::string fMessage;
-   };
-
 private:
    // low level logging
    template <class... Ts>

math/minuit2/src/MnHesse.cxx

@@ -25,6 +25,8 @@
 
 #include "./MnFcnCaller.h"
 
+#include "Math/Util.h"
+
 namespace ROOT {
 
 namespace Minuit2 {
@@ -104,7 +106,7 @@ MinimumState ComputeAnalytical(const FCNBase &fcn, const MinimumState &st, const
    MnAlgebraicSymMatrix vhmat(n);
 
    MnPrint print("MnHesse");
-   MnPrint::TimingScope timingScope(print, "Done after");
+   ROOT::Math::Util::TimingScope timingScope([&print](std::string const& s){ print.Info(s); }, "Done after");
 
    const MnMachinePrecision &prec = trafo.Precision();
 
@@ -176,7 +178,7 @@ MinimumState ComputeNumerical(const MnFcn &mfcn, const MinimumState &st, const M
    // Function who does the real Hessian calculations
    MnPrint print("MnHesse");
 
-   MnPrint::TimingScope timingScope(print, "Done after");
+   ROOT::Math::Util::TimingScope timingScope([&print](std::string const& s){ print.Info(s); }, "Done after");
 
    MnFcnCaller mfcnCaller{mfcn};
 

math/minuit2/src/MnPrint.cxx

@@ -419,64 +419,5 @@ std::ostream &operator<<(std::ostream &os, const std::pair<double, double> &poin
    return os;
 }
 
-MnPrint::TimingScope::TimingScope(MnPrint &mnPrint, std::string const &message)
-   : fBegin{std::chrono::steady_clock::now()}, fMnPrint{mnPrint}, fMessage{message}
-{
-}
-
-namespace {
-
-template<class T>
-std::string printTime(T duration) {
-   std::stringstream ss;
-   // Here, nanoseconds are represented as "long int", so the maximum value
-   // corresponds to about 300 years. Nobody will wait that long for a
-   // computation to complete, so for timing measurements it's fine to cast to
-   // nanoseconds to keep things simple.
-   double ns = std::chrono::duration_cast<std::chrono::nanoseconds>(duration).count();
-   bool forceSeconds = false;
-   // The largest unit that we consider for pretty-printing is days.
-   if (ns >= 24 * 360e9) {
-      auto days = std::floor(ns / (24 * 360e9));
-      ss << days << " d ";
-      ns -= days * 24 * 360e9; // subtract the days to print only the rest
-      // to avoid printouts like "1 d 4 h 23 min 324 ns", we force to print
-      // seconds if we print either days, hours, or minutes
-      forceSeconds = true;
-   }
-   if (ns >= 360e9) {
-      auto hours = std::floor(ns / 360e9);
-      ss << hours << " h ";
-      ns -= hours * 360e9;
-      forceSeconds = true;
-   }
-   if (ns >= 60e9) {
-      auto minutes = std::floor(ns / 60e9);
-      ss << minutes << " min ";
-      ns -= minutes * 60e9;
-      forceSeconds = true;
-   }
-   if (ns >= 1e9 || forceSeconds) {
-      ss << (1e-9 * ns) << " s";
-   } else if (ns >= 1e6) {
-      ss << (1e-6 * ns) << " ms";
-   } else if (ns >= 1e3) {
-      ss << (1e-3 * ns) << " μs";
-   } else {
-      ss << ns << " ns";
-   }
-   return ss.str();
-}
-
-} // namespace
-
-MnPrint::TimingScope::~TimingScope()
-{
-   std::chrono::steady_clock::time_point end = std::chrono::steady_clock::now();
-   std::stringstream ss;
-   ss << fMessage << " " << printTime(end - fBegin);
-   fMnPrint.Info(ss.str());
-}
-
 } // namespace Minuit2
 } // namespace ROOT

math/minuit2/src/MnSeedGenerator.cxx

@@ -32,6 +32,8 @@
 #include "Minuit2/HessianGradientCalculator.h"
 #include "Minuit2/MnPrint.h"
 
+#include "Math/Util.h"
+
 #include <cmath>
 
 namespace ROOT {
@@ -65,7 +67,8 @@ operator()(const MnFcn &fcn, const GradientCalculator &gc, const MnUserParameter
    // by default, and we're timing it here. If the G2 is negative, we also have
    // to run a NegativeG2LineSearch later, but this is timed separately inside
    // the line search.
-   auto timingScope = std::make_unique<MnPrint::TimingScope>(print, "Evaluated function and gradient in");
+   auto timingScope = std::make_unique<ROOT::Math::Util::TimingScope>([&print](std::string const &s) { print.Info(s); },
+                                                                      "Evaluated function and gradient in");
    MinimumParameters pa(x, fcn(x));
    FunctionGradient dgrad = gc(pa);
    timingScope.reset();

math/minuit2/src/NegativeG2LineSearch.cxx

@@ -17,6 +17,8 @@
 #include "Minuit2/VariableMetricEDMEstimator.h"
 #include "Minuit2/MnPrint.h"
 
+#include "Math/Util.h"
+
 #include <cmath>
 
 namespace ROOT {
@@ -35,7 +37,7 @@ MinimumState NegativeG2LineSearch::operator()(const MnFcn &fcn, const MinimumSta
    MnPrint print("NegativeG2LineSearch");
 
    // Print the runtime on returning from the function
-   MnPrint::TimingScope timingScope(print, "Done after");
+   ROOT::Math::Util::TimingScope timingScope([&print](std::string const& s){ print.Info(s); }, "Done after");
 
    bool negG2 = HasNegativeG2(st.Gradient(), prec);
    if (!negG2)

math/minuit2/src/VariableMetricBuilder.cxx

@@ -23,6 +23,8 @@
 #include "Minuit2/MnHesse.h"
 #include "Minuit2/MnPrint.h"
 
+#include "Math/Util.h"
+
 #include <cmath>
 #include <cassert>
 
@@ -94,7 +96,7 @@ FunctionMinimum VariableMetricBuilder::Minimum(const MnFcn &fcn, const GradientC
    print.Info("Start iterating until Edm is <", edmval, "with call limit =", maxfcn);
 
    // print time after returning
-   MnPrint::TimingScope timingScope(print, "Stop iterating after");
+   ROOT::Math::Util::TimingScope timingScope([&print](std::string const &s) { print.Info(s); }, "Stop iterating after");
 
    AddResult(result, seed.State());
 

math/minuit2/src/math/CMakeLists.txt

@@ -30,6 +30,7 @@ set(MATH_SOURCES
     Minimizer.cxx
     MinimizerOptions.cxx
     ParameterSettings.cxx
+    Util.cxx
     )
 
 copy_standalone(SOURCE ../../../mathcore/inc/Fit DESTINATION ../../inc/Fit