timer.h

Go to the documentation of this file.

// Copyright 2017-2020, Schlumberger
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//      http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
 
#pragma once
 
#include "../declspec.h"
 
namespace InternalZGY {
#if 0
}
#endif
 
class OPENZGY_TEST_API Timer {
 
private: // readonly, i.e. set only in constructor
  bool enabled_;      // If false, the class is just a stub.
  int  skip_;         // Do not accumulate the N first results
  long long frequency_; // Frequency of internal timer, in Hertz
  long long overhead_;  // Estimated overhead of reading timer, in usec
  char name_[256];    // Optional name of this timer
  char buff_[256];    // Returned from getValue().
 
private: // mutable
  int  laps_;         // Number of accumulated results
  long long last_;      // Time for last lap
  long long total_;     // Accumulated total time
  long long begin_;     // Time of last call to Start();
  long long end_;       // Time of last call to Stop();
  bool running_;      // Guard against two Stop() in a row.
  int  verbose_;      // Used by higher levels only.
 
private: // non-inlined versions of operations
  void doStart();
  void doStop();
  void doReset();
  long long getNativeTime();
  long long getNativeFrequency();
 
public:
  Timer(bool enable = true, const char* name = 0, int skip = 0, bool startrunning = true);
 
  // ACCESSORS
  bool   getEnabled()    const { return enabled_; }
  double getFrequency()  const { return static_cast<double>(frequency_); }
  double getLast()       const { return static_cast<double>(last_)     / static_cast<double>(frequency_); }
  double getTotal()      const { return static_cast<double>(total_)    / static_cast<double>(frequency_); }
  double getOverhead()   const { return static_cast<double>(overhead_) / static_cast<double>(frequency_); }
  int    getCount()      const { return laps_ < skip_ ? 0 : laps_ - skip_; }
  const char* getName()  const { return name_; }
  int    getSkip()       const { return skip_ < laps_ ? skip_ : laps_; }
  bool   getRunning()    const { return running_; }
  int    getVerbose()    const { return verbose_; }
  static void   getValue_s(char *buf, int len, const char *name, int count, double total, bool running, bool details, bool msonly);
  const char* getValue(bool details = false, bool msonly = false);
 
  // OPERATIONS
  void setVerbose(int v) { verbose_ = v; }
  void start()           { if (enabled_) doStart(); }
  void stop()            { if (enabled_) doStop();  }
  void reset()           { if (enabled_) doReset(); }
};
 
class OPENZGY_TEST_API PrintingTimer : public Timer
{
  int level_;
public:
  explicit PrintingTimer(const char *name, int level = 1, bool startrunning = true);
  ~PrintingTimer();
  void print();
};
 
class OPENZGY_TEST_API RawPrintingTimer : public Timer
{
  int level_;
public:
  explicit RawPrintingTimer(const char *name, int level = 1);
  ~RawPrintingTimer();
  void print();
};
 
class OPENZGY_TEST_API SummaryTimer
{
  class Impl;
  Impl *pimpl_;
public:
  explicit SummaryTimer(const char* name);
  virtual ~SummaryTimer();
  SummaryTimer(const SummaryTimer&) = delete;
  SummaryTimer& operator=(const SummaryTimer&) = delete;
 
  // ACCESSORS
  double getFrequency() const;
  int    getCount()     const;
  double getTotal()     const;
  double getLast()      const;
  const char* getName() const;
  const char* getValue(bool details, bool msonly) const;
 
  // OPERATIONS
  void reset();
  void add(int count, double total, double last);
  void add(const Timer& t);
};
 
class OPENZGY_TEST_API SummaryPrintingTimer : public SummaryTimer
{
public:
  explicit SummaryPrintingTimer(const char *name);
  virtual ~SummaryPrintingTimer();
  virtual void print();
};
 
class OPENZGY_TEST_API SimpleTimer : public Timer
{
  SummaryTimer& owner_;
public:
  explicit SimpleTimer(SummaryTimer& owner, bool enabled = true)
    : Timer(enabled)
    , owner_(owner)
  {
  }
  ~SimpleTimer()
  {
    if (getEnabled()) {
      stop();
      owner_.add(*this);
    }
  }
};
 
} // end namespace