// Copyright 2016 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 #include "include/libplatform/v8-tracing.h" #include "src/base/platform/platform.h" #include "src/libplatform/default-platform.h" #include "src/tracing/trace-event.h" #include "test/cctest/cctest.h" #ifdef V8_USE_PERFETTO #include "perfetto/trace/chrome/chrome_trace_event.pb.h" #include "perfetto/trace/chrome/chrome_trace_event.pbzero.h" #include "perfetto/trace/chrome/chrome_trace_packet.pb.h" #include "perfetto/trace/trace.pb.h" #include "perfetto/tracing.h" #include "src/libplatform/tracing/json-trace-event-listener.h" #include "src/libplatform/tracing/trace-event-listener.h" #endif // V8_USE_PERFETTO #ifdef V8_USE_PERFETTO class TestDataSource : public perfetto::DataSource { public: void OnSetup(const SetupArgs&) override {} void OnStart(const StartArgs&) override { started_.Signal(); } void OnStop(const StopArgs&) override {} static v8::base::Semaphore started_; }; v8::base::Semaphore TestDataSource::started_{0}; PERFETTO_DEFINE_DATA_SOURCE_STATIC_MEMBERS(TestDataSource); #endif // V8_USE_PERFETTO namespace v8 { namespace platform { namespace tracing { TEST(TestTraceConfig) { LocalContext env; TraceConfig* trace_config = new TraceConfig(); trace_config->AddIncludedCategory("v8"); trace_config->AddIncludedCategory(TRACE_DISABLED_BY_DEFAULT("v8.runtime")); CHECK_EQ(trace_config->IsSystraceEnabled(), false); CHECK_EQ(trace_config->IsArgumentFilterEnabled(), false); CHECK_EQ(trace_config->IsCategoryGroupEnabled("v8"), true); CHECK_EQ(trace_config->IsCategoryGroupEnabled("v8.cpu_profile"), false); CHECK_EQ(trace_config->IsCategoryGroupEnabled("v8.cpu_profile.hires"), false); CHECK_EQ(trace_config->IsCategoryGroupEnabled( TRACE_DISABLED_BY_DEFAULT("v8.runtime")), true); CHECK_EQ(trace_config->IsCategoryGroupEnabled("v8,v8.cpu_profile"), true); CHECK_EQ( trace_config->IsCategoryGroupEnabled("v8,disabled-by-default-v8.runtime"), true); CHECK_EQ(trace_config->IsCategoryGroupEnabled( "v8_cpu_profile,v8.cpu_profile.hires"), false); delete trace_config; } TEST(TestTraceObject) { TraceObject trace_object; uint8_t category_enabled_flag = 41; trace_object.Initialize('X', &category_enabled_flag, "Test.Trace", "Test.Scope", 42, 123, 0, nullptr, nullptr, nullptr, nullptr, 0, 1729, 4104); CHECK_EQ('X', trace_object.phase()); CHECK_EQ(category_enabled_flag, *trace_object.category_enabled_flag()); CHECK_EQ(std::string("Test.Trace"), std::string(trace_object.name())); CHECK_EQ(std::string("Test.Scope"), std::string(trace_object.scope())); CHECK_EQ(0u, trace_object.duration()); CHECK_EQ(0u, trace_object.cpu_duration()); } class ConvertableToTraceFormatMock : public v8::ConvertableToTraceFormat { public: explicit ConvertableToTraceFormatMock(int value) : value_(value) {} void AppendAsTraceFormat(std::string* out) const override { *out += "[" + std::to_string(value_) + "," + std::to_string(value_) + "]"; } private: int value_; DISALLOW_COPY_AND_ASSIGN(ConvertableToTraceFormatMock); }; class MockTraceWriter : public TraceWriter { public: void AppendTraceEvent(TraceObject* trace_event) override { // TraceObject might not have been initialized. const char* name = trace_event->name() ? trace_event->name() : ""; events_.push_back(name); } void Flush() override {} std::vector events() { return events_; } private: std::vector events_; }; TEST(TestTraceBufferRingBuffer) { // We should be able to add kChunkSize * 2 + 1 trace events. const int HANDLES_COUNT = TraceBufferChunk::kChunkSize * 2 + 1; MockTraceWriter* writer = new MockTraceWriter(); TraceBuffer* ring_buffer = TraceBuffer::CreateTraceBufferRingBuffer(2, writer); std::string names[HANDLES_COUNT]; for (int i = 0; i < HANDLES_COUNT; ++i) { names[i] = "Test.EventNo" + std::to_string(i); } std::vector handles(HANDLES_COUNT); uint8_t category_enabled_flag = 41; for (size_t i = 0; i < handles.size(); ++i) { TraceObject* trace_object = ring_buffer->AddTraceEvent(&handles[i]); CHECK_NOT_NULL(trace_object); trace_object->Initialize('X', &category_enabled_flag, names[i].c_str(), "Test.Scope", 42, 123, 0, nullptr, nullptr, nullptr, nullptr, 0, 1729, 4104); trace_object = ring_buffer->GetEventByHandle(handles[i]); CHECK_NOT_NULL(trace_object); CHECK_EQ('X', trace_object->phase()); CHECK_EQ(names[i], std::string(trace_object->name())); CHECK_EQ(category_enabled_flag, *trace_object->category_enabled_flag()); } // We should only be able to retrieve the last kChunkSize + 1. for (size_t i = 0; i < TraceBufferChunk::kChunkSize; ++i) { CHECK_NULL(ring_buffer->GetEventByHandle(handles[i])); } for (size_t i = TraceBufferChunk::kChunkSize; i < handles.size(); ++i) { TraceObject* trace_object = ring_buffer->GetEventByHandle(handles[i]); CHECK_NOT_NULL(trace_object); // The object properties should be correct. CHECK_EQ('X', trace_object->phase()); CHECK_EQ(names[i], std::string(trace_object->name())); CHECK_EQ(category_enabled_flag, *trace_object->category_enabled_flag()); } // Check Flush(), that the writer wrote the last kChunkSize 1 event names. ring_buffer->Flush(); auto events = writer->events(); CHECK_EQ(TraceBufferChunk::kChunkSize + 1, events.size()); for (size_t i = TraceBufferChunk::kChunkSize; i < handles.size(); ++i) { CHECK_EQ(names[i], events[i - TraceBufferChunk::kChunkSize]); } delete ring_buffer; } void PopulateJSONWriter(TraceWriter* writer) { v8::Platform* old_platform = i::V8::GetCurrentPlatform(); std::unique_ptr default_platform( v8::platform::NewDefaultPlatform()); i::V8::SetPlatformForTesting(default_platform.get()); auto tracing = base::make_unique(); v8::platform::tracing::TracingController* tracing_controller = tracing.get(); static_cast(default_platform.get()) ->SetTracingController(std::move(tracing)); TraceBuffer* ring_buffer = TraceBuffer::CreateTraceBufferRingBuffer(1, writer); tracing_controller->Initialize(ring_buffer); #ifdef V8_USE_PERFETTO std::ostringstream sstream; tracing_controller->InitializeForPerfetto(&sstream); #endif TraceConfig* trace_config = new TraceConfig(); trace_config->AddIncludedCategory("v8-cat"); tracing_controller->StartTracing(trace_config); TraceObject trace_object; trace_object.InitializeForTesting( 'X', tracing_controller->GetCategoryGroupEnabled("v8-cat"), "Test0", v8::internal::tracing::kGlobalScope, 42, 0x1234, 0, nullptr, nullptr, nullptr, nullptr, TRACE_EVENT_FLAG_HAS_ID, 11, 22, 100, 50, 33, 44); writer->AppendTraceEvent(&trace_object); trace_object.InitializeForTesting( 'Y', tracing_controller->GetCategoryGroupEnabled("v8-cat"), "Test1", v8::internal::tracing::kGlobalScope, 43, 0x5678, 0, nullptr, nullptr, nullptr, nullptr, TRACE_EVENT_FLAG_FLOW_IN | TRACE_EVENT_FLAG_FLOW_OUT, 55, 66, 110, 55, 77, 88); writer->AppendTraceEvent(&trace_object); tracing_controller->StopTracing(); i::V8::SetPlatformForTesting(old_platform); } TEST(TestJSONTraceWriter) { std::ostringstream stream; TraceWriter* writer = TraceWriter::CreateJSONTraceWriter(stream); PopulateJSONWriter(writer); std::string trace_str = stream.str(); std::string expected_trace_str = "{\"traceEvents\":[{\"pid\":11,\"tid\":22,\"ts\":100,\"tts\":50," "\"ph\":\"X\",\"cat\":\"v8-cat\",\"name\":\"Test0\",\"dur\":33," "\"tdur\":44,\"id\":\"0x2a\",\"args\":{}},{\"pid\":55,\"tid\":66," "\"ts\":110,\"tts\":55,\"ph\":\"Y\",\"cat\":\"v8-cat\",\"name\":" "\"Test1\",\"dur\":77,\"tdur\":88,\"bind_id\":\"0x5678\"," "\"flow_in\":true,\"flow_out\":true,\"args\":{}}]}"; CHECK_EQ(expected_trace_str, trace_str); } TEST(TestJSONTraceWriterWithCustomtag) { std::ostringstream stream; TraceWriter* writer = TraceWriter::CreateJSONTraceWriter(stream, "customTag"); PopulateJSONWriter(writer); std::string trace_str = stream.str(); std::string expected_trace_str = "{\"customTag\":[{\"pid\":11,\"tid\":22,\"ts\":100,\"tts\":50," "\"ph\":\"X\",\"cat\":\"v8-cat\",\"name\":\"Test0\",\"dur\":33," "\"tdur\":44,\"id\":\"0x2a\",\"args\":{}},{\"pid\":55,\"tid\":66," "\"ts\":110,\"tts\":55,\"ph\":\"Y\",\"cat\":\"v8-cat\",\"name\":" "\"Test1\",\"dur\":77,\"tdur\":88,\"bind_id\":\"0x5678\"," "\"flow_in\":true,\"flow_out\":true,\"args\":{}}]}"; CHECK_EQ(expected_trace_str, trace_str); } void GetJSONStrings(std::vector* ret, const std::string& str, const std::string& param, const std::string& start_delim, const std::string& end_delim) { size_t pos = str.find(param); while (pos != std::string::npos) { size_t start_pos = str.find(start_delim, pos + param.length()); size_t end_pos = str.find(end_delim, start_pos + 1); CHECK_NE(start_pos, std::string::npos); CHECK_NE(end_pos, std::string::npos); ret->push_back(str.substr(start_pos + 1, end_pos - start_pos - 1)); pos = str.find(param, pos + 1); } } #ifndef V8_USE_PERFETTO TEST(TestTracingController) { v8::Platform* old_platform = i::V8::GetCurrentPlatform(); std::unique_ptr default_platform( v8::platform::NewDefaultPlatform()); i::V8::SetPlatformForTesting(default_platform.get()); auto tracing = base::make_unique(); v8::platform::tracing::TracingController* tracing_controller = tracing.get(); static_cast(default_platform.get()) ->SetTracingController(std::move(tracing)); MockTraceWriter* writer = new MockTraceWriter(); TraceBuffer* ring_buffer = TraceBuffer::CreateTraceBufferRingBuffer(1, writer); tracing_controller->Initialize(ring_buffer); #ifdef V8_USE_PERFETTO std::ostringstream sstream; tracing_controller->InitializeForPerfetto(&sstream); #endif TraceConfig* trace_config = new TraceConfig(); trace_config->AddIncludedCategory("v8"); tracing_controller->StartTracing(trace_config); TRACE_EVENT0("v8", "v8.Test"); // cat category is not included in default config TRACE_EVENT0("cat", "v8.Test2"); TRACE_EVENT0("v8", "v8.Test3"); tracing_controller->StopTracing(); CHECK_EQ(2u, writer->events().size()); CHECK_EQ(std::string("v8.Test"), writer->events()[0]); CHECK_EQ(std::string("v8.Test3"), writer->events()[1]); i::V8::SetPlatformForTesting(old_platform); } TEST(TestTracingControllerMultipleArgsAndCopy) { std::ostringstream stream, perfetto_stream; uint64_t aa = 11; unsigned int bb = 22; uint16_t cc = 33; unsigned char dd = 44; int64_t ee = -55; int ff = -66; int16_t gg = -77; signed char hh = -88; bool ii1 = true; bool ii2 = false; double jj1 = 99.0; double jj2 = 1e100; double jj3 = std::numeric_limits::quiet_NaN(); double jj4 = std::numeric_limits::infinity(); double jj5 = -std::numeric_limits::infinity(); void* kk = &aa; const char* ll = "100"; std::string mm = "INIT"; std::string mmm = "\"INIT\""; // Create a scope for the tracing controller to terminate the trace writer. { v8::Platform* old_platform = i::V8::GetCurrentPlatform(); std::unique_ptr default_platform( v8::platform::NewDefaultPlatform()); i::V8::SetPlatformForTesting(default_platform.get()); auto tracing = base::make_unique(); v8::platform::tracing::TracingController* tracing_controller = tracing.get(); static_cast(default_platform.get()) ->SetTracingController(std::move(tracing)); TraceWriter* writer = TraceWriter::CreateJSONTraceWriter(stream); TraceBuffer* ring_buffer = TraceBuffer::CreateTraceBufferRingBuffer(1, writer); tracing_controller->Initialize(ring_buffer); #ifdef V8_USE_PERFETTO tracing_controller->InitializeForPerfetto(&perfetto_stream); #endif TraceConfig* trace_config = new TraceConfig(); trace_config->AddIncludedCategory("v8"); tracing_controller->StartTracing(trace_config); { TRACE_EVENT1("v8", "v8.Test.aa", "aa", aa); TRACE_EVENT1("v8", "v8.Test.bb", "bb", bb); TRACE_EVENT1("v8", "v8.Test.cc", "cc", cc); TRACE_EVENT1("v8", "v8.Test.dd", "dd", dd); TRACE_EVENT1("v8", "v8.Test.ee", "ee", ee); TRACE_EVENT1("v8", "v8.Test.ff", "ff", ff); TRACE_EVENT1("v8", "v8.Test.gg", "gg", gg); TRACE_EVENT1("v8", "v8.Test.hh", "hh", hh); TRACE_EVENT1("v8", "v8.Test.ii", "ii1", ii1); TRACE_EVENT1("v8", "v8.Test.ii", "ii2", ii2); TRACE_EVENT1("v8", "v8.Test.jj1", "jj1", jj1); TRACE_EVENT1("v8", "v8.Test.jj2", "jj2", jj2); TRACE_EVENT1("v8", "v8.Test.jj3", "jj3", jj3); TRACE_EVENT1("v8", "v8.Test.jj4", "jj4", jj4); TRACE_EVENT1("v8", "v8.Test.jj5", "jj5", jj5); TRACE_EVENT1("v8", "v8.Test.kk", "kk", kk); TRACE_EVENT1("v8", "v8.Test.ll", "ll", ll); TRACE_EVENT1("v8", "v8.Test.mm", "mm", TRACE_STR_COPY(mmm.c_str())); TRACE_EVENT2("v8", "v8.Test2.1", "aa", aa, "ll", ll); TRACE_EVENT2("v8", "v8.Test2.2", "mm1", TRACE_STR_COPY(mm.c_str()), "mm2", TRACE_STR_COPY(mmm.c_str())); // Check copies are correct. TRACE_EVENT_COPY_INSTANT0("v8", mm.c_str(), TRACE_EVENT_SCOPE_THREAD); TRACE_EVENT_COPY_INSTANT2("v8", mm.c_str(), TRACE_EVENT_SCOPE_THREAD, "mm1", mm.c_str(), "mm2", mmm.c_str()); mm = "CHANGED"; mmm = "CHANGED"; TRACE_EVENT_INSTANT1("v8", "v8.Test", TRACE_EVENT_SCOPE_THREAD, "a1", new ConvertableToTraceFormatMock(42)); std::unique_ptr trace_event_arg( new ConvertableToTraceFormatMock(42)); TRACE_EVENT_INSTANT2("v8", "v8.Test", TRACE_EVENT_SCOPE_THREAD, "a1", std::move(trace_event_arg), "a2", new ConvertableToTraceFormatMock(123)); } tracing_controller->StopTracing(); i::V8::SetPlatformForTesting(old_platform); } std::string trace_str = stream.str(); std::vector all_args, all_names, all_cats; GetJSONStrings(&all_args, trace_str, "\"args\"", "{", "}"); GetJSONStrings(&all_names, trace_str, "\"name\"", "\"", "\""); GetJSONStrings(&all_cats, trace_str, "\"cat\"", "\"", "\""); CHECK_EQ(all_args.size(), 24u); CHECK_EQ(all_args[0], "\"aa\":11"); CHECK_EQ(all_args[1], "\"bb\":22"); CHECK_EQ(all_args[2], "\"cc\":33"); CHECK_EQ(all_args[3], "\"dd\":44"); CHECK_EQ(all_args[4], "\"ee\":-55"); CHECK_EQ(all_args[5], "\"ff\":-66"); CHECK_EQ(all_args[6], "\"gg\":-77"); CHECK_EQ(all_args[7], "\"hh\":-88"); CHECK_EQ(all_args[8], "\"ii1\":true"); CHECK_EQ(all_args[9], "\"ii2\":false"); CHECK_EQ(all_args[10], "\"jj1\":99.0"); CHECK_EQ(all_args[11], "\"jj2\":1e+100"); CHECK_EQ(all_args[12], "\"jj3\":\"NaN\""); CHECK_EQ(all_args[13], "\"jj4\":\"Infinity\""); CHECK_EQ(all_args[14], "\"jj5\":\"-Infinity\""); std::ostringstream pointer_stream; pointer_stream << "\"kk\":\"" << &aa << "\""; CHECK_EQ(all_args[15], pointer_stream.str()); CHECK_EQ(all_args[16], "\"ll\":\"100\""); CHECK_EQ(all_args[17], "\"mm\":\"\\\"INIT\\\"\""); CHECK_EQ(all_names[18], "v8.Test2.1"); CHECK_EQ(all_args[18], "\"aa\":11,\"ll\":\"100\""); CHECK_EQ(all_args[19], "\"mm1\":\"INIT\",\"mm2\":\"\\\"INIT\\\"\""); CHECK_EQ(all_names[20], "INIT"); CHECK_EQ(all_names[21], "INIT"); CHECK_EQ(all_args[21], "\"mm1\":\"INIT\",\"mm2\":\"\\\"INIT\\\"\""); CHECK_EQ(all_args[22], "\"a1\":[42,42]"); CHECK_EQ(all_args[23], "\"a1\":[42,42],\"a2\":[123,123]"); } #endif // !V8_USE_PERFETTO namespace { class TraceStateObserverImpl : public TracingController::TraceStateObserver { public: void OnTraceEnabled() override { ++enabled_count; } void OnTraceDisabled() override { ++disabled_count; } int enabled_count = 0; int disabled_count = 0; }; } // namespace TEST(TracingObservers) { v8::Platform* old_platform = i::V8::GetCurrentPlatform(); std::unique_ptr default_platform( v8::platform::NewDefaultPlatform()); i::V8::SetPlatformForTesting(default_platform.get()); auto tracing = base::make_unique(); v8::platform::tracing::TracingController* tracing_controller = tracing.get(); static_cast(default_platform.get()) ->SetTracingController(std::move(tracing)); MockTraceWriter* writer = new MockTraceWriter(); v8::platform::tracing::TraceBuffer* ring_buffer = v8::platform::tracing::TraceBuffer::CreateTraceBufferRingBuffer(1, writer); tracing_controller->Initialize(ring_buffer); #ifdef V8_USE_PERFETTO std::ostringstream sstream; tracing_controller->InitializeForPerfetto(&sstream); #endif v8::platform::tracing::TraceConfig* trace_config = new v8::platform::tracing::TraceConfig(); trace_config->AddIncludedCategory("v8"); TraceStateObserverImpl observer; tracing_controller->AddTraceStateObserver(&observer); CHECK_EQ(0, observer.enabled_count); CHECK_EQ(0, observer.disabled_count); tracing_controller->StartTracing(trace_config); CHECK_EQ(1, observer.enabled_count); CHECK_EQ(0, observer.disabled_count); TraceStateObserverImpl observer2; tracing_controller->AddTraceStateObserver(&observer2); CHECK_EQ(1, observer2.enabled_count); CHECK_EQ(0, observer2.disabled_count); tracing_controller->RemoveTraceStateObserver(&observer2); CHECK_EQ(1, observer2.enabled_count); CHECK_EQ(0, observer2.disabled_count); tracing_controller->StopTracing(); CHECK_EQ(1, observer.enabled_count); CHECK_EQ(1, observer.disabled_count); CHECK_EQ(1, observer2.enabled_count); CHECK_EQ(0, observer2.disabled_count); tracing_controller->RemoveTraceStateObserver(&observer); CHECK_EQ(1, observer.enabled_count); CHECK_EQ(1, observer.disabled_count); trace_config = new v8::platform::tracing::TraceConfig(); tracing_controller->StartTracing(trace_config); tracing_controller->StopTracing(); CHECK_EQ(1, observer.enabled_count); CHECK_EQ(1, observer.disabled_count); i::V8::SetPlatformForTesting(old_platform); } class TraceWritingThread : public base::Thread { public: TraceWritingThread( v8::platform::tracing::TracingController* tracing_controller) : base::Thread(base::Thread::Options("TraceWritingThread")), tracing_controller_(tracing_controller) {} void Run() override { running_.store(true); while (running_.load()) { TRACE_EVENT0("v8", "v8.Test"); tracing_controller_->AddTraceEvent('A', nullptr, "v8", "", 1, 1, 0, nullptr, nullptr, nullptr, nullptr, 0); tracing_controller_->AddTraceEventWithTimestamp('A', nullptr, "v8", "", 1, 1, 0, nullptr, nullptr, nullptr, nullptr, 0, 0); } } void Stop() { running_.store(false); } private: std::atomic_bool running_{false}; v8::platform::tracing::TracingController* tracing_controller_; }; TEST(AddTraceEventMultiThreaded) { v8::Platform* old_platform = i::V8::GetCurrentPlatform(); std::unique_ptr default_platform( v8::platform::NewDefaultPlatform()); i::V8::SetPlatformForTesting(default_platform.get()); auto tracing = base::make_unique(); v8::platform::tracing::TracingController* tracing_controller = tracing.get(); static_cast(default_platform.get()) ->SetTracingController(std::move(tracing)); MockTraceWriter* writer = new MockTraceWriter(); TraceBuffer* ring_buffer = TraceBuffer::CreateTraceBufferRingBuffer(1, writer); tracing_controller->Initialize(ring_buffer); #ifdef V8_USE_PERFETTO std::ostringstream sstream; tracing_controller->InitializeForPerfetto(&sstream); #endif TraceConfig* trace_config = new TraceConfig(); trace_config->AddIncludedCategory("v8"); tracing_controller->StartTracing(trace_config); TraceWritingThread thread(tracing_controller); thread.StartSynchronously(); TRACE_EVENT0("v8", "v8.Test2"); TRACE_EVENT0("v8", "v8.Test2"); base::OS::Sleep(base::TimeDelta::FromMilliseconds(10)); tracing_controller->StopTracing(); thread.Stop(); thread.Join(); i::V8::SetPlatformForTesting(old_platform); } #ifdef V8_USE_PERFETTO using TraceEvent = ::perfetto::protos::ChromeTraceEvent; class TestListener : public TraceEventListener { public: void ProcessPacket(const ::perfetto::protos::TracePacket& packet) { for (const ::perfetto::protos::ChromeTraceEvent& event : packet.chrome_events().trace_events()) { events_.push_back(event); } } TraceEvent* get_event(size_t index) { return &events_.at(index); } size_t events_size() const { return events_.size(); } private: std::vector events_; }; class TracingTestHarness { public: TracingTestHarness() { old_platform_ = i::V8::GetCurrentPlatform(); default_platform_ = v8::platform::NewDefaultPlatform(); i::V8::SetPlatformForTesting(default_platform_.get()); auto tracing = base::make_unique(); tracing_controller_ = tracing.get(); static_cast(default_platform_.get()) ->SetTracingController(std::move(tracing)); tracing_controller_->InitializeForPerfetto(&perfetto_json_stream_); tracing_controller_->SetTraceEventListenerForTesting(&listener_); } ~TracingTestHarness() { i::V8::SetPlatformForTesting(old_platform_); } void StartTracing() { TraceConfig* trace_config = new TraceConfig(); trace_config->AddIncludedCategory("v8"); tracing_controller_->StartTracing(trace_config); } void StopTracing() { tracing_controller_->StopTracing(); } TraceEvent* get_event(size_t index) { return listener_.get_event(index); } size_t events_size() const { return listener_.events_size(); } std::string perfetto_json_stream() { return perfetto_json_stream_.str(); } private: std::unique_ptr default_platform_; v8::Platform* old_platform_; v8::platform::tracing::TracingController* tracing_controller_; TestListener listener_; std::ostringstream perfetto_json_stream_; }; TEST(Perfetto) { TracingTestHarness harness; harness.StartTracing(); uint64_t uint64_arg = 1024; const char* str_arg = "str_arg"; { TRACE_EVENT0("v8", "test1"); TRACE_EVENT1("v8", "test2", "arg1", uint64_arg); TRACE_EVENT2("v8", "test3", "arg1", uint64_arg, "arg2", str_arg); } TRACE_EVENT_INSTANT0("v8", "final event not captured", TRACE_EVENT_SCOPE_THREAD); harness.StopTracing(); TraceEvent* event = harness.get_event(0); int32_t thread_id = event->thread_id(); int32_t process_id = event->process_id(); CHECK_EQ("test1", event->name()); CHECK_EQ(TRACE_EVENT_PHASE_BEGIN, event->phase()); int64_t timestamp = event->timestamp(); event = harness.get_event(1); CHECK_EQ("test2", event->name()); CHECK_EQ(TRACE_EVENT_PHASE_BEGIN, event->phase()); CHECK_EQ(thread_id, event->thread_id()); CHECK_EQ(process_id, event->process_id()); CHECK_GE(event->timestamp(), timestamp); timestamp = event->timestamp(); event = harness.get_event(2); CHECK_EQ("test3", event->name()); CHECK_EQ(TRACE_EVENT_PHASE_BEGIN, event->phase()); CHECK_EQ(thread_id, event->thread_id()); CHECK_EQ(process_id, event->process_id()); CHECK_GE(event->timestamp(), timestamp); timestamp = event->timestamp(); event = harness.get_event(3); CHECK_EQ(TRACE_EVENT_PHASE_END, event->phase()); CHECK_EQ(thread_id, event->thread_id()); CHECK_EQ(process_id, event->process_id()); CHECK_GE(event->timestamp(), timestamp); timestamp = event->timestamp(); event = harness.get_event(4); CHECK_EQ(TRACE_EVENT_PHASE_END, event->phase()); CHECK_EQ(thread_id, event->thread_id()); CHECK_EQ(process_id, event->process_id()); CHECK_GE(event->timestamp(), timestamp); timestamp = event->timestamp(); event = harness.get_event(5); CHECK_EQ(TRACE_EVENT_PHASE_END, event->phase()); CHECK_EQ(thread_id, event->thread_id()); CHECK_EQ(process_id, event->process_id()); CHECK_GE(event->timestamp(), timestamp); timestamp = event->timestamp(); CHECK_EQ(6, harness.events_size()); } // Replacement for 'TestTracingController' TEST(Categories) { TracingTestHarness harness; harness.StartTracing(); { TRACE_EVENT0("v8", "v8.Test"); // cat category is not included in default config TRACE_EVENT0("cat", "v8.Test2"); TRACE_EVENT0("v8", "v8.Test3"); } TRACE_EVENT_INSTANT0("v8", "final event not captured", TRACE_EVENT_SCOPE_THREAD); harness.StopTracing(); CHECK_EQ(4, harness.events_size()); TraceEvent* event = harness.get_event(0); CHECK_EQ("v8.Test", event->name()); event = harness.get_event(1); CHECK_EQ("v8.Test3", event->name()); } // Replacement for 'TestTracingControllerMultipleArgsAndCopy' TEST(MultipleArgsAndCopy) { uint64_t aa = 11; unsigned int bb = 22; uint16_t cc = 33; unsigned char dd = 44; int64_t ee = -55; int ff = -66; int16_t gg = -77; signed char hh = -88; bool ii1 = true; bool ii2 = false; double jj1 = 99.0; double jj2 = 1e100; double jj3 = std::numeric_limits::quiet_NaN(); double jj4 = std::numeric_limits::infinity(); double jj5 = -std::numeric_limits::infinity(); void* kk = &aa; const char* ll = "100"; std::string mm = "INIT"; std::string mmm = "\"INIT\""; TracingTestHarness harness; harness.StartTracing(); // Create a scope for the tracing controller to terminate the trace writer. { TRACE_EVENT1("v8", "v8.Test.aa", "aa", aa); TRACE_EVENT1("v8", "v8.Test.bb", "bb", bb); TRACE_EVENT1("v8", "v8.Test.cc", "cc", cc); TRACE_EVENT1("v8", "v8.Test.dd", "dd", dd); TRACE_EVENT1("v8", "v8.Test.ee", "ee", ee); TRACE_EVENT1("v8", "v8.Test.ff", "ff", ff); TRACE_EVENT1("v8", "v8.Test.gg", "gg", gg); TRACE_EVENT1("v8", "v8.Test.hh", "hh", hh); TRACE_EVENT1("v8", "v8.Test.ii", "ii1", ii1); TRACE_EVENT1("v8", "v8.Test.ii", "ii2", ii2); TRACE_EVENT1("v8", "v8.Test.jj1", "jj1", jj1); TRACE_EVENT1("v8", "v8.Test.jj2", "jj2", jj2); TRACE_EVENT1("v8", "v8.Test.jj3", "jj3", jj3); TRACE_EVENT1("v8", "v8.Test.jj4", "jj4", jj4); TRACE_EVENT1("v8", "v8.Test.jj5", "jj5", jj5); TRACE_EVENT1("v8", "v8.Test.kk", "kk", kk); TRACE_EVENT1("v8", "v8.Test.ll", "ll", ll); TRACE_EVENT1("v8", "v8.Test.mm", "mm", TRACE_STR_COPY(mmm.c_str())); TRACE_EVENT2("v8", "v8.Test2.1", "aa", aa, "ll", ll); TRACE_EVENT2("v8", "v8.Test2.2", "mm1", TRACE_STR_COPY(mm.c_str()), "mm2", TRACE_STR_COPY(mmm.c_str())); // Check copies are correct. TRACE_EVENT_COPY_INSTANT0("v8", mm.c_str(), TRACE_EVENT_SCOPE_THREAD); TRACE_EVENT_COPY_INSTANT2("v8", mm.c_str(), TRACE_EVENT_SCOPE_THREAD, "mm1", mm.c_str(), "mm2", mmm.c_str()); mm = "CHANGED"; mmm = "CHANGED"; TRACE_EVENT_INSTANT1("v8", "v8.Test", TRACE_EVENT_SCOPE_THREAD, "a1", new ConvertableToTraceFormatMock(42)); std::unique_ptr trace_event_arg( new ConvertableToTraceFormatMock(42)); TRACE_EVENT_INSTANT2("v8", "v8.Test", TRACE_EVENT_SCOPE_THREAD, "a1", std::move(trace_event_arg), "a2", new ConvertableToTraceFormatMock(123)); } TRACE_EVENT_INSTANT0("v8", "final event not captured", TRACE_EVENT_SCOPE_THREAD); harness.StopTracing(); // 20 START/END events, 4 INSTANT events. CHECK_EQ(44, harness.events_size()); TraceEvent* event = harness.get_event(0); CHECK_EQ("aa", event->args()[0].name()); CHECK_EQ(aa, event->args()[0].uint_value()); event = harness.get_event(1); CHECK_EQ("bb", event->args()[0].name()); CHECK_EQ(bb, event->args()[0].uint_value()); event = harness.get_event(2); CHECK_EQ("cc", event->args()[0].name()); CHECK_EQ(cc, event->args()[0].uint_value()); event = harness.get_event(3); CHECK_EQ("dd", event->args()[0].name()); CHECK_EQ(dd, event->args()[0].uint_value()); event = harness.get_event(4); CHECK_EQ("ee", event->args()[0].name()); CHECK_EQ(ee, event->args()[0].int_value()); event = harness.get_event(5); CHECK_EQ("ff", event->args()[0].name()); CHECK_EQ(ff, event->args()[0].int_value()); event = harness.get_event(6); CHECK_EQ("gg", event->args()[0].name()); CHECK_EQ(gg, event->args()[0].int_value()); event = harness.get_event(7); CHECK_EQ("hh", event->args()[0].name()); CHECK_EQ(hh, event->args()[0].int_value()); event = harness.get_event(8); CHECK_EQ("ii1", event->args()[0].name()); CHECK_EQ(ii1, event->args()[0].bool_value()); event = harness.get_event(9); CHECK_EQ("ii2", event->args()[0].name()); CHECK_EQ(ii2, event->args()[0].bool_value()); event = harness.get_event(10); CHECK_EQ("jj1", event->args()[0].name()); CHECK_EQ(jj1, event->args()[0].double_value()); event = harness.get_event(11); CHECK_EQ("jj2", event->args()[0].name()); CHECK_EQ(jj2, event->args()[0].double_value()); event = harness.get_event(12); CHECK_EQ("jj3", event->args()[0].name()); CHECK(std::isnan(event->args()[0].double_value())); event = harness.get_event(13); CHECK_EQ("jj4", event->args()[0].name()); CHECK_EQ(jj4, event->args()[0].double_value()); event = harness.get_event(14); CHECK_EQ("jj5", event->args()[0].name()); CHECK_EQ(jj5, event->args()[0].double_value()); event = harness.get_event(15); CHECK_EQ("kk", event->args()[0].name()); CHECK_EQ(kk, reinterpret_cast(event->args()[0].pointer_value())); event = harness.get_event(16); CHECK_EQ("ll", event->args()[0].name()); CHECK_EQ(ll, event->args()[0].string_value()); event = harness.get_event(17); CHECK_EQ("mm", event->args()[0].name()); CHECK_EQ("\"INIT\"", event->args()[0].string_value()); event = harness.get_event(18); CHECK_EQ("v8.Test2.1", event->name()); CHECK_EQ("aa", event->args()[0].name()); CHECK_EQ(aa, event->args()[0].uint_value()); CHECK_EQ("ll", event->args()[1].name()); CHECK_EQ(ll, event->args()[1].string_value()); event = harness.get_event(19); CHECK_EQ("mm1", event->args()[0].name()); CHECK_EQ("INIT", event->args()[0].string_value()); CHECK_EQ("mm2", event->args()[1].name()); CHECK_EQ("\"INIT\"", event->args()[1].string_value()); event = harness.get_event(20); CHECK_EQ("INIT", event->name()); event = harness.get_event(21); CHECK_EQ("INIT", event->name()); CHECK_EQ("mm1", event->args()[0].name()); CHECK_EQ("INIT", event->args()[0].string_value()); CHECK_EQ("mm2", event->args()[1].name()); CHECK_EQ("\"INIT\"", event->args()[1].string_value()); event = harness.get_event(22); CHECK_EQ("a1", event->args()[0].name()); CHECK_EQ("[42,42]", event->args()[0].json_value()); event = harness.get_event(23); CHECK_EQ("a1", event->args()[0].name()); CHECK_EQ("[42,42]", event->args()[0].json_value()); CHECK_EQ("a2", event->args()[1].name()); CHECK_EQ("[123,123]", event->args()[1].json_value()); } TEST(JsonIntegrationTest) { // Check that tricky values are rendered correctly in the JSON output. double big_num = 1e100; double nan_num = std::numeric_limits::quiet_NaN(); double inf_num = std::numeric_limits::infinity(); double neg_inf_num = -std::numeric_limits::infinity(); TracingTestHarness harness; harness.StartTracing(); { TRACE_EVENT1("v8", "v8.Test.1", "1", big_num); TRACE_EVENT1("v8", "v8.Test.2", "2", nan_num); TRACE_EVENT1("v8", "v8.Test.3", "3", inf_num); TRACE_EVENT1("v8", "v8.Test.4", "4", neg_inf_num); } TRACE_EVENT_INSTANT0("v8", "final event not captured", TRACE_EVENT_SCOPE_THREAD); harness.StopTracing(); std::string json = harness.perfetto_json_stream(); std::vector all_args; GetJSONStrings(&all_args, json, "\"args\"", "{", "}"); CHECK_EQ("\"1\":1e+100", all_args[0]); CHECK_EQ("\"2\":\"NaN\"", all_args[1]); CHECK_EQ("\"3\":\"Infinity\"", all_args[2]); CHECK_EQ("\"4\":\"-Infinity\"", all_args[3]); } TEST(TracingPerfetto) { ::perfetto::TraceConfig perfetto_trace_config; perfetto_trace_config.add_buffers()->set_size_kb(4096); auto* ds_config = perfetto_trace_config.add_data_sources()->mutable_config(); ds_config->set_name("v8.trace_events"); perfetto::DataSourceDescriptor dsd; dsd.set_name("v8.trace_events"); TestDataSource::Register(dsd); auto tracing_session_ = perfetto::Tracing::NewTrace(perfetto::BackendType::kInProcessBackend); tracing_session_->Setup(perfetto_trace_config); tracing_session_->Start(); TestDataSource::started_.Wait(); for (int i = 0; i < 15; i++) { TestDataSource::Trace([&](TestDataSource::TraceContext ctx) { auto packet = ctx.NewTracePacket(); auto* trace_event_bundle = packet->set_chrome_events(); auto* trace_event = trace_event_bundle->add_trace_events(); trace_event->set_phase('c'); trace_event->set_thread_id(v8::base::OS::GetCurrentThreadId()); trace_event->set_timestamp(123); trace_event->set_process_id(v8::base::OS::GetCurrentProcessId()); trace_event->set_thread_timestamp(123); }); } v8::base::Semaphore stopped_{0}; tracing_session_->SetOnStopCallback([&stopped_]() { stopped_.Signal(); }); tracing_session_->Stop(); stopped_.Wait(); std::ostringstream perfetto_json_stream_; { v8::platform::tracing::JSONTraceEventListener json_listener_( &perfetto_json_stream_); std::vector trace = tracing_session_->ReadTraceBlocking(); json_listener_.ParseFromArray(trace); } printf("%s\n", perfetto_json_stream_.str().c_str()); CHECK_GT(perfetto_json_stream_.str().length(), 0); } #endif // V8_USE_PERFETTO } // namespace tracing } // namespace platform } // namespace v8