[Fuchsia] Routes timeline events to Fuchsia's tracing app

runtime/vm/timeline.cc

 // Copyright (c) 2015, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
+#include "platform/globals.h"
 #ifndef PRODUCT
 
 #include <errno.h>
 #include <fcntl.h>
 #include <cstdlib>
 
+#if defined(HOST_OS_FUCHSIA)
+#include "apps/tracing/lib/trace/event.h"
+#endif
+
 #include "vm/atomic.h"
 #include "vm/isolate.h"
 #include "vm/json_stream.h"
 #include "vm/lockers.h"
 #include "vm/log.h"
 #include "vm/object.h"
 #include "vm/service_event.h"
 #include "vm/thread.h"
 #include "vm/timeline.h"
 
@@ skipping 386 matching lines @@
   Init(kInstant, label);
   set_timestamp0(micros);
 }
 
 
 void TimelineEvent::Duration(const char* label,
                              int64_t start_micros,
                              int64_t end_micros,
                              int64_t thread_start_micros,
                              int64_t thread_end_micros) {
   Init(kDuration, label);

[rmacnak, 2017/07/10 23:39:01]

Maybe emit a Fuchsia tracing duration start here instead of the
DurationEventScope.

[zra, 2017/07/11 17:38:04]

event->Duration() and event->Complete() are both called from
TimelineDurationScope::~TimelineDurationScope(), which would give the wrong
result. They are also both called from Dart_TimelineEvent().

   set_timestamp0(start_micros);
   set_timestamp1(end_micros);
   set_thread_timestamp0(thread_start_micros);
   set_thread_timestamp1(thread_end_micros);
 }
 
 
 void TimelineEvent::Begin(const char* label,
                           int64_t micros,
                           int64_t thread_micros) {
@@ skipping 81 matching lines @@
 }
 
 
 void TimelineEvent::StealArguments(intptr_t arguments_length,
                                    TimelineEventArgument* arguments) {
   arguments_length_ = arguments_length;
   arguments_ = arguments;
 }
 
 
+#if defined(HOST_OS_FUCHSIA)
+
+// TODO(zra): The functions below emit Dart's timeline events all as category
+// "dart". Instead, we could have finer-grained categories that make use of
+// the name of the timeline stream, e.g. "VM", "GC", etc.
+
+#define FUCHSIA_EVENT_ARGS_LIST(V)                                             \
+  V(Begin, TRACE_DURATION_BEGIN)                                               \
+  V(End, TRACE_DURATION_END)
+
+#define EMIT_FUCHSIA_EVENT(__name, __macro)                                    \
+static void EmitFuchsia##__name##Event(const char* label,                      \
+                                       TimelineEventArgument* arguments,       \
+                                       intptr_t arguments_length) {            \
+  if (arguments_length == 0) {                                                 \
+    __macro("dart", label);                                                    \
+  } else if (arguments_length == 1) {                                          \
+    __macro("dart", label, arguments[0].name,                                  \
+                           const_cast<const char*>(arguments[0].value));       \
+  } else {                                                                     \
+    __macro("dart", label, arguments[0].name,                                  \
+                           const_cast<const char*>(arguments[0].value),        \
+                           arguments[1].name,                                  \
+                           const_cast<const char*>(arguments[1].value));       \
+  }                                                                            \
+}
+
+FUCHSIA_EVENT_ARGS_LIST(EMIT_FUCHSIA_EVENT)
+#undef EMIT_FUCHSIA_EVENT
+
+#define FUCHSIA_EVENT_ID_ARGS_LIST(V)                                          \
+  V(Instant, TRACE_INSTANT, ::tracing::EventScope)                             \
+  V(AsyncBegin, TRACE_ASYNC_BEGIN, int64_t)                                    \
+  V(AsyncEnd, TRACE_ASYNC_END, int64_t)                                        \
+  V(AsyncInstant, TRACE_ASYNC_INSTANT, int64_t)
+
+#define EMIT_FUCHSIA_EVENT(__name, __macro, __id_typ)                          \
+static void EmitFuchsia##__name##Event(const char* label,                      \
+                                       __id_typ id,                            \
+                                       TimelineEventArgument* arguments,       \
+                                       intptr_t arguments_length) {            \
+  if (arguments_length == 0) {                                                 \
+    __macro("dart", label, id);                                                \
+  } else if (arguments_length == 1) {                                          \
+    __macro("dart", label, id, arguments[0].name,                              \
+                               const_cast<const char*>(arguments[0].value));   \
+  } else {                                                                     \
+    __macro("dart", label, id, arguments[0].name,                              \
+                               const_cast<const char*>(arguments[0].value),    \
+                               arguments[1].name,                              \
+                               const_cast<const char*>(arguments[1].value));   \
+  }                                                                            \
+}
+
+FUCHSIA_EVENT_ID_ARGS_LIST(EMIT_FUCHSIA_EVENT)
+#undef EMIT_FUCHSIA_EVENT
+
+
+void TimelineEvent::EmitFuchsiaEvent() {
+  switch (event_type()) {
+    case kBegin:
+      EmitFuchsiaBeginEvent(label_, arguments_, arguments_length_);
+      break;
+    case kEnd:
+      EmitFuchsiaEndEvent(label_, arguments_, arguments_length_);
+      break;
+    case kInstant:
+      EmitFuchsiaInstantEvent(
+          label_, TRACE_SCOPE_THREAD, arguments_, arguments_length_);
+      break;
+    case kAsyncBegin:
+      EmitFuchsiaAsyncBeginEvent(
+          label_, AsyncId(), arguments_, arguments_length_);
+      break;
+    case kAsyncEnd:
+      EmitFuchsiaAsyncEndEvent(
+          label_, AsyncId(), arguments_, arguments_length_);
+      break;
+    case kAsyncInstant:
+      EmitFuchsiaAsyncInstantEvent(
+          label_, AsyncId(), arguments_, arguments_length_);
+      break;
+    default:
+      // TODO(zra): Figure out what to do with kDuration, kCounter, and

[rmacnak, 2017/07/10 23:39:02]

Duration is the most common event type.

[zra, 2017/07/11 17:38:04]

Except when coming through Dart_TimelineEvent(), kDuration only comes through
TimelineDurationScopes. Flutter engine already routes around
Dart_TimelineEvent() in Fuchsia, and dart:developer Timeline doesn't appear to
generate Duration events, so I think we probably won't even see kDuration here.

+      // kMetadata.
+      break;
+  }
+}
+#endif
+
+
 intptr_t TimelineEvent::PrintSystrace(char* buffer, intptr_t buffer_size) {
   ASSERT(buffer != NULL);
   ASSERT(buffer_size > 0);
   buffer[0] = '\0';
   intptr_t length = 0;
   int64_t pid = OS::ProcessId();
   switch (event_type()) {
     case kBegin: {
       length = OS::SNPrint(buffer, buffer_size, "B|%" Pd64 "|%s", pid, label());
     } break;
@@ skipping 377 matching lines @@
   arguments_ = NULL;
 }
 
 
 TimelineDurationScope::TimelineDurationScope(TimelineStream* stream,
                                              const char* label)
     : TimelineEventScope(stream, label) {
   if (!FLAG_support_timeline || !enabled()) {
     return;
   }
+#if defined(HOST_OS_FUCHSIA)
+  TRACE_DURATION_BEGIN("dart", label);
+#else
   timestamp_ = OS::GetCurrentMonotonicMicros();
   thread_timestamp_ = OS::GetCurrentThreadCPUMicros();
+#endif
 }
 
 
 TimelineDurationScope::TimelineDurationScope(Thread* thread,
                                              TimelineStream* stream,
                                              const char* label)
     : TimelineEventScope(thread, stream, label) {
   if (!FLAG_support_timeline || !enabled()) {
     return;
   }
+#if defined(HOST_OS_FUCHSIA)
+  TRACE_DURATION_BEGIN("dart", label);
+#else
   timestamp_ = OS::GetCurrentMonotonicMicros();
   thread_timestamp_ = OS::GetCurrentThreadCPUMicros();
+#endif
 }
 
 
 TimelineDurationScope::~TimelineDurationScope() {
   if (!FLAG_support_timeline) {
     return;
   }
   if (!ShouldEmitEvent()) {
     return;
   }
+#if defined(HOST_OS_FUCHSIA)
+  EmitFuchsiaEndEvent(label(), arguments(), arguments_length());
+#else
   TimelineEvent* event = stream()->StartEvent();
   if (event == NULL) {
     // Stream is now disabled.
     return;
   }
   ASSERT(event != NULL);
   // Emit a duration event.
   event->Duration(label(), timestamp_, OS::GetCurrentMonotonicMicros(),
                   thread_timestamp_, OS::GetCurrentThreadCPUMicros());
   StealArguments(event);
   event->Complete();
+#endif
 }
 
 
 TimelineBeginEndScope::TimelineBeginEndScope(TimelineStream* stream,
                                              const char* label)
     : TimelineEventScope(stream, label) {
   if (!FLAG_support_timeline) {
     return;
   }
   EmitBegin();
@@ skipping 414 matching lines @@
 
 TimelineEventSystraceRecorder::TimelineEventSystraceRecorder(intptr_t capacity)
     : TimelineEventFixedBufferRecorder(capacity), systrace_fd_(-1) {
 #if defined(HOST_OS_ANDROID) || defined(HOST_OS_LINUX)
   const char* kSystracePath = "/sys/kernel/debug/tracing/trace_marker";
   systrace_fd_ = open(kSystracePath, O_WRONLY);
   if ((systrace_fd_ < 0) && FLAG_trace_timeline) {
     OS::PrintErr("TimelineEventSystraceRecorder: Could not open `%s`\n",
                  kSystracePath);
   }
+#elif defined(HOST_OS_FUCHSIA)
+  // Nothing to do.
 #else
   OS::PrintErr(
       "Warning: The systrace timeline recorder is equivalent to the"
       "ring recorder on this platform.");
 #endif
 }
 
 
 TimelineEventSystraceRecorder::~TimelineEventSystraceRecorder() {
 #if defined(HOST_OS_ANDROID) || defined(HOST_OS_LINUX)
@@ skipping 29 matching lines @@
     const intptr_t event_length =
         event->PrintSystrace(&buffer[0], kBufferLength);
     if (event_length > 0) {
       ssize_t __result;
       // Repeatedly attempt the write while we are being interrupted.
       do {
         __result = write(systrace_fd_, buffer, event_length);
       } while ((__result == -1L) && (errno == EINTR));
     }
   }
+#elif defined(HOST_OS_FUCHSIA)
+  event->EmitFuchsiaEvent();
 #endif
   ThreadBlockCompleteEvent(event);
 }
 
 
 TimelineEventBlock* TimelineEventRingRecorder::GetNewBlockLocked() {
   // TODO(johnmccutchan): This function should only hand out blocks
   // which have been marked as finished.
   if (block_cursor_ == num_blocks_) {
     block_cursor_ = 0;
@@ skipping 330 matching lines @@
 TimelineEventBlock* TimelineEventBlockIterator::Next() {
   ASSERT(current_ != NULL);
   TimelineEventBlock* r = current_;
   current_ = current_->next();
   return r;
 }
 
 }  // namespace dart
 
 #endif  // !PRODUCT