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
|
/*
* Copyright 2017 Google Inc.
*
* Use of this source code is governed by a BSD-style license that can be
* found in the LICENSE file.
*/
#include "SkChromeTracingTracer.h"
#include "SkThreadID.h"
#include "SkTraceEvent.h"
#include "SkOSFile.h"
#include "SkOSPath.h"
#include "SkStream.h"
#include <chrono>
SkChromeTracingTracer::SkChromeTracingTracer(const char* filename) : fFilename(filename) {
fCurBlock = this->createBlock();
fEventsInCurBlock = 0;
}
SkChromeTracingTracer::~SkChromeTracingTracer() {
this->flush();
}
SkChromeTracingTracer::BlockPtr SkChromeTracingTracer::createBlock() {
return BlockPtr(new TraceEvent[kEventsPerBlock]);
}
SkChromeTracingTracer::TraceEvent* SkChromeTracingTracer::appendEvent(
const TraceEvent& traceEvent) {
SkAutoMutexAcquire lock(fMutex);
if (fEventsInCurBlock >= kEventsPerBlock) {
fBlocks.push_back(std::move(fCurBlock));
fCurBlock = this->createBlock();
fEventsInCurBlock = 0;
}
fCurBlock[fEventsInCurBlock] = traceEvent;
return &fCurBlock[fEventsInCurBlock++];
}
SkEventTracer::Handle SkChromeTracingTracer::addTraceEvent(char phase,
const uint8_t* categoryEnabledFlag,
const char* name,
uint64_t id,
int numArgs,
const char** argNames,
const uint8_t* argTypes,
const uint64_t* argValues,
uint8_t flags) {
// TODO: Respect flags (or assert). INSTANT events encode scope in flags, should be stored
// using "s" key in JSON. COPY flag should be supported or rejected.
TraceEvent traceEvent;
traceEvent.fPhase = phase;
traceEvent.fNumArgs = numArgs;
traceEvent.fName = name;
traceEvent.fCategory = fCategories.getCategoryGroupName(categoryEnabledFlag);
traceEvent.fClockBegin = std::chrono::high_resolution_clock::now().time_since_epoch().count();
traceEvent.fClockEnd = 0;
traceEvent.fThreadID = SkGetThreadID();
for (int i = 0; i < numArgs; ++i) {
traceEvent.fArgNames[i] = argNames[i];
traceEvent.fArgTypes[i] = argTypes[i];
if (TRACE_VALUE_TYPE_COPY_STRING == argTypes[i]) {
skia::tracing_internals::TraceValueUnion value;
value.as_uint = argValues[i];
value.as_string = SkStrDup(value.as_string);
traceEvent.fArgValues[i] = value.as_uint;
} else {
traceEvent.fArgValues[i] = argValues[i];
}
}
return reinterpret_cast<Handle>(this->appendEvent(traceEvent));
}
void SkChromeTracingTracer::updateTraceEventDuration(const uint8_t* categoryEnabledFlag,
const char* name,
SkEventTracer::Handle handle) {
// We could probably get away with not locking here, but let's be totally safe.
SkAutoMutexAcquire lock(fMutex);
TraceEvent* traceEvent = reinterpret_cast<TraceEvent*>(handle);
traceEvent->fClockEnd = std::chrono::high_resolution_clock::now().time_since_epoch().count();
}
Json::Value SkChromeTracingTracer::traceEventToJson(const TraceEvent& traceEvent) {
Json::Value json;
char phaseString[2] = { traceEvent.fPhase, 0 };
json["ph"] = phaseString;
json["name"] = traceEvent.fName;
json["cat"] = traceEvent.fCategory;
json["ts"] = static_cast<double>(traceEvent.fClockBegin) * 1E-3;
if (0 != traceEvent.fClockEnd) {
json["dur"] = static_cast<double>(traceEvent.fClockEnd - traceEvent.fClockBegin) * 1E-3;
}
json["tid"] = static_cast<Json::Int64>(traceEvent.fThreadID);
// Trace events *must* include a process ID, but for internal tools this isn't particularly
// important (and certainly not worth adding a cross-platform API to get it).
json["pid"] = 0;
if (traceEvent.fNumArgs) {
Json::Value args;
skia::tracing_internals::TraceValueUnion value;
for (int i = 0; i < traceEvent.fNumArgs; ++i) {
value.as_uint = traceEvent.fArgValues[i];
switch (traceEvent.fArgTypes[i]) {
case TRACE_VALUE_TYPE_BOOL:
args[traceEvent.fArgNames[i]] = value.as_bool;
break;
case TRACE_VALUE_TYPE_UINT:
args[traceEvent.fArgNames[i]] = static_cast<Json::UInt64>(value.as_uint);
break;
case TRACE_VALUE_TYPE_INT:
args[traceEvent.fArgNames[i]] = static_cast<Json::Int64>(value.as_uint);
break;
case TRACE_VALUE_TYPE_DOUBLE:
args[traceEvent.fArgNames[i]] = value.as_double;
break;
case TRACE_VALUE_TYPE_POINTER:
args[traceEvent.fArgNames[i]] = value.as_pointer;
break;
case TRACE_VALUE_TYPE_STRING:
case TRACE_VALUE_TYPE_COPY_STRING:
args[traceEvent.fArgNames[i]] = value.as_string;
break;
default:
args[traceEvent.fArgNames[i]] = "<unknown type>";
break;
}
}
json["args"] = args;
}
return json;
}
void SkChromeTracingTracer::flush() {
SkAutoMutexAcquire lock(fMutex);
Json::Value root(Json::arrayValue);
for (int i = 0; i < fBlocks.count(); ++i) {
for (int j = 0; j < kEventsPerBlock; ++j) {
root.append(this->traceEventToJson(fBlocks[i][j]));
}
}
for (int i = 0; i < fEventsInCurBlock; ++i) {
root.append(this->traceEventToJson(fCurBlock[i]));
}
SkString dirname = SkOSPath::Dirname(fFilename.c_str());
if (!dirname.isEmpty() && !sk_exists(dirname.c_str(), kWrite_SkFILE_Flag)) {
if (!sk_mkdir(dirname.c_str())) {
SkDebugf("Failed to create directory.");
}
}
SkFILEWStream stream(fFilename.c_str());
stream.writeText(Json::FastWriter().write(root).c_str());
stream.flush();
}
|
