[hist] Extend FillAtomic for non-arithmetic types

This includes RBinWithError, but also user-defined bin content types.

Author: hahnjo

hist/histv7/inc/ROOT/RBinWithError.hxx

@@ -5,6 +5,8 @@
 #ifndef ROOT_RBinWithError
 #define ROOT_RBinWithError
 
+#include "RHistUtils.hxx"
+
 namespace ROOT {
 namespace Experimental {
 
@@ -45,6 +47,18 @@ struct RBinWithError final {
       fSum2 += rhs.fSum2;
       return *this;
    }
+
+   void AtomicInc()
+   {
+      Internal::AtomicInc(&fSum);
+      Internal::AtomicInc(&fSum2);
+   }
+
+   void AtomicAdd(double w)
+   {
+      Internal::AtomicAdd(&fSum, w);
+      Internal::AtomicAdd(&fSum2, w * w);
+   }
 };
 
 } // namespace Experimental

hist/histv7/inc/ROOT/RHistUtils.hxx

@@ -196,6 +196,18 @@ std::enable_if_t<std::is_arithmetic_v<T>> AtomicInc(T *ptr)
    AtomicAdd(ptr, static_cast<T>(1));
 }
 
+template <typename T, typename U>
+std::enable_if_t<std::is_member_function_pointer_v<decltype(&T::AtomicAdd)>> AtomicAdd(T *ptr, const U &add)
+{
+   ptr->AtomicAdd(add);
+}
+
+template <typename T>
+std::enable_if_t<std::is_member_function_pointer_v<decltype(&T::AtomicInc)>> AtomicInc(T *ptr)
+{
+   ptr->AtomicInc();
+}
+
 } // namespace Internal
 } // namespace Experimental
 } // namespace ROOT

hist/histv7/test/hist_engine_atomic.cxx

@@ -143,3 +143,38 @@ TEST(RHistEngine, FillTupleWeightInvalidNumberOfArguments)
    EXPECT_NO_THROW(engine2.FillAtomic(std::make_tuple(1, 2), RWeight(1)));
    EXPECT_THROW(engine2.FillAtomic(std::make_tuple(1, 2, 3), RWeight(1)), std::invalid_argument);
 }
+
+TEST(RHistEngine_RBinWithError, FillAtomic)
+{
+   static constexpr std::size_t Bins = 20;
+   const RRegularAxis axis(Bins, {0, Bins});
+   RHistEngine<RBinWithError> engine({axis});
+
+   for (std::size_t i = 0; i < Bins; i++) {
+      engine.FillAtomic(i);
+   }
+
+   for (auto index : axis.GetNormalRange()) {
+      auto &bin = engine.GetBinContent(index);
+      EXPECT_EQ(bin.fSum, 1);
+      EXPECT_EQ(bin.fSum2, 1);
+   }
+}
+
+TEST(RHistEngine_RBinWithError, FillAtomicWeight)
+{
+   static constexpr std::size_t Bins = 20;
+   const RRegularAxis axis(Bins, {0, Bins});
+   RHistEngine<RBinWithError> engine({axis});
+
+   for (std::size_t i = 0; i < Bins; i++) {
+      engine.FillAtomic(i, RWeight(0.1 + i * 0.03));
+   }
+
+   for (auto index : axis.GetNormalRange()) {
+      auto &bin = engine.GetBinContent(index);
+      double weight = 0.1 + index.GetIndex() * 0.03;
+      EXPECT_FLOAT_EQ(bin.fSum, weight);
+      EXPECT_FLOAT_EQ(bin.fSum2, weight * weight);
+   }
+}

hist/histv7/test/hist_user.cxx

@@ -30,6 +30,10 @@ struct User {
       fValue += rhs.fValue;
       return *this;
    }
+
+   void AtomicInc() { ROOT::Experimental::Internal::AtomicInc(&fValue); }
+
+   void AtomicAdd(double w) { ROOT::Experimental::Internal::AtomicAdd(&fValue, w); }
 };
 
 static_assert(std::is_nothrow_move_constructible_v<RHistEngine<User>>);
@@ -119,3 +123,33 @@ TEST(RHistEngineUser, FillWeight)
    std::array<RBinIndex, 1> indices = {9};
    EXPECT_EQ(engine.GetBinContent(indices).fValue, 0.9);
 }
+
+TEST(RHistEngineUser, FillAtomic)
+{
+   // Unweighted filling with atomic instructions uses AtomicInc
+   static constexpr std::size_t Bins = 20;
+   const RRegularAxis axis(Bins, {0, Bins});
+   RHistEngine<User> engine({axis});
+
+   engine.FillAtomic(8.5);
+   engine.FillAtomic(std::make_tuple(9.5));
+
+   EXPECT_EQ(engine.GetBinContent(RBinIndex(8)).fValue, 1);
+   std::array<RBinIndex, 1> indices = {9};
+   EXPECT_EQ(engine.GetBinContent(indices).fValue, 1);
+}
+
+TEST(RHistEngineUser, FillAtomicWeight)
+{
+   // Weighted filling with atomic instructions uses AtomicAdd
+   static constexpr std::size_t Bins = 20;
+   const RRegularAxis axis(Bins, {0, Bins});
+   RHistEngine<User> engine({axis});
+
+   engine.FillAtomic(8.5, RWeight(0.8));
+   engine.FillAtomic(std::make_tuple(9.5), RWeight(0.9));
+
+   EXPECT_EQ(engine.GetBinContent(RBinIndex(8)).fValue, 0.8);
+   std::array<RBinIndex, 1> indices = {9};
+   EXPECT_EQ(engine.GetBinContent(indices).fValue, 0.9);
+}