GenericTimer.h

Go to the documentation of this file.

#pragma once

#include "Gaudi/Chrono/Counters.h"

#include <atomic>
#include <chrono>

namespace Gaudi {
  namespace Timers {
    template <typename Clock, typename Unit>
    class GenericTimer {
    public:
      typedef Gaudi::Accumulators::StatCounter<Unit> Stats_t;

      class ScopeTimer {
      public:
        ScopeTimer( Stats_t& stat ) : m_stats( stat ), m_t0( Clock::now() ) {}

        ~ScopeTimer() { stop(); }

        auto elapsed() const {
          // Fenced according to https://codereview.stackexchange.com/q/196245
          std::atomic_thread_fence( std::memory_order_relaxed );
          auto dt = Clock::now() - m_t0;
          std::atomic_thread_fence( std::memory_order_relaxed );
          return std::chrono::duration_cast<Unit>( dt );
        }

      private:
        void stop() const { m_stats += elapsed(); }

        Stats_t&                   m_stats; 
        typename Clock::time_point m_t0;    
      };

      GenericTimer() = default;

      template <class OWNER>
      GenericTimer( OWNER* o, const std::string& name ) {
        o->declareCounter( name, m_stats );
      }

      GenericTimer( const GenericTimer& ) = delete;

      [[nodiscard]] auto operator()() const { return ScopeTimer( m_stats ); }

      const Stats_t& stats() const { return m_stats; }

    private:
      mutable Stats_t m_stats; 
    };

  } // namespace Timers
} // namespace Gaudi