Counters.h

Go to the documentation of this file.

#ifndef GAUDIKERNEL_COUNTERS_H
#define GAUDIKERNEL_COUNTERS_H 1

#include "boost/algorithm/string/predicate.hpp"
#include "boost/format.hpp"
#include <atomic>
#include <cmath>
#include <iostream>
#include <limits>
#include <sstream>
#include <tuple>
#include <type_traits>
#include <utility>

#include "GaudiKernel/CommonMessaging.h"
#include "GaudiKernel/MsgStream.h"
#include "GaudiKernel/detected.h"

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 T, typename = int>
  using has_fetch_add_ = decltype( std::atomic<T>{}.fetch_add( 0 ) );
  template <typename T>
  inline constexpr bool has_fetch_add_v = Gaudi::cpp17::is_detected_v<has_fetch_add_, T>;

  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 = atomicity::full>
  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 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 ( DefaultValue() == b ) return; // avoid atomic operation if b is "0"
      if constexpr ( has_fetch_add_v<InternalType> ) {
        a.fetch_add( b, std::memory_order_relaxed );
      } else {
        auto current = BaseValueHandler<Arithmetic, atomicity::full>::getValue( a );
        while ( !a.compare_exchange_weak( current, current + b ) )
          ;
      }
    };
  };

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

  template <typename Arithmetic, typename Compare, Arithmetic ( *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(); }
    static void                 merge( InternalType& a, Arithmetic b ) noexcept {
      if ( Compare{}( b, a ) ) a = b;
    };
  };

  template <typename Arithmetic, typename Compare, Arithmetic ( *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(); }
    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>, std::numeric_limits<Arithmetic>::max>;

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

  template <typename InputType, 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 OutputType = std::decay_t<std::result_of_t<OutputTransform( InnerType )>>;
    GenericAccumulator operator+=( const InputType by ) {
      ValueHandler::merge( m_value, InputTransform{}( by ) );
      return *this;
    }
    GenericAccumulator() : m_value( ValueHandler::DefaultValue() ) {}
    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() ) );
    }

  protected:
    void reset( InnerType in ) { m_value = std::move( in ); }

  private:
    typename ValueHandler::InternalType m_value;
  };

  template <typename Arithmetic, atomicity Atomicity, template <typename, atomicity> class... Bases>
  class AccumulatorSet : public Bases<Arithmetic, Atomicity>... {
  public:
    using InputType            = Arithmetic;
    using OutputType           = std::tuple<typename Bases<Arithmetic, Atomicity>::OutputType...>;
    constexpr AccumulatorSet() = default;
    AccumulatorSet& operator+=( const InputType by ) {
      ( Bases<Arithmetic, Atomicity>::operator+=( by ), ... );
      return *this;
    }
    OutputType value() const { return std::make_tuple( Bases<Arithmetic, Atomicity>::value()... ); }
    void       reset() { ( Bases<Arithmetic, Atomicity>::reset(), ... ); }
    template <atomicity Ato>
    void mergeAndReset( AccumulatorSet<Arithmetic, Ato, Bases...>&& other ) {
      ( Bases<Arithmetic, Atomicity>::mergeAndReset( static_cast<Bases<Arithmetic, Ato>&&>( other ) ), ... );
    }

  protected:
    void reset( const std::tuple<typename Bases<Arithmetic, Atomicity>::OutputType...>& t ) {
      std::apply( [this]( const auto&... i ) { ( this->Bases<Arithmetic, Atomicity>::reset( i ), ... ); }, t );
    }
  };

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

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

  template <typename Arithmetic = double, atomicity Atomicity = atomicity::full>
  struct CountAccumulator : GenericAccumulator<Arithmetic, unsigned long, Atomicity, Constant<unsigned long, 1UL>> {
    unsigned long nEntries() const { return this->value(); }
  };

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

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

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

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

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

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

  template <typename Arithmetic, atomicity Atomicity = atomicity::full>
  struct BinomialAccumulator : AccumulatorSet<bool, Atomicity, TrueAccumulator, FalseAccumulator> {
    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(); }
  };

  template <typename Arithmetic, atomicity Atomicity = atomicity::full>
  struct AveragingAccumulator : AccumulatorSet<Arithmetic, Atomicity, CountAccumulator, SumAccumulator> {

    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 <typename Arithmetic, atomicity Atomicity = atomicity::full>
  struct SigmaAccumulator : AccumulatorSet<Arithmetic, Atomicity, AveragingAccumulator, SquareAccumulator> {

    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 <typename Arithmetic, atomicity Atomicity = atomicity::full>
  using StatAccumulator = AccumulatorSet<Arithmetic, Atomicity, SigmaAccumulator, MinAccumulator, MaxAccumulator>;

  template <typename Arithmetic, template <typename Int, atomicity Ato> class ContainedAccumulator>
  class Buffer : public ContainedAccumulator<Arithmetic, atomicity::none> {
    using prime_type = ContainedAccumulator<Arithmetic, atomicity::full>;
    using base_type  = ContainedAccumulator<Arithmetic, atomicity::none>;

  public:
    Buffer() = delete;
    Buffer( prime_type& p ) : base_type(), m_prime( p ) {}
    Buffer( const Buffer& ) = delete;
    void operator=( const Buffer& ) = delete;
    Buffer( Buffer&& other ) : base_type( other ), m_prime( other.m_prime ) { other.reset(); }
    void push() { m_prime.mergeAndReset( static_cast<base_type&&>( *this ) ); }
    ~Buffer() { push(); }

  private:
    prime_type& m_prime;
  };

  struct PrintableCounter {
    PrintableCounter() = default;
    template <class OWNER>
    PrintableCounter( OWNER* o, const std::string& tag ) {
      o->declareCounter( tag, *this );
    }
    virtual ~PrintableCounter() = default;
    // add tag to printout
    template <typename stream>
    stream& printImpl( stream& s, const std::string& tag ) const {
      s << boost::format{" | %|-48.48s|%|50t|"} % ( "\"" + tag + "\"" );
      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, const std::string& tag ) const { return printImpl( o, tag ); }
    virtual MsgStream&    print( MsgStream& o, const std::string& 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 <typename Arithmetic, atomicity Atomicity, template <typename Int, atomicity Ato> class Accumulator>
  struct BufferableCounter : PrintableCounter {
    using PrintableCounter::PrintableCounter;
    Buffer<Arithmetic, Accumulator> buffer() { return {*static_cast<Accumulator<Arithmetic, Atomicity>*>( this )}; }
  };

  template <typename Arithmetic = double, atomicity Atomicity = atomicity::full>
  struct Counter : BufferableCounter<Arithmetic, Atomicity, Counter>, CountAccumulator<Arithmetic, Atomicity> {
    using BufferableCounter<Arithmetic, Atomicity, Counter>::BufferableCounter;
    Counter& operator++() {
      ( *this ) += Arithmetic{};
      return *this;
    }
    Counter operator++( int ) {
      auto copy = *this;
      ++( *this );
      return copy;
    }
    using BufferableCounter<Arithmetic, Atomicity, Counter>::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;
      ;
    }
  };

  template <typename Arithmetic = double, atomicity Atomicity = atomicity::full>
  struct AveragingCounter : BufferableCounter<Arithmetic, Atomicity, AveragingCounter>,
                            AveragingAccumulator<Arithmetic, Atomicity> {
    using BufferableCounter<Arithmetic, Atomicity, AveragingCounter>::BufferableCounter;
    using BufferableCounter<Arithmetic, Atomicity, AveragingCounter>::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;
      ;
    }
  };
  template <typename Arithmetic = double, atomicity Atomicity = atomicity::full>
  using SummingCounter = AveragingCounter<Arithmetic, Atomicity>;

  template <typename Arithmetic = double, atomicity Atomicity = atomicity::full>
  struct SigmaCounter : BufferableCounter<Arithmetic, Atomicity, SigmaCounter>,
                        SigmaAccumulator<Arithmetic, Atomicity> {
    using BufferableCounter<Arithmetic, Atomicity, SigmaCounter>::BufferableCounter;
    using BufferableCounter<Arithmetic, Atomicity, SigmaCounter>::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;
      ;
    }
  };

  template <typename Arithmetic = double, atomicity Atomicity = atomicity::full>
  struct StatCounter : BufferableCounter<Arithmetic, Atomicity, StatCounter>, StatAccumulator<Arithmetic, Atomicity> {
    using BufferableCounter<Arithmetic, Atomicity, StatCounter>::BufferableCounter;
    using BufferableCounter<Arithmetic, Atomicity, StatCounter>::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; }
  };

  template <typename Arithmetic = double, atomicity Atomicity = atomicity::full>
  struct BinomialCounter : BufferableCounter<Arithmetic, Atomicity, BinomialCounter>,
                           BinomialAccumulator<Arithmetic, Atomicity> {
    using BufferableCounter<Arithmetic, Atomicity, BinomialCounter>::BufferableCounter;

    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, const std::string& tag ) const {
      // override default print to add a '*' in from of the name
      o << boost::format{" |*%|-48.48s|%|50t|"} % ( "\"" + tag + "\"" );
      return print( o, true );
    }
    std::ostream& print( std::ostream& o, const std::string& tag ) const override { return printImpl( o, tag ); }
    MsgStream&    print( MsgStream& o, const std::string& tag ) const override { return printImpl( o, tag ); }
    bool          toBePrinted() const override { return this->nEntries() > 0; }
  };

  namespace details::MsgCounter {
    struct Logger {
      CommonMessagingBase const* parent;
      std::string                msg;
      MSG::Level                 lvl;

      void operator()( bool suppress = false ) const {
        if ( suppress ) {
          parent->msgStream( lvl ) << "Suppressing message: " << std::quoted( msg, '\'' ) << endmsg;
        } else {
          parent->msgStream( lvl ) << msg << endmsg;
        }
      }
    };

    template <atomicity Atomicity>
    struct Data {
      std::conditional_t<Atomicity == atomicity::none, unsigned long, std::atomic<unsigned long>> count  = {0};
      unsigned long                                                                               max    = 0;
      Logger const*                                                                               logger = nullptr;

      constexpr Data( Logger const* p, unsigned long mx ) : max{mx}, logger{p} {}

      template <atomicity OtherAtomicity>
      Data( Data<OtherAtomicity> const& other ) {
        count  = other.count;
        max    = other.max;
        logger = other.logger;
      }
    };

    template <atomicity Atomicity>
    struct Handler {
      using InternalType = Data<Atomicity>;
      using OutputType   = Data<atomicity::none>;

      static constexpr OutputType getValue( InternalType const& v ) noexcept { return v; }

      static void merge( InternalType& orig, bool b ) {
        if ( b ) {
          auto count = ++orig.count;
          if ( UNLIKELY( count <= orig.max ) ) ( *orig.logger )( count == orig.max );
        }
      }
    };
    struct OutputTransform {
      template <atomicity Atomicity>
      constexpr unsigned long operator()( Data<Atomicity> const& v ) const noexcept {
        return v.count;
      }
    };
  } // namespace details::MsgCounter

  template <MSG::Level level, atomicity Atomicity = atomicity::full>
  struct MsgCounter
      : PrintableCounter,
        details::MsgCounter::Logger,
        GenericAccumulator<bool, details::MsgCounter::Data<Atomicity>, Atomicity, Identity,
                           details::MsgCounter::OutputTransform, details::MsgCounter::Handler<Atomicity>> {
    template <typename OWNER>
    MsgCounter( OWNER* o, std::string const& msg, int nMax = 10 )
        : PrintableCounter( o, msg )
        , details::MsgCounter::Logger{o, msg, level}
        , GenericAccumulator<bool, details::MsgCounter::Data<Atomicity>, Atomicity, Identity,
                             details::MsgCounter::OutputTransform, details::MsgCounter::Handler<Atomicity>>{
              std::in_place, this, nMax} {}
    MsgCounter& operator++() {
      ( *this ) += true;
      return *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 ); }
  };

  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

class StatEntity : public Gaudi::Accumulators::PrintableCounter,
                   public Gaudi::Accumulators::AccumulatorSet<double, Gaudi::Accumulators::atomicity::full,
                                                              Gaudi::Accumulators::StatAccumulator,
                                                              Gaudi::Accumulators::BinomialAccumulator> {
public:
  using AccParent         = Gaudi::Accumulators::AccumulatorSet<double, Gaudi::Accumulators::atomicity::full,
                                                        Gaudi::Accumulators::StatAccumulator,
                                                        Gaudi::Accumulators::BinomialAccumulator>;
  using BinomialAccParent = Gaudi::Accumulators::BinomialAccumulator<double, Gaudi::Accumulators::atomicity::full>;
  using Gaudi::Accumulators::StatAccumulator<double, Gaudi::Accumulators::atomicity::full>::nEntries;
  using AccParent::reset;
  StatEntity() = default;
  template <class OWNER>
  StatEntity( OWNER* o, const std::string& tag ) {
    o->declareCounter( tag, *this );
  }
  StatEntity( const unsigned long entries, const double flag, const double flag2, const double minFlag,
              const double maxFlag ) {
    reset( std::make_tuple(
        std::make_tuple( std::make_tuple( std::make_tuple( entries, flag ), flag2 ), minFlag, maxFlag ),
        std::make_tuple( 0, 0 ) ) );
  }
  void reset() { AccParent::reset(); }
  void operator=( double by ) {
    this->reset();
    ( *this ) += by;
  }
  StatEntity& operator-=( double by ) {
    ( *this ) += ( -by );
    return *this;
  }
  StatEntity& operator++() {
    ( *this ) += 1.0;
    return *this;
  }
  StatEntity operator++( int ) {
    auto copy = *this;
    ++( *this );
    return copy;
  }
  StatEntity& operator--() {
    ( *this ) += -1.0;
    return *this;
  }
  StatEntity operator--( int ) {
    auto copy = *this;
    --( *this );
    return copy;
  }
  bool operator<( const StatEntity& se ) const {
    return std::make_tuple( nEntries(), sum(), min(), max(), sum2() ) <
           std::make_tuple( se.nEntries(), se.sum(), se.min(), se.max(), se.sum2() );
  };
  // using AccumulatorSet::operator+=;
  StatEntity& operator+=( double by ) {
    this->AccumulatorSet::operator+=( by );
    return *this;
  }
  StatEntity& operator+=( StatEntity by ) {
    mergeAndReset( std::move( by ) );
    return *this;
  }
  unsigned long add( const double v ) {
    *this += v;
    return nEntries();
  }
  unsigned long addFlag( const double v ) { return add( v ); }
  // aliases (a'la ROOT)
  double Sum() const { return sum(); }                // get sum
  double Mean() const { return mean(); }              // get mean
  double MeanErr() const { return meanErr(); }        // get error in mean
  double rms() const { return standard_deviation(); } // get rms
  double Rms() const { return standard_deviation(); } // get rms
  double RMS() const { return standard_deviation(); } // get rms
  double Eff() const { return eff(); }                // get efficiency
  double Min() const { return min(); }                // get minimal value
  double Max() const { return max(); }                // get maximal value
  // some legacy methods, to be removed ...
  double      flag() const { return sum(); }
  double      flag2() const { return sum2(); }
  double      flagMean() const { return mean(); }
  double      flagRMS() const { return standard_deviation(); }
  double      flagMeanErr() const { return meanErr(); }
  double      flagMin() const { return min(); }
  double      flagMax() const { return max(); }
  static bool effCounter( const std::string& name ) {
    using boost::algorithm::icontains;
    return icontains( name, "eff" ) || icontains( name, "acc" ) || icontains( name, "filt" ) ||
           icontains( name, "fltr" ) || icontains( name, "pass" );
  }
  template <typename stream>
  stream& printFormattedImpl( stream& o, const std::string& format ) const {
    boost::format fmt{format};
    fmt % nEntries() % sum() % mean() % standard_deviation() % min() % max();
    return o << fmt.str();
  }
  std::ostream& printFormatted( std::ostream& o, const std::string& format ) const {
    return printFormattedImpl( o, format );
  }
  MsgStream& printFormatted( MsgStream& o, const std::string& format ) const { return printFormattedImpl( o, format ); }
  using Gaudi::Accumulators::PrintableCounter::print;
  template <typename stream>
  stream& printImpl( stream& o, bool tableFormat, const std::string& name, bool flag,
                     std::string const& fmtHead ) const {
    if ( flag && effCounter( name ) && 0 <= eff() && 0 <= effErr() && sum() <= nEntries() &&
         ( 0 == min() || 1 == min() ) && ( 0 == max() || 1 == max() ) ) {
      // efficiency printing
      if ( tableFormat ) {
        if ( name.empty() ) {
          constexpr auto fmt = "|%|10d| |%|11.5g| |(%|#9.7g| +- %|-#8.7g|)%%|   -------   |   -------   |";
          return o << boost::format{fmt} % BinomialAccParent::nEntries() % sum() % ( efficiency() * 100 ) %
                          ( efficiencyErr() * 100 );
        } else {
          auto fmt = " |*" + fmtHead + "|%|10d| |%|11.5g| |(%|#9.7g| +- %|-#8.7g|)%%|   -------   |   -------   |";
          return o << boost::format{fmt} % ( "\"" + name + "\"" ) % BinomialAccParent::nEntries() % sum() %
                          ( efficiency() * 100 ) % ( efficiencyErr() * 100 );
        }
      } else {
        constexpr auto fmt = "#=%|-7lu| Sum=%|-11.5g| Eff=|(%|#9.7g| +- %|-#8.6g|)%%|";
        return o << boost::format{fmt} % BinomialAccParent::nEntries() % sum() % ( efficiency() * 100 ) %
                        ( efficiencyErr() * 100 );
      }
    } else {
      // Standard printing
      if ( tableFormat ) {
        if ( name.empty() ) {
          constexpr auto fmt = "|%|10d| |%|11.7g| |%|#11.5g| |%|#11.5g| |%|#12.5g| |%|#12.5g| |";
          return o << boost::format{fmt} % nEntries() % sum() % mean() % standard_deviation() % min() % max();

        } else {
          auto fmt = " | " + fmtHead + "|%|10d| |%|11.7g| |%|#11.5g| |%|#11.5g| |%|#12.5g| |%|#12.5g| |";
          return o << boost::format{fmt} % ( "\"" + name + "\"" ) % nEntries() % sum() % mean() % standard_deviation() %
                          min() % max();
        }
      } else {
        constexpr auto fmt = "#=%|-7lu| Sum=%|-11.5g| Mean=%|#10.4g| +- %|-#10.5g| Min/Max=%|#10.4g|/%|-#10.4g|";
        return o << boost::format{fmt} % nEntries() % sum() % mean() % standard_deviation() % min() % max();
      }
    }
  }
  std::ostream& print( std::ostream& o, bool tableFormat, const std::string& name, bool flag = true,
                       std::string fmtHead = "%|-48.48s|%|27t|" ) const {
    return printImpl( o, tableFormat, name, flag, fmtHead );
  }
  MsgStream& print( MsgStream& o, bool tableFormat, const std::string& name, bool flag = true,
                    std::string fmtHead = "%|-48.48s|%|27t|" ) const {
    return printImpl( o, tableFormat, name, flag, fmtHead );
  }
  virtual std::ostream& print( std::ostream& o, const std::string& tag ) const override {
    return print( o, true, tag, true );
  }
  virtual MsgStream& print( MsgStream& o, const std::string& tag ) const override {
    return print( o, true, tag, true );
  }
  std::ostream& print( std::ostream& o, bool tableFormat = false ) const override {
    std::string emptyName;
    return print( o, tableFormat, emptyName, true );
  }
  MsgStream& print( MsgStream& o, bool tableFormat = false ) const override {
    std::string emptyName;
    return print( o, tableFormat, emptyName, true );
  }
  std::string toString() const {
    std::ostringstream ost;
    print( ost );
    return ost.str();
  }
  std::ostream& fillStream( std::ostream& o ) const { return print( o ); }
  MsgStream&    fillStream( MsgStream& o ) const { return print( o ); }
};

#endif // GAUDIKERNEL_COUNTERS_H