Statistic.h

Go to the documentation of this file.

#ifndef GALOIS_STATISTIC_H
#define GALOIS_STATISTIC_H

#include "Galois/config.h"
#include "Galois/Runtime/Support.h"
#include "Galois/Runtime/PerThreadStorage.h"
#include "Galois/Runtime/Sampling.h"
#include "Galois/Timer.h"

#include "boost/utility.hpp"

#include GALOIS_CXX11_STD_HEADER(deque)

namespace Galois {

class Statistic {
  std::string statname;
  std::string loopname;
  Galois::Runtime::PerThreadStorage<unsigned long> val;
  bool valid;

public:
  Statistic(const std::string& _sn, std::string _ln = "(NULL)"): statname(_sn), loopname(_ln), valid(true) { }

  ~Statistic() {
    report();
  }

  void report() {
    if (valid)
      Galois::Runtime::reportStat(this);
    valid = false;
  }

  unsigned long getValue(unsigned tid) {
    return *val.getRemote(tid);
  }

  std::string& getLoopname() {
    return loopname;
  }

  std::string& getStatname() {
    return statname;
  }

  Statistic& operator+=(unsigned long v) {
    *val.getLocal() += v;
    return *this;
  }
};

class StatManager: private boost::noncopyable {
  std::deque<Statistic*> stats;

public:
  ~StatManager() {
    for (std::deque<Statistic*>::iterator ii = stats.begin(), ei = stats.end(); ii != ei; ++ii) {
      (*ii)->report();
    }
    Galois::Runtime::printStats();
  }

  void push(Statistic& s) {
    stats.push_back(&s);
  }
};

struct start_now_t {};
#if defined(__IBMCPP__) && __IBMCPP__ <= 1210
static const start_now_t start_now = start_now_t();
#else
constexpr start_now_t start_now = start_now_t();
#endif

class StatTimer : public TimeAccumulator {
  const char* name;
  const char* loopname;
  bool main;
  bool valid;

protected:
  void init(const char* n, const char* l, bool m, bool s) {
    name = n;
    loopname = l;
    main = m;
    valid = false;
    if (s)
      start();
  }

public:
  StatTimer(const char* n) { init(n, 0, false, false); }
  StatTimer(const char* n, start_now_t t) { init(n, 0, false, true); }

  StatTimer(const char* n, const char* l) { init(n, l, false, false); }
  StatTimer(const char* n, const char* l, start_now_t t) { init(n, l, false, true); }

  StatTimer() { init("Time", 0, true, false); }
  StatTimer(start_now_t t) { init("Time", 0, true, true); }

  ~StatTimer() {
    if (valid)
      stop();
    if (TimeAccumulator::get()) // only report non-zero stat
      Galois::Runtime::reportStat(loopname, name, get());
  }

  void start() {
    if (main)
      Galois::Runtime::beginSampling();
    TimeAccumulator::start();
    valid = true;
  }

  void stop() {
    valid = false;
    TimeAccumulator::stop();
    if (main)
      Galois::Runtime::endSampling();
  }
};

}
#endif

---