| // Copyright (c) 2011 The Chromium Authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| |
| #ifndef BASE_METRICS_STATS_COUNTERS_H_ |
| #define BASE_METRICS_STATS_COUNTERS_H_ |
| |
| #include <string> |
| |
| #include "base/base_export.h" |
| #include "base/compiler_specific.h" |
| #if !defined(__LB_SHELL__) && !defined(COBALT) |
| #include "base/metrics/stats_table.h" |
| #endif |
| #include "base/time.h" |
| |
| namespace base { |
| |
| // StatsCounters are dynamically created values which can be tracked in |
| // the StatsTable. They are designed to be lightweight to create and |
| // easy to use. |
| // |
| // Since StatsCounters can be created dynamically by name, there is |
| // a hash table lookup to find the counter in the table. A StatsCounter |
| // object can be created once and used across multiple threads safely. |
| // |
| // Example usage: |
| // { |
| // StatsCounter request_count("RequestCount"); |
| // request_count.Increment(); |
| // } |
| // |
| // Note that creating counters on the stack does work, however creating |
| // the counter object requires a hash table lookup. For inner loops, it |
| // may be better to create the counter either as a member of another object |
| // (or otherwise outside of the loop) for maximum performance. |
| // |
| // Internally, a counter represents a value in a row of a StatsTable. |
| // The row has a 32bit value for each process/thread in the table and also |
| // a name (stored in the table metadata). |
| // |
| // NOTE: In order to make stats_counters usable in lots of different code, |
| // avoid any dependencies inside this header file. |
| // |
| |
| //------------------------------------------------------------------------------ |
| // Define macros for ease of use. They also allow us to change definitions |
| // as the implementation varies, or depending on compile options. |
| //------------------------------------------------------------------------------ |
| // First provide generic macros, which exist in production as well as debug. |
| #if defined(__LB_SHELL__) || defined(COBALT) |
| #define STATS_COUNTER(name, delta) |
| #define SIMPLE_STATS_COUNTER(name) |
| #define RATE_COUNTER(name, duration) |
| #else |
| #define STATS_COUNTER(name, delta) do { \ |
| base::StatsCounter counter(name); \ |
| counter.Add(delta); \ |
| } while (0) |
| |
| #define SIMPLE_STATS_COUNTER(name) STATS_COUNTER(name, 1) |
| |
| #define RATE_COUNTER(name, duration) do { \ |
| base::StatsRate hit_count(name); \ |
| hit_count.AddTime(duration); \ |
| } while (0) |
| #endif |
| |
| // Define Debug vs non-debug flavors of macros. |
| #ifndef NDEBUG |
| |
| #define DSTATS_COUNTER(name, delta) STATS_COUNTER(name, delta) |
| #define DSIMPLE_STATS_COUNTER(name) SIMPLE_STATS_COUNTER(name) |
| #define DRATE_COUNTER(name, duration) RATE_COUNTER(name, duration) |
| |
| #else // NDEBUG |
| |
| #define DSTATS_COUNTER(name, delta) do {} while (0) |
| #define DSIMPLE_STATS_COUNTER(name) do {} while (0) |
| #define DRATE_COUNTER(name, duration) do {} while (0) |
| |
| #endif // NDEBUG |
| |
| //------------------------------------------------------------------------------ |
| // StatsCounter represents a counter in the StatsTable class. |
| class BASE_EXPORT StatsCounter { |
| public: |
| // Create a StatsCounter object. |
| explicit StatsCounter(const std::string& name); |
| virtual ~StatsCounter(); |
| |
| // Sets the counter to a specific value. |
| void Set(int value); |
| |
| // Increments the counter. |
| void Increment() { |
| Add(1); |
| } |
| |
| virtual void Add(int value); |
| |
| // Decrements the counter. |
| void Decrement() { |
| Add(-1); |
| } |
| |
| void Subtract(int value) { |
| Add(-value); |
| } |
| |
| // Is this counter enabled? |
| // Returns false if table is full. |
| bool Enabled() { |
| return GetPtr() != NULL; |
| } |
| |
| int value() { |
| int* loc = GetPtr(); |
| if (loc) return *loc; |
| return 0; |
| } |
| |
| protected: |
| StatsCounter(); |
| |
| // Returns the cached address of this counter location. |
| int* GetPtr(); |
| |
| std::string name_; |
| // The counter id in the table. We initialize to -1 (an invalid value) |
| // and then cache it once it has been looked up. The counter_id is |
| // valid across all threads and processes. |
| int32 counter_id_; |
| }; |
| |
| |
| // A StatsCounterTimer is a StatsCounter which keeps a timer during |
| // the scope of the StatsCounterTimer. On destruction, it will record |
| // its time measurement. |
| class BASE_EXPORT StatsCounterTimer : protected StatsCounter { |
| public: |
| // Constructs and starts the timer. |
| explicit StatsCounterTimer(const std::string& name); |
| virtual ~StatsCounterTimer(); |
| |
| // Start the timer. |
| void Start(); |
| |
| // Stop the timer and record the results. |
| void Stop(); |
| |
| // Returns true if the timer is running. |
| bool Running(); |
| |
| // Accept a TimeDelta to increment. |
| virtual void AddTime(TimeDelta time); |
| |
| protected: |
| // Compute the delta between start and stop, in milliseconds. |
| void Record(); |
| |
| TimeTicks start_time_; |
| TimeTicks stop_time_; |
| }; |
| |
| // A StatsRate is a timer that keeps a count of the number of intervals added so |
| // that several statistics can be produced: |
| // min, max, avg, count, total |
| class BASE_EXPORT StatsRate : public StatsCounterTimer { |
| public: |
| // Constructs and starts the timer. |
| explicit StatsRate(const std::string& name); |
| virtual ~StatsRate(); |
| |
| virtual void Add(int value) override; |
| |
| private: |
| StatsCounter counter_; |
| StatsCounter largest_add_; |
| }; |
| |
| |
| // Helper class for scoping a timer or rate. |
| template<class T> class StatsScope { |
| public: |
| explicit StatsScope<T>(T& timer) |
| : timer_(timer) { |
| timer_.Start(); |
| } |
| |
| ~StatsScope() { |
| timer_.Stop(); |
| } |
| |
| void Stop() { |
| timer_.Stop(); |
| } |
| |
| private: |
| T& timer_; |
| }; |
| |
| } // namespace base |
| |
| #endif // BASE_METRICS_STATS_COUNTERS_H_ |