b2timing.H

//------------------------------------------------------------------------
// b2timing.H --
//
// written by Harald Klimach <harald.klimach@dlr.de>
//
// (c) 2024 Deutsches Zentrum für Luft- und Raumfahrt (DLR) e.V.
//          Linder Höhe, 51147 Köln
//
// All Rights Reserved.  Proprietary source code.  The contents of
// this file may not be disclosed to third parties, copied or
// duplicated in any form, in whole or in part, without the prior
// written permission of SMR or DLR.
//
// This timing infrastructure provides a map of timers that are uniquely
// identified by strings.
// After the creation of a timing object in that map of timers it can
// be started and stopped during program execution.
// There is no relation established between the timers and the regions
// they time may overlap or not. If you put timers into the code to
// assess the running times of different code segments you need to
// take care of those yourself.
// Timing information will be put into CSV files with one file per MPI
// rank. This can be controlled via the -timer-maxrank option. By default
// only the root process will write out its timing information.
//
// This is a convenience solution, as there are some problems with tracing
// OpenMP and TBB paralle programs.
//
//------------------------------------------------------------------------
 
#ifndef B2TIMING_H_
#define B2TIMING_H_
 
#include <chrono>
#include <iostream>
#include <map>
#include <string>
 
using namespace std::chrono_literals;
 
namespace b2000 {
 
class Timing {
public:
    Timing() {}
 
    void start();
 
    void stop();
 
    double avg_duration() const;
 
    size_t count() const;
 
    double duration() const;
 
    void print(std::ostream& out) const;
 
private:
    std::chrono::time_point<std::chrono::high_resolution_clock> start_;
    std::chrono::duration<double> duration_{0s};
    bool active_{false};
    size_t count_{0};
 
};  // class Timing
 
std::ostream& operator<<(std::ostream& out, const Timing& tim);
 
using timer_map_t = std::map<std::string, Timing>;
 
extern timer_map_t timers;
 
inline timer_map_t::iterator obtain_timer(std::string name) {
    return timers
          .emplace(std::piecewise_construct, std::forward_as_tuple(name), std::forward_as_tuple())
          .first;
}
 
void print_timers(std::string filename);
 
std::string timing_fn(std::string logdir, int rank);
 
}  // namespace b2000
 
#endif  // B2TIMING_H_