X-Git-Url: http://demsky.eecs.uci.edu/git/?a=blobdiff_plain;f=include%2Fllvm%2FADT%2FStatistic.h;h=b54d10b9dd334d0317054f81c82c3504a3517007;hb=acb8d9fbe3853394a2537985349993580309b8cd;hp=62dec92bc4fa79c09bdebbc3e3b9012d64b4c5b0;hpb=96ef1b90c8f3a6649993bb7ab10db3510f12e80a;p=oota-llvm.git diff --git a/include/llvm/ADT/Statistic.h b/include/llvm/ADT/Statistic.h index 62dec92bc4f..b54d10b9dd3 100644 --- a/include/llvm/ADT/Statistic.h +++ b/include/llvm/ADT/Statistic.h @@ -1,95 +1,139 @@ -//===-- 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 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_H -#define SUPPORT_STATISTIC_H +#ifndef LLVM_ADT_STATISTIC_H +#define LLVM_ADT_STATISTIC_H -#include - -// DebugFlag - This boolean is set to true if the '-debug' command line option -// is specified. This should probably not be referenced directly, instead, use -// the DEBUG macro below. -// -extern bool DebugFlag; - -// DEBUG macro - This macro should be used by passes to emit debug information. -// In the '-debug' option is specified on the commandline, and if this is a -// debug build, then the code specified as the option to the macro will be -// executed. Otherwise it will not be. Example: -// -// DEBUG(cerr << "Bitset contains: " << Bitset << "\n"); -// -#ifdef NDEBUG -#define DEBUG(X) -#else -#define DEBUG(X) \ - do { if (DebugFlag) { X; } } while (0) -#endif +#include "llvm/Support/Atomic.h" +#include "llvm/Support/Valgrind.h" +namespace llvm { +class raw_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 = 0; } - 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; } + const Statistic &operator=(unsigned Val) { + Value = Val; + return init(); + } - // printValue - Overridden by template class to print out the value type... - virtual void printValue(std::ostream &o) 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(); + } - // hasSomeData - Return true if some data has been aquired. Avoid printing - // lots of zero counts. - // - virtual bool hasSomeData() const = 0; -}; + unsigned operator++(int) { + init(); + unsigned OldValue = Value; + sys::AtomicIncrement(&Value); + return OldValue; + } -// Statistic Class - templated on the data type we are monitoring... -template -class Statistic : private StatisticBase { - DataType Value; + const Statistic &operator--() { + sys::AtomicDecrement(&Value); + return init(); + } - 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... - 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; } + 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(); + } + +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 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