[hist] Use correct SIMD size in the compiled TFormula code

Make sure that the `std::simd` class used arguments of the compiled
TFormula has the same width as the one used in compile ROOT.

Author: guitargeek

hist/hist/src/TFormula.cxx

@@ -49,6 +49,21 @@ std::string doubleToString(double val)
    return ss.str();
 }
 
+// To use the ROOT::Double_v type in the interpreter, we need to make sure that
+// we're using the SIMD type of the same size as in the compiled ROOT. If we
+// would use ROOT::Double_v directly, which aliases to native_simd, is might
+// choose different sized in compiled and interpreted contexts (especially if
+// compiling with march=native).
+std::string simdArgType()
+{
+#ifdef R__HAS_STD_SIMD
+   auto n = ROOT::Double_v::size();
+   return "std::experimental::resize_simd_t<" + std::to_string(n) + ", ROOT::Double_v>";
+#else
+   return "ROOT::Double_v";
+#endif
+}
+
 } // namespace
 
 /** \class TFormula  TFormula.h "inc/TFormula.h"
@@ -815,7 +830,7 @@ prepareMethod(bool HasParameters, bool HasVariables, const char* FuncName,
    TString prototypeArguments = "";
    if (HasVariables || HasParameters) {
       if (IsVectorized)
-         prototypeArguments.Append("ROOT::Double_v const*");
+         prototypeArguments.Append(simdArgType() + " const*");
       else
          prototypeArguments.Append("Double_t const*");
    }
@@ -2354,7 +2369,7 @@ void TFormula::ProcessFormula(TString &formula)
          if (fVectorized)
             inputFormulaVecFlag += " (vectorized)";
 
-         TString argType = fVectorized ? "ROOT::Double_v" : "Double_t";
+         TString argType = fVectorized ? simdArgType() : "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() : ""),

math/mathcore/inc/Math/Types.h

@@ -13,10 +13,8 @@ namespace ROOT {
 
 namespace Internal {
 
-// We can't use SIMDNative here, because we need ABI compatible types between
-// the context of the interpreter and compiled code, for usage in the TFormula.
 template <typename T>
-using SIMDTag = std::experimental::simd_abi::compatible<T>;
+using SIMDTag = std::experimental::simd_abi::native<T>;
 
 } // namespace Internal