[hist] Used fixed-width SIMD type for interpreted code in TFormula

In the interpreter, we must match the SIMD width used by compiled ROOT.
`ROOT::Double_v` aliases the best available native SIMD type, which may
differ between compiled and interpreted contexts (e.g. with
`-march=native`). Therefore, we explicitly select the fixed-size SIMD
type corresponding to the native SIMD width used in compiled ROOT.

This fixes failues in the vectorized TFormula tests for platforms with
possible mismatch between the SIMD types between interpretd and compiled
context (e.g. vanilla Alma 10 or Alma 9 with `march=native` in the CI).

Also, disable some subtests in the vectorized TFormula tests if they'd
still fail becaues of missing Vc symbols.

Author: guitargeek

hist/hist/src/TFormula.cxx

@@ -49,6 +49,22 @@ std::string doubleToString(double val)
    return ss.str();
 }
 
+// In the interpreter, we must match the SIMD width used by compiled ROOT.
+// ROOT::Double_v aliases the best available native SIMD type, which may differ
+// between compiled and interpreted contexts (e.g. with -march=native).
+// Therefore, we explicitly select the fixed-size SIMD type corresponding to
+// the native SIMD width used in compiled ROOT.
+std::string vectorizedArgType()
+{
+#ifdef VECCORE_ENABLE_VC
+   auto n = ROOT::Double_v::size();
+   return "Vc::fixed_size_simd<double, " + std::to_string(n) + ">";
+#else
+   // For other possible VecCore backends, we assume using the same type is fine.
+   return "ROOT::Double_v";
+#endif
+}
+
 } // namespace
 
 /** \class TFormula  TFormula.h "inc/TFormula.h"
@@ -815,7 +831,7 @@ prepareMethod(bool HasParameters, bool HasVariables, const char* FuncName,
    TString prototypeArguments = "";
    if (HasVariables || HasParameters) {
       if (IsVectorized)
-         prototypeArguments.Append("ROOT::Double_v const*");
+         prototypeArguments.Append(vectorizedArgType() + " const*");
       else
          prototypeArguments.Append("Double_t const*");
    }
@@ -2387,7 +2403,7 @@ void TFormula::ProcessFormula(TString &formula)
          if (fVectorized)
             inputFormulaVecFlag += " (vectorized)";
 
-         TString argType = fVectorized ? "ROOT::Double_v" : "Double_t";
+         TString argType = fVectorized ? vectorizedArgType() : "Double_t";
 
          // valid input formula - try to put into Cling (in case of no variables but only parameter we need to add the standard signature)
          TString argumentsPrototype = TString::Format("%s%s%s", ( (hasVariables || hasParameters) ? (argType + " const *x").Data() : ""),

test/TFormulaVecTests.h

@@ -93,25 +93,40 @@ bool testVecFormula() {
 
    bool ok = true;
 
+   // Note that we have to disable several tests when using the Vc backend
+   // because of linker errors. This is because Vc is always built as a static
+   // library, and linked in MathCore, but the interpreter cannot lookup
+   // missing symbols for Vc math functions if the formula requires them and
+   // they are not already linked into MathCore by chance.
+   // See also:
+   // https://its.cern.ch/jira/browse/ROOT-10614
+   // https://github.com/root-project/root/pull/20769
+
    ok &= testVec1D("3+[0]",constant_function, 3.333);
    ok &= testVec1D("3",constant_function, 3.333);
+#ifndef R__HAS_VC
    ok &= testVec1D("sin(x)",std::sin,1);
    ok &= testVec1D("cos(x)",std::cos,1);
+#endif
    ok &= testVec1D("exp(x)",std::exp,1);
    ok &= testVec1D("log(x)",std::log,2);
    ok &= testVec1D("log10(x)",TMath::Log10,2);
+#ifndef R__HAS_VC
    ok &= testVec1D("tan(x)",std::tan,1);
-   //ok &= testVec1D("sinh(x)",std::sinh,1);
-   //ok &= testVec1D("cosh(x)",std::cosh,1);
-   //ok &= testVec1D("tanh(x)",std::tanh,1);
+   ok &= testVec1D("sinh(x)",std::sinh,1);
+   ok &= testVec1D("cosh(x)",std::cosh,1);
+   ok &= testVec1D("tanh(x)",std::tanh,1);
    ok &= testVec1D("asin(x)",std::asin,.1);
    ok &= testVec1D("acos(x)",std::acos,.1);
+#endif
    ok &= testVec1D("atan(x)",std::atan,.1);
    ok &= testVec1D("sqrt(x)",std::sqrt,2);
    ok &= testVec1D("abs(x)",std::abs,-1);
    ok &= testVec2D("pow(x,y)",std::pow,2,3);
+#ifndef R__HAS_VC
    ok &= testVec2D("min(x,y)",TMath::Min,2,3);
    ok &= testVec2D("max(x,y)",TMath::Max,2,3);
+#endif
    ok &= testVec2D("atan2(x,y)",TMath::ATan2,2,3);
 
    return ok;