X-Git-Url: http://plrg.eecs.uci.edu/git/?a=blobdiff_plain;f=include%2Fllvm%2FADT%2FStatistic.h;h=7c84e3ef6b4dc95464d77d14d7300c5a447e8b38;hb=e293d6c8d134ad352bb69defee17c5c902476933;hp=5c464865ed1933bfc61edc25414c97909db5d14e;hpb=fa10fdf5eb9305d8af2f4c63264400bb17e6aa3f;p=oota-llvm.git diff --git a/include/llvm/ADT/Statistic.h b/include/llvm/ADT/Statistic.h index 5c464865ed1..7c84e3ef6b4 100644 --- a/include/llvm/ADT/Statistic.h +++ b/include/llvm/ADT/Statistic.h @@ -1,69 +1,186 @@ -//===-- Support/StatisticReporter.h - Easy way to expose stats ---*- C++ -*-==// +//===-- llvm/ADT/Statistic.h - Easy way to expose stats ---------*- C++ -*-===// +// +// The LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// // // This file defines the 'Statistic' class, which is designed to be an easy way -// to expose various success metrics from passes. These statistics are printed -// at the end of a run, when the -stats command line option is enabled on the -// command line. +// to expose various metrics from passes. These statistics are printed at the +// end of a run (from llvm_shutdown), when the -stats command line option is +// passed on the command line. // // This is useful for reporting information like the number of instructions // simplified, optimized or removed by various transformations, like this: // -// static Statistic<> NumInstEliminated("GCSE - Number of instructions killed"); +// static Statistic NumInstsKilled("gcse", "Number of instructions killed"); +// +// Later, in the code: ++NumInstsKilled; // -// Later, in the code: ++NumInstEliminated; +// NOTE: Statistics *must* be declared as global variables. // //===----------------------------------------------------------------------===// -#ifndef SUPPORT_STATISTIC_REPORTER_H -#define SUPPORT_STATISTIC_REPORTER_H +#ifndef LLVM_ADT_STATISTIC_H +#define LLVM_ADT_STATISTIC_H -#include +#include "llvm/Support/Atomic.h" +#include "llvm/Support/Valgrind.h" +#include -// StatisticBase - Nontemplated base class for Statistic<> class... -class StatisticBase { +namespace llvm { +class raw_ostream; +class raw_fd_ostream; + +class Statistic { +public: const char *Name; -protected: - StatisticBase(const char *name) : Name(name) {} - virtual ~StatisticBase() {} + const char *Desc; + volatile llvm::sys::cas_flag Value; + bool Initialized; - // destroy - Called by subclass dtor so that we can still invoke virtual - // functions on the subclass. - void destroy() const; + llvm::sys::cas_flag getValue() const { return Value; } + const char *getName() const { return Name; } + const char *getDesc() const { return Desc; } - // printValue - Overridden by template class to print out the value type... - virtual void printValue(ostream &o) const = 0; + /// construct - This should only be called for non-global statistics. + void construct(const char *name, const char *desc) { + Name = name; Desc = desc; + Value = 0; Initialized = false; + } - // hasSomeData - Return true if some data has been aquired. Avoid printing - // lots of zero counts. - // - virtual bool hasSomeData() const = 0; -}; + // Allow use of this class as the value itself. + operator unsigned() const { return Value; } -// Statistic Class - templated on the data type we are monitoring... -template -class Statistic : private StatisticBase { - DataType Value; +#if !defined(NDEBUG) || defined(LLVM_ENABLE_STATS) + const Statistic &operator=(unsigned Val) { + Value = Val; + return init(); + } - virtual void printValue(ostream &o) const { o << Value; } - virtual bool hasSomeData() const { return Value != DataType(); } -public: - // Normal constructor, default initialize data item... - Statistic(const char *name) : StatisticBase(name), Value(DataType()) {} - - // Constructor to provide an initial value... - Statistic(const DataType &Val, const char *name) - : StatisticBase(name), Value(Val) {} - - // Print information when destroyed, iff command line option is specified - ~Statistic() { destroy(); } - - // Allow use of this class as the value itself... - inline operator DataType() const { return Value; } - inline const DataType &operator=(DataType Val) { Value = Val; return Value; } - inline const DataType &operator++() { return ++Value; } - inline DataType operator++(int) { return Value++; } - inline const DataType &operator+=(const DataType &V) { return Value += V; } - inline const DataType &operator-=(const DataType &V) { return Value -= V; } + const Statistic &operator++() { + // FIXME: This function and all those that follow carefully use an + // atomic operation to update the value safely in the presence of + // concurrent accesses, but not to read the return value, so the + // return value is not thread safe. + sys::AtomicIncrement(&Value); + return init(); + } + + unsigned operator++(int) { + init(); + unsigned OldValue = Value; + sys::AtomicIncrement(&Value); + return OldValue; + } + + const Statistic &operator--() { + sys::AtomicDecrement(&Value); + return init(); + } + + unsigned operator--(int) { + init(); + unsigned OldValue = Value; + sys::AtomicDecrement(&Value); + return OldValue; + } + + const Statistic &operator+=(const unsigned &V) { + if (!V) return *this; + sys::AtomicAdd(&Value, V); + return init(); + } + + const Statistic &operator-=(const unsigned &V) { + if (!V) return *this; + sys::AtomicAdd(&Value, -V); + return init(); + } + + const Statistic &operator*=(const unsigned &V) { + sys::AtomicMul(&Value, V); + return init(); + } + + const Statistic &operator/=(const unsigned &V) { + sys::AtomicDiv(&Value, V); + return init(); + } + +#else // Statistics are disabled in release builds. + + const Statistic &operator=(unsigned Val) { + return *this; + } + + const Statistic &operator++() { + return *this; + } + + unsigned operator++(int) { + return 0; + } + + const Statistic &operator--() { + return *this; + } + + unsigned operator--(int) { + return 0; + } + + const Statistic &operator+=(const unsigned &V) { + return *this; + } + + const Statistic &operator-=(const unsigned &V) { + return *this; + } + + const Statistic &operator*=(const unsigned &V) { + return *this; + } + + const Statistic &operator/=(const unsigned &V) { + return *this; + } + +#endif // !defined(NDEBUG) || defined(LLVM_ENABLE_STATS) + +protected: + Statistic &init() { + bool tmp = Initialized; + sys::MemoryFence(); + if (!tmp) RegisterStatistic(); + TsanHappensAfter(this); + return *this; + } + void RegisterStatistic(); }; +// STATISTIC - A macro to make definition of statistics really simple. This +// automatically passes the DEBUG_TYPE of the file into the statistic. +#define STATISTIC(VARNAME, DESC) \ + static llvm::Statistic VARNAME = { DEBUG_TYPE, DESC, 0, 0 } + +/// \brief Enable the collection and printing of statistics. +void EnableStatistics(); + +/// \brief Check if statistics are enabled. +bool AreStatisticsEnabled(); + +/// \brief Return a file stream to print our output on. +std::unique_ptr CreateInfoOutputFile(); + +/// \brief Print statistics to the file returned by CreateInfoOutputFile(). +void PrintStatistics(); + +/// \brief Print statistics to the given output stream. +void PrintStatistics(raw_ostream &OS); + +} // End llvm namespace + #endif