mirror of
https://github.com/mozilla/gecko-dev.git
synced 2024-10-20 16:55:40 +00:00
8a68e6fb83
Currently the Gecko Profiler defines a moderate amount of stuff when MOZ_GECKO_PROFILER is undefined. It also #includes various headers, including JS ones. This is making it difficult to separate Gecko's media stack for inclusion in Servo. This patch greatly simplifies how things are exposed. The starting point is: - GeckoProfiler.h can be #included unconditionally; - everything else from the profiler must be guarded by MOZ_GECKO_PROFILER. In practice this introduces way too many #ifdefs, so the patch loosens it by adding no-op macros for a number of the most common operations. The net result is that #ifdefs and macros are used a bit more, but almost nothing is exposed in non-MOZ_GECKO_PROFILER builds (including ProfilerMarkerPayload.h and GeckoProfiler.h), and understanding what is exposed is much simpler than before. Note also that in BHR, ThreadStackHelper is now entirely absent in non-MOZ_GECKO_PROFILER builds.
238 lines
6.2 KiB
C++
238 lines
6.2 KiB
C++
/* -*- 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/. */
|
|
|
|
#include "MainThreadIOLogger.h"
|
|
|
|
#include "GeckoProfiler.h"
|
|
#include "IOInterposerPrivate.h"
|
|
#include "mozilla/IOInterposer.h"
|
|
#include "mozilla/StaticPtr.h"
|
|
#include "mozilla/TimeStamp.h"
|
|
#include "nsAutoPtr.h"
|
|
#include "nsNativeCharsetUtils.h"
|
|
#include "nsThreadUtils.h"
|
|
|
|
/**
|
|
* This code uses NSPR stuff and STL containers because it must be detached
|
|
* from leak checking code; this observer runs until the process terminates.
|
|
*/
|
|
|
|
#include <prenv.h>
|
|
#include <prprf.h>
|
|
#include <prthread.h>
|
|
#include <vector>
|
|
|
|
namespace {
|
|
|
|
struct ObservationWithStack
|
|
{
|
|
explicit ObservationWithStack(mozilla::IOInterposeObserver::Observation& aObs
|
|
#ifdef MOZ_GECKO_PROFILER
|
|
, ProfilerBacktrace* aStack
|
|
#endif
|
|
)
|
|
: mObservation(aObs)
|
|
#ifdef MOZ_GECKO_PROFILER
|
|
, mStack(aStack)
|
|
#endif
|
|
{
|
|
const char16_t* filename = aObs.Filename();
|
|
if (filename) {
|
|
mFilename = filename;
|
|
}
|
|
}
|
|
|
|
mozilla::IOInterposeObserver::Observation mObservation;
|
|
#ifdef MOZ_GECKO_PROFILER
|
|
ProfilerBacktrace* mStack;
|
|
#endif
|
|
nsString mFilename;
|
|
};
|
|
|
|
class MainThreadIOLoggerImpl final : public mozilla::IOInterposeObserver
|
|
{
|
|
public:
|
|
MainThreadIOLoggerImpl();
|
|
~MainThreadIOLoggerImpl();
|
|
|
|
bool Init();
|
|
|
|
void Observe(Observation& aObservation);
|
|
|
|
private:
|
|
static void sIOThreadFunc(void* aArg);
|
|
void IOThreadFunc();
|
|
|
|
TimeStamp mLogStartTime;
|
|
const char* mFileName;
|
|
PRThread* mIOThread;
|
|
IOInterposer::Monitor mMonitor;
|
|
bool mShutdownRequired;
|
|
std::vector<ObservationWithStack> mObservations;
|
|
};
|
|
|
|
static StaticAutoPtr<MainThreadIOLoggerImpl> sImpl;
|
|
|
|
MainThreadIOLoggerImpl::MainThreadIOLoggerImpl()
|
|
: mFileName(nullptr)
|
|
, mIOThread(nullptr)
|
|
, mShutdownRequired(false)
|
|
{
|
|
}
|
|
|
|
MainThreadIOLoggerImpl::~MainThreadIOLoggerImpl()
|
|
{
|
|
if (!mIOThread) {
|
|
return;
|
|
}
|
|
{
|
|
// Scope for lock
|
|
IOInterposer::MonitorAutoLock lock(mMonitor);
|
|
mShutdownRequired = true;
|
|
lock.Notify();
|
|
}
|
|
PR_JoinThread(mIOThread);
|
|
mIOThread = nullptr;
|
|
}
|
|
|
|
bool
|
|
MainThreadIOLoggerImpl::Init()
|
|
{
|
|
if (mFileName) {
|
|
// Already initialized
|
|
return true;
|
|
}
|
|
mFileName = PR_GetEnv("MOZ_MAIN_THREAD_IO_LOG");
|
|
if (!mFileName) {
|
|
// Can't start
|
|
return false;
|
|
}
|
|
mIOThread = PR_CreateThread(PR_USER_THREAD, &sIOThreadFunc, this,
|
|
PR_PRIORITY_LOW, PR_GLOBAL_THREAD,
|
|
PR_JOINABLE_THREAD, 0);
|
|
if (!mIOThread) {
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
/* static */ void
|
|
MainThreadIOLoggerImpl::sIOThreadFunc(void* aArg)
|
|
{
|
|
AUTO_PROFILER_REGISTER_THREAD("MainThreadIOLogger");
|
|
|
|
NS_SetCurrentThreadName("MainThreadIOLogger");
|
|
MainThreadIOLoggerImpl* obj = static_cast<MainThreadIOLoggerImpl*>(aArg);
|
|
obj->IOThreadFunc();
|
|
}
|
|
|
|
void
|
|
MainThreadIOLoggerImpl::IOThreadFunc()
|
|
{
|
|
PRFileDesc* fd = PR_Open(mFileName, PR_WRONLY | PR_CREATE_FILE | PR_TRUNCATE,
|
|
PR_IRUSR | PR_IWUSR | PR_IRGRP);
|
|
if (!fd) {
|
|
IOInterposer::MonitorAutoLock lock(mMonitor);
|
|
mShutdownRequired = true;
|
|
std::vector<ObservationWithStack>().swap(mObservations);
|
|
return;
|
|
}
|
|
mLogStartTime = TimeStamp::Now();
|
|
{
|
|
// Scope for lock
|
|
IOInterposer::MonitorAutoLock lock(mMonitor);
|
|
while (true) {
|
|
while (!mShutdownRequired && mObservations.empty()) {
|
|
lock.Wait();
|
|
}
|
|
if (mShutdownRequired) {
|
|
break;
|
|
}
|
|
// Pull events off the shared array onto a local one
|
|
std::vector<ObservationWithStack> observationsToWrite;
|
|
observationsToWrite.swap(mObservations);
|
|
|
|
// Release the lock so that we're not holding anybody up during I/O
|
|
IOInterposer::MonitorAutoUnlock unlock(mMonitor);
|
|
|
|
// Now write the events.
|
|
for (auto i = observationsToWrite.begin(), e = observationsToWrite.end();
|
|
i != e; ++i) {
|
|
if (i->mObservation.ObservedOperation() == OpNextStage) {
|
|
PR_fprintf(fd, "%f,NEXT-STAGE\n",
|
|
(TimeStamp::Now() - mLogStartTime).ToMilliseconds());
|
|
continue;
|
|
}
|
|
double durationMs = i->mObservation.Duration().ToMilliseconds();
|
|
nsAutoCString nativeFilename;
|
|
nativeFilename.AssignLiteral("(not available)");
|
|
if (!i->mFilename.IsEmpty()) {
|
|
if (NS_FAILED(NS_CopyUnicodeToNative(i->mFilename, nativeFilename))) {
|
|
nativeFilename.AssignLiteral("(conversion failed)");
|
|
}
|
|
}
|
|
/**
|
|
* Format:
|
|
* Start Timestamp (Milliseconds), Operation, Duration (Milliseconds), Event Source, Filename
|
|
*/
|
|
if (PR_fprintf(fd, "%f,%s,%f,%s,%s\n",
|
|
(i->mObservation.Start() - mLogStartTime).ToMilliseconds(),
|
|
i->mObservation.ObservedOperationString(), durationMs,
|
|
i->mObservation.Reference(), nativeFilename.get()) > 0) {
|
|
#ifdef MOZ_GECKO_PROFILER
|
|
// TODO: Write out the callstack
|
|
i->mStack = nullptr;
|
|
#endif
|
|
}
|
|
}
|
|
}
|
|
}
|
|
PR_Close(fd);
|
|
}
|
|
|
|
void
|
|
MainThreadIOLoggerImpl::Observe(Observation& aObservation)
|
|
{
|
|
if (!mFileName || !IsMainThread()) {
|
|
return;
|
|
}
|
|
IOInterposer::MonitorAutoLock lock(mMonitor);
|
|
if (mShutdownRequired) {
|
|
// The writer thread isn't running. Don't enqueue any more data.
|
|
return;
|
|
}
|
|
// Passing nullptr as aStack parameter for now
|
|
mObservations.push_back(ObservationWithStack(aObservation
|
|
#ifdef MOZ_GECKO_PROFILER
|
|
, nullptr
|
|
#endif
|
|
));
|
|
lock.Notify();
|
|
}
|
|
|
|
} // namespace
|
|
|
|
namespace mozilla {
|
|
|
|
namespace MainThreadIOLogger {
|
|
|
|
bool
|
|
Init()
|
|
{
|
|
nsAutoPtr<MainThreadIOLoggerImpl> impl(new MainThreadIOLoggerImpl());
|
|
if (!impl->Init()) {
|
|
return false;
|
|
}
|
|
sImpl = impl.forget();
|
|
IOInterposer::Register(IOInterposeObserver::OpAllWithStaging, sImpl);
|
|
return true;
|
|
}
|
|
|
|
} // namespace MainThreadIOLogger
|
|
|
|
} // namespace mozilla
|
|
|