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}
This commit is contained in:
fmeawad
Commit bot
parent
9e8b7564f7
commit
70a7c754bf
4
BUILD.gn
4
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",
|
||||
|
||||
1
DEPS
1
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":
|
||||
|
||||
@ -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': [
|
||||
|
||||
@ -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
|
||||
|
||||
1
src/DEPS
1
src/DEPS
@ -1,4 +1,5 @@
|
||||
include_rules = [
|
||||
"+base/trace_event/common/trace_event_common.h",
|
||||
"+src",
|
||||
"-src/compiler",
|
||||
"+src/compiler/pipeline.h",
|
||||
|
||||
22
src/d8.cc
22
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;
|
||||
|
||||
|
||||
@ -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
|
||||
|
||||
@ -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;
|
||||
|
||||
@ -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
|
||||
|
||||
19
src/tracing/trace-event.cc
Normal file
19
src/tracing/trace-event.cc
Normal file
@ -0,0 +1,19 @@
|
||||
// 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
|
||||
535
src/tracing/trace-event.h
Normal file
535
src/tracing/trace-event.h
Normal file
@ -0,0 +1,535 @@
|
||||
// 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_
|
||||
@ -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',
|
||||
|
||||
@ -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_;
|
||||
|
||||
258
test/cctest/test-trace-event.cc
Normal file
258
test/cctest/test-trace-event.cc
Normal file
@ -0,0 +1,258 @@
|
||||
// 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);
|
||||
}
|
||||
@ -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',
|
||||
|
||||
Loading…
Reference in New Issue
Block a user