shared_mem_statistics.h

Go to the documentation of this file.

// Copyright 2010 Google Inc. All Rights Reserved.

#ifndef PAGESPEED_KERNEL_SHAREDMEM_SHARED_MEM_STATISTICS_H_
#define PAGESPEED_KERNEL_SHAREDMEM_SHARED_MEM_STATISTICS_H_

#include <cstddef>

#include "pagespeed/kernel/base/abstract_mutex.h"
#include "pagespeed/kernel/base/abstract_shared_mem.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.h"
#include "pagespeed/kernel/base/string_util.h"

namespace net_instaweb {

class FileSystem;
class MessageHandler;
class StatisticsLogger;
class Timer;

class SharedMemVariable : public MutexedScalar {
 public:
  SharedMemVariable(StringPiece name, Statistics* stats);
  virtual ~SharedMemVariable() {}
  virtual StringPiece GetName() const { return name_; }

 protected:
  virtual AbstractMutex* mutex() const;
  virtual int64 GetLockHeld() const;
  virtual int64 SetReturningPreviousValueLockHeld(int64 value);

 private:
  friend class SharedMemStatistics;
  friend class SharedMemTimedVariable;

  explicit SharedMemVariable(const StringPiece& name);

  void AttachTo(AbstractSharedMemSegment* segment_, size_t offset,
                MessageHandler* message_handler);

  void Reset();

  const GoogleString name_;

  scoped_ptr<AbstractMutex> mutex_;

  volatile int64* value_ptr_;

  
};

class SharedMemHistogram : public Histogram {
 public:
  SharedMemHistogram(StringPiece name, Statistics* stats);

  virtual ~SharedMemHistogram();
  virtual void Add(double value);
  virtual void Clear();
  virtual int NumBuckets();
  virtual void EnableNegativeBuckets();
  virtual void SetMinValue(double value);
  virtual void SetMaxValue(double value);

  virtual void SetSuggestedNumBuckets(int i);

  size_t AllocationSize(AbstractSharedMem* shm_runtime) {
    return shm_runtime->SharedMutexSize() + sizeof(HistogramBody) +
        sizeof(double) * NumBuckets();
  }

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

 private:
  friend class SharedMemStatistics;
  void AttachTo(AbstractSharedMemSegment* segment, size_t offset,
                MessageHandler* message_handler);

  double BucketWidth();

  int FindBucket(double value);
  void Init();
  void DCheckRanges() const;
  void Reset();
  void ClearInternal(); 
  const GoogleString name_;
  scoped_ptr<AbstractMutex> mutex_;
  struct HistogramBody {
    bool enable_negative_;
    double min_value_;
    double max_value_;
    double min_;
    double max_;
    double count_;
    double sum_;
    double sum_of_squares_;
    double values_[1];
  };
  int num_buckets_;
  HistogramBody* buffer_; 
  
};

class SharedMemStatistics : public ScalarStatisticsTemplate<
  SharedMemVariable, SharedMemHistogram, FakeTimedVariable> {
 public:
  SharedMemStatistics(int64 logging_interval_ms,
                      int64 max_logfile_size_kb,
                      const StringPiece& logging_file, bool logging,
                      const GoogleString& filename_prefix,
                      AbstractSharedMem* shm_runtime,
                      MessageHandler* message_handler, FileSystem* file_system,
                      Timer* timer);
  virtual ~SharedMemStatistics();

  bool Init(bool parent, MessageHandler* message_handler);

  void GlobalCleanup(MessageHandler* message_handler);

  static void GlobalCleanup(AbstractSharedMem* shm_runtime,
                            const GoogleString& segment_name,
                            MessageHandler* message_handler);

  GoogleString SegmentName() const;

  virtual StatisticsLogger* console_logger() {
    return console_logger_.get();
  }

 protected:
  virtual Var* NewVariable(StringPiece name);
  virtual UpDown* NewUpDownCounter(StringPiece name);
  virtual Hist* NewHistogram(StringPiece name);

 private:
  bool InitMutexes(size_t per_var, MessageHandler* message_handler);

  friend class SharedMemStatisticsTestBase;

  AbstractSharedMem* shm_runtime_;
  GoogleString filename_prefix_;
  scoped_ptr<AbstractSharedMemSegment> segment_;
  bool frozen_;
  scoped_ptr<StatisticsLogger> console_logger_;

  
};

}  

#endif