Source code
Revision control
Copy as Markdown
Other Tools
/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* vim: set ts=8 sts=2 et sw=2 tw=80: */
/* 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
#ifndef ProfiledThreadData_h
#define ProfiledThreadData_h
#include "platform.h"
#include "ProfileBuffer.h"
#include "ProfileBufferEntry.h"
#include "mozilla/FailureLatch.h"
#include "mozilla/Maybe.h"
#include "mozilla/NotNull.h"
#include "mozilla/ProfileJSONWriter.h"
#include "mozilla/ProfilerThreadRegistrationInfo.h"
#include "mozilla/RefPtr.h"
#include "mozilla/TimeStamp.h"
#include "mozilla/UniquePtr.h"
#include "mozilla/Vector.h"
#include "nsStringFwd.h"
class nsIEventTarget;
class ProfilerCodeAddressService;
struct JSContext;
struct ThreadStreamingContext;
// This class contains information about a thread that is only relevant while
// the profiler is running, for any threads (both alive and dead) whose thread
// name matches the "thread filter" in the current profiler run.
// ProfiledThreadData objects may be kept alive even after the thread is
// unregistered, as long as there is still data for that thread in the profiler
// buffer.
//
// Accesses to this class are protected by the profiler state lock.
//
// Created as soon as the following are true for the thread:
// - The profiler is running, and
// - the thread matches the profiler's thread filter, and
// - the thread is registered with the profiler.
// So it gets created in response to either (1) the profiler being started (for
// an existing registered thread) or (2) the thread being registered (if the
// profiler is already running).
//
// The thread may be unregistered during the lifetime of ProfiledThreadData.
// If that happens, NotifyUnregistered() is called.
//
// This class is the right place to store buffer positions. Profiler buffer
// positions become invalid if the profiler buffer is destroyed, which happens
// when the profiler is stopped.
class ProfiledThreadData final {
public:
explicit ProfiledThreadData(
const mozilla::profiler::ThreadRegistrationInfo& aThreadInfo);
explicit ProfiledThreadData(
mozilla::profiler::ThreadRegistrationInfo&& aThreadInfo);
~ProfiledThreadData();
void NotifyUnregistered(uint64_t aBufferPosition) {
mLastSample = mozilla::Nothing();
MOZ_ASSERT(!mBufferPositionWhenReceivedJSContext,
"JSContext should have been cleared before the thread was "
"unregistered");
mUnregisterTime = mozilla::TimeStamp::Now();
mBufferPositionWhenUnregistered = mozilla::Some(aBufferPosition);
mPreviousThreadRunningTimes.Clear();
}
mozilla::Maybe<uint64_t> BufferPositionWhenUnregistered() {
return mBufferPositionWhenUnregistered;
}
mozilla::Maybe<uint64_t>& LastSample() { return mLastSample; }
mozilla::NotNull<mozilla::UniquePtr<UniqueStacks>> PrepareUniqueStacks(
const ProfileBuffer& aBuffer, JSContext* aCx,
mozilla::FailureLatch& aFailureLatch,
ProfilerCodeAddressService* aService,
mozilla::ProgressLogger aProgressLogger);
void StreamJSON(const ProfileBuffer& aBuffer, JSContext* aCx,
SpliceableJSONWriter& aWriter, const nsACString& aProcessName,
const nsACString& aETLDplus1,
const mozilla::TimeStamp& aProcessStartTime,
double aSinceTime, ProfilerCodeAddressService* aService,
mozilla::ProgressLogger aProgressLogger);
void StreamJSON(ThreadStreamingContext&& aThreadStreamingContext,
SpliceableJSONWriter& aWriter, const nsACString& aProcessName,
const nsACString& aETLDplus1,
const mozilla::TimeStamp& aProcessStartTime,
ProfilerCodeAddressService* aService,
mozilla::ProgressLogger aProgressLogger);
const mozilla::profiler::ThreadRegistrationInfo& Info() const {
return mThreadInfo;
}
void NotifyReceivedJSContext(uint64_t aCurrentBufferPosition) {
mBufferPositionWhenReceivedJSContext =
mozilla::Some(aCurrentBufferPosition);
}
// Call this method when the JS entries inside the buffer are about to
// become invalid, i.e., just before JS shutdown.
void NotifyAboutToLoseJSContext(JSContext* aCx,
const mozilla::TimeStamp& aProcessStartTime,
ProfileBuffer& aBuffer);
RunningTimes& PreviousThreadRunningTimesRef() {
return mPreviousThreadRunningTimes;
}
private:
// Group A:
// The following fields are interesting for the entire lifetime of a
// ProfiledThreadData object.
// This thread's thread info. Local copy because the one in ThreadRegistration
// may be destroyed while ProfiledThreadData stays alive.
const mozilla::profiler::ThreadRegistrationInfo mThreadInfo;
// Contains JSON for JIT frames from any JSContexts that were used for this
// thread in the past.
// Null if this thread has never lost a JSContext or if all samples from
// previous JSContexts have been evicted from the profiler buffer.
mozilla::UniquePtr<JITFrameInfo> mJITFrameInfoForPreviousJSContexts;
// Group B:
// The following fields are only used while this thread is alive and
// registered. They become Nothing() or empty once the thread is unregistered.
// When sampling, this holds the position in ActivePS::mBuffer of the most
// recent sample for this thread, or Nothing() if there is no sample for this
// thread in the buffer.
mozilla::Maybe<uint64_t> mLastSample;
// Only non-Nothing() if the thread currently has a JSContext.
mozilla::Maybe<uint64_t> mBufferPositionWhenReceivedJSContext;
// RunningTimes at the previous sample if any, or empty.
RunningTimes mPreviousThreadRunningTimes;
// Group C:
// The following fields are only used once this thread has been unregistered.
mozilla::Maybe<uint64_t> mBufferPositionWhenUnregistered;
mozilla::TimeStamp mUnregisterTime;
};
// This class will be used when outputting the profile data for one thread.
struct ThreadStreamingContext {
ProfiledThreadData& mProfiledThreadData;
JSContext* mJSContext;
SpliceableChunkedJSONWriter mSamplesDataWriter;
SpliceableChunkedJSONWriter mMarkersDataWriter;
mozilla::NotNull<mozilla::UniquePtr<UniqueStacks>> mUniqueStacks;
// These are updated when writing samples, and reused for "same-sample"s.
enum PreviousStackState { eNoStackYet, eStackWasNotEmpty, eStackWasEmpty };
PreviousStackState mPreviousStackState = eNoStackYet;
uint32_t mPreviousStack = 0;
ThreadStreamingContext(ProfiledThreadData& aProfiledThreadData,
const ProfileBuffer& aBuffer, JSContext* aCx,
mozilla::FailureLatch& aFailureLatch,
ProfilerCodeAddressService* aService,
mozilla::ProgressLogger aProgressLogger);
void FinalizeWriter();
};
// This class will be used when outputting the profile data for all threads.
class ProcessStreamingContext final : public mozilla::FailureLatch {
public:
// Pre-allocate space for `aThreadCount` threads.
ProcessStreamingContext(size_t aThreadCount,
mozilla::FailureLatch& aFailureLatch,
const mozilla::TimeStamp& aProcessStartTime,
double aSinceTime);
~ProcessStreamingContext();
// Add the streaming context corresponding to each profiled thread. This
// should be called exactly the number of times specified in the constructor.
void AddThreadStreamingContext(ProfiledThreadData& aProfiledThreadData,
const ProfileBuffer& aBuffer, JSContext* aCx,
ProfilerCodeAddressService* aService,
mozilla::ProgressLogger aProgressLogger);
// Retrieve the ThreadStreamingContext for a given thread id.
// Returns null if that thread id doesn't correspond to any profiled thread.
ThreadStreamingContext* GetThreadStreamingContext(
const ProfilerThreadId& aThreadId) {
for (size_t i = 0; i < mTIDList.length(); ++i) {
if (mTIDList[i] == aThreadId) {
return &mThreadStreamingContextList[i];
}
}
return nullptr;
}
const mozilla::TimeStamp& ProcessStartTime() const {
return mProcessStartTime;
}
double GetSinceTime() const { return mSinceTime; }
ThreadStreamingContext* begin() {
return mThreadStreamingContextList.begin();
};
ThreadStreamingContext* end() { return mThreadStreamingContextList.end(); };
FAILURELATCH_IMPL_PROXY(mFailureLatch)
private:
// Separate list of thread ids, it's much faster to do a linear search
// here than a vector of bigger items like mThreadStreamingContextList.
mozilla::Vector<ProfilerThreadId> mTIDList;
// Contexts corresponding to the thread id at the same indexes.
mozilla::Vector<ThreadStreamingContext> mThreadStreamingContextList;
mozilla::FailureLatch& mFailureLatch;
const mozilla::TimeStamp mProcessStartTime;
const double mSinceTime;
};
// Stream all samples and markers from aBuffer with the given aThreadId (or 0
// for everything, which is assumed to be a single backtrace sample.)
// Returns the thread id of the output sample(s), or 0 if none was present.
ProfilerThreadId StreamSamplesAndMarkers(
const char* aName, ProfilerThreadId aThreadId, const ProfileBuffer& aBuffer,
SpliceableJSONWriter& aWriter, const nsACString& aProcessName,
const nsACString& aETLDplus1, const mozilla::TimeStamp& aProcessStartTime,
const mozilla::TimeStamp& aRegisterTime,
const mozilla::TimeStamp& aUnregisterTime, double aSinceTime,
UniqueStacks& aUniqueStacks, mozilla::ProgressLogger aProgressLogger);
void StreamSamplesAndMarkers(const char* aName,
ThreadStreamingContext& aThreadData,
SpliceableJSONWriter& aWriter,
const nsACString& aProcessName,
const nsACString& aETLDplus1,
const mozilla::TimeStamp& aProcessStartTime,
const mozilla::TimeStamp& aRegisterTime,
const mozilla::TimeStamp& aUnregisterTime,
mozilla::ProgressLogger aProgressLogger);
#endif // ProfiledThreadData_h