mozilla
/
gecko-dev
зеркало из https://github.com/mozilla/gecko-dev.git
1
0
Форкнуть 0
Код Задачи Пакеты Проекты Релизы Вики Активность

Bug 1715257 - Remove Task Tracer code from the profiler, r=gerald,necko-reviewers. 

Differential Revision: https://phabricator.services.mozilla.com/D117996
This commit is contained in:
Florian Quèze 2021-06-17 06:12:10 +00:00
Родитель 32c5f87744
Коммит 7b4906a6bd
35 изменённых файлов: 25 добавлений и 1656 удалений
Показать статистику Скачать Patch файл Скачать Diff файл Показать все файлы Свернуть все файлы

10
devtools/client/performance-new/utils.js
Просмотреть файл

@ -208,7 +208,6 @@ function calculateOverhead(interval, bufferSize, features) {
features.includes("stackwalk") && periodicSampling ? 0.05 : 0;
const overheadFromJavaScript =
features.includes("js") && periodicSampling ? 0.05 : 0;
const overheadFromTaskTracer = features.includes("tasktracer") ? 0.05 : 0;
const overheadFromJSTracer = features.includes("jstracer") ? 0.05 : 0;
const overheadFromJSAllocations = features.includes("jsallocations")
? 0.05
@ -222,7 +221,6 @@ function calculateOverhead(interval, bufferSize, features) {
overheadFromBuffersize +
overheadFromStackwalk +
overheadFromJavaScript +
overheadFromTaskTracer +
overheadFromJSTracer +
overheadFromJSAllocations +
overheadFromNativeAllocations,
@ -372,14 +370,6 @@ const featureDescriptions = [
value: "seqstyle",
title: "Disable parallel traversal in styling.",
},
{
name: "TaskTracer",
value: "tasktracer",
title: "Enable TaskTracer",
experimental: true,
disabledReason:
"TaskTracer requires a custom build with the environment variable MOZ_TASK_TRACER set.",
},
{
name: "Screenshots",
value: "screenshots",

31
dom/events/EventDispatcher.cpp
Просмотреть файл

@ -66,13 +66,6 @@
#include "mozilla/TouchEvents.h"
#include "mozilla/Unused.h"
#ifdef MOZ_TASK_TRACER
# include "GeckoTaskTracer.h"
# include "mozilla/dom/Element.h"
# include "mozilla/Likely.h"
using namespace mozilla::tasktracer;
#endif
namespace mozilla {
using namespace dom;
@ -739,30 +732,6 @@ nsresult EventDispatcher::Dispatch(nsISupports* aTarget,
NS_ENSURE_TRUE(!nsContentUtils::IsInStableOrMetaStableState(),
NS_ERROR_DOM_INVALID_STATE_ERR);
#ifdef MOZ_TASK_TRACER
if (MOZ_UNLIKELY(mozilla::tasktracer::IsStartLogging())) {
nsAutoCString eventType;
nsAutoString eventTypeU16;
if (aDOMEvent) {
aDOMEvent->GetType(eventTypeU16);
} else {
Event::GetWidgetEventType(aEvent, eventTypeU16);
}
CopyUTF16toUTF8(eventTypeU16, eventType);
nsCOMPtr<Element> element = do_QueryInterface(aTarget);
nsAutoString elementId;
nsAutoString elementTagName;
if (element) {
element->GetId(elementId);
element->GetTagName(elementTagName);
}
AddLabel("Event [%s] dispatched at target [id:%s tag:%s]", eventType.get(),
NS_ConvertUTF16toUTF8(elementId).get(),
NS_ConvertUTF16toUTF8(elementTagName).get());
}
#endif
nsCOMPtr<EventTarget> target = do_QueryInterface(aTarget);
RefPtr<PerformanceEventTiming> eventTimingEntry;

14
ipc/chromium/src/base/message_loop.cc
Просмотреть файл

@ -33,10 +33,6 @@
# include "base/message_pump_android.h"
#endif
#include "nsISerialEventTarget.h"
#ifdef MOZ_TASK_TRACER
# include "GeckoTaskTracer.h"
# include "TracedTaskCommon.h"
#endif
#include "mozilla/ipc/MessagePump.h"
#include "nsThreadUtils.h"
@ -397,17 +393,7 @@ void MessageLoop::PostTask_Helper(already_AddRefed<nsIRunnable> task,
// Tasks should only be queued before or during the Run loop, not after.
MOZ_ASSERT(!shutting_down_);
#ifdef MOZ_TASK_TRACER
nsCOMPtr<nsIRunnable> tracedTask = task;
if (mozilla::tasktracer::IsStartLogging()) {
tracedTask = mozilla::tasktracer::CreateTracedRunnable(tracedTask.forget());
(static_cast<mozilla::tasktracer::TracedRunnable*>(tracedTask.get()))
->DispatchTask();
}
PendingTask pending_task(tracedTask.forget(), true);
#else
PendingTask pending_task(std::move(task), true);
#endif
if (delay_ms > 0) {
pending_task.delayed_run_time =

7
ipc/chromium/src/base/pickle.cc
Просмотреть файл

@ -26,14 +26,7 @@
static_assert(MOZ_ALIGNOF(Pickle::memberAlignmentType) >= MOZ_ALIGNOF(uint32_t),
"Insufficient alignment");
#ifndef MOZ_TASK_TRACER
static const uint32_t kHeaderSegmentCapacity = 64;
#else
// TaskTracer would add extra fields to the header to carry task ID and
// other information.
// \see class Message::HeaderTaskTracer
static const uint32_t kHeaderSegmentCapacity = 128;
#endif
static const uint32_t kDefaultSegmentCapacity = 4096;

8
ipc/chromium/src/base/thread.cc
Просмотреть файл

@ -16,10 +16,6 @@
#include "nsThreadUtils.h"
#include "nsThreadManager.h"
#ifdef MOZ_TASK_TRACER
# include "GeckoTaskTracer.h"
#endif
namespace base {
// This task is used to trigger the message loop to exit.
@ -198,10 +194,6 @@ void Thread::ThreadMain() {
mozilla::IOInterposer::UnregisterCurrentThread();
#ifdef MOZ_TASK_TRACER
mozilla::tasktracer::FreeTraceInfo();
#endif
// We can't receive messages anymore.
message_loop_ = NULL;
thread_id_ = 0;

5
ipc/chromium/src/chrome/common/ipc_channel_posix.cc
Просмотреть файл

@ -52,11 +52,6 @@ static const size_t kMaxIOVecSize = 256;
static const size_t kMaxIOVecSize = 16;
#endif
#ifdef MOZ_TASK_TRACER
# include "GeckoTaskTracerImpl.h"
using namespace mozilla::tasktracer;
#endif
using namespace mozilla::ipc;
namespace IPC {

86
ipc/chromium/src/chrome/common/ipc_message.cc
Просмотреть файл

@ -12,50 +12,28 @@
#if defined(OS_POSIX)
# include "chrome/common/file_descriptor_set_posix.h"
#endif
#ifdef MOZ_TASK_TRACER
# include "GeckoTaskTracerImpl.h"
#endif
#include <utility>
#include "nsISupportsImpl.h"
#ifdef MOZ_TASK_TRACER
using namespace mozilla::tasktracer;
# define MSG_HEADER_SZ \
(IsStartLogging() && GetOrCreateTraceInfo() == nullptr \
? sizeof(Header) \
: sizeof(HeaderTaskTracer))
#else
# define MSG_HEADER_SZ sizeof(Header)
#endif
namespace IPC {
//------------------------------------------------------------------------------
Message::~Message() { MOZ_COUNT_DTOR(IPC::Message); }
Message::Message() : Pickle(MSG_HEADER_SZ) {
Message::Message() : Pickle(sizeof(Header)) {
MOZ_COUNT_CTOR(IPC::Message);
header()->routing = header()->type = 0;
#if defined(OS_POSIX)
header()->num_fds = 0;
#endif
#ifdef MOZ_TASK_TRACER
if (UseTaskTracerHeader()) {
header()->flags.SetTaskTracer();
HeaderTaskTracer* _header = static_cast<HeaderTaskTracer*>(header());
GetCurTraceInfo(&_header->source_event_id, &_header->parent_task_id,
&_header->source_event_type);
}
#endif
}
Message::Message(int32_t routing_id, msgid_t type, uint32_t segment_capacity,
HeaderFlags flags, bool recordWriteLatency)
: Pickle(MSG_HEADER_SZ, segment_capacity) {
: Pickle(sizeof(Header), segment_capacity) {
MOZ_COUNT_CTOR(IPC::Message);
header()->routing = routing_id;
header()->type = type;
@ -68,31 +46,14 @@ Message::Message(int32_t routing_id, msgid_t type, uint32_t segment_capacity,
header()->seqno = 0;
#if defined(OS_MACOSX)
header()->cookie = 0;
#endif
#ifdef MOZ_TASK_TRACER
if (UseTaskTracerHeader()) {
header()->flags.SetTaskTracer();
HeaderTaskTracer* _header = static_cast<HeaderTaskTracer*>(header());
GetCurTraceInfo(&_header->source_event_id, &_header->parent_task_id,
&_header->source_event_type);
}
#endif
if (recordWriteLatency) {
create_time_ = mozilla::TimeStamp::Now();
}
}
#ifndef MOZ_TASK_TRACER
# define MSG_HEADER_SZ_DATA sizeof(Header)
#else
# define MSG_HEADER_SZ_DATA \
(reinterpret_cast<const Header*>(data)->flags.IsTaskTracer() \
? sizeof(HeaderTaskTracer) \
: sizeof(Header))
#endif
Message::Message(const char* data, int data_len)
: Pickle(MSG_HEADER_SZ_DATA, data, data_len) {
: Pickle(sizeof(Header), data, data_len) {
MOZ_COUNT_CTOR(IPC::Message);
}
@ -185,47 +146,10 @@ uint32_t Message::num_fds() const {
#endif
void Message::AssertAsLargeAsHeader() const {
MOZ_DIAGNOSTIC_ASSERT(size() >= MSG_HEADER_SZ);
MOZ_DIAGNOSTIC_ASSERT(CurrentSize() >= MSG_HEADER_SZ);
MOZ_DIAGNOSTIC_ASSERT(size() >= sizeof(Header));
MOZ_DIAGNOSTIC_ASSERT(CurrentSize() >= sizeof(Header));
// Our buffers should agree with what our header specifies.
MOZ_DIAGNOSTIC_ASSERT(size() == CurrentSize());
}
#ifdef MOZ_TASK_TRACER
void* MessageTask() { return reinterpret_cast<void*>(&MessageTask); }
void Message::TaskTracerDispatch() {
if (header()->flags.IsTaskTracer()) {
HeaderTaskTracer* _header = static_cast<HeaderTaskTracer*>(header());
_header->task_id = GenNewUniqueTaskId();
uintptr_t* vtab = reinterpret_cast<uintptr_t*>(&MessageTask);
LogVirtualTablePtr(_header->task_id, _header->source_event_id, vtab);
LogDispatch(_header->task_id, _header->parent_task_id,
_header->source_event_id, _header->source_event_type);
}
}
Message::AutoTaskTracerRun::AutoTaskTracerRun(Message& aMsg)
: mMsg(aMsg), mTaskId(0), mSourceEventId(0) {
if (mMsg.header()->flags.IsTaskTracer()) {
const HeaderTaskTracer* _header =
static_cast<HeaderTaskTracer*>(mMsg.header());
LogBegin(_header->task_id, _header->source_event_id);
SetCurTraceInfo(_header->source_event_id, _header->task_id,
_header->source_event_type);
mTaskId = _header->task_id;
mSourceEventId = _header->source_event_id;
} else {
SetCurTraceInfo(0, 0, SourceEventType::Unknown);
}
}
Message::AutoTaskTracerRun::~AutoTaskTracerRun() {
if (mTaskId) {
AddLabel("IPC Message %s", mMsg.name());
LogEnd(mTaskId, mSourceEventId);
}
}
#endif
} // namespace IPC

73
ipc/chromium/src/chrome/common/ipc_message.h
Просмотреть файл

@ -14,10 +14,6 @@
#include "mozilla/RefPtr.h"
#include "mozilla/TimeStamp.h"
#ifdef MOZ_TASK_TRACER
# include "GeckoTaskTracer.h"
#endif
#ifdef FUZZING
# include "mozilla/ipc/Faulty.h"
#endif
@ -105,9 +101,6 @@ class Message : public Pickle {
COMPRESS_BIT = 0x0200,
COMPRESSALL_BIT = 0x0400,
CONSTRUCTOR_BIT = 0x0800,
#ifdef MOZ_TASK_TRACER
TASKTRACER_BIT = 0x1000,
#endif
};
public:
@ -149,20 +142,12 @@ class Message : public Pickle {
bool IsReplyError() const { return (mFlags & REPLY_ERROR_BIT) != 0; }
#ifdef MOZ_TASK_TRACER
bool IsTaskTracer() const { return (mFlags & TASKTRACER_BIT) != 0; }
#endif
private:
void SetSync() { mFlags |= SYNC_BIT; }
void SetInterrupt() { mFlags |= INTERRUPT_BIT; }
void SetReply() { mFlags |= REPLY_BIT; }
void SetReplyError() { mFlags |= REPLY_ERROR_BIT; }
#ifdef MOZ_TASK_TRACER
void SetTaskTracer() { mFlags |= TASKTRACER_BIT; }
#endif
uint32_t mFlags;
};
@ -293,26 +278,11 @@ class Message : public Pickle {
// Used for async messages with no parameters.
static void Log(const Message* msg, std::wstring* l) {}
static int HeaderSizeFromData(const char* range_start,
const char* range_end) {
#ifdef MOZ_TASK_TRACER
return ((static_cast<unsigned int>(range_end - range_start) >=
sizeof(Header)) &&
(reinterpret_cast<const Header*>(range_start)
->flags.IsTaskTracer()))
? sizeof(HeaderTaskTracer)
: sizeof(Header);
#else
return sizeof(Header);
#endif
}
// Figure out how big the message starting at range_start is. Returns 0 if
// there's no enough data to determine (i.e., if [range_start, range_end) does
// not contain enough of the message header to know the size).
static uint32_t MessageSize(const char* range_start, const char* range_end) {
return Pickle::MessageSize(HeaderSizeFromData(range_start, range_end),
range_start, range_end);
return Pickle::MessageSize(sizeof(Header), range_start, range_end);
}
#if defined(OS_POSIX)
@ -340,19 +310,6 @@ class Message : public Pickle {
#endif
friend class mozilla::ipc::MiniTransceiver;
#ifdef MOZ_TASK_TRACER
void TaskTracerDispatch();
class AutoTaskTracerRun : public mozilla::tasktracer::AutoSaveCurTraceInfo {
Message& mMsg;
uint64_t mTaskId;
uint64_t mSourceEventId;
public:
explicit AutoTaskTracerRun(Message& aMsg);
~AutoTaskTracerRun();
};
#endif
#if !defined(OS_MACOSX)
protected:
#endif
@ -381,36 +338,8 @@ class Message : public Pickle {
int32_t seqno;
};
#ifdef MOZ_TASK_TRACER
/**
* The type is used as headers of Messages only if TaskTracer is
* enabled, or type |Header| would be used instead.
*/
struct HeaderTaskTracer : public Header {
uint64_t task_id;
uint64_t source_event_id;
uint64_t parent_task_id;
mozilla::tasktracer::SourceEventType source_event_type;
};
#endif
#ifdef MOZ_TASK_TRACER
bool UseTaskTracerHeader() const {
return sizeof(HeaderTaskTracer) == (size() - payload_size());
}
Header* header() {
return UseTaskTracerHeader() ? headerT<HeaderTaskTracer>()
: headerT<Header>();
}
const Header* header() const {
return UseTaskTracerHeader() ? headerT<HeaderTaskTracer>()
: headerT<Header>();
}
#else
Header* header() { return headerT<Header>(); }
const Header* header() const { return headerT<Header>(); }
#endif
#if defined(OS_POSIX)
// The set of file descriptors associated with this message.

23
ipc/glue/MessageChannel.cpp
Просмотреть файл

@ -40,11 +40,6 @@
# include "mozilla/gfx/Logging.h"
#endif
#ifdef MOZ_TASK_TRACER
# include "GeckoTaskTracer.h"
using namespace mozilla::tasktracer;
#endif
// Undo the damage done by mozzconf.h
#undef compress
@ -1301,9 +1296,6 @@ void MessageChannel::OnMessageReceivedFromLink(Message&& aMsg) {
// blocked. This is okay, since we always check for pending events before
// blocking again.
#ifdef MOZ_TASK_TRACER
aMsg.TaskTracerDispatch();
#endif
RefPtr<MessageTask> task = new MessageTask(this, std::move(aMsg));
mPending.insertBack(task);
@ -1416,9 +1408,6 @@ bool MessageChannel::Send(UniquePtr<Message> aMsg, Message* aReply) {
NeuteredWindowRegion neuteredRgn(mFlags &
REQUIRE_DEFERRED_MESSAGE_PROTECTION);
#endif
#ifdef MOZ_TASK_TRACER
AutoScopedLabel autolabel("sync message %s", aMsg->name());
#endif
CxxStackFrame f(*this, OUT_MESSAGE, aMsg.get());
@ -1626,9 +1615,6 @@ bool MessageChannel::Call(UniquePtr<Message> aMsg, Message* aReply) {
#ifdef OS_WIN
SyncStackFrame frame(this, true);
#endif
#ifdef MOZ_TASK_TRACER
AutoScopedLabel autolabel("sync message %s", aMsg->name());
#endif
// This must come before MonitorAutoLock, as its destructor acquires the
// monitor lock.
@ -1780,9 +1766,6 @@ bool MessageChannel::Call(UniquePtr<Message> aMsg, Message* aReply) {
// own the monitor.
size_t stackDepth = InterruptStackDepth();
{
#ifdef MOZ_TASK_TRACER
Message::AutoTaskTracerRun tasktracerRun(recvd);
#endif
MonitorAutoUnlock unlock(*mMonitor);
CxxStackFrame frame(*this, IN_MESSAGE, &recvd);
@ -2079,9 +2062,6 @@ void MessageChannel::DispatchMessage(Message&& aMsg) {
MOZ_RELEASE_ASSERT(!aMsg.is_sync() || id == transaction.TransactionID());
{
#ifdef MOZ_TASK_TRACER
Message::AutoTaskTracerRun tasktracerRun(aMsg);
#endif
MonitorAutoUnlock unlock(*mMonitor);
CxxStackFrame frame(*this, IN_MESSAGE, &aMsg);
@ -2126,9 +2106,6 @@ void MessageChannel::DispatchSyncMessage(ActorLifecycleProxy* aProxy,
MOZ_RELEASE_ASSERT(nestedLevel == IPC::Message::NOT_NESTED ||
NS_IsMainThread());
#ifdef MOZ_TASK_TRACER
AutoScopedLabel autolabel("sync message %s", aMsg.name());
#endif
MessageChannel* dummy;
MessageChannel*& blockingVar =

23
layout/base/PresShell.cpp
Просмотреть файл

@ -209,11 +209,6 @@
#include "VisualViewport.h"
#include "ZoomConstraintsClient.h"
#ifdef MOZ_TASK_TRACER
# include "GeckoTaskTracer.h"
using namespace mozilla::tasktracer;
#endif
// define the scalfactor of drag and drop images
// relative to the max screen height/width
#define RELATIVE_SCALEFACTOR 0.0925f
@ -6838,24 +6833,6 @@ nsresult PresShell::EventHandler::HandleEvent(nsIFrame* aFrameForPresShell,
MOZ_DIAGNOSTIC_ASSERT(aGUIEvent->IsTrusted());
MOZ_ASSERT(aEventStatus);
#ifdef MOZ_TASK_TRACER
Maybe<AutoSourceEvent> taskTracerEvent;
if (MOZ_UNLIKELY(IsStartLogging())) {
// Make touch events, mouse events and hardware key events to be
// the source events of TaskTracer, and originate the rest
// correlation tasks from here.
SourceEventType type = SourceEventType::Unknown;
if (aGUIEvent->AsTouchEvent()) {
type = SourceEventType::Touch;
} else if (aGUIEvent->AsMouseEvent()) {
type = SourceEventType::Mouse;
} else if (aGUIEvent->AsKeyboardEvent()) {
type = SourceEventType::Key;
}
taskTracerEvent.emplace(type);
}
#endif
NS_ASSERTION(aFrameForPresShell, "aFrameForPresShell should be not null");
// Update the latest focus sequence number with this new sequence number;

1
mozglue/baseprofiler/core/platform.cpp
Просмотреть файл

@ -223,7 +223,6 @@ static uint32_t AvailableFeatures() {
#if !defined(HAVE_NATIVE_UNWIND)
ProfilerFeature::ClearStackWalk(features);
#endif
ProfilerFeature::ClearTaskTracer(features);
ProfilerFeature::ClearJSTracer(features);
return features;

21
mozglue/baseprofiler/public/BaseProfilerState.h
Просмотреть файл

@ -166,34 +166,31 @@ class MOZ_RAII AutoProfilerStats {
MACRO(9, "stackwalk", StackWalk, \
"Walk the C++ stack, not available on all platforms") \
\
MACRO(10, "tasktracer", TaskTracer, \
"Start profiling with feature TaskTracer") \
MACRO(10, "threads", Threads, "Profile the registered secondary threads") \
\
MACRO(11, "threads", Threads, "Profile the registered secondary threads") \
MACRO(11, "jstracer", JSTracer, "Enable tracing of the JavaScript engine") \
\
MACRO(12, "jstracer", JSTracer, "Enable tracing of the JavaScript engine") \
\
MACRO(13, "jsallocations", JSAllocations, \
MACRO(12, "jsallocations", JSAllocations, \
"Have the JavaScript engine track allocations") \
\
MACRO(14, "nostacksampling", NoStackSampling, \
MACRO(13, "nostacksampling", NoStackSampling, \
"Disable all stack sampling: Cancels \"js\", \"leaf\", " \
"\"stackwalk\" and labels") \
\
MACRO(15, "preferencereads", PreferenceReads, \
MACRO(14, "preferencereads", PreferenceReads, \
"Track when preferences are read") \
\
MACRO(16, "nativeallocations", NativeAllocations, \
MACRO(15, "nativeallocations", NativeAllocations, \
"Collect the stacks from a smaller subset of all native " \
"allocations, biasing towards collecting larger allocations") \
\
MACRO(17, "ipcmessages", IPCMessages, \
MACRO(16, "ipcmessages", IPCMessages, \
"Have the IPC layer track cross-process messages") \
\
MACRO(18, "audiocallbacktracing", AudioCallbackTracing, \
MACRO(17, "audiocallbacktracing", AudioCallbackTracing, \
"Audio callback tracing") \
\
MACRO(19, "cpu", CPUUtilization, "CPU utilization")
MACRO(18, "cpu", CPUUtilization, "CPU utilization")
struct ProfilerFeature {
# define DECLARE(n_, str_, Name_, desc_) \

20
netwerk/base/nsSocketTransportService2.cpp
Просмотреть файл

@ -29,10 +29,6 @@
#include "prerror.h"
#include "prnetdb.h"
#ifdef MOZ_TASK_TRACER
# include "GeckoTaskTracer.h"
#endif
namespace mozilla {
namespace net {
@ -420,10 +416,6 @@ nsresult nsSocketTransportService::DetachSocket(SocketContext* listHead,
"DetachSocket invalid head");
{
#ifdef MOZ_TASK_TRACER
tasktracer::AutoSourceEvent taskTracerEvent(
tasktracer::SourceEventType::SocketIO);
#endif
// inform the handler that this socket is going away
sock->mHandler->OnSocketDetached(sock->mFD);
}
@ -1357,17 +1349,9 @@ nsresult nsSocketTransportService::DoPollIteration(TimeDuration* pollDuration) {
PRPollDesc& desc = mPollList[i + 1];
SocketContext& s = mActiveList[i];
if (n > 0 && desc.out_flags != 0) {
#ifdef MOZ_TASK_TRACER
tasktracer::AutoSourceEvent taskTracerEvent(
tasktracer::SourceEventType::SocketIO);
#endif
s.DisengageTimeout();
s.mHandler->OnSocketReady(desc.fd, desc.out_flags);
} else if (s.IsTimedOut(now)) {
#ifdef MOZ_TASK_TRACER
tasktracer::AutoSourceEvent taskTracerEvent(
tasktracer::SourceEventType::SocketIO);
#endif
SOCKET_LOG(("socket %p timed out", s.mHandler));
s.DisengageTimeout();
s.mHandler->OnSocketReady(desc.fd, -1);
@ -1541,10 +1525,6 @@ void nsSocketTransportService::NotifyKeepaliveEnabledPrefChange(
return;
}
#ifdef MOZ_TASK_TRACER
tasktracer::AutoSourceEvent taskTracerEvent(
tasktracer::SourceEventType::SocketIO);
#endif
sock->mHandler->OnKeepaliveEnabledPrefChange(mKeepaliveEnabledPref);
}

11
netwerk/cache2/CacheIOThread.cpp
Просмотреть файл

@ -24,11 +24,6 @@
# include <windows.h>
#endif
#ifdef MOZ_TASK_TRACER
# include "GeckoTaskTracer.h"
# include "TracedTaskCommon.h"
#endif
namespace mozilla::net {
namespace { // anon
@ -291,12 +286,6 @@ nsresult CacheIOThread::DispatchAfterPendingOpens(nsIRunnable* aRunnable) {
nsresult CacheIOThread::DispatchInternal(
already_AddRefed<nsIRunnable> aRunnable, uint32_t aLevel) {
nsCOMPtr<nsIRunnable> runnable(aRunnable);
#ifdef MOZ_TASK_TRACER
if (tasktracer::IsStartLogging()) {
runnable = tasktracer::CreateTracedRunnable(runnable.forget());
(static_cast<tasktracer::TracedRunnable*>(runnable.get()))->DispatchTask();
}
#endif
LogRunnable::LogDispatch(runnable.get());

14
netwerk/protocol/http/HttpChannelChild.cpp
Просмотреть файл

@ -64,10 +64,6 @@
#include "ClassifierDummyChannel.h"
#include "nsIOService.h"
#ifdef MOZ_TASK_TRACER
# include "GeckoTaskTracer.h"
#endif
#include <functional>
using namespace mozilla::dom;
@ -1975,16 +1971,6 @@ nsresult HttpChannelChild::AsyncOpenInternal(nsIStreamListener* aListener) {
mAsyncOpenTime = TimeStamp::Now();
}
#ifdef MOZ_TASK_TRACER
if (tasktracer::IsStartLogging()) {
nsCOMPtr<nsIURI> uri;
GetURI(getter_AddRefs(uri));
nsAutoCString urispec;
uri->GetSpec(urispec);
tasktracer::AddLabel("HttpChannelChild::AsyncOpen %s", urispec.get());
}
#endif
// Port checked in parent, but duplicate here so we can return with error
// immediately
rv = NS_CheckPortSafety(mURI);

15
netwerk/protocol/http/nsHttpChannel.cpp
Просмотреть файл

@ -138,10 +138,6 @@
# include "HttpWinUtils.h"
#endif
#ifdef MOZ_TASK_TRACER
# include "GeckoTaskTracer.h"
#endif
namespace mozilla {
using namespace dom;
@ -5676,17 +5672,6 @@ nsHttpChannel::AsyncOpen(nsIStreamListener* aListener) {
LOG(("nsHttpChannel::AsyncOpen [this=%p]\n", this));
LogCallingScriptLocation(this);
#ifdef MOZ_TASK_TRACER
if (tasktracer::IsStartLogging()) {
uint64_t sourceEventId, parentTaskId;
tasktracer::SourceEventType sourceEventType;
GetCurTraceInfo(&sourceEventId, &parentTaskId, &sourceEventType);
nsAutoCString urispec;
mURI->GetSpec(urispec);
tasktracer::AddLabel("nsHttpChannel::AsyncOpen %s", urispec.get());
}
#endif
#ifdef MOZ_GECKO_PROFILER
mLastStatusReported =
TimeStamp::Now(); // in case we enable the profiler after AsyncOpen()

12
netwerk/protocol/http/nsHttpHandler.cpp
Просмотреть файл

@ -96,10 +96,6 @@
# include "nsCocoaFeatures.h"
#endif
#ifdef MOZ_TASK_TRACER
# include "GeckoTaskTracer.h"
#endif
//-----------------------------------------------------------------------------
#include "mozilla/net/HttpChannelChild.h"
@ -1981,14 +1977,6 @@ nsresult nsHttpHandler::SetupChannelInternal(
nsIChannel** result) {
RefPtr<HttpBaseChannel> httpChannel = aChannel;
#ifdef MOZ_TASK_TRACER
if (tasktracer::IsStartLogging()) {
nsAutoCString urispec;
uri->GetSpec(urispec);
tasktracer::AddLabel("nsHttpHandler::NewProxiedChannel2 %s", urispec.get());
}
#endif
nsCOMPtr<nsProxyInfo> proxyInfo;
if (givenProxyInfo) {
proxyInfo = do_QueryInterface(givenProxyInfo);

1
toolkit/components/extensions/schemas/geckoProfiler.json
Просмотреть файл

@ -31,7 +31,6 @@
"screenshots",
"seqstyle",
"stackwalk",
"tasktracer",
"threads",
"jstracer",
"jsallocations",

8
toolkit/moz.configure
Просмотреть файл

@ -1592,14 +1592,6 @@ set_define(
depends_if("--enable-bundled-fonts", when=allow_bundled_fonts)(lambda _: True),
)
# TaskTracer
# ==============================================================
option("--enable-tasktracer", help="Enable TaskTracer")
set_define("MOZ_TASK_TRACER", depends_if("--enable-tasktracer")(lambda _: True))
set_config("MOZ_TASK_TRACER", depends_if("--enable-tasktracer")(lambda _: True))
# Reflow counting
# ==============================================================

2
toolkit/toolkit.mozbuild
Просмотреть файл

@ -192,7 +192,7 @@ if CONFIG['ENABLE_TESTS']:
if CONFIG['MOZ_MEMORY']:
DIRS += ['/memory/gtest']
if CONFIG['MOZ_WEBRTC'] and not CONFIG['MOZ_TASK_TRACER']:
if CONFIG['MOZ_WEBRTC']:
DIRS += [
'/dom/media/webrtc/transport/test',
]

82
tools/profiler/core/platform.cpp
Просмотреть файл

@ -96,10 +96,6 @@
#include <sstream>
#include <type_traits>
#ifdef MOZ_TASK_TRACER
# include "GeckoTaskTracer.h"
#endif
#if defined(GP_OS_android)
# include "mozilla/java/GeckoJavaSamplerNatives.h"
#endif
@ -246,9 +242,6 @@ static uint32_t AvailableFeatures() {
#if !defined(HAVE_NATIVE_UNWIND)
ProfilerFeature::ClearStackWalk(features);
#endif
#if !defined(MOZ_TASK_TRACER)
ProfilerFeature::ClearTaskTracer(features);
#endif
#if defined(MOZ_REPLACE_MALLOC) && defined(MOZ_PROFILER_MEMORY)
if (getenv("XPCOM_MEM_BLOAT_LOG")) {
NS_WARNING("XPCOM_MEM_BLOAT_LOG is set, disabling native allocations.");
@ -2555,54 +2548,6 @@ void AppendSharedLibraries(JSONWriter& aWriter) {
}
}
#ifdef MOZ_TASK_TRACER
static void StreamNameAndThreadId(JSONWriter& aWriter, const char* aName,
int aThreadId) {
aWriter.StartObjectElement();
{
if (XRE_GetProcessType() == GeckoProcessType_Plugin) {
// TODO Add the proper plugin name
aWriter.StringProperty("name", "Plugin");
} else {
aWriter.StringProperty("name", aName);
}
aWriter.IntProperty("tid", aThreadId);
}
aWriter.EndObject();
}
#endif
static void StreamTaskTracer(PSLockRef aLock, SpliceableJSONWriter& aWriter) {
#ifdef MOZ_TASK_TRACER
MOZ_RELEASE_ASSERT(CorePS::Exists() && ActivePS::Exists(aLock));
aWriter.StartArrayProperty("data");
{
UniquePtr<Vector<nsCString>> data =
tasktracer::GetLoggedData(CorePS::ProcessStartTime());
for (const nsCString& dataString : *data) {
aWriter.StringElement(dataString.get());
}
}
aWriter.EndArray();
aWriter.StartArrayProperty("threads");
{
ActivePS::DiscardExpiredDeadProfiledThreads(aLock);
Vector<std::pair<RegisteredThread*, ProfiledThreadData*>> threads =
ActivePS::ProfiledThreads(aLock);
for (auto& thread : threads) {
RefPtr<ThreadInfo> info = thread.second->Info();
StreamNameAndThreadId(aWriter, info->Name(), info->ThreadId());
}
}
aWriter.EndArray();
aWriter.DoubleProperty("start",
static_cast<double>(tasktracer::GetStartTime()));
#endif
}
static void StreamCategories(SpliceableJSONWriter& aWriter) {
// Same order as ProfilingCategory. Format:
// [
@ -3078,13 +3023,6 @@ static void locked_profiler_stream_json_for_this_process(
aSinceTime);
buffer.StreamCountersToJSON(aWriter, CorePS::ProcessStartTime(), aSinceTime);
// Data of TaskTracer doesn't belong in the circular buffer.
if (ActivePS::FeatureTaskTracer(aLock)) {
aWriter.StartObjectProperty("tasktracer");
StreamTaskTracer(aLock, aWriter);
aWriter.EndObject();
}
// Lists the samples for each thread profile
aWriter.StartArrayProperty("threads");
{
@ -4392,10 +4330,6 @@ void profiler_init(void* aStackTop) {
// Platform-specific initialization.
PlatformInit(lock);
#ifdef MOZ_TASK_TRACER
tasktracer::InitTaskTracer();
#endif
#if defined(GP_OS_android)
if (jni::IsAvailable()) {
GeckoJavaSampler::Init();
@ -4586,10 +4520,6 @@ void profiler_shutdown(IsFastShutdown aIsFastShutdown) {
// We can also clear the AutoProfilerLabel's ProfilingStack because the
// main thread should not use labels after profiler_shutdown.
TLSRegisteredThread::ResetAutoProfilerLabelProfilingStack(lock);
#ifdef MOZ_TASK_TRACER
tasktracer::ShutdownTaskTracer();
#endif
}
// We do these operations with gPSMutex unlocked. The comments in
@ -5031,12 +4961,6 @@ static void locked_profiler_start(PSLockRef aLock, PowerOfTwo32 aCapacity,
// Setup support for pushing/popping labels in mozglue.
RegisterProfilerLabelEnterExit(MozGlueLabelEnter, MozGlueLabelExit);
#ifdef MOZ_TASK_TRACER
if (ActivePS::FeatureTaskTracer(aLock)) {
tasktracer::StartLogging();
}
#endif
#if defined(GP_OS_android)
if (ActivePS::FeatureJava(aLock)) {
int javaInterval = interval;
@ -5185,12 +5109,6 @@ void profiler_ensure_started(PowerOfTwo32 aCapacity, double aInterval,
}
#endif
#ifdef MOZ_TASK_TRACER
if (ActivePS::FeatureTaskTracer(aLock)) {
tasktracer::StopLogging();
}
#endif
// Remove support for pushing/popping labels in mozglue.
RegisterProfilerLabelEnterExit(nullptr, nullptr);

12
tools/profiler/moz.build
Просмотреть файл

@ -154,18 +154,6 @@ EXPORTS.mozilla += [
"public/ProfilerState.h",
]
if CONFIG["MOZ_TASK_TRACER"]:
EXPORTS += [
"tasktracer/GeckoTaskTracer.h",
"tasktracer/GeckoTaskTracerImpl.h",
"tasktracer/SourceEventTypeMap.h",
"tasktracer/TracedTaskCommon.h",
]
UNIFIED_SOURCES += [
"tasktracer/GeckoTaskTracer.cpp",
"tasktracer/TracedTaskCommon.cpp",
]
XPCSHELL_TESTS_MANIFESTS += ["tests/xpcshell/xpcshell.ini"]
MOCHITEST_CHROME_MANIFESTS += ["tests/chrome/chrome.ini"]
BROWSER_CHROME_MANIFESTS += ["tests/browser/browser.ini"]

21
tools/profiler/public/ProfilerState.h
Просмотреть файл

@ -51,34 +51,31 @@
MACRO(9, "stackwalk", StackWalk, \
"Walk the C++ stack, not available on all platforms") \
\
MACRO(10, "tasktracer", TaskTracer, \
"Start profiling with feature TaskTracer") \
MACRO(10, "threads", Threads, "Profile the registered secondary threads") \
\
MACRO(11, "threads", Threads, "Profile the registered secondary threads") \
MACRO(11, "jstracer", JSTracer, "Enable tracing of the JavaScript engine") \
\
MACRO(12, "jstracer", JSTracer, "Enable tracing of the JavaScript engine") \
\
MACRO(13, "jsallocations", JSAllocations, \
MACRO(12, "jsallocations", JSAllocations, \
"Have the JavaScript engine track allocations") \
\
MACRO(14, "nostacksampling", NoStackSampling, \
MACRO(13, "nostacksampling", NoStackSampling, \
"Disable all stack sampling: Cancels \"js\", \"leaf\", " \
"\"stackwalk\" and labels") \
\
MACRO(15, "preferencereads", PreferenceReads, \
MACRO(14, "preferencereads", PreferenceReads, \
"Track when preferences are read") \
\
MACRO(16, "nativeallocations", NativeAllocations, \
MACRO(15, "nativeallocations", NativeAllocations, \
"Collect the stacks from a smaller subset of all native " \
"allocations, biasing towards collecting larger allocations") \
\
MACRO(17, "ipcmessages", IPCMessages, \
MACRO(16, "ipcmessages", IPCMessages, \
"Have the IPC layer track cross-process messages") \
\
MACRO(18, "audiocallbacktracing", AudioCallbackTracing, \
MACRO(17, "audiocallbacktracing", AudioCallbackTracing, \
"Audio callback tracing") \
\
MACRO(19, "cpu", CPUUtilization, "CPU utilization")
MACRO(18, "cpu", CPUUtilization, "CPU utilization")
struct ProfilerFeature {
#define DECLARE(n_, str_, Name_, desc_) \

464
tools/profiler/tasktracer/GeckoTaskTracer.cpp
Просмотреть файл

@ -1,464 +0,0 @@
/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* vim:set ts=2 sw=2 sts=2 et cindent: */
/* 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 "GeckoTaskTracer.h"
#include "GeckoTaskTracerImpl.h"
#include "platform.h"
#include "mozilla/DebugOnly.h"
#include "mozilla/MathAlgorithms.h"
#include "mozilla/StaticMutex.h"
#include "mozilla/ThreadLocal.h"
#include "mozilla/TimeStamp.h"
#include "mozilla/UniquePtr.h"
#include "mozilla/Unused.h"
#include "nsString.h"
#include "nsThreadUtils.h"
#include "prtime.h"
#include <stdarg.h>
#define MAX_SIZE_LOG (1024 * 128)
// NS_ENSURE_TRUE_VOID() without the warning on the debug build.
#define ENSURE_TRUE_VOID(x) \
do { \
if (MOZ_UNLIKELY(!(x))) { \
return; \
} \
} while (0)
// NS_ENSURE_TRUE() without the warning on the debug build.
#define ENSURE_TRUE(x, ret) \
do { \
if (MOZ_UNLIKELY(!(x))) { \
return ret; \
} \
} while (0)
namespace mozilla {
namespace tasktracer {
#define SOURCE_EVENT_NAME(type) \
const char* CreateSourceEvent##type() { return "SourceEvent" #type; }
#include "SourceEventTypeMap.h"
#undef SOURCE_EVENT_NAME
static MOZ_THREAD_LOCAL(TraceInfo*) sTraceInfoTLS;
static mozilla::StaticMutex sMutex;
// The generation of TraceInfo. It will be > 0 if the Task Tracer is started and
// <= 0 if stopped.
bool gStarted(false);
static nsTArray<UniquePtr<TraceInfo>>* sTraceInfos = nullptr;
static PRTime sStartTime;
static const char sJSLabelPrefix[] = "#tt#";
namespace {
static PRTime GetTimestamp() { return PR_Now() / 1000; }
static TraceInfo* AllocTraceInfo(int aTid) {
sMutex.AssertCurrentThreadOwns();
MOZ_ASSERT(sTraceInfos);
auto* info = sTraceInfos->AppendElement(MakeUnique<TraceInfo>(aTid));
return info->get();
}
static void CreateSourceEvent(SourceEventType aType) {
// Create a new unique task id.
uint64_t newId = GenNewUniqueTaskId();
{
TraceInfoHolder info = GetOrCreateTraceInfo();
ENSURE_TRUE_VOID(info);
info->mCurTraceSourceId = newId;
info->mCurTraceSourceType = aType;
info->mCurTaskId = newId;
}
uintptr_t* namePtr;
#define SOURCE_EVENT_NAME(type) \
case SourceEventType::type: { \
namePtr = (uintptr_t*)&CreateSourceEvent##type; \
break; \
}
switch (aType) {
#include "SourceEventTypeMap.h"
default:
MOZ_CRASH("Unknown SourceEvent.");
}
#undef SOURCE_EVENT_NAME
// Log a fake dispatch and start for this source event.
LogDispatch(newId, newId, newId, aType);
LogVirtualTablePtr(newId, newId, namePtr);
LogBegin(newId, newId);
}
static void DestroySourceEvent() {
// Log a fake end for this source event.
TraceInfoHolder info = GetOrCreateTraceInfo();
ENSURE_TRUE_VOID(info);
uint64_t curTraceSourceId;
curTraceSourceId = info->mCurTraceSourceId;
info.Reset();
LogEnd(curTraceSourceId, curTraceSourceId);
}
inline static void ObsoleteCurrentTraceInfos() {
MOZ_ASSERT(sTraceInfos);
for (uint32_t i = 0; i < sTraceInfos->Length(); ++i) {
(*sTraceInfos)[i]->mObsolete = true;
}
}
static void SetLogStarted(bool aIsStartLogging) {
MOZ_ASSERT(aIsStartLogging != gStarted);
StaticMutexAutoLock lock(sMutex);
gStarted = aIsStartLogging;
if (aIsStartLogging && sTraceInfos == nullptr) {
sTraceInfos = new nsTArray<UniquePtr<TraceInfo>>();
}
if (!aIsStartLogging && sTraceInfos) {
ObsoleteCurrentTraceInfos();
}
}
} // namespace
TraceInfoLogType* TraceInfo::AppendLog() {
if (mLogsSize >= MAX_SIZE_LOG) {
return nullptr;
}
TraceInfoLogNode* node = new TraceInfoLogNode;
node->mNext = nullptr;
if (mLogsTail) {
mLogsTail->mNext = node;
mLogsTail = node;
} else {
mLogsTail = mLogsHead = node;
}
mLogsSize++;
return &node->mLog;
}
void InitTaskTracer(uint32_t aFlags) {
StaticMutexAutoLock lock(sMutex);
if (aFlags & FORKED_AFTER_NUWA) {
ObsoleteCurrentTraceInfos();
return;
}
MOZ_ASSERT(!sTraceInfos);
bool success = sTraceInfoTLS.init();
if (!success) {
MOZ_CRASH();
}
}
void ShutdownTaskTracer() {
if (IsStartLogging()) {
SetLogStarted(false);
StaticMutexAutoLock lock(sMutex);
// Make sure all threads are out of holding mutics.
// See |GetOrCreateTraceInfo()|
for (auto& traceinfo : *sTraceInfos) {
MutexAutoLock lock(traceinfo->mLogsMutex);
}
delete sTraceInfos;
sTraceInfos = nullptr;
}
}
static void FreeTraceInfo(TraceInfo* aTraceInfo) {
sMutex.AssertCurrentThreadOwns();
if (aTraceInfo) {
UniquePtr<TraceInfo> traceinfo(aTraceInfo);
mozilla::DebugOnly<bool> removed = sTraceInfos->RemoveElement(traceinfo);
MOZ_ASSERT(removed);
Unused << traceinfo.release(); // A dirty hack to prevent double free.
}
}
void FreeTraceInfo() {
StaticMutexAutoLock lock(sMutex);
if (sTraceInfos) {
FreeTraceInfo(sTraceInfoTLS.get());
}
}
TraceInfoHolder GetOrCreateTraceInfo() {
TraceInfo* info = sTraceInfoTLS.get();
StaticMutexAutoLock lock(sMutex);
ENSURE_TRUE(IsStartLogging(), TraceInfoHolder{});
if (info && info->mObsolete) {
// TraceInfo is obsolete: remove it.
FreeTraceInfo(info);
info = nullptr;
}
if (!info) {
info = AllocTraceInfo(profiler_current_thread_id());
sTraceInfoTLS.set(info);
}
return TraceInfoHolder{info}; // |mLogsMutex| will be held, then
// ||sMutex| will be released for
// efficiency reason.
}
uint64_t GenNewUniqueTaskId() {
TraceInfoHolder info = GetOrCreateTraceInfo();
ENSURE_TRUE(info, 0);
int tid = profiler_current_thread_id();
uint64_t taskid = ((uint64_t)tid << 32) | ++info->mLastUniqueTaskId;
return taskid;
}
AutoSaveCurTraceInfoImpl::AutoSaveCurTraceInfoImpl() {
GetCurTraceInfo(&mSavedSourceEventId, &mSavedTaskId, &mSavedSourceEventType);
}
AutoSaveCurTraceInfoImpl::~AutoSaveCurTraceInfoImpl() {
SetCurTraceInfo(mSavedSourceEventId, mSavedTaskId, mSavedSourceEventType);
}
void SetCurTraceInfo(uint64_t aSourceEventId, uint64_t aParentTaskId,
SourceEventType aSourceEventType) {
TraceInfoHolder info = GetOrCreateTraceInfo();
ENSURE_TRUE_VOID(info);
info->mCurTraceSourceId = aSourceEventId;
info->mCurTaskId = aParentTaskId;
info->mCurTraceSourceType = aSourceEventType;
}
void GetCurTraceInfo(uint64_t* aOutSourceEventId, uint64_t* aOutParentTaskId,
SourceEventType* aOutSourceEventType) {
TraceInfoHolder info = GetOrCreateTraceInfo();
ENSURE_TRUE_VOID(info);
*aOutSourceEventId = info->mCurTraceSourceId;
*aOutParentTaskId = info->mCurTaskId;
*aOutSourceEventType = info->mCurTraceSourceType;
}
void LogDispatch(uint64_t aTaskId, uint64_t aParentTaskId,
uint64_t aSourceEventId, SourceEventType aSourceEventType) {
LogDispatch(aTaskId, aParentTaskId, aSourceEventId, aSourceEventType, 0);
}
void LogDispatch(uint64_t aTaskId, uint64_t aParentTaskId,
uint64_t aSourceEventId, SourceEventType aSourceEventType,
int aDelayTimeMs) {
TraceInfoHolder info = GetOrCreateTraceInfo();
ENSURE_TRUE_VOID(info);
// aDelayTimeMs is the expected delay time in milliseconds, thus the dispatch
// time calculated of it might be slightly off in the real world.
uint64_t time =
(aDelayTimeMs <= 0) ? GetTimestamp() : GetTimestamp() + aDelayTimeMs;
// Log format:
// [0 taskId dispatchTime sourceEventId sourceEventType parentTaskId]
TraceInfoLogType* log = info->AppendLog();
if (log) {
log->mDispatch.mType = ACTION_DISPATCH;
log->mDispatch.mTaskId = aTaskId;
log->mDispatch.mTime = time;
log->mDispatch.mSourceEventId = aSourceEventId;
log->mDispatch.mSourceEventType = aSourceEventType;
log->mDispatch.mParentTaskId = aParentTaskId;
}
}
void LogBegin(uint64_t aTaskId, uint64_t aSourceEventId) {
TraceInfoHolder info = GetOrCreateTraceInfo();
ENSURE_TRUE_VOID(info);
// Log format:
// [1 taskId beginTime processId threadId]
TraceInfoLogType* log = info->AppendLog();
if (log) {
log->mBegin.mType = ACTION_BEGIN;
log->mBegin.mTaskId = aTaskId;
log->mBegin.mTime = GetTimestamp();
log->mBegin.mPid = profiler_current_process_id();
log->mBegin.mTid = profiler_current_thread_id();
MOZ_ASSERT(log->mBegin.mPid >= 0,
"native process ID is < 0 (signed integer overflow)");
MOZ_ASSERT(log->mBegin.mTid >= 0,
"native thread ID is < 0 (signed integer overflow)");
}
}
void LogEnd(uint64_t aTaskId, uint64_t aSourceEventId) {
TraceInfoHolder info = GetOrCreateTraceInfo();
ENSURE_TRUE_VOID(info);
// Log format:
// [2 taskId endTime]
TraceInfoLogType* log = info->AppendLog();
if (log) {
log->mEnd.mType = ACTION_END;
log->mEnd.mTaskId = aTaskId;
log->mEnd.mTime = GetTimestamp();
}
}
void LogVirtualTablePtr(uint64_t aTaskId, uint64_t aSourceEventId,
uintptr_t* aVptr) {
TraceInfoHolder info = GetOrCreateTraceInfo();
ENSURE_TRUE_VOID(info);
// Log format:
// [4 taskId address]
TraceInfoLogType* log = info->AppendLog();
if (log) {
// Since addr2line used by the Gecko Profiler addon can not solve
// non-function addresses, we use the first entry of vtable as the symbol
// to solve. We should find a better solution later.
log->mVPtr.mType = ACTION_GET_VTABLE;
log->mVPtr.mTaskId = aTaskId;
log->mVPtr.mVPtr = reinterpret_cast<uintptr_t>(aVptr);
}
}
void AutoSourceEvent::StartScope(SourceEventType aType) {
CreateSourceEvent(aType);
}
void AutoSourceEvent::StopScope() { DestroySourceEvent(); }
void AutoScopedLabel::Init(const char* aFormat, va_list& aArgs) {
nsCString label;
va_list& args = aArgs;
label.AppendPrintf(aFormat, args);
mLabel = strdup(label.get());
AddLabel("Begin %s", mLabel);
}
void DoAddLabel(const char* aFormat, va_list& aArgs) {
TraceInfoHolder info = GetOrCreateTraceInfo();
ENSURE_TRUE_VOID(info);
// Log format:
// [3 taskId "label"]
TraceInfoLogType* log = info->AppendLog();
if (log) {
va_list& args = aArgs;
nsCString& buffer = *info->mStrs.AppendElement();
buffer.AppendPrintf(aFormat, args);
log->mLabel.mType = ACTION_ADD_LABEL;
log->mLabel.mTaskId = info->mCurTaskId;
log->mLabel.mTime = GetTimestamp();
log->mLabel.mStrIdx = info->mStrs.Length() - 1;
}
}
// Functions used by GeckoProfiler.
void StartLogging() {
sStartTime = GetTimestamp();
SetLogStarted(true);
}
void StopLogging() { SetLogStarted(false); }
UniquePtr<Vector<nsCString>> GetLoggedData(TimeStamp aTimeStamp) {
auto result = MakeUnique<Vector<nsCString>>();
// TODO: This is called from a signal handler. Use semaphore instead.
StaticMutexAutoLock lock(sMutex);
if (sTraceInfos == nullptr) {
return result;
}
for (uint32_t i = 0; i < sTraceInfos->Length(); ++i) {
TraceInfo* info = (*sTraceInfos)[i].get();
MutexAutoLock lockLogs(info->mLogsMutex);
if (info->mObsolete) {
continue;
}
nsTArray<nsCString>& strs = info->mStrs;
for (TraceInfoLogNode* node = info->mLogsHead; node; node = node->mNext) {
TraceInfoLogType& log = node->mLog;
MOZ_RELEASE_ASSERT(result->append(nsCString()));
nsCString& buffer = result->back();
switch (log.mType) {
case ACTION_DISPATCH:
buffer.AppendPrintf("%d %llu %llu %llu %d %llu", ACTION_DISPATCH,
(unsigned long long)log.mDispatch.mTaskId,
(unsigned long long)log.mDispatch.mTime,
(unsigned long long)log.mDispatch.mSourceEventId,
log.mDispatch.mSourceEventType,
(unsigned long long)log.mDispatch.mParentTaskId);
break;
case ACTION_BEGIN:
buffer.AppendPrintf("%d %llu %llu %d %d", ACTION_BEGIN,
(unsigned long long)log.mBegin.mTaskId,
(unsigned long long)log.mBegin.mTime,
log.mBegin.mPid, log.mBegin.mTid);
break;
case ACTION_END:
buffer.AppendPrintf("%d %llu %llu", ACTION_END,
(unsigned long long)log.mEnd.mTaskId,
(unsigned long long)log.mEnd.mTime);
break;
case ACTION_GET_VTABLE:
buffer.AppendPrintf("%d %llu %p", ACTION_GET_VTABLE,
(unsigned long long)log.mVPtr.mTaskId,
(void*)log.mVPtr.mVPtr);
break;
case ACTION_ADD_LABEL:
buffer.AppendPrintf("%d %llu %llu2 \"%s\"", ACTION_ADD_LABEL,
(unsigned long long)log.mLabel.mTaskId,
(unsigned long long)log.mLabel.mTime,
strs[log.mLabel.mStrIdx].get());
break;
default:
MOZ_CRASH("Unknow TaskTracer log type!");
}
}
}
return result;
}
PRTime GetStartTime() { return sStartTime; }
const char* GetJSLabelPrefix() { return sJSLabelPrefix; }
#undef ENSURE_TRUE_VOID
#undef ENSURE_TRUE
} // namespace tasktracer
} // namespace mozilla

182
tools/profiler/tasktracer/GeckoTaskTracer.h
Просмотреть файл

@ -1,182 +0,0 @@
/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* vim:set ts=2 sw=2 sts=2 et cindent: */
/* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
#ifndef GECKO_TASK_TRACER_H
#define GECKO_TASK_TRACER_H
#include "mozilla/Atomics.h"
#include "mozilla/Maybe.h"
#include "mozilla/UniquePtr.h"
#include "mozilla/Vector.h"
#include "nsCOMPtr.h"
#include "nsStringFwd.h"
#include <stdarg.h>
/**
* TaskTracer provides a way to trace the correlation between different tasks
* across threads and processes. Unlike sampling based profilers, TaskTracer can
* tell you where a task is dispatched from, what its original source was, how
* long it waited in the event queue, and how long it took to execute.
*
* Source Events are usually some kinds of I/O events we're interested in, such
* as touch events, timer events, network events, etc. When a source event is
* created, TaskTracer records the entire chain of Tasks and nsRunnables as they
* are dispatched to different threads and processes. It records latency,
* execution time, etc. for each Task and nsRunnable that chains back to the
* original source event.
*/
class nsIRunnable;
namespace mozilla {
class TimeStamp;
class Runnable;
namespace tasktracer {
extern bool gStarted;
/**
* Check if the TaskTracer has been started.
*/
inline bool IsStartLogging() {
// |gStarted| is not an atomic variable, but it is fine for it is a
// boolean value and will be changed under the protection of
// |sMutex|.
//
// There is a latency between the change of the value and the
// observation of threads. |gStarted| would be checked again with
// the protection of mutex in logging functions; for example,
// |AddLabel()|, so all false positive would be blocked with the
// double checks. For false negative, it is fine to lose some
// records at begin of logging.
return gStarted;
}
enum { FORKED_AFTER_NUWA = 1 << 0 };
enum SourceEventType {
#define SOURCE_EVENT_NAME(x) x,
#include "SourceEventTypeMap.h"
#undef SOURCE_EVENT_NAME
};
class AutoSaveCurTraceInfoImpl {
uint64_t mSavedTaskId;
uint64_t mSavedSourceEventId;
SourceEventType mSavedSourceEventType;
public:
AutoSaveCurTraceInfoImpl();
~AutoSaveCurTraceInfoImpl();
};
class AutoSaveCurTraceInfo {
Maybe<AutoSaveCurTraceInfoImpl> mSaved;
public:
AutoSaveCurTraceInfo() {
if (IsStartLogging()) {
mSaved.emplace();
}
}
/**
* The instance had saved TraceInfo.
*
* It means that TaskTrace had been enabled when the instance was
* created.
*/
bool HasSavedTraceInfo() { return !!mSaved; }
};
class AutoSourceEvent : public AutoSaveCurTraceInfo {
void StartScope(SourceEventType aType);
void StopScope();
public:
explicit AutoSourceEvent(SourceEventType aType) : AutoSaveCurTraceInfo() {
if (HasSavedTraceInfo()) {
StartScope(aType);
}
}
~AutoSourceEvent() {
if (HasSavedTraceInfo()) {
StopScope();
}
}
};
void InitTaskTracer(uint32_t aFlags = 0);
void ShutdownTaskTracer();
void DoAddLabel(const char* aFormat, va_list& aArgs);
// Add a label to the currently running task, aFormat is the message to log,
// followed by corresponding parameters.
inline void AddLabel(const char* aFormat, ...) MOZ_FORMAT_PRINTF(1, 2);
inline void AddLabel(const char* aFormat, ...) {
if (IsStartLogging()) {
va_list args;
va_start(args, aFormat);
DoAddLabel(aFormat, args);
va_end(args);
}
}
void StartLogging();
void StopLogging();
UniquePtr<Vector<nsCString>> GetLoggedData(TimeStamp aStartTime);
// Returns the timestamp when Task Tracer is enabled in this process.
PRTime GetStartTime();
/**
* Internal functions.
*/
already_AddRefed<nsIRunnable> CreateTracedRunnable(
already_AddRefed<nsIRunnable>&& aRunnable);
// Free the TraceInfo allocated on a thread's TLS. Currently we are wrapping
// tasks running on nsThreads and base::thread, so FreeTraceInfo is called at
// where nsThread and base::thread release themselves.
void FreeTraceInfo();
const char* GetJSLabelPrefix();
void GetCurTraceInfo(uint64_t* aOutSourceEventId, uint64_t* aOutParentTaskId,
SourceEventType* aOutSourceEventType);
class AutoScopedLabel {
char* mLabel;
void Init(const char* aFormat, va_list& aArgs);
public:
explicit AutoScopedLabel(const char* aFormat, ...) : mLabel(nullptr) {
if (IsStartLogging()) {
va_list args;
va_start(args, aFormat);
Init(aFormat, args);
va_end(args);
}
}
~AutoScopedLabel() {
if (mLabel) {
AddLabel("End %s", mLabel);
free(mLabel);
}
}
};
} // namespace tasktracer
} // namespace mozilla.
#endif

180
tools/profiler/tasktracer/GeckoTaskTracerImpl.h
Просмотреть файл

@ -1,180 +0,0 @@
/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* vim:set ts=2 sw=2 sts=2 et cindent: */
/* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
#ifndef GECKO_TASK_TRACER_IMPL_H
#define GECKO_TASK_TRACER_IMPL_H
#include "GeckoTaskTracer.h"
#include "mozilla/Mutex.h"
#include "nsTArray.h"
namespace mozilla {
namespace tasktracer {
struct LogRecDispatch {
uint32_t mType;
uint32_t mSourceEventType;
uint64_t mTaskId;
uint64_t mTime;
uint64_t mSourceEventId;
uint64_t mParentTaskId;
};
struct LogRecBegin {
uint32_t mType;
uint64_t mTaskId;
uint64_t mTime;
uint32_t mPid;
uint32_t mTid;
};
struct LogRecEnd {
uint32_t mType;
uint64_t mTaskId;
uint64_t mTime;
};
struct LogRecVPtr {
uint32_t mType;
uint64_t mTaskId;
uintptr_t mVPtr;
};
struct LogRecLabel {
uint32_t mType;
uint32_t mStrIdx;
uint64_t mTaskId;
uint64_t mTime;
};
union TraceInfoLogType {
uint32_t mType;
LogRecDispatch mDispatch;
LogRecBegin mBegin;
LogRecEnd mEnd;
LogRecVPtr mVPtr;
LogRecLabel mLabel;
};
struct TraceInfoLogNode {
TraceInfoLogType mLog;
TraceInfoLogNode* mNext;
};
struct TraceInfo {
explicit TraceInfo(uint32_t aThreadId)
: mCurTraceSourceId(0),
mCurTaskId(0),
mCurTraceSourceType(Unknown),
mThreadId(aThreadId),
mLastUniqueTaskId(0),
mObsolete(false),
mLogsMutex("TraceInfoMutex"),
mLogsHead(nullptr),
mLogsTail(nullptr),
mLogsSize(0) {
MOZ_COUNT_CTOR(TraceInfo);
}
~TraceInfo() {
MOZ_COUNT_DTOR(TraceInfo);
while (mLogsHead) {
auto node = mLogsHead;
mLogsHead = node->mNext;
delete node;
}
}
TraceInfoLogType* AppendLog();
uint64_t mCurTraceSourceId;
uint64_t mCurTaskId;
SourceEventType mCurTraceSourceType;
uint32_t mThreadId;
uint32_t mLastUniqueTaskId;
mozilla::Atomic<bool> mObsolete;
// This mutex protects the following log
mozilla::Mutex mLogsMutex;
TraceInfoLogNode* mLogsHead;
TraceInfoLogNode* mLogsTail;
int mLogsSize;
nsTArray<nsCString> mStrs;
};
class TraceInfoHolder {
public:
TraceInfoHolder() : mInfo(nullptr) {}
explicit TraceInfoHolder(TraceInfo* aInfo) : mInfo(aInfo) {
aInfo->mLogsMutex.AssertNotCurrentThreadOwns(); // in case of recursive
aInfo->mLogsMutex.Lock();
MOZ_ASSERT(aInfo);
}
TraceInfoHolder(const TraceInfoHolder& aOther) = delete;
TraceInfoHolder(TraceInfoHolder&& aOther) : mInfo(aOther.mInfo) {
if (!!aOther) {
aOther->mLogsMutex.AssertCurrentThreadOwns();
}
aOther.mInfo = nullptr;
}
~TraceInfoHolder() {
if (mInfo) mInfo->mLogsMutex.Unlock();
}
explicit operator bool() const { return !!mInfo; }
TraceInfo* operator->() { return mInfo; }
bool operator==(TraceInfo* aOther) const { return mInfo == aOther; }
bool operator==(const TraceInfoHolder& aOther) const {
return mInfo == aOther.mInfo;
}
void Reset() {
if (mInfo) {
mInfo->mLogsMutex.Unlock();
mInfo = nullptr;
}
}
private:
TraceInfo* mInfo;
};
// Return the TraceInfo of current thread, allocate a new one if not exit.
TraceInfoHolder GetOrCreateTraceInfo();
uint64_t GenNewUniqueTaskId();
void SetCurTraceInfo(uint64_t aSourceEventId, uint64_t aParentTaskId,
SourceEventType aSourceEventType);
/**
* Logging functions of different trace actions.
*/
enum ActionType {
ACTION_DISPATCH = 0,
ACTION_BEGIN,
ACTION_END,
ACTION_ADD_LABEL,
ACTION_GET_VTABLE
};
void LogDispatch(uint64_t aTaskId, uint64_t aParentTaskId,
uint64_t aSourceEventId, SourceEventType aSourceEventType);
void LogDispatch(uint64_t aTaskId, uint64_t aParentTaskId,
uint64_t aSourceEventId, SourceEventType aSourceEventType,
int aDelayTimeMs);
void LogBegin(uint64_t aTaskId, uint64_t aSourceEventId);
void LogEnd(uint64_t aTaskId, uint64_t aSourceEventId);
void LogVirtualTablePtr(uint64_t aTaskId, uint64_t aSourceEventId,
uintptr_t* aVptr);
} // namespace tasktracer
} // namespace mozilla
#endif

16
tools/profiler/tasktracer/SourceEventTypeMap.h
Просмотреть файл

@ -1,16 +0,0 @@
/* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this file,
* You can obtain one at http://mozilla.org/MPL/2.0/. */
#ifndef GECKO_TASK_TRACER_H
# error "Don't include this file directly"
#endif
SOURCE_EVENT_NAME(Unknown)
SOURCE_EVENT_NAME(Touch)
SOURCE_EVENT_NAME(Mouse)
SOURCE_EVENT_NAME(Key)
SOURCE_EVENT_NAME(Bluetooth)
SOURCE_EVENT_NAME(Unixsocket)
SOURCE_EVENT_NAME(Wifi)
SOURCE_EVENT_NAME(SocketIO)

128
tools/profiler/tasktracer/TracedTaskCommon.cpp
Просмотреть файл

@ -1,128 +0,0 @@
/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* vim:set ts=2 sw=2 sts=2 et cindent: */
/* 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 "TracedTaskCommon.h"
#include "GeckoTaskTracerImpl.h"
// NS_ENSURE_TRUE_VOID() without the warning on the debug build.
#define ENSURE_TRUE_VOID(x) \
do { \
if (MOZ_UNLIKELY(!(x))) { \
return; \
} \
} while (0)
namespace mozilla {
namespace tasktracer {
TracedTaskCommon::TracedTaskCommon()
: mSourceEventType(SourceEventType::Unknown),
mSourceEventId(0),
mParentTaskId(0),
mTaskId(0),
mIsTraceInfoInit(false) {}
TracedTaskCommon::~TracedTaskCommon() {}
void TracedTaskCommon::Init() {
// Keep the following line before GetOrCreateTraceInfo() to avoid a
// deadlock.
uint64_t taskid = GenNewUniqueTaskId();
TraceInfoHolder info = GetOrCreateTraceInfo();
ENSURE_TRUE_VOID(info);
mTaskId = taskid;
mSourceEventId = info->mCurTraceSourceId;
mSourceEventType = info->mCurTraceSourceType;
mParentTaskId = info->mCurTaskId;
mIsTraceInfoInit = true;
}
void TracedTaskCommon::DispatchTask(int aDelayTimeMs) {
LogDispatch(mTaskId, mParentTaskId, mSourceEventId, mSourceEventType,
aDelayTimeMs);
}
void TracedTaskCommon::DoGetTLSTraceInfo() {
TraceInfoHolder info = GetOrCreateTraceInfo();
ENSURE_TRUE_VOID(info);
MOZ_ASSERT(!mIsTraceInfoInit);
mSourceEventType = info->mCurTraceSourceType;
mSourceEventId = info->mCurTraceSourceId;
mTaskId = info->mCurTaskId;
mIsTraceInfoInit = true;
}
void TracedTaskCommon::DoSetTLSTraceInfo() {
TraceInfoHolder info = GetOrCreateTraceInfo();
ENSURE_TRUE_VOID(info);
if (mIsTraceInfoInit) {
info->mCurTraceSourceId = mSourceEventId;
info->mCurTraceSourceType = mSourceEventType;
info->mCurTaskId = mTaskId;
}
}
void TracedTaskCommon::ClearTLSTraceInfo() {
TraceInfoHolder info = GetOrCreateTraceInfo();
ENSURE_TRUE_VOID(info);
info->mCurTraceSourceId = 0;
info->mCurTraceSourceType = SourceEventType::Unknown;
info->mCurTaskId = 0;
}
/**
* Implementation of class TracedRunnable.
*/
NS_IMPL_ISUPPORTS(TracedRunnable, nsIRunnable);
TracedRunnable::TracedRunnable(already_AddRefed<nsIRunnable>&& aOriginalObj)
: TracedTaskCommon(), mOriginalObj(std::move(aOriginalObj)) {
Init();
LogVirtualTablePtr(mTaskId, mSourceEventId,
*reinterpret_cast<uintptr_t**>(mOriginalObj.get()));
}
TracedRunnable::~TracedRunnable() {}
NS_IMETHODIMP
TracedRunnable::Run() {
SetTLSTraceInfo();
LogBegin(mTaskId, mSourceEventId);
nsresult rv = mOriginalObj->Run();
LogEnd(mTaskId, mSourceEventId);
ClearTLSTraceInfo();
return rv;
}
/**
* CreateTracedRunnable() returns a TracedRunnable wrapping the original
* nsIRunnable object, aRunnable.
*/
already_AddRefed<nsIRunnable> CreateTracedRunnable(
already_AddRefed<nsIRunnable>&& aRunnable) {
RefPtr<nsIRunnable> runnable = new TracedRunnable(std::move(aRunnable));
return runnable.forget();
}
void VirtualTask::AutoRunTask::StartScope(VirtualTask* aTask) {
mTask->SetTLSTraceInfo();
LogBegin(mTask->mTaskId, mTask->mSourceEventId);
}
void VirtualTask::AutoRunTask::StopScope() {
LogEnd(mTask->mTaskId, mTask->mSourceEventId);
}
} // namespace tasktracer
} // namespace mozilla

130
tools/profiler/tasktracer/TracedTaskCommon.h
Просмотреть файл

@ -1,130 +0,0 @@
/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* vim:set ts=2 sw=2 sts=2 et cindent: */
/* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
#ifndef TRACED_TASK_COMMON_H
#define TRACED_TASK_COMMON_H
#include "GeckoTaskTracer.h"
#include "nsCOMPtr.h"
#include "nsThreadUtils.h"
namespace mozilla {
namespace tasktracer {
class TracedTaskCommon {
public:
TracedTaskCommon();
TracedTaskCommon(const TracedTaskCommon& aSrc)
: mSourceEventType(aSrc.mSourceEventType),
mSourceEventId(aSrc.mSourceEventId),
mParentTaskId(aSrc.mParentTaskId),
mTaskId(aSrc.mTaskId),
mIsTraceInfoInit(aSrc.mIsTraceInfoInit) {}
virtual ~TracedTaskCommon();
void DispatchTask(int aDelayTimeMs = 0);
void SetTLSTraceInfo() {
if (mIsTraceInfoInit) {
DoSetTLSTraceInfo();
}
}
void GetTLSTraceInfo() {
if (IsStartLogging()) {
DoGetTLSTraceInfo();
}
}
void ClearTLSTraceInfo();
private:
void DoSetTLSTraceInfo();
void DoGetTLSTraceInfo();
protected:
void Init();
// TraceInfo of TLS will be set by the following parameters, including source
// event type, source event ID, parent task ID, and task ID of this traced
// task/runnable.
SourceEventType mSourceEventType;
uint64_t mSourceEventId;
uint64_t mParentTaskId;
uint64_t mTaskId;
bool mIsTraceInfoInit;
};
class TracedRunnable : public TracedTaskCommon, public nsIRunnable {
public:
NS_DECL_THREADSAFE_ISUPPORTS
NS_DECL_NSIRUNNABLE
explicit TracedRunnable(already_AddRefed<nsIRunnable>&& aOriginalObj);
private:
virtual ~TracedRunnable();
nsCOMPtr<nsIRunnable> mOriginalObj;
};
/**
* This class is used to create a logical task, without a real
* runnable.
*/
class VirtualTask : public TracedTaskCommon {
public:
VirtualTask() : TracedTaskCommon() {}
VirtualTask(const VirtualTask& aSrc) : TracedTaskCommon(aSrc) {}
/**
* Initialize the task to create an unique ID, and store other
* information.
*
* This method may be called for one or more times.
*/
void Init(uintptr_t* aVPtr = nullptr) {
TracedTaskCommon::Init();
if (aVPtr) {
extern void LogVirtualTablePtr(uint64_t aTaskId, uint64_t aSourceEventId,
uintptr_t * aVptr);
LogVirtualTablePtr(mTaskId, mSourceEventId, aVPtr);
}
DispatchTask();
}
/**
* Define the life-span of a VirtualTask.
*
* VirtualTask is not a real task, goes without a runnable, it's
* instances are never dispatched and ran by event loops. This
* class used to define running time as the life-span of it's
* instance.
*/
class AutoRunTask : public AutoSaveCurTraceInfo {
VirtualTask* mTask;
void StartScope(VirtualTask* aTask);
void StopScope();
public:
explicit AutoRunTask(VirtualTask* aTask)
: AutoSaveCurTraceInfo(), mTask(aTask) {
if (HasSavedTraceInfo()) {
StartScope(aTask);
}
}
~AutoRunTask() {
if (HasSavedTraceInfo()) {
StopScope();
}
}
};
};
} // namespace tasktracer
} // namespace mozilla
#endif

16
xpcom/base/nsConsoleService.cpp
Просмотреть файл

@ -39,11 +39,6 @@
# include <windows.h>
#endif
#ifdef MOZ_TASK_TRACER
# include "GeckoTaskTracer.h"
using namespace mozilla::tasktracer;
#endif
using namespace mozilla;
NS_IMPL_ADDREF(nsConsoleService)
@ -362,17 +357,6 @@ nsresult nsConsoleService::LogMessageWithMode(
OutputDebugStringW(msg.get());
}
#endif
#ifdef MOZ_TASK_TRACER
if (IsStartLogging()) {
nsCString msg;
aMessage->ToString(msg);
int prefixPos = msg.Find(GetJSLabelPrefix());
if (prefixPos >= 0) {
nsDependentCSubstring submsg(msg, prefixPos);
AddLabel("%s", submsg.BeginReading());
}
}
#endif
if (gLoggingBuffered) {
MessageElement* e = new MessageElement(aMessage);

13
xpcom/threads/ThreadEventTarget.cpp
Просмотреть файл

@ -19,12 +19,6 @@
#include "nsXPCOMPrivate.h" // for gXPCOMThreadsShutDown
#include "ThreadDelay.h"
#ifdef MOZ_TASK_TRACER
# include "GeckoTaskTracer.h"
# include "TracedTaskCommon.h"
using namespace mozilla::tasktracer;
#endif
using namespace mozilla;
ThreadEventTarget::ThreadEventTarget(ThreadTargetSink* aSink,
@ -66,13 +60,6 @@ ThreadEventTarget::Dispatch(already_AddRefed<nsIRunnable> aEvent,
return NS_ERROR_ILLEGAL_DURING_SHUTDOWN;
}
#ifdef MOZ_TASK_TRACER
nsCOMPtr<nsIRunnable> tracedRunnable = CreateTracedRunnable(event.take());
(static_cast<TracedRunnable*>(tracedRunnable.get()))->DispatchTask();
// XXX tracedRunnable will always leaked when we fail to disptch.
event = tracedRunnable.forget();
#endif
LogRunnable::LogDispatch(event.get());
if (aFlags & DISPATCH_SYNC) {

18
xpcom/threads/TimerThread.cpp
Просмотреть файл

@ -22,10 +22,6 @@
#include <math.h>
using namespace mozilla;
#ifdef MOZ_TASK_TRACER
# include "GeckoTaskTracerImpl.h"
using namespace mozilla::tasktracer;
#endif
NS_IMPL_ISUPPORTS_INHERITED(TimerThread, Runnable, nsIObserver)
@ -643,12 +639,6 @@ bool TimerThread::AddTimerInternal(nsTimerImpl* aTimer) {
std::push_heap(mTimers.begin(), mTimers.end(), Entry::UniquePtrLessThan);
#ifdef MOZ_TASK_TRACER
// Caller of AddTimer is the parent task of its timer event, so we store the
// TraceInfo here for later used.
aTimer->GetTLSTraceInfo();
#endif
return true;
}
@ -709,14 +699,6 @@ already_AddRefed<nsTimerImpl> TimerThread::PostTimerEvent(
// event, so we can avoid firing a timer that was re-initialized after being
// canceled.
#ifdef MOZ_TASK_TRACER
// During the dispatch of TimerEvent, we overwrite the current TraceInfo
// partially with the info saved in timer earlier, and restore it back by
// AutoSaveCurTraceInfo.
AutoSaveCurTraceInfo saveCurTraceInfo;
(timer->GetTracedTask()).SetTLSTraceInfo();
#endif
nsCOMPtr<nsIEventTarget> target = timer->mEventTarget;
void* p = nsTimerEvent::operator new(sizeof(nsTimerEvent));

10
xpcom/threads/nsThread.cpp
Просмотреть файл

@ -95,12 +95,6 @@ using GetCurrentThreadStackLimitsFn = void(WINAPI*)(PULONG_PTR LowLimit,
# include "nsXULAppAPI.h"
#endif
#ifdef MOZ_TASK_TRACER
# include "GeckoTaskTracer.h"
# include "TracedTaskCommon.h"
using namespace mozilla::tasktracer;
#endif
using namespace mozilla;
extern void InitThreadLocalVariables();
@ -446,10 +440,6 @@ void nsThread::ThreadFunc(void* aArg) {
// Release any observer of the thread here.
self->SetObserver(nullptr);
#ifdef MOZ_TASK_TRACER
FreeTraceInfo();
#endif
// The PRThread will be deleted in PR_JoinThread(), so clear references.
self->mThread = nullptr;
self->mEventTarget->ClearCurrentThread();

11
xpcom/threads/nsTimerImpl.cpp
Просмотреть файл

@ -19,10 +19,6 @@
#include "nsThreadManager.h"
#include "nsThreadUtils.h"
#include "pratom.h"
#ifdef MOZ_TASK_TRACER
# include "GeckoTaskTracerImpl.h"
using namespace mozilla::tasktracer;
#endif
#ifdef XP_WIN
# include <process.h>
@ -694,10 +690,3 @@ nsresult nsTimer::XPCOMConstructor(nsISupports* aOuter, REFNSIID aIID,
return timer->QueryInterface(aIID, aResult);
}
#ifdef MOZ_TASK_TRACER
void nsTimerImpl::GetTLSTraceInfo() { mTracedTask.GetTLSTraceInfo(); }
TracedTaskCommon nsTimerImpl::GetTracedTask() { return mTracedTask; }
#endif

13
xpcom/threads/nsTimerImpl.h
Просмотреть файл

@ -19,10 +19,6 @@
#include "mozilla/Variant.h"
#include "mozilla/Logging.h"
#ifdef MOZ_TASK_TRACER
# include "TracedTaskCommon.h"
#endif
extern mozilla::LogModule* GetTimerLog();
#define NS_TIMER_CID \
@ -60,11 +56,6 @@ class nsTimerImpl {
void Fire(int32_t aGeneration);
#ifdef MOZ_TASK_TRACER
void GetTLSTraceInfo();
mozilla::tasktracer::TracedTaskCommon GetTracedTask();
#endif
int32_t GetGeneration() { return mGeneration; }
struct UnknownCallback {};
@ -155,10 +146,6 @@ class nsTimerImpl {
// Updated only after this timer has been removed from the timer thread.
mozilla::TimeStamp mTimeout;
#ifdef MOZ_TASK_TRACER
mozilla::tasktracer::TracedTaskCommon mTracedTask;
#endif
static double sDeltaSum;
static double sDeltaSumSquared;
static double sDeltaNum;