Page Speed Optimization Libraries  1.5.27.2
net/instaweb/util/public/shared_mem_statistics.h
00001 // Copyright 2010 Google Inc. All Rights Reserved.
00014 
00015 #ifndef NET_INSTAWEB_UTIL_PUBLIC_SHARED_MEM_STATISTICS_H_
00016 #define NET_INSTAWEB_UTIL_PUBLIC_SHARED_MEM_STATISTICS_H_
00017 
00018 #include <cstddef>
00019 #include <map>
00020 #include <set>
00021 #include <vector>
00022 
00023 #include "net/instaweb/util/public/abstract_mutex.h"
00024 #include "net/instaweb/util/public/abstract_shared_mem.h"
00025 #include "net/instaweb/util/public/basictypes.h"
00026 #include "net/instaweb/util/public/scoped_ptr.h"
00027 #include "net/instaweb/util/public/statistics.h"
00028 #include "net/instaweb/util/public/statistics_template.h"
00029 #include "net/instaweb/util/public/string.h"
00030 #include "net/instaweb/util/public/string_util.h"
00031 #include "net/instaweb/util/public/file_system.h"
00032 #include "net/instaweb/util/public/gtest_prod.h"  
00033 
00034 namespace net_instaweb {
00035 
00036 class MessageHandler;
00037 class SharedMemConsoleStatisticsLogger;
00038 class Timer;
00039 class Writer;
00040 
00059 class SharedMemVariable : public Variable {
00060  public:
00061   virtual ~SharedMemVariable() {}
00062   int64 Get() const;
00063   virtual int64 SetReturningPreviousValue(int64 new_value); 
00064   virtual void Set(int64 new_value);
00065   virtual int64 Add(int delta);
00066   virtual StringPiece GetName() const { return name_; }
00067   AbstractMutex* mutex();
00068 
00069  private:
00070   friend class SharedMemConsoleStatisticsLogger;
00071   friend class SharedMemStatistics;
00072   friend class SharedMemTimedVariable;
00073 
00074   explicit SharedMemVariable(const StringPiece& name);
00075 
00076   void AttachTo(AbstractSharedMemSegment* segment_, size_t offset,
00077                 MessageHandler* message_handler);
00078 
00081   void Reset();
00082 
00083   void SetConsoleStatisticsLogger(SharedMemConsoleStatisticsLogger* logger);
00084 
00089   void SetLockHeldNoUpdate(int64 newValue);
00090 
00092   int64 GetLockHeld() const;
00093 
00095   const GoogleString name_;
00096 
00098   scoped_ptr<AbstractMutex> mutex_;
00099 
00101   volatile int64* value_ptr_;
00102 
00106   SharedMemConsoleStatisticsLogger* console_logger_;
00107 
00108   DISALLOW_COPY_AND_ASSIGN(SharedMemVariable);
00109 };
00110 
00112 class ConsoleStatisticsLogfileReader {
00113  public:
00114   ConsoleStatisticsLogfileReader(FileSystem::InputFile* file, int64 start_time,
00115                                  int64 end_time, int64 granularity_ms,
00116                                  MessageHandler* message_handler);
00117   ~ConsoleStatisticsLogfileReader();
00118 
00124   bool ReadNextDataBlock(int64* timestamp, GoogleString* data);
00125   int64 end_time() { return end_time_; }
00126 
00127  private:
00128   size_t BufferFind(const char* search_for, size_t start_at);
00129   int FeedBuffer();
00130 
00131   FileSystem::InputFile* file_;
00132   int64 start_time_;
00133   int64 end_time_;
00134   int64 granularity_ms_;
00135   MessageHandler* message_handler_;
00137   GoogleString buffer_;
00138 
00139   DISALLOW_COPY_AND_ASSIGN(ConsoleStatisticsLogfileReader);
00140 };
00141 
00142 class SharedMemConsoleStatisticsLogger : public ConsoleStatisticsLogger {
00143  public:
00144   SharedMemConsoleStatisticsLogger(
00145       int64 update_interval_ms, int64 max_logfile_size_kb,
00146       const StringPiece& log_file, SharedMemVariable* last_dump_timestamp,
00147       MessageHandler* message_handler, Statistics* stats,
00148       FileSystem* file_system, Timer* timer);
00149   virtual ~SharedMemConsoleStatisticsLogger();
00150 
00155   virtual void DumpJSON(const std::set<GoogleString>& var_titles,
00156                         int64 start_time, int64 end_time, int64 granularity_ms,
00157                         Writer* writer, MessageHandler* message_handler) const;
00158 
00161   void UpdateAndDumpIfRequired();
00162 
00164   void TrimLogfileIfNeeded();
00165 
00166  private:
00167   friend class SharedMemStatisticsTestBase;
00168   FRIEND_TEST(SharedMemStatisticsTestBase, TestNextDataBlock);
00169   FRIEND_TEST(SharedMemStatisticsTestBase, TestParseVarData);
00170   FRIEND_TEST(SharedMemStatisticsTestBase, TestPrintJSONResponse);
00171   FRIEND_TEST(SharedMemStatisticsTestBase, TestParseDataFromReader);
00172 
00173   typedef std::vector<GoogleString> VariableInfo;
00174   typedef std::map<GoogleString, VariableInfo> VarMap;
00175   void ParseDataFromReader(const std::set<GoogleString>& var_titles,
00176                            ConsoleStatisticsLogfileReader* reader,
00177                            std::vector<int64>* list_of_timestamps,
00178                            VarMap* parsed_var_data) const;
00179   void ParseVarDataIntoMap(StringPiece logfile_var_data,
00180                            const std::set<GoogleString>& var_titles,
00181                            VarMap* parsed_var_data) const;
00182   void PrintVarDataAsJSON(const VarMap& parsed_var_data, Writer* writer,
00183                           MessageHandler* message_handler) const;
00184   void PrintTimestampListAsJSON(const std::vector<int64>& list_of_timestamps,
00185                                 Writer* writer,
00186                                 MessageHandler* message_handler) const;
00187   void PrintJSON(const std::vector<int64>& list_of_timestamps,
00188                  const VarMap& parsed_var_data,
00189                  Writer* writer, MessageHandler* message_handler) const;
00190 
00193   SharedMemVariable* last_dump_timestamp_;
00194   MessageHandler* message_handler_;
00195   Statistics* statistics_; 
00196 
00197 
00198   FileSystem* file_system_;
00199   Timer* timer_; 
00200   const int64 update_interval_ms_;
00201   const int64 max_logfile_size_kb_;
00202   GoogleString logfile_name_;
00203   DISALLOW_COPY_AND_ASSIGN(SharedMemConsoleStatisticsLogger);
00204 };
00205 
00206 class SharedMemHistogram : public Histogram {
00207  public:
00208   virtual ~SharedMemHistogram();
00209   virtual void Add(double value);
00210   virtual void Clear();
00211   virtual int NumBuckets();
00215   virtual void EnableNegativeBuckets();
00217   virtual void SetMinValue(double value);
00221   virtual void SetMaxValue(double value);
00222 
00227   virtual void SetSuggestedNumBuckets(int i);
00228 
00231   size_t AllocationSize(AbstractSharedMem* shm_runtime) {
00234     return shm_runtime->SharedMutexSize() + sizeof(HistogramBody) +
00235         sizeof(double) * NumBuckets();
00236   }
00237 
00238  protected:
00239   virtual AbstractMutex* lock() {
00240     return mutex_.get();
00241   }
00242   virtual double AverageInternal();
00243   virtual double PercentileInternal(const double perc);
00244   virtual double StandardDeviationInternal();
00245   virtual double CountInternal();
00246   virtual double MaximumInternal();
00247   virtual double MinimumInternal();
00248   virtual double BucketStart(int index);
00249   virtual double BucketCount(int index);
00250 
00251  private:
00252   friend class SharedMemStatistics;
00253   SharedMemHistogram();
00254   void AttachTo(AbstractSharedMemSegment* segment, size_t offset,
00255                 MessageHandler* message_handler);
00256 
00259   double BucketWidth();
00260 
00263   int FindBucket(double value);
00264   void Init();
00265   void DCheckRanges() const;
00266   void Reset();
00267   void ClearInternal(); 
00268   const GoogleString name_;
00269   scoped_ptr<AbstractMutex> mutex_;
00271   struct HistogramBody {
00273     bool enable_negative_;
00275     double min_value_;
00278     double max_value_;
00280     double min_;
00282     double max_;
00283     double count_;
00284     double sum_;
00285     double sum_of_squares_;
00287     double values_[1];
00288   };
00290   int num_buckets_;
00291   HistogramBody* buffer_; 
00292   DISALLOW_COPY_AND_ASSIGN(SharedMemHistogram);
00293 };
00294 
00295 class SharedMemStatistics : public StatisticsTemplate<SharedMemVariable,
00296     SharedMemHistogram, FakeTimedVariable> {
00297  public:
00298   SharedMemStatistics(int64 logging_interval_ms,
00299                       int64 max_logfile_size_kb,
00300                       const StringPiece& logging_file, bool logging,
00301                       const GoogleString& filename_prefix,
00302                       AbstractSharedMem* shm_runtime,
00303                       MessageHandler* message_handler, FileSystem* file_system,
00304                       Timer* timer);
00305   virtual ~SharedMemStatistics();
00306 
00315   void Init(bool parent, MessageHandler* message_handler);
00316 
00319   void GlobalCleanup(MessageHandler* message_handler);
00320 
00321   SharedMemConsoleStatisticsLogger* console_logger() {
00322     return console_logger_.get();
00323   }
00324 
00325   virtual void DumpConsoleVarsToWriter(int64 current_time_ms, Writer* writer,
00326                                        MessageHandler* message_handler);
00329   bool IsIgnoredVariable(const GoogleString& var_name);
00330 
00331  protected:
00332   virtual SharedMemVariable* NewVariable(const StringPiece& name, int index);
00333   virtual SharedMemHistogram* NewHistogram(const StringPiece& name);
00334   virtual FakeTimedVariable* NewTimedVariable(const StringPiece& name,
00335                                               int index);
00336 
00337  private:
00338   GoogleString SegmentName() const;
00339 
00342   bool InitMutexes(size_t per_var, MessageHandler* message_handler);
00343 
00344   friend class SharedMemStatisticsTestBase;
00345 
00346   AbstractSharedMem* shm_runtime_;
00347   GoogleString filename_prefix_;
00348   scoped_ptr<AbstractSharedMemSegment> segment_;
00349   bool frozen_;
00350   scoped_ptr<SharedMemConsoleStatisticsLogger> console_logger_;
00352   std::set<GoogleString> important_variables_;
00353 
00354   DISALLOW_COPY_AND_ASSIGN(SharedMemStatistics);
00355 };
00356 
00357 }  
00358 
00359 #endif  ///< NET_INSTAWEB_UTIL_PUBLIC_SHARED_MEM_STATISTICS_H_
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Defines