// Copyright (c) 2018 Google LLC.

//

// 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.

// Contains utils for getting resource utilization

#ifndef SOURCE_UTIL_TIMER_H_

#define SOURCE_UTIL_TIMER_H_

#if defined(SPIRV_TIMER_ENABLED)

#include <sys/resource.h>

#include <cassert>

#include <iostream>

// A macro to call spvtools::utils::PrintTimerDescription(std::ostream*, bool).

// The first argument must be given as std::ostream*. If it is NULL, the

// function does nothing. Otherwise, it prints resource types measured by Timer

// class. The second is optional and if it is true, the function also prints

// resource type fields related to memory. Otherwise, it does not print memory

// related fields. Its default is false. In usual, this must be placed before

// calling Timer::Report() to inform what those fields printed by

// Timer::Report() indicate (or spvtools::utils::PrintTimerDescription() must be

// used instead).

#define SPIRV_TIMER_DESCRIPTION(...) \

  spvtools::utils::PrintTimerDescription(__VA_ARGS__)

// Creates an object of ScopedTimer to measure the resource utilization for the

// scope surrounding it as the following example:

//

//   {   // <-- beginning of this scope

//

//     /* ... code out of interest ... */

//

//     SPIRV_TIMER_SCOPED(std::cout, tag);

//

//     /* ... lines of code that we want to know its resource usage ... */

//

//   }   // <-- end of this scope. The destructor of ScopedTimer prints tag and

//              the resource utilization to std::cout.

#define SPIRV_TIMER_SCOPED(...)                                         \

  spvtools::utils::ScopedTimer<spvtools::utils::Timer> timer##__LINE__( \

      __VA_ARGS__)

namespace spvtools {

namespace utils {

// Prints the description of resource types measured by Timer class. If |out| is

// NULL, it does nothing. Otherwise, it prints resource types. The second is

// optional and if it is true, the function also prints resource type fields

// related to memory. Its default is false. In usual, this must be placed before

// calling Timer::Report() to inform what those fields printed by

// Timer::Report() indicate.

void PrintTimerDescription(std::ostream*, bool = false);

// Status of Timer. kGetrusageFailed means it failed in calling getrusage().

// kClockGettimeWalltimeFailed means it failed in getting wall time when calling

// clock_gettime(). kClockGettimeCPUtimeFailed means it failed in getting CPU

// time when calling clock_gettime().

enum UsageStatus {

  kSucceeded = 0,

  kGetrusageFailed = 1 << 0,

  kClockGettimeWalltimeFailed = 1 << 1,

  kClockGettimeCPUtimeFailed = 1 << 2,

};

// Timer measures the resource utilization for a range of code. The resource

// utilization consists of CPU time (i.e., process time), WALL time (elapsed

// time), USR time, SYS time, RSS delta, and the delta of the number of page

// faults. RSS delta and the delta of the number of page faults are measured

// only when |measure_mem_usage| given to the constructor is true. This class

// should be used as the following example:

//

//   spvtools::utils::Timer timer(std::cout);

//   timer.Start();       // <-- set |usage_before_|, |wall_before_|,

//                               and |cpu_before_|

//

//   /* ... lines of code that we want to know its resource usage ... */

//

//   timer.Stop();        // <-- set |cpu_after_|, |wall_after_|, and

//                               |usage_after_|

//   timer.Report(tag);   // <-- print tag and the resource utilization to

//                               std::cout.

class Timer {

 public:

  Timer(std::ostream* out, bool measure_mem_usage = false)

      : report_stream_(out),

        usage_status_(kSucceeded),

        measure_mem_usage_(measure_mem_usage) {}

  // Sets |usage_before_|, |wall_before_|, and |cpu_before_| as results of

  // getrusage(), clock_gettime() for the wall time, and clock_gettime() for the

  // CPU time respectively. Note that this method erases all previous state of

  // |usage_before_|, |wall_before_|, |cpu_before_|.

  virtual void Start();

  // Sets |cpu_after_|, |wall_after_|, and |usage_after_| as results of

  // clock_gettime() for the wall time, and clock_gettime() for the CPU time,

  // getrusage() respectively. Note that this method erases all previous state

  // of |cpu_after_|, |wall_after_|, |usage_after_|.

  virtual void Stop();

  // If |report_stream_| is NULL, it does nothing. Otherwise, it prints the

  // resource utilization (i.e., CPU/WALL/USR/SYS time, RSS delta) between the

  // time of calling Timer::Start() and the time of calling Timer::Stop(). If we

  // cannot get a resource usage because of failures, it prints "Failed" instead

  // for the resource.

  void Report(const char* tag);

  // Returns the measured CPU Time (i.e., process time) for a range of code

  // execution. If kClockGettimeCPUtimeFailed is set by the failure of calling

  // clock_gettime(), it returns -1.

  virtual double CPUTime() {

    if (usage_status_ & kClockGettimeCPUtimeFailed) return -1;

    return TimeDifference(cpu_before_, cpu_after_);

  }

  // Returns the measured Wall Time (i.e., elapsed time) for a range of code

  // execution. If kClockGettimeWalltimeFailed is set by the failure of

  // calling clock_gettime(), it returns -1.

  virtual double WallTime() {

    if (usage_status_ & kClockGettimeWalltimeFailed) return -1;

    return TimeDifference(wall_before_, wall_after_);

  }

  // Returns the measured USR Time for a range of code execution. If

  // kGetrusageFailed is set because of the failure of calling getrusage(), it

  // returns -1.

  virtual double UserTime() {

    if (usage_status_ & kGetrusageFailed) return -1;

    return TimeDifference(usage_before_.ru_utime, usage_after_.ru_utime);

  }

  // Returns the measured SYS Time for a range of code execution. If

  // kGetrusageFailed is set because of the failure of calling getrusage(), it

  // returns -1.

  virtual double SystemTime() {

    if (usage_status_ & kGetrusageFailed) return -1;

    return TimeDifference(usage_before_.ru_stime, usage_after_.ru_stime);

  }

  // Returns the measured RSS delta for a range of code execution. If

  // kGetrusageFailed is set because of the failure of calling getrusage(), it

  // returns -1.

  virtual long RSS() const {

    if (usage_status_ & kGetrusageFailed) return -1;

    return usage_after_.ru_maxrss - usage_before_.ru_maxrss;

  }

  // Returns the measured the delta of the number of page faults for a range of

  // code execution. If kGetrusageFailed is set because of the failure of

  // calling getrusage(), it returns -1.

  virtual long PageFault() const {

    if (usage_status_ & kGetrusageFailed) return -1;

    return (usage_after_.ru_minflt - usage_before_.ru_minflt) +

           (usage_after_.ru_majflt - usage_before_.ru_majflt);

  }

  virtual ~Timer() {}

 private:

  // Returns the time gap between |from| and |to| in seconds.

  static double TimeDifference(const timeval& from, const timeval& to) {

    assert((to.tv_sec > from.tv_sec) ||

           (to.tv_sec == from.tv_sec && to.tv_usec >= from.tv_usec));

    return static_cast<double>(to.tv_sec - from.tv_sec) +

           static_cast<double>(to.tv_usec - from.tv_usec) * .000001;

  }

  // Returns the time gap between |from| and |to| in seconds.

  static double TimeDifference(const timespec& from, const timespec& to) {

    assert((to.tv_sec > from.tv_sec) ||

           (to.tv_sec == from.tv_sec && to.tv_nsec >= from.tv_nsec));

    return static_cast<double>(to.tv_sec - from.tv_sec) +

           static_cast<double>(to.tv_nsec - from.tv_nsec) * .000000001;

  }

  // Output stream to print out the resource utilization. If it is NULL,

  // Report() does nothing.

  std::ostream* report_stream_;

  // Status to stop measurement if a system call returns an error.

  unsigned usage_status_;

  // Variable to save the result of clock_gettime(CLOCK_PROCESS_CPUTIME_ID) when

  // Timer::Start() is called. It is used as the base status of CPU time.

  timespec cpu_before_;

  // Variable to save the result of clock_gettime(CLOCK_MONOTONIC) when

  // Timer::Start() is called. It is used as the base status of WALL time.

  timespec wall_before_;

  // Variable to save the result of getrusage() when Timer::Start() is called.

  // It is used as the base status of USR time, SYS time, and RSS.

  rusage usage_before_;

  // Variable to save the result of clock_gettime(CLOCK_PROCESS_CPUTIME_ID) when

  // Timer::Stop() is called. It is used as the last status of CPU time. The

  // resource usage is measured by subtracting |cpu_before_| from it.

  timespec cpu_after_;

  // Variable to save the result of clock_gettime(CLOCK_MONOTONIC) when

  // Timer::Stop() is called. It is used as the last status of WALL time. The

  // resource usage is measured by subtracting |wall_before_| from it.

  timespec wall_after_;

  // Variable to save the result of getrusage() when Timer::Stop() is called. It

  // is used as the last status of USR time, SYS time, and RSS. Those resource

  // usages are measured by subtracting |usage_before_| from it.

  rusage usage_after_;

  // If true, Timer reports the memory usage information too. Otherwise, Timer

  // reports only USR time, WALL time, SYS time.

  bool measure_mem_usage_;

};

// The purpose of ScopedTimer is to measure the resource utilization for a

// scope. Simply creating a local variable of ScopedTimer will call

// Timer::Start() and it calls Timer::Stop() and Timer::Report() at the end of

// the scope by its destructor. When we use this class, we must choose the

// proper Timer class (for class TimerType template) in advance. This class

// should be used as the following example:

//

//   {   // <-- beginning of this scope

//

//     /* ... code out of interest ... */

//

//     spvtools::utils::ScopedTimer<spvtools::utils::Timer>

//     scopedtimer(std::cout, tag);

//

//     /* ... lines of code that we want to know its resource usage ... */

//

//   }   // <-- end of this scope. The destructor of ScopedTimer prints tag and

//              the resource utilization to std::cout.

//

// The template<class TimerType> is used to choose a Timer class. Currently,

// only options for the Timer class are Timer and MockTimer in the unit test.

template <class TimerType>

class ScopedTimer {

 public:

  ScopedTimer(std::ostream* out, const char* tag,

              bool measure_mem_usage = false)

      : timer(new TimerType(out, measure_mem_usage)), tag_(tag) {

    timer->Start();

  }

  // At the end of the scope surrounding the instance of this class, this

  // destructor saves the last status of resource usage and reports it.

  virtual ~ScopedTimer() {

    timer->Stop();

    timer->Report(tag_);

    delete timer;

  }

 private:

  // Actual timer that measures the resource utilization. It must be an instance

  // of Timer class if there is no special reason to use other class.

  TimerType* timer;

  // A tag that will be printed in front of the trace reported by Timer class.

  const char* tag_;

};

// CumulativeTimer is the same as Timer class, but it supports a cumulative

// measurement as the following example:

//

//   CumulativeTimer *ctimer = new CumulativeTimer(std::cout);

//   ctimer->Start();

//

//   /* ... lines of code that we want to know its resource usage ... */

//

//   ctimer->Stop();

//

//   /* ... code out of interest ... */

//

//   ctimer->Start();

//

//   /* ... lines of code that we want to know its resource usage ... */

//

//   ctimer->Stop();

//   ctimer->Report(tag);

//   delete ctimer;

//

class CumulativeTimer : public Timer {

 public:

  CumulativeTimer(std::ostream* out, bool measure_mem_usage = false)

      : Timer(out, measure_mem_usage),

        cpu_time_(0),

        wall_time_(0),

        usr_time_(0),

        sys_time_(0),

        rss_(0),

        pgfaults_(0) {}

  // If we cannot get a resource usage because of failures, it sets -1 for the

  // resource usage.

  void Stop() override {

    Timer::Stop();

    if (cpu_time_ >= 0 && Timer::CPUTime() >= 0)

      cpu_time_ += Timer::CPUTime();

    else

      cpu_time_ = -1;

    if (wall_time_ >= 0 && Timer::WallTime() >= 0)

      wall_time_ += Timer::WallTime();

    else

      wall_time_ = -1;

    if (usr_time_ >= 0 && Timer::UserTime() >= 0)

      usr_time_ += Timer::UserTime();

    else

      usr_time_ = -1;

    if (sys_time_ >= 0 && Timer::SystemTime() >= 0)

      sys_time_ += Timer::SystemTime();

    else

      sys_time_ = -1;

    if (rss_ >= 0 && Timer::RSS() >= 0)

      rss_ += Timer::RSS();

    else

      rss_ = -1;

    if (pgfaults_ >= 0 && Timer::PageFault() >= 0)

      pgfaults_ += Timer::PageFault();

    else

      pgfaults_ = -1;

  }

  // Returns the cumulative CPU Time (i.e., process time) for a range of code

  // execution.

  double CPUTime() override { return cpu_time_; }

  // Returns the cumulative Wall Time (i.e., elapsed time) for a range of code

  // execution.

  double WallTime() override { return wall_time_; }

  // Returns the cumulative USR Time for a range of code execution.

  double UserTime() override { return usr_time_; }

  // Returns the cumulative SYS Time for a range of code execution.

  double SystemTime() override { return sys_time_; }

  // Returns the cumulative RSS delta for a range of code execution.

  long RSS() const override { return rss_; }

  // Returns the cumulative delta of number of page faults for a range of code

  // execution.

  long PageFault() const override { return pgfaults_; }

 private:

  // Variable to save the cumulative CPU time (i.e., process time).

  double cpu_time_;

  // Variable to save the cumulative wall time (i.e., elapsed time).

  double wall_time_;

  // Variable to save the cumulative user time.

  double usr_time_;

  // Variable to save the cumulative system time.

  double sys_time_;

  // Variable to save the cumulative RSS delta.

  long rss_;

  // Variable to save the cumulative delta of the number of page faults.

  long pgfaults_;

};

}  // namespace utils

}  // namespace spvtools

#else  // defined(SPIRV_TIMER_ENABLED)

#define SPIRV_TIMER_DESCRIPTION(...)

#define SPIRV_TIMER_SCOPED(...)

#endif  // defined(SPIRV_TIMER_ENABLED)

#endif  // SOURCE_UTIL_TIMER_H_