From b6705c25362fff0298f098631cbd939b0d2898b5 Mon Sep 17 00:00:00 2001 From: Brian Osman Date: Tue, 1 Aug 2017 10:23:38 -0400 Subject: Add support for object creation/snapshot/deletion events - Bring back some previously deleted macros and helper types. - Automatically inject base_type information into snapshot events, to allow simpler tracking of polymorphic object types. - Fix JSON formatting of pointer values (they were serializing as bool). Bug: skia: Change-Id: Iac7803f72ce5396ffd2fbcb5a36d76745c5e3f3e Reviewed-on: https://skia-review.googlesource.com/28220 Reviewed-by: Mike Klein Commit-Queue: Brian Osman --- tests/TracingTest.cpp | 189 ++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 189 insertions(+) create mode 100644 tests/TracingTest.cpp (limited to 'tests/TracingTest.cpp') diff --git a/tests/TracingTest.cpp b/tests/TracingTest.cpp new file mode 100644 index 0000000000..e157cd70eb --- /dev/null +++ b/tests/TracingTest.cpp @@ -0,0 +1,189 @@ +/* + * 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 "SkCommandLineFlags.h" +#include "SkImageInfo.h" +#include "SkLeanWindows.h" +#include "SkPoint.h" +#include "SkRect.h" +#include "SkTraceEvent.h" +#include "Test.h" + +DEFINE_bool(slowTracingTest, false, "Artificially slow down tracing test to produce nicer JSON"); + +namespace { + +/** + * Helper types for demonstrating usage of TRACE_EVENT_OBJECT_XXX macros. + */ +struct TracingShape { + TracingShape() { + TRACE_EVENT_OBJECT_CREATED_WITH_ID("skia.objects", this->typeName(), this); + } + virtual ~TracingShape() { + TRACE_EVENT_OBJECT_DELETED_WITH_ID("skia.objects", this->typeName(), this); + } + void traceSnapshot() { + // The state of an object can be specified at any point with the OBJECT_SNAPSHOT macro. + // This takes the "name" (actually the type name), the ID of the object (typically a + // pointer), and a single (unnnamed) argument, which is the "snapshot" of that object. + // + // Tracing viewer requires that all object macros use the same name and id for creation, + // deletion, and snapshots. However: It's convenient to put creation and deletion in the + // base-class constructor/destructor where the actual type name isn't known yet. That's + // what we're doing here. The JSON for snapshots can therefore include the actual type + // name, and a special tag that refers to the type name originally used at creation time. + // Skia's JSON tracer handles this automatically, so SNAPSHOT macros can simply use the + // derived type name, and the JSON will be formatted correctly to link the events. + TRACE_EVENT_OBJECT_SNAPSHOT_WITH_ID("skia.objects", this->typeName(), this, + TRACE_STR_COPY(this->toString().c_str())); + } + + virtual const char* typeName() { return "TracingShape"; } + virtual SkString toString() { return SkString("Shape()"); } +}; + +struct TracingCircle : public TracingShape { + TracingCircle(SkPoint center, SkScalar radius) : fCenter(center), fRadius(radius) {} + const char* typeName() override { return "TracingCircle"; } + SkString toString() override { + return SkStringPrintf("Circle(%f, %f, %f)", fCenter.fX, fCenter.fY, fRadius); + } + + SkPoint fCenter; + SkScalar fRadius; +}; + +struct TracingRect : public TracingShape { + TracingRect(SkRect rect) : fRect(rect) {} + const char* typeName() override { return "TracingRect"; } + SkString toString() override { + return SkStringPrintf("Rect(%f, %f, %f, %f)", + fRect.fLeft, fRect.fTop, fRect.fRight, fRect.fBottom); + } + + SkRect fRect; +}; + +} + +static SkScalar gTracingTestWorkSink = 1.0f; + +static void do_work(int howMuchWork) { + // Do busy work so the trace marker durations are large enough to be readable in trace viewer + if (FLAGS_slowTracingTest) { + for (int i = 0; i < howMuchWork * 100; ++i) { + gTracingTestWorkSink += SkScalarSin(i); + } + } +} + +static void test_trace_simple() { + // Simple event that lasts until the end of the current scope. TRACE_FUNC is an easy way + // to insert the current function name. + TRACE_EVENT0("skia", TRACE_FUNC); + + { + // There are versions of the macro that take 1 or 2 named arguments. The arguments + // can be any simple type. Strings need to be static/literal - we just copy pointers. + // Argument names & values are shown when the event is selected in the viewer. + TRACE_EVENT1("skia", "Nested work", + "isBGRA", kN32_SkColorType == kBGRA_8888_SkColorType); + do_work(500); + } + + { + // If you must copy a string as an argument value, use the TRACE_STR_COPY macro. + // This will instruct the tracing system (if one is active) to make a copy. + SkString message = SkStringPrintf("%s %s", "Hello", "World"); + TRACE_EVENT1("skia", "Dynamic String", "message", TRACE_STR_COPY(message.c_str())); + do_work(500); + } +} + +static void test_trace_counters() { + TRACE_EVENT0("skia", TRACE_FUNC); + + { + TRACE_EVENT0("skia", "Single Counter"); + + // Counter macros allow recording a named value (which must be a 32-bit integer). + // The value will be graphed in the viewer. + for (int i = 0; i < 180; ++i) { + SkScalar rad = SkDegreesToRadians(SkIntToScalar(i)); + TRACE_COUNTER1("skia", "sin", SkScalarSin(rad) * 1000.0f + 1000.0f); + do_work(10); + } + } + + { + TRACE_EVENT0("skia", "Independent Counters"); + + // Recording multiple counters with separate COUNTER1 macros will make separate graphs. + for (int i = 0; i < 180; ++i) { + SkScalar rad = SkDegreesToRadians(SkIntToScalar(i)); + SkScalar cos; + SkScalar sin = SkScalarSinCos(rad, &cos); + TRACE_COUNTER1("skia", "sin", sin * 1000.0f + 1000.0f); + TRACE_COUNTER1("skia", "cos", cos * 1000.0f + 1000.0f); + do_work(10); + } + } + + { + TRACE_EVENT0("skia", "Stacked Counters"); + + // Two counters can be recorded together with COUNTER2. They will be graphed together, + // as a stacked bar graph. The combined graph needs a name, as does each data series. + for (int i = 0; i < 180; ++i) { + SkScalar rad = SkDegreesToRadians(SkIntToScalar(i)); + SkScalar cos; + SkScalar sin = SkScalarSinCos(rad, &cos); + TRACE_COUNTER2("skia", "trig", + "sin", sin * 1000.0f + 1000.0f, + "cos", cos * 1000.0f + 1000.0f); + do_work(10); + } + } +} + +static void test_trace_objects() { + TRACE_EVENT0("skia", TRACE_FUNC); + + // Objects can be tracked through time with the TRACE_EVENT_OBJECT_ macros. + // The macros in use (and their idiosyncracies) are commented in the TracingShape class above. + + TracingCircle* circle = new TracingCircle(SkPoint::Make(20, 20), 15); + circle->traceSnapshot(); + do_work(100); + + // Make another object. Objects with the same base type are shown in the same row in the viewer. + TracingRect* rect = new TracingRect(SkRect::MakeWH(100, 50)); + rect->traceSnapshot(); + do_work(100); + + // We can create multiple snapshots of objects to reflect their state over time. + circle->fCenter.offset(10, 10); + circle->traceSnapshot(); + + { + // Other events (duration or instant) can refer directly to objects. For Skia's JSON + // tracer, having an argument whose name starts with '#' will trigger the creation of JSON + // that links the event to the object (with a direct link to the most recent snapshot). + TRACE_EVENT1("skia", "Processing Shape", "#shape", circle); + do_work(100); + } + + delete circle; + delete rect; +} + +DEF_TEST(Tracing, reporter) { + test_trace_simple(); + test_trace_counters(); + test_trace_objects(); +} -- cgit v1.2.3