Flutter Engine
 
Loading...
Searching...
No Matches
Classes | Namespaces | Macros | Typedefs | Functions
trace_event.h File Reference
#include <functional>
#include "flutter/fml/build_config.h"
#include <cstddef>
#include <cstdint>
#include <string>
#include <type_traits>
#include <vector>
#include "flutter/fml/macros.h"
#include "flutter/fml/time/time_point.h"
#include "third_party/dart/runtime/include/dart_tools_api.h"

Go to the source code of this file.

Classes

class  fml::tracing::ScopedInstantEnd
 
class  fml::tracing::TraceFlow
 

Namespaces

namespace  fml
 
namespace  fml::tracing
 

Macros

#define FLUTTER_TIMELINE_ENABLED   1
 
#define __FML__TOKEN_CAT__(x, y)   x##y
 
#define __FML__TOKEN_CAT__2(x, y)   __FML__TOKEN_CAT__(x, y)
 
#define __FML__AUTO_TRACE_END(name)
 
#define FML_TRACE_COUNTER(category_group, name, counter_id, arg1, ...)
 
#define FML_TRACE_EVENT_WITH_FLOW_IDS(category_group, name, flow_id_count, flow_ids, ...)
 
#define FML_TRACE_EVENT(category_group, name, ...)
 
#define TRACE_EVENT0_WITH_FLOW_IDS(category_group, name, flow_id_count, flow_ids)
 
#define TRACE_EVENT0(category_group, name)
 
#define TRACE_EVENT1_WITH_FLOW_IDS(category_group, name, flow_id_count, flow_ids, arg1_name, arg1_val)
 
#define TRACE_EVENT1(category_group, name, arg1_name, arg1_val)
 
#define TRACE_EVENT2(category_group, name, arg1_name, arg1_val, arg2_name, arg2_val)
 
#define TRACE_EVENT_ASYNC_BEGIN0_WITH_FLOW_IDS(category_group, name, id, flow_id_count, flow_ids)
 
#define TRACE_EVENT_ASYNC_BEGIN0(category_group, name, id)
 
#define TRACE_EVENT_ASYNC_END0(category_group, name, id)    ::fml::tracing::TraceEventAsyncEnd0(category_group, name, id);
 
#define TRACE_EVENT_ASYNC_BEGIN1(category_group, name, id, arg1_name, arg1_val)
 
#define TRACE_EVENT_ASYNC_END1(category_group, name, id, arg1_name, arg1_val)
 
#define TRACE_EVENT_INSTANT0(category_group, name)
 
#define TRACE_EVENT_INSTANT1(category_group, name, arg1_name, arg1_val)
 
#define TRACE_EVENT_INSTANT2(category_group, name, arg1_name, arg1_val, arg2_name, arg2_val)
 
#define TRACE_FLOW_BEGIN(category, name, id)    ::fml::tracing::TraceEventFlowBegin0(category, name, id);
 
#define TRACE_FLOW_STEP(category, name, id)    ::fml::tracing::TraceEventFlowStep0(category, name, id);
 
#define TRACE_FLOW_END(category, name, id)    ::fml::tracing::TraceEventFlowEnd0(category, name, id);
 
#define TRACE_EVENT2_INT(category_group, name, arg1_name, arg1_val, arg2_name, arg2_val)
 

Typedefs

using fml::tracing::TraceArg = const char *
 
using fml::tracing::TraceIDArg = int64_t
 
typedef void(* fml::tracing::TimelineEventHandler) (const char *, int64_t, int64_t, intptr_t, const int64_t *, Dart_Timeline_Event_Type, intptr_t, const char **, const char **)
 
using fml::tracing::TimelineMicrosSource = int64_t(*)()
 

Functions

void fml::tracing::TraceSetAllowlist (const std::vector< std::string > &allowlist)
 
void fml::tracing::TraceSetTimelineEventHandler (TimelineEventHandler handler)
 
bool fml::tracing::TraceHasTimelineEventHandler ()
 
void fml::tracing::TraceSetTimelineMicrosSource (TimelineMicrosSource source)
 
int64_t fml::tracing::TraceGetTimelineMicros ()
 
void fml::tracing::TraceTimelineEvent (TraceArg category_group, TraceArg name, int64_t timestamp_micros, TraceIDArg identifier, size_t flow_id_count, const uint64_t *flow_ids, Dart_Timeline_Event_Type type, const std::vector< const char * > &c_names, const std::vector< std::string > &values)
 
void fml::tracing::TraceTimelineEvent (TraceArg category_group, TraceArg name, TraceIDArg identifier, size_t flow_id_count, const uint64_t *flow_ids, Dart_Timeline_Event_Type type, const std::vector< const char * > &c_names, const std::vector< std::string > &values)
 
std::string fml::tracing::TraceToString (const char *string)
 
std::string fml::tracing::TraceToString (std::string string)
 
std::string fml::tracing::TraceToString (TimePoint point)
 
template<typename T , typename = std::enable_if_t<std::is_arithmetic<T>::value>>
std::string fml::tracing::TraceToString (T string)
 
void fml::tracing::SplitArgumentsCollect (std::vector< const char * > &keys, std::vector< std::string > &values)
 
template<typename Key , typename Value , typename... Args>
void fml::tracing::SplitArgumentsCollect (std::vector< const char * > &keys, std::vector< std::string > &values, Key key, Value value, Args... args)
 
std::pair< std::vector< const char * >, std::vector< std::string > > fml::tracing::SplitArguments ()
 
template<typename Key , typename Value , typename... Args>
std::pair< std::vector< const char * >, std::vector< std::string > > fml::tracing::SplitArguments (Key key, Value value, Args... args)
 
size_t fml::tracing::TraceNonce ()
 
template<typename... Args>
void fml::tracing::TraceCounter (TraceArg category, TraceArg name, TraceIDArg identifier, Args... args)
 
template<typename... Args>
void fml::tracing::TraceCounterNopHACK (TraceArg category, TraceArg name, TraceIDArg identifier, Args... args)
 
template<typename... Args>
void fml::tracing::TraceEvent (TraceArg category, TraceArg name, size_t flow_id_count, const uint64_t *flow_ids, Args... args)
 
void fml::tracing::TraceEvent0 (TraceArg category_group, TraceArg name, size_t flow_id_count, const uint64_t *flow_ids)
 
void fml::tracing::TraceEvent1 (TraceArg category_group, TraceArg name, size_t flow_id_count, const uint64_t *flow_ids, TraceArg arg1_name, TraceArg arg1_val)
 
void fml::tracing::TraceEvent2 (TraceArg category_group, TraceArg name, size_t flow_id_count, const uint64_t *flow_ids, TraceArg arg1_name, TraceArg arg1_val, TraceArg arg2_name, TraceArg arg2_val)
 
void fml::tracing::TraceEventEnd (TraceArg name)
 
template<typename... Args>
void fml::tracing::TraceEventAsyncComplete (TraceArg category_group, TraceArg name, TimePoint begin, TimePoint end, Args... args)
 
void fml::tracing::TraceEventAsyncBegin0 (TraceArg category_group, TraceArg name, TraceIDArg id, size_t flow_id_count, const uint64_t *flow_ids)
 
void fml::tracing::TraceEventAsyncEnd0 (TraceArg category_group, TraceArg name, TraceIDArg id)
 
void fml::tracing::TraceEventAsyncBegin1 (TraceArg category_group, TraceArg name, TraceIDArg id, size_t flow_id_count, const uint64_t *flow_ids, TraceArg arg1_name, TraceArg arg1_val)
 
void fml::tracing::TraceEventAsyncEnd1 (TraceArg category_group, TraceArg name, TraceIDArg id, TraceArg arg1_name, TraceArg arg1_val)
 
void fml::tracing::TraceEventInstant0 (TraceArg category_group, TraceArg name, size_t flow_id_count, const uint64_t *flow_ids)
 
void fml::tracing::TraceEventInstant1 (TraceArg category_group, TraceArg name, size_t flow_id_count, const uint64_t *flow_ids, TraceArg arg1_name, TraceArg arg1_val)
 
void fml::tracing::TraceEventInstant2 (TraceArg category_group, TraceArg name, size_t flow_id_count, const uint64_t *flow_ids, TraceArg arg1_name, TraceArg arg1_val, TraceArg arg2_name, TraceArg arg2_val)
 
void fml::tracing::TraceEventFlowBegin0 (TraceArg category_group, TraceArg name, TraceIDArg id)
 
void fml::tracing::TraceEventFlowStep0 (TraceArg category_group, TraceArg name, TraceIDArg id)
 
void fml::tracing::TraceEventFlowEnd0 (TraceArg category_group, TraceArg name, TraceIDArg id)
 

Macro Definition Documentation

◆ __FML__AUTO_TRACE_END

#define __FML__AUTO_TRACE_END (   name)
Value:
::fml::tracing::ScopedInstantEnd __FML__TOKEN_CAT__2(__trace_end_, \
__LINE__)(name);
name
const char * name
Definition fuchsia.cc:49
__FML__TOKEN_CAT__2
#define __FML__TOKEN_CAT__2(x, y)
Definition trace_event.h:76

Definition at line 77 of file trace_event.h.

208 {
209namespace tracing {
210
211using TraceArg = const char*;
212using TraceIDArg = int64_t;
213
214void TraceSetAllowlist(const std::vector<std::string>& allowlist);
215
216typedef void (*TimelineEventHandler)(const char*,
217 int64_t,
218 int64_t,
219 intptr_t,
220 const int64_t*,
221 Dart_Timeline_Event_Type,
222 intptr_t,
223 const char**,
224 const char**);
225
226using TimelineMicrosSource = int64_t (*)();
227
228void TraceSetTimelineEventHandler(TimelineEventHandler handler);
229
230bool TraceHasTimelineEventHandler();
231
232void TraceSetTimelineMicrosSource(TimelineMicrosSource source);
233
234int64_t TraceGetTimelineMicros();
235
236void TraceTimelineEvent(TraceArg category_group,
237 TraceArg name,
238 int64_t timestamp_micros,
239 TraceIDArg id,
240 size_t flow_id_count,
241 const uint64_t* flow_ids,
242 Dart_Timeline_Event_Type type,
243 const std::vector<const char*>& names,
244 const std::vector<std::string>& values);
245
246void TraceTimelineEvent(TraceArg category_group,
247 TraceArg name,
248 TraceIDArg id,
249 size_t flow_id_count,
250 const uint64_t* flow_ids,
251 Dart_Timeline_Event_Type type,
252 const std::vector<const char*>& names,
253 const std::vector<std::string>& values);
254
255inline std::string TraceToString(const char* string) {
256 return std::string{string};
257}
258
259inline std::string TraceToString(std::string string) {
260 return string;
261}
262
263inline std::string TraceToString(TimePoint point) {
264 return std::to_string(point.ToEpochDelta().ToNanoseconds());
265}
266
267template <typename T, typename = std::enable_if_t<std::is_arithmetic<T>::value>>
268std::string TraceToString(T string) {
269 return std::to_string(string);
270}
271
272inline void SplitArgumentsCollect(std::vector<const char*>& keys,
273 std::vector<std::string>& values) {}
274
275template <typename Key, typename Value, typename... Args>
276void SplitArgumentsCollect(std::vector<const char*>& keys,
277 std::vector<std::string>& values,
278 Key key,
279 Value value,
280 Args... args) {
281 keys.emplace_back(key);
282 values.emplace_back(TraceToString(std::move(value)));
283 SplitArgumentsCollect(keys, values, args...);
284}
285
286inline std::pair<std::vector<const char*>, std::vector<std::string>>
287SplitArguments() {
288 return {};
289}
290
291template <typename Key, typename Value, typename... Args>
292std::pair<std::vector<const char*>, std::vector<std::string>>
293SplitArguments(Key key, Value value, Args... args) {
294 std::vector<const char*> keys;
295 std::vector<std::string> values;
296 SplitArgumentsCollect(keys, values, key, std::move(value), args...);
297 return std::make_pair(std::move(keys), std::move(values));
298}
299
300size_t TraceNonce();
301
302template <typename... Args>
303void TraceCounter(TraceArg category,
304 TraceArg name,
305 TraceIDArg identifier,
306 Args... args) {
307#if FLUTTER_TIMELINE_ENABLED
308 auto split = SplitArguments(args...);
309 TraceTimelineEvent(category, name, identifier, /*flow_id_count=*/0,
310 /*flow_ids=*/nullptr, Dart_Timeline_Event_Counter,
311 split.first, split.second);
312#endif // FLUTTER_TIMELINE_ENABLED
313}
314
315// HACK: Used to NOP FML_TRACE_COUNTER macro without triggering unused var
316// warnings at usage sites.
317template <typename... Args>
318void TraceCounterNopHACK(TraceArg category,
319 TraceArg name,
320 TraceIDArg identifier,
321 Args... args) {}
322
323template <typename... Args>
324void TraceEvent(TraceArg category,
325 TraceArg name,
326 size_t flow_id_count,
327 const uint64_t* flow_ids,
328 Args... args) {
329#if FLUTTER_TIMELINE_ENABLED
330 auto split = SplitArguments(std::move(args)...);
331 TraceTimelineEvent(category, name, 0, flow_id_count, flow_ids,
332 Dart_Timeline_Event_Begin, split.first, split.second);
333#endif // FLUTTER_TIMELINE_ENABLED
334}
335
336void TraceEvent0(TraceArg category_group,
337 TraceArg name,
338 size_t flow_id_count,
339 const uint64_t* flow_ids);
340
341void TraceEvent1(TraceArg category_group,
342 TraceArg name,
343 size_t flow_id_count,
344 const uint64_t* flow_ids,
345 TraceArg arg1_name,
346 TraceArg arg1_val);
347
348void TraceEvent2(TraceArg category_group,
349 TraceArg name,
350 size_t flow_id_count,
351 const uint64_t* flow_ids,
352 TraceArg arg1_name,
353 TraceArg arg1_val,
354 TraceArg arg2_name,
355 TraceArg arg2_val);
356
357void TraceEventEnd(TraceArg name);
358
359template <typename... Args>
360void TraceEventAsyncComplete(TraceArg category_group,
361 TraceArg name,
362 TimePoint begin,
363 TimePoint end,
364 Args... args) {
365#if FLUTTER_TIMELINE_ENABLED
366 auto identifier = TraceNonce();
367 const auto split = SplitArguments(args...);
368
369 if (begin > end) {
370 std::swap(begin, end);
371 }
372
373 const int64_t begin_micros = begin.ToEpochDelta().ToMicroseconds();
374 const int64_t end_micros = end.ToEpochDelta().ToMicroseconds();
375
376 TraceTimelineEvent(category_group, // group
377 name, // name
378 begin_micros, // timestamp_micros
379 identifier, // identifier
380 0, // flow_id_count
381 nullptr, // flow_ids
382 Dart_Timeline_Event_Async_Begin, // type
383 split.first, // names
384 split.second // values
385 );
386
387 TraceTimelineEvent(category_group, // group
388 name, // name
389 end_micros, // timestamp_micros
390 identifier, // identifier
391 0, // flow_id_count
392 nullptr, // flow_ids
393 Dart_Timeline_Event_Async_End, // type
394 split.first, // names
395 split.second // values
396 );
397#endif // FLUTTER_TIMELINE_ENABLED
398}
399
400void TraceEventAsyncBegin0(TraceArg category_group,
401 TraceArg name,
402 TraceIDArg id,
403 size_t flow_id_count,
404 const uint64_t* flow_ids);
405
406void TraceEventAsyncEnd0(TraceArg category_group, TraceArg name, TraceIDArg id);
407
408void TraceEventAsyncBegin1(TraceArg category_group,
409 TraceArg name,
410 TraceIDArg id,
411 size_t flow_id_count,
412 const uint64_t* flow_ids,
413 TraceArg arg1_name,
414 TraceArg arg1_val);
415
416void TraceEventAsyncEnd1(TraceArg category_group,
417 TraceArg name,
418 TraceIDArg id,
419 TraceArg arg1_name,
420 TraceArg arg1_val);
421
422void TraceEventInstant0(TraceArg category_group,
423 TraceArg name,
424 size_t flow_id_count,
425 const uint64_t* flow_ids);
426
427void TraceEventInstant1(TraceArg category_group,
428 TraceArg name,
429 size_t flow_id_count,
430 const uint64_t* flow_ids,
431 TraceArg arg1_name,
432 TraceArg arg1_val);
433
434void TraceEventInstant2(TraceArg category_group,
435 TraceArg name,
436 size_t flow_id_count,
437 const uint64_t* flow_ids,
438 TraceArg arg1_name,
439 TraceArg arg1_val,
440 TraceArg arg2_name,
441 TraceArg arg2_val);
442
443void TraceEventFlowBegin0(TraceArg category_group,
444 TraceArg name,
445 TraceIDArg id);
446
447void TraceEventFlowStep0(TraceArg category_group, TraceArg name, TraceIDArg id);
448
449void TraceEventFlowEnd0(TraceArg category_group, TraceArg name, TraceIDArg id);
450
451class ScopedInstantEnd {
452 public:
453 explicit ScopedInstantEnd(const char* str) : label_(str) {}
454
455 ~ScopedInstantEnd() { TraceEventEnd(label_); }
456
457 private:
458 const char* label_;
459
460 FML_DISALLOW_COPY_AND_ASSIGN(ScopedInstantEnd);
461};
462
463// A move-only utility object that creates a new flow with a unique ID and
464// automatically ends it when it goes out of scope. When tracing using multiple
465// overlapping flows, it often gets hard to make sure to end the flow
466// (especially with early returns), or, end/step on the wrong flow. This
467// leads to corrupted or missing traces in the UI.
468class TraceFlow {
469 public:
470 explicit TraceFlow(const char* label) : label_(label), nonce_(TraceNonce()) {
471 TraceEvent0("flutter", label_, /*flow_id_count=*/1,
472 /*flow_ids=*/&nonce_);
473 TraceEventFlowBegin0("flutter", label_, nonce_);
474 TraceEventEnd(label_);
475 }
476
477 ~TraceFlow() { End(label_); }
478
479 TraceFlow(TraceFlow&& other) : label_(other.label_), nonce_(other.nonce_) {
480 other.nonce_ = 0;
481 }
482
483 void Step(const char* label = nullptr) const {
484 TraceEvent0("flutter", label ? label : label_, /*flow_id_count=*/1,
485 /*flow_ids=*/&nonce_);
486 TraceEventFlowStep0("flutter", label ? label : label_, nonce_);
487 TraceEventEnd(label ? label : label_);
488 }
489
490 void End(const char* label = nullptr) {
491 if (nonce_ != 0) {
492 TraceEvent0("flutter", label ? label : label_, /*flow_id_count=*/1,
493 /*flow_ids=*/&nonce_);
494 TraceEventFlowEnd0("flutter", label ? label : label_, nonce_);
495 TraceEventEnd(label ? label : label_);
496 nonce_ = 0;
497 }
498 }
499
500 private:
501 const char* label_;
502 uint64_t nonce_;
503
504 FML_DISALLOW_COPY_AND_ASSIGN(TraceFlow);
505};
506
507} // namespace tracing
508} // namespace fml
509
510#endif // FLUTTER_FML_TRACE_EVENT_H_
type
GLenum type
Definition blit_command_gles.cc:153
args
G_BEGIN_DECLS G_MODULE_EXPORT FlValue * args
Definition fl_event_channel.h:89
handler
const gchar FlBinaryMessengerMessageHandler handler
Definition fl_mock_binary_messenger.cc:205
FML_DISALLOW_COPY_AND_ASSIGN
#define FML_DISALLOW_COPY_AND_ASSIGN(TypeName)
Definition macros.h:27
key
int key
Definition keyboard_key_handler_unittests.cc:114
flutter::tracing
it will be possible to load the file into Perfetto s trace viewer use test Running tests that layout and measure text will not yield consistent results across various platforms Enabling this option will make font resolution default to the Ahem test font on all disable asset Prevents usage of any non test fonts unless they were explicitly Loaded via prefetched default font Indicates whether the embedding started a prefetch of the default font manager before creating the engine run In non interactive keep the shell running after the Dart script has completed enable serial On low power devices with low core running concurrent GC tasks on threads can cause them to contend with the UI thread which could potentially lead to jank This option turns off all concurrent GC activities domain network JSON encoded network policy per domain This overrides the DisallowInsecureConnections switch Embedder can specify whether to allow or disallow insecure connections at a domain level old gen heap The size limit in megabytes for the Dart VM old gen heap space enable Enable the Impeller renderer on supported platforms Ignored if Impeller is not supported on the platform enable vulkan Enable loading Vulkan validation layers The layers must be available to the application and loadable On non Vulkan this flag does nothing enable vulkan gpu tracing
Definition switch_defs.h:265
fml::tracing::TraceEventFlowEnd0
void TraceEventFlowEnd0(TraceArg category_group, TraceArg name, TraceIDArg id)
Definition trace_event.cc:489
fml::tracing::TraceEventInstant0
void TraceEventInstant0(TraceArg category_group, TraceArg name, size_t flow_id_count, const uint64_t *flow_ids)
Definition trace_event.cc:460
fml::tracing::TraceToString
std::string TraceToString(const char *string)
Definition trace_event.h:256
fml::tracing::TraceEventFlowBegin0
void TraceEventFlowBegin0(TraceArg category_group, TraceArg name, TraceIDArg id)
Definition trace_event.cc:481
fml::tracing::TraceHasTimelineEventHandler
bool TraceHasTimelineEventHandler()
Definition trace_event.cc:375
fml::tracing::TraceEventAsyncBegin0
void TraceEventAsyncBegin0(TraceArg category_group, TraceArg name, TraceIDArg id, size_t flow_id_count, const uint64_t *flow_ids)
Definition trace_event.cc:436
fml::tracing::TraceSetAllowlist
void TraceSetAllowlist(const std::vector< std::string > &allowlist)
Definition trace_event.cc:371
fml::tracing::TraceEventAsyncEnd0
void TraceEventAsyncEnd0(TraceArg category_group, TraceArg name, TraceIDArg id)
Definition trace_event.cc:442
fml::tracing::TraceEvent0
void TraceEvent0(TraceArg category_group, TraceArg name, size_t flow_id_count, const uint64_t *flow_ids)
Definition trace_event.cc:408
fml::tracing::TraceEventInstant1
void TraceEventInstant1(TraceArg category_group, TraceArg name, size_t flow_id_count, const uint64_t *flow_ids, TraceArg arg1_name, TraceArg arg1_val)
Definition trace_event.cc:465
fml::tracing::TraceArg
const char * TraceArg
Definition trace_event.h:212
fml::tracing::TimelineMicrosSource
int64_t(*)() TimelineMicrosSource
Definition trace_event.h:227
fml::tracing::TraceEventAsyncBegin1
void TraceEventAsyncBegin1(TraceArg category_group, TraceArg name, TraceIDArg id, size_t flow_id_count, const uint64_t *flow_ids, TraceArg arg1_name, TraceArg arg1_val)
Definition trace_event.cc:446
fml::tracing::TraceTimelineEvent
void TraceTimelineEvent(TraceArg category_group, TraceArg name, int64_t timestamp_micros, TraceIDArg identifier, size_t flow_id_count, const uint64_t *flow_ids, Dart_Timeline_Event_Type type, const std::vector< const char * > &c_names, const std::vector< std::string > &values)
Definition trace_event.cc:389
fml::tracing::SplitArgumentsCollect
void SplitArgumentsCollect(std::vector< const char * > &keys, std::vector< std::string > &values)
Definition trace_event.h:273
fml::tracing::TraceSetTimelineEventHandler
void TraceSetTimelineEventHandler(TimelineEventHandler handler)
Definition trace_event.cc:373
fml::tracing::TraceSetTimelineMicrosSource
void TraceSetTimelineMicrosSource(TimelineMicrosSource source)
Definition trace_event.cc:383
fml::tracing::TraceEvent2
void TraceEvent2(TraceArg category_group, TraceArg name, size_t flow_id_count, const uint64_t *flow_ids, TraceArg arg1_name, TraceArg arg1_val, TraceArg arg2_name, TraceArg arg2_val)
Definition trace_event.cc:420
fml::tracing::TraceEventAsyncEnd1
void TraceEventAsyncEnd1(TraceArg category_group, TraceArg name, TraceIDArg id, TraceArg arg1_name, TraceArg arg1_val)
Definition trace_event.cc:454
fml::tracing::TraceIDArg
int64_t TraceIDArg
Definition trace_event.h:213
fml::tracing::TraceNonce
size_t TraceNonce()
Definition trace_event.cc:385
fml::tracing::TraceEventEnd
void TraceEventEnd(TraceArg name)
Definition trace_event.cc:429
fml::tracing::TraceEventInstant2
void TraceEventInstant2(TraceArg category_group, TraceArg name, size_t flow_id_count, const uint64_t *flow_ids, TraceArg arg1_name, TraceArg arg1_val, TraceArg arg2_name, TraceArg arg2_val)
Definition trace_event.cc:472
fml::tracing::TraceEvent
void TraceEvent(TraceArg category, TraceArg name, size_t flow_id_count, const uint64_t *flow_ids, Args... args)
Definition trace_event.h:325
fml::tracing::TraceGetTimelineMicros
int64_t TraceGetTimelineMicros()
Definition trace_event.cc:379
fml::tracing::TraceCounter
void TraceCounter(TraceArg category, TraceArg name, TraceIDArg identifier, Args... args)
Definition trace_event.h:304
fml::tracing::SplitArguments
std::pair< std::vector< const char * >, std::vector< std::string > > SplitArguments()
Definition trace_event.h:288
fml::tracing::TraceEvent1
void TraceEvent1(TraceArg category_group, TraceArg name, size_t flow_id_count, const uint64_t *flow_ids, TraceArg arg1_name, TraceArg arg1_val)
Definition trace_event.cc:413
fml::tracing::TraceCounterNopHACK
void TraceCounterNopHACK(TraceArg category, TraceArg name, TraceIDArg identifier, Args... args)
Definition trace_event.h:319
fml::tracing::TraceEventAsyncComplete
void TraceEventAsyncComplete(TraceArg category_group, TraceArg name, TimePoint begin, TimePoint end)
Definition trace_event.cc:431
fml::tracing::TraceEventFlowStep0
void TraceEventFlowStep0(TraceArg category_group, TraceArg name, TraceIDArg id)
Definition trace_event.cc:485
end
const size_t end
Definition tessellator_libtess.cc:63

◆ __FML__TOKEN_CAT__

#define __FML__TOKEN_CAT__ (   x,
  y 
)    x##y

Definition at line 75 of file trace_event.h.

◆ __FML__TOKEN_CAT__2

#define __FML__TOKEN_CAT__2 (   x,
  y 
)    __FML__TOKEN_CAT__(x, y)

Definition at line 76 of file trace_event.h.

◆ FLUTTER_TIMELINE_ENABLED

#define FLUTTER_TIMELINE_ENABLED   1

Definition at line 69 of file trace_event.h.

◆ FML_TRACE_COUNTER

#define FML_TRACE_COUNTER (   category_group,
  name,
  counter_id,
  arg1,
  ... 
)
Value:
::fml::tracing::TraceCounter((category_group), (name), (counter_id), (arg1), \
__VA_ARGS__);

Definition at line 85 of file trace_event.h.

◆ FML_TRACE_EVENT

#define FML_TRACE_EVENT (   category_group,
  name,
  ... 
)
Value:
FML_TRACE_EVENT_WITH_FLOW_IDS((category_group), (name), \
/*flow_id_count=*/(0), /*flow_ids=*/(nullptr), \
__VA_ARGS__)
FML_TRACE_EVENT_WITH_FLOW_IDS
#define FML_TRACE_EVENT_WITH_FLOW_IDS(category_group, name, flow_id_count, flow_ids,...)
Definition trace_event.h:102

Definition at line 121 of file trace_event.h.

◆ FML_TRACE_EVENT_WITH_FLOW_IDS

#define FML_TRACE_EVENT_WITH_FLOW_IDS (   category_group,
  name,
  flow_id_count,
  flow_ids,
  ... 
)
Value:
::fml::tracing::TraceEvent((category_group), (name), (flow_id_count), \
(flow_ids), __VA_ARGS__); \
__FML__AUTO_TRACE_END(name)

Definition at line 102 of file trace_event.h.

◆ TRACE_EVENT0

#define TRACE_EVENT0 (   category_group,
  name 
)
Value:
TRACE_EVENT0_WITH_FLOW_IDS(category_group, name, /*flow_id_count=*/0, \
/*flow_ids=*/nullptr)
TRACE_EVENT0_WITH_FLOW_IDS
#define TRACE_EVENT0_WITH_FLOW_IDS(category_group, name, flow_id_count, flow_ids)
Definition trace_event.h:126

Definition at line 131 of file trace_event.h.

◆ TRACE_EVENT0_WITH_FLOW_IDS

#define TRACE_EVENT0_WITH_FLOW_IDS (   category_group,
  name,
  flow_id_count,
  flow_ids 
)
Value:
::fml::tracing::TraceEvent0(category_group, name, flow_id_count, flow_ids); \
__FML__AUTO_TRACE_END(name)

Definition at line 126 of file trace_event.h.

◆ TRACE_EVENT1

#define TRACE_EVENT1 (   category_group,
  name,
  arg1_name,
  arg1_val 
)
Value:
TRACE_EVENT1_WITH_FLOW_IDS(category_group, name, /*flow_id_count=*/0, \
/*flow_ids=*/nullptr, arg1_name, arg1_val)
TRACE_EVENT1_WITH_FLOW_IDS
#define TRACE_EVENT1_WITH_FLOW_IDS(category_group, name, flow_id_count, flow_ids, arg1_name, arg1_val)
Definition trace_event.h:135

Definition at line 141 of file trace_event.h.

◆ TRACE_EVENT1_WITH_FLOW_IDS

#define TRACE_EVENT1_WITH_FLOW_IDS (   category_group,
  name,
  flow_id_count,
  flow_ids,
  arg1_name,
  arg1_val 
)
Value:
::fml::tracing::TraceEvent1(category_group, name, flow_id_count, flow_ids, \
arg1_name, arg1_val); \
__FML__AUTO_TRACE_END(name)

Definition at line 135 of file trace_event.h.

◆ TRACE_EVENT2

#define TRACE_EVENT2 (   category_group,
  name,
  arg1_name,
  arg1_val,
  arg2_name,
  arg2_val 
)
Value:
::fml::tracing::TraceEvent2(category_group, name, /*flow_id_count=*/0, \
/*flow_ids=*/nullptr, arg1_name, arg1_val, \
arg2_name, arg2_val); \
__FML__AUTO_TRACE_END(name)

Definition at line 145 of file trace_event.h.

◆ TRACE_EVENT2_INT

#define TRACE_EVENT2_INT (   category_group,
  name,
  arg1_name,
  arg1_val,
  arg2_name,
  arg2_val 
)
Value:
const auto __arg1_val_str = std::to_string(arg1_val); \
const auto __arg2_val_str = std::to_string(arg2_val); \
TRACE_EVENT2(category_group, name, arg1_name, __arg1_val_str.c_str(), \
arg2_name, __arg2_val_str.c_str());

Definition at line 202 of file trace_event.h.

◆ TRACE_EVENT_ASYNC_BEGIN0

#define TRACE_EVENT_ASYNC_BEGIN0 (   category_group,
  name,
  id 
)
Value:
TRACE_EVENT_ASYNC_BEGIN0_WITH_FLOW_IDS( \
category_group, name, id, /*flow_id_count=*/0, /*flow_ids=*/nullptr)
TRACE_EVENT_ASYNC_BEGIN0_WITH_FLOW_IDS
#define TRACE_EVENT_ASYNC_BEGIN0_WITH_FLOW_IDS(category_group, name, id, flow_id_count, flow_ids)
Definition trace_event.h:152

Definition at line 157 of file trace_event.h.

◆ TRACE_EVENT_ASYNC_BEGIN0_WITH_FLOW_IDS

#define TRACE_EVENT_ASYNC_BEGIN0_WITH_FLOW_IDS (   category_group,
  name,
  id,
  flow_id_count,
  flow_ids 
)
Value:
::fml::tracing::TraceEventAsyncBegin0(category_group, name, id, \
flow_id_count, flow_ids);

Definition at line 152 of file trace_event.h.

◆ TRACE_EVENT_ASYNC_BEGIN1

#define TRACE_EVENT_ASYNC_BEGIN1 (   category_group,
  name,
  id,
  arg1_name,
  arg1_val 
)
Value:
::fml::tracing::TraceEventAsyncBegin1( \
category_group, name, id, /*flow_id_count=*/0, /*flow_ids=*/nullptr, \
arg1_name, arg1_val);

Definition at line 164 of file trace_event.h.

◆ TRACE_EVENT_ASYNC_END0

#define TRACE_EVENT_ASYNC_END0 (   category_group,
  name,
  id 
)     ::fml::tracing::TraceEventAsyncEnd0(category_group, name, id);

Definition at line 161 of file trace_event.h.

◆ TRACE_EVENT_ASYNC_END1

#define TRACE_EVENT_ASYNC_END1 (   category_group,
  name,
  id,
  arg1_name,
  arg1_val 
)
Value:
::fml::tracing::TraceEventAsyncEnd1( \
category_group, name, id, /*flow_id_count=*/0, /*flow_ids=*/nullptr, \
arg1_name, arg1_val);

Definition at line 170 of file trace_event.h.

◆ TRACE_EVENT_INSTANT0

#define TRACE_EVENT_INSTANT0 (   category_group,
  name 
)
Value:
::fml::tracing::TraceEventInstant0( \
category_group, name, /*flow_id_count=*/0, /*flow_ids=*/nullptr);

Definition at line 175 of file trace_event.h.

◆ TRACE_EVENT_INSTANT1

#define TRACE_EVENT_INSTANT1 (   category_group,
  name,
  arg1_name,
  arg1_val 
)
Value:
::fml::tracing::TraceEventInstant1( \
category_group, name, /*flow_id_count=*/0, /*flow_ids=*/nullptr, \
arg1_name, arg1_val);

Definition at line 179 of file trace_event.h.

◆ TRACE_EVENT_INSTANT2

#define TRACE_EVENT_INSTANT2 (   category_group,
  name,
  arg1_name,
  arg1_val,
  arg2_name,
  arg2_val 
)
Value:
::fml::tracing::TraceEventInstant2( \
category_group, name, /*flow_id_count=*/0, /*flow_ids=*/nullptr, \
arg1_name, arg1_val, arg2_name, arg2_val);

Definition at line 184 of file trace_event.h.

◆ TRACE_FLOW_BEGIN

#define TRACE_FLOW_BEGIN (   category,
  name,
  id 
)     ::fml::tracing::TraceEventFlowBegin0(category, name, id);

Definition at line 190 of file trace_event.h.

◆ TRACE_FLOW_END

#define TRACE_FLOW_END (   category,
  name,
  id 
)     ::fml::tracing::TraceEventFlowEnd0(category, name, id);

Definition at line 196 of file trace_event.h.

◆ TRACE_FLOW_STEP

#define TRACE_FLOW_STEP (   category,
  name,
  id 
)     ::fml::tracing::TraceEventFlowStep0(category, name, id);

Definition at line 193 of file trace_event.h.