statistics.h

Go to the documentation of this file.

/*
 * Copyright 2010 Google Inc.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http:///www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */


#ifndef PAGESPEED_KERNEL_BASE_STATISTICS_H_
#define PAGESPEED_KERNEL_BASE_STATISTICS_H_

#include <map>

#include "base/logging.h"
#include "pagespeed/kernel/base/abstract_mutex.h"
#include "pagespeed/kernel/base/basictypes.h"
#include "pagespeed/kernel/base/scoped_ptr.h"
#include "pagespeed/kernel/base/string.h"
#include "pagespeed/kernel/base/string_util.h"
#include "pagespeed/kernel/base/thread_annotations.h"

namespace net_instaweb {

class MessageHandler;
class Statistics;
class StatisticsLogger;
class Writer;

class Variable {
 public:
  virtual ~Variable();

  virtual int64 Get() const = 0;
  virtual StringPiece GetName() const = 0;

  int64 Add(int64 non_negative_delta) {
    DCHECK_LE(0, non_negative_delta);
    return AddHelper(non_negative_delta);
  }

  virtual void Clear() = 0;

 protected:
  virtual int64 AddHelper(int64 delta) = 0;
};

class UpDownCounter {
 public:
  virtual ~UpDownCounter();

  virtual int64 Get() const = 0;
  virtual StringPiece GetName() const = 0;

  virtual int64 SetReturningPreviousValue(int64 value);

  virtual void Set(int64 value) = 0;
  void Clear() { Set(0); }
  int64 Add(int64 delta) { return AddHelper(delta); }

 protected:
  virtual int64 AddHelper(int64 delta) = 0;
};

class MutexedScalar {
 public:
  virtual ~MutexedScalar();

  int64 Get() const;
  void Set(int64 value);
  int64 SetReturningPreviousValue(int64 value);
  int64 AddHelper(int64 delta);

 protected:
  friend class StatisticsLogger;

  virtual AbstractMutex* mutex() const = 0;

  virtual int64 GetLockHeld() const = 0;
  virtual int64 SetReturningPreviousValueLockHeld(int64 value) = 0;

  void SetLockHeld(int64 value);
  int64 AddLockHeld(int64 delta);
};

class Histogram {
 public:
  virtual ~Histogram();
  virtual void Add(double value) = 0;
  virtual void Clear() = 0;
  bool Empty() {
    ScopedMutex hold(lock());
    return CountInternal() == 0;
  }
  virtual void Render(int index, Writer* writer, MessageHandler* handler);

  virtual int NumBuckets() = 0;
  virtual void EnableNegativeBuckets() = 0;
  virtual void SetMinValue(double value) = 0;
  virtual void SetMaxValue(double value) = 0;

  virtual void SetSuggestedNumBuckets(int i) = 0;

  double Average() {
    ScopedMutex hold(lock());
    return AverageInternal();
  }
  double Percentile(const double perc) {
    ScopedMutex hold(lock());
    return PercentileInternal(perc);
  }
  double StandardDeviation() {
    ScopedMutex hold(lock());
    return StandardDeviationInternal();
  }
  double Count() {
    ScopedMutex hold(lock());
    return CountInternal();
  }
  double Maximum() {
    ScopedMutex hold(lock());
    return MaximumInternal();
  }
  double Minimum() {
    ScopedMutex hold(lock());
    return MinimumInternal();
  }
  double Median() {
    return Percentile(50);
  }

  GoogleString HtmlTableRow(const GoogleString& title, int index);

  virtual double BucketStart(int index) = 0;
  virtual double BucketLimit(int index) {
    return BucketStart(index + 1);
  }
  virtual double BucketCount(int index) = 0;

 protected:
  Histogram() {}

  virtual double AverageInternal() = 0;
  virtual double PercentileInternal(const double perc) = 0;
  virtual double StandardDeviationInternal() = 0;
  virtual double CountInternal() = 0;
  virtual double MaximumInternal() = 0;
  virtual double MinimumInternal() = 0;

  virtual AbstractMutex* lock() = 0;

  void WriteRawHistogramData(Writer* writer, MessageHandler* handler);

 private:
  
};

class CountHistogram : public Histogram {
 public:
  explicit CountHistogram(AbstractMutex* mutex);
  virtual ~CountHistogram();
  virtual void Add(double value) {
    ScopedMutex hold(lock());
    ++count_;
  }
  virtual void Clear() {
    ScopedMutex hold(lock());
    count_ = 0;
  }
  virtual int NumBuckets() { return 0; }
  virtual void EnableNegativeBuckets() { }
  virtual void SetMinValue(double value) { }
  virtual void SetMaxValue(double value) { }
  virtual void SetSuggestedNumBuckets(int i) { }
  virtual GoogleString GetName() const { return ""; }

 protected:
  virtual AbstractMutex* lock() LOCK_RETURNED(mutex_) { return mutex_.get(); }
  virtual double AverageInternal() { return 0.0; }
  virtual double PercentileInternal(const double perc) { return 0.0; }
  virtual double StandardDeviationInternal() { return 0.0; }
  virtual double CountInternal() EXCLUSIVE_LOCKS_REQUIRED(lock()) {
    return count_;
  }
  virtual double MaximumInternal() { return 0.0; }
  virtual double MinimumInternal() { return 0.0; }
  virtual double BucketStart(int index) { return 0.0; }
  virtual double BucketCount(int index) { return 0.0; }

 private:
  scoped_ptr<AbstractMutex> mutex_;
  int count_ GUARDED_BY(mutex_);

  
};

class TimedVariable {
 public:
  enum Levels { TENSEC, MINUTE, HOUR, START };
  virtual ~TimedVariable();
  virtual void IncBy(int64 delta) = 0;
  virtual int64 Get(int level) = 0;
  virtual void Clear() = 0;
};

class FakeTimedVariable : public TimedVariable {
 public:
  FakeTimedVariable(StringPiece name, Statistics* stats);
  virtual ~FakeTimedVariable();
  virtual void IncBy(int64 delta) {
    var_->Add(delta);
  }
  virtual int64 Get(int level) {
    if (level == START) {
      return var_->Get();
    }
    return 0;
  }
  virtual void Clear() {
    return var_->Clear();
  }

 protected:
  Variable* var_;
};

class Statistics {
 public:
  static const char kDefaultGroup[];

  Statistics() {}
  virtual ~Statistics();

  virtual UpDownCounter* AddUpDownCounter(const StringPiece& name) = 0;

  virtual UpDownCounter* AddGlobalUpDownCounter(const StringPiece& name);

  virtual UpDownCounter* FindUpDownCounter(const StringPiece& name) const = 0;

  UpDownCounter* GetUpDownCounter(const StringPiece& name) const {
    UpDownCounter* var = FindUpDownCounter(name);
    CHECK(var != NULL) << "UpDownCounter not found: " << name;
    return var;
  }

  virtual Variable* AddVariable(const StringPiece& name) = 0;

  virtual Variable* FindVariable(const StringPiece& name) const = 0;

  Variable* GetVariable(const StringPiece& name) const {
    Variable* var = FindVariable(name);
    CHECK(var != NULL) << "Variable not found: " << name;
    return var;
  }


  virtual Histogram* AddHistogram(const StringPiece& name) = 0;
  virtual Histogram* FindHistogram(const StringPiece& name) const = 0;
  Histogram* GetHistogram(const StringPiece& name) const {
    Histogram* hist = FindHistogram(name);
    CHECK(hist != NULL) << "Histogram not found: " << name;
    return hist;
  }

  virtual TimedVariable* AddTimedVariable(
      const StringPiece& name, const StringPiece& group) = 0;
  virtual TimedVariable* FindTimedVariable(
      const StringPiece& name) const = 0;
  TimedVariable* GetTimedVariable(
      const StringPiece& name) const {
    TimedVariable* stat = FindTimedVariable(name);
    CHECK(stat != NULL) << "TimedVariable not found: " << name;
    return stat;
  }
  virtual const StringVector& HistogramNames() = 0;
  virtual const std::map<GoogleString, StringVector>& TimedVariableMap() = 0;
  virtual void Dump(Writer* writer, MessageHandler* handler) = 0;
  virtual void DumpJson(Writer* writer, MessageHandler* message_handler) = 0;
  virtual void RenderTimedVariables(Writer* writer,
                                    MessageHandler* handler);
  virtual void RenderHistograms(Writer* writer, MessageHandler* handler);
  virtual void Clear() = 0;

  virtual StatisticsLogger* console_logger() { return NULL; }

  int64 LookupValue(StringPiece stat_name);

 private:
  
};

}  

#endif