flutter::FlutterEventTracer Class Reference

Inheritance diagram for flutter::FlutterEventTracer:

Public Member Functions
	FlutterEventTracer (bool enabled, const std::optional< std::vector< std::string > > &allowlist)
SkEventTracer::Handle	addTraceEvent (char phase, const uint8_t *category_enabled_flag, const char *name, uint64_t id, int num_args, const char **p_arg_names, const uint8_t *p_arg_types, const uint64_t *p_arg_values, uint8_t flags) override
void	updateTraceEventDuration (const uint8_t *category_enabled_flag, const char *name, SkEventTracer::Handle handle) override
const uint8_t *	getCategoryGroupEnabled (const char *name) override
const char *	getCategoryGroupName (const uint8_t *category_enabled_flag) override
Public Member Functions inherited from SkEventTracer
virtual	~SkEventTracer ()=default
virtual SkEventTracer::Handle	addTraceEvent (char phase, const uint8_t *categoryEnabledFlag, const char *name, uint64_t id, int32_t numArgs, const char **argNames, const uint8_t *argTypes, const uint64_t *argValues, uint8_t flags)=0
virtual void	newTracingSection (const char *)

Static Public Attributes
static constexpr const char *	kSkiaTag = "skia"
static constexpr uint8_t	kYes = 1
static constexpr uint8_t	kNo = 0

Additional Inherited Members
Public Types inherited from SkEventTracer
enum	CategoryGroupEnabledFlags { kEnabledForRecording_CategoryGroupEnabledFlags = 1 << 0 , kEnabledForMonitoring_CategoryGroupEnabledFlags = 1 << 1 , kEnabledForEventCallback_CategoryGroupEnabledFlags = 1 << 2 }
typedef uint64_t	Handle
Static Public Member Functions inherited from SkEventTracer
static bool	SetInstance (SkEventTracer *, bool leakTracer=false)
static SkEventTracer *	GetInstance ()
Protected Member Functions inherited from SkEventTracer
	SkEventTracer ()=default
	SkEventTracer (const SkEventTracer &)=delete
SkEventTracer &	operator= (const SkEventTracer &)=delete

Detailed Description

Definition at line 76 of file skia_event_tracer_impl.cc.

Constructor & Destructor Documentation

FlutterEventTracer()

flutter::FlutterEventTracer::FlutterEventTracer ( bool  enabled, const std::optional< std::vector< std::string > > &  allowlist  )

inline

Definition at line 82 of file skia_event_tracer_impl.cc.

      : enabled_(enabled ? kYes : kNo) {
    if (allowlist.has_value()) {
      allowlist_.emplace();
      for (const std::string& category : *allowlist) {
        allowlist_->insert(std::string(kTraceCategoryPrefix) + category);
      }
    }
  };

Member Function Documentation

addTraceEvent()

SkEventTracer::Handle flutter::FlutterEventTracer::addTraceEvent ( char  phase, const uint8_t *  category_enabled_flag, const char *  name, uint64_t  id, int  num_args, const char **  p_arg_names, const uint8_t *  p_arg_types, const uint64_t *  p_arg_values, uint8_t  flags  )

inlineoverride

Definition at line 93 of file skia_event_tracer_impl.cc.

                                                              {
#if defined(OS_FUCHSIA)
    static trace_site_t trace_site;
    trace_string_ref_t category_ref;
    trace_context_t* trace_context = trace_acquire_context_for_category_cached(
        kSkiaTag, &trace_site, &category_ref);
 
    if (likely(!trace_context)) {
      return 0;
    }
 
    trace_ticks_t ticks = zx_ticks_get();
 
    trace_thread_ref_t thread_ref;
    trace_context_register_current_thread(trace_context, &thread_ref);
    trace_string_ref_t name_ref;
    trace_context_register_string_literal(trace_context, name, &name_ref);
 
    constexpr int kMaxArgs = 2;
    trace_arg_t trace_args[kMaxArgs] = {};
    FML_DCHECK(num_args >= 0);
    int num_trace_args = std::min(kMaxArgs, num_args);
 
    for (int i = 0; i < num_trace_args; i++) {
      const char* arg_name = p_arg_names[i];
      const uint8_t arg_type = p_arg_types[i];
      const uint64_t arg_value = p_arg_values[i];
 
      trace_string_ref_t arg_name_string_ref =
          trace_context_make_registered_string_literal(trace_context, arg_name);
 
      trace_arg_value_t trace_arg_value;
      switch (arg_type) {
        case TRACE_VALUE_TYPE_BOOL: {
          trace_arg_value = trace_make_bool_arg_value(!!arg_value);
          break;
        }
        case TRACE_VALUE_TYPE_UINT:
          trace_arg_value = trace_make_uint64_arg_value(arg_value);
          break;
        case TRACE_VALUE_TYPE_INT:
          trace_arg_value =
              trace_make_int64_arg_value(BitCast<int64_t>(arg_value));
          break;
        case TRACE_VALUE_TYPE_DOUBLE:
          trace_arg_value =
              trace_make_double_arg_value(BitCast<double>(arg_value));
          break;
        case TRACE_VALUE_TYPE_POINTER:
          trace_arg_value =
              trace_make_pointer_arg_value(BitCast<uintptr_t>(arg_value));
          break;
        case TRACE_VALUE_TYPE_STRING: {
          trace_string_ref_t arg_value_string_ref =
              trace_context_make_registered_string_literal(
                  trace_context, reinterpret_cast<const char*>(arg_value));
          trace_arg_value = trace_make_string_arg_value(arg_value_string_ref);
          break;
        }
        case TRACE_VALUE_TYPE_COPY_STRING: {
          const char* arg_value_as_cstring =
              reinterpret_cast<const char*>(arg_value);
          trace_string_ref_t arg_value_string_ref =
              trace_context_make_registered_string_copy(
                  trace_context, arg_value_as_cstring,
                  strlen(arg_value_as_cstring));
          trace_arg_value = trace_make_string_arg_value(arg_value_string_ref);
          break;
        }
        case TRACE_VALUE_TYPE_CONVERTABLE:
          trace_arg_value = trace_make_null_arg_value();
          break;
        default:
          trace_arg_value = trace_make_null_arg_value();
      }
 
      trace_args[i] = trace_make_arg(arg_name_string_ref, trace_arg_value);
    }
 
    switch (phase) {
      case TRACE_EVENT_PHASE_BEGIN:
      case TRACE_EVENT_PHASE_COMPLETE:
        trace_context_write_duration_begin_event_record(
            trace_context, ticks, &thread_ref, &category_ref, &name_ref,
            trace_args, num_trace_args);
        break;
      case TRACE_EVENT_PHASE_END:
        trace_context_write_duration_end_event_record(
            trace_context, ticks, &thread_ref, &category_ref, &name_ref,
            trace_args, num_trace_args);
        break;
      case TRACE_EVENT_PHASE_INSTANT:
        trace_context_write_instant_event_record(
            trace_context, ticks, &thread_ref, &category_ref, &name_ref,
            TRACE_SCOPE_THREAD, trace_args, num_trace_args);
        break;
      case TRACE_EVENT_PHASE_ASYNC_BEGIN:
        trace_context_write_async_begin_event_record(
            trace_context, ticks, &thread_ref, &category_ref, &name_ref, id,
            trace_args, num_trace_args);
        break;
      case TRACE_EVENT_PHASE_ASYNC_END:
        trace_context_write_async_end_event_record(
            trace_context, ticks, &thread_ref, &category_ref, &name_ref, id,
            trace_args, num_trace_args);
        break;
      default:
        break;
    }
 
    trace_release_context(trace_context);
 
#else   // defined(OS_FUCHSIA)
    const char* devtoolsTag = nullptr;
    if (shaders_category_flag_ &&
        category_enabled_flag == shaders_category_flag_) {
      devtoolsTag = kShadersDevtoolsTag;
    }
    switch (phase) {
      case TRACE_EVENT_PHASE_BEGIN:
      case TRACE_EVENT_PHASE_COMPLETE:
        if (devtoolsTag) {
          fml::tracing::TraceEvent1(kSkiaTag, name, /*flow_id_count=*/0,
                                    /*flow_ids=*/nullptr, kDevtoolsTagArg,
                                    devtoolsTag);
        } else {
          fml::tracing::TraceEvent0(kSkiaTag, name, /*flow_id_count=*/0,
                                    /*flow_ids=*/nullptr);
        }
        break;
      case TRACE_EVENT_PHASE_END:
        fml::tracing::TraceEventEnd(name);
        break;
      case TRACE_EVENT_PHASE_INSTANT:
        if (devtoolsTag) {
          fml::tracing::TraceEventInstant1(kSkiaTag, name,
                                           /*flow_id_count=*/0,
                                           /*flow_ids=*/nullptr,
                                           kDevtoolsTagArg, devtoolsTag);
        } else {
          fml::tracing::TraceEventInstant0(kSkiaTag, name,
                                           /*flow_id_count=*/0,
                                           /*flow_ids=*/nullptr);
        }
        break;
      case TRACE_EVENT_PHASE_ASYNC_BEGIN:
        if (devtoolsTag) {
          fml::tracing::TraceEventAsyncBegin1(kSkiaTag, name, id,
                                              /*flow_id_count=*/0,
                                              /*flow_ids=*/nullptr,
                                              kDevtoolsTagArg, devtoolsTag);
        } else {
          fml::tracing::TraceEventAsyncBegin0(kSkiaTag, name, id,
                                              /*flow_id_count=*/0,
                                              /*flow_ids=*/nullptr);
        }
        break;
      case TRACE_EVENT_PHASE_ASYNC_END:
        if (devtoolsTag) {
          fml::tracing::TraceEventAsyncEnd1(kSkiaTag, name, id, kDevtoolsTagArg,
                                            devtoolsTag);
        } else {
          fml::tracing::TraceEventAsyncEnd0(kSkiaTag, name, id);
        }
        break;
      default:
        break;
    }
#endif  // defined(OS_FUCHSIA)
    return 0;
  }

getCategoryGroupEnabled()

const uint8_t * flutter::FlutterEventTracer::getCategoryGroupEnabled ( const char *  name )

inlineoverridevirtual

Implements SkEventTracer.

Definition at line 285 of file skia_event_tracer_impl.cc.

                                                                    {
    // Skia will only use long-lived string literals as event names.
    std::lock_guard<std::mutex> lock(flag_map_mutex_);
    auto flag_it = category_flag_map_.find(name);
    if (flag_it == category_flag_map_.end()) {
      bool allowed;
      if (enabled_) {
        allowed = !allowlist_.has_value() ||
                  allowlist_->find(name) != allowlist_->end();
      } else {
        allowed = false;
      }
      flag_it = category_flag_map_.insert(std::make_pair(name, allowed)).first;
      const uint8_t* flag = &flag_it->second;
      reverse_flag_map_.insert(std::make_pair(flag, name));
      if (kShaderCategoryName == name) {
        shaders_category_flag_ = flag;
      }
    }
    return &flag_it->second;
  }

getCategoryGroupName()

const char * flutter::FlutterEventTracer::getCategoryGroupName ( const uint8_t *  category_enabled_flag )

inlineoverridevirtual

Implements SkEventTracer.

Definition at line 307 of file skia_event_tracer_impl.cc.

                                                     {
    std::lock_guard<std::mutex> lock(flag_map_mutex_);
    auto reverse_it = reverse_flag_map_.find(category_enabled_flag);
    if (reverse_it != reverse_flag_map_.end()) {
      return reverse_it->second;
    } else {
      return kSkiaTag;
    }
  }

updateTraceEventDuration()

void flutter::FlutterEventTracer::updateTraceEventDuration ( const uint8_t *  category_enabled_flag, const char *  name, SkEventTracer::Handle  handle  )

inlineoverridevirtual

Implements SkEventTracer.

Definition at line 273 of file skia_event_tracer_impl.cc.

                                                                     {
    // This is only ever called from a scoped trace event so we will just end
    // the section.
#if defined(OS_FUCHSIA)
    TRACE_DURATION_END(kSkiaTag, name);
#else
    fml::tracing::TraceEventEnd(name);
#endif
  }

Member Data Documentation

kNo

constexpr uint8_t flutter::FlutterEventTracer::kNo = 0

staticconstexpr

Definition at line 80 of file skia_event_tracer_impl.cc.

kSkiaTag

constexpr const char* flutter::FlutterEventTracer::kSkiaTag = "skia"

staticconstexpr

Definition at line 78 of file skia_event_tracer_impl.cc.

kYes

constexpr uint8_t flutter::FlutterEventTracer::kYes = 1

staticconstexpr

Definition at line 79 of file skia_event_tracer_impl.cc.

---

The documentation for this class was generated from the following file:

• shell/common/skia_event_tracer_impl.cc