Page Speed Optimization Libraries  1.3.25.1
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 <utility>
00022 #include <vector>
00023 
00024 #include "net/instaweb/util/public/abstract_mutex.h"
00025 #include "net/instaweb/util/public/abstract_shared_mem.h"
00026 #include "net/instaweb/util/public/basictypes.h"
00027 #include "net/instaweb/util/public/scoped_ptr.h"
00028 #include "net/instaweb/util/public/statistics.h"
00029 #include "net/instaweb/util/public/statistics_template.h"
00030 #include "net/instaweb/util/public/string.h"
00031 #include "net/instaweb/util/public/string_util.h"
00032 #include "net/instaweb/util/public/file_system.h"
00033 #include "net/instaweb/util/public/gtest_prod.h"  
00034 
00035 namespace net_instaweb {
00036 
00037 class MessageHandler;
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(ConsoleStatisticsLogger* 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   ConsoleStatisticsLogger* 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();
00120   bool ReadNextDataBlock(int64* timestamp, GoogleString* data);
00121   int64 end_time() { return end_time_; }
00122 
00123  private:
00124   size_t BufferFind(const char* search_for, size_t start_at);
00125   int FeedBuffer();
00126 
00127   FileSystem::InputFile* file_;
00128   int64 start_time_;
00129   int64 end_time_;
00130   int64 granularity_ms_;
00131   MessageHandler* message_handler_;
00132   GoogleString buffer_;
00133 
00134   DISALLOW_COPY_AND_ASSIGN(ConsoleStatisticsLogfileReader);
00135 };
00136 
00137 class SharedMemConsoleStatisticsLogger : public ConsoleStatisticsLogger {
00138  public:
00139   SharedMemConsoleStatisticsLogger(
00140       const int64 update_interval_ms, const StringPiece& log_file,
00141       SharedMemVariable* var, MessageHandler* message_handler,
00142       Statistics* stats, FileSystem *file_system, Timer* timer);
00143   virtual ~SharedMemConsoleStatisticsLogger();
00144   virtual void UpdateAndDumpIfRequired();
00145   Timer* timer() { return timer_;}
00151   void DumpJSON(const std::set<GoogleString>& var_titles,
00152                 const std::set<GoogleString>& hist_titles, int64 start_time,
00153                 int64 end_time, int64 granularity_ms, Writer* writer,
00154                 MessageHandler* message_handler) const;
00155 
00156  private:
00157   friend class SharedMemStatisticsTestBase;
00158   FRIEND_TEST(SharedMemStatisticsTestBase, TestNextDataBlock);
00159   FRIEND_TEST(SharedMemStatisticsTestBase, TestParseVarData);
00160   FRIEND_TEST(SharedMemStatisticsTestBase, TestParseHistData);
00161   FRIEND_TEST(SharedMemStatisticsTestBase, TestPrintJSONResponse);
00162   FRIEND_TEST(SharedMemStatisticsTestBase, TestParseDataFromReader);
00163 
00164   typedef std::vector<GoogleString> VariableInfo;
00165   typedef std::map<GoogleString, VariableInfo> VarMap;
00166   typedef std::pair<GoogleString, GoogleString> HistBounds;
00167   typedef std::pair<HistBounds, GoogleString> HistBarInfo;
00168   typedef std::vector<HistBarInfo> HistInfo;
00169   typedef std::map<GoogleString, HistInfo> HistMap;
00170   void ParseDataFromReader(const std::set<GoogleString>& var_titles,
00171                            const std::set<GoogleString>& hist_titles,
00172                            ConsoleStatisticsLogfileReader* reader,
00173                            std::vector<int64>* list_of_timestamps,
00174                            VarMap* parsed_var_data, HistMap* parsed_hist_data)
00175                            const;
00176   void ParseVarDataIntoMap(StringPiece logfile_var_data,
00177                            const std::set<GoogleString>& var_titles,
00178                            VarMap* parsed_var_data) const;
00179   HistMap ParseHistDataIntoMap(StringPiece logfile_hist_data,
00180                                const std::set<GoogleString>& hist_titles) const;
00181   void PrintVarDataAsJSON(const VarMap& parsed_var_data, Writer* writer,
00182                           MessageHandler* message_handler) const;
00183   void PrintHistDataAsJSON(const HistMap* parsed_hist_data, Writer* writer,
00184                            MessageHandler* message_handler) const;
00185   void PrintTimestampListAsJSON(const std::vector<int64>& list_of_timestamps,
00186                                 Writer* writer,
00187                                 MessageHandler* message_handler) const;
00188   void PrintJSON(const std::vector<int64> & list_of_timestamps,
00189                  const VarMap& parsed_var_data, const HistMap& parsed_hist_data,
00190                  Writer* writer, MessageHandler* message_handler) const;
00191 
00194   SharedMemVariable* last_dump_timestamp_;
00195   MessageHandler* message_handler_;
00196   Statistics* statistics_; 
00197 
00198 
00199   FileSystem* file_system_;
00200   Timer* timer_; 
00201   const int64 update_interval_ms_;
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 Reset();
00266   void ClearInternal(); 
00267   const GoogleString name_;
00268   scoped_ptr<AbstractMutex> mutex_;
00270   struct HistogramBody {
00272     bool enable_negative_;
00274     double min_value_;
00277     double max_value_;
00279     double min_;
00281     double max_;
00282     double count_;
00283     double sum_;
00284     double sum_of_squares_;
00286     double values_[1];
00287   };
00289   int num_buckets_;
00290   HistogramBody* buffer_; 
00291   DISALLOW_COPY_AND_ASSIGN(SharedMemHistogram);
00292 };
00293 
00294 class SharedMemStatistics : public StatisticsTemplate<SharedMemVariable,
00295     SharedMemHistogram, FakeTimedVariable> {
00296  public:
00297   SharedMemStatistics(int64 logging_interval_ms,
00298                       const StringPiece& logging_file, bool logging,
00299                       const GoogleString& filename_prefix,
00300                       AbstractSharedMem* shm_runtime,
00301                       MessageHandler* message_handler, FileSystem* file_system,
00302                       Timer* timer);
00303   virtual ~SharedMemStatistics();
00304 
00313   void Init(bool parent, MessageHandler* message_handler);
00314 
00317   void GlobalCleanup(MessageHandler* message_handler);
00318 
00319   ConsoleStatisticsLogger* console_logger() const { return logger_.get(); }
00320 
00321   virtual void DumpConsoleVarsToWriter(int64 current_time_ms, Writer* writer,
00322                                        MessageHandler* message_handler);
00325   bool IsIgnoredVariable(const GoogleString& var_name);
00326 
00327  protected:
00328   virtual SharedMemVariable* NewVariable(const StringPiece& name, int index);
00329   virtual SharedMemHistogram* NewHistogram(const StringPiece& name);
00330   virtual FakeTimedVariable* NewTimedVariable(const StringPiece& name,
00331                                               int index);
00332 
00333  private:
00334   GoogleString SegmentName() const;
00335 
00338   bool InitMutexes(size_t per_var, MessageHandler* message_handler);
00339 
00340   AbstractSharedMem* shm_runtime_;
00341   GoogleString filename_prefix_;
00342   scoped_ptr<AbstractSharedMemSegment> segment_;
00343   bool frozen_;
00344   scoped_ptr<SharedMemConsoleStatisticsLogger> logger_;
00346   std::set<GoogleString> important_variables_;
00347 
00348   DISALLOW_COPY_AND_ASSIGN(SharedMemStatistics);
00349 };
00350 
00351 }  
00352 
00353 #endif  ///< NET_INSTAWEB_UTIL_PUBLIC_SHARED_MEM_STATISTICS_H_
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Defines