The Tor Browser / file revision

 /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */

 /* This Source Code Form is subject to the terms of the Mozilla Public

  * License, v. 2.0. If a copy of the MPL was not distributed with this

  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */

 #ifndef TableTicker_h

 #define TableTicker_h

 #include "platform.h"

 #include "ProfileEntry.h"

 #include "mozilla/Mutex.h"

 #include "IntelPowerGadget.h"

 static bool

 hasFeature(const char** aFeatures, uint32_t aFeatureCount, const char* aFeature) {

   for(size_t i = 0; i < aFeatureCount; i++) {

     if (strcmp(aFeatures[i], aFeature) == 0)

       return true;

   }

   return false;

 }

 static bool

 threadSelected(ThreadInfo* aInfo, char** aThreadNameFilters, uint32_t aFeatureCount) {

   if (aFeatureCount == 0) {

     return true;

   }

   for (uint32_t i = 0; i < aFeatureCount; ++i) {

     const char* filterPrefix = aThreadNameFilters[i];

     if (strncmp(aInfo->Name(), filterPrefix, strlen(filterPrefix)) == 0) {

       return true;

     }

   }

   return false;

 }

 extern TimeStamp sLastTracerEvent;

 extern int sFrameNumber;

 extern int sLastFrameNumber;

 extern unsigned int sCurrentEventGeneration;

 extern unsigned int sLastSampledEventGeneration;

 class BreakpadSampler;

 class TableTicker: public Sampler {

  public:

   TableTicker(double aInterval, int aEntrySize,

               const char** aFeatures, uint32_t aFeatureCount,

               const char** aThreadNameFilters, uint32_t aFilterCount)

     : Sampler(aInterval, true, aEntrySize)

     , mPrimaryThreadProfile(nullptr)

     , mSaveRequested(false)

     , mUnwinderThread(false)

     , mFilterCount(aFilterCount)

 #if defined(XP_WIN)

     , mIntelPowerGadget(nullptr)

 #endif

   {

     mUseStackWalk = hasFeature(aFeatures, aFeatureCount, "stackwalk");

     //XXX: It's probably worth splitting the jank profiler out from the regular profiler at some point

     mJankOnly = hasFeature(aFeatures, aFeatureCount, "jank");

     mProfileJS = hasFeature(aFeatures, aFeatureCount, "js");

     mProfileJava = hasFeature(aFeatures, aFeatureCount, "java");

     mProfilePower = hasFeature(aFeatures, aFeatureCount, "power");

     mProfileThreads = hasFeature(aFeatures, aFeatureCount, "threads");

     mUnwinderThread = hasFeature(aFeatures, aFeatureCount, "unwinder") || sps_version2();

     mAddLeafAddresses = hasFeature(aFeatures, aFeatureCount, "leaf");

     mPrivacyMode = hasFeature(aFeatures, aFeatureCount, "privacy");

     mAddMainThreadIO = hasFeature(aFeatures, aFeatureCount, "mainthreadio");

 #if defined(XP_WIN)

     if (mProfilePower) {

       mIntelPowerGadget = new IntelPowerGadget();

       mProfilePower = mIntelPowerGadget->Init();

     }

 #endif

     // Deep copy aThreadNameFilters

     mThreadNameFilters = new char*[aFilterCount];

     for (uint32_t i = 0; i < aFilterCount; ++i) {

       mThreadNameFilters[i] = strdup(aThreadNameFilters[i]);

     }

     sStartTime = TimeStamp::Now();

     {

       mozilla::MutexAutoLock lock(*sRegisteredThreadsMutex);

       // Create ThreadProfile for each registered thread

       for (uint32_t i = 0; i < sRegisteredThreads->size(); i++) {

         ThreadInfo* info = sRegisteredThreads->at(i);

         RegisterThread(info);

       }

       SetActiveSampler(this);

     }

   }

   ~TableTicker() {

     if (IsActive())

       Stop();

     SetActiveSampler(nullptr);

     // Destroy ThreadProfile for all threads

     {

       mozilla::MutexAutoLock lock(*sRegisteredThreadsMutex);

       for (uint32_t i = 0; i < sRegisteredThreads->size(); i++) {

         ThreadInfo* info = sRegisteredThreads->at(i);

         ThreadProfile* profile = info->Profile();

         if (profile) {

           delete profile;

           info->SetProfile(nullptr);

         }

       }

     }

 #if defined(XP_WIN)

     delete mIntelPowerGadget;

 #endif

   }

   void RegisterThread(ThreadInfo* aInfo) {

     if (!aInfo->IsMainThread() && !mProfileThreads) {

       return;

     }

     if (!threadSelected(aInfo, mThreadNameFilters, mFilterCount)) {

       return;

     }

     ThreadProfile* profile = new ThreadProfile(aInfo->Name(),

                                                EntrySize(),

                                                aInfo->Stack(),

                                                aInfo->ThreadId(),

                                                aInfo->GetPlatformData(),

                                                aInfo->IsMainThread(),

                                                aInfo->StackTop());

     aInfo->SetProfile(profile);

   }

   // Called within a signal. This function must be reentrant

   virtual void Tick(TickSample* sample);

   // Immediately captures the calling thread's call stack and returns it.

   virtual SyncProfile* GetBacktrace();

   // Called within a signal. This function must be reentrant

   virtual void RequestSave()

   {

     mSaveRequested = true;

   }

   virtual void HandleSaveRequest();

   ThreadProfile* GetPrimaryThreadProfile()

   {

     if (!mPrimaryThreadProfile) {

       mozilla::MutexAutoLock lock(*sRegisteredThreadsMutex);

       for (uint32_t i = 0; i < sRegisteredThreads->size(); i++) {

         ThreadInfo* info = sRegisteredThreads->at(i);

         if (info->IsMainThread()) {

           mPrimaryThreadProfile = info->Profile();

           break;

         }

       }

     }

     return mPrimaryThreadProfile;

   }

   void ToStreamAsJSON(std::ostream& stream);

   virtual JSObject *ToJSObject(JSContext *aCx);

   void StreamMetaJSCustomObject(JSStreamWriter& b);

   bool HasUnwinderThread() const { return mUnwinderThread; }

   bool ProfileJS() const { return mProfileJS; }

   bool ProfileJava() const { return mProfileJava; }

   bool ProfilePower() const { return mProfilePower; }

   bool ProfileThreads() const { return mProfileThreads; }

   bool InPrivacyMode() const { return mPrivacyMode; }

   bool AddMainThreadIO() const { return mAddMainThreadIO; }

 protected:

   // Called within a signal. This function must be reentrant

   virtual void UnwinderTick(TickSample* sample);

   // Called within a signal. This function must be reentrant

   virtual void InplaceTick(TickSample* sample);

   // Not implemented on platforms which do not support backtracing

   void doNativeBacktrace(ThreadProfile &aProfile, TickSample* aSample);

   void StreamJSObject(JSStreamWriter& b);

   // This represent the application's main thread (SAMPLER_INIT)

   ThreadProfile* mPrimaryThreadProfile;

   bool mSaveRequested;

   bool mAddLeafAddresses;

   bool mUseStackWalk;

   bool mJankOnly;

   bool mProfileJS;

   bool mProfileThreads;

   bool mUnwinderThread;

   bool mProfileJava;

   bool mProfilePower;

   // Keep the thread filter to check against new thread that

   // are started while profiling

   char** mThreadNameFilters;

   uint32_t mFilterCount;

   bool mPrivacyMode;

   bool mAddMainThreadIO;

 #if defined(XP_WIN)

   IntelPowerGadget* mIntelPowerGadget;

 #endif

 };

 #endif