Line data    Source code

       1             : /*
       2             :  * Copyright 2014 Google Inc.
       3             :  *
       4             :  * Use of this source code is governed by a BSD-style license that can be
       5             :  * found in the LICENSE file.
       6             :  */
       7             : 
       8             : #ifndef GrTracing_DEFINED
       9             : #define GrTracing_DEFINED
      10             : 
      11             : #include "GrGpu.h"
      12             : #include "GrTraceMarker.h"
      13             : #include "SkTLazy.h"
      14             : #include "SkTraceEvent.h"
      15             : 
      16             : /**
      17             :  * Marker generation class used for adding and removing markers around code blocks
      18             :  */
      19             : class GrGpuTraceMarkerGenerator : public ::SkNoncopyable {
      20             : public:
      21             :     GrGpuTraceMarkerGenerator() {}
      22             : 
      23             :     ~GrGpuTraceMarkerGenerator() {
      24             :         if (fTraceMarker.isValid()) {
      25             :             // TODO remove trace marker
      26             :         }
      27             :     }
      28             : 
      29             :     void initialize(const char* marker_str, int* marker_counter) {
      30             :         // GrGpuTraceMarker* traceMarker = fTraceMarker.init(marker_str, *marker_counter);
      31             :         // TODO add trace marker
      32             :     }
      33             : 
      34             : private:
      35             :     SkTLazy<GrGpuTraceMarker> fTraceMarker;
      36             : };
      37             : 
      38             : class GrGpuTraceMarkerGeneratorContext : public ::SkNoncopyable {
      39             : public:
      40           0 :     GrGpuTraceMarkerGeneratorContext(GrContext* context) {}
      41             : 
      42           0 :     ~GrGpuTraceMarkerGeneratorContext() {
      43           0 :         if (fTraceMarker.isValid()) {
      44             :             // TODO remove trace marker
      45             :         }
      46           0 :     }
      47             : 
      48           0 :     void initialize(const char* marker_str, int* marker_counter) {
      49             :         // GrGpuTraceMarker* traceMarker = fTraceMarker.init(marker_str, *marker_counter);
      50             :         // TODO add trace marker
      51           0 :     }
      52             : 
      53             : private:
      54             :     SkTLazy<GrGpuTraceMarker> fTraceMarker;
      55             : };
      56             : 
      57             : /**
      58             :  * GR_CREATE_TRACE_MARKER will place begin and end trace markers for both
      59             :  * cpu and gpu (if gpu tracing enabled) for the current scope.
      60             :  * name is of type const char* and target is of type GrOpList*
      61             :  */
      62             : #define GR_CREATE_TRACE_MARKER(name, target)                                                       \
      63             :     /* Chromium tracing */                                                                         \
      64             :     static int SK_MACRO_APPEND_LINE(name_counter) = 0;                                             \
      65             :     bool SK_MACRO_APPEND_LINE(gpuTracingEnabled);                                                  \
      66             :     TRACE_EVENT_CATEGORY_GROUP_ENABLED(TRACE_DISABLED_BY_DEFAULT("skia.gpu"),                      \
      67             :                                        &SK_MACRO_APPEND_LINE(gpuTracingEnabled));                  \
      68             :     if (SK_MACRO_APPEND_LINE(gpuTracingEnabled)) {                                                 \
      69             :         INTERNAL_GR_CREATE_TRACE_MARKER_SCOPED(name, SK_MACRO_APPEND_LINE(name_counter), target)   \
      70             :     }                                                                                              \
      71             :     INTERNAL_TRACE_EVENT_ADD_SCOPED(TRACE_DISABLED_BY_DEFAULT("skia.gpu"), name,                   \
      72             :                                     "id", SK_MACRO_APPEND_LINE(name_counter));
      73             : 
      74             : #define INTERNAL_GR_CREATE_TRACE_MARKER_SCOPED(name, name_counter, target)        \
      75             :     static const char* SK_MACRO_APPEND_LINE(static_name) = name;                  \
      76             :     INTERNAL_GR_CREATE_TRACE_MARKER(SK_MACRO_APPEND_LINE(static_name),            \
      77             :                                     name_counter,                                 \
      78             :                                     target)                                       \
      79             :     sk_atomic_inc(&name_counter);
      80             : 
      81             : #define INTERNAL_GR_CREATE_TRACE_MARKER(name, name_counter, target, ...)          \
      82             :     GR_CREATE_GPU_TRACE_MARKER(name, name_counter, target)                        \
      83             : 
      84             : #define GR_CREATE_GPU_TRACE_MARKER(name, name_counter, target)                    \
      85             :     GrGpuTraceMarkerGenerator SK_MACRO_APPEND_LINE(TMG)(target);                  \
      86             :     SK_MACRO_APPEND_LINE(TMG).initialize(name, &name_counter);                    \
      87             : 
      88             : /**
      89             :  * Context level GrTracing macros, classname and op are const char*, context is GrContext
      90             :  * TODO can we just have one set of macros?  Probably.
      91             :  */
      92             : #define GR_CREATE_TRACE_MARKER_CONTEXT(classname, op, context)                                     \
      93             :     /* Chromium tracing */                                                                         \
      94             :     static int SK_MACRO_APPEND_LINE(name_counter) = 0;                                             \
      95             :     bool SK_MACRO_APPEND_LINE(gpuTracingEnabled);                                                  \
      96             :     TRACE_EVENT_CATEGORY_GROUP_ENABLED(TRACE_DISABLED_BY_DEFAULT("skia.gpu"),                      \
      97             :                                        &SK_MACRO_APPEND_LINE(gpuTracingEnabled));                  \
      98             :     if (SK_MACRO_APPEND_LINE(gpuTracingEnabled)) {                                                 \
      99             :         INTERNAL_GR_CREATE_TRACE_MARKER_SCOPED_C(classname "::" op,                                \
     100             :                                                  SK_MACRO_APPEND_LINE(name_counter), context)      \
     101             :     }                                                                                              \
     102             :     GR_AUDIT_TRAIL_AUTO_FRAME(context->getAuditTrail(), classname "::" op);                        \
     103             :     INTERNAL_TRACE_EVENT_ADD_SCOPED(TRACE_DISABLED_BY_DEFAULT("skia.gpu"), classname "::" op,      \
     104             :                                     "id", SK_MACRO_APPEND_LINE(name_counter));
     105             : 
     106             : #define INTERNAL_GR_CREATE_TRACE_MARKER_SCOPED_C(name, name_counter, context)     \
     107             :     static const char* SK_MACRO_APPEND_LINE(static_name) = name;                  \
     108             :     INTERNAL_GR_CREATE_TRACE_MARKER_C(SK_MACRO_APPEND_LINE(static_name),          \
     109             :                                       name_counter,                               \
     110             :                                       context)                                    \
     111             :     sk_atomic_inc(&name_counter);
     112             : 
     113             : #define INTERNAL_GR_CREATE_TRACE_MARKER_C(name, name_counter, context, ...)       \
     114             :     GR_CREATE_GPU_TRACE_MARKER_C(name, name_counter, context)                     \
     115             : 
     116             : #define GR_CREATE_GPU_TRACE_MARKER_C(name, name_counter, context)                 \
     117             :     GrGpuTraceMarkerGeneratorContext SK_MACRO_APPEND_LINE(TMG)(context);          \
     118             :     SK_MACRO_APPEND_LINE(TMG).initialize(name, &name_counter);                    \
     119             : 
     120             : #endif