TracingTest.cpp File Reference

#include "include/core/SkColorType.h"
#include "include/core/SkPoint.h"
#include "include/core/SkRect.h"
#include "include/core/SkScalar.h"
#include "include/core/SkString.h"
#include "src/core/SkTraceEvent.h"
#include "tests/Test.h"
#include "tools/flags/CommandLineFlags.h"
#include <cstdint>

Go to the source code of this file.

Functions
static	DEFINE_bool (slowTracingTest, false, "Artificially slow down tracing test to produce nicer JSON")
static void	do_work (int howMuchWork)
static void	test_trace_simple ()
static void	test_trace_counters ()
static void	test_trace_objects ()
	DEF_TEST (Tracing, reporter)

Variables
static SkScalar	gTracingTestWorkSink = 1.0f

Function Documentation

DEF_TEST()

DEF_TEST	(	Tracing	,
		reporter
	)

Definition at line 190 of file TracingTest.cpp.

                            {
    test_trace_simple();
    test_trace_counters();
    test_trace_objects();
}

DEFINE_bool()

static DEFINE_bool ( slowTracingTest  , false  , "Artificially slow down tracing test to produce nicer JSON"    )

static

do_work()

static void do_work ( int  howMuchWork )

static

Definition at line 85 of file TracingTest.cpp.

                                     {
    // 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);
        }
    }
}

test_trace_counters()

static void test_trace_counters ( )

static

Definition at line 117 of file TracingTest.cpp.

                                  {
    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));
            TRACE_COUNTER1("skia", "sin", SkScalarSin(rad) * 1000.0f + 1000.0f);
            TRACE_COUNTER1("skia", "cos", SkScalarCos(rad) * 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));
            TRACE_COUNTER2("skia", "trig",
                           "sin", SkScalarSin(rad) * 1000.0f + 1000.0f,
                           "cos", SkScalarCos(rad) * 1000.0f + 1000.0f);
            do_work(10);
        }
    }
}

test_trace_objects()

static void test_trace_objects ( )

static

Definition at line 159 of file TracingTest.cpp.

                                 {
    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;
}

test_trace_simple()

static void test_trace_simple ( )

static

Definition at line 94 of file TracingTest.cpp.

                                {
    // 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);
    }
}

Variable Documentation

gTracingTestWorkSink

SkScalar gTracingTestWorkSink = 1.0f

static

Definition at line 83 of file TracingTest.cpp.