split_statistics.h

Go to the documentation of this file.

/*
 * Copyright 2012 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_SPLIT_STATISTICS_H_
#define PAGESPEED_KERNEL_BASE_SPLIT_STATISTICS_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/statistics.h"
#include "pagespeed/kernel/base/statistics_template.h"
#include "pagespeed/kernel/base/string_util.h"        
#include "pagespeed/kernel/base/writer.h"

namespace net_instaweb {

class MessageHandler;
class StatisticsLogger;
class ThreadSystem;

class SplitUpDownCounter : public UpDownCounter {
 public:
  SplitUpDownCounter(UpDownCounter* rw, UpDownCounter* w);
  virtual ~SplitUpDownCounter();
  virtual void Set(int64 new_value);
  virtual int64 SetReturningPreviousValue(int64 new_value);
  virtual int64 Get() const;
  virtual StringPiece GetName() const;
  virtual int64 AddHelper(int64 delta);

 private:
  UpDownCounter* rw_;
  UpDownCounter* w_;
  
};

class SplitVariable : public Variable {
 public:
  SplitVariable(Variable* rw, Variable* w);
  virtual ~SplitVariable();
  virtual int64 Get() const;
  virtual StringPiece GetName() const;
  virtual int64 AddHelper(int64 delta);
  virtual void Clear();

 private:
  Variable* rw_;
  Variable* w_;
  
};

class SplitHistogram : public Histogram {
 public:
  SplitHistogram(ThreadSystem* thread_system, Histogram* rw, Histogram* w);
  virtual ~SplitHistogram();

  virtual void Add(double value);
  virtual void Clear();
  virtual void Render(int index, Writer* writer, MessageHandler* handler);
  virtual int NumBuckets();
  virtual void EnableNegativeBuckets();
  virtual void SetMinValue(double value);
  virtual void SetMaxValue(double value);
  virtual void SetSuggestedNumBuckets(int i);
  virtual double BucketStart(int index);
  virtual double BucketLimit(int index);
  virtual double BucketCount(int index);

 protected:
  virtual double AverageInternal();
  virtual double PercentileInternal(const double perc);
  virtual double StandardDeviationInternal();
  virtual double CountInternal();
  virtual double MaximumInternal();
  virtual double MinimumInternal();

  virtual AbstractMutex* lock();

 private:
  scoped_ptr<AbstractMutex> lock_;
  Histogram* rw_;
  Histogram* w_;

  
};

class SplitTimedVariable : public TimedVariable {
 public:
  SplitTimedVariable(TimedVariable* rw, TimedVariable* w);
  virtual ~SplitTimedVariable();

  virtual void IncBy(int64 delta);
  virtual int64 Get(int level);
  virtual void Clear();

 private:
  TimedVariable* rw_;
  TimedVariable* w_;

  
};

class SplitStatistics
    : public StatisticsTemplate<SplitVariable, SplitUpDownCounter,
                                SplitHistogram, SplitTimedVariable> {
 public:
  SplitStatistics(ThreadSystem* thread_system,
                  Statistics* local,
                  Statistics* global);

  virtual ~SplitStatistics();

  virtual StatisticsLogger* console_logger() {
    return local_->console_logger();
  }

 protected:
  virtual SplitUpDownCounter* NewUpDownCounter(StringPiece name);
  virtual SplitVariable* NewVariable(StringPiece name);
  virtual SplitUpDownCounter* NewGlobalUpDownCounter(StringPiece name);
  virtual SplitHistogram* NewHistogram(StringPiece name);
  virtual SplitTimedVariable* NewTimedVariable(StringPiece name);

 private:
  ThreadSystem* thread_system_;
  scoped_ptr<Statistics> local_;
  Statistics* global_;
  
};

}  

#endif