Source code
Revision control
Copy as Markdown
Other Tools
/* -*- Mode: C++; tab-width: 8; 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/. */
namespace mozilla {
namespace baseprofiler {
// StreamMetaJSCustomObject needs the "Unix epoch" (microseconds since January
// 1, 1970 GMT). In the Profiler, we use PR_Now to get that information.
// However, we cannot use PR_Now in the baseprofiler because PR_Now belongs to
// nspr which is not linked to mozglue.
//
// Stub returns microseconds since ProcessStartTime.
static int64_t MicrosecondsSince1970() {
return static_cast<int64_t>(
(TimeStamp::Now() - CorePS::ProcessStartTime()).ToMicroseconds());
}
// @aGuess: a pointer to a variable on the stack (with attribute("stack")).
// Note: GetStackTop is manually inlined in
// mozilla::profiler::ThreadRegistrationData::ThreadRegistrationData.
void* GetStackTop(void* aGuess) { return aGuess; }
// On linux and freebsd, we use SIGPROF to Suspend threads before sampling them.
// However, if that thread is currently inside fork(), the fork() will restart
// which can cause serious delays. PlatformInit is currently used to install
// hooks at the beginning and at the end of fork(). The hooks pause and resume
// the sampling, i.e. SIGPROF is no longer sent. As a result, fork() pauses
// sampling of all threads, not just the threads that are forking.
static void PlatformInit(PSLockRef aLock) { /* Noop */ }
// The thread that we want to profile will construct an instance of
// PlatformData. The constructor can store platform specific data related to
// that thread to better suspend/resume it afterwards in
// Sampler::SuspendAndSampleAndResumeThread.
class PlatformData {
public:
explicit PlatformData(BaseProfilerThreadId aThreadId) { /* Noop */ }
};
// Prepare this thread to be sampled in the future.
// On linux and freebsd, we register a handler for SIGPROF.
Sampler::Sampler(PSLockRef aLock) { /* Noop */ }
// Restore modifications done in Constructor.
// On linux and freebsd, we deregister/restore the original SIGPROF handler.
void Sampler::Disable(PSLockRef aLock) { /* Noop */ }
template <typename Func>
void Sampler::SuspendAndSampleAndResumeThread(
PSLockRef aLock, const RegisteredThread& aRegisteredThread,
const TimeStamp& aNow, const Func& aProcessRegs) { /* Noop */ }
// Spawn a thread that calls mSampler->Run()
SamplerThread::SamplerThread(PSLockRef aLock, uint32_t aActivityGeneration,
double aIntervalMilliseconds, uint32_t aFeatures)
: mSampler(aLock),
mActivityGeneration(aActivityGeneration),
mIntervalMicroseconds(std::max(
1, int(floor(aIntervalMilliseconds * 1000 + 0.5)))) { /* Noop */ }
// Wait for the thread to terminate
SamplerThread::~SamplerThread() { /* Noop */ }
void SamplerThread::Stop(PSLockRef aLock) { mSampler.Disable(aLock); }
void SamplerThread::SleepMicro(uint32_t aMicroseconds) {
MOZ_CRASH("Not reachable because we never spawn SamplerThread");
}
} // namespace baseprofiler
} // namespace mozilla