nagai/fune
3
0
Fork 0
forked from mirrors/gecko-dev
Code Pull requests Activity
fune/tools/profiler/tests/gtest/GeckoProfiler.cpp
Valentin Gosu 7ebb860b81 Bug 1898171 - Add SanitizedString profiler marker format r=acreskey,profiler-reviewers,aabh 
The sanitization function for URL and FilePath cannot currently sanitize
an arbitrary string in the profiler data. The expectation is that the URL
starts with a scheme like http:// and that a file path contains a /,
so none of them are sanitized if the contents are a domain name.
This commit introduces a new 'sanitized-string' format, that the profiler
can make sure to completely blank out.

Differential Revision: https://phabricator.services.mozilla.com/D211171
2024-06-04 17:59:19 +00:00

5040 lines
202 KiB
C++
Raw Blame History

/* -*- 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
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
// This file tests a lot of the profiler_*() functions in GeckoProfiler.h.
// Most of the tests just check that nothing untoward (e.g. crashes, deadlocks)
// happens when calling these functions. They don't do much inspection of
// profiler internals.
#include "mozilla/ProfilerThreadPlatformData.h"
#include "mozilla/ProfilerThreadRegistration.h"
#include "mozilla/ProfilerThreadRegistrationInfo.h"
#include "mozilla/ProfilerThreadRegistry.h"
#include "mozilla/ProfilerUtils.h"
#include "mozilla/ProgressLogger.h"
#include "mozilla/UniquePtrExtensions.h"
#include "nsIThread.h"
#include "nsThreadUtils.h"
#include "prthread.h"
#include "gtest/gtest.h"
#include "mozilla/gtest/MozAssertions.h"
#include <thread>
#if defined(_MSC_VER) || defined(__MINGW32__)
# include <processthreadsapi.h>
# include <realtimeapiset.h>
#elif defined(__APPLE__)
# include <mach/thread_act.h>
#endif
#ifdef MOZ_GECKO_PROFILER
# include "GeckoProfiler.h"
# include "mozilla/ProfilerMarkerTypes.h"
# include "mozilla/ProfilerMarkers.h"
# include "NetworkMarker.h"
# include "platform.h"
# include "ProfileBuffer.h"
# include "ProfilerControl.h"
# include "js/Initialization.h"
# include "js/Printf.h"
# include "jsapi.h"
# include "json/json.h"
# include "mozilla/Atomics.h"
# include "mozilla/DataMutex.h"
# include "mozilla/ProfileBufferEntrySerializationGeckoExtensions.h"
# include "mozilla/ProfileJSONWriter.h"
# include "mozilla/ScopeExit.h"
# include "mozilla/net/HttpBaseChannel.h"
# include "nsIChannelEventSink.h"
# include "nsIThread.h"
# include "nsThreadUtils.h"
# include <cstring>
# include <set>
#endif // MOZ_GECKO_PROFILER
// Note: profiler_init() has already been called in XRE_main(), so we can't
// test it here. Likewise for profiler_shutdown(), and AutoProfilerInit
// (which is just an RAII wrapper for profiler_init() and profiler_shutdown()).
using namespace mozilla;
TEST(GeckoProfiler, ProfilerUtils)
{
profiler_init_main_thread_id();
static_assert(std::is_same_v<decltype(profiler_current_process_id()),
ProfilerProcessId>);
static_assert(
std::is_same_v<decltype(profiler_current_process_id()),
decltype(baseprofiler::profiler_current_process_id())>);
ProfilerProcessId processId = profiler_current_process_id();
EXPECT_TRUE(processId.IsSpecified());
EXPECT_EQ(processId, baseprofiler::profiler_current_process_id());
static_assert(
std::is_same_v<decltype(profiler_current_thread_id()), ProfilerThreadId>);
static_assert(
std::is_same_v<decltype(profiler_current_thread_id()),
decltype(baseprofiler::profiler_current_thread_id())>);
EXPECT_EQ(profiler_current_thread_id(),
baseprofiler::profiler_current_thread_id());
ProfilerThreadId mainTestThreadId = profiler_current_thread_id();
EXPECT_TRUE(mainTestThreadId.IsSpecified());
ProfilerThreadId mainThreadId = profiler_main_thread_id();
EXPECT_TRUE(mainThreadId.IsSpecified());
EXPECT_EQ(mainThreadId, mainTestThreadId)
<< "Test should run on the main thread";
EXPECT_TRUE(profiler_is_main_thread());
std::thread testThread([&]() {
EXPECT_EQ(profiler_current_process_id(), processId);
const ProfilerThreadId testThreadId = profiler_current_thread_id();
EXPECT_TRUE(testThreadId.IsSpecified());
EXPECT_NE(testThreadId, mainThreadId);
EXPECT_FALSE(profiler_is_main_thread());
EXPECT_EQ(baseprofiler::profiler_current_process_id(), processId);
EXPECT_EQ(baseprofiler::profiler_current_thread_id(), testThreadId);
EXPECT_EQ(baseprofiler::profiler_main_thread_id(), mainThreadId);
EXPECT_FALSE(baseprofiler::profiler_is_main_thread());
});
testThread.join();
}
TEST(GeckoProfiler, ThreadRegistrationInfo)
{
profiler_init_main_thread_id();
TimeStamp ts = TimeStamp::Now();
{
profiler::ThreadRegistrationInfo trInfo{
"name", ProfilerThreadId::FromNumber(123), false, ts};
EXPECT_STREQ(trInfo.Name(), "name");
EXPECT_NE(trInfo.Name(), "name")
<< "ThreadRegistrationInfo should keep its own copy of the name";
EXPECT_EQ(trInfo.RegisterTime(), ts);
EXPECT_EQ(trInfo.ThreadId(), ProfilerThreadId::FromNumber(123));
EXPECT_EQ(trInfo.IsMainThread(), false);
}
// Make sure the next timestamp will be different from `ts`.
while (TimeStamp::Now() == ts) {
}
{
profiler::ThreadRegistrationInfo trInfoHere{"Here"};
EXPECT_STREQ(trInfoHere.Name(), "Here");
EXPECT_NE(trInfoHere.Name(), "Here")
<< "ThreadRegistrationInfo should keep its own copy of the name";
TimeStamp baseRegistrationTime;
#ifdef MOZ_GECKO_PROFILER
baseRegistrationTime = baseprofiler::detail::GetThreadRegistrationTime();
#endif
if (baseRegistrationTime) {
EXPECT_EQ(trInfoHere.RegisterTime(), baseRegistrationTime);
} else {
EXPECT_GT(trInfoHere.RegisterTime(), ts);
}
EXPECT_EQ(trInfoHere.ThreadId(), profiler_current_thread_id());
EXPECT_EQ(trInfoHere.ThreadId(), profiler_main_thread_id())
<< "Gtests are assumed to run on the main thread";
EXPECT_EQ(trInfoHere.IsMainThread(), true)
<< "Gtests are assumed to run on the main thread";
}
{
// Sub-thread test.
// These will receive sub-thread data (to test move at thread end).
TimeStamp tsThread;
ProfilerThreadId threadThreadId;
UniquePtr<profiler::ThreadRegistrationInfo> trInfoThreadPtr;
std::thread testThread([&]() {
profiler::ThreadRegistrationInfo trInfoThread{"Thread"};
EXPECT_STREQ(trInfoThread.Name(), "Thread");
EXPECT_NE(trInfoThread.Name(), "Thread")
<< "ThreadRegistrationInfo should keep its own copy of the name";
EXPECT_GT(trInfoThread.RegisterTime(), ts);
EXPECT_EQ(trInfoThread.ThreadId(), profiler_current_thread_id());
EXPECT_NE(trInfoThread.ThreadId(), profiler_main_thread_id());
EXPECT_EQ(trInfoThread.IsMainThread(), false);
tsThread = trInfoThread.RegisterTime();
threadThreadId = trInfoThread.ThreadId();
trInfoThreadPtr =
MakeUnique<profiler::ThreadRegistrationInfo>(std::move(trInfoThread));
});
testThread.join();
ASSERT_NE(trInfoThreadPtr, nullptr);
EXPECT_STREQ(trInfoThreadPtr->Name(), "Thread");
EXPECT_EQ(trInfoThreadPtr->RegisterTime(), tsThread);
EXPECT_EQ(trInfoThreadPtr->ThreadId(), threadThreadId);
EXPECT_EQ(trInfoThreadPtr->IsMainThread(), false)
<< "Gtests are assumed to run on the main thread";
}
}
static constexpr ThreadProfilingFeatures scEachAndAnyThreadProfilingFeatures[] =
{ThreadProfilingFeatures::CPUUtilization, ThreadProfilingFeatures::Sampling,
ThreadProfilingFeatures::Markers, ThreadProfilingFeatures::Any};
TEST(GeckoProfiler, ThreadProfilingFeaturesType)
{
ASSERT_EQ(static_cast<uint32_t>(ThreadProfilingFeatures::Any), 1u + 2u + 4u)
<< "This test assumes that there are 3 binary choices 1+2+4; "
"Is this test up to date?";
EXPECT_EQ(Combine(ThreadProfilingFeatures::CPUUtilization,
ThreadProfilingFeatures::Sampling,
ThreadProfilingFeatures::Markers),
ThreadProfilingFeatures::Any);
constexpr ThreadProfilingFeatures allThreadProfilingFeatures[] = {
ThreadProfilingFeatures::NotProfiled,
ThreadProfilingFeatures::CPUUtilization,
ThreadProfilingFeatures::Sampling, ThreadProfilingFeatures::Markers,
ThreadProfilingFeatures::Any};
for (ThreadProfilingFeatures f1 : allThreadProfilingFeatures) {
// Combine and Intersect are commutative.
for (ThreadProfilingFeatures f2 : allThreadProfilingFeatures) {
EXPECT_EQ(Combine(f1, f2), Combine(f2, f1));
EXPECT_EQ(Intersect(f1, f2), Intersect(f2, f1));
}
// Combine works like OR.
EXPECT_EQ(Combine(f1, f1), f1);
EXPECT_EQ(Combine(f1, f1, f1), f1);
// 'OR NotProfiled' doesn't change anything.
EXPECT_EQ(Combine(f1, ThreadProfilingFeatures::NotProfiled), f1);
// 'OR Any' makes Any.
EXPECT_EQ(Combine(f1, ThreadProfilingFeatures::Any),
ThreadProfilingFeatures::Any);
// Intersect works like AND.
EXPECT_EQ(Intersect(f1, f1), f1);
EXPECT_EQ(Intersect(f1, f1, f1), f1);
// 'AND NotProfiled' erases anything.
EXPECT_EQ(Intersect(f1, ThreadProfilingFeatures::NotProfiled),
ThreadProfilingFeatures::NotProfiled);
// 'AND Any' doesn't change anything.
EXPECT_EQ(Intersect(f1, ThreadProfilingFeatures::Any), f1);
}
for (ThreadProfilingFeatures f1 : scEachAndAnyThreadProfilingFeatures) {
EXPECT_TRUE(DoFeaturesIntersect(f1, f1));
// NotProfiled doesn't intersect with any feature.
EXPECT_FALSE(DoFeaturesIntersect(f1, ThreadProfilingFeatures::NotProfiled));
// Any intersects with any feature.
EXPECT_TRUE(DoFeaturesIntersect(f1, ThreadProfilingFeatures::Any));
}
}
static void TestConstUnlockedConstReader(
const profiler::ThreadRegistration::UnlockedConstReader& aData,
const TimeStamp& aBeforeRegistration, const TimeStamp& aAfterRegistration,
const void* aOnStackObject,
ProfilerThreadId aThreadId = profiler_current_thread_id()) {
EXPECT_STREQ(aData.Info().Name(), "Test thread");
EXPECT_GE(aData.Info().RegisterTime(), aBeforeRegistration);
EXPECT_LE(aData.Info().RegisterTime(), aAfterRegistration);
EXPECT_EQ(aData.Info().ThreadId(), aThreadId);
EXPECT_FALSE(aData.Info().IsMainThread());
#if (defined(_MSC_VER) || defined(__MINGW32__)) && defined(MOZ_GECKO_PROFILER)
HANDLE threadHandle = aData.PlatformDataCRef().ProfiledThread();
EXPECT_NE(threadHandle, nullptr);
EXPECT_EQ(ProfilerThreadId::FromNumber(::GetThreadId(threadHandle)),
aThreadId);
// Test calling QueryThreadCycleTime, we cannot assume that it will always
// work, but at least it shouldn't crash.
ULONG64 cycles;
(void)QueryThreadCycleTime(threadHandle, &cycles);
#elif defined(__APPLE__) && defined(MOZ_GECKO_PROFILER)
// Test calling thread_info, we cannot assume that it will always work, but at
// least it shouldn't crash.
thread_basic_info_data_t threadBasicInfo;
mach_msg_type_number_t basicCount = THREAD_BASIC_INFO_COUNT;
(void)thread_info(
aData.PlatformDataCRef().ProfiledThread(), THREAD_BASIC_INFO,
reinterpret_cast<thread_info_t>(&threadBasicInfo), &basicCount);
#elif (defined(__linux__) || defined(__ANDROID__) || defined(__FreeBSD__)) && \
defined(MOZ_GECKO_PROFILER)
// Test calling GetClockId, we cannot assume that it will always work, but at
// least it shouldn't crash.
Maybe<clockid_t> maybeClockId = aData.PlatformDataCRef().GetClockId();
if (maybeClockId) {
// Test calling clock_gettime, we cannot assume that it will always work,
// but at least it shouldn't crash.
timespec ts;
(void)clock_gettime(*maybeClockId, &ts);
}
#else
(void)aData.PlatformDataCRef();
#endif
EXPECT_GE(aData.StackTop(), aOnStackObject)
<< "StackTop should be at &onStackChar, or higher on some "
"platforms";
};
static void TestConstUnlockedConstReaderAndAtomicRW(
const profiler::ThreadRegistration::UnlockedConstReaderAndAtomicRW& aData,
const TimeStamp& aBeforeRegistration, const TimeStamp& aAfterRegistration,
const void* aOnStackObject,
ProfilerThreadId aThreadId = profiler_current_thread_id()) {
TestConstUnlockedConstReader(aData, aBeforeRegistration, aAfterRegistration,
aOnStackObject, aThreadId);
(void)aData.ProfilingStackCRef();
EXPECT_EQ(aData.ProfilingFeatures(), ThreadProfilingFeatures::NotProfiled);
EXPECT_FALSE(aData.IsSleeping());
};
static void TestUnlockedConstReaderAndAtomicRW(
profiler::ThreadRegistration::UnlockedConstReaderAndAtomicRW& aData,
const TimeStamp& aBeforeRegistration, const TimeStamp& aAfterRegistration,
const void* aOnStackObject,
ProfilerThreadId aThreadId = profiler_current_thread_id()) {
TestConstUnlockedConstReaderAndAtomicRW(aData, aBeforeRegistration,
aAfterRegistration, aOnStackObject,
aThreadId);
(void)aData.ProfilingStackRef();
EXPECT_FALSE(aData.IsSleeping());
aData.SetSleeping();
EXPECT_TRUE(aData.IsSleeping());
aData.SetAwake();
EXPECT_FALSE(aData.IsSleeping());
aData.ReinitializeOnResume();
EXPECT_FALSE(aData.CanDuplicateLastSampleDueToSleep());
EXPECT_FALSE(aData.CanDuplicateLastSampleDueToSleep());
aData.SetSleeping();
// After sleeping, the 2nd+ calls can duplicate.
EXPECT_FALSE(aData.CanDuplicateLastSampleDueToSleep());
EXPECT_TRUE(aData.CanDuplicateLastSampleDueToSleep());
EXPECT_TRUE(aData.CanDuplicateLastSampleDueToSleep());
aData.ReinitializeOnResume();
// After reinit (and sleeping), the 2nd+ calls can duplicate.
EXPECT_FALSE(aData.CanDuplicateLastSampleDueToSleep());
EXPECT_TRUE(aData.CanDuplicateLastSampleDueToSleep());
EXPECT_TRUE(aData.CanDuplicateLastSampleDueToSleep());
aData.SetAwake();
EXPECT_FALSE(aData.CanDuplicateLastSampleDueToSleep());
EXPECT_FALSE(aData.CanDuplicateLastSampleDueToSleep());
};
static void TestConstUnlockedRWForLockedProfiler(
const profiler::ThreadRegistration::UnlockedRWForLockedProfiler& aData,
const TimeStamp& aBeforeRegistration, const TimeStamp& aAfterRegistration,
const void* aOnStackObject,
ProfilerThreadId aThreadId = profiler_current_thread_id()) {
TestConstUnlockedConstReaderAndAtomicRW(aData, aBeforeRegistration,
aAfterRegistration, aOnStackObject,
aThreadId);
// We can't create a PSAutoLock here, so just verify that the call would
// compile and return the expected type.
static_assert(std::is_same_v<decltype(aData.GetProfiledThreadData(
std::declval<PSAutoLock>())),
const ProfiledThreadData*>);
};
static void TestConstUnlockedReaderAndAtomicRWOnThread(
const profiler::ThreadRegistration::UnlockedReaderAndAtomicRWOnThread&
aData,
const TimeStamp& aBeforeRegistration, const TimeStamp& aAfterRegistration,
const void* aOnStackObject,
ProfilerThreadId aThreadId = profiler_current_thread_id()) {
TestConstUnlockedRWForLockedProfiler(aData, aBeforeRegistration,
aAfterRegistration, aOnStackObject,
aThreadId);
EXPECT_EQ(aData.GetJSContext(), nullptr);
};
static void TestUnlockedRWForLockedProfiler(
profiler::ThreadRegistration::UnlockedRWForLockedProfiler& aData,
const TimeStamp& aBeforeRegistration, const TimeStamp& aAfterRegistration,
const void* aOnStackObject,
ProfilerThreadId aThreadId = profiler_current_thread_id()) {
TestConstUnlockedRWForLockedProfiler(aData, aBeforeRegistration,
aAfterRegistration, aOnStackObject,
aThreadId);
TestUnlockedConstReaderAndAtomicRW(aData, aBeforeRegistration,
aAfterRegistration, aOnStackObject,
aThreadId);
// No functions to test here.
};
static void TestUnlockedReaderAndAtomicRWOnThread(
profiler::ThreadRegistration::UnlockedReaderAndAtomicRWOnThread& aData,
const TimeStamp& aBeforeRegistration, const TimeStamp& aAfterRegistration,
const void* aOnStackObject,
ProfilerThreadId aThreadId = profiler_current_thread_id()) {
TestConstUnlockedReaderAndAtomicRWOnThread(aData, aBeforeRegistration,
aAfterRegistration, aOnStackObject,
aThreadId);
TestUnlockedRWForLockedProfiler(aData, aBeforeRegistration,
aAfterRegistration, aOnStackObject,
aThreadId);
// No functions to test here.
};
static void TestConstLockedRWFromAnyThread(
const profiler::ThreadRegistration::LockedRWFromAnyThread& aData,
const TimeStamp& aBeforeRegistration, const TimeStamp& aAfterRegistration,
const void* aOnStackObject,
ProfilerThreadId aThreadId = profiler_current_thread_id()) {
TestConstUnlockedReaderAndAtomicRWOnThread(aData, aBeforeRegistration,
aAfterRegistration, aOnStackObject,
aThreadId);
EXPECT_EQ(aData.GetJsFrameBuffer(), nullptr);
EXPECT_EQ(aData.GetEventTarget(), nullptr);
};
static void TestLockedRWFromAnyThread(
profiler::ThreadRegistration::LockedRWFromAnyThread& aData,
const TimeStamp& aBeforeRegistration, const TimeStamp& aAfterRegistration,
const void* aOnStackObject,
ProfilerThreadId aThreadId = profiler_current_thread_id()) {
TestConstLockedRWFromAnyThread(aData, aBeforeRegistration, aAfterRegistration,
aOnStackObject, aThreadId);
TestUnlockedReaderAndAtomicRWOnThread(aData, aBeforeRegistration,
aAfterRegistration, aOnStackObject,
aThreadId);
// We can't create a ProfiledThreadData nor PSAutoLock here, so just verify
// that the call would compile and return the expected type.
static_assert(std::is_same_v<decltype(aData.SetProfilingFeaturesAndData(
std::declval<ThreadProfilingFeatures>(),
std::declval<ProfiledThreadData*>(),
std::declval<PSAutoLock>())),
void>);
aData.ResetMainThread(nullptr);
TimeDuration delay = TimeDuration::FromSeconds(1);
TimeDuration running = TimeDuration::FromSeconds(1);
aData.GetRunningEventDelay(TimeStamp::Now(), delay, running);
EXPECT_TRUE(delay.IsZero());
EXPECT_TRUE(running.IsZero());
aData.StartJSSampling(123u);
aData.StopJSSampling();
};
static void TestConstLockedRWOnThread(
const profiler::ThreadRegistration::LockedRWOnThread& aData,
const TimeStamp& aBeforeRegistration, const TimeStamp& aAfterRegistration,
const void* aOnStackObject,
ProfilerThreadId aThreadId = profiler_current_thread_id()) {
TestConstLockedRWFromAnyThread(aData, aBeforeRegistration, aAfterRegistration,
aOnStackObject, aThreadId);
// No functions to test here.
};
static void TestLockedRWOnThread(
profiler::ThreadRegistration::LockedRWOnThread& aData,
const TimeStamp& aBeforeRegistration, const TimeStamp& aAfterRegistration,
const void* aOnStackObject,
ProfilerThreadId aThreadId = profiler_current_thread_id()) {
TestConstLockedRWOnThread(aData, aBeforeRegistration, aAfterRegistration,
aOnStackObject, aThreadId);
TestLockedRWFromAnyThread(aData, aBeforeRegistration, aAfterRegistration,
aOnStackObject, aThreadId);
// We don't want to really call SetJSContext here, so just verify that
// the call would compile and return the expected type.
static_assert(
std::is_same_v<decltype(aData.SetJSContext(std::declval<JSContext*>())),
void>);
aData.ClearJSContext();
aData.PollJSSampling();
};
TEST(GeckoProfiler, ThreadRegistration_DataAccess)
{
using TR = profiler::ThreadRegistration;
profiler_init_main_thread_id();
ASSERT_TRUE(profiler_is_main_thread())
<< "This test assumes it runs on the main thread";
// Note that the main thread could already be registered, so we work in a new
// thread to test an actual registration that we control.
std::thread testThread([&]() {
ASSERT_FALSE(TR::IsRegistered())
<< "A new std::thread should not start registered";
EXPECT_FALSE(TR::GetOnThreadPtr());
EXPECT_FALSE(TR::WithOnThreadRefOr([&](auto) { return true; }, false));
char onStackChar;
TimeStamp beforeRegistration = TimeStamp::Now();
TR tr{"Test thread", &onStackChar};
TimeStamp afterRegistration = TimeStamp::Now();
ASSERT_TRUE(TR::IsRegistered());
// Note: This test will mostly be about checking the correct access to
// thread data, depending on how it's obtained. Not all the functionality
// related to that data is tested (e.g., because it involves JS or other
// external dependencies that would be difficult to control here.)
auto TestOnThreadRef = [&](TR::OnThreadRef aOnThreadRef) {
// To test const-qualified member functions.
const TR::OnThreadRef& onThreadCRef = aOnThreadRef;
// const UnlockedConstReader (always const)
TestConstUnlockedConstReader(onThreadCRef.UnlockedConstReaderCRef(),
beforeRegistration, afterRegistration,
&onStackChar);
onThreadCRef.WithUnlockedConstReader(
[&](const TR::UnlockedConstReader& aData) {
TestConstUnlockedConstReader(aData, beforeRegistration,
afterRegistration, &onStackChar);
});
// const UnlockedConstReaderAndAtomicRW
TestConstUnlockedConstReaderAndAtomicRW(
onThreadCRef.UnlockedConstReaderAndAtomicRWCRef(), beforeRegistration,
afterRegistration, &onStackChar);
onThreadCRef.WithUnlockedConstReaderAndAtomicRW(
[&](const TR::UnlockedConstReaderAndAtomicRW& aData) {
TestConstUnlockedConstReaderAndAtomicRW(
aData, beforeRegistration, afterRegistration, &onStackChar);
});
// non-const UnlockedConstReaderAndAtomicRW
TestUnlockedConstReaderAndAtomicRW(
aOnThreadRef.UnlockedConstReaderAndAtomicRWRef(), beforeRegistration,
afterRegistration, &onStackChar);
aOnThreadRef.WithUnlockedConstReaderAndAtomicRW(
[&](TR::UnlockedConstReaderAndAtomicRW& aData) {
TestUnlockedConstReaderAndAtomicRW(aData, beforeRegistration,
afterRegistration, &onStackChar);
});
// const UnlockedRWForLockedProfiler
TestConstUnlockedRWForLockedProfiler(
onThreadCRef.UnlockedRWForLockedProfilerCRef(), beforeRegistration,
afterRegistration, &onStackChar);
onThreadCRef.WithUnlockedRWForLockedProfiler(
[&](const TR::UnlockedRWForLockedProfiler& aData) {
TestConstUnlockedRWForLockedProfiler(
aData, beforeRegistration, afterRegistration, &onStackChar);
});
// non-const UnlockedRWForLockedProfiler
TestUnlockedRWForLockedProfiler(
aOnThreadRef.UnlockedRWForLockedProfilerRef(), beforeRegistration,
afterRegistration, &onStackChar);
aOnThreadRef.WithUnlockedRWForLockedProfiler(
[&](TR::UnlockedRWForLockedProfiler& aData) {
TestUnlockedRWForLockedProfiler(aData, beforeRegistration,
afterRegistration, &onStackChar);
});
// const UnlockedReaderAndAtomicRWOnThread
TestConstUnlockedReaderAndAtomicRWOnThread(
onThreadCRef.UnlockedReaderAndAtomicRWOnThreadCRef(),
beforeRegistration, afterRegistration, &onStackChar);
onThreadCRef.WithUnlockedReaderAndAtomicRWOnThread(
[&](const TR::UnlockedReaderAndAtomicRWOnThread& aData) {
TestConstUnlockedReaderAndAtomicRWOnThread(
aData, beforeRegistration, afterRegistration, &onStackChar);
});
// non-const UnlockedReaderAndAtomicRWOnThread
TestUnlockedReaderAndAtomicRWOnThread(
aOnThreadRef.UnlockedReaderAndAtomicRWOnThreadRef(),
beforeRegistration, afterRegistration, &onStackChar);
aOnThreadRef.WithUnlockedReaderAndAtomicRWOnThread(
[&](TR::UnlockedReaderAndAtomicRWOnThread& aData) {
TestUnlockedReaderAndAtomicRWOnThread(
aData, beforeRegistration, afterRegistration, &onStackChar);
});
// LockedRWFromAnyThread
// Note: It cannot directly be accessed on the thread, this will be
// tested through LockedRWOnThread.
// const LockedRWOnThread
EXPECT_FALSE(TR::IsDataMutexLockedOnCurrentThread());
{
TR::OnThreadRef::ConstRWOnThreadWithLock constRWOnThreadWithLock =
onThreadCRef.ConstLockedRWOnThread();
EXPECT_TRUE(TR::IsDataMutexLockedOnCurrentThread());
TestConstLockedRWOnThread(constRWOnThreadWithLock.DataCRef(),
beforeRegistration, afterRegistration,
&onStackChar);
}
EXPECT_FALSE(TR::IsDataMutexLockedOnCurrentThread());
onThreadCRef.WithConstLockedRWOnThread(
[&](const TR::LockedRWOnThread& aData) {
EXPECT_TRUE(TR::IsDataMutexLockedOnCurrentThread());
TestConstLockedRWOnThread(aData, beforeRegistration,
afterRegistration, &onStackChar);
});
EXPECT_FALSE(TR::IsDataMutexLockedOnCurrentThread());
// non-const LockedRWOnThread
EXPECT_FALSE(TR::IsDataMutexLockedOnCurrentThread());
{
TR::OnThreadRef::RWOnThreadWithLock rwOnThreadWithLock =
aOnThreadRef.GetLockedRWOnThread();
EXPECT_TRUE(TR::IsDataMutexLockedOnCurrentThread());
TestConstLockedRWOnThread(rwOnThreadWithLock.DataCRef(),
beforeRegistration, afterRegistration,
&onStackChar);
TestLockedRWOnThread(rwOnThreadWithLock.DataRef(), beforeRegistration,
afterRegistration, &onStackChar);
}
EXPECT_FALSE(TR::IsDataMutexLockedOnCurrentThread());
aOnThreadRef.WithLockedRWOnThread([&](TR::LockedRWOnThread& aData) {
EXPECT_TRUE(TR::IsDataMutexLockedOnCurrentThread());
TestLockedRWOnThread(aData, beforeRegistration, afterRegistration,
&onStackChar);
});
EXPECT_FALSE(TR::IsDataMutexLockedOnCurrentThread());
};
TR::OnThreadPtr onThreadPtr = TR::GetOnThreadPtr();
ASSERT_TRUE(onThreadPtr);
TestOnThreadRef(*onThreadPtr);
TR::WithOnThreadRef(
[&](TR::OnThreadRef aOnThreadRef) { TestOnThreadRef(aOnThreadRef); });
EXPECT_TRUE(TR::WithOnThreadRefOr(
[&](TR::OnThreadRef aOnThreadRef) {
TestOnThreadRef(aOnThreadRef);
return true;
},
false));
});
testThread.join();
}
// Thread name if registered, nullptr otherwise.
static const char* GetThreadName() {
return profiler::ThreadRegistration::WithOnThreadRefOr(
[](profiler::ThreadRegistration::OnThreadRef onThreadRef) {
return onThreadRef.WithUnlockedConstReader(
[](const profiler::ThreadRegistration::UnlockedConstReader& aData) {
return aData.Info().Name();
});
},
nullptr);
}
// Get the thread name, as registered in the PRThread, nullptr on failure.
static const char* GetPRThreadName() {
nsIThread* nsThread = NS_GetCurrentThread();
if (!nsThread) {
return nullptr;
}
PRThread* prThread = nullptr;
if (NS_FAILED(nsThread->GetPRThread(&prThread))) {
return nullptr;
}
if (!prThread) {
return nullptr;
}
return PR_GetThreadName(prThread);
}
TEST(GeckoProfiler, ThreadRegistration_MainThreadName)
{
EXPECT_TRUE(profiler::ThreadRegistration::IsRegistered());
EXPECT_STREQ(GetThreadName(), "GeckoMain");
// Check that the real thread name (outside the profiler) is *not* GeckoMain.
EXPECT_STRNE(GetPRThreadName(), "GeckoMain");
}
TEST(GeckoProfiler, ThreadRegistration_NestedRegistrations)
{
using TR = profiler::ThreadRegistration;
profiler_init_main_thread_id();
ASSERT_TRUE(profiler_is_main_thread())
<< "This test assumes it runs on the main thread";
// Note that the main thread could already be registered, so we work in a new
// thread to test actual registrations that we control.
std::thread testThread([&]() {
ASSERT_FALSE(TR::IsRegistered())
<< "A new std::thread should not start registered";
char onStackChar;
// Blocks {} are mostly for clarity, but some control on-stack registration
// lifetimes.
// On-stack registration.
{
TR rt{"Test thread #1", &onStackChar};
ASSERT_TRUE(TR::IsRegistered());
EXPECT_STREQ(GetThreadName(), "Test thread #1");
EXPECT_STREQ(GetPRThreadName(), "Test thread #1");
}
ASSERT_FALSE(TR::IsRegistered());
// Off-stack registration.
{
TR::RegisterThread("Test thread #2", &onStackChar);
ASSERT_TRUE(TR::IsRegistered());
EXPECT_STREQ(GetThreadName(), "Test thread #2");
EXPECT_STREQ(GetPRThreadName(), "Test thread #2");
TR::UnregisterThread();
ASSERT_FALSE(TR::IsRegistered());
}
// Extra un-registration should be ignored.
TR::UnregisterThread();
ASSERT_FALSE(TR::IsRegistered());
// Nested on-stack.
{
TR rt2{"Test thread #3", &onStackChar};
ASSERT_TRUE(TR::IsRegistered());
EXPECT_STREQ(GetThreadName(), "Test thread #3");
EXPECT_STREQ(GetPRThreadName(), "Test thread #3");
{
TR rt3{"Test thread #4", &onStackChar};
ASSERT_TRUE(TR::IsRegistered());
EXPECT_STREQ(GetThreadName(), "Test thread #3")
<< "Nested registration shouldn't change the name";
EXPECT_STREQ(GetPRThreadName(), "Test thread #3")
<< "Nested registration shouldn't change the PRThread name";
}
ASSERT_TRUE(TR::IsRegistered())
<< "Thread should still be registered after nested un-registration";
EXPECT_STREQ(GetThreadName(), "Test thread #3")
<< "Thread should still be registered after nested un-registration";
EXPECT_STREQ(GetPRThreadName(), "Test thread #3");
}
ASSERT_FALSE(TR::IsRegistered());
// Nested off-stack.
{
TR::RegisterThread("Test thread #5", &onStackChar);
ASSERT_TRUE(TR::IsRegistered());
EXPECT_STREQ(GetThreadName(), "Test thread #5");
EXPECT_STREQ(GetPRThreadName(), "Test thread #5");
{
TR::RegisterThread("Test thread #6", &onStackChar);
ASSERT_TRUE(TR::IsRegistered());
EXPECT_STREQ(GetThreadName(), "Test thread #5")
<< "Nested registration shouldn't change the name";
EXPECT_STREQ(GetPRThreadName(), "Test thread #5")
<< "Nested registration shouldn't change the PRThread name";
TR::UnregisterThread();
ASSERT_TRUE(TR::IsRegistered())
<< "Thread should still be registered after nested un-registration";
EXPECT_STREQ(GetThreadName(), "Test thread #5")
<< "Thread should still be registered after nested un-registration";
EXPECT_STREQ(GetPRThreadName(), "Test thread #5");
}
TR::UnregisterThread();
ASSERT_FALSE(TR::IsRegistered());
}
// Nested on- and off-stack.
{
TR rt2{"Test thread #7", &onStackChar};
ASSERT_TRUE(TR::IsRegistered());
EXPECT_STREQ(GetThreadName(), "Test thread #7");
EXPECT_STREQ(GetPRThreadName(), "Test thread #7");
{
TR::RegisterThread("Test thread #8", &onStackChar);
ASSERT_TRUE(TR::IsRegistered());
EXPECT_STREQ(GetThreadName(), "Test thread #7")
<< "Nested registration shouldn't change the name";
EXPECT_STREQ(GetPRThreadName(), "Test thread #7")
<< "Nested registration shouldn't change the PRThread name";
TR::UnregisterThread();
ASSERT_TRUE(TR::IsRegistered())
<< "Thread should still be registered after nested un-registration";
EXPECT_STREQ(GetThreadName(), "Test thread #7")
<< "Thread should still be registered after nested un-registration";
EXPECT_STREQ(GetPRThreadName(), "Test thread #7");
}
}
ASSERT_FALSE(TR::IsRegistered());
// Nested off- and on-stack.
{
TR::RegisterThread("Test thread #9", &onStackChar);
ASSERT_TRUE(TR::IsRegistered());
EXPECT_STREQ(GetThreadName(), "Test thread #9");
EXPECT_STREQ(GetPRThreadName(), "Test thread #9");
{
TR rt3{"Test thread #10", &onStackChar};
ASSERT_TRUE(TR::IsRegistered());
EXPECT_STREQ(GetThreadName(), "Test thread #9")
<< "Nested registration shouldn't change the name";
EXPECT_STREQ(GetPRThreadName(), "Test thread #9")
<< "Nested registration shouldn't change the PRThread name";
}
ASSERT_TRUE(TR::IsRegistered())
<< "Thread should still be registered after nested un-registration";
EXPECT_STREQ(GetThreadName(), "Test thread #9")
<< "Thread should still be registered after nested un-registration";
EXPECT_STREQ(GetPRThreadName(), "Test thread #9");
TR::UnregisterThread();
ASSERT_FALSE(TR::IsRegistered());
}
// Excess UnregisterThread with on-stack TR.
{
TR rt2{"Test thread #11", &onStackChar};
ASSERT_TRUE(TR::IsRegistered());
EXPECT_STREQ(GetThreadName(), "Test thread #11");
EXPECT_STREQ(GetPRThreadName(), "Test thread #11");
TR::UnregisterThread();
ASSERT_TRUE(TR::IsRegistered())
<< "On-stack thread should still be registered after off-stack "
"un-registration";
EXPECT_STREQ(GetThreadName(), "Test thread #11")
<< "On-stack thread should still be registered after off-stack "
"un-registration";
EXPECT_STREQ(GetPRThreadName(), "Test thread #11");
}
ASSERT_FALSE(TR::IsRegistered());
// Excess on-thread TR destruction with already-unregistered root off-thread
// registration.
{
TR::RegisterThread("Test thread #12", &onStackChar);
ASSERT_TRUE(TR::IsRegistered());
EXPECT_STREQ(GetThreadName(), "Test thread #12");
EXPECT_STREQ(GetPRThreadName(), "Test thread #12");
{
TR rt3{"Test thread #13", &onStackChar};
ASSERT_TRUE(TR::IsRegistered());
EXPECT_STREQ(GetThreadName(), "Test thread #12")
<< "Nested registration shouldn't change the name";
EXPECT_STREQ(GetPRThreadName(), "Test thread #12")
<< "Nested registration shouldn't change the PRThread name";
// Note that we unregister the root registration, while nested `rt3` is
// still alive.
TR::UnregisterThread();
ASSERT_FALSE(TR::IsRegistered())
<< "UnregisterThread() of the root RegisterThread() should always work";
// At this end of this block, `rt3` will be destroyed, but nothing
// should happen.
}
ASSERT_FALSE(TR::IsRegistered());
}
ASSERT_FALSE(TR::IsRegistered());
});
testThread.join();
}
TEST(GeckoProfiler, ThreadRegistry_DataAccess)
{
using TR = profiler::ThreadRegistration;
using TRy = profiler::ThreadRegistry;
profiler_init_main_thread_id();
ASSERT_TRUE(profiler_is_main_thread())
<< "This test assumes it runs on the main thread";
// Note that the main thread could already be registered, so we work in a new
// thread to test an actual registration that we control.
std::thread testThread([&]() {
ASSERT_FALSE(TR::IsRegistered())
<< "A new std::thread should not start registered";
EXPECT_FALSE(TR::GetOnThreadPtr());
EXPECT_FALSE(TR::WithOnThreadRefOr([&](auto) { return true; }, false));
char onStackChar;
TimeStamp beforeRegistration = TimeStamp::Now();
TR tr{"Test thread", &onStackChar};
TimeStamp afterRegistration = TimeStamp::Now();
ASSERT_TRUE(TR::IsRegistered());
// Note: This test will mostly be about checking the correct access to
// thread data, depending on how it's obtained. Not all the functionality
// related to that data is tested (e.g., because it involves JS or other
// external dependencies that would be difficult to control here.)
const ProfilerThreadId testThreadId = profiler_current_thread_id();
auto testThroughRegistry = [&]() {
auto TestOffThreadRef = [&](TRy::OffThreadRef aOffThreadRef) {
// To test const-qualified member functions.
const TRy::OffThreadRef& offThreadCRef = aOffThreadRef;
// const UnlockedConstReader (always const)
TestConstUnlockedConstReader(offThreadCRef.UnlockedConstReaderCRef(),
beforeRegistration, afterRegistration,
&onStackChar, testThreadId);
offThreadCRef.WithUnlockedConstReader(
[&](const TR::UnlockedConstReader& aData) {
TestConstUnlockedConstReader(aData, beforeRegistration,
afterRegistration, &onStackChar,
testThreadId);
});
// const UnlockedConstReaderAndAtomicRW
TestConstUnlockedConstReaderAndAtomicRW(
offThreadCRef.UnlockedConstReaderAndAtomicRWCRef(),
beforeRegistration, afterRegistration, &onStackChar, testThreadId);
offThreadCRef.WithUnlockedConstReaderAndAtomicRW(
[&](const TR::UnlockedConstReaderAndAtomicRW& aData) {
TestConstUnlockedConstReaderAndAtomicRW(
aData, beforeRegistration, afterRegistration, &onStackChar,
testThreadId);
});
// non-const UnlockedConstReaderAndAtomicRW
TestUnlockedConstReaderAndAtomicRW(
aOffThreadRef.UnlockedConstReaderAndAtomicRWRef(),
beforeRegistration, afterRegistration, &onStackChar, testThreadId);
aOffThreadRef.WithUnlockedConstReaderAndAtomicRW(
[&](TR::UnlockedConstReaderAndAtomicRW& aData) {
TestUnlockedConstReaderAndAtomicRW(aData, beforeRegistration,
afterRegistration,
&onStackChar, testThreadId);
});
// const UnlockedRWForLockedProfiler
TestConstUnlockedRWForLockedProfiler(
offThreadCRef.UnlockedRWForLockedProfilerCRef(), beforeRegistration,
afterRegistration, &onStackChar, testThreadId);
offThreadCRef.WithUnlockedRWForLockedProfiler(
[&](const TR::UnlockedRWForLockedProfiler& aData) {
TestConstUnlockedRWForLockedProfiler(aData, beforeRegistration,
afterRegistration,
&onStackChar, testThreadId);
});
// non-const UnlockedRWForLockedProfiler
TestUnlockedRWForLockedProfiler(
aOffThreadRef.UnlockedRWForLockedProfilerRef(), beforeRegistration,
afterRegistration, &onStackChar, testThreadId);
aOffThreadRef.WithUnlockedRWForLockedProfiler(
[&](TR::UnlockedRWForLockedProfiler& aData) {
TestUnlockedRWForLockedProfiler(aData, beforeRegistration,
afterRegistration, &onStackChar,
testThreadId);
});
// UnlockedReaderAndAtomicRWOnThread
// Note: It cannot directly be accessed off the thread, this will be
// tested through LockedRWFromAnyThread.
// const LockedRWFromAnyThread
EXPECT_FALSE(TR::IsDataMutexLockedOnCurrentThread());
{
TRy::OffThreadRef::ConstRWFromAnyThreadWithLock
constRWFromAnyThreadWithLock =
offThreadCRef.ConstLockedRWFromAnyThread();
if (profiler_current_thread_id() == testThreadId) {
EXPECT_TRUE(TR::IsDataMutexLockedOnCurrentThread());
}
TestConstLockedRWFromAnyThread(
constRWFromAnyThreadWithLock.DataCRef(), beforeRegistration,
afterRegistration, &onStackChar, testThreadId);
}
EXPECT_FALSE(TR::IsDataMutexLockedOnCurrentThread());
offThreadCRef.WithConstLockedRWFromAnyThread(
[&](const TR::LockedRWFromAnyThread& aData) {
if (profiler_current_thread_id() == testThreadId) {
EXPECT_TRUE(TR::IsDataMutexLockedOnCurrentThread());
}
TestConstLockedRWFromAnyThread(aData, beforeRegistration,
afterRegistration, &onStackChar,
testThreadId);
});
EXPECT_FALSE(TR::IsDataMutexLockedOnCurrentThread());
// non-const LockedRWFromAnyThread
EXPECT_FALSE(TR::IsDataMutexLockedOnCurrentThread());
{
TRy::OffThreadRef::RWFromAnyThreadWithLock rwFromAnyThreadWithLock =
aOffThreadRef.GetLockedRWFromAnyThread();
if (profiler_current_thread_id() == testThreadId) {
EXPECT_TRUE(TR::IsDataMutexLockedOnCurrentThread());
}
TestLockedRWFromAnyThread(rwFromAnyThreadWithLock.DataRef(),
beforeRegistration, afterRegistration,
&onStackChar, testThreadId);
}
EXPECT_FALSE(TR::IsDataMutexLockedOnCurrentThread());
aOffThreadRef.WithLockedRWFromAnyThread(
[&](TR::LockedRWFromAnyThread& aData) {
if (profiler_current_thread_id() == testThreadId) {
EXPECT_TRUE(TR::IsDataMutexLockedOnCurrentThread());
}
TestLockedRWFromAnyThread(aData, beforeRegistration,
afterRegistration, &onStackChar,
testThreadId);
});
EXPECT_FALSE(TR::IsDataMutexLockedOnCurrentThread());
// LockedRWOnThread
// Note: It can never be accessed off the thread.
};
int ranTest = 0;
TRy::WithOffThreadRef(testThreadId, [&](TRy::OffThreadRef aOffThreadRef) {
TestOffThreadRef(aOffThreadRef);
++ranTest;
});
EXPECT_EQ(ranTest, 1);
EXPECT_TRUE(TRy::WithOffThreadRefOr(
testThreadId,
[&](TRy::OffThreadRef aOffThreadRef) {
TestOffThreadRef(aOffThreadRef);
return true;
},
false));
ranTest = 0;
EXPECT_FALSE(TRy::IsRegistryMutexLockedOnCurrentThread());
for (TRy::OffThreadRef offThreadRef : TRy::LockedRegistry{}) {
EXPECT_TRUE(TRy::IsRegistryMutexLockedOnCurrentThread() ||
!TR::IsRegistered());
if (offThreadRef.UnlockedConstReaderCRef().Info().ThreadId() ==
testThreadId) {
TestOffThreadRef(offThreadRef);
++ranTest;
}
}
EXPECT_EQ(ranTest, 1);
EXPECT_FALSE(TRy::IsRegistryMutexLockedOnCurrentThread());
{
ranTest = 0;
EXPECT_FALSE(TRy::IsRegistryMutexLockedOnCurrentThread());
TRy::LockedRegistry lockedRegistry{};
EXPECT_TRUE(TRy::IsRegistryMutexLockedOnCurrentThread() ||
!TR::IsRegistered());
for (TRy::OffThreadRef offThreadRef : lockedRegistry) {
if (offThreadRef.UnlockedConstReaderCRef().Info().ThreadId() ==
testThreadId) {
TestOffThreadRef(offThreadRef);
++ranTest;
}
}
EXPECT_EQ(ranTest, 1);
}
EXPECT_FALSE(TRy::IsRegistryMutexLockedOnCurrentThread());
};
// Test on the current thread.
testThroughRegistry();
// Test from another thread.
std::thread otherThread([&]() {
ASSERT_NE(profiler_current_thread_id(), testThreadId);
testThroughRegistry();
// Test that this unregistered thread is really not registered.
int ranTest = 0;
TRy::WithOffThreadRef(
profiler_current_thread_id(),
[&](TRy::OffThreadRef aOffThreadRef) { ++ranTest; });
EXPECT_EQ(ranTest, 0);
EXPECT_FALSE(TRy::WithOffThreadRefOr(
profiler_current_thread_id(),
[&](TRy::OffThreadRef aOffThreadRef) {
++ranTest;
return true;
},
false));
EXPECT_EQ(ranTest, 0);
});
otherThread.join();
});
testThread.join();
}
TEST(GeckoProfiler, ThreadRegistration_RegistrationEdgeCases)
{
using TR = profiler::ThreadRegistration;
using TRy = profiler::ThreadRegistry;
profiler_init_main_thread_id();
ASSERT_TRUE(profiler_is_main_thread())
<< "This test assumes it runs on the main thread";
// Note that the main thread could already be registered, so we work in a new
// thread to test an actual registration that we control.
int registrationCount = 0;
int otherThreadLoops = 0;
int otherThreadReads = 0;
// This thread will register and unregister in a loop, with some pauses.
// Another thread will attempty to access the test thread, and lock its data.
// The main goal is to check edges cases around (un)registrations.
std::thread testThread([&]() {
const ProfilerThreadId testThreadId = profiler_current_thread_id();
const TimeStamp endTestAt = TimeStamp::Now() + TimeDuration::FromSeconds(1);
std::thread otherThread([&]() {
// Initial sleep so that testThread can start its loop.
PR_Sleep(PR_MillisecondsToInterval(1));
while (TimeStamp::Now() < endTestAt) {
++otherThreadLoops;
TRy::WithOffThreadRef(testThreadId, [&](TRy::OffThreadRef
aOffThreadRef) {
if (otherThreadLoops % 1000 == 0) {
PR_Sleep(PR_MillisecondsToInterval(1));
}
TRy::OffThreadRef::RWFromAnyThreadWithLock rwFromAnyThreadWithLock =
aOffThreadRef.GetLockedRWFromAnyThread();
++otherThreadReads;
if (otherThreadReads % 1000 == 0) {
PR_Sleep(PR_MillisecondsToInterval(1));
}
});
}
});
while (TimeStamp::Now() < endTestAt) {
ASSERT_FALSE(TR::IsRegistered())
<< "A new std::thread should not start registered";
EXPECT_FALSE(TR::GetOnThreadPtr());
EXPECT_FALSE(TR::WithOnThreadRefOr([&](auto) { return true; }, false));
char onStackChar;
TR tr{"Test thread", &onStackChar};
++registrationCount;
ASSERT_TRUE(TR::IsRegistered());
int ranTest = 0;
TRy::WithOffThreadRef(testThreadId, [&](TRy::OffThreadRef aOffThreadRef) {
if (registrationCount % 2000 == 0) {
PR_Sleep(PR_MillisecondsToInterval(1));
}
++ranTest;
});
EXPECT_EQ(ranTest, 1);
if (registrationCount % 1000 == 0) {
PR_Sleep(PR_MillisecondsToInterval(1));
}
}
otherThread.join();
});
testThread.join();
// It's difficult to guess what these numbers should be, but they definitely
// should be non-zero. The main goal was to test that nothing goes wrong.
EXPECT_GT(registrationCount, 0);
EXPECT_GT(otherThreadLoops, 0);
EXPECT_GT(otherThreadReads, 0);
}
#ifdef MOZ_GECKO_PROFILER
// Common JSON checks.
// Check that the given JSON string include no JSON whitespace characters
// (excluding those in property names and strings).
void JSONWhitespaceCheck(const char* aOutput) {
ASSERT_NE(aOutput, nullptr);
enum class State { Data, String, StringEscaped };
State state = State::Data;
size_t length = 0;
size_t whitespaces = 0;
for (const char* p = aOutput; *p != '\0'; ++p) {
++length;
const char c = *p;
switch (state) {
case State::Data:
if (c == '\n' || c == '\r' || c == ' ' || c == '\t') {
++whitespaces;
} else if (c == '"') {
state = State::String;
}
break;
case State::String:
if (c == '"') {
state = State::Data;
} else if (c == '\\') {
state = State::StringEscaped;
}
break;
case State::StringEscaped:
state = State::String;
break;
}
}
EXPECT_EQ(whitespaces, 0u);
EXPECT_GT(length, 0u);
}
// Does the GETTER return a non-null TYPE? (Non-critical)
# define EXPECT_HAS_JSON(GETTER, TYPE) \
do { \
if ((GETTER).isNull()) { \
EXPECT_FALSE((GETTER).isNull()) \
<< #GETTER " doesn't exist or is null"; \
} else if (!(GETTER).is##TYPE()) { \
EXPECT_TRUE((GETTER).is##TYPE()) \
<< #GETTER " didn't return type " #TYPE; \
} \
} while (false)
// Does the GETTER return a non-null TYPE? (Critical)
# define ASSERT_HAS_JSON(GETTER, TYPE) \
do { \
ASSERT_FALSE((GETTER).isNull()); \
ASSERT_TRUE((GETTER).is##TYPE()); \
} while (false)
// Does the GETTER return a non-null TYPE? (Critical)
// If yes, store the reference to Json::Value into VARIABLE.
# define GET_JSON(VARIABLE, GETTER, TYPE) \
ASSERT_HAS_JSON(GETTER, TYPE); \
const Json::Value& VARIABLE = (GETTER)
// Does the GETTER return a non-null TYPE? (Critical)
// If yes, store the value as `const TYPE` into VARIABLE.
# define GET_JSON_VALUE(VARIABLE, GETTER, TYPE) \
ASSERT_HAS_JSON(GETTER, TYPE); \
const auto VARIABLE = (GETTER).as##TYPE()
// Non-const GET_JSON_VALUE.
# define GET_JSON_MUTABLE_VALUE(VARIABLE, GETTER, TYPE) \
ASSERT_HAS_JSON(GETTER, TYPE); \
auto VARIABLE = (GETTER).as##TYPE()
// Checks that the GETTER's value is present, is of the expected TYPE, and has
// the expected VALUE. (Non-critical)
# define EXPECT_EQ_JSON(GETTER, TYPE, VALUE) \
do { \
if ((GETTER).isNull()) { \
EXPECT_FALSE((GETTER).isNull()) \
<< #GETTER " doesn't exist or is null"; \
} else if (!(GETTER).is##TYPE()) { \
EXPECT_TRUE((GETTER).is##TYPE()) \
<< #GETTER " didn't return type " #TYPE; \
} else { \
EXPECT_EQ((GETTER).as##TYPE(), (VALUE)); \
} \
} while (false)
// Checks that the GETTER's value is present, and is a valid index into the
// STRINGTABLE array, pointing at the expected STRING.
# define EXPECT_EQ_STRINGTABLE(GETTER, STRINGTABLE, STRING) \
do { \
if ((GETTER).isNull()) { \
EXPECT_FALSE((GETTER).isNull()) \
<< #GETTER " doesn't exist or is null"; \
} else if (!(GETTER).isUInt()) { \
EXPECT_TRUE((GETTER).isUInt()) << #GETTER " didn't return an index"; \
} else { \
EXPECT_LT((GETTER).asUInt(), (STRINGTABLE).size()); \
EXPECT_EQ_JSON((STRINGTABLE)[(GETTER).asUInt()], String, (STRING)); \
} \
} while (false)
# define EXPECT_JSON_ARRAY_CONTAINS(GETTER, TYPE, VALUE) \
do { \
if ((GETTER).isNull()) { \
EXPECT_FALSE((GETTER).isNull()) \
<< #GETTER " doesn't exist or is null"; \
} else if (!(GETTER).isArray()) { \
EXPECT_TRUE((GETTER).is##TYPE()) << #GETTER " is not an array"; \
} else if (const Json::ArrayIndex size = (GETTER).size(); size == 0u) { \
EXPECT_NE(size, 0u) << #GETTER " is an empty array"; \
} else { \
bool found = false; \
for (Json::ArrayIndex i = 0; i < size; ++i) { \
if (!(GETTER)[i].is##TYPE()) { \
EXPECT_TRUE((GETTER)[i].is##TYPE()) \
<< #GETTER "[" << i << "] is not " #TYPE; \
break; \
} \
if ((GETTER)[i].as##TYPE() == (VALUE)) { \
found = true; \
break; \
} \
} \
EXPECT_TRUE(found) << #GETTER " doesn't contain " #VALUE; \
} \
} while (false)
# define EXPECT_JSON_ARRAY_EXCLUDES(GETTER, TYPE, VALUE) \
do { \
if ((GETTER).isNull()) { \
EXPECT_FALSE((GETTER).isNull()) \
<< #GETTER " doesn't exist or is null"; \
} else if (!(GETTER).isArray()) { \
EXPECT_TRUE((GETTER).is##TYPE()) << #GETTER " is not an array"; \
} else { \
const Json::ArrayIndex size = (GETTER).size(); \
for (Json::ArrayIndex i = 0; i < size; ++i) { \
if (!(GETTER)[i].is##TYPE()) { \
EXPECT_TRUE((GETTER)[i].is##TYPE()) \
<< #GETTER "[" << i << "] is not " #TYPE; \
break; \
} \
if ((GETTER)[i].as##TYPE() == (VALUE)) { \
EXPECT_TRUE((GETTER)[i].as##TYPE() != (VALUE)) \
<< #GETTER " contains " #VALUE; \
break; \
} \
} \
} \
} while (false)
// Check that the given process root contains all the expected properties.
static void JSONRootCheck(const Json::Value& aRoot,
bool aWithMainThread = true) {
ASSERT_TRUE(aRoot.isObject());
EXPECT_HAS_JSON(aRoot["libs"], Array);
GET_JSON(meta, aRoot["meta"], Object);
EXPECT_HAS_JSON(meta["version"], UInt);
EXPECT_HAS_JSON(meta["startTime"], Double);
EXPECT_HAS_JSON(meta["profilingStartTime"], Double);
EXPECT_HAS_JSON(meta["contentEarliestTime"], Double);
EXPECT_HAS_JSON(meta["profilingEndTime"], Double);
EXPECT_HAS_JSON(aRoot["pages"], Array);
// "counters" is only present if there is any data to report.
// Test that expect "counters" should test for its presence first.
if (aRoot.isMember("counters")) {
// We have "counters", test their overall validity.
GET_JSON(counters, aRoot["counters"], Array);
for (const Json::Value& counter : counters) {
ASSERT_TRUE(counter.isObject());
EXPECT_HAS_JSON(counter["name"], String);
EXPECT_HAS_JSON(counter["category"], String);
EXPECT_HAS_JSON(counter["description"], String);
GET_JSON(samples, counter["samples"], Object);
GET_JSON(samplesSchema, samples["schema"], Object);
EXPECT_GE(samplesSchema.size(), 3u);
GET_JSON_VALUE(samplesTime, samplesSchema["time"], UInt);
GET_JSON_VALUE(samplesNumber, samplesSchema["number"], UInt);
GET_JSON_VALUE(samplesCount, samplesSchema["count"], UInt);
GET_JSON(samplesData, samples["data"], Array);
double previousTime = 0.0;
for (const Json::Value& sample : samplesData) {
ASSERT_TRUE(sample.isArray());
GET_JSON_VALUE(time, sample[samplesTime], Double);
EXPECT_GE(time, previousTime);
previousTime = time;
if (sample.isValidIndex(samplesNumber)) {
EXPECT_HAS_JSON(sample[samplesNumber], UInt64);
}
if (sample.isValidIndex(samplesCount)) {
EXPECT_HAS_JSON(sample[samplesCount], Int64);
}
}
}
}
GET_JSON(threads, aRoot["threads"], Array);
const Json::ArrayIndex threadCount = threads.size();
for (Json::ArrayIndex i = 0; i < threadCount; ++i) {
GET_JSON(thread, threads[i], Object);
EXPECT_HAS_JSON(thread["processType"], String);
EXPECT_HAS_JSON(thread["name"], String);
EXPECT_HAS_JSON(thread["registerTime"], Double);
GET_JSON(samples, thread["samples"], Object);
EXPECT_HAS_JSON(thread["markers"], Object);
EXPECT_HAS_JSON(thread["pid"], Int64);
EXPECT_HAS_JSON(thread["tid"], Int64);
GET_JSON(stackTable, thread["stackTable"], Object);
GET_JSON(frameTable, thread["frameTable"], Object);
GET_JSON(stringTable, thread["stringTable"], Array);
GET_JSON(stackTableSchema, stackTable["schema"], Object);
EXPECT_GE(stackTableSchema.size(), 2u);
GET_JSON_VALUE(stackTablePrefix, stackTableSchema["prefix"], UInt);
GET_JSON_VALUE(stackTableFrame, stackTableSchema["frame"], UInt);
GET_JSON(stackTableData, stackTable["data"], Array);
GET_JSON(frameTableSchema, frameTable["schema"], Object);
EXPECT_GE(frameTableSchema.size(), 1u);
GET_JSON_VALUE(frameTableLocation, frameTableSchema["location"], UInt);
GET_JSON(frameTableData, frameTable["data"], Array);
GET_JSON(samplesSchema, samples["schema"], Object);
GET_JSON_VALUE(sampleStackIndex, samplesSchema["stack"], UInt);
GET_JSON(samplesData, samples["data"], Array);
for (const Json::Value& sample : samplesData) {
ASSERT_TRUE(sample.isArray());
if (sample.isValidIndex(sampleStackIndex)) {
if (!sample[sampleStackIndex].isNull()) {
GET_JSON_MUTABLE_VALUE(stack, sample[sampleStackIndex], UInt);
EXPECT_TRUE(stackTableData.isValidIndex(stack));
for (;;) {
// `stack` (from the sample, or from the callee frame's "prefix" in
// the previous loop) points into the stackTable.
GET_JSON(stackTableEntry, stackTableData[stack], Array);
GET_JSON_VALUE(frame, stackTableEntry[stackTableFrame], UInt);
// The stackTable entry's "frame" points into the frameTable.
EXPECT_TRUE(frameTableData.isValidIndex(frame));
GET_JSON(frameTableEntry, frameTableData[frame], Array);
GET_JSON_VALUE(location, frameTableEntry[frameTableLocation], UInt);
// The frameTable entry's "location" points at a string.
EXPECT_TRUE(stringTable.isValidIndex(location));
// The stackTable entry's "prefix" is null for the root frame.
if (stackTableEntry[stackTablePrefix].isNull()) {
break;
}
// Otherwise it recursively points at the caller in the stackTable.
GET_JSON_VALUE(prefix, stackTableEntry[stackTablePrefix], UInt);
EXPECT_TRUE(stackTableData.isValidIndex(prefix));
stack = prefix;
}
}
}
}
}
if (aWithMainThread) {
ASSERT_GT(threadCount, 0u);
GET_JSON(thread0, threads[0], Object);
EXPECT_EQ_JSON(thread0["name"], String, "GeckoMain");
}
EXPECT_HAS_JSON(aRoot["pausedRanges"], Array);
const Json::Value& processes = aRoot["processes"];
if (!processes.isNull()) {
ASSERT_TRUE(processes.isArray());
const Json::ArrayIndex processCount = processes.size();
for (Json::ArrayIndex i = 0; i < processCount; ++i) {
GET_JSON(process, processes[i], Object);
JSONRootCheck(process, aWithMainThread);
}
}
GET_JSON(profilingLog, aRoot["profilingLog"], Object);
EXPECT_EQ(profilingLog.size(), 1u);
for (auto it = profilingLog.begin(); it != profilingLog.end(); ++it) {
// The key should be a pid.
const auto key = it.name();
for (const auto letter : key) {
EXPECT_GE(letter, '0');
EXPECT_LE(letter, '9');
}
// And the value should be an object.
GET_JSON(logForPid, profilingLog[key], Object);
// Its content is not defined, but we expect at least these:
EXPECT_HAS_JSON(logForPid["profilingLogBegin_TSms"], Double);
EXPECT_HAS_JSON(logForPid["profilingLogEnd_TSms"], Double);
}
}
// Check that various expected top properties are in the JSON, and then call the
// provided `aJSONCheckFunction` with the JSON root object.
template <typename JSONCheckFunction>
void JSONOutputCheck(const char* aOutput,
JSONCheckFunction&& aJSONCheckFunction) {
ASSERT_NE(aOutput, nullptr);
JSONWhitespaceCheck(aOutput);
// Extract JSON.
Json::Value parsedRoot;
Json::CharReaderBuilder builder;
const std::unique_ptr<Json::CharReader> reader(builder.newCharReader());
ASSERT_TRUE(
reader->parse(aOutput, strchr(aOutput, '\0'), &parsedRoot, nullptr));
JSONRootCheck(parsedRoot);
std::forward<JSONCheckFunction>(aJSONCheckFunction)(parsedRoot);
}
// Returns `static_cast<SamplingState>(-1)` if callback could not be installed.
static SamplingState WaitForSamplingState() {
Atomic<int> samplingState{-1};
if (!profiler_callback_after_sampling([&](SamplingState aSamplingState) {
samplingState = static_cast<int>(aSamplingState);
})) {
return static_cast<SamplingState>(-1);
}
while (samplingState == -1) {
}
return static_cast<SamplingState>(static_cast<int>(samplingState));
}
typedef Vector<const char*> StrVec;
static void InactiveFeaturesAndParamsCheck() {
int entries;
Maybe<double> duration;
double interval;
uint32_t features;
StrVec filters;
uint64_t activeTabID;
ASSERT_TRUE(!profiler_is_active());
ASSERT_TRUE(!profiler_feature_active(ProfilerFeature::MainThreadIO));
ASSERT_TRUE(!profiler_feature_active(ProfilerFeature::NativeAllocations));
profiler_get_start_params(&entries, &duration, &interval, &features, &filters,
&activeTabID);
ASSERT_TRUE(entries == 0);
ASSERT_TRUE(duration == Nothing());
ASSERT_TRUE(interval == 0);
ASSERT_TRUE(features == 0);
ASSERT_TRUE(filters.empty());
ASSERT_TRUE(activeTabID == 0);
}
static void ActiveParamsCheck(int aEntries, double aInterval,
uint32_t aFeatures, const char** aFilters,
size_t aFiltersLen, uint64_t aActiveTabID,
const Maybe<double>& aDuration = Nothing()) {
int entries;
Maybe<double> duration;
double interval;
uint32_t features;
StrVec filters;
uint64_t activeTabID;
profiler_get_start_params(&entries, &duration, &interval, &features, &filters,
&activeTabID);
ASSERT_TRUE(entries == aEntries);
ASSERT_TRUE(duration == aDuration);
ASSERT_TRUE(interval == aInterval);
ASSERT_TRUE(features == aFeatures);
ASSERT_TRUE(filters.length() == aFiltersLen);
ASSERT_TRUE(activeTabID == aActiveTabID);
for (size_t i = 0; i < aFiltersLen; i++) {
ASSERT_TRUE(strcmp(filters[i], aFilters[i]) == 0);
}
}
TEST(GeckoProfiler, FeaturesAndParams)
{
InactiveFeaturesAndParamsCheck();
// Try a couple of features and filters.
{
uint32_t features = ProfilerFeature::JS;
const char* filters[] = {"GeckoMain", "Compositor"};
# define PROFILER_DEFAULT_DURATION 20 /* seconds, for tests only */
profiler_start(PROFILER_DEFAULT_ENTRIES, PROFILER_DEFAULT_INTERVAL,
features, filters, MOZ_ARRAY_LENGTH(filters), 100,
Some(PROFILER_DEFAULT_DURATION));
ASSERT_TRUE(profiler_is_active());
ASSERT_TRUE(!profiler_feature_active(ProfilerFeature::MainThreadIO));
ASSERT_TRUE(!profiler_feature_active(ProfilerFeature::IPCMessages));
ActiveParamsCheck(PROFILER_DEFAULT_ENTRIES.Value(),
PROFILER_DEFAULT_INTERVAL, features, filters,
MOZ_ARRAY_LENGTH(filters), 100,
Some(PROFILER_DEFAULT_DURATION));
profiler_stop();
InactiveFeaturesAndParamsCheck();
}
// Try some different features and filters.
{
uint32_t features =
ProfilerFeature::MainThreadIO | ProfilerFeature::IPCMessages;
const char* filters[] = {"GeckoMain", "Foo", "Bar"};
// Testing with some arbitrary buffer size (as could be provided by
// external code), which we convert to the appropriate power of 2.
profiler_start(PowerOfTwo32(999999), 3, features, filters,
MOZ_ARRAY_LENGTH(filters), 123, Some(25.0));
ASSERT_TRUE(profiler_is_active());
ASSERT_TRUE(profiler_feature_active(ProfilerFeature::MainThreadIO));
ASSERT_TRUE(profiler_feature_active(ProfilerFeature::IPCMessages));
ActiveParamsCheck(int(PowerOfTwo32(999999).Value()), 3, features, filters,
MOZ_ARRAY_LENGTH(filters), 123, Some(25.0));
profiler_stop();
InactiveFeaturesAndParamsCheck();
}
// Try with no duration
{
uint32_t features =
ProfilerFeature::MainThreadIO | ProfilerFeature::IPCMessages;
const char* filters[] = {"GeckoMain", "Foo", "Bar"};
profiler_start(PowerOfTwo32(999999), 3, features, filters,
MOZ_ARRAY_LENGTH(filters), 0, Nothing());
ASSERT_TRUE(profiler_is_active());
ASSERT_TRUE(profiler_feature_active(ProfilerFeature::MainThreadIO));
ASSERT_TRUE(profiler_feature_active(ProfilerFeature::IPCMessages));
ActiveParamsCheck(int(PowerOfTwo32(999999).Value()), 3, features, filters,
MOZ_ARRAY_LENGTH(filters), 0, Nothing());
profiler_stop();
InactiveFeaturesAndParamsCheck();
}
// Try all supported features, and filters that match all threads.
{
uint32_t availableFeatures = profiler_get_available_features();
const char* filters[] = {""};
profiler_start(PowerOfTwo32(88888), 10, availableFeatures, filters,
MOZ_ARRAY_LENGTH(filters), 0, Some(15.0));
ASSERT_TRUE(profiler_is_active());
ASSERT_TRUE(profiler_feature_active(ProfilerFeature::MainThreadIO));
ASSERT_TRUE(profiler_feature_active(ProfilerFeature::IPCMessages));
ActiveParamsCheck(PowerOfTwo32(88888).Value(), 10, availableFeatures,
filters, MOZ_ARRAY_LENGTH(filters), 0, Some(15.0));
// Don't call profiler_stop() here.
}
// Try no features, and filters that match no threads.
{
uint32_t features = 0;
const char* filters[] = {"NoThreadWillMatchThis"};
// Second profiler_start() call in a row without an intervening
// profiler_stop(); this will do an implicit profiler_stop() and restart.
profiler_start(PowerOfTwo32(0), 0, features, filters,
MOZ_ARRAY_LENGTH(filters), 0, Some(0.0));
ASSERT_TRUE(profiler_is_active());
ASSERT_TRUE(!profiler_feature_active(ProfilerFeature::MainThreadIO));
ASSERT_TRUE(!profiler_feature_active(ProfilerFeature::IPCMessages));
// Entries and intervals go to defaults if 0 is specified.
ActiveParamsCheck(PROFILER_DEFAULT_ENTRIES.Value(),
PROFILER_DEFAULT_INTERVAL, features, filters,
MOZ_ARRAY_LENGTH(filters), 0, Nothing());
profiler_stop();
InactiveFeaturesAndParamsCheck();
// These calls are no-ops.
profiler_stop();
profiler_stop();
InactiveFeaturesAndParamsCheck();
}
}
TEST(GeckoProfiler, EnsureStarted)
{
InactiveFeaturesAndParamsCheck();
uint32_t features = ProfilerFeature::JS;
const char* filters[] = {"GeckoMain", "Compositor"};
{
// Inactive -> Active
profiler_ensure_started(PROFILER_DEFAULT_ENTRIES, PROFILER_DEFAULT_INTERVAL,
features, filters, MOZ_ARRAY_LENGTH(filters), 0,
Some(PROFILER_DEFAULT_DURATION));
ActiveParamsCheck(
PROFILER_DEFAULT_ENTRIES.Value(), PROFILER_DEFAULT_INTERVAL, features,
filters, MOZ_ARRAY_LENGTH(filters), 0, Some(PROFILER_DEFAULT_DURATION));
}
{
// Active -> Active with same settings
Maybe<ProfilerBufferInfo> info0 = profiler_get_buffer_info();
ASSERT_TRUE(info0->mRangeEnd > 0);
// First, write some samples into the buffer.
PR_Sleep(PR_MillisecondsToInterval(500));
Maybe<ProfilerBufferInfo> info1 = profiler_get_buffer_info();
ASSERT_TRUE(info1->mRangeEnd > info0->mRangeEnd);
// Call profiler_ensure_started with the same settings as before.
// This operation must not clear our buffer!
profiler_ensure_started(PROFILER_DEFAULT_ENTRIES, PROFILER_DEFAULT_INTERVAL,
features, filters, MOZ_ARRAY_LENGTH(filters), 0,
Some(PROFILER_DEFAULT_DURATION));
ActiveParamsCheck(
PROFILER_DEFAULT_ENTRIES.Value(), PROFILER_DEFAULT_INTERVAL, features,
filters, MOZ_ARRAY_LENGTH(filters), 0, Some(PROFILER_DEFAULT_DURATION));
// Check that our position in the buffer stayed the same or advanced, but
// not by much, and the range-start after profiler_ensure_started shouldn't
// have passed the range-end before.
Maybe<ProfilerBufferInfo> info2 = profiler_get_buffer_info();
ASSERT_TRUE(info2->mRangeEnd >= info1->mRangeEnd);
ASSERT_TRUE(info2->mRangeEnd - info1->mRangeEnd <
info1->mRangeEnd - info0->mRangeEnd);
ASSERT_TRUE(info2->mRangeStart < info1->mRangeEnd);
}
{
// Active -> Active with *different* settings
Maybe<ProfilerBufferInfo> info1 = profiler_get_buffer_info();
// Call profiler_ensure_started with a different feature set than the one
// it's currently running with. This is supposed to stop and restart the
// profiler, thereby discarding the buffer contents.
uint32_t differentFeatures = features | ProfilerFeature::CPUUtilization;
profiler_ensure_started(PROFILER_DEFAULT_ENTRIES, PROFILER_DEFAULT_INTERVAL,
differentFeatures, filters,
MOZ_ARRAY_LENGTH(filters), 0);
ActiveParamsCheck(PROFILER_DEFAULT_ENTRIES.Value(),
PROFILER_DEFAULT_INTERVAL, differentFeatures, filters,
MOZ_ARRAY_LENGTH(filters), 0);
// Check the the buffer was cleared, so its range-start should be at/after
// its range-end before.
Maybe<ProfilerBufferInfo> info2 = profiler_get_buffer_info();
ASSERT_TRUE(info2->mRangeStart >= info1->mRangeEnd);
}
{
// Active -> Inactive
profiler_stop();
InactiveFeaturesAndParamsCheck();
}
}
TEST(GeckoProfiler, MultiRegistration)
{
// This whole test only checks that function calls don't crash, they don't
// actually verify that threads get profiled or not.
{
std::thread thread([]() {
char top;
profiler_register_thread("thread, no unreg", &top);
});
thread.join();
}
{
std::thread thread([]() { profiler_unregister_thread(); });
thread.join();
}
{
std::thread thread([]() {
char top;
profiler_register_thread("thread 1st", &top);
profiler_unregister_thread();
profiler_register_thread("thread 2nd", &top);
profiler_unregister_thread();
});
thread.join();
}
{
std::thread thread([]() {
char top;
profiler_register_thread("thread once", &top);
profiler_register_thread("thread again", &top);
profiler_unregister_thread();
});
thread.join();
}
{
std::thread thread([]() {
char top;
profiler_register_thread("thread to unreg twice", &top);
profiler_unregister_thread();
profiler_unregister_thread();
});
thread.join();
}
}
TEST(GeckoProfiler, DifferentThreads)
{
InactiveFeaturesAndParamsCheck();
nsCOMPtr<nsIThread> thread;
nsresult rv = NS_NewNamedThread("GeckoProfGTest", getter_AddRefs(thread));
ASSERT_NS_SUCCEEDED(rv);
// Control the profiler on a background thread and verify flags on the
// main thread.
{
uint32_t features = ProfilerFeature::JS;
const char* filters[] = {"GeckoMain", "Compositor"};
NS_DispatchAndSpinEventLoopUntilComplete(
"GeckoProfiler_DifferentThreads_Test::TestBody"_ns, thread,
NS_NewRunnableFunction(
"GeckoProfiler_DifferentThreads_Test::TestBody", [&]() {
profiler_start(PROFILER_DEFAULT_ENTRIES,
PROFILER_DEFAULT_INTERVAL, features, filters,
MOZ_ARRAY_LENGTH(filters), 0);
}));
ASSERT_TRUE(profiler_is_active());
ASSERT_TRUE(!profiler_feature_active(ProfilerFeature::MainThreadIO));
ASSERT_TRUE(!profiler_feature_active(ProfilerFeature::IPCMessages));
ActiveParamsCheck(PROFILER_DEFAULT_ENTRIES.Value(),
PROFILER_DEFAULT_INTERVAL, features, filters,
MOZ_ARRAY_LENGTH(filters), 0);
NS_DispatchAndSpinEventLoopUntilComplete(
"GeckoProfiler_DifferentThreads_Test::TestBody"_ns, thread,
NS_NewRunnableFunction("GeckoProfiler_DifferentThreads_Test::TestBody",
[&]() { profiler_stop(); }));
InactiveFeaturesAndParamsCheck();
}
// Control the profiler on the main thread and verify flags on a
// background thread.
{
uint32_t features = ProfilerFeature::JS;
const char* filters[] = {"GeckoMain", "Compositor"};
profiler_start(PROFILER_DEFAULT_ENTRIES, PROFILER_DEFAULT_INTERVAL,
features, filters, MOZ_ARRAY_LENGTH(filters), 0);
NS_DispatchAndSpinEventLoopUntilComplete(
"GeckoProfiler_DifferentThreads_Test::TestBody"_ns, thread,
NS_NewRunnableFunction(
"GeckoProfiler_DifferentThreads_Test::TestBody", [&]() {
ASSERT_TRUE(profiler_is_active());
ASSERT_TRUE(
!profiler_feature_active(ProfilerFeature::MainThreadIO));
ASSERT_TRUE(
!profiler_feature_active(ProfilerFeature::IPCMessages));
ActiveParamsCheck(PROFILER_DEFAULT_ENTRIES.Value(),
PROFILER_DEFAULT_INTERVAL, features, filters,
MOZ_ARRAY_LENGTH(filters), 0);
}));
profiler_stop();
NS_DispatchAndSpinEventLoopUntilComplete(
"GeckoProfiler_DifferentThreads_Test::TestBody"_ns, thread,
NS_NewRunnableFunction("GeckoProfiler_DifferentThreads_Test::TestBody",
[&]() { InactiveFeaturesAndParamsCheck(); }));
}
thread->Shutdown();
}
TEST(GeckoProfiler, GetBacktrace)
{
ASSERT_TRUE(!profiler_get_backtrace());
{
uint32_t features = ProfilerFeature::StackWalk;
const char* filters[] = {"GeckoMain"};
profiler_start(PROFILER_DEFAULT_ENTRIES, PROFILER_DEFAULT_INTERVAL,
features, filters, MOZ_ARRAY_LENGTH(filters), 0);
// These will be destroyed while the profiler is active.
static const int N = 100;
{
UniqueProfilerBacktrace u[N];
for (int i = 0; i < N; i++) {
u[i] = profiler_get_backtrace();
ASSERT_TRUE(u[i]);
}
}
// These will be destroyed after the profiler stops.
UniqueProfilerBacktrace u[N];
for (int i = 0; i < N; i++) {
u[i] = profiler_get_backtrace();
ASSERT_TRUE(u[i]);
}
profiler_stop();
}
ASSERT_TRUE(!profiler_get_backtrace());
}
TEST(GeckoProfiler, Pause)
{
profiler_init_main_thread_id();
ASSERT_TRUE(profiler_is_main_thread())
<< "This test must run on the main thread";
uint32_t features = ProfilerFeature::StackWalk;
const char* filters[] = {"GeckoMain", "Profiled GeckoProfiler.Pause"};
ASSERT_TRUE(!profiler_is_paused());
for (ThreadProfilingFeatures features : scEachAndAnyThreadProfilingFeatures) {
ASSERT_TRUE(!profiler_thread_is_being_profiled(features));
ASSERT_TRUE(
!profiler_thread_is_being_profiled(ProfilerThreadId{}, features));
ASSERT_TRUE(!profiler_thread_is_being_profiled(profiler_current_thread_id(),
features));
ASSERT_TRUE(!profiler_thread_is_being_profiled(profiler_main_thread_id(),
features));
}
std::thread{[&]() {
{
for (ThreadProfilingFeatures features :
scEachAndAnyThreadProfilingFeatures) {
ASSERT_TRUE(!profiler_thread_is_being_profiled(features));
ASSERT_TRUE(
!profiler_thread_is_being_profiled(ProfilerThreadId{}, features));
ASSERT_TRUE(!profiler_thread_is_being_profiled(
profiler_current_thread_id(), features));
ASSERT_TRUE(!profiler_thread_is_being_profiled(
profiler_main_thread_id(), features));
}
}
{
AUTO_PROFILER_REGISTER_THREAD(
"Ignored GeckoProfiler.Pause - before start");
for (ThreadProfilingFeatures features :
scEachAndAnyThreadProfilingFeatures) {
ASSERT_TRUE(!profiler_thread_is_being_profiled(features));
ASSERT_TRUE(
!profiler_thread_is_being_profiled(ProfilerThreadId{}, features));
ASSERT_TRUE(!profiler_thread_is_being_profiled(
profiler_current_thread_id(), features));
ASSERT_TRUE(!profiler_thread_is_being_profiled(
profiler_main_thread_id(), features));
}
}
{
AUTO_PROFILER_REGISTER_THREAD(
"Profiled GeckoProfiler.Pause - before start");
for (ThreadProfilingFeatures features :
scEachAndAnyThreadProfilingFeatures) {
ASSERT_TRUE(!profiler_thread_is_being_profiled(features));
ASSERT_TRUE(
!profiler_thread_is_being_profiled(ProfilerThreadId{}, features));
ASSERT_TRUE(!profiler_thread_is_being_profiled(
profiler_current_thread_id(), features));
ASSERT_TRUE(!profiler_thread_is_being_profiled(
profiler_main_thread_id(), features));
}
}
}}.join();
profiler_start(PROFILER_DEFAULT_ENTRIES, PROFILER_DEFAULT_INTERVAL, features,
filters, MOZ_ARRAY_LENGTH(filters), 0);
ASSERT_TRUE(!profiler_is_paused());
for (ThreadProfilingFeatures features : scEachAndAnyThreadProfilingFeatures) {
ASSERT_TRUE(profiler_thread_is_being_profiled(features));
ASSERT_TRUE(
profiler_thread_is_being_profiled(ProfilerThreadId{}, features));
ASSERT_TRUE(profiler_thread_is_being_profiled(profiler_current_thread_id(),
features));
}
std::thread{[&]() {
{
for (ThreadProfilingFeatures features :
scEachAndAnyThreadProfilingFeatures) {
ASSERT_TRUE(!profiler_thread_is_being_profiled(features));
ASSERT_TRUE(
!profiler_thread_is_being_profiled(ProfilerThreadId{}, features));
ASSERT_TRUE(!profiler_thread_is_being_profiled(
profiler_current_thread_id(), features));
ASSERT_TRUE(profiler_thread_is_being_profiled(profiler_main_thread_id(),
features));
}
}
{
AUTO_PROFILER_REGISTER_THREAD(
"Ignored GeckoProfiler.Pause - after start");
for (ThreadProfilingFeatures features :
scEachAndAnyThreadProfilingFeatures) {
ASSERT_TRUE(!profiler_thread_is_being_profiled(features));
ASSERT_TRUE(
!profiler_thread_is_being_profiled(ProfilerThreadId{}, features));
ASSERT_TRUE(!profiler_thread_is_being_profiled(
profiler_current_thread_id(), features));
ASSERT_TRUE(profiler_thread_is_being_profiled(profiler_main_thread_id(),
features));
}
}
{
AUTO_PROFILER_REGISTER_THREAD(
"Profiled GeckoProfiler.Pause - after start");
for (ThreadProfilingFeatures features :
scEachAndAnyThreadProfilingFeatures) {
ASSERT_TRUE(profiler_thread_is_being_profiled(features));
ASSERT_TRUE(
profiler_thread_is_being_profiled(ProfilerThreadId{}, features));
ASSERT_TRUE(profiler_thread_is_being_profiled(
profiler_current_thread_id(), features));
ASSERT_TRUE(profiler_thread_is_being_profiled(profiler_main_thread_id(),
features));
}
}
}}.join();
// Check that we are writing samples while not paused.
Maybe<ProfilerBufferInfo> info1 = profiler_get_buffer_info();
PR_Sleep(PR_MillisecondsToInterval(500));
Maybe<ProfilerBufferInfo> info2 = profiler_get_buffer_info();
ASSERT_TRUE(info1->mRangeEnd != info2->mRangeEnd);
// Check that we are writing markers while not paused.
ASSERT_TRUE(profiler_thread_is_being_profiled_for_markers());
ASSERT_TRUE(
profiler_thread_is_being_profiled_for_markers(ProfilerThreadId{}));
ASSERT_TRUE(profiler_thread_is_being_profiled_for_markers(
profiler_current_thread_id()));
ASSERT_TRUE(
profiler_thread_is_being_profiled_for_markers(profiler_main_thread_id()));
info1 = profiler_get_buffer_info();
PROFILER_MARKER_UNTYPED("Not paused", OTHER, {});
info2 = profiler_get_buffer_info();
ASSERT_TRUE(info1->mRangeEnd != info2->mRangeEnd);
profiler_pause();
ASSERT_TRUE(profiler_is_paused());
for (ThreadProfilingFeatures features : scEachAndAnyThreadProfilingFeatures) {
ASSERT_TRUE(!profiler_thread_is_being_profiled(features));
ASSERT_TRUE(
!profiler_thread_is_being_profiled(ProfilerThreadId{}, features));
ASSERT_TRUE(!profiler_thread_is_being_profiled(profiler_current_thread_id(),
features));
}
ASSERT_TRUE(!profiler_thread_is_being_profiled_for_markers());
ASSERT_TRUE(
!profiler_thread_is_being_profiled_for_markers(ProfilerThreadId{}));
ASSERT_TRUE(!profiler_thread_is_being_profiled_for_markers(
profiler_current_thread_id()));
ASSERT_TRUE(!profiler_thread_is_being_profiled_for_markers(
profiler_main_thread_id()));
std::thread{[&]() {
{
for (ThreadProfilingFeatures features :
scEachAndAnyThreadProfilingFeatures) {
ASSERT_TRUE(!profiler_thread_is_being_profiled(features));
ASSERT_TRUE(
!profiler_thread_is_being_profiled(ProfilerThreadId{}, features));
ASSERT_TRUE(!profiler_thread_is_being_profiled(
profiler_current_thread_id(), features));
ASSERT_TRUE(!profiler_thread_is_being_profiled(
profiler_main_thread_id(), features));
}
}
{
AUTO_PROFILER_REGISTER_THREAD(
"Ignored GeckoProfiler.Pause - after pause");
for (ThreadProfilingFeatures features :
scEachAndAnyThreadProfilingFeatures) {
ASSERT_TRUE(!profiler_thread_is_being_profiled(features));
ASSERT_TRUE(
!profiler_thread_is_being_profiled(ProfilerThreadId{}, features));
ASSERT_TRUE(!profiler_thread_is_being_profiled(
profiler_current_thread_id(), features));
ASSERT_TRUE(!profiler_thread_is_being_profiled(
profiler_main_thread_id(), features));
}
}
{
AUTO_PROFILER_REGISTER_THREAD(
"Profiled GeckoProfiler.Pause - after pause");
for (ThreadProfilingFeatures features :
scEachAndAnyThreadProfilingFeatures) {
ASSERT_TRUE(!profiler_thread_is_being_profiled(features));
ASSERT_TRUE(
!profiler_thread_is_being_profiled(ProfilerThreadId{}, features));
ASSERT_TRUE(!profiler_thread_is_being_profiled(
profiler_current_thread_id(), features));
ASSERT_TRUE(!profiler_thread_is_being_profiled(
profiler_main_thread_id(), features));
}
}
}}.join();
// Check that we are not writing samples while paused.
info1 = profiler_get_buffer_info();
PR_Sleep(PR_MillisecondsToInterval(500));
info2 = profiler_get_buffer_info();
ASSERT_TRUE(info1->mRangeEnd == info2->mRangeEnd);
// Check that we are now writing markers while paused.
info1 = profiler_get_buffer_info();
PROFILER_MARKER_UNTYPED("Paused", OTHER, {});
info2 = profiler_get_buffer_info();
ASSERT_TRUE(info1->mRangeEnd == info2->mRangeEnd);
PROFILER_MARKER_UNTYPED("Paused v2", OTHER, {});
Maybe<ProfilerBufferInfo> info3 = profiler_get_buffer_info();
ASSERT_TRUE(info2->mRangeEnd == info3->mRangeEnd);
profiler_resume();
ASSERT_TRUE(!profiler_is_paused());
for (ThreadProfilingFeatures features : scEachAndAnyThreadProfilingFeatures) {
ASSERT_TRUE(profiler_thread_is_being_profiled(features));
ASSERT_TRUE(
profiler_thread_is_being_profiled(ProfilerThreadId{}, features));
ASSERT_TRUE(profiler_thread_is_being_profiled(profiler_current_thread_id(),
features));
}
std::thread{[&]() {
{
for (ThreadProfilingFeatures features :
scEachAndAnyThreadProfilingFeatures) {
ASSERT_TRUE(!profiler_thread_is_being_profiled(features));
ASSERT_TRUE(
!profiler_thread_is_being_profiled(ProfilerThreadId{}, features));
ASSERT_TRUE(!profiler_thread_is_being_profiled(
profiler_current_thread_id(), features));
ASSERT_TRUE(profiler_thread_is_being_profiled(profiler_main_thread_id(),
features));
}
}
{
AUTO_PROFILER_REGISTER_THREAD(
"Ignored GeckoProfiler.Pause - after resume");
for (ThreadProfilingFeatures features :
scEachAndAnyThreadProfilingFeatures) {
ASSERT_TRUE(!profiler_thread_is_being_profiled(features));
ASSERT_TRUE(
!profiler_thread_is_being_profiled(ProfilerThreadId{}, features));
ASSERT_TRUE(!profiler_thread_is_being_profiled(
profiler_current_thread_id(), features));
ASSERT_TRUE(profiler_thread_is_being_profiled(profiler_main_thread_id(),
features));
}
}
{
AUTO_PROFILER_REGISTER_THREAD(
"Profiled GeckoProfiler.Pause - after resume");
for (ThreadProfilingFeatures features :
scEachAndAnyThreadProfilingFeatures) {
ASSERT_TRUE(profiler_thread_is_being_profiled(features));
ASSERT_TRUE(
profiler_thread_is_being_profiled(ProfilerThreadId{}, features));
ASSERT_TRUE(profiler_thread_is_being_profiled(
profiler_current_thread_id(), features));
ASSERT_TRUE(profiler_thread_is_being_profiled(profiler_main_thread_id(),
features));
}
}
}}.join();
profiler_stop();
ASSERT_TRUE(!profiler_is_paused());
for (ThreadProfilingFeatures features : scEachAndAnyThreadProfilingFeatures) {
ASSERT_TRUE(!profiler_thread_is_being_profiled(features));
ASSERT_TRUE(
!profiler_thread_is_being_profiled(ProfilerThreadId{}, features));
ASSERT_TRUE(!profiler_thread_is_being_profiled(profiler_current_thread_id(),
features));
}
std::thread{[&]() {
{
for (ThreadProfilingFeatures features :
scEachAndAnyThreadProfilingFeatures) {
ASSERT_TRUE(!profiler_thread_is_being_profiled(features));
ASSERT_TRUE(
!profiler_thread_is_being_profiled(ProfilerThreadId{}, features));
ASSERT_TRUE(!profiler_thread_is_being_profiled(
profiler_current_thread_id(), features));
ASSERT_TRUE(!profiler_thread_is_being_profiled(
profiler_main_thread_id(), features));
}
}
{
AUTO_PROFILER_REGISTER_THREAD("Ignored GeckoProfiler.Pause - after stop");
for (ThreadProfilingFeatures features :
scEachAndAnyThreadProfilingFeatures) {
ASSERT_TRUE(!profiler_thread_is_being_profiled(features));
ASSERT_TRUE(
!profiler_thread_is_being_profiled(ProfilerThreadId{}, features));
ASSERT_TRUE(!profiler_thread_is_being_profiled(
profiler_current_thread_id(), features));
ASSERT_TRUE(!profiler_thread_is_being_profiled(
profiler_main_thread_id(), features));
}
}
{
AUTO_PROFILER_REGISTER_THREAD(
"Profiled GeckoProfiler.Pause - after stop");
for (ThreadProfilingFeatures features :
scEachAndAnyThreadProfilingFeatures) {
ASSERT_TRUE(!profiler_thread_is_being_profiled(features));
ASSERT_TRUE(
!profiler_thread_is_being_profiled(ProfilerThreadId{}, features));
ASSERT_TRUE(!profiler_thread_is_being_profiled(
profiler_current_thread_id(), features));
ASSERT_TRUE(!profiler_thread_is_being_profiled(
profiler_main_thread_id(), features));
}
}
}}.join();
}
TEST(GeckoProfiler, Markers)
{
uint32_t features = ProfilerFeature::StackWalk;
const char* filters[] = {"GeckoMain"};
profiler_start(PROFILER_DEFAULT_ENTRIES, PROFILER_DEFAULT_INTERVAL, features,
filters, MOZ_ARRAY_LENGTH(filters), 0);
PROFILER_MARKER("tracing event", OTHER, {}, Tracing, "A");
PROFILER_MARKER("tracing start", OTHER, MarkerTiming::IntervalStart(),
Tracing, "A");
PROFILER_MARKER("tracing end", OTHER, MarkerTiming::IntervalEnd(), Tracing,
"A");
auto bt = profiler_capture_backtrace();
PROFILER_MARKER("tracing event with stack", OTHER,
MarkerStack::TakeBacktrace(std::move(bt)), Tracing, "B");
{ AUTO_PROFILER_TRACING_MARKER("C", "auto tracing", OTHER); }
PROFILER_MARKER_UNTYPED("M1", OTHER, {});
PROFILER_MARKER_UNTYPED("M3", OTHER, {});
// Create three strings: two that are the maximum allowed length, and one that
// is one char longer.
static const size_t kMax = ProfileBuffer::kMaxFrameKeyLength;
UniquePtr<char[]> okstr1 = MakeUnique<char[]>(kMax);
UniquePtr<char[]> okstr2 = MakeUnique<char[]>(kMax);
UniquePtr<char[]> longstr = MakeUnique<char[]>(kMax + 1);
UniquePtr<char[]> longstrCut = MakeUnique<char[]>(kMax + 1);
for (size_t i = 0; i < kMax; i++) {
okstr1[i] = 'a';
okstr2[i] = 'b';
longstr[i] = 'c';
longstrCut[i] = 'c';
}
okstr1[kMax - 1] = '\0';
okstr2[kMax - 1] = '\0';
longstr[kMax] = '\0';
longstrCut[kMax] = '\0';
// Should be output as-is.
AUTO_PROFILER_LABEL_DYNAMIC_CSTR("", LAYOUT, "");
AUTO_PROFILER_LABEL_DYNAMIC_CSTR("", LAYOUT, okstr1.get());
// Should be output as label + space + okstr2.
AUTO_PROFILER_LABEL_DYNAMIC_CSTR("okstr2", LAYOUT, okstr2.get());
// Should be output with kMax length, ending with "...\0".
AUTO_PROFILER_LABEL_DYNAMIC_CSTR("", LAYOUT, longstr.get());
ASSERT_EQ(longstrCut[kMax - 4], 'c');
longstrCut[kMax - 4] = '.';
ASSERT_EQ(longstrCut[kMax - 3], 'c');
longstrCut[kMax - 3] = '.';
ASSERT_EQ(longstrCut[kMax - 2], 'c');
longstrCut[kMax - 2] = '.';
ASSERT_EQ(longstrCut[kMax - 1], 'c');
longstrCut[kMax - 1] = '\0';
// Test basic markers 2.0.
EXPECT_TRUE(profiler_add_marker_impl(
"default-templated markers 2.0 with empty options",
geckoprofiler::category::OTHER, {}));
PROFILER_MARKER_UNTYPED(
"default-templated markers 2.0 with option", OTHER,
MarkerStack::TakeBacktrace(profiler_capture_backtrace()));
PROFILER_MARKER("explicitly-default-templated markers 2.0 with empty options",
OTHER, {}, NoPayload);
EXPECT_TRUE(profiler_add_marker_impl(
"explicitly-default-templated markers 2.0 with option",
geckoprofiler::category::OTHER, {},
::geckoprofiler::markers::NoPayload{}));
// Used in markers below.
TimeStamp ts1 = TimeStamp::Now();
// Sleep briefly to ensure a sample is taken and the pending markers are
// processed.
PR_Sleep(PR_MillisecondsToInterval(500));
// Used in markers below.
TimeStamp ts2 = TimeStamp::Now();
// ts1 and ts2 should be different thanks to the sleep.
EXPECT_NE(ts1, ts2);
// Test most marker payloads.
// Keep this one first! (It's used to record `ts1` and `ts2`, to compare
// to serialized numbers in other markers.)
EXPECT_TRUE(profiler_add_marker_impl(
"FirstMarker", geckoprofiler::category::OTHER,
MarkerTiming::Interval(ts1, ts2), geckoprofiler::markers::TextMarker{},
"First Marker"));
// User-defined marker type with different properties, and fake schema.
struct GtestMarker {
static constexpr Span<const char> MarkerTypeName() {
return MakeStringSpan("markers-gtest");
}
static void StreamJSONMarkerData(
mozilla::baseprofiler::SpliceableJSONWriter& aWriter, int aInt,
double aDouble, const mozilla::ProfilerString8View& aText,
const mozilla::ProfilerString8View& aUniqueText,
const mozilla::TimeStamp& aTime) {
aWriter.NullProperty("null");
aWriter.BoolProperty("bool-false", false);
aWriter.BoolProperty("bool-true", true);
aWriter.IntProperty("int", aInt);
aWriter.DoubleProperty("double", aDouble);
aWriter.StringProperty("text", aText);
aWriter.UniqueStringProperty("unique text", aUniqueText);
aWriter.UniqueStringProperty("unique text again", aUniqueText);
aWriter.TimeProperty("time", aTime);
}
static mozilla::MarkerSchema MarkerTypeDisplay() {
// Note: This is an test function that is not intended to actually output
// that correctly matches StreamJSONMarkerData data above! Instead we only
// test that it outputs the expected JSON at the end.
using MS = mozilla::MarkerSchema;
MS schema{MS::Location::MarkerChart, MS::Location::MarkerTable,
MS::Location::TimelineOverview, MS::Location::TimelineMemory,
MS::Location::TimelineIPC, MS::Location::TimelineFileIO,
MS::Location::StackChart};
// All label functions.
schema.SetChartLabel("chart label");
schema.SetTooltipLabel("tooltip label");
schema.SetTableLabel("table label");
// All data functions, all formats, all "searchable" values.
schema.AddKeyFormat("key with url", MS::Format::Url);
schema.AddKeyLabelFormat("key with label filePath", "label filePath",
MS::Format::FilePath);
schema.AddKeyFormatSearchable("key with string not-searchable",
MS::Format::String,
MS::Searchable::NotSearchable);
schema.AddKeyLabelFormatSearchable("key with label duration searchable",
"label duration", MS::Format::Duration,
MS::Searchable::Searchable);
schema.AddKeyFormat("key with time", MS::Format::Time);
schema.AddKeyFormat("key with seconds", MS::Format::Seconds);
schema.AddKeyFormat("key with milliseconds", MS::Format::Milliseconds);
schema.AddKeyFormat("key with microseconds", MS::Format::Microseconds);
schema.AddKeyFormat("key with nanoseconds", MS::Format::Nanoseconds);
schema.AddKeyFormat("key with bytes", MS::Format::Bytes);
schema.AddKeyFormat("key with percentage", MS::Format::Percentage);
schema.AddKeyFormat("key with integer", MS::Format::Integer);
schema.AddKeyFormat("key with decimal", MS::Format::Decimal);
schema.AddStaticLabelValue("static label", "static value");
schema.AddKeyFormat("key with unique string", MS::Format::UniqueString);
schema.AddKeyFormatSearchable("key with sanitized string",
MS::Format::SanitizedString,
MS::Searchable::Searchable);
return schema;
}
};
EXPECT_TRUE(profiler_add_marker_impl(
"Gtest custom marker", geckoprofiler::category::OTHER,
MarkerTiming::Interval(ts1, ts2), GtestMarker{}, 42, 43.0, "gtest text",
"gtest unique text", ts1));
// User-defined marker type with no data, special frontend schema.
struct GtestSpecialMarker {
static constexpr Span<const char> MarkerTypeName() {
return MakeStringSpan("markers-gtest-special");
}
static void StreamJSONMarkerData(
mozilla::baseprofiler::SpliceableJSONWriter& aWriter) {}
static mozilla::MarkerSchema MarkerTypeDisplay() {
return mozilla::MarkerSchema::SpecialFrontendLocation{};
}
};
EXPECT_TRUE(profiler_add_marker_impl("Gtest special marker",
geckoprofiler::category::OTHER, {},
GtestSpecialMarker{}));
// User-defined marker type that is never used, so it shouldn't appear in the
// output.
struct GtestUnusedMarker {
static constexpr Span<const char> MarkerTypeName() {
return MakeStringSpan("markers-gtest-unused");
}
static void StreamJSONMarkerData(
mozilla::baseprofiler::SpliceableJSONWriter& aWriter) {}
static mozilla::MarkerSchema MarkerTypeDisplay() {
return mozilla::MarkerSchema::SpecialFrontendLocation{};
}
};
// Make sure the compiler doesn't complain about this unused struct.
mozilla::Unused << GtestUnusedMarker{};
// Other markers in alphabetical order of payload class names.
nsCOMPtr<nsIURI> uri;
ASSERT_TRUE(
NS_SUCCEEDED(NS_NewURI(getter_AddRefs(uri), "http://mozilla.org/"_ns)));
// The marker name will be "Load <aChannelId>: <aURI>".
profiler_add_network_marker(
/* nsIURI* aURI */ uri,
/* const nsACString& aRequestMethod */ "GET"_ns,
/* int32_t aPriority */ 34,
/* uint64_t aChannelId */ 1,
/* NetworkLoadType aType */ net::NetworkLoadType::LOAD_START,
/* mozilla::TimeStamp aStart */ ts1,
/* mozilla::TimeStamp aEnd */ ts2,
/* int64_t aCount */ 56,
/* mozilla::net::CacheDisposition aCacheDisposition */
net::kCacheHit,
/* uint64_t aInnerWindowID */ 78,
/* bool aIsPrivateBrowsing */ false
/* const mozilla::net::TimingStruct* aTimings = nullptr */
/* mozilla::UniquePtr<mozilla::ProfileChunkedBuffer> aSource =
nullptr */
/* const mozilla::Maybe<nsDependentCString>& aContentType =
mozilla::Nothing() */
/* nsIURI* aRedirectURI = nullptr */
/* uint64_t aRedirectChannelId = 0 */
);
profiler_add_network_marker(
/* nsIURI* aURI */ uri,
/* const nsACString& aRequestMethod */ "GET"_ns,
/* int32_t aPriority */ 34,
/* uint64_t aChannelId */ 2,
/* NetworkLoadType aType */ net::NetworkLoadType::LOAD_STOP,
/* mozilla::TimeStamp aStart */ ts1,
/* mozilla::TimeStamp aEnd */ ts2,
/* int64_t aCount */ 56,
/* mozilla::net::CacheDisposition aCacheDisposition */
net::kCacheUnresolved,
/* uint64_t aInnerWindowID */ 78,
/* bool aIsPrivateBrowsing */ false,
/* const mozilla::net::TimingStruct* aTimings = nullptr */ nullptr,
/* mozilla::UniquePtr<mozilla::ProfileChunkedBuffer> aSource =
nullptr */
nullptr,
/* const mozilla::Maybe<nsDependentCString>& aContentType =
mozilla::Nothing() */
Some(nsDependentCString("text/html")),
/* nsIURI* aRedirectURI = nullptr */ nullptr,
/* uint64_t aRedirectChannelId = 0 */ 0);
nsCOMPtr<nsIURI> redirectURI;
ASSERT_TRUE(NS_SUCCEEDED(
NS_NewURI(getter_AddRefs(redirectURI), "http://example.com/"_ns)));
profiler_add_network_marker(
/* nsIURI* aURI */ uri,
/* const nsACString& aRequestMethod */ "GET"_ns,
/* int32_t aPriority */ 34,
/* uint64_t aChannelId */ 3,
/* NetworkLoadType aType */ net::NetworkLoadType::LOAD_REDIRECT,
/* mozilla::TimeStamp aStart */ ts1,
/* mozilla::TimeStamp aEnd */ ts2,
/* int64_t aCount */ 56,
/* mozilla::net::CacheDisposition aCacheDisposition */
net::kCacheUnresolved,
/* uint64_t aInnerWindowID */ 78,
/* bool aIsPrivateBrowsing */ false,
/* const mozilla::net::TimingStruct* aTimings = nullptr */ nullptr,
/* mozilla::UniquePtr<mozilla::ProfileChunkedBuffer> aSource =
nullptr */
nullptr,
/* const mozilla::Maybe<nsDependentCString>& aContentType =
mozilla::Nothing() */
mozilla::Nothing(),
/* nsIURI* aRedirectURI = nullptr */ redirectURI,
/* uint32_t aRedirectFlags = 0 */
nsIChannelEventSink::REDIRECT_TEMPORARY,
/* uint64_t aRedirectChannelId = 0 */ 103);
profiler_add_network_marker(
/* nsIURI* aURI */ uri,
/* const nsACString& aRequestMethod */ "GET"_ns,
/* int32_t aPriority */ 34,
/* uint64_t aChannelId */ 4,
/* NetworkLoadType aType */ net::NetworkLoadType::LOAD_REDIRECT,
/* mozilla::TimeStamp aStart */ ts1,
/* mozilla::TimeStamp aEnd */ ts2,
/* int64_t aCount */ 56,
/* mozilla::net::CacheDisposition aCacheDisposition */
net::kCacheUnresolved,
/* uint64_t aInnerWindowID */ 78,
/* bool aIsPrivateBrowsing */ false,
/* const mozilla::net::TimingStruct* aTimings = nullptr */ nullptr,
/* mozilla::UniquePtr<mozilla::ProfileChunkedBuffer> aSource =
nullptr */
nullptr,
/* const mozilla::Maybe<nsDependentCString>& aContentType =
mozilla::Nothing() */
mozilla::Nothing(),
/* nsIURI* aRedirectURI = nullptr */ redirectURI,
/* uint32_t aRedirectFlags = 0 */
nsIChannelEventSink::REDIRECT_PERMANENT,
/* uint64_t aRedirectChannelId = 0 */ 104);
profiler_add_network_marker(
/* nsIURI* aURI */ uri,
/* const nsACString& aRequestMethod */ "GET"_ns,
/* int32_t aPriority */ 34,
/* uint64_t aChannelId */ 5,
/* NetworkLoadType aType */ net::NetworkLoadType::LOAD_REDIRECT,
/* mozilla::TimeStamp aStart */ ts1,
/* mozilla::TimeStamp aEnd */ ts2,
/* int64_t aCount */ 56,
/* mozilla::net::CacheDisposition aCacheDisposition */
net::kCacheUnresolved,
/* uint64_t aInnerWindowID */ 78,
/* bool aIsPrivateBrowsing */ false,
/* const mozilla::net::TimingStruct* aTimings = nullptr */ nullptr,
/* mozilla::UniquePtr<mozilla::ProfileChunkedBuffer> aSource =
nullptr */
nullptr,
/* const mozilla::Maybe<nsDependentCString>& aContentType =
mozilla::Nothing() */
mozilla::Nothing(),
/* nsIURI* aRedirectURI = nullptr */ redirectURI,
/* uint32_t aRedirectFlags = 0 */ nsIChannelEventSink::REDIRECT_INTERNAL,
/* uint64_t aRedirectChannelId = 0 */ 105);
profiler_add_network_marker(
/* nsIURI* aURI */ uri,
/* const nsACString& aRequestMethod */ "GET"_ns,
/* int32_t aPriority */ 34,
/* uint64_t aChannelId */ 6,
/* NetworkLoadType aType */ net::NetworkLoadType::LOAD_REDIRECT,
/* mozilla::TimeStamp aStart */ ts1,
/* mozilla::TimeStamp aEnd */ ts2,
/* int64_t aCount */ 56,
/* mozilla::net::CacheDisposition aCacheDisposition */
net::kCacheUnresolved,
/* uint64_t aInnerWindowID */ 78,
/* bool aIsPrivateBrowsing */ false,
/* const mozilla::net::TimingStruct* aTimings = nullptr */ nullptr,
/* mozilla::UniquePtr<mozilla::ProfileChunkedBuffer> aSource =
nullptr */
nullptr,
/* const mozilla::Maybe<nsDependentCString>& aContentType =
mozilla::Nothing() */
mozilla::Nothing(),
/* nsIURI* aRedirectURI = nullptr */ redirectURI,
/* uint32_t aRedirectFlags = 0 */ nsIChannelEventSink::REDIRECT_INTERNAL |
nsIChannelEventSink::REDIRECT_STS_UPGRADE,
/* uint64_t aRedirectChannelId = 0 */ 106);
profiler_add_network_marker(
/* nsIURI* aURI */ uri,
/* const nsACString& aRequestMethod */ "GET"_ns,
/* int32_t aPriority */ 34,
/* uint64_t aChannelId */ 7,
/* NetworkLoadType aType */ net::NetworkLoadType::LOAD_START,
/* mozilla::TimeStamp aStart */ ts1,
/* mozilla::TimeStamp aEnd */ ts2,
/* int64_t aCount */ 56,
/* mozilla::net::CacheDisposition aCacheDisposition */
net::kCacheUnresolved,
/* uint64_t aInnerWindowID */ 78,
/* bool aIsPrivateBrowsing */ true
/* const mozilla::net::TimingStruct* aTimings = nullptr */
/* mozilla::UniquePtr<mozilla::ProfileChunkedBuffer> aSource =
nullptr */
/* const mozilla::Maybe<nsDependentCString>& aContentType =
mozilla::Nothing() */
/* nsIURI* aRedirectURI = nullptr */
/* uint64_t aRedirectChannelId = 0 */
);
EXPECT_TRUE(profiler_add_marker_impl(
"Text in main thread with stack", geckoprofiler::category::OTHER,
{MarkerStack::Capture(), MarkerTiming::Interval(ts1, ts2)},
geckoprofiler::markers::TextMarker{}, ""));
EXPECT_TRUE(profiler_add_marker_impl(
"Text from main thread with stack", geckoprofiler::category::OTHER,
MarkerOptions(MarkerThreadId::MainThread(), MarkerStack::Capture()),
geckoprofiler::markers::TextMarker{}, ""));
std::thread registeredThread([]() {
AUTO_PROFILER_REGISTER_THREAD("Marker test sub-thread");
// Marker in non-profiled thread won't be stored.
EXPECT_FALSE(profiler_add_marker_impl(
"Text in registered thread with stack", geckoprofiler::category::OTHER,
MarkerStack::Capture(), geckoprofiler::markers::TextMarker{}, ""));
// Marker will be stored in main thread, with stack from registered thread.
EXPECT_TRUE(profiler_add_marker_impl(
"Text from registered thread with stack",
geckoprofiler::category::OTHER,
MarkerOptions(MarkerThreadId::MainThread(), MarkerStack::Capture()),
geckoprofiler::markers::TextMarker{}, ""));
});
registeredThread.join();
std::thread unregisteredThread([]() {
// Marker in unregistered thread won't be stored.
EXPECT_FALSE(profiler_add_marker_impl(
"Text in unregistered thread with stack",
geckoprofiler::category::OTHER, MarkerStack::Capture(),
geckoprofiler::markers::TextMarker{}, ""));
// Marker will be stored in main thread, but stack cannot be captured in an
// unregistered thread.
EXPECT_TRUE(profiler_add_marker_impl(
"Text from unregistered thread with stack",
geckoprofiler::category::OTHER,
MarkerOptions(MarkerThreadId::MainThread(), MarkerStack::Capture()),
geckoprofiler::markers::TextMarker{}, ""));
});
unregisteredThread.join();
EXPECT_TRUE(
profiler_add_marker_impl("Tracing", geckoprofiler::category::OTHER, {},
geckoprofiler::markers::Tracing{}, "category"));
EXPECT_TRUE(profiler_add_marker_impl("Text", geckoprofiler::category::OTHER,
{}, geckoprofiler::markers::TextMarker{},
"Text text"));
// Ensure that we evaluate to false for markers with very long texts by
// testing against a ~3mb string. A string of this size should exceed the
// available buffer chunks (max: 2) that are available and be discarded.
EXPECT_FALSE(profiler_add_marker_impl(
"Text", geckoprofiler::category::OTHER, {},
geckoprofiler::markers::TextMarker{}, std::string(3 * 1024 * 1024, 'x')));
EXPECT_TRUE(profiler_add_marker_impl(
"MediaSample", geckoprofiler::category::OTHER, {},
geckoprofiler::markers::MediaSampleMarker{}, 123, 456, 789));
SpliceableChunkedJSONWriter w{FailureLatchInfallibleSource::Singleton()};
w.Start();
EXPECT_TRUE(::profiler_stream_json_for_this_process(w).isOk());
w.End();
EXPECT_FALSE(w.Failed());
UniquePtr<char[]> profile = w.ChunkedWriteFunc().CopyData();
ASSERT_TRUE(!!profile.get());
// Expected markers, in order.
enum State {
S_tracing_event,
S_tracing_start,
S_tracing_end,
S_tracing_event_with_stack,
S_tracing_auto_tracing_start,
S_tracing_auto_tracing_end,
S_M1,
S_M3,
S_Markers2DefaultEmptyOptions,
S_Markers2DefaultWithOptions,
S_Markers2ExplicitDefaultEmptyOptions,
S_Markers2ExplicitDefaultWithOptions,
S_FirstMarker,
S_CustomMarker,
S_SpecialMarker,
S_NetworkMarkerPayload_start,
S_NetworkMarkerPayload_stop,
S_NetworkMarkerPayload_redirect_temporary,
S_NetworkMarkerPayload_redirect_permanent,
S_NetworkMarkerPayload_redirect_internal,
S_NetworkMarkerPayload_redirect_internal_sts,
S_NetworkMarkerPayload_private_browsing,
S_TextWithStack,
S_TextToMTWithStack,
S_RegThread_TextToMTWithStack,
S_UnregThread_TextToMTWithStack,
S_LAST,
} state = State(0);
// These will be set when first read from S_FirstMarker, then
// compared in following markers.
// TODO: Compute these values from the timestamps.
double ts1Double = 0.0;
double ts2Double = 0.0;
JSONOutputCheck(profile.get(), [&](const Json::Value& root) {
{
GET_JSON(threads, root["threads"], Array);
ASSERT_EQ(threads.size(), 1u);
{
GET_JSON(thread0, threads[0], Object);
// Keep a reference to the string table in this block, it will be used
// below.
GET_JSON(stringTable, thread0["stringTable"], Array);
ASSERT_TRUE(stringTable.isArray());
// Test the expected labels in the string table.
bool foundEmpty = false;
bool foundOkstr1 = false;
bool foundOkstr2 = false;
const std::string okstr2Label = std::string("okstr2 ") + okstr2.get();
bool foundTooLong = false;
for (const auto& s : stringTable) {
ASSERT_TRUE(s.isString());
std::string sString = s.asString();
if (sString.empty()) {
EXPECT_FALSE(foundEmpty);
foundEmpty = true;
} else if (sString == okstr1.get()) {
EXPECT_FALSE(foundOkstr1);
foundOkstr1 = true;
} else if (sString == okstr2Label) {
EXPECT_FALSE(foundOkstr2);
foundOkstr2 = true;
} else if (sString == longstrCut.get()) {
EXPECT_FALSE(foundTooLong);
foundTooLong = true;
} else {
EXPECT_NE(sString, longstr.get());
}
}
EXPECT_TRUE(foundEmpty);
EXPECT_TRUE(foundOkstr1);
EXPECT_TRUE(foundOkstr2);
EXPECT_TRUE(foundTooLong);
{
GET_JSON(markers, thread0["markers"], Object);
{
GET_JSON(data, markers["data"], Array);
for (const Json::Value& marker : data) {
// Name the indexes into the marker tuple:
// [name, startTime, endTime, phase, category, payload]
const unsigned int NAME = 0u;
const unsigned int START_TIME = 1u;
const unsigned int END_TIME = 2u;
const unsigned int PHASE = 3u;
const unsigned int CATEGORY = 4u;
const unsigned int PAYLOAD = 5u;
const unsigned int PHASE_INSTANT = 0;
const unsigned int PHASE_INTERVAL = 1;
const unsigned int PHASE_START = 2;
const unsigned int PHASE_END = 3;
const unsigned int SIZE_WITHOUT_PAYLOAD = 5u;
const unsigned int SIZE_WITH_PAYLOAD = 6u;
ASSERT_TRUE(marker.isArray());
// The payload is optional.
ASSERT_GE(marker.size(), SIZE_WITHOUT_PAYLOAD);
ASSERT_LE(marker.size(), SIZE_WITH_PAYLOAD);
// root.threads[0].markers.data[i] is an array with 5 or 6
// elements.
ASSERT_TRUE(marker[NAME].isUInt()); // name id
GET_JSON(name, stringTable[marker[NAME].asUInt()], String);
std::string nameString = name.asString();
EXPECT_TRUE(marker[START_TIME].isNumeric());
EXPECT_TRUE(marker[END_TIME].isNumeric());
EXPECT_TRUE(marker[PHASE].isUInt());
EXPECT_TRUE(marker[PHASE].asUInt() < 4);
EXPECT_TRUE(marker[CATEGORY].isUInt());
# define EXPECT_TIMING_INSTANT \
EXPECT_NE(marker[START_TIME].asDouble(), 0); \
EXPECT_EQ(marker[END_TIME].asDouble(), 0); \
EXPECT_EQ(marker[PHASE].asUInt(), PHASE_INSTANT);
# define EXPECT_TIMING_INTERVAL \
EXPECT_NE(marker[START_TIME].asDouble(), 0); \
EXPECT_NE(marker[END_TIME].asDouble(), 0); \
EXPECT_EQ(marker[PHASE].asUInt(), PHASE_INTERVAL);
# define EXPECT_TIMING_START \
EXPECT_NE(marker[START_TIME].asDouble(), 0); \
EXPECT_EQ(marker[END_TIME].asDouble(), 0); \
EXPECT_EQ(marker[PHASE].asUInt(), PHASE_START);
# define EXPECT_TIMING_END \
EXPECT_EQ(marker[START_TIME].asDouble(), 0); \
EXPECT_NE(marker[END_TIME].asDouble(), 0); \
EXPECT_EQ(marker[PHASE].asUInt(), PHASE_END);
# define EXPECT_TIMING_INSTANT_AT(t) \
EXPECT_EQ(marker[START_TIME].asDouble(), t); \
EXPECT_EQ(marker[END_TIME].asDouble(), 0); \
EXPECT_EQ(marker[PHASE].asUInt(), PHASE_INSTANT);
# define EXPECT_TIMING_INTERVAL_AT(start, end) \
EXPECT_EQ(marker[START_TIME].asDouble(), start); \
EXPECT_EQ(marker[END_TIME].asDouble(), end); \
EXPECT_EQ(marker[PHASE].asUInt(), PHASE_INTERVAL);
# define EXPECT_TIMING_START_AT(start) \
EXPECT_EQ(marker[START_TIME].asDouble(), start); \
EXPECT_EQ(marker[END_TIME].asDouble(), 0); \
EXPECT_EQ(marker[PHASE].asUInt(), PHASE_START);
# define EXPECT_TIMING_END_AT(end) \
EXPECT_EQ(marker[START_TIME].asDouble(), 0); \
EXPECT_EQ(marker[END_TIME].asDouble(), end); \
EXPECT_EQ(marker[PHASE].asUInt(), PHASE_END);
if (marker.size() == SIZE_WITHOUT_PAYLOAD) {
// root.threads[0].markers.data[i] is an array with 5 elements,
// so there is no payload.
if (nameString == "M1") {
ASSERT_EQ(state, S_M1);
state = State(state + 1);
} else if (nameString == "M3") {
ASSERT_EQ(state, S_M3);
state = State(state + 1);
} else if (nameString ==
"default-templated markers 2.0 with empty options") {
EXPECT_EQ(state, S_Markers2DefaultEmptyOptions);
state = State(S_Markers2DefaultEmptyOptions + 1);
// TODO: Re-enable this when bug 1646714 lands, and check for stack.
# if 0
} else if (nameString ==
"default-templated markers 2.0 with option") {
EXPECT_EQ(state, S_Markers2DefaultWithOptions);
state = State(S_Markers2DefaultWithOptions + 1);
# endif
} else if (nameString ==
"explicitly-default-templated markers 2.0 with "
"empty "
"options") {
EXPECT_EQ(state, S_Markers2ExplicitDefaultEmptyOptions);
state = State(S_Markers2ExplicitDefaultEmptyOptions + 1);
} else if (nameString ==
"explicitly-default-templated markers 2.0 with "
"option") {
EXPECT_EQ(state, S_Markers2ExplicitDefaultWithOptions);
state = State(S_Markers2ExplicitDefaultWithOptions + 1);
}
} else {
// root.threads[0].markers.data[i] is an array with 6 elements,
// so there is a payload.
GET_JSON(payload, marker[PAYLOAD], Object);
// root.threads[0].markers.data[i][PAYLOAD] is an object
// (payload).
// It should at least have a "type" string.
GET_JSON(type, payload["type"], String);
std::string typeString = type.asString();
if (nameString == "tracing event") {
EXPECT_EQ(state, S_tracing_event);
state = State(S_tracing_event + 1);
EXPECT_EQ(typeString, "tracing");
EXPECT_TIMING_INSTANT;
EXPECT_EQ_JSON(payload["category"], String, "A");
EXPECT_TRUE(payload["stack"].isNull());
} else if (nameString == "tracing start") {
EXPECT_EQ(state, S_tracing_start);
state = State(S_tracing_start + 1);
EXPECT_EQ(typeString, "tracing");
EXPECT_TIMING_START;
EXPECT_EQ_JSON(payload["category"], String, "A");
EXPECT_TRUE(payload["stack"].isNull());
} else if (nameString == "tracing end") {
EXPECT_EQ(state, S_tracing_end);
state = State(S_tracing_end + 1);
EXPECT_EQ(typeString, "tracing");
EXPECT_TIMING_END;
EXPECT_EQ_JSON(payload["category"], String, "A");
EXPECT_TRUE(payload["stack"].isNull());
} else if (nameString == "tracing event with stack") {
EXPECT_EQ(state, S_tracing_event_with_stack);
state = State(S_tracing_event_with_stack + 1);
EXPECT_EQ(typeString, "tracing");
EXPECT_TIMING_INSTANT;
EXPECT_EQ_JSON(payload["category"], String, "B");
EXPECT_TRUE(payload["stack"].isObject());
} else if (nameString == "auto tracing") {
switch (state) {
case S_tracing_auto_tracing_start:
state = State(S_tracing_auto_tracing_start + 1);
EXPECT_EQ(typeString, "tracing");
EXPECT_TIMING_START;
EXPECT_EQ_JSON(payload["category"], String, "C");
EXPECT_TRUE(payload["stack"].isNull());
break;
case S_tracing_auto_tracing_end:
state = State(S_tracing_auto_tracing_end + 1);
EXPECT_EQ(typeString, "tracing");
EXPECT_TIMING_END;
EXPECT_EQ_JSON(payload["category"], String, "C");
ASSERT_TRUE(payload["stack"].isNull());
break;
default:
EXPECT_TRUE(state == S_tracing_auto_tracing_start ||
state == S_tracing_auto_tracing_end);
break;
}
} else if (nameString ==
"default-templated markers 2.0 with option") {
// TODO: Remove this when bug 1646714 lands.
EXPECT_EQ(state, S_Markers2DefaultWithOptions);
state = State(S_Markers2DefaultWithOptions + 1);
EXPECT_EQ(typeString, "NoPayloadUserData");
EXPECT_FALSE(payload["stack"].isNull());
} else if (nameString == "FirstMarker") {
// Record start and end times, to compare with timestamps in
// following markers.
EXPECT_EQ(state, S_FirstMarker);
ts1Double = marker[START_TIME].asDouble();
ts2Double = marker[END_TIME].asDouble();
state = State(S_FirstMarker + 1);
EXPECT_EQ(typeString, "Text");
EXPECT_EQ_JSON(payload["name"], String, "First Marker");
} else if (nameString == "Gtest custom marker") {
EXPECT_EQ(state, S_CustomMarker);
state = State(S_CustomMarker + 1);
EXPECT_EQ(typeString, "markers-gtest");
EXPECT_EQ(payload.size(), 1u + 9u);
EXPECT_TRUE(payload["null"].isNull());
EXPECT_EQ_JSON(payload["bool-false"], Bool, false);
EXPECT_EQ_JSON(payload["bool-true"], Bool, true);
EXPECT_EQ_JSON(payload["int"], Int64, 42);
EXPECT_EQ_JSON(payload["double"], Double, 43.0);
EXPECT_EQ_JSON(payload["text"], String, "gtest text");
// Unique strings can be fetched from the string table.
ASSERT_TRUE(payload["unique text"].isUInt());
auto textIndex = payload["unique text"].asUInt();
GET_JSON(uniqueText, stringTable[textIndex], String);
ASSERT_TRUE(uniqueText.isString());
ASSERT_EQ(uniqueText.asString(), "gtest unique text");
// The duplicate unique text should have the exact same index.
EXPECT_EQ_JSON(payload["unique text again"], UInt, textIndex);
EXPECT_EQ_JSON(payload["time"], Double, ts1Double);
} else if (nameString == "Gtest special marker") {
EXPECT_EQ(state, S_SpecialMarker);
state = State(S_SpecialMarker + 1);
EXPECT_EQ(typeString, "markers-gtest-special");
EXPECT_EQ(payload.size(), 1u) << "Only 'type' in the payload";
} else if (nameString == "Load 1: http://mozilla.org/") {
EXPECT_EQ(state, S_NetworkMarkerPayload_start);
state = State(S_NetworkMarkerPayload_start + 1);
EXPECT_EQ(typeString, "Network");
EXPECT_EQ_JSON(payload["startTime"], Double, ts1Double);
EXPECT_EQ_JSON(payload["endTime"], Double, ts2Double);
EXPECT_EQ_JSON(payload["id"], Int64, 1);
EXPECT_EQ_JSON(payload["URI"], String, "http://mozilla.org/");
EXPECT_EQ_JSON(payload["requestMethod"], String, "GET");
EXPECT_EQ_JSON(payload["pri"], Int64, 34);
EXPECT_EQ_JSON(payload["count"], Int64, 56);
EXPECT_EQ_JSON(payload["cache"], String, "Hit");
EXPECT_TRUE(payload["isPrivateBrowsing"].isNull());
EXPECT_TRUE(payload["RedirectURI"].isNull());
EXPECT_TRUE(payload["redirectType"].isNull());
EXPECT_TRUE(payload["isHttpToHttpsRedirect"].isNull());
EXPECT_TRUE(payload["redirectId"].isNull());
EXPECT_TRUE(payload["contentType"].isNull());
} else if (nameString == "Load 2: http://mozilla.org/") {
EXPECT_EQ(state, S_NetworkMarkerPayload_stop);
state = State(S_NetworkMarkerPayload_stop + 1);
EXPECT_EQ(typeString, "Network");
EXPECT_EQ_JSON(payload["startTime"], Double, ts1Double);
EXPECT_EQ_JSON(payload["endTime"], Double, ts2Double);
EXPECT_EQ_JSON(payload["id"], Int64, 2);
EXPECT_EQ_JSON(payload["URI"], String, "http://mozilla.org/");
EXPECT_EQ_JSON(payload["requestMethod"], String, "GET");
EXPECT_EQ_JSON(payload["pri"], Int64, 34);
EXPECT_EQ_JSON(payload["count"], Int64, 56);
EXPECT_EQ_JSON(payload["cache"], String, "Unresolved");
EXPECT_TRUE(payload["isPrivateBrowsing"].isNull());
EXPECT_TRUE(payload["RedirectURI"].isNull());
EXPECT_TRUE(payload["redirectType"].isNull());
EXPECT_TRUE(payload["isHttpToHttpsRedirect"].isNull());
EXPECT_TRUE(payload["redirectId"].isNull());
EXPECT_EQ_JSON(payload["contentType"], String, "text/html");
} else if (nameString == "Load 3: http://mozilla.org/") {
EXPECT_EQ(state, S_NetworkMarkerPayload_redirect_temporary);
state = State(S_NetworkMarkerPayload_redirect_temporary + 1);
EXPECT_EQ(typeString, "Network");
EXPECT_EQ_JSON(payload["startTime"], Double, ts1Double);
EXPECT_EQ_JSON(payload["endTime"], Double, ts2Double);
EXPECT_EQ_JSON(payload["id"], Int64, 3);
EXPECT_EQ_JSON(payload["URI"], String, "http://mozilla.org/");
EXPECT_EQ_JSON(payload["requestMethod"], String, "GET");
EXPECT_EQ_JSON(payload["pri"], Int64, 34);
EXPECT_EQ_JSON(payload["count"], Int64, 56);
EXPECT_EQ_JSON(payload["cache"], String, "Unresolved");
EXPECT_TRUE(payload["isPrivateBrowsing"].isNull());
EXPECT_EQ_JSON(payload["RedirectURI"], String,
"http://example.com/");
EXPECT_EQ_JSON(payload["redirectType"], String, "Temporary");
EXPECT_EQ_JSON(payload["isHttpToHttpsRedirect"], Bool, false);
EXPECT_EQ_JSON(payload["redirectId"], Int64, 103);
EXPECT_TRUE(payload["contentType"].isNull());
} else if (nameString == "Load 4: http://mozilla.org/") {
EXPECT_EQ(state, S_NetworkMarkerPayload_redirect_permanent);
state = State(S_NetworkMarkerPayload_redirect_permanent + 1);
EXPECT_EQ(typeString, "Network");
EXPECT_EQ_JSON(payload["startTime"], Double, ts1Double);
EXPECT_EQ_JSON(payload["endTime"], Double, ts2Double);
EXPECT_EQ_JSON(payload["id"], Int64, 4);
EXPECT_EQ_JSON(payload["URI"], String, "http://mozilla.org/");
EXPECT_EQ_JSON(payload["requestMethod"], String, "GET");
EXPECT_EQ_JSON(payload["pri"], Int64, 34);
EXPECT_EQ_JSON(payload["count"], Int64, 56);
EXPECT_EQ_JSON(payload["cache"], String, "Unresolved");
EXPECT_TRUE(payload["isPrivateBrowsing"].isNull());
EXPECT_EQ_JSON(payload["RedirectURI"], String,
"http://example.com/");
EXPECT_EQ_JSON(payload["redirectType"], String, "Permanent");
EXPECT_EQ_JSON(payload["isHttpToHttpsRedirect"], Bool, false);
EXPECT_EQ_JSON(payload["redirectId"], Int64, 104);
EXPECT_TRUE(payload["contentType"].isNull());
} else if (nameString == "Load 5: http://mozilla.org/") {
EXPECT_EQ(state, S_NetworkMarkerPayload_redirect_internal);
state = State(S_NetworkMarkerPayload_redirect_internal + 1);
EXPECT_EQ(typeString, "Network");
EXPECT_EQ_JSON(payload["startTime"], Double, ts1Double);
EXPECT_EQ_JSON(payload["endTime"], Double, ts2Double);
EXPECT_EQ_JSON(payload["id"], Int64, 5);
EXPECT_EQ_JSON(payload["URI"], String, "http://mozilla.org/");
EXPECT_EQ_JSON(payload["requestMethod"], String, "GET");
EXPECT_EQ_JSON(payload["pri"], Int64, 34);
EXPECT_EQ_JSON(payload["count"], Int64, 56);
EXPECT_EQ_JSON(payload["cache"], String, "Unresolved");
EXPECT_TRUE(payload["isPrivateBrowsing"].isNull());
EXPECT_EQ_JSON(payload["RedirectURI"], String,
"http://example.com/");
EXPECT_EQ_JSON(payload["redirectType"], String, "Internal");
EXPECT_EQ_JSON(payload["isHttpToHttpsRedirect"], Bool, false);
EXPECT_EQ_JSON(payload["redirectId"], Int64, 105);
EXPECT_TRUE(payload["contentType"].isNull());
} else if (nameString == "Load 6: http://mozilla.org/") {
EXPECT_EQ(state,
S_NetworkMarkerPayload_redirect_internal_sts);
state =
State(S_NetworkMarkerPayload_redirect_internal_sts + 1);
EXPECT_EQ(typeString, "Network");
EXPECT_EQ_JSON(payload["startTime"], Double, ts1Double);
EXPECT_EQ_JSON(payload["endTime"], Double, ts2Double);
EXPECT_EQ_JSON(payload["id"], Int64, 6);
EXPECT_EQ_JSON(payload["URI"], String, "http://mozilla.org/");
EXPECT_EQ_JSON(payload["requestMethod"], String, "GET");
EXPECT_EQ_JSON(payload["pri"], Int64, 34);
EXPECT_EQ_JSON(payload["count"], Int64, 56);
EXPECT_EQ_JSON(payload["cache"], String, "Unresolved");
EXPECT_TRUE(payload["isPrivateBrowsing"].isNull());
EXPECT_EQ_JSON(payload["RedirectURI"], String,
"http://example.com/");
EXPECT_EQ_JSON(payload["redirectType"], String, "Internal");
EXPECT_EQ_JSON(payload["isHttpToHttpsRedirect"], Bool, true);
EXPECT_EQ_JSON(payload["redirectId"], Int64, 106);
EXPECT_TRUE(payload["contentType"].isNull());
} else if (nameString == "Load 7: http://mozilla.org/") {
EXPECT_EQ(state, S_NetworkMarkerPayload_private_browsing);
state = State(S_NetworkMarkerPayload_private_browsing + 1);
EXPECT_EQ(typeString, "Network");
EXPECT_EQ_JSON(payload["startTime"], Double, ts1Double);
EXPECT_EQ_JSON(payload["endTime"], Double, ts2Double);
EXPECT_EQ_JSON(payload["id"], Int64, 7);
EXPECT_EQ_JSON(payload["URI"], String, "http://mozilla.org/");
EXPECT_EQ_JSON(payload["requestMethod"], String, "GET");
EXPECT_EQ_JSON(payload["pri"], Int64, 34);
EXPECT_EQ_JSON(payload["count"], Int64, 56);
EXPECT_EQ_JSON(payload["cache"], String, "Unresolved");
EXPECT_EQ_JSON(payload["isPrivateBrowsing"], Bool, true);
EXPECT_TRUE(payload["RedirectURI"].isNull());
EXPECT_TRUE(payload["redirectType"].isNull());
EXPECT_TRUE(payload["isHttpToHttpsRedirect"].isNull());
EXPECT_TRUE(payload["redirectId"].isNull());
EXPECT_TRUE(payload["contentType"].isNull());
} else if (nameString == "Text in main thread with stack") {
EXPECT_EQ(state, S_TextWithStack);
state = State(S_TextWithStack + 1);
EXPECT_EQ(typeString, "Text");
EXPECT_FALSE(payload["stack"].isNull());
EXPECT_TIMING_INTERVAL_AT(ts1Double, ts2Double);
EXPECT_EQ_JSON(payload["name"], String, "");
} else if (nameString == "Text from main thread with stack") {
EXPECT_EQ(state, S_TextToMTWithStack);
state = State(S_TextToMTWithStack + 1);
EXPECT_EQ(typeString, "Text");
EXPECT_FALSE(payload["stack"].isNull());
EXPECT_EQ_JSON(payload["name"], String, "");
} else if (nameString ==
"Text in registered thread with stack") {
ADD_FAILURE()
<< "Unexpected 'Text in registered thread with stack'";
} else if (nameString ==
"Text from registered thread with stack") {
EXPECT_EQ(state, S_RegThread_TextToMTWithStack);
state = State(S_RegThread_TextToMTWithStack + 1);
EXPECT_EQ(typeString, "Text");
EXPECT_FALSE(payload["stack"].isNull());
EXPECT_EQ_JSON(payload["name"], String, "");
} else if (nameString ==
"Text in unregistered thread with stack") {
ADD_FAILURE()
<< "Unexpected 'Text in unregistered thread with stack'";
} else if (nameString ==
"Text from unregistered thread with stack") {
EXPECT_EQ(state, S_UnregThread_TextToMTWithStack);
state = State(S_UnregThread_TextToMTWithStack + 1);
EXPECT_EQ(typeString, "Text");
EXPECT_TRUE(payload["stack"].isNull());
EXPECT_EQ_JSON(payload["name"], String, "");
}
} // marker with payload
} // for (marker : data)
} // markers.data
} // markers
} // thread0
} // threads
// We should have read all expected markers.
EXPECT_EQ(state, S_LAST);
{
GET_JSON(meta, root["meta"], Object);
{
GET_JSON(markerSchema, meta["markerSchema"], Array);
std::set<std::string> testedSchemaNames;
for (const Json::Value& schema : markerSchema) {
GET_JSON(name, schema["name"], String);
const std::string nameString = name.asString();
GET_JSON(display, schema["display"], Array);
GET_JSON(data, schema["data"], Array);
EXPECT_TRUE(
testedSchemaNames
.insert(std::string(nameString.data(), nameString.size()))
.second)
<< "Each schema name should be unique (inserted once in the set)";
if (nameString == "Text") {
EXPECT_EQ(display.size(), 2u);
EXPECT_EQ(display[0u].asString(), "marker-chart");
EXPECT_EQ(display[1u].asString(), "marker-table");
ASSERT_EQ(data.size(), 2u);
ASSERT_TRUE(data[0u].isObject());
EXPECT_EQ_JSON(data[0u]["key"], String, "name");
EXPECT_EQ_JSON(data[0u]["label"], String, "Details");
EXPECT_EQ_JSON(data[0u]["format"], String, "string");
EXPECT_EQ_JSON(data[1u]["label"], String, "Description");
EXPECT_EQ_JSON(data[1u]["value"], String, "Generic text marker");
} else if (nameString == "NoPayloadUserData") {
// TODO: Remove this when bug 1646714 lands.
EXPECT_EQ(display.size(), 2u);
EXPECT_EQ(display[0u].asString(), "marker-chart");
EXPECT_EQ(display[1u].asString(), "marker-table");
ASSERT_EQ(data.size(), 0u);
} else if (nameString == "FileIO") {
// These are defined in ProfilerIOInterposeObserver.cpp
} else if (nameString == "tracing") {
EXPECT_EQ(display.size(), 3u);
EXPECT_EQ(display[0u].asString(), "marker-chart");
EXPECT_EQ(display[1u].asString(), "marker-table");
EXPECT_EQ(display[2u].asString(), "timeline-overview");
ASSERT_EQ(data.size(), 2u);
ASSERT_TRUE(data[0u].isObject());
EXPECT_EQ_JSON(data[0u]["key"], String, "category");
EXPECT_EQ_JSON(data[0u]["label"], String, "Type");
EXPECT_EQ_JSON(data[0u]["format"], String, "string");
EXPECT_EQ_JSON(data[1u]["label"], String, "Description");
EXPECT_EQ_JSON(data[1u]["value"], String, "Generic tracing marker");
} else if (nameString == "BHR-detected hang") {
EXPECT_EQ(display.size(), 2u);
EXPECT_EQ(display[0u].asString(), "marker-chart");
EXPECT_EQ(display[1u].asString(), "marker-table");
ASSERT_EQ(data.size(), 0u);
} else if (nameString == "MainThreadLongTask") {
EXPECT_EQ(display.size(), 2u);
EXPECT_EQ(display[0u].asString(), "marker-chart");
EXPECT_EQ(display[1u].asString(), "marker-table");
ASSERT_EQ(data.size(), 1u);
ASSERT_TRUE(data[0u].isObject());
EXPECT_EQ_JSON(data[0u]["key"], String, "category");
EXPECT_EQ_JSON(data[0u]["label"], String, "Type");
EXPECT_EQ_JSON(data[0u]["format"], String, "string");
} else if (nameString == "Log") {
EXPECT_EQ(display.size(), 1u);
EXPECT_EQ(display[0u].asString(), "marker-table");
ASSERT_EQ(data.size(), 2u);
ASSERT_TRUE(data[0u].isObject());
EXPECT_EQ_JSON(data[0u]["key"], String, "module");
EXPECT_EQ_JSON(data[0u]["label"], String, "Module");
EXPECT_EQ_JSON(data[0u]["format"], String, "string");
ASSERT_TRUE(data[1u].isObject());
EXPECT_EQ_JSON(data[1u]["key"], String, "name");
EXPECT_EQ_JSON(data[1u]["label"], String, "Name");
EXPECT_EQ_JSON(data[1u]["format"], String, "string");
} else if (nameString == "MediaSample") {
EXPECT_EQ(display.size(), 2u);
EXPECT_EQ(display[0u].asString(), "marker-chart");
EXPECT_EQ(display[1u].asString(), "marker-table");
ASSERT_EQ(data.size(), 3u);
ASSERT_TRUE(data[0u].isObject());
EXPECT_EQ_JSON(data[0u]["key"], String, "sampleStartTimeUs");
EXPECT_EQ_JSON(data[0u]["label"], String, "Sample start time");
EXPECT_EQ_JSON(data[0u]["format"], String, "microseconds");
ASSERT_TRUE(data[1u].isObject());
EXPECT_EQ_JSON(data[1u]["key"], String, "sampleEndTimeUs");
EXPECT_EQ_JSON(data[1u]["label"], String, "Sample end time");
EXPECT_EQ_JSON(data[1u]["format"], String, "microseconds");
ASSERT_TRUE(data[2u].isObject());
EXPECT_EQ_JSON(data[2u]["key"], String, "queueLength");
EXPECT_EQ_JSON(data[2u]["label"], String, "Queue length");
EXPECT_EQ_JSON(data[2u]["format"], String, "integer");
} else if (nameString == "VideoFallingBehind") {
EXPECT_EQ(display.size(), 2u);
EXPECT_EQ(display[0u].asString(), "marker-chart");
EXPECT_EQ(display[1u].asString(), "marker-table");
ASSERT_EQ(data.size(), 2u);
ASSERT_TRUE(data[0u].isObject());
EXPECT_EQ_JSON(data[0u]["key"], String, "videoFrameStartTimeUs");
EXPECT_EQ_JSON(data[0u]["label"], String, "Video frame start time");
EXPECT_EQ_JSON(data[0u]["format"], String, "microseconds");
ASSERT_TRUE(data[1u].isObject());
EXPECT_EQ_JSON(data[1u]["key"], String, "mediaCurrentTimeUs");
EXPECT_EQ_JSON(data[1u]["label"], String, "Media current time");
EXPECT_EQ_JSON(data[1u]["format"], String, "microseconds");
} else if (nameString == "Budget") {
EXPECT_EQ(display.size(), 2u);
EXPECT_EQ(display[0u].asString(), "marker-chart");
EXPECT_EQ(display[1u].asString(), "marker-table");
ASSERT_EQ(data.size(), 0u);
} else if (nameString == "markers-gtest") {
EXPECT_EQ(display.size(), 7u);
EXPECT_EQ(display[0u].asString(), "marker-chart");
EXPECT_EQ(display[1u].asString(), "marker-table");
EXPECT_EQ(display[2u].asString(), "timeline-overview");
EXPECT_EQ(display[3u].asString(), "timeline-memory");
EXPECT_EQ(display[4u].asString(), "timeline-ipc");
EXPECT_EQ(display[5u].asString(), "timeline-fileio");
EXPECT_EQ(display[6u].asString(), "stack-chart");
EXPECT_EQ_JSON(schema["chartLabel"], String, "chart label");
EXPECT_EQ_JSON(schema["tooltipLabel"], String, "tooltip label");
EXPECT_EQ_JSON(schema["tableLabel"], String, "table label");
ASSERT_EQ(data.size(), 16u);
ASSERT_TRUE(data[0u].isObject());
EXPECT_EQ_JSON(data[0u]["key"], String, "key with url");
EXPECT_TRUE(data[0u]["label"].isNull());
EXPECT_EQ_JSON(data[0u]["format"], String, "url");
EXPECT_TRUE(data[0u]["searchable"].isNull());
ASSERT_TRUE(data[1u].isObject());
EXPECT_EQ_JSON(data[1u]["key"], String, "key with label filePath");
EXPECT_EQ_JSON(data[1u]["label"], String, "label filePath");
EXPECT_EQ_JSON(data[1u]["format"], String, "file-path");
EXPECT_TRUE(data[1u]["searchable"].isNull());
ASSERT_TRUE(data[2u].isObject());
EXPECT_EQ_JSON(data[2u]["key"], String,
"key with string not-searchable");
EXPECT_TRUE(data[2u]["label"].isNull());
EXPECT_EQ_JSON(data[2u]["format"], String, "string");
EXPECT_EQ_JSON(data[2u]["searchable"], Bool, false);
ASSERT_TRUE(data[3u].isObject());
EXPECT_EQ_JSON(data[3u]["key"], String,
"key with label duration searchable");
EXPECT_TRUE(data[3u]["label duration"].isNull());
EXPECT_EQ_JSON(data[3u]["format"], String, "duration");
EXPECT_EQ_JSON(data[3u]["searchable"], Bool, true);
ASSERT_TRUE(data[4u].isObject());
EXPECT_EQ_JSON(data[4u]["key"], String, "key with time");
EXPECT_TRUE(data[4u]["label"].isNull());
EXPECT_EQ_JSON(data[4u]["format"], String, "time");
EXPECT_TRUE(data[4u]["searchable"].isNull());
ASSERT_TRUE(data[5u].isObject());
EXPECT_EQ_JSON(data[5u]["key"], String, "key with seconds");
EXPECT_TRUE(data[5u]["label"].isNull());
EXPECT_EQ_JSON(data[5u]["format"], String, "seconds");
EXPECT_TRUE(data[5u]["searchable"].isNull());
ASSERT_TRUE(data[6u].isObject());
EXPECT_EQ_JSON(data[6u]["key"], String, "key with milliseconds");
EXPECT_TRUE(data[6u]["label"].isNull());
EXPECT_EQ_JSON(data[6u]["format"], String, "milliseconds");
EXPECT_TRUE(data[6u]["searchable"].isNull());
ASSERT_TRUE(data[7u].isObject());
EXPECT_EQ_JSON(data[7u]["key"], String, "key with microseconds");
EXPECT_TRUE(data[7u]["label"].isNull());
EXPECT_EQ_JSON(data[7u]["format"], String, "microseconds");
EXPECT_TRUE(data[7u]["searchable"].isNull());
ASSERT_TRUE(data[8u].isObject());
EXPECT_EQ_JSON(data[8u]["key"], String, "key with nanoseconds");
EXPECT_TRUE(data[8u]["label"].isNull());
EXPECT_EQ_JSON(data[8u]["format"], String, "nanoseconds");
EXPECT_TRUE(data[8u]["searchable"].isNull());
ASSERT_TRUE(data[9u].isObject());
EXPECT_EQ_JSON(data[9u]["key"], String, "key with bytes");
EXPECT_TRUE(data[9u]["label"].isNull());
EXPECT_EQ_JSON(data[9u]["format"], String, "bytes");
EXPECT_TRUE(data[9u]["searchable"].isNull());
ASSERT_TRUE(data[10u].isObject());
EXPECT_EQ_JSON(data[10u]["key"], String, "key with percentage");
EXPECT_TRUE(data[10u]["label"].isNull());
EXPECT_EQ_JSON(data[10u]["format"], String, "percentage");
EXPECT_TRUE(data[10u]["searchable"].isNull());
ASSERT_TRUE(data[11u].isObject());
EXPECT_EQ_JSON(data[11u]["key"], String, "key with integer");
EXPECT_TRUE(data[11u]["label"].isNull());
EXPECT_EQ_JSON(data[11u]["format"], String, "integer");
EXPECT_TRUE(data[11u]["searchable"].isNull());
ASSERT_TRUE(data[12u].isObject());
EXPECT_EQ_JSON(data[12u]["key"], String, "key with decimal");
EXPECT_TRUE(data[12u]["label"].isNull());
EXPECT_EQ_JSON(data[12u]["format"], String, "decimal");
EXPECT_TRUE(data[12u]["searchable"].isNull());
ASSERT_TRUE(data[13u].isObject());
EXPECT_EQ_JSON(data[13u]["label"], String, "static label");
EXPECT_EQ_JSON(data[13u]["value"], String, "static value");
ASSERT_TRUE(data[14u].isObject());
EXPECT_EQ_JSON(data[14u]["key"], String, "key with unique string");
EXPECT_TRUE(data[14u]["label"].isNull());
EXPECT_EQ_JSON(data[14u]["format"], String, "unique-string");
EXPECT_TRUE(data[14u]["searchable"].isNull());
ASSERT_TRUE(data[15u].isObject());
EXPECT_EQ_JSON(data[15u]["key"], String,
"key with sanitized string");
EXPECT_TRUE(data[15u]["label"].isNull());
EXPECT_EQ_JSON(data[15u]["format"], String, "sanitized-string");
EXPECT_EQ_JSON(data[15u]["searchable"], Bool, true);
} else if (nameString == "markers-gtest-special") {
EXPECT_EQ(display.size(), 0u);
ASSERT_EQ(data.size(), 0u);
} else if (nameString == "markers-gtest-unused") {
ADD_FAILURE() << "Schema for GtestUnusedMarker should not be here";
} else {
printf("FYI: Unknown marker schema '%s'\n", nameString.c_str());
}
}
// Check that we've got all expected schema.
EXPECT_TRUE(testedSchemaNames.find("Text") != testedSchemaNames.end());
EXPECT_TRUE(testedSchemaNames.find("tracing") !=
testedSchemaNames.end());
EXPECT_TRUE(testedSchemaNames.find("MediaSample") !=
testedSchemaNames.end());
} // markerSchema
} // meta
});
Maybe<ProfilerBufferInfo> info = profiler_get_buffer_info();
EXPECT_TRUE(info.isSome());
printf("Profiler buffer range: %llu .. %llu (%llu bytes)\n",
static_cast<unsigned long long>(info->mRangeStart),
static_cast<unsigned long long>(info->mRangeEnd),
// sizeof(ProfileBufferEntry) == 9
(static_cast<unsigned long long>(info->mRangeEnd) -
static_cast<unsigned long long>(info->mRangeStart)) *
9);
printf("Stats: min(us) .. mean(us) .. max(us) [count]\n");
printf("- Intervals: %7.1f .. %7.1f .. %7.1f [%u]\n",
info->mIntervalsUs.min, info->mIntervalsUs.sum / info->mIntervalsUs.n,
info->mIntervalsUs.max, info->mIntervalsUs.n);
printf("- Overheads: %7.1f .. %7.1f .. %7.1f [%u]\n",
info->mOverheadsUs.min, info->mOverheadsUs.sum / info->mOverheadsUs.n,
info->mOverheadsUs.max, info->mOverheadsUs.n);
printf(" - Locking: %7.1f .. %7.1f .. %7.1f [%u]\n",
info->mLockingsUs.min, info->mLockingsUs.sum / info->mLockingsUs.n,
info->mLockingsUs.max, info->mLockingsUs.n);
printf(" - Clearning: %7.1f .. %7.1f .. %7.1f [%u]\n",
info->mCleaningsUs.min, info->mCleaningsUs.sum / info->mCleaningsUs.n,
info->mCleaningsUs.max, info->mCleaningsUs.n);
printf(" - Counters: %7.1f .. %7.1f .. %7.1f [%u]\n",
info->mCountersUs.min, info->mCountersUs.sum / info->mCountersUs.n,
info->mCountersUs.max, info->mCountersUs.n);
printf(" - Threads: %7.1f .. %7.1f .. %7.1f [%u]\n",
info->mThreadsUs.min, info->mThreadsUs.sum / info->mThreadsUs.n,
info->mThreadsUs.max, info->mThreadsUs.n);
profiler_stop();
// Try to add markers while the profiler is stopped.
PROFILER_MARKER_UNTYPED("marker after profiler_stop", OTHER);
// Warning: this could be racy
profiler_start(PROFILER_DEFAULT_ENTRIES, PROFILER_DEFAULT_INTERVAL, features,
filters, MOZ_ARRAY_LENGTH(filters), 0);
// This last marker shouldn't get streamed.
SpliceableChunkedJSONWriter w2{FailureLatchInfallibleSource::Singleton()};
w2.Start();
EXPECT_TRUE(::profiler_stream_json_for_this_process(w2).isOk());
w2.End();
EXPECT_FALSE(w2.Failed());
UniquePtr<char[]> profile2 = w2.ChunkedWriteFunc().CopyData();
ASSERT_TRUE(!!profile2.get());
EXPECT_TRUE(
std::string_view(profile2.get()).find("marker after profiler_stop") ==
std::string_view::npos);
profiler_stop();
}
# define COUNTER_NAME "TestCounter"
# define COUNTER_DESCRIPTION "Test of counters in profiles"
# define COUNTER_NAME2 "Counter2"
# define COUNTER_DESCRIPTION2 "Second Test of counters in profiles"
PROFILER_DEFINE_COUNT_TOTAL(TestCounter, COUNTER_NAME, COUNTER_DESCRIPTION);
PROFILER_DEFINE_COUNT_TOTAL(TestCounter2, COUNTER_NAME2, COUNTER_DESCRIPTION2);
TEST(GeckoProfiler, Counters)
{
uint32_t features = 0;
const char* filters[] = {"GeckoMain"};
// We will record some counter values, and check that they're present (and no
// other) when expected.
struct NumberAndCount {
uint64_t mNumber;
int64_t mCount;
};
int64_t testCounters[] = {10, 7, -17};
NumberAndCount expectedTestCounters[] = {{1u, 10}, {0u, 0}, {1u, 7},
{0u, 0}, {0u, 0}, {1u, -17},
{0u, 0}, {0u, 0}};
constexpr size_t expectedTestCountersCount =
MOZ_ARRAY_LENGTH(expectedTestCounters);
bool expectCounter2 = false;
int64_t testCounters2[] = {10};
NumberAndCount expectedTestCounters2[] = {{1u, 10}, {0u, 0}};
constexpr size_t expectedTestCounters2Count =
MOZ_ARRAY_LENGTH(expectedTestCounters2);
auto checkCountersInJSON = [&](const Json::Value& aRoot) {
size_t nextExpectedTestCounter = 0u;
size_t nextExpectedTestCounter2 = 0u;
GET_JSON(counters, aRoot["counters"], Array);
for (const Json::Value& counter : counters) {
ASSERT_TRUE(counter.isObject());
GET_JSON_VALUE(name, counter["name"], String);
if (name == "TestCounter") {
EXPECT_EQ_JSON(counter["category"], String, COUNTER_NAME);
EXPECT_EQ_JSON(counter["description"], String, COUNTER_DESCRIPTION);
GET_JSON(samples, counter["samples"], Object);
GET_JSON(samplesSchema, samples["schema"], Object);
EXPECT_GE(samplesSchema.size(), 3u);
GET_JSON_VALUE(samplesNumber, samplesSchema["number"], UInt);
GET_JSON_VALUE(samplesCount, samplesSchema["count"], UInt);
GET_JSON(samplesData, samples["data"], Array);
for (const Json::Value& sample : samplesData) {
ASSERT_TRUE(sample.isArray());
ASSERT_LT(nextExpectedTestCounter, expectedTestCountersCount);
EXPECT_EQ_JSON(sample[samplesNumber], UInt64,
expectedTestCounters[nextExpectedTestCounter].mNumber);
EXPECT_EQ_JSON(sample[samplesCount], Int64,
expectedTestCounters[nextExpectedTestCounter].mCount);
++nextExpectedTestCounter;
}
} else if (name == "TestCounter2") {
EXPECT_TRUE(expectCounter2);
EXPECT_EQ_JSON(counter["category"], String, COUNTER_NAME2);
EXPECT_EQ_JSON(counter["description"], String, COUNTER_DESCRIPTION2);
GET_JSON(samples, counter["samples"], Object);
GET_JSON(samplesSchema, samples["schema"], Object);
EXPECT_GE(samplesSchema.size(), 3u);
GET_JSON_VALUE(samplesNumber, samplesSchema["number"], UInt);
GET_JSON_VALUE(samplesCount, samplesSchema["count"], UInt);
GET_JSON(samplesData, samples["data"], Array);
for (const Json::Value& sample : samplesData) {
ASSERT_TRUE(sample.isArray());
ASSERT_LT(nextExpectedTestCounter2, expectedTestCounters2Count);
EXPECT_EQ_JSON(
sample[samplesNumber], UInt64,
expectedTestCounters2[nextExpectedTestCounter2].mNumber);
EXPECT_EQ_JSON(
sample[samplesCount], Int64,
expectedTestCounters2[nextExpectedTestCounter2].mCount);
++nextExpectedTestCounter2;
}
}
}
EXPECT_EQ(nextExpectedTestCounter, expectedTestCountersCount);
if (expectCounter2) {
EXPECT_EQ(nextExpectedTestCounter2, expectedTestCounters2Count);
}
};
// Inactive -> Active
profiler_ensure_started(PROFILER_DEFAULT_ENTRIES, PROFILER_DEFAULT_INTERVAL,
features, filters, MOZ_ARRAY_LENGTH(filters), 0);
// Output all "TestCounter"s, with increasing delays (to test different
// number of counter samplings).
int samplingWaits = 2;
for (int64_t counter : testCounters) {
AUTO_PROFILER_COUNT_TOTAL(TestCounter, counter);
for (int i = 0; i < samplingWaits; ++i) {
ASSERT_EQ(WaitForSamplingState(), SamplingState::SamplingCompleted);
}
++samplingWaits;
}
// Verify we got "TestCounter" in the output, but not "TestCounter2" yet.
UniquePtr<char[]> profile = profiler_get_profile();
JSONOutputCheck(profile.get(), checkCountersInJSON);
// Now introduce TestCounter2.
expectCounter2 = true;
for (int64_t counter2 : testCounters2) {
AUTO_PROFILER_COUNT_TOTAL(TestCounter2, counter2);
ASSERT_EQ(WaitForSamplingState(), SamplingState::SamplingCompleted);
ASSERT_EQ(WaitForSamplingState(), SamplingState::SamplingCompleted);
}
// Verify we got both "TestCounter" and "TestCounter2" in the output.
profile = profiler_get_profile();
JSONOutputCheck(profile.get(), checkCountersInJSON);
profiler_stop();
}
TEST(GeckoProfiler, Time)
{
uint32_t features = ProfilerFeature::StackWalk;
const char* filters[] = {"GeckoMain"};
double t1 = profiler_time();
double t2 = profiler_time();
ASSERT_TRUE(t1 <= t2);
// profiler_start() restarts the timer used by profiler_time().
profiler_start(PROFILER_DEFAULT_ENTRIES, PROFILER_DEFAULT_INTERVAL, features,
filters, MOZ_ARRAY_LENGTH(filters), 0);
double t3 = profiler_time();
double t4 = profiler_time();
ASSERT_TRUE(t3 <= t4);
profiler_stop();
double t5 = profiler_time();
double t6 = profiler_time();
ASSERT_TRUE(t4 <= t5 && t1 <= t6);
}
TEST(GeckoProfiler, GetProfile)
{
uint32_t features = ProfilerFeature::StackWalk;
const char* filters[] = {"GeckoMain"};
ASSERT_TRUE(!profiler_get_profile());
profiler_start(PROFILER_DEFAULT_ENTRIES, PROFILER_DEFAULT_INTERVAL, features,
filters, MOZ_ARRAY_LENGTH(filters), 0);
mozilla::Maybe<uint32_t> activeFeatures = profiler_features_if_active();
ASSERT_TRUE(activeFeatures.isSome());
// Not all platforms support stack-walking.
const bool hasStackWalk = ProfilerFeature::HasStackWalk(*activeFeatures);
UniquePtr<char[]> profile = profiler_get_profile();
JSONOutputCheck(profile.get(), [&](const Json::Value& aRoot) {
GET_JSON(meta, aRoot["meta"], Object);
{
GET_JSON(configuration, meta["configuration"], Object);
{
GET_JSON(features, configuration["features"], Array);
{
EXPECT_EQ(features.size(), (hasStackWalk ? 1u : 0u));
if (hasStackWalk) {
EXPECT_JSON_ARRAY_CONTAINS(features, String, "stackwalk");
}
}
GET_JSON(threads, configuration["threads"], Array);
{
EXPECT_EQ(threads.size(), 1u);
EXPECT_JSON_ARRAY_CONTAINS(threads, String, "GeckoMain");
}
}
}
});
profiler_stop();
ASSERT_TRUE(!profiler_get_profile());
}
TEST(GeckoProfiler, StreamJSONForThisProcess)
{
uint32_t features = ProfilerFeature::StackWalk;
const char* filters[] = {"GeckoMain"};
SpliceableChunkedJSONWriter w{FailureLatchInfallibleSource::Singleton()};
MOZ_RELEASE_ASSERT(!w.ChunkedWriteFunc().Fallible());
MOZ_RELEASE_ASSERT(!w.ChunkedWriteFunc().Failed());
MOZ_RELEASE_ASSERT(!w.ChunkedWriteFunc().GetFailure());
MOZ_RELEASE_ASSERT(&w.ChunkedWriteFunc().SourceFailureLatch() ==
&mozilla::FailureLatchInfallibleSource::Singleton());
MOZ_RELEASE_ASSERT(
&std::as_const(w.ChunkedWriteFunc()).SourceFailureLatch() ==
&mozilla::FailureLatchInfallibleSource::Singleton());
MOZ_RELEASE_ASSERT(!w.Fallible());
MOZ_RELEASE_ASSERT(!w.Failed());
MOZ_RELEASE_ASSERT(!w.GetFailure());
MOZ_RELEASE_ASSERT(&w.SourceFailureLatch() ==
&mozilla::FailureLatchInfallibleSource::Singleton());
MOZ_RELEASE_ASSERT(&std::as_const(w).SourceFailureLatch() ==
&mozilla::FailureLatchInfallibleSource::Singleton());
ASSERT_TRUE(::profiler_stream_json_for_this_process(w).isErr());
MOZ_RELEASE_ASSERT(!w.ChunkedWriteFunc().Failed());
MOZ_RELEASE_ASSERT(!w.ChunkedWriteFunc().GetFailure());
MOZ_RELEASE_ASSERT(!w.Failed());
MOZ_RELEASE_ASSERT(!w.GetFailure());
profiler_start(PROFILER_DEFAULT_ENTRIES, PROFILER_DEFAULT_INTERVAL, features,
filters, MOZ_ARRAY_LENGTH(filters), 0);
w.Start();
ASSERT_TRUE(::profiler_stream_json_for_this_process(w).isOk());
w.End();
MOZ_RELEASE_ASSERT(!w.ChunkedWriteFunc().Failed());
MOZ_RELEASE_ASSERT(!w.ChunkedWriteFunc().GetFailure());
MOZ_RELEASE_ASSERT(!w.Failed());
MOZ_RELEASE_ASSERT(!w.GetFailure());
UniquePtr<char[]> profile = w.ChunkedWriteFunc().CopyData();
JSONOutputCheck(profile.get(), [](const Json::Value&) {});
profiler_stop();
ASSERT_TRUE(::profiler_stream_json_for_this_process(w).isErr());
}
// Internal version of profiler_stream_json_for_this_process, which allows being
// called from a non-main thread of the parent process, at the risk of getting
// an incomplete profile.
ProfilerResult<ProfileGenerationAdditionalInformation>
do_profiler_stream_json_for_this_process(
SpliceableJSONWriter& aWriter, double aSinceTime, bool aIsShuttingDown,
ProfilerCodeAddressService* aService,
mozilla::ProgressLogger aProgressLogger);
TEST(GeckoProfiler, StreamJSONForThisProcessThreaded)
{
// Same as the previous test, but calling some things on background threads.
nsCOMPtr<nsIThread> thread;
nsresult rv = NS_NewNamedThread("GeckoProfGTest", getter_AddRefs(thread));
ASSERT_NS_SUCCEEDED(rv);
uint32_t features = ProfilerFeature::StackWalk;
const char* filters[] = {"GeckoMain"};
SpliceableChunkedJSONWriter w{FailureLatchInfallibleSource::Singleton()};
MOZ_RELEASE_ASSERT(!w.ChunkedWriteFunc().Fallible());
MOZ_RELEASE_ASSERT(!w.ChunkedWriteFunc().Failed());
MOZ_RELEASE_ASSERT(!w.ChunkedWriteFunc().GetFailure());
MOZ_RELEASE_ASSERT(&w.ChunkedWriteFunc().SourceFailureLatch() ==
&mozilla::FailureLatchInfallibleSource::Singleton());
MOZ_RELEASE_ASSERT(
&std::as_const(w.ChunkedWriteFunc()).SourceFailureLatch() ==
&mozilla::FailureLatchInfallibleSource::Singleton());
MOZ_RELEASE_ASSERT(!w.Fallible());
MOZ_RELEASE_ASSERT(!w.Failed());
MOZ_RELEASE_ASSERT(!w.GetFailure());
MOZ_RELEASE_ASSERT(&w.SourceFailureLatch() ==
&mozilla::FailureLatchInfallibleSource::Singleton());
MOZ_RELEASE_ASSERT(&std::as_const(w).SourceFailureLatch() ==
&mozilla::FailureLatchInfallibleSource::Singleton());
ASSERT_TRUE(::profiler_stream_json_for_this_process(w).isErr());
MOZ_RELEASE_ASSERT(!w.ChunkedWriteFunc().Failed());
MOZ_RELEASE_ASSERT(!w.ChunkedWriteFunc().GetFailure());
MOZ_RELEASE_ASSERT(!w.Failed());
MOZ_RELEASE_ASSERT(!w.GetFailure());
// Start the profiler on the main thread.
profiler_start(PROFILER_DEFAULT_ENTRIES, PROFILER_DEFAULT_INTERVAL, features,
filters, MOZ_ARRAY_LENGTH(filters), 0);
// Call profiler_stream_json_for_this_process on a background thread.
NS_DispatchAndSpinEventLoopUntilComplete(
"GeckoProfiler_StreamJSONForThisProcessThreaded_Test::TestBody"_ns,
thread,
NS_NewRunnableFunction(
"GeckoProfiler_StreamJSONForThisProcessThreaded_Test::TestBody",
[&]() {
w.Start();
ASSERT_TRUE(::do_profiler_stream_json_for_this_process(
w, /* double aSinceTime */ 0.0,
/* bool aIsShuttingDown */ false,
/* ProfilerCodeAddressService* aService */ nullptr,
mozilla::ProgressLogger{})
.isOk());
w.End();
}));
MOZ_RELEASE_ASSERT(!w.ChunkedWriteFunc().Failed());
MOZ_RELEASE_ASSERT(!w.ChunkedWriteFunc().GetFailure());
MOZ_RELEASE_ASSERT(!w.Failed());
MOZ_RELEASE_ASSERT(!w.GetFailure());
UniquePtr<char[]> profile = w.ChunkedWriteFunc().CopyData();
JSONOutputCheck(profile.get(), [](const Json::Value&) {});
// Stop the profiler and call profiler_stream_json_for_this_process on a
// background thread.
NS_DispatchAndSpinEventLoopUntilComplete(
"GeckoProfiler_StreamJSONForThisProcessThreaded_Test::TestBody"_ns,
thread,
NS_NewRunnableFunction(
"GeckoProfiler_StreamJSONForThisProcessThreaded_Test::TestBody",
[&]() {
profiler_stop();
ASSERT_TRUE(::do_profiler_stream_json_for_this_process(
w, /* double aSinceTime */ 0.0,
/* bool aIsShuttingDown */ false,
/* ProfilerCodeAddressService* aService */ nullptr,
mozilla::ProgressLogger{})
.isErr());
}));
thread->Shutdown();
// Call profiler_stream_json_for_this_process on the main thread.
ASSERT_TRUE(::profiler_stream_json_for_this_process(w).isErr());
}
TEST(GeckoProfiler, ProfilingStack)
{
uint32_t features = ProfilerFeature::StackWalk;
const char* filters[] = {"GeckoMain"};
AUTO_PROFILER_LABEL("A::B", OTHER);
UniqueFreePtr<char> dynamic(strdup("dynamic"));
{
AUTO_PROFILER_LABEL_DYNAMIC_CSTR("A::C", JS, dynamic.get());
AUTO_PROFILER_LABEL_DYNAMIC_NSCSTRING("A::C2", JS,
nsDependentCString(dynamic.get()));
AUTO_PROFILER_LABEL_DYNAMIC_LOSSY_NSSTRING(
"A::C3", JS, NS_ConvertUTF8toUTF16(dynamic.get()));
profiler_start(PROFILER_DEFAULT_ENTRIES, PROFILER_DEFAULT_INTERVAL,
features, filters, MOZ_ARRAY_LENGTH(filters), 0);
ASSERT_TRUE(profiler_get_backtrace());
}
AutoProfilerLabel label1("A", nullptr, JS::ProfilingCategoryPair::DOM);
AutoProfilerLabel label2("A", dynamic.get(),
JS::ProfilingCategoryPair::NETWORK);
ASSERT_TRUE(profiler_get_backtrace());
profiler_stop();
ASSERT_TRUE(!profiler_get_profile());
}
TEST(GeckoProfiler, Bug1355807)
{
uint32_t features = ProfilerFeature::JS;
const char* manyThreadsFilter[] = {""};
const char* fewThreadsFilter[] = {"GeckoMain"};
profiler_start(PROFILER_DEFAULT_ENTRIES, PROFILER_DEFAULT_INTERVAL, features,
manyThreadsFilter, MOZ_ARRAY_LENGTH(manyThreadsFilter), 0);
profiler_start(PROFILER_DEFAULT_ENTRIES, PROFILER_DEFAULT_INTERVAL, features,
fewThreadsFilter, MOZ_ARRAY_LENGTH(fewThreadsFilter), 0);
// In bug 1355807 this caused an assertion failure in StopJSSampling().
profiler_start(PROFILER_DEFAULT_ENTRIES, PROFILER_DEFAULT_INTERVAL, features,
fewThreadsFilter, MOZ_ARRAY_LENGTH(fewThreadsFilter), 0);
profiler_stop();
}
class GTestStackCollector final : public ProfilerStackCollector {
public:
GTestStackCollector() : mSetIsMainThread(0), mFrames(0) {}
virtual void SetIsMainThread() { mSetIsMainThread++; }
virtual void CollectNativeLeafAddr(void* aAddr) { mFrames++; }
virtual void CollectJitReturnAddr(void* aAddr) { mFrames++; }
virtual void CollectWasmFrame(JS::ProfilingCategoryPair aCategory,
const char* aLabel) {
mFrames++;
}
virtual void CollectProfilingStackFrame(
const js::ProfilingStackFrame& aFrame) {
mFrames++;
}
int mSetIsMainThread;
int mFrames;
};
void DoSuspendAndSample(ProfilerThreadId aTidToSample,
nsIThread* aSamplingThread) {
NS_DispatchAndSpinEventLoopUntilComplete(
"GeckoProfiler_SuspendAndSample_Test::TestBody"_ns, aSamplingThread,
NS_NewRunnableFunction(
"GeckoProfiler_SuspendAndSample_Test::TestBody", [&]() {
uint32_t features = ProfilerFeature::CPUUtilization;
GTestStackCollector collector;
profiler_suspend_and_sample_thread(aTidToSample, features,
collector,
/* sampleNative = */ true);
ASSERT_TRUE(collector.mSetIsMainThread ==
(aTidToSample == profiler_main_thread_id()));
ASSERT_TRUE(collector.mFrames > 0);
}));
}
TEST(GeckoProfiler, SuspendAndSample)
{
nsCOMPtr<nsIThread> thread;
nsresult rv = NS_NewNamedThread("GeckoProfGTest", getter_AddRefs(thread));
ASSERT_NS_SUCCEEDED(rv);
ProfilerThreadId tid = profiler_current_thread_id();
ASSERT_TRUE(!profiler_is_active());
// Suspend and sample while the profiler is inactive.
DoSuspendAndSample(tid, thread);
DoSuspendAndSample(ProfilerThreadId{}, thread);
uint32_t features = ProfilerFeature::JS;
const char* filters[] = {"GeckoMain", "Compositor"};
profiler_start(PROFILER_DEFAULT_ENTRIES, PROFILER_DEFAULT_INTERVAL, features,
filters, MOZ_ARRAY_LENGTH(filters), 0);
ASSERT_TRUE(profiler_is_active());
// Suspend and sample while the profiler is active.
DoSuspendAndSample(tid, thread);
DoSuspendAndSample(ProfilerThreadId{}, thread);
profiler_stop();
ASSERT_TRUE(!profiler_is_active());
}
TEST(GeckoProfiler, PostSamplingCallback)
{
const char* filters[] = {"GeckoMain"};
ASSERT_TRUE(!profiler_is_active());
ASSERT_TRUE(!profiler_callback_after_sampling(
[&](SamplingState) { ASSERT_TRUE(false); }));
profiler_start(PROFILER_DEFAULT_ENTRIES, PROFILER_DEFAULT_INTERVAL,
ProfilerFeature::StackWalk, filters, MOZ_ARRAY_LENGTH(filters),
0);
{
// Stack sampling -> This label should appear at least once.
AUTO_PROFILER_LABEL("PostSamplingCallback completed", OTHER);
ASSERT_EQ(WaitForSamplingState(), SamplingState::SamplingCompleted);
}
UniquePtr<char[]> profileCompleted = profiler_get_profile();
JSONOutputCheck(profileCompleted.get(), [](const Json::Value& aRoot) {
GET_JSON(threads, aRoot["threads"], Array);
{
GET_JSON(thread0, threads[0], Object);
{
EXPECT_JSON_ARRAY_CONTAINS(thread0["stringTable"], String,
"PostSamplingCallback completed");
}
}
});
profiler_pause();
{
// Paused -> This label should not appear.
AUTO_PROFILER_LABEL("PostSamplingCallback paused", OTHER);
ASSERT_EQ(WaitForSamplingState(), SamplingState::SamplingPaused);
}
UniquePtr<char[]> profilePaused = profiler_get_profile();
JSONOutputCheck(profilePaused.get(), [](const Json::Value& aRoot) {});
// This string shouldn't appear *anywhere* in the profile.
ASSERT_FALSE(strstr(profilePaused.get(), "PostSamplingCallback paused"));
profiler_resume();
{
// Stack sampling -> This label should appear at least once.
AUTO_PROFILER_LABEL("PostSamplingCallback resumed", OTHER);
ASSERT_EQ(WaitForSamplingState(), SamplingState::SamplingCompleted);
}
UniquePtr<char[]> profileResumed = profiler_get_profile();
JSONOutputCheck(profileResumed.get(), [](const Json::Value& aRoot) {
GET_JSON(threads, aRoot["threads"], Array);
{
GET_JSON(thread0, threads[0], Object);
{
EXPECT_JSON_ARRAY_CONTAINS(thread0["stringTable"], String,
"PostSamplingCallback resumed");
}
}
});
profiler_start(PROFILER_DEFAULT_ENTRIES, PROFILER_DEFAULT_INTERVAL,
ProfilerFeature::StackWalk | ProfilerFeature::NoStackSampling,
filters, MOZ_ARRAY_LENGTH(filters), 0);
{
// No stack sampling -> This label should not appear.
AUTO_PROFILER_LABEL("PostSamplingCallback completed (no stacks)", OTHER);
ASSERT_EQ(WaitForSamplingState(), SamplingState::NoStackSamplingCompleted);
}
UniquePtr<char[]> profileNoStacks = profiler_get_profile();
JSONOutputCheck(profileNoStacks.get(), [](const Json::Value& aRoot) {});
// This string shouldn't appear *anywhere* in the profile.
ASSERT_FALSE(strstr(profileNoStacks.get(),
"PostSamplingCallback completed (no stacks)"));
// Note: There is no non-racy way to test for SamplingState::JustStopped, as
// it would require coordination between `profiler_stop()` and another thread
// doing `profiler_callback_after_sampling()` at just the right moment.
profiler_stop();
ASSERT_TRUE(!profiler_is_active());
ASSERT_TRUE(!profiler_callback_after_sampling(
[&](SamplingState) { ASSERT_TRUE(false); }));
}
TEST(GeckoProfiler, ProfilingStateCallback)
{
const char* filters[] = {"GeckoMain"};
ASSERT_TRUE(!profiler_is_active());
struct ProfilingStateAndId {
ProfilingState mProfilingState;
int mId;
};
DataMutex<Vector<ProfilingStateAndId>> states{"Profiling states"};
auto CreateCallback = [&states](int id) {
return [id, &states](ProfilingState aProfilingState) {
auto lockedStates = states.Lock();
ASSERT_TRUE(
lockedStates->append(ProfilingStateAndId{aProfilingState, id}));
};
};
auto CheckStatesIsEmpty = [&states]() {
auto lockedStates = states.Lock();
EXPECT_TRUE(lockedStates->empty());
};
auto CheckStatesOnlyContains = [&states](ProfilingState aProfilingState,
int aId) {
auto lockedStates = states.Lock();
EXPECT_EQ(lockedStates->length(), 1u);
if (lockedStates->length() >= 1u) {
EXPECT_EQ((*lockedStates)[0].mProfilingState, aProfilingState);
EXPECT_EQ((*lockedStates)[0].mId, aId);
}
lockedStates->clear();
};
profiler_add_state_change_callback(AllProfilingStates(), CreateCallback(1),
1);
// This is in case of error, and it also exercises the (allowed) removal of
// unknown callback ids.
auto cleanup1 = mozilla::MakeScopeExit(
[]() { profiler_remove_state_change_callback(1); });
CheckStatesIsEmpty();
profiler_start(PROFILER_DEFAULT_ENTRIES, PROFILER_DEFAULT_INTERVAL,
ProfilerFeature::StackWalk, filters, MOZ_ARRAY_LENGTH(filters),
0);
CheckStatesOnlyContains(ProfilingState::Started, 1);
profiler_add_state_change_callback(AllProfilingStates(), CreateCallback(2),
2);
// This is in case of error, and it also exercises the (allowed) removal of
// unknown callback ids.
auto cleanup2 = mozilla::MakeScopeExit(
[]() { profiler_remove_state_change_callback(2); });
CheckStatesOnlyContains(ProfilingState::AlreadyActive, 2);
profiler_remove_state_change_callback(2);
CheckStatesOnlyContains(ProfilingState::RemovingCallback, 2);
// Note: The actual removal is effectively tested below, by not seeing any
// more invocations of the 2nd callback.
ASSERT_EQ(WaitForSamplingState(), SamplingState::SamplingCompleted);
UniquePtr<char[]> profileCompleted = profiler_get_profile();
CheckStatesOnlyContains(ProfilingState::GeneratingProfile, 1);
JSONOutputCheck(profileCompleted.get(), [](const Json::Value& aRoot) {});
profiler_pause();
CheckStatesOnlyContains(ProfilingState::Pausing, 1);
UniquePtr<char[]> profilePaused = profiler_get_profile();
CheckStatesOnlyContains(ProfilingState::GeneratingProfile, 1);
JSONOutputCheck(profilePaused.get(), [](const Json::Value& aRoot) {});
profiler_resume();
CheckStatesOnlyContains(ProfilingState::Resumed, 1);
ASSERT_EQ(WaitForSamplingState(), SamplingState::SamplingCompleted);
UniquePtr<char[]> profileResumed = profiler_get_profile();
CheckStatesOnlyContains(ProfilingState::GeneratingProfile, 1);
JSONOutputCheck(profileResumed.get(), [](const Json::Value& aRoot) {});
// This effectively stops the profiler before restarting it, but
// ProfilingState::Stopping is not notified. See `profiler_start` for details.
profiler_start(PROFILER_DEFAULT_ENTRIES, PROFILER_DEFAULT_INTERVAL,
ProfilerFeature::StackWalk | ProfilerFeature::NoStackSampling,
filters, MOZ_ARRAY_LENGTH(filters), 0);
CheckStatesOnlyContains(ProfilingState::Started, 1);
ASSERT_EQ(WaitForSamplingState(), SamplingState::NoStackSamplingCompleted);
UniquePtr<char[]> profileNoStacks = profiler_get_profile();
CheckStatesOnlyContains(ProfilingState::GeneratingProfile, 1);
JSONOutputCheck(profileNoStacks.get(), [](const Json::Value& aRoot) {});
profiler_stop();
CheckStatesOnlyContains(ProfilingState::Stopping, 1);
ASSERT_TRUE(!profiler_is_active());
profiler_remove_state_change_callback(1);
CheckStatesOnlyContains(ProfilingState::RemovingCallback, 1);
// Note: ProfilingState::ShuttingDown cannot be tested here, and the profiler
// can only be shut down once per process.
}
TEST(GeckoProfiler, BaseProfilerHandOff)
{
const char* filters[] = {"GeckoMain"};
ASSERT_TRUE(!baseprofiler::profiler_is_active());
ASSERT_TRUE(!profiler_is_active());
BASE_PROFILER_MARKER_UNTYPED("Base marker before base profiler", OTHER, {});
PROFILER_MARKER_UNTYPED("Gecko marker before base profiler", OTHER, {});
// Start the Base Profiler.
baseprofiler::profiler_start(
PROFILER_DEFAULT_ENTRIES, PROFILER_DEFAULT_INTERVAL,
ProfilerFeature::StackWalk, filters, MOZ_ARRAY_LENGTH(filters));
ASSERT_TRUE(baseprofiler::profiler_is_active());
ASSERT_TRUE(!profiler_is_active());
// Add at least a marker, which should go straight into the buffer.
Maybe<baseprofiler::ProfilerBufferInfo> info0 =
baseprofiler::profiler_get_buffer_info();
BASE_PROFILER_MARKER_UNTYPED("Base marker during base profiler", OTHER, {});
Maybe<baseprofiler::ProfilerBufferInfo> info1 =
baseprofiler::profiler_get_buffer_info();
ASSERT_GT(info1->mRangeEnd, info0->mRangeEnd);
PROFILER_MARKER_UNTYPED("Gecko marker during base profiler", OTHER, {});
// Start the Gecko Profiler, which should grab the Base Profiler profile and
// stop it.
profiler_start(PROFILER_DEFAULT_ENTRIES, PROFILER_DEFAULT_INTERVAL,
ProfilerFeature::StackWalk, filters, MOZ_ARRAY_LENGTH(filters),
0);
ASSERT_TRUE(!baseprofiler::profiler_is_active());
ASSERT_TRUE(profiler_is_active());
BASE_PROFILER_MARKER_UNTYPED("Base marker during gecko profiler", OTHER, {});
PROFILER_MARKER_UNTYPED("Gecko marker during gecko profiler", OTHER, {});
// Write some Gecko Profiler samples.
ASSERT_EQ(WaitForSamplingState(), SamplingState::SamplingCompleted);
// Check that the Gecko Profiler profile contains at least the Base Profiler
// main thread samples.
UniquePtr<char[]> profile = profiler_get_profile();
profiler_stop();
ASSERT_TRUE(!profiler_is_active());
BASE_PROFILER_MARKER_UNTYPED("Base marker after gecko profiler", OTHER, {});
PROFILER_MARKER_UNTYPED("Gecko marker after gecko profiler", OTHER, {});
JSONOutputCheck(profile.get(), [](const Json::Value& aRoot) {
GET_JSON(threads, aRoot["threads"], Array);
{
bool found = false;
for (const Json::Value& thread : threads) {
ASSERT_TRUE(thread.isObject());
GET_JSON(name, thread["name"], String);
if (name.asString() == "GeckoMain") {
found = true;
EXPECT_JSON_ARRAY_EXCLUDES(thread["stringTable"], String,
"Base marker before base profiler");
EXPECT_JSON_ARRAY_EXCLUDES(thread["stringTable"], String,
"Gecko marker before base profiler");
EXPECT_JSON_ARRAY_CONTAINS(thread["stringTable"], String,
"Base marker during base profiler");
EXPECT_JSON_ARRAY_EXCLUDES(thread["stringTable"], String,
"Gecko marker during base profiler");
EXPECT_JSON_ARRAY_CONTAINS(thread["stringTable"], String,
"Base marker during gecko profiler");
EXPECT_JSON_ARRAY_CONTAINS(thread["stringTable"], String,
"Gecko marker during gecko profiler");
EXPECT_JSON_ARRAY_EXCLUDES(thread["stringTable"], String,
"Base marker after gecko profiler");
EXPECT_JSON_ARRAY_EXCLUDES(thread["stringTable"], String,
"Gecko marker after gecko profiler");
break;
}
}
EXPECT_TRUE(found);
}
});
}
static std::string_view GetFeatureName(uint32_t feature) {
switch (feature) {
# define FEATURE_NAME(n_, str_, Name_, desc_) \
case ProfilerFeature::Name_: \
return str_;
PROFILER_FOR_EACH_FEATURE(FEATURE_NAME)
# undef FEATURE_NAME
default:
return "?";
}
}
TEST(GeckoProfiler, FeatureCombinations)
{
const char* filters[] = {"*"};
// List of features to test. Every combination of up to 3 of them will be
// tested, so be careful not to add too many to keep the test run at a
// reasonable time.
uint32_t featureList[] = {ProfilerFeature::JS,
ProfilerFeature::Screenshots,
ProfilerFeature::StackWalk,
ProfilerFeature::NoStackSampling,
ProfilerFeature::NativeAllocations,
ProfilerFeature::CPUUtilization,
ProfilerFeature::CPUAllThreads,
ProfilerFeature::SamplingAllThreads,
ProfilerFeature::MarkersAllThreads,
ProfilerFeature::UnregisteredThreads};
constexpr uint32_t featureCount = uint32_t(MOZ_ARRAY_LENGTH(featureList));
auto testFeatures = [&](uint32_t features,
const std::string& featuresString) {
SCOPED_TRACE(featuresString.c_str());
ASSERT_TRUE(!profiler_is_active());
profiler_start(PROFILER_DEFAULT_ENTRIES, PROFILER_DEFAULT_INTERVAL,
features, filters, MOZ_ARRAY_LENGTH(filters), 0);
ASSERT_TRUE(profiler_is_active());
// Write some Gecko Profiler samples.
EXPECT_EQ(WaitForSamplingState(),
(((features & ProfilerFeature::NoStackSampling) != 0) &&
((features & (ProfilerFeature::CPUUtilization |
ProfilerFeature::CPUAllThreads)) == 0))
? SamplingState::NoStackSamplingCompleted
: SamplingState::SamplingCompleted);
// Check that the profile looks valid. Note that we don't test feature-
// specific changes.
UniquePtr<char[]> profile = profiler_get_profile();
JSONOutputCheck(profile.get(), [](const Json::Value& aRoot) {});
profiler_stop();
ASSERT_TRUE(!profiler_is_active());
};
testFeatures(0, "Features: (none)");
for (uint32_t f1 = 0u; f1 < featureCount; ++f1) {
const uint32_t features1 = featureList[f1];
std::string features1String = "Features: ";
features1String += GetFeatureName(featureList[f1]);
testFeatures(features1, features1String);
for (uint32_t f2 = f1 + 1u; f2 < featureCount; ++f2) {
const uint32_t features12 = f1 | featureList[f2];
std::string features12String = features1String + " ";
features12String += GetFeatureName(featureList[f2]);
testFeatures(features12, features12String);
for (uint32_t f3 = f2 + 1u; f3 < featureCount; ++f3) {
const uint32_t features123 = features12 | featureList[f3];
std::string features123String = features12String + " ";
features123String += GetFeatureName(featureList[f3]);
testFeatures(features123, features123String);
}
}
}
}
static void CountCPUDeltas(const Json::Value& aThread, size_t& aOutSamplings,
uint64_t& aOutCPUDeltaSum) {
GET_JSON(samples, aThread["samples"], Object);
{
Json::ArrayIndex threadCPUDeltaIndex = 0;
GET_JSON(schema, samples["schema"], Object);
{
GET_JSON(jsonThreadCPUDeltaIndex, schema["threadCPUDelta"], UInt);
threadCPUDeltaIndex = jsonThreadCPUDeltaIndex.asUInt();
}
aOutSamplings = 0;
aOutCPUDeltaSum = 0;
GET_JSON(data, samples["data"], Array);
aOutSamplings = data.size();
for (const Json::Value& sample : data) {
ASSERT_TRUE(sample.isArray());
if (sample.isValidIndex(threadCPUDeltaIndex)) {
if (!sample[threadCPUDeltaIndex].isNull()) {
GET_JSON(cpuDelta, sample[threadCPUDeltaIndex], UInt64);
aOutCPUDeltaSum += uint64_t(cpuDelta.asUInt64());
}
}
}
}
}
TEST(GeckoProfiler, CPUUsage)
{
profiler_init_main_thread_id();
ASSERT_TRUE(profiler_is_main_thread())
<< "This test assumes it runs on the main thread";
const char* filters[] = {"GeckoMain", "Idle test", "Busy test"};
enum class TestThreadsState {
// Initial state, while constructing and starting the idle thread.
STARTING,
// Set by the idle thread just before running its main mostly-idle loop.
RUNNING1,
RUNNING2,
// Set by the main thread when it wants the idle thread to stop.
STOPPING
};
Atomic<TestThreadsState> testThreadsState{TestThreadsState::STARTING};
std::thread idle([&]() {
AUTO_PROFILER_REGISTER_THREAD("Idle test");
// Add a label to ensure that we have a non-empty stack, even if native
// stack-walking is not available.
AUTO_PROFILER_LABEL("Idle test", PROFILER);
ASSERT_TRUE(testThreadsState.compareExchange(TestThreadsState::STARTING,
TestThreadsState::RUNNING1) ||
testThreadsState.compareExchange(TestThreadsState::RUNNING1,
TestThreadsState::RUNNING2));
while (testThreadsState != TestThreadsState::STOPPING) {
// Sleep for multiple profiler intervals, so the profiler should have
// samples with zero CPU utilization.
PR_Sleep(PR_MillisecondsToInterval(PROFILER_DEFAULT_INTERVAL * 10));
}
});
std::thread busy([&]() {
AUTO_PROFILER_REGISTER_THREAD("Busy test");
// Add a label to ensure that we have a non-empty stack, even if native
// stack-walking is not available.
AUTO_PROFILER_LABEL("Busy test", PROFILER);
ASSERT_TRUE(testThreadsState.compareExchange(TestThreadsState::STARTING,
TestThreadsState::RUNNING1) ||
testThreadsState.compareExchange(TestThreadsState::RUNNING1,
TestThreadsState::RUNNING2));
while (testThreadsState != TestThreadsState::STOPPING) {
// Stay busy!
}
});
// Wait for idle thread to start running its main loop.
while (testThreadsState != TestThreadsState::RUNNING2) {
PR_Sleep(PR_MillisecondsToInterval(1));
}
// We want to ensure that CPU usage numbers are present whether or not we are
// collecting stack samples.
static constexpr bool scTestsWithOrWithoutStackSampling[] = {false, true};
for (const bool testWithNoStackSampling : scTestsWithOrWithoutStackSampling) {
ASSERT_TRUE(!profiler_is_active());
ASSERT_TRUE(!profiler_callback_after_sampling(
[&](SamplingState) { ASSERT_TRUE(false); }));
profiler_start(
PROFILER_DEFAULT_ENTRIES, PROFILER_DEFAULT_INTERVAL,
ProfilerFeature::StackWalk | ProfilerFeature::CPUUtilization |
(testWithNoStackSampling ? ProfilerFeature::NoStackSampling : 0),
filters, MOZ_ARRAY_LENGTH(filters), 0);
// Grab a few samples, each with a different label on the stack.
# define SAMPLE_LABEL_PREFIX "CPUUsage sample label "
static constexpr const char* scSampleLabels[] = {
SAMPLE_LABEL_PREFIX "0", SAMPLE_LABEL_PREFIX "1",
SAMPLE_LABEL_PREFIX "2", SAMPLE_LABEL_PREFIX "3",
SAMPLE_LABEL_PREFIX "4", SAMPLE_LABEL_PREFIX "5",
SAMPLE_LABEL_PREFIX "6", SAMPLE_LABEL_PREFIX "7",
SAMPLE_LABEL_PREFIX "8", SAMPLE_LABEL_PREFIX "9"};
static constexpr size_t scSampleLabelCount =
(sizeof(scSampleLabels) / sizeof(scSampleLabels[0]));
// We'll do two samplings for each label.
static constexpr size_t scMinSamplings = scSampleLabelCount * 2;
for (const char* sampleLabel : scSampleLabels) {
AUTO_PROFILER_LABEL(sampleLabel, OTHER);
ASSERT_EQ(WaitForSamplingState(), SamplingState::SamplingCompleted);
// Note: There could have been a delay before this label above, where the
// profiler could have sampled the stack and missed the label. By forcing
// another sampling now, the label is guaranteed to be present.
ASSERT_EQ(WaitForSamplingState(), SamplingState::SamplingCompleted);
}
UniquePtr<char[]> profile = profiler_get_profile();
if (testWithNoStackSampling) {
// If we are testing nostacksampling, we shouldn't find this label prefix
// in the profile.
EXPECT_FALSE(strstr(profile.get(), SAMPLE_LABEL_PREFIX));
} else {
// In normal sampling mode, we should find all labels.
for (const char* sampleLabel : scSampleLabels) {
EXPECT_TRUE(strstr(profile.get(), sampleLabel));
}
}
JSONOutputCheck(profile.get(), [testWithNoStackSampling](
const Json::Value& aRoot) {
// Check that the "cpu" feature is present.
GET_JSON(meta, aRoot["meta"], Object);
{
GET_JSON(configuration, meta["configuration"], Object);
{
GET_JSON(features, configuration["features"], Array);
{ EXPECT_JSON_ARRAY_CONTAINS(features, String, "cpu"); }
}
}
{
GET_JSON(sampleUnits, meta["sampleUnits"], Object);
{
EXPECT_EQ_JSON(sampleUnits["time"], String, "ms");
EXPECT_EQ_JSON(sampleUnits["eventDelay"], String, "ms");
# if defined(GP_OS_windows) || defined(GP_OS_darwin) || \
defined(GP_OS_linux) || defined(GP_OS_android) || defined(GP_OS_freebsd)
// Note: The exact string is not important here.
EXPECT_TRUE(sampleUnits["threadCPUDelta"].isString())
<< "There should be a sampleUnits.threadCPUDelta on this "
"platform";
# else
EXPECT_FALSE(sampleUnits.isMember("threadCPUDelta"))
<< "Unexpected sampleUnits.threadCPUDelta on this platform";;
# endif
}
}
bool foundMain = false;
bool foundIdle = false;
uint64_t idleThreadCPUDeltaSum = 0u;
bool foundBusy = false;
uint64_t busyThreadCPUDeltaSum = 0u;
// Check that the sample schema contains "threadCPUDelta".
GET_JSON(threads, aRoot["threads"], Array);
for (const Json::Value& thread : threads) {
ASSERT_TRUE(thread.isObject());
GET_JSON(name, thread["name"], String);
if (name.asString() == "GeckoMain") {
foundMain = true;
GET_JSON(samples, thread["samples"], Object);
{
Json::ArrayIndex stackIndex = 0;
Json::ArrayIndex threadCPUDeltaIndex = 0;
GET_JSON(schema, samples["schema"], Object);
{
GET_JSON(jsonStackIndex, schema["stack"], UInt);
stackIndex = jsonStackIndex.asUInt();
GET_JSON(jsonThreadCPUDeltaIndex, schema["threadCPUDelta"], UInt);
threadCPUDeltaIndex = jsonThreadCPUDeltaIndex.asUInt();
}
std::set<uint64_t> stackLeaves; // To count distinct leaves.
unsigned threadCPUDeltaCount = 0;
GET_JSON(data, samples["data"], Array);
if (testWithNoStackSampling) {
// When not sampling stacks, the first sampling loop will have no
// running times, so it won't output anything.
EXPECT_GE(data.size(), scMinSamplings - 1);
} else {
EXPECT_GE(data.size(), scMinSamplings);
}
for (const Json::Value& sample : data) {
ASSERT_TRUE(sample.isArray());
if (sample.isValidIndex(stackIndex)) {
if (!sample[stackIndex].isNull()) {
GET_JSON(stack, sample[stackIndex], UInt64);
stackLeaves.insert(stack.asUInt64());
}
}
if (sample.isValidIndex(threadCPUDeltaIndex)) {
if (!sample[threadCPUDeltaIndex].isNull()) {
EXPECT_TRUE(sample[threadCPUDeltaIndex].isUInt64());
++threadCPUDeltaCount;
}
}
}
if (testWithNoStackSampling) {
// in nostacksampling mode, there should only be one kind of stack
// leaf (the root).
EXPECT_EQ(stackLeaves.size(), 1u);
} else {
// in normal sampling mode, there should be at least one kind of
// stack leaf for each distinct label.
EXPECT_GE(stackLeaves.size(), scSampleLabelCount);
}
# if defined(GP_OS_windows) || defined(GP_OS_darwin) || \
defined(GP_OS_linux) || defined(GP_OS_android) || defined(GP_OS_freebsd)
EXPECT_GE(threadCPUDeltaCount, data.size() - 1u)
<< "There should be 'threadCPUDelta' values in all but 1 "
"samples";
# else
// All "threadCPUDelta" data should be absent or null on unsupported
// platforms.
EXPECT_EQ(threadCPUDeltaCount, 0u);
# endif
}
} else if (name.asString() == "Idle test") {
foundIdle = true;
size_t samplings;
CountCPUDeltas(thread, samplings, idleThreadCPUDeltaSum);
if (testWithNoStackSampling) {
// When not sampling stacks, the first sampling loop will have no
// running times, so it won't output anything.
EXPECT_GE(samplings, scMinSamplings - 1);
} else {
EXPECT_GE(samplings, scMinSamplings);
}
# if !(defined(GP_OS_windows) || defined(GP_OS_darwin) || \
defined(GP_OS_linux) || defined(GP_OS_android) || \
defined(GP_OS_freebsd))
// All "threadCPUDelta" data should be absent or null on unsupported
// platforms.
EXPECT_EQ(idleThreadCPUDeltaSum, 0u);
# endif
} else if (name.asString() == "Busy test") {
foundBusy = true;
size_t samplings;
CountCPUDeltas(thread, samplings, busyThreadCPUDeltaSum);
if (testWithNoStackSampling) {
// When not sampling stacks, the first sampling loop will have no
// running times, so it won't output anything.
EXPECT_GE(samplings, scMinSamplings - 1);
} else {
EXPECT_GE(samplings, scMinSamplings);
}
# if !(defined(GP_OS_windows) || defined(GP_OS_darwin) || \
defined(GP_OS_linux) || defined(GP_OS_android) || \
defined(GP_OS_freebsd))
// All "threadCPUDelta" data should be absent or null on unsupported
// platforms.
EXPECT_EQ(busyThreadCPUDeltaSum, 0u);
# endif
}
}
EXPECT_TRUE(foundMain);
EXPECT_TRUE(foundIdle);
EXPECT_TRUE(foundBusy);
EXPECT_LE(idleThreadCPUDeltaSum, busyThreadCPUDeltaSum);
});
// Note: There is no non-racy way to test for SamplingState::JustStopped, as
// it would require coordination between `profiler_stop()` and another
// thread doing `profiler_callback_after_sampling()` at just the right
// moment.
profiler_stop();
ASSERT_TRUE(!profiler_is_active());
ASSERT_TRUE(!profiler_callback_after_sampling(
[&](SamplingState) { ASSERT_TRUE(false); }));
}
testThreadsState = TestThreadsState::STOPPING;
busy.join();
idle.join();
}
TEST(GeckoProfiler, AllThreads)
{
profiler_init_main_thread_id();
ASSERT_TRUE(profiler_is_main_thread())
<< "This test assumes it runs on the main thread";
ASSERT_EQ(static_cast<uint32_t>(ThreadProfilingFeatures::Any), 1u + 2u + 4u)
<< "This test assumes that there are 3 binary choices 1+2+4; "
"Is this test up to date?";
for (uint32_t threadFeaturesBinary = 0u;
threadFeaturesBinary <=
static_cast<uint32_t>(ThreadProfilingFeatures::Any);
++threadFeaturesBinary) {
ThreadProfilingFeatures threadFeatures =
static_cast<ThreadProfilingFeatures>(threadFeaturesBinary);
const bool threadCPU = DoFeaturesIntersect(
threadFeatures, ThreadProfilingFeatures::CPUUtilization);
const bool threadSampling =
DoFeaturesIntersect(threadFeatures, ThreadProfilingFeatures::Sampling);
const bool threadMarkers =
DoFeaturesIntersect(threadFeatures, ThreadProfilingFeatures::Markers);
ASSERT_TRUE(!profiler_is_active());
uint32_t features = ProfilerFeature::StackWalk;
std::string featuresString = "Features: StackWalk Threads";
if (threadCPU) {
features |= ProfilerFeature::CPUAllThreads;
featuresString += " CPUAllThreads";
}
if (threadSampling) {
features |= ProfilerFeature::SamplingAllThreads;
featuresString += " SamplingAllThreads";
}
if (threadMarkers) {
features |= ProfilerFeature::MarkersAllThreads;
featuresString += " MarkersAllThreads";
}
SCOPED_TRACE(featuresString.c_str());
const char* filters[] = {"GeckoMain", "Selected"};
EXPECT_FALSE(profiler_thread_is_being_profiled(
ThreadProfilingFeatures::CPUUtilization));
EXPECT_FALSE(
profiler_thread_is_being_profiled(ThreadProfilingFeatures::Sampling));
EXPECT_FALSE(
profiler_thread_is_being_profiled(ThreadProfilingFeatures::Markers));
EXPECT_FALSE(profiler_thread_is_being_profiled_for_markers());
profiler_start(PROFILER_DEFAULT_ENTRIES, PROFILER_DEFAULT_INTERVAL,
features, filters, MOZ_ARRAY_LENGTH(filters), 0);
EXPECT_TRUE(profiler_thread_is_being_profiled(
ThreadProfilingFeatures::CPUUtilization));
EXPECT_TRUE(
profiler_thread_is_being_profiled(ThreadProfilingFeatures::Sampling));
EXPECT_TRUE(
profiler_thread_is_being_profiled(ThreadProfilingFeatures::Markers));
EXPECT_TRUE(profiler_thread_is_being_profiled_for_markers());
// This will signal all threads to stop spinning.
Atomic<bool> stopThreads{false};
Atomic<int> selectedThreadSpins{0};
std::thread selectedThread([&]() {
AUTO_PROFILER_REGISTER_THREAD("Selected test thread");
// Add a label to ensure that we have a non-empty stack, even if native
// stack-walking is not available.
AUTO_PROFILER_LABEL("Selected test thread", PROFILER);
EXPECT_TRUE(profiler_thread_is_being_profiled(
ThreadProfilingFeatures::CPUUtilization));
EXPECT_TRUE(
profiler_thread_is_being_profiled(ThreadProfilingFeatures::Sampling));
EXPECT_TRUE(
profiler_thread_is_being_profiled(ThreadProfilingFeatures::Markers));
EXPECT_TRUE(profiler_thread_is_being_profiled_for_markers());
while (!stopThreads) {
PROFILER_MARKER_UNTYPED("Spinning Selected!", PROFILER);
++selectedThreadSpins;
PR_Sleep(PR_MillisecondsToInterval(1));
}
});
Atomic<int> unselectedThreadSpins{0};
std::thread unselectedThread([&]() {
AUTO_PROFILER_REGISTER_THREAD("Registered test thread");
// Add a label to ensure that we have a non-empty stack, even if native
// stack-walking is not available.
AUTO_PROFILER_LABEL("Registered test thread", PROFILER);
// This thread is *not* selected for full profiling, but it may still be
// profiled depending on the -allthreads features.
EXPECT_EQ(profiler_thread_is_being_profiled(
ThreadProfilingFeatures::CPUUtilization),
threadCPU);
EXPECT_EQ(
profiler_thread_is_being_profiled(ThreadProfilingFeatures::Sampling),
threadSampling);
EXPECT_EQ(
profiler_thread_is_being_profiled(ThreadProfilingFeatures::Markers),
threadMarkers);
EXPECT_EQ(profiler_thread_is_being_profiled_for_markers(), threadMarkers);
while (!stopThreads) {
PROFILER_MARKER_UNTYPED("Spinning Registered!", PROFILER);
++unselectedThreadSpins;
PR_Sleep(PR_MillisecondsToInterval(1));
}
});
Atomic<int> unregisteredThreadSpins{0};
std::thread unregisteredThread([&]() {
// No `AUTO_PROFILER_REGISTER_THREAD` here.
EXPECT_FALSE(profiler_thread_is_being_profiled(
ThreadProfilingFeatures::CPUUtilization));
EXPECT_FALSE(
profiler_thread_is_being_profiled(ThreadProfilingFeatures::Sampling));
EXPECT_FALSE(
profiler_thread_is_being_profiled(ThreadProfilingFeatures::Markers));
EXPECT_FALSE(profiler_thread_is_being_profiled_for_markers());
while (!stopThreads) {
PROFILER_MARKER_UNTYPED("Spinning Unregistered!", PROFILER);
++unregisteredThreadSpins;
PR_Sleep(PR_MillisecondsToInterval(1));
}
});
// Wait for all threads to have started at least one spin.
while (selectedThreadSpins == 0 || unselectedThreadSpins == 0 ||
unregisteredThreadSpins == 0) {
PR_Sleep(PR_MillisecondsToInterval(1));
}
// Wait until the sampler has done at least one loop.
ASSERT_EQ(WaitForSamplingState(), SamplingState::SamplingCompleted);
// Restart the spin counts, and ensure each threads will do at least one
// more spin each. Since spins are increased after PROFILER_MARKER calls, in
// the worst case, each thread will have attempted to record at least one
// marker.
selectedThreadSpins = 0;
unselectedThreadSpins = 0;
unregisteredThreadSpins = 0;
while (selectedThreadSpins < 1 && unselectedThreadSpins < 1 &&
unregisteredThreadSpins < 1) {
ASSERT_EQ(WaitForSamplingState(), SamplingState::SamplingCompleted);
}
profiler_pause();
UniquePtr<char[]> profile = profiler_get_profile();
profiler_stop();
stopThreads = true;
unregisteredThread.join();
unselectedThread.join();
selectedThread.join();
JSONOutputCheck(profile.get(), [&](const Json::Value& aRoot) {
GET_JSON(threads, aRoot["threads"], Array);
int foundMain = 0;
int foundSelected = 0;
int foundSelectedMarker = 0;
int foundUnselected = 0;
int foundUnselectedMarker = 0;
for (const Json::Value& thread : threads) {
ASSERT_TRUE(thread.isObject());
GET_JSON(stringTable, thread["stringTable"], Array);
GET_JSON(name, thread["name"], String);
if (name.asString() == "GeckoMain") {
++foundMain;
// Don't check the main thread further in this test.
} else if (name.asString() == "Selected test thread") {
++foundSelected;
GET_JSON(samples, thread["samples"], Object);
GET_JSON(samplesData, samples["data"], Array);
EXPECT_GT(samplesData.size(), 0u);
GET_JSON(markers, thread["markers"], Object);
GET_JSON(markersData, markers["data"], Array);
for (const Json::Value& marker : markersData) {
const unsigned int NAME = 0u;
ASSERT_TRUE(marker[NAME].isUInt()); // name id
GET_JSON(name, stringTable[marker[NAME].asUInt()], String);
if (name == "Spinning Selected!") {
++foundSelectedMarker;
}
}
} else if (name.asString() == "Registered test thread") {
++foundUnselected;
GET_JSON(samples, thread["samples"], Object);
GET_JSON(samplesData, samples["data"], Array);
if (threadCPU || threadSampling) {
EXPECT_GT(samplesData.size(), 0u);
} else {
EXPECT_EQ(samplesData.size(), 0u);
}
GET_JSON(markers, thread["markers"], Object);
GET_JSON(markersData, markers["data"], Array);
for (const Json::Value& marker : markersData) {
const unsigned int NAME = 0u;
ASSERT_TRUE(marker[NAME].isUInt()); // name id
GET_JSON(name, stringTable[marker[NAME].asUInt()], String);
if (name == "Spinning Registered!") {
++foundUnselectedMarker;
}
}
} else {
EXPECT_STRNE(name.asString().c_str(),
"Unregistered test thread label");
}
}
EXPECT_EQ(foundMain, 1);
EXPECT_EQ(foundSelected, 1);
EXPECT_GT(foundSelectedMarker, 0);
EXPECT_EQ(foundUnselected,
(threadCPU || threadSampling || threadMarkers) ? 1 : 0)
<< "Unselected thread should only be present if at least one of the "
"allthreads feature is on";
if (threadMarkers) {
EXPECT_GT(foundUnselectedMarker, 0);
} else {
EXPECT_EQ(foundUnselectedMarker, 0);
}
});
}
}
TEST(GeckoProfiler, FailureHandling)
{
profiler_init_main_thread_id();
ASSERT_TRUE(profiler_is_main_thread())
<< "This test assumes it runs on the main thread";
uint32_t features = ProfilerFeature::StackWalk;
const char* filters[] = {"GeckoMain"};
profiler_start(PROFILER_DEFAULT_ENTRIES, PROFILER_DEFAULT_INTERVAL, features,
filters, MOZ_ARRAY_LENGTH(filters), 0);
ASSERT_EQ(WaitForSamplingState(), SamplingState::SamplingCompleted);
// User-defined marker type that generates a failure when streaming JSON.
struct GtestFailingMarker {
static constexpr Span<const char> MarkerTypeName() {
return MakeStringSpan("markers-gtest-failing");
}
static void StreamJSONMarkerData(
mozilla::baseprofiler::SpliceableJSONWriter& aWriter) {
aWriter.SetFailure("boom!");
}
static mozilla::MarkerSchema MarkerTypeDisplay() {
return mozilla::MarkerSchema::SpecialFrontendLocation{};
}
};
EXPECT_TRUE(profiler_add_marker_impl("Gtest failing marker",
geckoprofiler::category::OTHER, {},
GtestFailingMarker{}));
ASSERT_EQ(WaitForSamplingState(), SamplingState::SamplingCompleted);
profiler_pause();
FailureLatchSource failureLatch;
SpliceableChunkedJSONWriter w{failureLatch};
EXPECT_FALSE(w.Failed());
ASSERT_FALSE(w.GetFailure());
w.Start();
EXPECT_FALSE(w.Failed());
ASSERT_FALSE(w.GetFailure());
// The marker will cause a failure during this function call.
EXPECT_FALSE(::profiler_stream_json_for_this_process(w).isOk());
EXPECT_TRUE(w.Failed());
ASSERT_TRUE(w.GetFailure());
EXPECT_EQ(strcmp(w.GetFailure(), "boom!"), 0);
// Already failed, check that we don't crash or reset the failure.
EXPECT_FALSE(::profiler_stream_json_for_this_process(w).isOk());
EXPECT_TRUE(w.Failed());
ASSERT_TRUE(w.GetFailure());
EXPECT_EQ(strcmp(w.GetFailure(), "boom!"), 0);
w.End();
profiler_stop();
EXPECT_TRUE(w.Failed());
ASSERT_TRUE(w.GetFailure());
EXPECT_EQ(strcmp(w.GetFailure(), "boom!"), 0);
UniquePtr<char[]> profile = w.ChunkedWriteFunc().CopyData();
ASSERT_EQ(profile.get(), nullptr);
}
TEST(GeckoProfiler, NoMarkerStacks)
{
uint32_t features = ProfilerFeature::NoMarkerStacks;
const char* filters[] = {"GeckoMain"};
ASSERT_TRUE(!profiler_get_profile());
// Make sure that profiler_capture_backtrace returns nullptr when the profiler
// is not active.
ASSERT_TRUE(!profiler_capture_backtrace());
{
// Start the profiler without the NoMarkerStacks feature and make sure we
// capture stacks.
profiler_start(PROFILER_DEFAULT_ENTRIES, PROFILER_DEFAULT_INTERVAL,
/* features */ 0, filters, MOZ_ARRAY_LENGTH(filters), 0);
ASSERT_TRUE(profiler_capture_backtrace());
profiler_stop();
}
// Start the profiler without the NoMarkerStacks feature and make sure we
// don't capture stacks.
profiler_start(PROFILER_DEFAULT_ENTRIES, PROFILER_DEFAULT_INTERVAL, features,
filters, MOZ_ARRAY_LENGTH(filters), 0);
// Make sure that the active features has the NoMarkerStacks feature.
mozilla::Maybe<uint32_t> activeFeatures = profiler_features_if_active();
ASSERT_TRUE(activeFeatures.isSome());
ASSERT_TRUE(ProfilerFeature::HasNoMarkerStacks(*activeFeatures));
// Make sure we don't capture stacks.
ASSERT_TRUE(!profiler_capture_backtrace());
// Add a marker with a stack to test.
EXPECT_TRUE(profiler_add_marker_impl(
"Text with stack", geckoprofiler::category::OTHER, MarkerStack::Capture(),
geckoprofiler::markers::TextMarker{}, ""));
UniquePtr<char[]> profile = profiler_get_profile();
JSONOutputCheck(profile.get(), [&](const Json::Value& aRoot) {
// Check that the meta.configuration.features array contains
// "nomarkerstacks".
GET_JSON(meta, aRoot["meta"], Object);
{
GET_JSON(configuration, meta["configuration"], Object);
{
GET_JSON(features, configuration["features"], Array);
{
EXPECT_EQ(features.size(), 1u);
EXPECT_JSON_ARRAY_CONTAINS(features, String, "nomarkerstacks");
}
}
}
// Make sure that the marker we captured doesn't have a stack.
GET_JSON(threads, aRoot["threads"], Array);
{
ASSERT_EQ(threads.size(), 1u);
GET_JSON(thread0, threads[0], Object);
{
GET_JSON(markers, thread0["markers"], Object);
{
GET_JSON(data, markers["data"], Array);
{
const unsigned int NAME = 0u;
const unsigned int PAYLOAD = 5u;
bool foundMarker = false;
GET_JSON(stringTable, thread0["stringTable"], Array);
for (const Json::Value& marker : data) {
// Even though we only added one marker, some markers like
// NotifyObservers are being added as well. Let's iterate over
// them and make sure that we have the one we added explicitly and
// check its stack doesn't exist.
GET_JSON(name, stringTable[marker[NAME].asUInt()], String);
std::string nameString = name.asString();
if (nameString == "Text with stack") {
// Make sure that the marker doesn't have a stack.
foundMarker = true;
EXPECT_FALSE(marker[PAYLOAD].isNull());
EXPECT_TRUE(marker[PAYLOAD]["stack"].isNull());
}
}
EXPECT_TRUE(foundMarker);
}
}
}
}
});
profiler_stop();
ASSERT_TRUE(!profiler_get_profile());
}
#endif // MOZ_GECKO_PROFILER
View git blame Copy permalink