[hist] Implement RHist{,Stats}::AddAtomic

Author: hahnjo

hist/histv7/inc/ROOT/RHist.hxx

@@ -174,6 +174,17 @@ public:
       fStats.Add(other.fStats);
    }
 
+   /// Add all bin contents and statistics of another histogram using atomic instructions.
+   ///
+   /// Throws an exception if the axes configurations are not identical.
+   ///
+   /// \param[in] other another histogram that must not be modified during the operation
+   void AddAtomic(const RHist<BinContentType> &other)
+   {
+      fEngine.AddAtomic(other.fEngine);
+      fStats.AddAtomic(other.fStats);
+   }
+
    /// Clear all bin contents and statistics.
    void Clear()
    {

hist/histv7/inc/ROOT/RHistStats.hxx

@@ -68,6 +68,17 @@ public:
          fSumWX4 += other.fSumWX4;
       }
 
+      /// Add another statistics object using atomic instructions.
+      ///
+      /// \param[in] other another statistics object that must not be modified during the operation
+      void AddAtomic(const RDimensionStats &other)
+      {
+         Internal::AtomicAdd(&fSumWX, other.fSumWX);
+         Internal::AtomicAdd(&fSumWX2, other.fSumWX2);
+         Internal::AtomicAdd(&fSumWX3, other.fSumWX3);
+         Internal::AtomicAdd(&fSumWX4, other.fSumWX4);
+      }
+
       void Clear()
       {
          fSumWX = 0.0;
@@ -125,6 +136,24 @@ public:
       }
    }
 
+   /// Add all entries from another statistics object using atomic instructions.
+   ///
+   /// Throws an exception if the number of dimensions are not identical.
+   ///
+   /// \param[in] other another statistics object that must not be modified during the operation
+   void AddAtomic(const RHistStats &other)
+   {
+      if (fDimensionStats.size() != other.fDimensionStats.size()) {
+         throw std::invalid_argument("number of dimensions not identical in Add");
+      }
+      Internal::AtomicAdd(&fNEntries, other.fNEntries);
+      Internal::AtomicAdd(&fSumW, other.fSumW);
+      Internal::AtomicAdd(&fSumW2, other.fSumW2);
+      for (std::size_t i = 0; i < fDimensionStats.size(); i++) {
+         fDimensionStats[i].AddAtomic(other.fDimensionStats[i]);
+      }
+   }
+
    /// Clear this statistics object.
    void Clear()
    {

hist/histv7/test/hist_hist.cxx

@@ -52,6 +52,23 @@ TEST(RHist, Add)
    EXPECT_EQ(histA.GetBinContent(RBinIndex(9)), 1);
 }
 
+TEST(RHist, AddAtomic)
+{
+   static constexpr std::size_t Bins = 20;
+   const RRegularAxis axis(Bins, {0, Bins});
+   RHist<int> histA({axis});
+   RHist<int> histB({axis});
+
+   histA.Fill(8.5);
+   histB.Fill(9.5);
+
+   histA.AddAtomic(histB);
+
+   EXPECT_EQ(histA.GetNEntries(), 2);
+   EXPECT_EQ(histA.GetBinContent(RBinIndex(8)), 1);
+   EXPECT_EQ(histA.GetBinContent(RBinIndex(9)), 1);
+}
+
 TEST(RHist, Clear)
 {
    static constexpr std::size_t Bins = 20;

hist/histv7/test/hist_stats.cxx

@@ -123,6 +123,47 @@ TEST(RHistStats, AddDifferent)
    EXPECT_THROW(statsA.Add(statsB), std::invalid_argument);
 }
 
+TEST(RHistStats, AddAtomic)
+{
+   RHistStats statsA(2);
+   RHistStats statsB(2);
+
+   static constexpr std::size_t Entries = 20;
+   for (std::size_t i = 0; i < Entries; i++) {
+      statsA.Fill(i, 2 * i);
+      statsB.Fill(2 * i, 3 * i, RWeight(0.1 + 0.03 * i));
+   }
+
+   statsA.AddAtomic(statsB);
+
+   ASSERT_EQ(statsA.GetNEntries(), 2 * Entries);
+   EXPECT_DOUBLE_EQ(statsA.GetSumW(), 27.7);
+   EXPECT_DOUBLE_EQ(statsA.GetSumW2(), 23.563);
+
+   {
+      const auto &dimensionStats = statsA.GetDimensionStats(/*=0*/);
+      EXPECT_FLOAT_EQ(dimensionStats.fSumWX, 376.2);
+      EXPECT_FLOAT_EQ(dimensionStats.fSumWX2, 7790);
+      EXPECT_FLOAT_EQ(dimensionStats.fSumWX3, 200019.84);
+      EXPECT_FLOAT_EQ(dimensionStats.fSumWX4, 5846915.6);
+   }
+   {
+      const auto &dimensionStats = statsA.GetDimensionStats(1);
+      EXPECT_FLOAT_EQ(dimensionStats.fSumWX, 659.3);
+      EXPECT_FLOAT_EQ(dimensionStats.fSumWX2, 21850);
+      EXPECT_FLOAT_EQ(dimensionStats.fSumWX3, 842029.46);
+      EXPECT_FLOAT_EQ(dimensionStats.fSumWX4, 35754169.6);
+   }
+}
+
+TEST(RHistStats, AddAtomicDifferent)
+{
+   RHistStats statsA(2);
+   RHistStats statsB(3);
+
+   EXPECT_THROW(statsA.AddAtomic(statsB), std::invalid_argument);
+}
+
 TEST(RHistStats, Clear)
 {
    RHistStats stats(2);