The Tor Browser: comparison ipc/chromium/src/base/stats

--1:000000000000
+:cadb80945ad7
+// Copyright (c) 2006-2008 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_STATS_COUNTERS_H__
+#define BASE_STATS_COUNTERS_H__
+#include <string>
+#include "base/stats_table.h"
+#include "base/time.h"
+// 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.
+#define STATS_COUNTER(name, delta) do { \
+static StatsCounter counter(name); \
+counter.Add(delta); \
+} while (0)
+#define SIMPLE_STATS_COUNTER(name) STATS_COUNTER(name, 1)
+#define RATE_COUNTER(name, duration) do { \
+static StatsRate hit_count(name); \
+hit_count.AddTime(duration); \
+} while (0)
+// 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 StatsCounter {
+public:
+// Create a StatsCounter object.
+explicit StatsCounter(const std::string& name)
+: counter_id_(-1) {
+// We prepend the name with 'c:' to indicate that it is a counter.
+name_ = "c:";
+name_.append(name);
+};
+virtual ~StatsCounter() {}
+// Sets the counter to a specific value.
+void Set(int value) {
+int* loc = GetPtr();
+if (loc) *loc = value;
+}
+// Increments the counter.
+void Increment() {
+Add(1);
+}
+virtual void Add(int value) {
+int* loc = GetPtr();
+if (loc)
+(*loc) += 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()
+: counter_id_(-1) {
+}
+// Returns the cached address of this counter location.
+int* GetPtr() {
+StatsTable* table = StatsTable::current();
+if (!table)
+return NULL;
+// If counter_id_ is -1, then we haven't looked it up yet.
+if (counter_id_ == -1) {
+counter_id_ = table->FindCounter(name_);
+if (table->GetSlot() == 0) {
+if (!table->RegisterThread("")) {
+// There is no room for this thread.  This thread
+// cannot use counters.
+counter_id_ = 0;
+return NULL;
+}
+}
+}
+// If counter_id_ is > 0, then we have a valid counter.
+if (counter_id_ > 0)
+return table->GetLocation(counter_id_, table->GetSlot());
+// counter_id_ was zero, which means the table is full.
+return NULL;
+}
+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_t 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 StatsCounterTimer : protected StatsCounter {
+public:
+// Constructs and starts the timer.
+explicit StatsCounterTimer(const std::string& name) {
+// we prepend the name with 't:' to indicate that it is a timer.
+name_ = "t:";
+name_.append(name);
+}
+// Start the timer.
+void Start() {
+if (!Enabled())
+return;
+start_time_ = base::TimeTicks::Now();
+stop_time_ = base::TimeTicks();
+}
+// Stop the timer and record the results.
+void Stop() {
+if (!Enabled() || !Running())
+return;
+stop_time_ = base::TimeTicks::Now();
+Record();
+}
+// Returns true if the timer is running.
+bool Running() {
+return Enabled() && !start_time_.is_null() && stop_time_.is_null();
+}
+// Accept a TimeDelta to increment.
+virtual void AddTime(base::TimeDelta time) {
+Add(static_cast<int>(time.InMilliseconds()));
+}
+protected:
+// Compute the delta between start and stop, in milliseconds.
+void Record() {
+AddTime(stop_time_ - start_time_);
+}
+base::TimeTicks start_time_;
+base::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 StatsRate : public StatsCounterTimer {
+public:
+// Constructs and starts the timer.
+explicit StatsRate(const char* name)
+: StatsCounterTimer(name),
+counter_(name),
+largest_add_(std::string(" ").append(name).append("MAX").c_str()) {
+}
+virtual void Add(int value) {
+counter_.Increment();
+StatsCounterTimer::Add(value);
+if (value > largest_add_.value())
+largest_add_.Set(value);
+}
+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_;
+};
+#endif  // BASE_STATS_COUNTERS_H__

The Tor Browser / file comparison

comparison: ipc/chromium/src/base/stats_counters.h

ipc/chromium/src/base/stats_counters.h