1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
|
/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* 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 GeckoSampler_h
#define GeckoSampler_h
#include "platform.h"
#include "ProfileEntry.h"
#include "mozilla/Vector.h"
#include "ThreadProfile.h"
#include "ThreadInfo.h"
#ifndef SPS_STANDALONE
#include "IntelPowerGadget.h"
#endif
#ifdef MOZ_TASK_TRACER
#include "GeckoTaskTracer.h"
#endif
#include <algorithm>
namespace mozilla {
class ProfileGatherer;
} // namespace mozilla
typedef mozilla::Vector<std::string> ThreadNameFilterList;
typedef mozilla::Vector<std::string> FeatureList;
static bool
threadSelected(ThreadInfo* aInfo, const ThreadNameFilterList &aThreadNameFilters) {
if (aThreadNameFilters.empty()) {
return true;
}
std::string name = aInfo->Name();
std::transform(name.begin(), name.end(), name.begin(), ::tolower);
for (uint32_t i = 0; i < aThreadNameFilters.length(); ++i) {
std::string filter = aThreadNameFilters[i];
std::transform(filter.begin(), filter.end(), filter.begin(), ::tolower);
// Crude, non UTF-8 compatible, case insensitive substring search
if (name.find(filter) != std::string::npos) {
return true;
}
}
return false;
}
extern mozilla::TimeStamp sLastTracerEvent;
extern int sFrameNumber;
extern int sLastFrameNumber;
class GeckoSampler: public Sampler {
public:
GeckoSampler(double aInterval, int aEntrySize,
const char** aFeatures, uint32_t aFeatureCount,
const char** aThreadNameFilters, uint32_t aFilterCount);
~GeckoSampler();
void RegisterThread(ThreadInfo* aInfo) {
if (!aInfo->IsMainThread() && !mProfileThreads) {
return;
}
if (!threadSelected(aInfo, mThreadNameFilters)) {
return;
}
ThreadProfile* profile = new ThreadProfile(aInfo, mBuffer);
aInfo->SetProfile(profile);
}
// Called within a signal. This function must be reentrant
virtual void Tick(TickSample* sample) override;
// Immediately captures the calling thread's call stack and returns it.
virtual SyncProfile* GetBacktrace() override;
// Called within a signal. This function must be reentrant
virtual void RequestSave() override
{
mSaveRequested = true;
#ifdef MOZ_TASK_TRACER
if (mTaskTracer) {
mozilla::tasktracer::StopLogging();
}
#endif
}
virtual void HandleSaveRequest() override;
virtual void DeleteExpiredMarkers() override;
ThreadProfile* GetPrimaryThreadProfile()
{
if (!mPrimaryThreadProfile) {
::MutexAutoLock lock(*sRegisteredThreadsMutex);
for (uint32_t i = 0; i < sRegisteredThreads->size(); i++) {
ThreadInfo* info = sRegisteredThreads->at(i);
if (info->IsMainThread() && !info->IsPendingDelete()) {
mPrimaryThreadProfile = info->Profile();
break;
}
}
}
return mPrimaryThreadProfile;
}
void ToStreamAsJSON(std::ostream& stream, double aSinceTime = 0);
#ifndef SPS_STANDALONE
virtual JSObject *ToJSObject(JSContext *aCx, double aSinceTime = 0);
void GetGatherer(nsISupports** aRetVal);
#endif
mozilla::UniquePtr<char[]> ToJSON(double aSinceTime = 0);
virtual void ToJSObjectAsync(double aSinceTime = 0, mozilla::dom::Promise* aPromise = 0);
void StreamMetaJSCustomObject(SpliceableJSONWriter& aWriter);
void StreamTaskTracer(SpliceableJSONWriter& aWriter);
void FlushOnJSShutdown(JSContext* aContext);
bool ProfileJS() const { return mProfileJS; }
bool ProfileJava() const { return mProfileJava; }
bool ProfileGPU() const { return mProfileGPU; }
bool ProfilePower() const { return mProfilePower; }
bool ProfileThreads() const override { return mProfileThreads; }
bool InPrivacyMode() const { return mPrivacyMode; }
bool AddMainThreadIO() const { return mAddMainThreadIO; }
bool ProfileMemory() const { return mProfileMemory; }
bool TaskTracer() const { return mTaskTracer; }
bool LayersDump() const { return mLayersDump; }
bool DisplayListDump() const { return mDisplayListDump; }
bool ProfileRestyle() const { return mProfileRestyle; }
const ThreadNameFilterList& ThreadNameFilters() { return mThreadNameFilters; }
const FeatureList& Features() { return mFeatures; }
void GetBufferInfo(uint32_t *aCurrentPosition, uint32_t *aTotalSize, uint32_t *aGeneration);
protected:
// Called within a signal. This function must be reentrant
virtual void InplaceTick(TickSample* sample);
// Not implemented on platforms which do not support backtracing
void doNativeBacktrace(ThreadProfile &aProfile, TickSample* aSample);
void StreamJSON(SpliceableJSONWriter& aWriter, double aSinceTime);
// This represent the application's main thread (SAMPLER_INIT)
ThreadProfile* mPrimaryThreadProfile;
RefPtr<ProfileBuffer> mBuffer;
bool mSaveRequested;
bool mAddLeafAddresses;
bool mUseStackWalk;
bool mProfileJS;
bool mProfileGPU;
bool mProfileThreads;
bool mProfileJava;
bool mProfilePower;
bool mLayersDump;
bool mDisplayListDump;
bool mProfileRestyle;
// Keep the thread filter to check against new thread that
// are started while profiling
ThreadNameFilterList mThreadNameFilters;
FeatureList mFeatures;
bool mPrivacyMode;
bool mAddMainThreadIO;
bool mProfileMemory;
bool mTaskTracer;
#if defined(XP_WIN)
IntelPowerGadget* mIntelPowerGadget;
#endif
private:
RefPtr<mozilla::ProfileGatherer> mGatherer;
};
#endif
|
