[hist] Add stress tests for AtomicAdd

Author: hahnjo

hist/histv7/test/hist_engine_atomic.cxx

@@ -1,5 +1,8 @@
 #include "hist_test.hxx"
 
+#include <atomic>
+#include <cstddef>
+
 TEST(RHistEngine, AddAtomic)
 {
    static constexpr std::size_t Bins = 20;
@@ -24,6 +27,27 @@ TEST(RHistEngine, AddAtomic)
    EXPECT_EQ(engineA.GetBinContent(RBinIndex::Overflow()), 1);
 }
 
+TEST(RHistEngine, StressAddAtomic)
+{
+   static constexpr std::size_t NThreads = 4;
+   static constexpr std::size_t NAddsPerThread = 10000;
+   static constexpr std::size_t NAdds = NThreads * NAddsPerThread;
+
+   // Fill a single bin, to maximize contention.
+   const RRegularAxis axis(1, {0, 1});
+   RHistEngine<int> engineA({axis});
+   RHistEngine<int> engineB({axis});
+   engineB.Fill(0.5);
+
+   StressInParallel(NThreads, [&] {
+      for (std::size_t i = 0; i < NAddsPerThread; i++) {
+         engineA.AddAtomic(engineB);
+      }
+   });
+
+   EXPECT_EQ(engineA.GetBinContent(0), NAdds);
+}
+
 TEST(RHistEngine, AddAtomicDifferent)
 {
    // The equality operators of RAxes and the axis objects are already unit-tested separately, so here we only check one
@@ -213,6 +237,36 @@ TEST(RHistEngine, FillAtomicTupleWeightInvalidNumberOfArguments)
    EXPECT_THROW(engine2.FillAtomic(std::make_tuple(1, 2, 3), RWeight(1)), std::invalid_argument);
 }
 
+TEST(RHistEngine, StressFillAddAtomicWeight)
+{
+   static constexpr std::size_t NThreads = 4;
+   static constexpr std::size_t NOpsPerThread = 10000;
+   static constexpr std::size_t NOps = NThreads * NOpsPerThread;
+   static constexpr double Weight = 0.5;
+
+   // Fill a single bin, to maximize contention.
+   const RRegularAxis axis(1, {0, 1});
+   RHistEngine<float> engineA({axis});
+   RHistEngine<float> engineB({axis});
+   engineB.Fill(0.5, RWeight(Weight));
+
+   std::atomic<int> op = 0;
+   StressInParallel(NThreads, [&] {
+      int chosenOp = op.fetch_add(1) % 2;
+      if (chosenOp == 0) {
+         for (std::size_t i = 0; i < NOpsPerThread; i++) {
+            engineA.FillAtomic(0.5, RWeight(Weight));
+         }
+      } else {
+         for (std::size_t i = 0; i < NOpsPerThread; i++) {
+            engineA.AddAtomic(engineB);
+         }
+      }
+   });
+
+   EXPECT_EQ(engineA.GetBinContent(0), NOps * Weight);
+}
+
 TEST(RHistEngine_RBinWithError, AddAtomic)
 {
    static constexpr std::size_t Bins = 20;
@@ -236,6 +290,28 @@ TEST(RHistEngine_RBinWithError, AddAtomic)
    }
 }
 
+TEST(RHistEngine_RBinWithError, StressAddAtomic)
+{
+   static constexpr std::size_t NThreads = 4;
+   static constexpr std::size_t NAddsPerThread = 10000;
+   static constexpr std::size_t NAdds = NThreads * NAddsPerThread;
+
+   // Fill a single bin, to maximize contention.
+   const RRegularAxis axis(1, {0, 1});
+   RHistEngine<RBinWithError> engineA({axis});
+   RHistEngine<RBinWithError> engineB({axis});
+   engineB.Fill(0.5);
+
+   StressInParallel(NThreads, [&] {
+      for (std::size_t i = 0; i < NAddsPerThread; i++) {
+         engineA.AddAtomic(engineB);
+      }
+   });
+
+   EXPECT_EQ(engineA.GetBinContent(0).fSum, NAdds);
+   EXPECT_EQ(engineA.GetBinContent(0).fSum2, NAdds);
+}
+
 TEST(RHistEngine_RBinWithError, FillAtomic)
 {
    static constexpr std::size_t Bins = 20;

hist/histv7/test/hist_hist.cxx

@@ -69,6 +69,28 @@ TEST(RHist, AddAtomic)
    EXPECT_EQ(histA.GetBinContent(RBinIndex(9)), 1);
 }
 
+TEST(RHist, StressAddAtomic)
+{
+   static constexpr std::size_t NThreads = 4;
+   static constexpr std::size_t NAddsPerThread = 10000;
+   static constexpr std::size_t NAdds = NThreads * NAddsPerThread;
+
+   // Fill a single bin, to maximize contention.
+   const RRegularAxis axis(1, {0, 1});
+   RHist<int> histA({axis});
+   RHist<int> histB({axis});
+   histB.Fill(0.5);
+
+   StressInParallel(NThreads, [&] {
+      for (std::size_t i = 0; i < NAddsPerThread; i++) {
+         histA.AddAtomic(histB);
+      }
+   });
+
+   EXPECT_EQ(histA.GetNEntries(), NAdds);
+   EXPECT_EQ(histA.GetBinContent(0), NAdds);
+}
+
 TEST(RHist, Clear)
 {
    static constexpr std::size_t Bins = 20;

hist/histv7/test/hist_stats.cxx

@@ -156,6 +156,36 @@ TEST(RHistStats, AddAtomic)
    }
 }
 
+TEST(RHistStats, StressAddAtomic)
+{
+   static constexpr std::size_t NThreads = 4;
+   static constexpr std::size_t NAddsPerThread = 10000;
+   static constexpr std::size_t NAdds = NThreads * NAddsPerThread;
+   static constexpr double X = 1.5;
+   static constexpr double Weight = 0.5;
+
+   // Use a single dimension, to maximize contention.
+   RHistStats statsA(1);
+   RHistStats statsB(1);
+   statsB.Fill(X, RWeight(Weight));
+
+   StressInParallel(NThreads, [&] {
+      for (std::size_t i = 0; i < NAddsPerThread; i++) {
+         statsA.AddAtomic(statsB);
+      }
+   });
+
+   EXPECT_EQ(statsA.GetNEntries(), NAdds);
+   EXPECT_DOUBLE_EQ(statsA.GetSumW(), NAdds * Weight);
+   EXPECT_DOUBLE_EQ(statsA.GetSumW2(), NAdds * Weight * Weight);
+
+   const auto &dimensionStats = statsA.GetDimensionStats();
+   EXPECT_DOUBLE_EQ(dimensionStats.fSumWX, NAdds * Weight * X);
+   EXPECT_DOUBLE_EQ(dimensionStats.fSumWX2, NAdds * Weight * X * X);
+   EXPECT_DOUBLE_EQ(dimensionStats.fSumWX3, NAdds * Weight * X * X * X);
+   EXPECT_DOUBLE_EQ(dimensionStats.fSumWX4, NAdds * Weight * X * X * X * X);
+}
+
 TEST(RHistStats, AddAtomicDifferent)
 {
    RHistStats statsA(2);