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 PROFILER_PSEUDO_STACK_H_

 #define PROFILER_PSEUDO_STACK_H_

 #include "mozilla/ArrayUtils.h"

 #include "mozilla/NullPtr.h"

 #include <stdint.h>

 #include "js/ProfilingStack.h"

 #include <stdlib.h>

 #include "mozilla/Atomics.h"

 /* we duplicate this code here to avoid header dependencies

  * which make it more difficult to include in other places */

 #if defined(_M_X64) || defined(__x86_64__)

 #define V8_HOST_ARCH_X64 1

 #elif defined(_M_IX86) || defined(__i386__) || defined(__i386)

 #define V8_HOST_ARCH_IA32 1

 #elif defined(__ARMEL__)

 #define V8_HOST_ARCH_ARM 1

 #else

 #warning Please add support for your architecture in chromium_types.h

 #endif

 // STORE_SEQUENCER: Because signals can interrupt our profile modification

 //                  we need to make stores are not re-ordered by the compiler

 //                  or hardware to make sure the profile is consistent at

 //                  every point the signal can fire.

 #ifdef V8_HOST_ARCH_ARM

 // TODO Is there something cheaper that will prevent

 //      memory stores from being reordered

 typedef void (*LinuxKernelMemoryBarrierFunc)(void);

 LinuxKernelMemoryBarrierFunc pLinuxKernelMemoryBarrier __attribute__((weak)) =

     (LinuxKernelMemoryBarrierFunc) 0xffff0fa0;

 # define STORE_SEQUENCER() pLinuxKernelMemoryBarrier()

 #elif defined(V8_HOST_ARCH_IA32) || defined(V8_HOST_ARCH_X64)

 # if defined(_MSC_VER)

 #if _MSC_VER > 1400

 #  include <intrin.h>

 #else // _MSC_VER > 1400

     // MSVC2005 has a name collision bug caused when both <intrin.h> and <winnt.h> are included together.

 #ifdef _WINNT_

 #  define _interlockedbittestandreset _interlockedbittestandreset_NAME_CHANGED_TO_AVOID_MSVS2005_ERROR

 #  define _interlockedbittestandset _interlockedbittestandset_NAME_CHANGED_TO_AVOID_MSVS2005_ERROR

 #  include <intrin.h>

 #else

 #  include <intrin.h>

 #  define _interlockedbittestandreset _interlockedbittestandreset_NAME_CHANGED_TO_AVOID_MSVS2005_ERROR

 #  define _interlockedbittestandset _interlockedbittestandset_NAME_CHANGED_TO_AVOID_MSVS2005_ERROR

 #endif

    // Even though MSVC2005 has the intrinsic _ReadWriteBarrier, it fails to link to it when it's

    // not explicitly declared.

 #  pragma intrinsic(_ReadWriteBarrier)

 #endif // _MSC_VER > 1400

 #  define STORE_SEQUENCER() _ReadWriteBarrier();

 # elif defined(__INTEL_COMPILER)

 #  define STORE_SEQUENCER() __memory_barrier();

 # elif __GNUC__

 #  define STORE_SEQUENCER() asm volatile("" ::: "memory");

 # else

 #  error "Memory clobber not supported for your compiler."

 # endif

 #else

 # error "Memory clobber not supported for your platform."

 #endif

 // We can't include <algorithm> because it causes issues on OS X, so we use

 // our own min function.

 static inline uint32_t sMin(uint32_t l, uint32_t r) {

   return l < r ? l : r;

 }

 // A stack entry exists to allow the JS engine to inform SPS of the current

 // backtrace, but also to instrument particular points in C++ in case stack

 // walking is not available on the platform we are running on.

 //

 // Each entry has a descriptive string, a relevant stack address, and some extra

 // information the JS engine might want to inform SPS of. This class inherits

 // from the JS engine's version of the entry to ensure that the size and layout

 // of the two representations are consistent.

 class StackEntry : public js::ProfileEntry

 {

 public:

   bool isCopyLabel() const volatile {

     return !((uintptr_t)stackAddress() & 0x1);

   }

   void setStackAddressCopy(void *sparg, bool copy) volatile {

     // Tagged pointer. Less significant bit used to track if mLabel needs a

     // copy. Note that we don't need the last bit of the stack address for

     // proper ordering. This is optimized for encoding within the JS engine's

     // instrumentation, so we do the extra work here of encoding a bit.

     // Last bit 1 = Don't copy, Last bit 0 = Copy.

     if (copy) {

       setStackAddress(reinterpret_cast<void*>(

                         reinterpret_cast<uintptr_t>(sparg) & ~NoCopyBit));

     } else {

       setStackAddress(reinterpret_cast<void*>(

                         reinterpret_cast<uintptr_t>(sparg) | NoCopyBit));

     }

   }

 };

 class ProfilerMarkerPayload;

 template<typename T>

 class ProfilerLinkedList;

 class JSStreamWriter;

 class JSCustomArray;

 class ThreadProfile;

 class ProfilerMarker {

   friend class ProfilerLinkedList<ProfilerMarker>;

 public:

   ProfilerMarker(const char* aMarkerName,

          ProfilerMarkerPayload* aPayload = nullptr,

          float aTime = 0);

   ~ProfilerMarker();

   const char* GetMarkerName() const {

     return mMarkerName;

   }

   void

   StreamJSObject(JSStreamWriter& b) const;

   void SetGeneration(int aGenID);

   bool HasExpired(int aGenID) const {

     return mGenID + 2 <= aGenID;

   }

   float GetTime();

 private:

   char* mMarkerName;

   ProfilerMarkerPayload* mPayload;

   ProfilerMarker* mNext;

   float mTime;

   int mGenID;

 };

 // Foward declaration

 typedef struct _UnwinderThreadBuffer UnwinderThreadBuffer;

 /**

  * This struct is used to add a mNext field to UnwinderThreadBuffer objects for

  * use with ProfilerLinkedList. It is done this way so that UnwinderThreadBuffer

  * may continue to be opaque with respect to code outside of UnwinderThread2.cpp

  */

 struct LinkedUWTBuffer

 {

   LinkedUWTBuffer()

     :mNext(nullptr)

   {}

   virtual ~LinkedUWTBuffer() {}

   virtual UnwinderThreadBuffer* GetBuffer() = 0;

   LinkedUWTBuffer*  mNext;

 };

 template<typename T>

 class ProfilerLinkedList {

 public:

   ProfilerLinkedList()

     : mHead(nullptr)

     , mTail(nullptr)

   {}

   void insert(T* elem)

   {

     if (!mTail) {

       mHead = elem;

       mTail = elem;

     } else {

       mTail->mNext = elem;

       mTail = elem;

     }

     elem->mNext = nullptr;

   }

   T* popHead()

   {

     if (!mHead) {

       MOZ_ASSERT(false);

       return nullptr;

     }

     T* head = mHead;

     mHead = head->mNext;

     if (!mHead) {

       mTail = nullptr;

     }

     return head;

   }

   const T* peek() {

     return mHead;

   }

 private:

   T* mHead;

   T* mTail;

 };

 typedef ProfilerLinkedList<ProfilerMarker> ProfilerMarkerLinkedList;

 typedef ProfilerLinkedList<LinkedUWTBuffer> UWTBufferLinkedList;

 class PendingMarkers {

 public:

   PendingMarkers()

     : mSignalLock(false)

   {}

   ~PendingMarkers();

   void addMarker(ProfilerMarker *aMarker);

   void updateGeneration(int aGenID);

   /**

    * Track a marker which has been inserted into the ThreadProfile.

    * This marker can safely be deleted once the generation has

    * expired.

    */

   void addStoredMarker(ProfilerMarker *aStoredMarker);

   // called within signal. Function must be reentrant

   ProfilerMarkerLinkedList* getPendingMarkers()

   {

     // if mSignalLock then the stack is inconsistent because it's being

     // modified by the profiled thread. Post pone these markers

     // for the next sample. The odds of a livelock are nearly impossible

     // and would show up in a profile as many sample in 'addMarker' thus

     // we ignore this scenario.

     if (mSignalLock) {

       return nullptr;

     }

     return &mPendingMarkers;

   }

   void clearMarkers()

   {

     while (mPendingMarkers.peek()) {

       delete mPendingMarkers.popHead();

     }

     while (mStoredMarkers.peek()) {

       delete mStoredMarkers.popHead();

     }

   }

 private:

   // Keep a list of active markers to be applied to the next sample taken

   ProfilerMarkerLinkedList mPendingMarkers;

   ProfilerMarkerLinkedList mStoredMarkers;

   // If this is set then it's not safe to read mStackPointer from the signal handler

   volatile bool mSignalLock;

   // We don't want to modify _markers from within the signal so we allow

   // it to queue a clear operation.

   volatile mozilla::sig_safe_t mGenID;

 };

 class PendingUWTBuffers

 {

 public:

   PendingUWTBuffers()

     : mSignalLock(false)

   {

   }

   void addLinkedUWTBuffer(LinkedUWTBuffer* aBuff)

   {

     MOZ_ASSERT(aBuff);

     mSignalLock = true;

     STORE_SEQUENCER();

     mPendingUWTBuffers.insert(aBuff);

     STORE_SEQUENCER();

     mSignalLock = false;

   }

   // called within signal. Function must be reentrant

   UWTBufferLinkedList* getLinkedUWTBuffers()

   {

     if (mSignalLock) {

       return nullptr;

     }

     return &mPendingUWTBuffers;

   }

 private:

   UWTBufferLinkedList mPendingUWTBuffers;

   volatile bool       mSignalLock;

 };

 // Stub eventMarker function for js-engine event generation.

 void ProfilerJSEventMarker(const char *event);

 // the PseudoStack members are read by signal

 // handlers, so the mutation of them needs to be signal-safe.

 struct PseudoStack

 {

 public:

   PseudoStack()

     : mStackPointer(0)

     , mSleepId(0)

     , mSleepIdObserved(0)

     , mSleeping(false)

     , mRuntime(nullptr)

     , mStartJSSampling(false)

     , mPrivacyMode(false)

   { }

   ~PseudoStack() {

     if (mStackPointer != 0) {

       // We're releasing the pseudostack while it's still in use.

       // The label macros keep a non ref counted reference to the

       // stack to avoid a TLS. If these are not all cleared we will

       // get a use-after-free so better to crash now.

       abort();

     }

   }

   // This is called on every profiler restart. Put things that should happen at that time here.

   void reinitializeOnResume() {

     // This is needed to cause an initial sample to be taken from sleeping threads. Otherwise sleeping

     // threads would not have any samples to copy forward while sleeping.

     mSleepId++;

   }

   void addLinkedUWTBuffer(LinkedUWTBuffer* aBuff)

   {

     mPendingUWTBuffers.addLinkedUWTBuffer(aBuff);

   }

   UWTBufferLinkedList* getLinkedUWTBuffers()

   {

     return mPendingUWTBuffers.getLinkedUWTBuffers();

   }

   void addMarker(const char *aMarkerStr, ProfilerMarkerPayload *aPayload, float aTime)

   {

     ProfilerMarker* marker = new ProfilerMarker(aMarkerStr, aPayload, aTime);

     mPendingMarkers.addMarker(marker);

   }

   void addStoredMarker(ProfilerMarker *aStoredMarker) {

     mPendingMarkers.addStoredMarker(aStoredMarker);

   }

   void updateGeneration(int aGenID) {

     mPendingMarkers.updateGeneration(aGenID);

   }

   // called within signal. Function must be reentrant

   ProfilerMarkerLinkedList* getPendingMarkers()

   {

     return mPendingMarkers.getPendingMarkers();

   }

   void push(const char *aName, uint32_t line)

   {

     push(aName, nullptr, false, line);

   }

   void push(const char *aName, void *aStackAddress, bool aCopy, uint32_t line)

   {

     if (size_t(mStackPointer) >= mozilla::ArrayLength(mStack)) {

       mStackPointer++;

       return;

     }

     // Make sure we increment the pointer after the name has

     // been written such that mStack is always consistent.

     mStack[mStackPointer].setLabel(aName);

     mStack[mStackPointer].setStackAddressCopy(aStackAddress, aCopy);

     mStack[mStackPointer].setLine(line);

     // Prevent the optimizer from re-ordering these instructions

     STORE_SEQUENCER();

     mStackPointer++;

   }

   void pop()

   {

     mStackPointer--;

   }

   bool isEmpty()

   {

     return mStackPointer == 0;

   }

   uint32_t stackSize() const

   {

     return sMin(mStackPointer, mozilla::sig_safe_t(mozilla::ArrayLength(mStack)));

   }

   void sampleRuntime(JSRuntime *runtime) {

     mRuntime = runtime;

     if (!runtime) {

       // JS shut down

       return;

     }

     static_assert(sizeof(mStack[0]) == sizeof(js::ProfileEntry),

                   "mStack must be binary compatible with js::ProfileEntry.");

     js::SetRuntimeProfilingStack(runtime,

                                  (js::ProfileEntry*) mStack,

                                  (uint32_t*) &mStackPointer,

                                  uint32_t(mozilla::ArrayLength(mStack)));

     if (mStartJSSampling)

       enableJSSampling();

   }

   void enableJSSampling() {

     if (mRuntime) {

       js::EnableRuntimeProfilingStack(mRuntime, true);

       js::RegisterRuntimeProfilingEventMarker(mRuntime, &ProfilerJSEventMarker);

       mStartJSSampling = false;

     } else {

       mStartJSSampling = true;

     }

   }

   void jsOperationCallback() {

     if (mStartJSSampling)

       enableJSSampling();

   }

   void disableJSSampling() {

     mStartJSSampling = false;

     if (mRuntime)

       js::EnableRuntimeProfilingStack(mRuntime, false);

   }

   // Keep a list of active checkpoints

   StackEntry volatile mStack[1024];

  private:

   // Keep a list of pending markers that must be moved

   // to the circular buffer

   PendingMarkers mPendingMarkers;

   // List of LinkedUWTBuffers that must be processed on the next tick

   PendingUWTBuffers mPendingUWTBuffers;

   // This may exceed the length of mStack, so instead use the stackSize() method

   // to determine the number of valid samples in mStack

   mozilla::sig_safe_t mStackPointer;

   // Incremented at every sleep/wake up of the thread

   int mSleepId;

   // Previous id observed. If this is not the same as mSleepId, this thread is not sleeping in the same place any more

   mozilla::Atomic<int> mSleepIdObserved;

   // Keeps tack of whether the thread is sleeping or not (1 when sleeping 0 when awake)

   mozilla::Atomic<int> mSleeping;

  public:

   // The runtime which is being sampled

   JSRuntime *mRuntime;

   // Start JS Profiling when possible

   bool mStartJSSampling;

   bool mPrivacyMode;

   enum SleepState {NOT_SLEEPING, SLEEPING_FIRST, SLEEPING_AGAIN};

   // The first time this is called per sleep cycle we return SLEEPING_FIRST

   // and any other subsequent call within the same sleep cycle we return SLEEPING_AGAIN

   SleepState observeSleeping() {

     if (mSleeping != 0) {

       if (mSleepIdObserved == mSleepId) {

         return SLEEPING_AGAIN;

       } else {

         mSleepIdObserved = mSleepId;

         return SLEEPING_FIRST;

       }

     } else {

       return NOT_SLEEPING;

     }

   }

   // Call this whenever the current thread sleeps or wakes up

   // Calling setSleeping with the same value twice in a row is an error

   void setSleeping(int sleeping) {

     MOZ_ASSERT(mSleeping != sleeping);

     mSleepId++;

     mSleeping = sleeping;

   }

 };

 #endif