tools/trace/SkChromeTracingTracer.cpp - platform/external/skqp - Gitiles

 /*
  * 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.fID = id;
     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();
 }

 static Json::Value trace_value_to_json(uint64_t argValue, uint8_t argType) {
     skia::tracing_internals::TraceValueUnion value;
     value.as_uint = argValue;

     switch (argType) {
         case TRACE_VALUE_TYPE_BOOL:
             return Json::Value(value.as_bool);
         case TRACE_VALUE_TYPE_UINT:
             return Json::Value(static_cast<Json::UInt64>(value.as_uint));
         case TRACE_VALUE_TYPE_INT:
             return Json::Value(static_cast<Json::Int64>(value.as_uint));
         case TRACE_VALUE_TYPE_DOUBLE:
             return Json::Value(value.as_double);
         case TRACE_VALUE_TYPE_POINTER:
             return Json::Value(SkStringPrintf("%p", value.as_pointer).c_str());
         case TRACE_VALUE_TYPE_STRING:
         case TRACE_VALUE_TYPE_COPY_STRING:
             return Json::Value(value.as_string);
         default:
             return Json::Value("<unknown type>");
     }
 }

 Json::Value SkChromeTracingTracer::traceEventToJson(const TraceEvent& traceEvent,
                                                     BaseTypeResolver* baseTypeResolver) {
     // We track the original (creation time) "name" of each currently live object, so we can
     // automatically insert "base_name" fields in object snapshot events.
     if (TRACE_EVENT_PHASE_CREATE_OBJECT == traceEvent.fPhase) {
         SkASSERT(nullptr == baseTypeResolver->find(traceEvent.fID));
         baseTypeResolver->set(traceEvent.fID, traceEvent.fName);
     } else if (TRACE_EVENT_PHASE_DELETE_OBJECT == traceEvent.fPhase) {
         SkASSERT(nullptr != baseTypeResolver->find(traceEvent.fID));
         baseTypeResolver->remove(traceEvent.fID);
     }

     Json::Value json;
     char phaseString[2] = { traceEvent.fPhase, 0 };
     json["ph"] = phaseString;
     json["name"] = traceEvent.fName;
     json["cat"] = traceEvent.fCategory;
     if (0 != traceEvent.fID) {
         // IDs are (almost) always pointers
         json["id"] = SkStringPrintf("%p", traceEvent.fID).c_str();
     }
     // Convert nanoseconds to microseconds (standard time unit for tracing JSON files)
     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;
         for (int i = 0; i < traceEvent.fNumArgs; ++i) {
             Json::Value argValue = trace_value_to_json(traceEvent.fArgValues[i],
                                                        traceEvent.fArgTypes[i]);
             if (traceEvent.fArgNames[i] && '#' == traceEvent.fArgNames[i][0]) {
                 // Interpret #foo as an ID reference
                 Json::Value idRef;
                 idRef["id_ref"] = argValue;
                 args[traceEvent.fArgNames[i] + 1] = idRef;
             } else {
                 args[traceEvent.fArgNames[i]] = argValue;
             }
         }
         if (TRACE_EVENT_PHASE_SNAPSHOT_OBJECT == traceEvent.fPhase &&
                 baseTypeResolver->find(traceEvent.fID) &&
                 0 != strcmp(*baseTypeResolver->find(traceEvent.fID), traceEvent.fName)) {
             // Special handling for snapshots where the name differs from creation.
             // We start with args = { "snapshot": "Object info" }

             // Inject base_type. args = { "snapshot": "Object Info", "base_type": "BaseFoo" }
             args["base_type"] = *baseTypeResolver->find(traceEvent.fID);

             // Wrap this up in a new dict, again keyed by "snapshot". The inner "snapshot" is now
             // arbitrary, but we don't have a better name (and the outer key *must* be snapshot).
             // snapshot = { "snapshot": { "snapshot": "Object Info", "base_type": "BaseFoo" } }
             Json::Value snapshot;
             snapshot["snapshot"] = args;

             // Now insert that whole thing as the event's args.
             // { "name": "DerivedFoo", "id": "0x12345678, ...
             //     "args": { "snapshot":  { "snapshot": "Object Info", "base_type": "BaseFoo" } }
             // }, ...
             json["args"] = snapshot;
         } else {
             json["args"] = args;
         }
     }
     return json;
 }

 void SkChromeTracingTracer::flush() {
     SkAutoMutexAcquire lock(fMutex);

     Json::Value root(Json::arrayValue);
     BaseTypeResolver baseTypeResolver;

     for (int i = 0; i < fBlocks.count(); ++i) {
         for (int j = 0; j < kEventsPerBlock; ++j) {
             root.append(this->traceEventToJson(fBlocks[i][j], &baseTypeResolver));
         }
     }

     for (int i = 0; i < fEventsInCurBlock; ++i) {
         root.append(this->traceEventToJson(fCurBlock[i], &baseTypeResolver));
     }

     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();
 }
	/*
	* 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.fID = id;
	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();
	}

	static Json::Value trace_value_to_json(uint64_t argValue, uint8_t argType) {
	skia::tracing_internals::TraceValueUnion value;
	value.as_uint = argValue;

	switch (argType) {
	case TRACE_VALUE_TYPE_BOOL:
	return Json::Value(value.as_bool);
	case TRACE_VALUE_TYPE_UINT:
	return Json::Value(static_cast<Json::UInt64>(value.as_uint));
	case TRACE_VALUE_TYPE_INT:
	return Json::Value(static_cast<Json::Int64>(value.as_uint));
	case TRACE_VALUE_TYPE_DOUBLE:
	return Json::Value(value.as_double);
	case TRACE_VALUE_TYPE_POINTER:
	return Json::Value(SkStringPrintf("%p", value.as_pointer).c_str());
	case TRACE_VALUE_TYPE_STRING:
	case TRACE_VALUE_TYPE_COPY_STRING:
	return Json::Value(value.as_string);
	default:
	return Json::Value("<unknown type>");
	}
	}

	Json::Value SkChromeTracingTracer::traceEventToJson(const TraceEvent& traceEvent,
	BaseTypeResolver* baseTypeResolver) {
	// We track the original (creation time) "name" of each currently live object, so we can
	// automatically insert "base_name" fields in object snapshot events.
	if (TRACE_EVENT_PHASE_CREATE_OBJECT == traceEvent.fPhase) {
	SkASSERT(nullptr == baseTypeResolver->find(traceEvent.fID));
	baseTypeResolver->set(traceEvent.fID, traceEvent.fName);
	} else if (TRACE_EVENT_PHASE_DELETE_OBJECT == traceEvent.fPhase) {
	SkASSERT(nullptr != baseTypeResolver->find(traceEvent.fID));
	baseTypeResolver->remove(traceEvent.fID);
	}

	Json::Value json;
	char phaseString[2] = { traceEvent.fPhase, 0 };
	json["ph"] = phaseString;
	json["name"] = traceEvent.fName;
	json["cat"] = traceEvent.fCategory;
	if (0 != traceEvent.fID) {
	// IDs are (almost) always pointers
	json["id"] = SkStringPrintf("%p", traceEvent.fID).c_str();
	}
	// Convert nanoseconds to microseconds (standard time unit for tracing JSON files)
	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;
	for (int i = 0; i < traceEvent.fNumArgs; ++i) {
	Json::Value argValue = trace_value_to_json(traceEvent.fArgValues[i],
	traceEvent.fArgTypes[i]);
	if (traceEvent.fArgNames[i] && '#' == traceEvent.fArgNames[i][0]) {
	// Interpret #foo as an ID reference
	Json::Value idRef;
	idRef["id_ref"] = argValue;
	args[traceEvent.fArgNames[i] + 1] = idRef;
	} else {
	args[traceEvent.fArgNames[i]] = argValue;
	}
	}
	if (TRACE_EVENT_PHASE_SNAPSHOT_OBJECT == traceEvent.fPhase &&
	baseTypeResolver->find(traceEvent.fID) &&
	0 != strcmp(*baseTypeResolver->find(traceEvent.fID), traceEvent.fName)) {
	// Special handling for snapshots where the name differs from creation.
	// We start with args = { "snapshot": "Object info" }

	// Inject base_type. args = { "snapshot": "Object Info", "base_type": "BaseFoo" }
	args["base_type"] = *baseTypeResolver->find(traceEvent.fID);

	// Wrap this up in a new dict, again keyed by "snapshot". The inner "snapshot" is now
	// arbitrary, but we don't have a better name (and the outer key must be snapshot).
	// snapshot = { "snapshot": { "snapshot": "Object Info", "base_type": "BaseFoo" } }
	Json::Value snapshot;
	snapshot["snapshot"] = args;

	// Now insert that whole thing as the event's args.
	// { "name": "DerivedFoo", "id": "0x12345678, ...
	// "args": { "snapshot": { "snapshot": "Object Info", "base_type": "BaseFoo" } }
	// }, ...
	json["args"] = snapshot;
	} else {
	json["args"] = args;
	}
	}
	return json;
	}

	void SkChromeTracingTracer::flush() {
	SkAutoMutexAcquire lock(fMutex);

	Json::Value root(Json::arrayValue);
	BaseTypeResolver baseTypeResolver;

	for (int i = 0; i < fBlocks.count(); ++i) {
	for (int j = 0; j < kEventsPerBlock; ++j) {
	root.append(this->traceEventToJson(fBlocks[i][j], &baseTypeResolver));
	}
	}

	for (int i = 0; i < fEventsInCurBlock; ++i) {
	root.append(this->traceEventToJson(fCurBlock[i], &baseTypeResolver));
	}

	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();
	}