Accumulators.h

Go to the documentation of this file.

/***********************************************************************************\
* (c) Copyright 1998-2026 CERN for the benefit of the LHCb and ATLAS collaborations *
*                                                                                   *
* This software is distributed under the terms of the Apache version 2 licence,     *
* copied verbatim in the file "LICENSE".                                            *
*                                                                                   *
* In applying this licence, CERN does not waive the privileges and immunities       *
* granted to it by virtue of its status as an Intergovernmental Organization        *
* or submit itself to any jurisdiction.                                             *
\***********************************************************************************/
 
#pragma once
 
#include <Gaudi/MonitoringHub.h>
 
#include <chrono>
 
namespace Gaudi::Accumulators {
  template <class Rep, class Period>
  auto sqrt( std::chrono::duration<Rep, Period> d );
  template <class Rep1, class Rep2, class Period>
  auto operator*( const std::chrono::duration<Rep1, Period>& lhs, const std::chrono::duration<Rep2, Period>& rhs );
} // namespace Gaudi::Accumulators
 
// Fix builds with GCC 11 and C++20
#if defined( __GNUC__ ) && ( __GNUC__ == 11 ) && !defined( __clang__ )
namespace std::chrono {
  template <typename Ratio>
  static constexpr const char* suffix( const Ratio& ) {
    if constexpr ( std::ratio_equal_v<Ratio, std::ratio<1>> ) {
      return "s";
    } else if constexpr ( std::ratio_equal_v<Ratio, std::milli> ) {
      return "ms";
    } else if constexpr ( std::ratio_equal_v<Ratio, std::micro> ) {
      return "us";
    } else if constexpr ( std::ratio_equal_v<Ratio, std::nano> ) {
      return "ns";
    } else if constexpr ( std::ratio_equal_v<Ratio, std::ratio<60>> ) {
      return "m";
    } else if constexpr ( std::ratio_equal_v<Ratio, std::ratio<3600>> ) {
      return "h";
    }
    return "";
  }
  template <class Rep, class Period>
  std::ostream& operator<<( std::ostream& os, const std::chrono::duration<Rep, Period>& d ) {
    return os << d.count() << suffix( Period{} );
  }
} // namespace std::chrono
#endif

 
#include <atomic>
#include <boost/format.hpp>
#include <cmath>
#include <iostream>
#include <limits>
#include <nlohmann/json.hpp>
#include <sstream>
#include <tuple>
#include <type_traits>
#include <utility>
 
#include <GaudiKernel/CommonMessaging.h>
#include <GaudiKernel/MsgStream.h>
 
// Json serialization for std::chrono::duration
namespace nlohmann {
  template <class Rep, class Period>
  struct adl_serializer<std::chrono::duration<Rep, Period>> {
    static void to_json( json& j, const std::chrono::duration<Rep, Period>& d ) { j = d.count(); }
    static void from_json( const json& j, std::chrono::duration<Rep, Period>& d ) {
      d = std::chrono::duration<Rep, Period>{ j.get<Rep>() };
    }
  };
} // namespace nlohmann
 
namespace Gaudi::Accumulators {

  enum class atomicity { none, full };

  template <class T>
  auto sqrt( T d );

  template <typename T, T N>
  struct Constant {
    template <typename U>
    constexpr T operator()( U&& ) const noexcept {
      return N;
    }
  };

  struct Identity {
    template <typename U>
    constexpr decltype( auto ) operator()( U&& v ) const noexcept {
      return std::forward<U>( v );
    }
  };

  struct Square {
    template <typename U>
    constexpr decltype( auto ) operator()( U&& v ) const noexcept {
      return v * v;
    }
  };

  template <typename Arithmetic, typename Result = double>
  using fp_result_type = std::conditional_t<std::is_integral_v<Arithmetic>, Result, Arithmetic>;

  template <typename Arithmetic, atomicity Atomicity>
  struct BaseValueHandler;

  template <typename Arithmetic>
  struct BaseValueHandler<Arithmetic, atomicity::none> {
    using OutputType   = Arithmetic;
    using InternalType = Arithmetic;
    static constexpr OutputType getValue( const InternalType& v ) noexcept { return v; }
    static Arithmetic exchange( InternalType& v, Arithmetic newv ) noexcept { return std::exchange( v, newv ); }
  };

  template <typename Arithmetic>
  struct BaseValueHandler<Arithmetic, atomicity::full> {
    using OutputType   = Arithmetic;
    using InternalType = std::atomic<Arithmetic>;
    static constexpr OutputType getValue( const InternalType& v ) noexcept {
      return v.load( std::memory_order_relaxed );
    }
    static Arithmetic exchange( InternalType& v, Arithmetic newv ) noexcept { return v.exchange( newv ); }
  };

  template <typename Arithmetic, atomicity Atomicity>
  struct Adder;

  template <typename Arithmetic>
  struct Adder<Arithmetic, atomicity::none> : BaseValueHandler<Arithmetic, atomicity::none> {
    using typename BaseValueHandler<Arithmetic, atomicity::none>::OutputType;
    using typename BaseValueHandler<Arithmetic, atomicity::none>::InternalType;
    static constexpr OutputType DefaultValue() { return Arithmetic{}; }
    static void                 merge( InternalType& a, Arithmetic b ) noexcept { a += b; }
  };

  template <typename AtomicType, typename Arithmetic>
  void fetch_add( AtomicType& atVar, Arithmetic value ) {
    if constexpr ( requires { atVar.fetch_add( value, std::memory_order_relaxed ); } ) {
      atVar.fetch_add( value, std::memory_order_relaxed );
    } else {
      auto current = BaseValueHandler<Arithmetic, atomicity::full>::getValue( atVar );
      while ( !atVar.compare_exchange_weak( current, current + value ) )
        ;
    }
  }

  template <typename Arithmetic>
  struct Adder<Arithmetic, atomicity::full> : BaseValueHandler<Arithmetic, atomicity::full> {
    using typename BaseValueHandler<Arithmetic, atomicity::full>::OutputType;
    using typename BaseValueHandler<Arithmetic, atomicity::full>::InternalType;
    static constexpr OutputType DefaultValue() { return Arithmetic{}; }
    static void                 merge( InternalType& a, Arithmetic b ) noexcept {
      if constexpr ( !std::is_floating_point_v<Arithmetic> ) { // avoid comparisons for floating points
        if ( DefaultValue() == b ) return;                     // avoid atomic operation if b is "0"
      }
      fetch_add( a, b );
    }
  };
 
  namespace detail {
    template <typename Arithmetic>
    struct Min {
      static constexpr Arithmetic value() { return std::numeric_limits<Arithmetic>::lowest(); }
    };

    template <typename Arithmetic>
    struct Max {
      static constexpr Arithmetic value() { return std::numeric_limits<Arithmetic>::max(); }
    };
  } // namespace detail

  template <typename Arithmetic, atomicity Atomicity, typename Compare, typename Initial>
  struct Extremum;

  template <typename Arithmetic, typename Compare, typename Initial>
  struct Extremum<Arithmetic, atomicity::none, Compare, Initial> : BaseValueHandler<Arithmetic, atomicity::none> {
    using typename BaseValueHandler<Arithmetic, atomicity::none>::OutputType;
    using typename BaseValueHandler<Arithmetic, atomicity::none>::InternalType;
    static constexpr OutputType DefaultValue() { return Initial::value(); }
    static void                 merge( InternalType& a, Arithmetic b ) noexcept {
      if ( Compare{}( b, a ) ) a = b;
    }
  };

  template <typename Arithmetic, typename Compare, typename Initial>
  struct Extremum<Arithmetic, atomicity::full, Compare, Initial> : BaseValueHandler<Arithmetic, atomicity::full> {
    using typename BaseValueHandler<Arithmetic, atomicity::full>::OutputType;
    using typename BaseValueHandler<Arithmetic, atomicity::full>::InternalType;
    static constexpr OutputType DefaultValue() { return Initial::value(); }
    static void                 merge( InternalType& a, Arithmetic b ) noexcept {
      Arithmetic prev_value = BaseValueHandler<Arithmetic, atomicity::full>::getValue( a );
      while ( Compare{}( b, prev_value ) && !a.compare_exchange_weak( prev_value, b ) )
        ;
    }
  };

  template <typename Arithmetic, atomicity Atomicity = atomicity::full>
  using Minimum = Extremum<Arithmetic, Atomicity, std::less<Arithmetic>, detail::Max<Arithmetic>>;

  template <typename Arithmetic, atomicity Atomicity = atomicity::full>
  using Maximum = Extremum<Arithmetic, Atomicity, std::greater<Arithmetic>, detail::Min<Arithmetic>>;

  struct construct_empty_t {
    explicit construct_empty_t() = default;
  };
  constexpr construct_empty_t construct_empty{};

  template <typename InputTypeT, typename InnerType, atomicity Atomicity = atomicity::full,
            typename InputTransform = Identity, typename OutputTransform = Identity,
            typename ValueHandler = Adder<InnerType, Atomicity>>
  class GenericAccumulator {
    template <typename, typename, atomicity, typename, typename, typename>
    friend class GenericAccumulator;
 
  public:
    using InputType             = InputTypeT;
    using OutputType            = std::decay_t<std::invoke_result_t<OutputTransform, InnerType>>;
    using InternalType          = InnerType;
    using JSONStringEntriesType = std::string;
    GenericAccumulator operator+=( const InputType by ) {
      ValueHandler::merge( m_value, InputTransform{}( by ) );
      return *this;
    }
    GenericAccumulator() = default;
    template <atomicity ato, typename VH>
    GenericAccumulator( construct_empty_t,
                        const GenericAccumulator<InputType, InnerType, ato, InputTransform, OutputTransform, VH>& )
        : GenericAccumulator() {}
    template <typename... Args>
    GenericAccumulator( std::in_place_t, Args&&... args ) : m_value( std::forward<Args>( args )... ) {}
    GenericAccumulator( const GenericAccumulator& other ) : m_value( ValueHandler::getValue( other.m_value ) ) {}
    GenericAccumulator& operator=( const GenericAccumulator& other ) {
      m_value = ValueHandler::getValue( other.m_value );
      return *this;
    }
    OutputType value() const { return OutputTransform{}( ValueHandler::getValue( m_value ) ); }
    void       reset() { reset( ValueHandler::DefaultValue() ); }
    template <atomicity ato, typename VH>
    void mergeAndReset( GenericAccumulator<InputType, InnerType, ato, InputTransform, OutputTransform, VH>& other ) {
      ValueHandler::merge( m_value, VH::exchange( other.m_value, VH::DefaultValue() ) );
    }
    template <atomicity ato, typename VH>
    void operator+( GenericAccumulator<InputType, InnerType, ato, InputTransform, OutputTransform, VH>&& other ) {
      ValueHandler::merge( m_value, other.m_value );
    }
 
  protected:
    GenericAccumulator( InnerType in ) : m_value( std::move( in ) ) {}
    auto             rawValue() const { return ValueHandler::getValue( m_value ); }
    void             reset( InnerType in ) { m_value = std::move( in ); }
    static InnerType extractJSONData( const nlohmann::json& j, const JSONStringEntriesType& entries ) {
      return j.at( entries ).get<InnerType>();
    }
 
  private:
    typename ValueHandler::InternalType m_value{ ValueHandler::DefaultValue() };
  };

  template <typename Arithmetic, atomicity Atomicity, typename InputTypeT = Arithmetic,
            template <atomicity, typename> class... Bases>
  class AccumulatorSet : public Bases<Atomicity, Arithmetic>... {
  public:
    using InputType             = InputTypeT;
    using OutputType            = std::tuple<typename Bases<Atomicity, Arithmetic>::OutputType...>;
    using InternalType          = std::tuple<typename Bases<Atomicity, Arithmetic>::InternalType...>;
    using JSONStringEntriesType = std::tuple<typename Bases<Atomicity, Arithmetic>::JSONStringEntriesType...>;
    constexpr AccumulatorSet()  = default;
    template <atomicity ato>
    AccumulatorSet( construct_empty_t, const AccumulatorSet<Arithmetic, ato, InputType, Bases...>& )
        : AccumulatorSet() {}
    AccumulatorSet& operator+=( const InputType by ) {
      ( Bases<Atomicity, Arithmetic>::operator+=( by ), ... );
      return *this;
    }
    OutputType value() const { return std::make_tuple( Bases<Atomicity, Arithmetic>::value()... ); }
    void       reset() { ( Bases<Atomicity, Arithmetic>::reset(), ... ); }
    template <atomicity Ato>
    void mergeAndReset( AccumulatorSet<Arithmetic, Ato, InputType, Bases...>& other ) {
      ( Bases<Atomicity, Arithmetic>::mergeAndReset( static_cast<Bases<Ato, Arithmetic>&>( other ) ), ... );
    }
    template <atomicity Ato>
    void operator+( AccumulatorSet<Arithmetic, Ato, InputType, Bases...>&& other ) {
      ( Bases<Atomicity, Arithmetic>::operator+( static_cast<Bases<Ato, Arithmetic>&&>( other ) ), ... );
    }
    // explicitely delete operator++ as it's not 100% clear what one would expect from them in more
    // complex cases, e.g. binomial counters, or counters based on enums, etc...
    void operator++()      = delete;
    void operator++( int ) = delete;
 
  protected:
    AccumulatorSet( const InternalType& t ) : AccumulatorSet() { reset( t ); }
    void reset( const InternalType& t ) {
      std::apply( [this]( const auto&... i ) { ( this->Bases<Atomicity, Arithmetic>::reset( i ), ... ); }, t );
    }
    static InternalType extractJSONData( const nlohmann::json& j, const JSONStringEntriesType& entries ) {
      return extractJSONDataHelper( j, entries, std::index_sequence_for<Bases<Atomicity, Arithmetic>...>{} );
    }
 
  private:
    template <size_t... Is>
    static InternalType extractJSONDataHelper( const nlohmann::json& j, const JSONStringEntriesType& entries,
                                               std::index_sequence<Is...> ) {
      return extractJSONDataHelper( j, std::get<Is>( entries )... );
    }
    static InternalType
    extractJSONDataHelper( const nlohmann::json& j,
                           typename Bases<Atomicity, Arithmetic>::JSONStringEntriesType... entries ) {
      return { Bases<Atomicity, Arithmetic>::extractJSONData( j, entries )... };
    }
  };

  template <atomicity Atomicity, typename Arithmetic = double>
  struct MaxAccumulator
      : GenericAccumulator<Arithmetic, Arithmetic, Atomicity, Identity, Identity, Maximum<Arithmetic, Atomicity>> {
    using GenericAccumulator<Arithmetic, Arithmetic, Atomicity, Identity, Identity,
                             Maximum<Arithmetic, Atomicity>>::GenericAccumulator;
    Arithmetic max() const { return this->value(); }
  };

  template <atomicity Atomicity, typename Arithmetic = double>
  struct MinAccumulator
      : GenericAccumulator<Arithmetic, Arithmetic, Atomicity, Identity, Identity, Minimum<Arithmetic, Atomicity>> {
    using GenericAccumulator<Arithmetic, Arithmetic, Atomicity, Identity, Identity,
                             Minimum<Arithmetic, Atomicity>>::GenericAccumulator;
    Arithmetic min() const { return this->value(); }
  };

  template <atomicity Atomicity, typename Arithmetic = double>
  struct CountAccumulator : GenericAccumulator<Arithmetic, unsigned long, Atomicity, Constant<unsigned long, 1UL>> {
    using GenericAccumulator<Arithmetic, unsigned long, Atomicity, Constant<unsigned long, 1UL>>::GenericAccumulator;
    CountAccumulator& operator++() {
      ( *this ) += Arithmetic{};
      return *this;
    }
    CountAccumulator operator++( int ) {
      auto copy = *this;
      ++( *this );
      return copy;
    }
    unsigned long nEntries() const { return this->value(); }
  };

  template <atomicity Atomicity, typename Arithmetic = double>
  struct SumAccumulator : GenericAccumulator<Arithmetic, Arithmetic, Atomicity, Identity> {
    using GenericAccumulator<Arithmetic, Arithmetic, Atomicity, Identity>::GenericAccumulator;
    Arithmetic sum() const { return this->value(); }
  };

  template <atomicity Atomicity, typename Arithmetic = unsigned long>
  struct IntegralAccumulator : GenericAccumulator<Arithmetic, Arithmetic, Atomicity, Identity> {
    static_assert( std::is_integral_v<Arithmetic>,
                   "Invalid Arithmetic type for IntegralAccumulator. It must be an integral type" );
 
    using GenericAccumulator<Arithmetic, Arithmetic, Atomicity, Identity>::GenericAccumulator;
    IntegralAccumulator& operator++() {
      ( *this ) += 1;
      return *this;
    }
    IntegralAccumulator operator++( int ) {
      auto copy = *this;
      ++( *this );
      return copy;
    }
    Arithmetic nEntries() const { return this->value(); }
    Arithmetic sum() const { return this->value(); }
  };

  template <atomicity Atomicity, typename Arithmetic = double>
  struct SquareAccumulator : GenericAccumulator<Arithmetic, Arithmetic, Atomicity, Square> {
    using GenericAccumulator<Arithmetic, Arithmetic, Atomicity, Square>::GenericAccumulator;
    Arithmetic sum2() const { return this->value(); }
  };

  struct TrueTo1 {
    unsigned int operator()( bool v ) const { return v; }
  };

  template <atomicity Atomicity, typename Arithmetic>
  struct TrueAccumulator : GenericAccumulator<Arithmetic, unsigned long, Atomicity, TrueTo1> {
    using GenericAccumulator<Arithmetic, unsigned long, Atomicity, TrueTo1>::GenericAccumulator;
    unsigned long nTrueEntries() const { return this->value(); }
  };

  struct FalseTo1 {
    unsigned int operator()( bool v ) const { return !v; }
  };

  template <atomicity Atomicity, typename Arithmetic>
  struct FalseAccumulator : GenericAccumulator<Arithmetic, unsigned long, Atomicity, FalseTo1> {
    using GenericAccumulator<Arithmetic, unsigned long, Atomicity, FalseTo1>::GenericAccumulator;
    unsigned long nFalseEntries() const { return this->value(); }
  };

  template <atomicity Atomicity, typename Arithmetic>
  struct BinomialAccumulator : AccumulatorSet<bool, Atomicity, bool, TrueAccumulator, FalseAccumulator> {
    using AccumulatorSet<bool, Atomicity, bool, TrueAccumulator, FalseAccumulator>::AccumulatorSet;
    unsigned long nEntries() const { return this->nTrueEntries() + this->nFalseEntries(); }
 
    template <typename Result = fp_result_type<Arithmetic>>
    auto efficiency() const {
      auto nbEntries = nEntries();
      if ( 1 > nbEntries ) return Result{ -1 };
      return static_cast<Result>( this->nTrueEntries() ) / nbEntries;
    }
    auto eff() const { return efficiency(); }
 
    template <typename Result = fp_result_type<Arithmetic>>
    auto efficiencyErr() const {
      // Note the usage of using, aiming at using the std version of sqrt by default, without preventing
      // more specialized versions to be used via ADL (see http://en.cppreference.com/w/cpp/language/adl)
      using Gaudi::Accumulators::sqrt;
      using std::sqrt;
      auto nbEntries = nEntries();
      if ( 1 > nbEntries ) return Result{ -1 };
      return sqrt( static_cast<Result>( this->nTrueEntries() * this->nFalseEntries() ) / nbEntries ) / nbEntries;
    }
    auto effErr() const { return efficiencyErr(); }
    using AccumulatorSet<bool, Atomicity, bool, TrueAccumulator, FalseAccumulator>::operator+=;
    struct binomial_t {
      unsigned long nPass;
      unsigned long nTotal;
    };
    BinomialAccumulator& operator+=( binomial_t b ) {
      assert( b.nPass <= b.nTotal );
      TrueAccumulator<atomicity::none, bool> t{ std::in_place, b.nPass };
      TrueAccumulator<Atomicity, bool>::mergeAndReset( t );
      FalseAccumulator<atomicity::none, bool> f{ std::in_place, b.nTotal - b.nPass };
      FalseAccumulator<Atomicity, bool>::mergeAndReset( f );
      return *this;
    }
  };

  template <atomicity Atomicity, typename Arithmetic, template <atomicity, typename> typename CountAcc,
            template <atomicity, typename> typename SumAcc>
  struct AveragingAccumulatorBase
      : AccumulatorSet<Arithmetic, Atomicity, typename CountAcc<Atomicity, Arithmetic>::InputType, CountAcc, SumAcc> {
    static_assert( std::is_same_v<typename CountAcc<Atomicity, Arithmetic>::InputType,
                                  typename SumAcc<Atomicity, Arithmetic>::InputType>,
                   "Incompatible Counters in definition of AveragingAccumulator. Both should have identical Input" );
    using AccumulatorSet<Arithmetic, Atomicity, typename CountAcc<Atomicity, Arithmetic>::InputType, CountAcc,
                         SumAcc>::AccumulatorSet;
    template <typename Result = fp_result_type<Arithmetic>>
    auto mean() const {
      auto   n   = this->nEntries();
      Result sum = this->sum();
      return ( n > 0 ) ? static_cast<Result>( sum / n ) : Result{};
    }
  };

  template <atomicity Atomicity, typename Arithmetic>
  using AveragingAccumulator = AveragingAccumulatorBase<Atomicity, Arithmetic, CountAccumulator, SumAccumulator>;

  template <atomicity Atomicity, typename Arithmetic, template <atomicity, typename> typename AvgAcc,
            template <atomicity, typename> typename SquareAcc>
  struct SigmaAccumulatorBase
      : AccumulatorSet<Arithmetic, Atomicity, typename AvgAcc<Atomicity, Arithmetic>::InputType, AvgAcc, SquareAcc> {
    static_assert( std::is_same_v<typename AvgAcc<Atomicity, Arithmetic>::InputType,
                                  typename SquareAcc<Atomicity, Arithmetic>::InputType>,
                   "Incompatible Counters in definition of SigmaAccumulator. Both should have identical Input" );
    using AccumulatorSet<Arithmetic, Atomicity, typename SquareAcc<Atomicity, Arithmetic>::InputType, AvgAcc,
                         SquareAcc>::AccumulatorSet;
    template <typename Result = fp_result_type<Arithmetic>>
    auto biased_sample_variance() const {
      auto   n   = this->nEntries();
      Result sum = this->sum();
      return ( n > 0 ) ? static_cast<Result>( ( this->sum2() - sum * ( sum / n ) ) / n ) : Result{};
    }
 
    template <typename Result = fp_result_type<Arithmetic>>
    auto unbiased_sample_variance() const {
      auto   n   = this->nEntries();
      Result sum = this->sum();
      return ( n > 1 ) ? static_cast<Result>( ( this->sum2() - sum * ( sum / n ) ) / ( n - 1 ) ) : Result{};
    }
 
    template <typename Result = fp_result_type<Arithmetic>>
    auto standard_deviation() const {
      // Note the usage of using, aiming at using the std version of sqrt by default, without preventing
      // more specialized versions to be used via ADL (see http://en.cppreference.com/w/cpp/language/adl)
      using Gaudi::Accumulators::sqrt;
      using std::sqrt;
      Result v = biased_sample_variance();
      return ( Result{ 0 } > v ) ? Result{} : static_cast<Result>( sqrt( v ) );
    }
    [[deprecated( "The name 'rms' has changed to standard_deviation" )]] Arithmetic rms() const {
      return standard_deviation();
    }
 
    template <typename Result = fp_result_type<Arithmetic>>
    auto meanErr() const {
      auto n = this->nEntries();
      if ( 0 == n ) return Result{};
      // Note the usage of using, aiming at using the std version of sqrt by default, without preventing
      // more specialized versions to be used via ADL (see http://en.cppreference.com/w/cpp/language/adl)
      using Gaudi::Accumulators::sqrt;
      using std::sqrt;
      Result v = biased_sample_variance();
      return ( Result{ 0 } > v ) ? Result{} : static_cast<Result>( sqrt( v / n ) );
    }
  };

  template <atomicity Atomicity, typename Arithmetic>
  using SigmaAccumulator = SigmaAccumulatorBase<Atomicity, Arithmetic, AveragingAccumulator, SquareAccumulator>;

  template <atomicity Atomicity, typename Arithmetic>
  using StatAccumulator =
      AccumulatorSet<Arithmetic, Atomicity, Arithmetic, SigmaAccumulator, MinAccumulator, MaxAccumulator>;

  template <template <atomicity Ato, typename... Int> class ContainedAccumulator, atomicity Atomicity, typename... Args>
  class Buffer : public ContainedAccumulator<atomicity::none, Args...> {
    using prime_type = ContainedAccumulator<Atomicity, Args...>;
    using base_type  = ContainedAccumulator<atomicity::none, Args...>;
 
  public:
    Buffer() = delete;
    Buffer( prime_type& p ) : base_type( construct_empty, p ), m_prime( &p ) {}
    Buffer( const Buffer& )         = delete;
    void operator=( const Buffer& ) = delete;
    Buffer( Buffer&& other ) : base_type( std::move( other ) ), m_prime( other.m_prime ) { other.m_prime = nullptr; }
    void push() {
      if ( m_prime ) { m_prime->mergeAndReset( static_cast<base_type&>( *this ) ); }
    }
    ~Buffer() { push(); }
 
  private:
    prime_type* m_prime = nullptr;
  };

  struct PrintableCounter {
    PrintableCounter() = default;
    virtual ~PrintableCounter() = default;
    // add tag to printout
    template <typename stream>
    stream& printImpl( stream& s, std::string_view tag ) const {
      s << boost::format{ " | %|-48.48s|%|50t|" } % ( std::string{ '\"' }.append( tag ).append( "\"" ) );
      return print( s, true );
    }

    virtual std::ostream& print( std::ostream&, bool tableFormat = false ) const = 0;
    virtual MsgStream&    print( MsgStream&, bool tableFormat = true ) const     = 0;
    virtual std::ostream& print( std::ostream& o, std::string_view tag ) const { return printImpl( o, tag ); }
    virtual MsgStream&    print( MsgStream& o, std::string_view tag ) const { return printImpl( o, tag ); }
    virtual bool toBePrinted() const { return true; }
    std::string toString() const {
      std::ostringstream ost;
      print( ost );
      return ost.str();
    }
  };

  inline std::ostream& operator<<( std::ostream& s, const PrintableCounter& counter ) { return counter.print( s ); }
  inline MsgStream&    operator<<( MsgStream& s, const PrintableCounter& counter ) { return counter.print( s ); }
  template <atomicity Atomicity, template <atomicity Ato, typename... Int> class Accumulator, typename... Args>
  class BufferableCounter : public PrintableCounter, public Accumulator<Atomicity, Args...> {
  public:
    using Accumulator<Atomicity, Args...>::Accumulator;
    using BufferType    = Buffer<Accumulator, Atomicity, Args...>;
    BufferableCounter() = default;
    template <typename OWNER>
    BufferableCounter( OWNER* o, std::string const& name ) : BufferableCounter( o, name, *this ) {}
    BufferType buffer() { return { *this }; }
    BufferableCounter( BufferableCounter const& )            = delete;
    BufferableCounter& operator=( BufferableCounter const& ) = delete;
    ~BufferableCounter() {
      if ( m_monitoringHub ) { m_monitoringHub->removeEntity( *this ); }
    }
 
    inline static const std::string typeString{ "counter" };
 
  protected:
    template <typename OWNER, typename SELF, typename... CARGS>
    BufferableCounter( OWNER* o, std::string const& name, SELF& self, CARGS... args )
        : Accumulator<Atomicity, Args...>( args... ), m_monitoringHub( &o->serviceLocator()->monitoringHub() ) {
      m_monitoringHub->registerEntity( o->name(), name, self.typeString, self );
    }
 
  private:
    Monitoring::Hub* m_monitoringHub{ nullptr };
  };

  template <atomicity Atomicity = atomicity::full, typename Arithmetic = unsigned long>
  struct Counter : BufferableCounter<Atomicity, IntegralAccumulator, Arithmetic> {
    inline static const std::string typeString{ std::string{ "counter:Counter:" } + typeid( Arithmetic ).name() };
    using BufferableCounter<Atomicity, IntegralAccumulator, Arithmetic>::BufferableCounter;
    template <typename OWNER>
    Counter( OWNER* o, std::string const& name )
        : BufferableCounter<Atomicity, IntegralAccumulator, Arithmetic>( o, name, *this ) {}
    Counter& operator++() { return ( *this ) += 1; }
    Counter& operator+=( const Arithmetic v ) {
      BufferableCounter<Atomicity, IntegralAccumulator, Arithmetic>::operator+=( v );
      return *this;
    }
    using BufferableCounter<Atomicity, IntegralAccumulator, Arithmetic>::print;
 
    template <typename stream>
    stream& printImpl( stream& o, bool tableFormat ) const {
      // Avoid printing empty counters in non DEBUG mode
      auto fmt = ( tableFormat ? "|%|10d| |" : "#=%|-7lu|" );
      return o << boost::format{ fmt } % this->nEntries();
    }
 
    std::ostream& print( std::ostream& o, bool tableFormat = false ) const override {
      return printImpl( o, tableFormat );
    }
    MsgStream&  print( MsgStream& o, bool tableFormat = false ) const override { return printImpl( o, tableFormat ); }
    bool        toBePrinted() const override { return this->nEntries() > 0; }
    friend void reset( Counter& c ) { c.reset(); }
    friend void mergeAndReset( Counter& c, Counter& o ) { c.mergeAndReset( o ); }
    friend void to_json( nlohmann::json& j, Counter const& c ) {
      j = { { "type", c.typeString }, { "empty", c.nEntries() == 0 }, { "nEntries", c.nEntries() } };
    }
    static Counter fromJSON( const nlohmann::json& j ) {
      return IntegralAccumulator<Atomicity, Arithmetic>::extractJSONData( j, { "nEntries" } );
    }
  };

  template <typename Arithmetic = double, atomicity Atomicity = atomicity::full>
  struct AveragingCounter : BufferableCounter<Atomicity, AveragingAccumulator, Arithmetic> {
    inline static const std::string typeString{ std::string{ "counter:AveragingCounter:" } +
                                                typeid( Arithmetic ).name() };
    using BufferableCounter<Atomicity, AveragingAccumulator, Arithmetic>::BufferableCounter;
    template <typename OWNER>
    AveragingCounter( OWNER* o, std::string const& name )
        : BufferableCounter<Atomicity, AveragingAccumulator, Arithmetic>( o, name, *this ) {}
    using BufferableCounter<Atomicity, AveragingAccumulator, Arithmetic>::print;
 
    template <typename stream>
    stream& printImpl( stream& o, bool tableFormat ) const {
      auto fmt = ( tableFormat ? "|%|10d| |%|11.7g| |%|#11.5g| |" : "#=%|-7lu| Sum=%|-11.5g| Mean=%|#10.4g|" );
      return o << boost::format{ fmt } % this->nEntries() % this->sum() % this->mean();
    }
 
    std::ostream& print( std::ostream& o, bool tableFormat = false ) const override {
      return printImpl( o, tableFormat );
    }
    MsgStream& print( MsgStream& o, bool tableFormat = false ) const override { return printImpl( o, tableFormat ); }
 
    bool        toBePrinted() const override { return this->nEntries() > 0; }
    friend void reset( AveragingCounter& c ) { return c.reset(); }
    friend void mergeAndReset( AveragingCounter& c, AveragingCounter& o ) { c.mergeAndReset( o ); }
    friend void to_json( nlohmann::json& j, AveragingCounter const& c ) {
      j = { { "type", c.typeString },
            { "empty", c.nEntries() == 0 },
            { "nEntries", c.nEntries() },
            { "sum", c.sum() },
            { "mean", c.mean() } };
    }
    static AveragingCounter fromJSON( const nlohmann::json& j ) {
      return AveragingAccumulator<Atomicity, Arithmetic>::extractJSONData( j, { "nEntries", "sum" } );
    }
  };
  template <typename Arithmetic = double, atomicity Atomicity = atomicity::full>
  using SummingCounter = AveragingCounter<Arithmetic, Atomicity>;

  template <typename Arithmetic = double, atomicity Atomicity = atomicity::full>
  struct SigmaCounter : BufferableCounter<Atomicity, SigmaAccumulator, Arithmetic> {
    inline static const std::string typeString{ std::string{ "counter:SigmaCounter:" } + typeid( Arithmetic ).name() };
    using BufferableCounter<Atomicity, SigmaAccumulator, Arithmetic>::BufferableCounter;
    template <typename OWNER>
    SigmaCounter( OWNER* o, std::string const& name )
        : BufferableCounter<Atomicity, SigmaAccumulator, Arithmetic>( o, name, *this ) {}
    using BufferableCounter<Atomicity, SigmaAccumulator, Arithmetic>::print;
 
    template <typename stream>
    stream& printImpl( stream& o, bool tableFormat ) const {
      auto fmt = ( tableFormat ? "|%|10d| |%|11.7g| |%|#11.5g| |%|#11.5g| |"
                               : "#=%|-7lu| Sum=%|-11.5g| Mean=%|#10.4g| +- %|-#10.5g|" );
      return o << boost::format{ fmt } % this->nEntries() % this->sum() % this->mean() % this->standard_deviation();
    }
 
    std::ostream& print( std::ostream& o, bool tableFormat = false ) const override {
      return printImpl( o, tableFormat );
    }
    MsgStream&  print( MsgStream& o, bool tableFormat = false ) const override { return printImpl( o, tableFormat ); }
    bool        toBePrinted() const override { return this->nEntries() > 0; }
    friend void reset( SigmaCounter& c ) { c.reset(); }
    friend void mergeAndReset( SigmaCounter& c, SigmaCounter& o ) { c.mergeAndReset( o ); }
    friend void to_json( nlohmann::json& j, SigmaCounter const& c ) {
      j = { { "type", c.typeString },
            { "empty", c.nEntries() == 0 },
            { "nEntries", c.nEntries() },
            { "sum", c.sum() },
            { "mean", c.mean() },
            { "sum2", c.sum2() },
            { "standard_deviation", c.standard_deviation() } };
    }
    static SigmaCounter fromJSON( const nlohmann::json& j ) {
      return SigmaAccumulator<Atomicity, Arithmetic>::extractJSONData( j, { { "nEntries", "sum" }, "sum2" } );
    }
  };

  template <typename Arithmetic = double, atomicity Atomicity = atomicity::full>
  struct StatCounter : BufferableCounter<Atomicity, StatAccumulator, Arithmetic> {
    inline static const std::string typeString{ std::string{ "counter:StatCounter:" } + typeid( Arithmetic ).name() };
    using BufferableCounter<Atomicity, StatAccumulator, Arithmetic>::BufferableCounter;
    template <typename OWNER>
    StatCounter( OWNER* o, std::string const& name )
        : BufferableCounter<Atomicity, StatAccumulator, Arithmetic>( o, name, *this ) {}
    using BufferableCounter<Atomicity, StatAccumulator, Arithmetic>::print;
 
    template <typename stream>
    stream& printImpl( stream& o, bool tableFormat ) const {
      auto fmt = ( tableFormat ? "|%|10d| |%|11.7g| |%|#11.5g| |%|#11.5g| |%|#12.5g| |%|#12.5g| |"
                               : "#=%|-7lu| Sum=%|-11.5g| Mean=%|#10.4g| +- %|-#10.5g| Min/Max=%|#10.4g|/%|-#10.4g|" );
      return o << boost::format{ fmt } % this->nEntries() % this->sum() % this->mean() % this->standard_deviation() %
                      this->min() % this->max();
    }
 
    std::ostream& print( std::ostream& o, bool tableFormat = false ) const override {
      return printImpl( o, tableFormat );
    }
    MsgStream&  print( MsgStream& o, bool tableFormat = false ) const override { return printImpl( o, tableFormat ); }
    bool        toBePrinted() const override { return this->nEntries() > 0; }
    friend void reset( StatCounter& c ) { c.reset(); }
    friend void mergeAndReset( StatCounter& c, StatCounter& o ) { c.mergeAndReset( o ); }
    friend void to_json( nlohmann::json& j, StatCounter const& c ) {
      j = { { "type", c.typeString },
            { "empty", c.nEntries() == 0 },
            { "nEntries", c.nEntries() },
            { "sum", c.sum() },
            { "mean", c.mean() },
            { "sum2", c.sum2() },
            { "standard_deviation", c.standard_deviation() },
            { "min", c.min() },
            { "max", c.max() } };
    }
    static StatCounter fromJSON( const nlohmann::json& j ) {
      return StatAccumulator<Atomicity, Arithmetic>::extractJSONData(
          j, { { { "nEntries", "sum" }, "sum2" }, "min", "max" } );
    }
  };

  template <typename Arithmetic = double, atomicity Atomicity = atomicity::full>
  struct BinomialCounter : BufferableCounter<Atomicity, BinomialAccumulator, Arithmetic> {
    inline static const std::string typeString{ std::string{ "counter:BinomialCounter:" } +
                                                typeid( Arithmetic ).name() };
    using BufferableCounter<Atomicity, BinomialAccumulator, Arithmetic>::BufferableCounter;
    template <typename OWNER>
    BinomialCounter( OWNER* o, std::string const& name )
        : BufferableCounter<Atomicity, BinomialAccumulator, Arithmetic>( o, name, *this ) {}
 
    template <typename stream>
    stream& printImpl( stream& o, bool tableFormat ) const {
      auto fmt = ( tableFormat ? "|%|10d| |%|11.5g| |(%|#9.7g| +- %|-#8.7g|)%% |"
                               : "#=%|-7lu| Sum=%|-11.5g| Eff=|(%|#9.7g| +- %|-#8.6g|)%%|" );
      return o << boost::format{ fmt } % this->nEntries() % this->nTrueEntries() % ( this->efficiency() * 100 ) %
                      ( this->efficiencyErr() * 100 );
    }
 
    std::ostream& print( std::ostream& o, bool tableFormat = false ) const override {
      return printImpl( o, tableFormat );
    }
    MsgStream& print( MsgStream& o, bool tableFormat = false ) const override { return printImpl( o, tableFormat ); }
 
    template <typename stream>
    stream& printImpl( stream& o, std::string_view tag ) const {
      // override default print to add a '*' in from of the name
      o << boost::format{ " |*%|-48.48s|%|50t|" } % ( std::string{ "\"" }.append( tag ).append( "\"" ) );
      return print( o, true );
    }

    std::ostream& print( std::ostream& o, std::string_view tag ) const override { return printImpl( o, tag ); }
    MsgStream&    print( MsgStream& o, std::string_view tag ) const override { return printImpl( o, tag ); }
    bool          toBePrinted() const override { return this->nEntries() > 0; }
    friend void   reset( BinomialCounter& c ) { c.reset(); }
    friend void   mergeAndReset( BinomialCounter& c, BinomialCounter& o ) { c.mergeAndReset( o ); }
    friend void   to_json( nlohmann::json& j, BinomialCounter const& c ) {
      j = { { "type", c.typeString },
              { "empty", c.nEntries() == 0 },
              { "nEntries", c.nTrueEntries() + c.nFalseEntries() },
              { "nTrueEntries", c.nTrueEntries() },
              { "nFalseEntries", c.nFalseEntries() },
              { "efficiency", c.efficiency() },
              { "efficiencyErr", c.efficiencyErr() } };
    }
    static BinomialCounter fromJSON( const nlohmann::json& j ) {
      return BinomialAccumulator<Atomicity, Arithmetic>::extractJSONData( j, { "nTrueEntries", "nFalseEntries" } );
    }
  };
 
  namespace details::MsgCounter {
    template <atomicity Atomicity>
    struct Handler : Adder<unsigned long, Atomicity> {
      using Base = Adder<unsigned long, Atomicity>;
      static void merge( typename Base::InternalType& orig, bool b ) {
        if ( b ) Base::merge( orig, 1 );
      }
    };
    // note that Arithmetic type is unused in this case but needs to be there in case
    // we want to create AccumulatorSets with this Accumulator
    template <atomicity Atomicity, typename Arithmetic = double>
    using MsgAccumulator = GenericAccumulator<bool, unsigned long, Atomicity, Identity, Identity, Handler<Atomicity>>;
  } // namespace details::MsgCounter
 
  template <MSG::Level level, atomicity Atomicity = atomicity::full>
  class MsgCounter : public PrintableCounter, public details::MsgCounter::MsgAccumulator<Atomicity> {
  public:
    inline static const std::string typeString{ "counter:MsgCounter" };
    template <typename OWNER>
    MsgCounter( OWNER* o, std::string const& ms, unsigned long nMax = 10 )
        : m_monitoringHub{ &o->serviceLocator()->monitoringHub() }, logger( o ), msg( ms ), max( nMax ) {
      m_monitoringHub->registerEntity( o->name(), ms, typeString, *this );
    }
    MsgCounter& operator++() {
      ( *this ) += true;
      return *this;
    }
    MsgCounter& operator+=( const bool by ) {
      details::MsgCounter::MsgAccumulator<Atomicity>::operator+=( by );
      if ( by ) log();
      return *this;
    }
    MsgCounter( MsgCounter const& )            = delete;
    MsgCounter& operator=( MsgCounter const& ) = delete;
    ~MsgCounter() {
      if ( m_monitoringHub ) m_monitoringHub->removeEntity( *this );
    }
    template <typename stream>
    stream& printImpl( stream& o, bool tableFormat ) const {
      return o << boost::format{ tableFormat ? "|%|10d| |" : "#=%|-7lu|" } % this->value();
    }
    using PrintableCounter::print;
    std::ostream& print( std::ostream& os, bool tableFormat ) const override { return printImpl( os, tableFormat ); }
    MsgStream&    print( MsgStream& os, bool tableFormat ) const override { return printImpl( os, tableFormat ); }
    bool          toBePrinted() const override { return this->value() > 0; }
    friend void   reset( MsgCounter& c ) { c.reset(); }
    friend void   mergeAndReset( MsgCounter& c, MsgCounter& o ) { c.mergeAndReset( o ); }
    friend void   to_json( nlohmann::json& j, MsgCounter const& c ) {
      j = { { "type", c.typeString },  { "empty", c.value() == 0 },
              { "nEntries", c.value() }, { "level", level },
              { "max", c.max },          { "msg", c.msg } };
    }
    static MsgCounter fromJSON( const nlohmann::json& j ) {
      return { j.at( "msg" ).get<std::string>(), j.at( "max" ).get<unsigned long>(),
               j.at( "nEntries" ).get<unsigned long>() };
    }
 
  private:
    MsgCounter( std::string const& ms, unsigned long nMax, unsigned long count )
        : details::MsgCounter::MsgAccumulator<Atomicity>{ count }, msg( ms ), max( nMax ) {}
 
    Monitoring::Hub*           m_monitoringHub{ nullptr };
    const CommonMessagingBase* logger{ nullptr };
    std::string                msg;
    unsigned long              max;
    void                       log() {
      if ( this->value() <= max && logger ) {
        if ( this->value() == max ) {
          logger->msgStream( level ) << "Suppressing message: " << std::quoted( msg, '\'' ) << endmsg;
        } else {
          logger->msgStream( level ) << msg << endmsg;
        }
      }
    }
  };

  template <typename Counter, typename Container, typename Fun>
  void accumulate( Counter& counter, const Container& container, Fun f = Identity{} ) {
    auto b = counter.buffer();
    for ( const auto& elem : container ) b += f( elem );
  }
 
} // namespace Gaudi::Accumulators