Implement tracing interface for v8

This is based on the Skia Implementation.

More on the project can be found here:
https://docs.google.com/a/chromium.org/document/d/1_4LAnInOB8tM_DLjptWiszRwa4qwiSsDzMkO4tU-Qes/edit#heading=h.p97rw6yt8o2j

The V8 Tracing platform will replace the isolate->event_logger().
But since the current embedders (namely chromium) currently use the isolate->event_logger, I made the default implementation (event-tracer) call into isolate->event_logger if an event_logger was set.
Once the embedders properly implement the interface (for example in chromium it would look like this: https://codereview.chromium.org/707273005/), the default implementation will be doing nothing.

Once the embedders side is fixed, we will change how V8 uses the tracing framework beyond the call from Logger:CallEventLogger. (which would also include a d8 implementation)

BUG=v8:4560
LOG=N

Review URL: https://codereview.chromium.org/988893003

Cr-Commit-Position: refs/heads/master@{#32959}

BUILD.gn

@@ -595,6 +595,8 @@ source_set("v8_base") {
   visibility = [ ":*" ]  # Only targets in this file can depend on this.
 
   sources = [
+    # TODO(fmeawad): This needs to be updated to support standalone V8 builds.
+    "../base/trace_event/common/trace_event_common.h",
     "include/v8-debug.h",
     "include/v8-experimental.h",
     "include/v8-platform.h",
@@ -1247,6 +1249,8 @@ source_set("v8_base") {
     "src/string-stream.h",
     "src/strtod.cc",
     "src/strtod.h",
+    "src/tracing/trace-event.cc",
+    "src/tracing/trace-event.h",
     "src/transitions-inl.h",
     "src/transitions.cc",
     "src/transitions.h",

DEPS

@@ -13,7 +13,6 @@ deps = {
     Var("git_url") + "/chromium/deps/icu.git" + "@" + "8d342a405be5ae8aacb1e16f0bc31c3a4fbf26a2",
   "v8/buildtools":
     Var("git_url") + "/chromium/buildtools.git" + "@" + "68e3c238a5ab347436762cb929316aa55ca72563",
-  # TODO(fmeawad): this dependency is not currently used. Added to allow for developement of the V8 Tracing system.
   "v8/base/trace_event/common":
     Var("git_url") + "/chromium/src/base/trace_event/common.git" + "@" + "d83d44b13d07c2fd0a40101a7deef9b93b841732",
   "v8/tools/swarming_client":

build/standalone.gypi

@@ -686,6 +686,7 @@
           '-pedantic',
           # Don't warn about the "struct foo f = {0};" initialization pattern.
           '-Wno-missing-field-initializers',
+          '-Wno-gnu-zero-variadic-macro-arguments',
         ],
         'cflags_cc': [
           '-Wnon-virtual-dtor',
@@ -695,6 +696,16 @@
         ],
         'ldflags': [ '-pthread', ],
         'conditions': [
+          # Don't warn about TRACE_EVENT_* macros with zero arguments passed to
+          # ##__VA_ARGS__. C99 strict mode prohibits having zero variadic macro
+          # arguments in gcc.
+          [ 'clang==0', {
+            'cflags!' : [
+              '-pedantic' ,
+              # Don't warn about unrecognized command line option.
+              '-Wno-gnu-zero-variadic-macro-arguments',
+            ],
+          }],
           [ 'clang==1 and (v8_target_arch=="x64" or v8_target_arch=="arm64" \
             or v8_target_arch=="mips64el")', {
             'cflags': [ '-Wshorten-64-to-32' ],
@@ -726,6 +737,7 @@
           '-Wno-unused-parameter',
           # Don't warn about the "struct foo f = {0};" initialization pattern.
           '-Wno-missing-field-initializers',
+          '-Wno-gnu-zero-variadic-macro-arguments',
         ],
         'cflags_cc': [
           '-Wnon-virtual-dtor',
@@ -950,6 +962,7 @@
             '-Wno-unused-parameter',
             # Don't warn about the "struct foo f = {0};" initialization pattern.
             '-Wno-missing-field-initializers',
+            '-Wno-gnu-zero-variadic-macro-arguments',
           ],
         },
         'conditions': [

include/v8-platform.h

@@ -5,6 +5,8 @@
 #ifndef V8_V8_PLATFORM_H_
 #define V8_V8_PLATFORM_H_
 
+#include <stdint.h>
+
 namespace v8 {
 
 class Isolate;
@@ -107,6 +109,51 @@ class Platform {
    * the epoch.
    **/
   virtual double MonotonicallyIncreasingTime() = 0;
+
+  /**
+   * Called by TRACE_EVENT* macros, don't call this directly.
+   * The name parameter is a category group for example:
+   * TRACE_EVENT0("v8,parse", "V8.Parse")
+   * The pointer returned points to a value with zero or more of the bits
+   * defined in CategoryGroupEnabledFlags.
+   **/
+  virtual const uint8_t* GetCategoryGroupEnabled(const char* name) {
+    static uint8_t no = 0;
+    return &no;
+  }
+
+  /**
+   * Gets the category group name of the given category_enabled_flag pointer.
+   * Usually used while serliazing TRACE_EVENTs.
+   **/
+  virtual const char* GetCategoryGroupName(
+      const uint8_t* category_enabled_flag) {
+    static const char dummy[] = "dummy";
+    return dummy;
+  }
+
+  /**
+   * Adds a trace event to the platform tracing system. This function call is
+   * usually the result of a TRACE_* macro from trace_event_common.h when
+   * tracing and the category of the particular trace are enabled. It is not
+   * advisable to call this function on its own; it is really only meant to be
+   * used by the trace macros. The returned handle can be used by
+   * UpdateTraceEventDuration to update the duration of COMPLETE events.
+   */
+  virtual uint64_t AddTraceEvent(
+      char phase, const uint8_t* category_enabled_flag, const char* name,
+      uint64_t id, uint64_t bind_id, int32_t num_args, const char** arg_names,
+      const uint8_t* arg_types, const uint64_t* arg_values,
+      unsigned int flags) {
+    return 0;
+  }
+
+  /**
+   * Sets the duration field of a COMPLETE trace event. It must be called with
+   * the handle returned from AddTraceEvent().
+   **/
+  virtual void UpdateTraceEventDuration(const uint8_t* category_enabled_flag,
+                                        const char* name, uint64_t handle) {}
 };
 
 }  // namespace v8

src/DEPS

 include_rules = [
+  "+base/trace_event/common/trace_event_common.h",
   "+src",
   "-src/compiler",
   "+src/compiler/pipeline.h",

src/d8.cc

@@ -135,6 +135,28 @@ class PredictablePlatform : public Platform {
     return synthetic_time_in_sec_ += 0.00001;
   }
 
+  uint64_t AddTraceEvent(char phase, const uint8_t* categoryEnabledFlag,
+                         const char* name, uint64_t id, uint64_t bind_id,
+                         int numArgs, const char** argNames,
+                         const uint8_t* argTypes, const uint64_t* argValues,
+                         unsigned int flags) override {
+    return 0;
+  }
+
+  void UpdateTraceEventDuration(const uint8_t* categoryEnabledFlag,
+                                const char* name, uint64_t handle) override {}
+
+  const uint8_t* GetCategoryGroupEnabled(const char* name) override {
+    static uint8_t no = 0;
+    return &no;
+  }
+
+  const char* GetCategoryGroupName(
+      const uint8_t* categoryEnabledFlag) override {
+    static const char* dummy = "dummy";
+    return dummy;
+  }
+
  private:
   double synthetic_time_in_sec_ = 0.0;
 

src/libplatform/default-platform.cc

@@ -168,5 +168,30 @@ double DefaultPlatform::MonotonicallyIncreasingTime() {
   return base::TimeTicks::HighResolutionNow().ToInternalValue() /
          static_cast<double>(base::Time::kMicrosecondsPerSecond);
 }
+
+
+uint64_t DefaultPlatform::AddTraceEvent(
+    char phase, const uint8_t* category_enabled_flag, const char* name,
+    uint64_t id, uint64_t bind_id, int num_args, const char** arg_names,
+    const uint8_t* arg_types, const uint64_t* arg_values, unsigned int flags) {
+  return 0;
+}
+
+
+void DefaultPlatform::UpdateTraceEventDuration(
+    const uint8_t* category_enabled_flag, const char* name, uint64_t handle) {}
+
+
+const uint8_t* DefaultPlatform::GetCategoryGroupEnabled(const char* name) {
+  static uint8_t no = 0;
+  return &no;
+}
+
+
+const char* DefaultPlatform::GetCategoryGroupName(
+    const uint8_t* category_enabled_flag) {
+  static const char dummy[] = "dummy";
+  return dummy;
+}
 }  // namespace platform
 }  // namespace v8

src/libplatform/default-platform.h

@@ -42,6 +42,17 @@ class DefaultPlatform : public Platform {
   void CallIdleOnForegroundThread(Isolate* isolate, IdleTask* task) override;
   bool IdleTasksEnabled(Isolate* isolate) override;
   double MonotonicallyIncreasingTime() override;
+  const uint8_t* GetCategoryGroupEnabled(const char* name) override;
+  const char* GetCategoryGroupName(
+      const uint8_t* category_enabled_flag) override;
+  uint64_t AddTraceEvent(char phase, const uint8_t* category_enabled_flag,
+                         const char* name, uint64_t id, uint64_t bind_id,
+                         int32_t num_args, const char** arg_names,
+                         const uint8_t* arg_types, const uint64_t* arg_values,
+                         unsigned int flags) override;
+  void UpdateTraceEventDuration(const uint8_t* category_enabled_flag,
+                                const char* name, uint64_t handle) override;
+
 
  private:
   static const int kMaxThreadPoolSize;

src/log-inl.h

@@ -8,6 +8,7 @@
 #include "src/log.h"
 #include "src/isolate.h"
 #include "src/objects-inl.h"
+#include "src/tracing/trace-event.h"
 
 namespace v8 {
 namespace internal {
@@ -37,6 +38,19 @@ void Logger::CallEventLogger(Isolate* isolate, const char* name, StartEnd se,
       isolate->event_logger()(name, se);
     }
   }
+  if (expose_to_api) {
+    if (se == START) {
+      TRACE_EVENT_BEGIN0("v8", name);
+    } else {
+      TRACE_EVENT_END0("v8", name);
+    }
+  } else {
+    if (se == START) {
+      TRACE_EVENT_BEGIN0(TRACE_DISABLED_BY_DEFAULT("v8"), name);
+    } else {
+      TRACE_EVENT_END0(TRACE_DISABLED_BY_DEFAULT("v8"), name);
+    }
+  }
 }
 }  // namespace internal
 }  // namespace v8

src/tracing/trace-event.cc

+// Copyright 2015 the V8 project authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "src/tracing/trace-event.h"
+
+#include "src/v8.h"
+
+namespace v8 {
+namespace internal {
+namespace tracing {
+
+v8::Platform* TraceEventHelper::GetCurrentPlatform() {
+  return v8::internal::V8::GetCurrentPlatform();
+}
+
+}  // namespace tracing
+}  // namespace internal
+}  // namespace v8

src/tracing/trace-event.h

+// Copyright 2015 the V8 project authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef SRC_TRACING_TRACE_EVENT_H_
+#define SRC_TRACING_TRACE_EVENT_H_
+
+#include <stddef.h>
+
+#include "base/trace_event/common/trace_event_common.h"
+#include "include/v8-platform.h"
+#include "src/base/atomicops.h"
+
+// This header file defines implementation details of how the trace macros in
+// trace_event_common.h collect and store trace events. Anything not
+// implementation-specific should go in trace_macros_common.h instead of here.
+
+
+// The pointer returned from GetCategoryGroupEnabled() points to a
+// value with zero or more of the following bits. Used in this class only.
+// The TRACE_EVENT macros should only use the value as a bool.
+// These values must be in sync with macro values in trace_log.h in
+// chromium.
+enum CategoryGroupEnabledFlags {
+  // Category group enabled for the recording mode.
+  kEnabledForRecording_CategoryGroupEnabledFlags = 1 << 0,
+  // Category group enabled for the monitoring mode.
+  kEnabledForMonitoring_CategoryGroupEnabledFlags = 1 << 1,
+  // Category group enabled by SetEventCallbackEnabled().
+  kEnabledForEventCallback_CategoryGroupEnabledFlags = 1 << 2,
+  // Category group enabled to export events to ETW.
+  kEnabledForETWExport_CategoryGroupEnabledFlags = 1 << 3,
+};
+
+// By default, const char* asrgument values are assumed to have long-lived scope
+// and will not be copied. Use this macro to force a const char* to be copied.
+#define TRACE_STR_COPY(str) v8::internal::tracing::TraceStringWithCopy(str)
+
+// By default, uint64 ID argument values are not mangled with the Process ID in
+// TRACE_EVENT_ASYNC macros. Use this macro to force Process ID mangling.
+#define TRACE_ID_MANGLE(id) v8::internal::tracing::TraceID::ForceMangle(id)
+
+// By default, pointers are mangled with the Process ID in TRACE_EVENT_ASYNC
+// macros. Use this macro to prevent Process ID mangling.
+#define TRACE_ID_DONT_MANGLE(id) v8::internal::tracing::TraceID::DontMangle(id)
+
+// Sets the current sample state to the given category and name (both must be
+// constant strings). These states are intended for a sampling profiler.
+// Implementation note: we store category and name together because we don't
+// want the inconsistency/expense of storing two pointers.
+// |thread_bucket| is [0..2] and is used to statically isolate samples in one
+// thread from others.
+#define TRACE_EVENT_SET_SAMPLING_STATE_FOR_BUCKET(bucket_number, category, \
+                                                  name)                    \
+  v8::internal::tracing::TraceEventSamplingStateScope<bucket_number>::Set( \
+      category "\0" name)
+
+// Returns a current sampling state of the given bucket.
+#define TRACE_EVENT_GET_SAMPLING_STATE_FOR_BUCKET(bucket_number) \
+  v8::internal::tracing::TraceEventSamplingStateScope<bucket_number>::Current()
+
+// Creates a scope of a sampling state of the given bucket.
+//
+// {  // The sampling state is set within this scope.
+//    TRACE_EVENT_SAMPLING_STATE_SCOPE_FOR_BUCKET(0, "category", "name");
+//    ...;
+// }
+#define TRACE_EVENT_SCOPED_SAMPLING_STATE_FOR_BUCKET(bucket_number, category, \
+                                                     name)                    \
+  v8::internal::TraceEventSamplingStateScope<bucket_number>                   \
+      traceEventSamplingScope(category "\0" name);
+
+
+#define INTERNAL_TRACE_EVENT_CATEGORY_GROUP_ENABLED_FOR_RECORDING_MODE() \
+  *INTERNAL_TRACE_EVENT_UID(category_group_enabled) &                    \
+      (kEnabledForRecording_CategoryGroupEnabledFlags |                  \
+       kEnabledForEventCallback_CategoryGroupEnabledFlags)
+
+// The following macro has no implementation, but it needs to exist since
+// it gets called from scoped trace events. It cannot call UNIMPLEMENTED()
+// since an empty implementation is a valid one.
+#define INTERNAL_TRACE_MEMORY(category, name)
+
+////////////////////////////////////////////////////////////////////////////////
+// Implementation specific tracing API definitions.
+
+// Get a pointer to the enabled state of the given trace category. Only
+// long-lived literal strings should be given as the category group. The
+// returned pointer can be held permanently in a local static for example. If
+// the unsigned char is non-zero, tracing is enabled. If tracing is enabled,
+// TRACE_EVENT_API_ADD_TRACE_EVENT can be called. It's OK if tracing is disabled
+// between the load of the tracing state and the call to
+// TRACE_EVENT_API_ADD_TRACE_EVENT, because this flag only provides an early out
+// for best performance when tracing is disabled.
+// const uint8_t*
+//     TRACE_EVENT_API_GET_CATEGORY_GROUP_ENABLED(const char* category_group)
+#define TRACE_EVENT_API_GET_CATEGORY_GROUP_ENABLED              \
+  v8::internal::tracing::TraceEventHelper::GetCurrentPlatform() \
+      ->GetCategoryGroupEnabled
+
+// Get the number of times traces have been recorded. This is used to implement
+// the TRACE_EVENT_IS_NEW_TRACE facility.
+// unsigned int TRACE_EVENT_API_GET_NUM_TRACES_RECORDED()
+#define TRACE_EVENT_API_GET_NUM_TRACES_RECORDED                 \
+  v8::internal::tracing::TraceEventHelper::GetCurrentPlatform() \
+      ->getNumTracesRecorded
+
+// Add a trace event to the platform tracing system.
+// uint64_t TRACE_EVENT_API_ADD_TRACE_EVENT(
+//                    char phase,
+//                    const uint8_t* category_group_enabled,
+//                    const char* name,
+//                    uint64_t id,
+//                    uint64_t bind_id,
+//                    int num_args,
+//                    const char** arg_names,
+//                    const uint8_t* arg_types,
+//                    const uint64_t* arg_values,
+//                    unsigned int flags)
+#define TRACE_EVENT_API_ADD_TRACE_EVENT \
+  v8::internal::tracing::TraceEventHelper::GetCurrentPlatform()->AddTraceEvent
+
+// Set the duration field of a COMPLETE trace event.
+// void TRACE_EVENT_API_UPDATE_TRACE_EVENT_DURATION(
+//     const uint8_t* category_group_enabled,
+//     const char* name,
+//     uint64_t id)
+#define TRACE_EVENT_API_UPDATE_TRACE_EVENT_DURATION             \
+  v8::internal::tracing::TraceEventHelper::GetCurrentPlatform() \
+      ->UpdateTraceEventDuration
+
+// Defines atomic operations used internally by the tracing system.
+#define TRACE_EVENT_API_ATOMIC_WORD v8::base::AtomicWord
+#define TRACE_EVENT_API_ATOMIC_LOAD(var) v8::base::NoBarrier_Load(&(var))
+#define TRACE_EVENT_API_ATOMIC_STORE(var, value) \
+  v8::base::NoBarrier_Store(&(var), (value))
+
+// The thread buckets for the sampling profiler.
+extern TRACE_EVENT_API_ATOMIC_WORD g_trace_state[3];
+
+#define TRACE_EVENT_API_THREAD_BUCKET(thread_bucket) \
+  g_trace_state[thread_bucket]
+
+////////////////////////////////////////////////////////////////////////////////
+
+// Implementation detail: trace event macros create temporary variables
+// to keep instrumentation overhead low. These macros give each temporary
+// variable a unique name based on the line number to prevent name collisions.
+#define INTERNAL_TRACE_EVENT_UID3(a, b) trace_event_unique_##a##b
+#define INTERNAL_TRACE_EVENT_UID2(a, b) INTERNAL_TRACE_EVENT_UID3(a, b)
+#define INTERNAL_TRACE_EVENT_UID(name_prefix) \
+  INTERNAL_TRACE_EVENT_UID2(name_prefix, __LINE__)
+
+// Implementation detail: internal macro to create static category.
+// No barriers are needed, because this code is designed to operate safely
+// even when the unsigned char* points to garbage data (which may be the case
+// on processors without cache coherency).
+// TODO(fmeawad): This implementation contradicts that we can have a different
+// configuration for each isolate,
+// https://code.google.com/p/v8/issues/detail?id=4563
+#define INTERNAL_TRACE_EVENT_GET_CATEGORY_INFO_CUSTOM_VARIABLES(             \
+    category_group, atomic, category_group_enabled)                          \
+  category_group_enabled =                                                   \
+      reinterpret_cast<const uint8_t*>(TRACE_EVENT_API_ATOMIC_LOAD(atomic)); \
+  if (!category_group_enabled) {                                             \
+    category_group_enabled =                                                 \
+        TRACE_EVENT_API_GET_CATEGORY_GROUP_ENABLED(category_group);          \
+    TRACE_EVENT_API_ATOMIC_STORE(                                            \
+        atomic, reinterpret_cast<TRACE_EVENT_API_ATOMIC_WORD>(               \
+                    category_group_enabled));                                \
+  }
+
+#define INTERNAL_TRACE_EVENT_GET_CATEGORY_INFO(category_group)             \
+  static TRACE_EVENT_API_ATOMIC_WORD INTERNAL_TRACE_EVENT_UID(atomic) = 0; \
+  const uint8_t* INTERNAL_TRACE_EVENT_UID(category_group_enabled);         \
+  INTERNAL_TRACE_EVENT_GET_CATEGORY_INFO_CUSTOM_VARIABLES(                 \
+      category_group, INTERNAL_TRACE_EVENT_UID(atomic),                    \
+      INTERNAL_TRACE_EVENT_UID(category_group_enabled));
+
+// Implementation detail: internal macro to create static category and add
+// event if the category is enabled.
+#define INTERNAL_TRACE_EVENT_ADD(phase, category_group, name, flags, ...)    \
+  do {                                                                       \
+    INTERNAL_TRACE_EVENT_GET_CATEGORY_INFO(category_group);                  \
+    if (INTERNAL_TRACE_EVENT_CATEGORY_GROUP_ENABLED_FOR_RECORDING_MODE()) {  \
+      v8::internal::tracing::AddTraceEvent(                                  \
+          phase, INTERNAL_TRACE_EVENT_UID(category_group_enabled), name,     \
+          v8::internal::tracing::kNoId, v8::internal::tracing::kNoId, flags, \
+          ##__VA_ARGS__);                                                    \
+    }                                                                        \
+  } while (0)
+
+// Implementation detail: internal macro to create static category and add begin
+// event if the category is enabled. Also adds the end event when the scope
+// ends.
+#define INTERNAL_TRACE_EVENT_ADD_SCOPED(category_group, name, ...)          \
+  INTERNAL_TRACE_EVENT_GET_CATEGORY_INFO(category_group);                   \
+  v8::internal::tracing::ScopedTracer INTERNAL_TRACE_EVENT_UID(tracer);     \
+  if (INTERNAL_TRACE_EVENT_CATEGORY_GROUP_ENABLED_FOR_RECORDING_MODE()) {   \
+    uint64_t h = v8::internal::tracing::AddTraceEvent(                      \
+        TRACE_EVENT_PHASE_COMPLETE,                                         \
+        INTERNAL_TRACE_EVENT_UID(category_group_enabled), name,             \
+        v8::internal::tracing::kNoId, v8::internal::tracing::kNoId,         \
+        TRACE_EVENT_FLAG_NONE, ##__VA_ARGS__);                              \
+    INTERNAL_TRACE_EVENT_UID(tracer)                                        \
+        .Initialize(INTERNAL_TRACE_EVENT_UID(category_group_enabled), name, \
+                    h);                                                     \
+  }
+
+#define INTERNAL_TRACE_EVENT_ADD_SCOPED_WITH_FLOW(category_group, name,     \
+                                                  bind_id, flow_flags, ...) \
+  INTERNAL_TRACE_EVENT_GET_CATEGORY_INFO(category_group);                   \
+  v8::internal::tracing::ScopedTracer INTERNAL_TRACE_EVENT_UID(tracer);     \
+  if (INTERNAL_TRACE_EVENT_CATEGORY_GROUP_ENABLED_FOR_RECORDING_MODE()) {   \
+    unsigned int trace_event_flags = flow_flags;                            \
+    v8::internal::tracing::TraceID trace_event_bind_id(bind_id,             \
+                                                       &trace_event_flags); \
+    uint64_t h = v8::internal::tracing::AddTraceEvent(                      \
+        TRACE_EVENT_PHASE_COMPLETE,                                         \
+        INTERNAL_TRACE_EVENT_UID(category_group_enabled), name,             \
+        v8::internal::tracing::kNoId, trace_event_bind_id.data(),           \
+        trace_event_flags, ##__VA_ARGS__);                                  \
+    INTERNAL_TRACE_EVENT_UID(tracer)                                        \
+        .Initialize(INTERNAL_TRACE_EVENT_UID(category_group_enabled), name, \
+                    h);                                                     \
+  }
+
+// Implementation detail: internal macro to create static category and add
+// event if the category is enabled.
+#define INTERNAL_TRACE_EVENT_ADD_WITH_ID(phase, category_group, name, id,      \
+                                         flags, ...)                           \
+  do {                                                                         \
+    INTERNAL_TRACE_EVENT_GET_CATEGORY_INFO(category_group);                    \
+    if (INTERNAL_TRACE_EVENT_CATEGORY_GROUP_ENABLED_FOR_RECORDING_MODE()) {    \
+      unsigned int trace_event_flags = flags | TRACE_EVENT_FLAG_HAS_ID;        \
+      v8::internal::tracing::TraceID trace_event_trace_id(id,                  \
+                                                          &trace_event_flags); \
+      v8::internal::tracing::AddTraceEvent(                                    \
+          phase, INTERNAL_TRACE_EVENT_UID(category_group_enabled), name,       \
+          trace_event_trace_id.data(), v8::internal::tracing::kNoId,           \
+          trace_event_flags, ##__VA_ARGS__);                                   \
+    }                                                                          \
+  } while (0)
+
+// Adds a trace event with a given timestamp. Not Implemented.
+#define INTERNAL_TRACE_EVENT_ADD_WITH_TIMESTAMP(phase, category_group, name, \
+                                                timestamp, flags, ...)       \
+  UNIMPLEMENTED()
+
+// Adds a trace event with a given id and timestamp. Not Implemented.
+#define INTERNAL_TRACE_EVENT_ADD_WITH_ID_AND_TIMESTAMP(     \
+    phase, category_group, name, id, timestamp, flags, ...) \
+  UNIMPLEMENTED()
+
+// Adds a trace event with a given id, thread_id, and timestamp. Not
+// Implemented.
+#define INTERNAL_TRACE_EVENT_ADD_WITH_ID_TID_AND_TIMESTAMP(            \
+    phase, category_group, name, id, thread_id, timestamp, flags, ...) \
+  UNIMPLEMENTED()
+
+namespace v8 {
+namespace internal {
+namespace tracing {
+
+// Specify these values when the corresponding argument of AddTraceEvent is not
+// used.
+const int kZeroNumArgs = 0;
+const uint64_t kNoId = 0;
+
+class TraceEventHelper {
+ public:
+  static v8::Platform* GetCurrentPlatform();
+};
+
+// TraceID encapsulates an ID that can either be an integer or pointer. Pointers
+// are by default mangled with the Process ID so that they are unlikely to
+// collide when the same pointer is used on different processes.
+class TraceID {
+ public:
+  class DontMangle {
+   public:
+    explicit DontMangle(const void* id)
+        : data_(static_cast<uint64_t>(reinterpret_cast<uintptr_t>(id))) {}
+    explicit DontMangle(uint64_t id) : data_(id) {}
+    explicit DontMangle(unsigned int id) : data_(id) {}
+    explicit DontMangle(uint16_t id) : data_(id) {}
+    explicit DontMangle(unsigned char id) : data_(id) {}
+    explicit DontMangle(int64_t id) : data_(static_cast<uint64_t>(id)) {}
+    explicit DontMangle(int id) : data_(static_cast<uint64_t>(id)) {}
+    explicit DontMangle(int16_t id) : data_(static_cast<uint64_t>(id)) {}
+    explicit DontMangle(signed char id) : data_(static_cast<uint64_t>(id)) {}
+    uint64_t data() const { return data_; }
+
+   private:
+    uint64_t data_;
+  };
+
+  class ForceMangle {
+   public:
+    explicit ForceMangle(uint64_t id) : data_(id) {}
+    explicit ForceMangle(unsigned int id) : data_(id) {}
+    explicit ForceMangle(uint16_t id) : data_(id) {}
+    explicit ForceMangle(unsigned char id) : data_(id) {}
+    explicit ForceMangle(int64_t id) : data_(static_cast<uint64_t>(id)) {}
+    explicit ForceMangle(int id) : data_(static_cast<uint64_t>(id)) {}
+    explicit ForceMangle(int16_t id) : data_(static_cast<uint64_t>(id)) {}
+    explicit ForceMangle(signed char id) : data_(static_cast<uint64_t>(id)) {}
+    uint64_t data() const { return data_; }
+
+   private:
+    uint64_t data_;
+  };
+
+  TraceID(const void* id, unsigned int* flags)
+      : data_(static_cast<uint64_t>(reinterpret_cast<uintptr_t>(id))) {
+    *flags |= TRACE_EVENT_FLAG_MANGLE_ID;
+  }
+  TraceID(ForceMangle id, unsigned int* flags) : data_(id.data()) {
+    *flags |= TRACE_EVENT_FLAG_MANGLE_ID;
+  }
+  TraceID(DontMangle id, unsigned int* flags) : data_(id.data()) {}
+  TraceID(uint64_t id, unsigned int* flags) : data_(id) { (void)flags; }
+  TraceID(unsigned int id, unsigned int* flags) : data_(id) { (void)flags; }
+  TraceID(uint16_t id, unsigned int* flags) : data_(id) { (void)flags; }
+  TraceID(unsigned char id, unsigned int* flags) : data_(id) { (void)flags; }
+  TraceID(int64_t id, unsigned int* flags) : data_(static_cast<uint64_t>(id)) {
+    (void)flags;
+  }
+  TraceID(int id, unsigned int* flags) : data_(static_cast<uint64_t>(id)) {
+    (void)flags;
+  }
+  TraceID(int16_t id, unsigned int* flags) : data_(static_cast<uint64_t>(id)) {
+    (void)flags;
+  }
+  TraceID(signed char id, unsigned int* flags)
+      : data_(static_cast<uint64_t>(id)) {
+    (void)flags;
+  }
+
+  uint64_t data() const { return data_; }
+
+ private:
+  uint64_t data_;
+};
+
+// Simple union to store various types as uint64_t.
+union TraceValueUnion {
+  bool as_bool;
+  uint64_t as_uint;
+  int64_t as_int;
+  double as_double;
+  const void* as_pointer;
+  const char* as_string;
+};
+
+// Simple container for const char* that should be copied instead of retained.
+class TraceStringWithCopy {
+ public:
+  explicit TraceStringWithCopy(const char* str) : str_(str) {}
+  operator const char*() const { return str_; }
+
+ private:
+  const char* str_;
+};
+
+// Define SetTraceValue for each allowed type. It stores the type and
+// value in the return arguments. This allows this API to avoid declaring any
+// structures so that it is portable to third_party libraries.
+#define INTERNAL_DECLARE_SET_TRACE_VALUE(actual_type, union_member,         \
+                                         value_type_id)                     \
+  static V8_INLINE void SetTraceValue(actual_type arg, unsigned char* type, \
+                                      uint64_t* value) {                    \
+    TraceValueUnion type_value;                                             \
+    type_value.union_member = arg;                                          \
+    *type = value_type_id;                                                  \
+    *value = type_value.as_uint;                                            \
+  }
+// Simpler form for int types that can be safely casted.
+#define INTERNAL_DECLARE_SET_TRACE_VALUE_INT(actual_type, value_type_id)    \
+  static V8_INLINE void SetTraceValue(actual_type arg, unsigned char* type, \
+                                      uint64_t* value) {                    \
+    *type = value_type_id;                                                  \
+    *value = static_cast<uint64_t>(arg);                                    \
+  }
+
+INTERNAL_DECLARE_SET_TRACE_VALUE_INT(uint64_t, TRACE_VALUE_TYPE_UINT)
+INTERNAL_DECLARE_SET_TRACE_VALUE_INT(unsigned int, TRACE_VALUE_TYPE_UINT)
+INTERNAL_DECLARE_SET_TRACE_VALUE_INT(uint16_t, TRACE_VALUE_TYPE_UINT)
+INTERNAL_DECLARE_SET_TRACE_VALUE_INT(unsigned char, TRACE_VALUE_TYPE_UINT)
+INTERNAL_DECLARE_SET_TRACE_VALUE_INT(int64_t, TRACE_VALUE_TYPE_INT)
+INTERNAL_DECLARE_SET_TRACE_VALUE_INT(int, TRACE_VALUE_TYPE_INT)
+INTERNAL_DECLARE_SET_TRACE_VALUE_INT(int16_t, TRACE_VALUE_TYPE_INT)
+INTERNAL_DECLARE_SET_TRACE_VALUE_INT(signed char, TRACE_VALUE_TYPE_INT)
+INTERNAL_DECLARE_SET_TRACE_VALUE(bool, as_bool, TRACE_VALUE_TYPE_BOOL)
+INTERNAL_DECLARE_SET_TRACE_VALUE(double, as_double, TRACE_VALUE_TYPE_DOUBLE)
+INTERNAL_DECLARE_SET_TRACE_VALUE(const void*, as_pointer,
+                                 TRACE_VALUE_TYPE_POINTER)
+INTERNAL_DECLARE_SET_TRACE_VALUE(const char*, as_string,
+                                 TRACE_VALUE_TYPE_STRING)
+INTERNAL_DECLARE_SET_TRACE_VALUE(const TraceStringWithCopy&, as_string,
+                                 TRACE_VALUE_TYPE_COPY_STRING)
+
+#undef INTERNAL_DECLARE_SET_TRACE_VALUE
+#undef INTERNAL_DECLARE_SET_TRACE_VALUE_INT
+
+// These AddTraceEvent template
+// function is defined here instead of in the macro, because the arg_values
+// could be temporary objects, such as std::string. In order to store
+// pointers to the internal c_str and pass through to the tracing API,
+// the arg_values must live throughout these procedures.
+
+static V8_INLINE uint64_t AddTraceEvent(char phase,
+                                        const uint8_t* category_group_enabled,
+                                        const char* name, uint64_t id,
+                                        uint64_t bind_id, unsigned int flags) {
+  return TRACE_EVENT_API_ADD_TRACE_EVENT(phase, category_group_enabled, name,
+                                         id, bind_id, kZeroNumArgs, NULL, NULL,
+                                         NULL, flags);
+}
+
+template <class ARG1_TYPE>
+static V8_INLINE uint64_t AddTraceEvent(char phase,
+                                        const uint8_t* category_group_enabled,
+                                        const char* name, uint64_t id,
+                                        uint64_t bind_id, unsigned int flags,
+                                        const char* arg1_name,
+                                        const ARG1_TYPE& arg1_val) {
+  const int num_args = 1;
+  uint8_t arg_types[1];
+  uint64_t arg_values[1];
+  SetTraceValue(arg1_val, &arg_types[0], &arg_values[0]);
+  return TRACE_EVENT_API_ADD_TRACE_EVENT(phase, category_group_enabled, name,
+                                         id, bind_id, num_args, &arg1_name,
+                                         arg_types, arg_values, flags);
+}
+
+template <class ARG1_TYPE, class ARG2_TYPE>
+static V8_INLINE uint64_t AddTraceEvent(
+    char phase, const uint8_t* category_group_enabled, const char* name,
+    uint64_t id, uint64_t bind_id, unsigned int flags, const char* arg1_name,
+    const ARG1_TYPE& arg1_val, const char* arg2_name,
+    const ARG2_TYPE& arg2_val) {
+  const int num_args = 2;
+  const char* arg_names[2] = {arg1_name, arg2_name};
+  unsigned char arg_types[2];
+  uint64_t arg_values[2];
+  SetTraceValue(arg1_val, &arg_types[0], &arg_values[0]);
+  SetTraceValue(arg2_val, &arg_types[1], &arg_values[1]);
+  return TRACE_EVENT_API_ADD_TRACE_EVENT(phase, category_group_enabled, name,
+                                         id, bind_id, num_args, arg_names,
+                                         arg_types, arg_values, flags);
+}
+
+// Used by TRACE_EVENTx macros. Do not use directly.
+class ScopedTracer {
+ public:
+  // Note: members of data_ intentionally left uninitialized. See Initialize.
+  ScopedTracer() : p_data_(NULL) {}
+
+  ~ScopedTracer() {
+    if (p_data_ && *data_.category_group_enabled)
+      TRACE_EVENT_API_UPDATE_TRACE_EVENT_DURATION(
+          data_.category_group_enabled, data_.name, data_.event_handle);
+  }
+
+  void Initialize(const uint8_t* category_group_enabled, const char* name,
+                  uint64_t event_handle) {
+    data_.category_group_enabled = category_group_enabled;
+    data_.name = name;
+    data_.event_handle = event_handle;
+    p_data_ = &data_;
+  }
+
+ private:
+  // This Data struct workaround is to avoid initializing all the members
+  // in Data during construction of this object, since this object is always
+  // constructed, even when tracing is disabled. If the members of Data were
+  // members of this class instead, compiler warnings occur about potential
+  // uninitialized accesses.
+  struct Data {
+    const uint8_t* category_group_enabled;
+    const char* name;
+    uint64_t event_handle;
+  };
+  Data* p_data_;
+  Data data_;
+};
+
+// Used by TRACE_EVENT_BINARY_EFFICIENTx macro. Do not use directly.
+class ScopedTraceBinaryEfficient {
+ public:
+  ScopedTraceBinaryEfficient(const char* category_group, const char* name);
+  ~ScopedTraceBinaryEfficient();
+
+ private:
+  const uint8_t* category_group_enabled_;
+  const char* name_;
+  uint64_t event_handle_;
+};
+
+// TraceEventSamplingStateScope records the current sampling state
+// and sets a new sampling state. When the scope exists, it restores
+// the sampling state having recorded.
+template <size_t BucketNumber>
+class TraceEventSamplingStateScope {
+ public:
+  explicit TraceEventSamplingStateScope(const char* category_and_name) {
+    previous_state_ = TraceEventSamplingStateScope<BucketNumber>::Current();
+    TraceEventSamplingStateScope<BucketNumber>::Set(category_and_name);
+  }
+
+  ~TraceEventSamplingStateScope() {
+    TraceEventSamplingStateScope<BucketNumber>::Set(previous_state_);
+  }
+
+  static V8_INLINE const char* Current() {
+    return reinterpret_cast<const char*>(
+        TRACE_EVENT_API_ATOMIC_LOAD(g_trace_state[BucketNumber]));
+  }
+
+  static V8_INLINE void Set(const char* category_and_name) {
+    TRACE_EVENT_API_ATOMIC_STORE(g_trace_state[BucketNumber],
+                                 reinterpret_cast<TRACE_EVENT_API_ATOMIC_WORD>(
+                                     const_cast<char*>(category_and_name)));
+  }
+
+ private:
+  const char* previous_state_;
+};
+
+}  // namespace tracing
+}  // namespace internal
+}  // namespace v8
+
+#endif  // SRC_TRACING_TRACE_EVENT_H_

test/cctest/cctest.gyp

@@ -170,6 +170,7 @@
         'test-strtod.cc',
         'test-thread-termination.cc',
         'test-threads.cc',
+        'test-trace-event.cc',
         'test-transitions.cc',
         'test-typedarrays.cc',
         'test-types.cc',

test/cctest/heap/test-incremental-marking.cc

@@ -85,6 +85,28 @@ class MockPlatform : public v8::Platform {
     delete task;
   }
 
+  uint64_t AddTraceEvent(char phase, const uint8_t* categoryEnabledFlag,
+                         const char* name, uint64_t id, uint64_t bind_id,
+                         int numArgs, const char** argNames,
+                         const uint8_t* argTypes, const uint64_t* argValues,
+                         unsigned int flags) override {
+    return 0;
+  }
+
+  void UpdateTraceEventDuration(const uint8_t* categoryEnabledFlag,
+                                const char* name, uint64_t handle) override {}
+
+  const uint8_t* GetCategoryGroupEnabled(const char* name) override {
+    static uint8_t no = 0;
+    return &no;
+  }
+
+  const char* GetCategoryGroupName(
+      const uint8_t* categoryEnabledFlag) override {
+    static const char* dummy = "dummy";
+    return dummy;
+  }
+
  private:
   v8::Platform* platform_;
   IdleTask* idle_task_;

test/cctest/test-trace-event.cc

+// Copyright 2015 the V8 project authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+#include <stdlib.h>
+#include <string.h>
+
+#include "src/v8.h"
+
+#include "src/list.h"
+#include "src/list-inl.h"
+#include "test/cctest/cctest.h"
+
+using v8::IdleTask;
+using v8::Task;
+using v8::Isolate;
+
+#include "src/tracing/trace-event.h"
+
+#define GET_TRACE_OBJECTS_LIST platform.GetMockTraceObjects()
+
+#define GET_TRACE_OBJECT(Index) GET_TRACE_OBJECTS_LIST->at(Index)
+
+
+struct MockTraceObject {
+  char phase;
+  std::string name;
+  uint64_t id;
+  uint64_t bind_id;
+  int num_args;
+  unsigned int flags;
+  MockTraceObject(char phase, std::string name, uint64_t id, uint64_t bind_id,
+                  int num_args, int flags)
+      : phase(phase),
+        name(name),
+        id(id),
+        bind_id(bind_id),
+        num_args(num_args),
+        flags(flags) {}
+};
+
+typedef v8::internal::List<MockTraceObject*> MockTraceObjectList;
+
+class MockTracingPlatform : public v8::Platform {
+ public:
+  explicit MockTracingPlatform(v8::Platform* platform) {}
+  virtual ~MockTracingPlatform() {
+    for (int i = 0; i < trace_object_list_.length(); ++i) {
+      delete trace_object_list_[i];
+    }
+    trace_object_list_.Clear();
+  }
+  void CallOnBackgroundThread(Task* task,
+                              ExpectedRuntime expected_runtime) override {}
+
+  void CallOnForegroundThread(Isolate* isolate, Task* task) override {}
+
+  void CallDelayedOnForegroundThread(Isolate* isolate, Task* task,
+                                     double delay_in_seconds) override {}
+
+  double MonotonicallyIncreasingTime() override { return 0.0; }
+
+  void CallIdleOnForegroundThread(Isolate* isolate, IdleTask* task) override {}
+
+  bool IdleTasksEnabled(Isolate* isolate) override { return false; }
+
+  bool PendingIdleTask() { return false; }
+
+  void PerformIdleTask(double idle_time_in_seconds) {}
+
+  bool PendingDelayedTask() { return false; }
+
+  void PerformDelayedTask() {}
+
+  uint64_t AddTraceEvent(char phase, const uint8_t* category_enabled_flag,
+                         const char* name, uint64_t id, uint64_t bind_id,
+                         int num_args, const char** arg_names,
+                         const uint8_t* arg_types, const uint64_t* arg_values,
+                         unsigned int flags) override {
+    MockTraceObject* to = new MockTraceObject(phase, std::string(name), id,
+                                              bind_id, num_args, flags);
+    trace_object_list_.Add(to);
+    return 0;
+  }
+
+  void UpdateTraceEventDuration(const uint8_t* category_enabled_flag,
+                                const char* name, uint64_t handle) override {}
+
+  const uint8_t* GetCategoryGroupEnabled(const char* name) override {
+    if (strcmp(name, "v8-cat")) {
+      static uint8_t no = 0;
+      return &no;
+    } else {
+      static uint8_t yes = 0x7;
+      return &yes;
+    }
+  }
+
+  const char* GetCategoryGroupName(
+      const uint8_t* category_enabled_flag) override {
+    static const char dummy[] = "dummy";
+    return dummy;
+  }
+
+  MockTraceObjectList* GetMockTraceObjects() { return &trace_object_list_; }
+
+ private:
+  MockTraceObjectList trace_object_list_;
+};
+
+
+TEST(TraceEventDisabledCategory) {
+  v8::Platform* old_platform = i::V8::GetCurrentPlatform();
+  MockTracingPlatform platform(old_platform);
+  i::V8::SetPlatformForTesting(&platform);
+
+  // Disabled category, will not add events.
+  TRACE_EVENT_BEGIN0("cat", "e1");
+  TRACE_EVENT_END0("cat", "e1");
+  CHECK_EQ(0, GET_TRACE_OBJECTS_LIST->length());
+
+  i::V8::SetPlatformForTesting(old_platform);
+}
+
+
+TEST(TraceEventNoArgs) {
+  v8::Platform* old_platform = i::V8::GetCurrentPlatform();
+  MockTracingPlatform platform(old_platform);
+  i::V8::SetPlatformForTesting(&platform);
+
+  // Enabled category will add 2 events.
+  TRACE_EVENT_BEGIN0("v8-cat", "e1");
+  TRACE_EVENT_END0("v8-cat", "e1");
+
+  CHECK_EQ(2, GET_TRACE_OBJECTS_LIST->length());
+  CHECK_EQ('B', GET_TRACE_OBJECT(0)->phase);
+  CHECK_EQ("e1", GET_TRACE_OBJECT(0)->name);
+  CHECK_EQ(0, GET_TRACE_OBJECT(0)->num_args);
+
+  CHECK_EQ('E', GET_TRACE_OBJECT(1)->phase);
+  CHECK_EQ("e1", GET_TRACE_OBJECT(1)->name);
+  CHECK_EQ(0, GET_TRACE_OBJECT(1)->num_args);
+
+  i::V8::SetPlatformForTesting(old_platform);
+}
+
+
+TEST(TraceEventWithOneArg) {
+  v8::Platform* old_platform = i::V8::GetCurrentPlatform();
+  MockTracingPlatform platform(old_platform);
+  i::V8::SetPlatformForTesting(&platform);
+
+  TRACE_EVENT_BEGIN1("v8-cat", "e1", "arg1", 42);
+  TRACE_EVENT_END1("v8-cat", "e1", "arg1", 42);
+  TRACE_EVENT_BEGIN1("v8-cat", "e2", "arg1", "abc");
+  TRACE_EVENT_END1("v8-cat", "e2", "arg1", "abc");
+
+  CHECK_EQ(4, GET_TRACE_OBJECTS_LIST->length());
+
+  CHECK_EQ(1, GET_TRACE_OBJECT(0)->num_args);
+  CHECK_EQ(1, GET_TRACE_OBJECT(1)->num_args);
+  CHECK_EQ(1, GET_TRACE_OBJECT(2)->num_args);
+  CHECK_EQ(1, GET_TRACE_OBJECT(3)->num_args);
+
+  i::V8::SetPlatformForTesting(old_platform);
+}
+
+
+TEST(TraceEventWithTwoArgs) {
+  v8::Platform* old_platform = i::V8::GetCurrentPlatform();
+  MockTracingPlatform platform(old_platform);
+  i::V8::SetPlatformForTesting(&platform);
+
+  TRACE_EVENT_BEGIN2("v8-cat", "e1", "arg1", 42, "arg2", "abc");
+  TRACE_EVENT_END2("v8-cat", "e1", "arg1", 42, "arg2", "abc");
+  TRACE_EVENT_BEGIN2("v8-cat", "e2", "arg1", "abc", "arg2", 43);
+  TRACE_EVENT_END2("v8-cat", "e2", "arg1", "abc", "arg2", 43);
+
+  CHECK_EQ(4, GET_TRACE_OBJECTS_LIST->length());
+
+  CHECK_EQ(2, GET_TRACE_OBJECT(0)->num_args);
+  CHECK_EQ(2, GET_TRACE_OBJECT(1)->num_args);
+  CHECK_EQ(2, GET_TRACE_OBJECT(2)->num_args);
+  CHECK_EQ(2, GET_TRACE_OBJECT(3)->num_args);
+
+  i::V8::SetPlatformForTesting(old_platform);
+}
+
+
+TEST(ScopedTraceEvent) {
+  v8::Platform* old_platform = i::V8::GetCurrentPlatform();
+  MockTracingPlatform platform(old_platform);
+  i::V8::SetPlatformForTesting(&platform);
+
+  { TRACE_EVENT0("v8-cat", "e"); }
+
+  CHECK_EQ(1, GET_TRACE_OBJECTS_LIST->length());
+  CHECK_EQ(0, GET_TRACE_OBJECT(0)->num_args);
+
+  { TRACE_EVENT1("v8-cat", "e1", "arg1", "abc"); }
+
+  CHECK_EQ(2, GET_TRACE_OBJECTS_LIST->length());
+  CHECK_EQ(1, GET_TRACE_OBJECT(1)->num_args);
+
+  { TRACE_EVENT2("v8-cat", "e1", "arg1", "abc", "arg2", 42); }
+
+  CHECK_EQ(3, GET_TRACE_OBJECTS_LIST->length());
+  CHECK_EQ(2, GET_TRACE_OBJECT(2)->num_args);
+
+  i::V8::SetPlatformForTesting(old_platform);
+}
+
+
+TEST(TestEventWithFlow) {
+  v8::Platform* old_platform = i::V8::GetCurrentPlatform();
+  MockTracingPlatform platform(old_platform);
+  i::V8::SetPlatformForTesting(&platform);
+
+  static uint64_t bind_id = 21;
+  {
+    TRACE_EVENT_WITH_FLOW0("v8-cat", "f1", bind_id, TRACE_EVENT_FLAG_FLOW_OUT);
+  }
+  {
+    TRACE_EVENT_WITH_FLOW0(
+        "v8-cat", "f2", bind_id,
+        TRACE_EVENT_FLAG_FLOW_IN | TRACE_EVENT_FLAG_FLOW_OUT);
+  }
+  { TRACE_EVENT_WITH_FLOW0("v8-cat", "f3", bind_id, TRACE_EVENT_FLAG_FLOW_IN); }
+
+  CHECK_EQ(3, GET_TRACE_OBJECTS_LIST->length());
+  CHECK_EQ(bind_id, GET_TRACE_OBJECT(0)->bind_id);
+  CHECK_EQ(TRACE_EVENT_FLAG_FLOW_OUT, GET_TRACE_OBJECT(0)->flags);
+  CHECK_EQ(bind_id, GET_TRACE_OBJECT(1)->bind_id);
+  CHECK_EQ(TRACE_EVENT_FLAG_FLOW_IN | TRACE_EVENT_FLAG_FLOW_OUT,
+           GET_TRACE_OBJECT(1)->flags);
+  CHECK_EQ(bind_id, GET_TRACE_OBJECT(2)->bind_id);
+  CHECK_EQ(TRACE_EVENT_FLAG_FLOW_IN, GET_TRACE_OBJECT(2)->flags);
+
+  i::V8::SetPlatformForTesting(old_platform);
+}
+
+
+TEST(TestEventWithId) {
+  v8::Platform* old_platform = i::V8::GetCurrentPlatform();
+  MockTracingPlatform platform(old_platform);
+  i::V8::SetPlatformForTesting(&platform);
+
+  static uint64_t event_id = 21;
+  TRACE_EVENT_ASYNC_BEGIN0("v8-cat", "a1", event_id);
+  TRACE_EVENT_ASYNC_END0("v8-cat", "a1", event_id);
+
+  CHECK_EQ(2, GET_TRACE_OBJECTS_LIST->length());
+  CHECK_EQ(TRACE_EVENT_PHASE_ASYNC_BEGIN, GET_TRACE_OBJECT(0)->phase);
+  CHECK_EQ(event_id, GET_TRACE_OBJECT(0)->id);
+  CHECK_EQ(TRACE_EVENT_PHASE_ASYNC_END, GET_TRACE_OBJECT(1)->phase);
+  CHECK_EQ(event_id, GET_TRACE_OBJECT(1)->id);
+
+  i::V8::SetPlatformForTesting(old_platform);
+}

tools/gyp/v8.gyp

@@ -367,6 +367,8 @@
       },
       'include_dirs+': [
         '../..',
+        # To be able to find base/trace_event/common/trace_event_common.h
+        '../../..',
       ],
       'defines': [
         # TODO(jochen): Remove again after this is globally turned on.
@@ -1030,6 +1032,8 @@
         '../../src/strtod.h',
         '../../src/ic/stub-cache.cc',
         '../../src/ic/stub-cache.h',
+        '../../src/tracing/trace-event.cc',
+        '../../src/tracing/trace-event.h',
         '../../src/transitions-inl.h',
         '../../src/transitions.cc',
         '../../src/transitions.h',