X-Git-Url: http://plrg.eecs.uci.edu/git/?a=blobdiff_plain;f=include%2Fllvm%2FADT%2FStatistic.h;h=7c84e3ef6b4dc95464d77d14d7300c5a447e8b38;hb=e293d6c8d134ad352bb69defee17c5c902476933;hp=d69809ff186e54f1c5f2701e1b44e9290664f9b7;hpb=b2109ce97881269a610fa4afbcbca350e975174d;p=oota-llvm.git diff --git a/include/llvm/ADT/Statistic.h b/include/llvm/ADT/Statistic.h index d69809ff186..7c84e3ef6b4 100644 --- a/include/llvm/ADT/Statistic.h +++ b/include/llvm/ADT/Statistic.h @@ -1,81 +1,186 @@ -//===-- Support/Statistic.h - Easy way to expose stats ----------*- C++ -*-===// -// +//===-- llvm/ADT/Statistic.h - Easy way to expose stats ---------*- C++ -*-===// +// // The LLVM Compiler Infrastructure // -// This file was developed by the LLVM research group and is distributed under -// the University of Illinois Open Source License. See LICENSE.TXT for details. -// +// 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: ++NumInstEliminated; +// Later, in the code: ++NumInstsKilled; +// +// NOTE: Statistics *must* be declared as global variables. // //===----------------------------------------------------------------------===// -#ifndef SUPPORT_STATISTIC_H -#define SUPPORT_STATISTIC_H +#ifndef LLVM_ADT_STATISTIC_H +#define LLVM_ADT_STATISTIC_H + +#include "llvm/Support/Atomic.h" +#include "llvm/Support/Valgrind.h" +#include -#include +namespace llvm { +class raw_ostream; +class raw_fd_ostream; -// StatisticBase - Nontemplated base class for Statistic<> class... -class StatisticBase { +class Statistic { +public: const char *Name; const char *Desc; - static unsigned NumStats; -protected: - StatisticBase(const char *name, const char *desc) : Name(name), Desc(desc) { - ++NumStats; // Keep track of how many stats are created... + volatile llvm::sys::cas_flag Value; + bool Initialized; + + llvm::sys::cas_flag getValue() const { return Value; } + const char *getName() const { return Name; } + const char *getDesc() const { return Desc; } + + /// 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; } - virtual ~StatisticBase() {} - // destroy - Called by subclass dtor so that we can still invoke virtual - // functions on the subclass. - void destroy() const; + // Allow use of this class as the value itself. + operator unsigned() const { return Value; } - // printValue - Overridden by template class to print out the value type... - virtual void printValue(std::ostream &o) const = 0; +#if !defined(NDEBUG) || defined(LLVM_ENABLE_STATS) + const Statistic &operator=(unsigned Val) { + Value = Val; + return init(); + } - // hasSomeData - Return true if some data has been aquired. Avoid printing - // lots of zero counts. - // - virtual bool hasSomeData() const = 0; -}; + 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(); + } -// Statistic Class - templated on the data type we are monitoring... -template -class Statistic : private StatisticBase { - DataType Value; + unsigned operator++(int) { + init(); + unsigned OldValue = Value; + sys::AtomicIncrement(&Value); + return OldValue; + } - virtual void printValue(std::ostream &o) const { o << Value; } - virtual bool hasSomeData() const { return Value != DataType(); } -public: - // Normal constructor, default initialize data item... - Statistic(const char *name, const char *desc) - : StatisticBase(name, desc), Value(DataType()) {} - - // Constructor to provide an initial value... - Statistic(const DataType &Val, const char *name, const char *desc) - : StatisticBase(name, desc), Value(Val) {} - - // Print information when destroyed, iff command line option is specified - ~Statistic() { destroy(); } - - // Allow use of this class as the value itself... - operator DataType() const { return Value; } - const Statistic &operator=(DataType Val) { Value = Val; return *this; } - const Statistic &operator++() { ++Value; return *this; } - DataType operator++(int) { return Value++; } - const Statistic &operator+=(const DataType &V) { Value += V; return *this; } - const Statistic &operator-=(const DataType &V) { Value -= V; return *this; } + 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