[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"
 
 namespace dart {
 
 DEFINE_FLAG(bool, complete_timeline, false, "Record the complete timeline");
 DEFINE_FLAG(bool, startup_timeline, false, "Record the startup timeline");
-DEFINE_FLAG(bool, systrace_timeline, false, "Record the timeline to systrace");
+DEFINE_FLAG(
+    bool,
+    systrace_timeline,
+    false,
+    "Record the timeline to the platform's tracing service if there is one");
 DEFINE_FLAG(bool, trace_timeline, false, "Trace timeline backend");
 DEFINE_FLAG(bool,
             trace_timeline_analysis,
             false,
             "Trace timeline analysis backend");
 DEFINE_FLAG(bool,
             timing,
             false,
             "Dump isolate timing information from timeline.");
 DEFINE_FLAG(charp,
@@ skipping 64 matching lines @@
   const bool use_startup_recorder = FLAG_startup_timeline;
   const bool use_systrace_recorder = FLAG_systrace_timeline;
 
   const char* flag = FLAG_timeline_recorder;
 
   if (use_systrace_recorder || (flag != NULL)) {
     if (use_systrace_recorder || (strcmp("systrace", flag) == 0)) {
       if (FLAG_trace_timeline) {
         THR_Print("Using the Systrace timeline recorder.\n");
       }
+#if defined(HOST_OS_FUCHSIA)
+      return new TimelineEventFuchsiaRecorder();
+#else
       return new TimelineEventSystraceRecorder();
+#endif
     }
   }
 
   if (use_endless_recorder || (flag != NULL)) {
     if (use_endless_recorder || (strcmp("endless", flag) == 0)) {
       if (FLAG_trace_timeline) {
         THR_Print("Using the endless timeline recorder.\n");
       }
       return new TimelineEventEndlessRecorder();
     }
@@ skipping 388 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
+      // 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 468 matching lines @@
       do {
         __result = write(systrace_fd_, buffer, event_length);
       } while ((__result == -1L) && (errno == EINTR));
     }
   }
 #endif
   ThreadBlockCompleteEvent(event);
 }
 
 
+#if defined(HOST_OS_FUCHSIA)
+TimelineEventFuchsiaRecorder::TimelineEventFuchsiaRecorder(intptr_t capacity)
+    : TimelineEventFixedBufferRecorder(capacity) {}
+
+
+TimelineEventBlock* TimelineEventFuchsiaRecorder::GetNewBlockLocked() {
+  // TODO(johnmccutchan): This function should only hand out blocks
+  // which have been marked as finished.
+  if (block_cursor_ == num_blocks_) {
+    block_cursor_ = 0;
+  }
+  TimelineEventBlock* block = blocks_[block_cursor_++];
+  block->Reset();
+  block->Open();
+  return block;
+}
+
+
+void TimelineEventFuchsiaRecorder::CompleteEvent(TimelineEvent* event) {
+  if (event == NULL) {
+    return;
+  }
+  event->EmitFuchsiaEvent();
+  ThreadBlockCompleteEvent(event);
+}
+#endif  // defined(HOST_OS_FUCHSIA)
+
+
 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;
   }
   TimelineEventBlock* block = blocks_[block_cursor_++];
   block->Reset();
   block->Open();
   return block;
@@ skipping 325 matching lines @@
 TimelineEventBlock* TimelineEventBlockIterator::Next() {
   ASSERT(current_ != NULL);
   TimelineEventBlock* r = current_;
   current_ = current_->next();
   return r;
 }
 
 }  // namespace dart
 
 #endif  // !PRODUCT