ChromeTracingTracer.cpp File Reference

#include "include/core/SkStream.h"
#include "include/private/base/SkThreadID.h"
#include "src/core/SkOSFile.h"
#include "src/core/SkTraceEvent.h"
#include "src/utils/SkJSONWriter.h"
#include "src/utils/SkOSPath.h"
#include "tools/trace/ChromeTracingTracer.h"
#include <chrono>

Go to the source code of this file.

Functions
static void	trace_value_to_json (SkJSONWriter *writer, uint64_t argValue, uint8_t argType, const char *stringTableBase)
static void	trace_event_to_json (SkJSONWriter *writer, TraceEvent *traceEvent, TraceEventSerializationState *serializationState)

Function Documentation

trace_event_to_json()

static void trace_event_to_json ( SkJSONWriter *  writer, TraceEvent *  traceEvent, TraceEventSerializationState *  serializationState  )

static

Definition at line 196 of file ChromeTracingTracer.cpp.

                                                                                  {
    // We track the original (creation time) "name" of each currently live object, so we can
    // automatically insert "base_name" fields in object snapshot events.
    auto baseTypeResolver = &(serializationState->fBaseTypeResolver);
    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);
    }
 
    writer->beginObject();
 
    writer->appendString("ph", &traceEvent->fPhase, 1);
    writer->appendCString("name", traceEvent->fName);
    if (0 != traceEvent->fID) {
        // IDs are (almost) always pointers
        writer->appendPointer("id", reinterpret_cast<void*>(traceEvent->fID));
    }
 
    // Offset timestamps to reduce JSON length, then convert nanoseconds to microseconds
    // (standard time unit for tracing JSON files).
    uint64_t relativeTimestamp =
            static_cast<int64_t>(traceEvent->fClockBegin - serializationState->fClockOffset);
    writer->appendDouble("ts", static_cast<double>(relativeTimestamp) * 1E-3);
    if (0 != traceEvent->fClockEnd) {
        double dur = static_cast<double>(traceEvent->fClockEnd - traceEvent->fClockBegin) * 1E-3;
        writer->appendDouble("dur", dur);
    }
 
    writer->appendS64("tid", serializationState->getShortThreadID(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).
    writer->appendS32("pid", 0);
 
    if (traceEvent->fNumArgs) {
        writer->beginObject("args");
        const char* stringTable   = traceEvent->stringTable();
        bool        addedSnapshot = false;
        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.
            writer->beginObject("snapshot");
            writer->appendCString("base_type", *baseTypeResolver->find(traceEvent->fID));
            addedSnapshot = true;
        }
 
        for (int i = 0; i < traceEvent->fNumArgs; ++i) {
            const TraceEventArg* arg = traceEvent->args() + i;
            // TODO: Skip '#'
            writer->appendName(arg->fArgName);
 
            if (arg->fArgName && '#' == arg->fArgName[0]) {
                writer->beginObject();
                writer->appendName("id_ref");
                trace_value_to_json(writer, arg->fArgValue, arg->fArgType, stringTable);
                writer->endObject();
            } else {
                trace_value_to_json(writer, arg->fArgValue, arg->fArgType, stringTable);
            }
        }
 
        if (addedSnapshot) {
            writer->endObject();
        }
 
        writer->endObject();
    }
 
    writer->endObject();
}

trace_value_to_json()

static void trace_value_to_json ( SkJSONWriter *  writer, uint64_t  argValue, uint8_t  argType, const char *  stringTableBase  )

static

Definition at line 150 of file ChromeTracingTracer.cpp.

                                                               {
    switch (argType) {
        case TRACE_VALUE_TYPE_BOOL:   writer->appendBool(argValue); break;
        case TRACE_VALUE_TYPE_UINT:   writer->appendU64(argValue); break;
        case TRACE_VALUE_TYPE_INT:    writer->appendS64(static_cast<int64_t>(argValue)); break;
        case TRACE_VALUE_TYPE_DOUBLE: writer->appendDouble(sk_bit_cast<double>(argValue)); break;
        case TRACE_VALUE_TYPE_POINTER:
            writer->appendPointer(skia_private::TraceValueAsPointer(argValue));
            break;
        case TRACE_VALUE_TYPE_STRING:
            writer->appendCString(skia_private::TraceValueAsString(argValue));
            break;
        case TRACE_VALUE_TYPE_COPY_STRING:
            // See addTraceEvent(), the value in _COPY_STRING events is replaced with an offset
            writer->appendCString(stringTableBase + argValue);
            break;
        default: writer->appendNString("<unknown type>"); break;
    }
}