timing.hh

Go to the documentation of this file.

/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
/*                                                                           */
/*  This file is part of the library KASKADE 7                               */
/*  https://www.zib.de/research/projects/kaskade7-finite-element-toolbox     */
/*                                                                           */
/*  Copyright (C) 2016-2022 Zuse Institute Berlin                            */
/*                                                                           */
/*  KASKADE 7 is distributed under the terms of the ZIB Academic License.    */
/*    see $KASKADE/academic.txt                                              */
/*                                                                           */
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
 
#ifndef TIMING_HH
#define TIMING_HH
 
#include <chrono>
#include <memory>
#include <mutex>
#include <ostream>
#include <stack>
#include <vector>
 
 
namespace Kaskade
{
  class Timings;
 
  namespace Timings_Details
  {
    struct SectionBeacon
    {
      std::string name;
      Timings* timer;
    };
  }
 
 
  class Timings
  {
    struct Times;
 
  public:
    static Timings& instance();
    
    Timings();
    
    std::ostream& report(std::ostream& out, int maxlevel=1000) const;
 
    Timings_Details::SectionBeacon startSection(std::string const& name);
    
    struct Times const* start(std::string const& name);
    
    void stop(std::string const& name);
 
    void stop(struct Times const* ticket = nullptr);
 
    
    void clear();
    
    // needed for use of unique_ptr with incomplete type
    ~Timings();
    
  private:
    std::unique_ptr<Times> all;
    std::stack<Times*> stack;
    mutable std::mutex mutex;
  };
  
  std::ostream& operator<<(std::ostream& out, Timings const& timings);
 
  // -----------------------------------------------------------------------------------------------
  // -----------------------------------------------------------------------------------------------
 
  class ScopedTimingSection
  {
  public:
    ScopedTimingSection();
 
    ScopedTimingSection(ScopedTimingSection const&) = delete;
 
    ScopedTimingSection(Timings_Details::SectionBeacon const& sec);
 
    ScopedTimingSection(std::string const& name, bool gather=true);
    
    ScopedTimingSection(std::string const& name, Timings& timer, bool gather=true);
    
    ~ScopedTimingSection();
 
    void restart(std::string const& name);
 
    ScopedTimingSection& operator=(Timings_Details::SectionBeacon const& sec);
    
    void start();
 
    void stop();
    
    bool isRunning() const;
 
    Timings& timer();
    
  private:
    std::string name;
    Timings* mytimer;
    bool running;
    bool gather;        // if false, do not call mytimer at all
  };
  
  // ----------------------------------------------------------------------------------------------
  
  class TaskTiming
  {
  public:
    TaskTiming(int nTasks, int m=1);
    
    void start(int task);
 
    void stop(int task);
    
  private:
    using TimePoint = std::chrono::time_point<std::chrono::high_resolution_clock>;
    TimePoint zero;
    std::vector<std::array<TimePoint,2>> times;
    std::vector<int> segment;
    int nSegments;
    
    friend std::ostream& operator <<(std::ostream& out, TaskTiming const& tt);
  };
  
  std::ostream& operator <<(std::ostream& out, TaskTiming const& tt);
}
 
 
 
#endif