OLD | NEW |
(Empty) | |
| 1 // Copyright 2016 the V8 project authors. All rights reserved. |
| 2 // Use of this source code is governed by a BSD-style license that can be |
| 3 // found in the LICENSE file. |
| 4 #include <stdio.h> |
| 5 |
| 6 #include "include/libplatform/v8-tracing.h" |
| 7 #include "src/tracing/trace-event.h" |
| 8 #include "test/cctest/cctest.h" |
| 9 |
| 10 namespace v8 { |
| 11 namespace platform { |
| 12 namespace tracing { |
| 13 |
| 14 const char* test_trace_config_str = |
| 15 "{\"record_mode\":\"record-until-full\",\"enable_sampling\":1,\"enable_" |
| 16 "systrace\":0,\"enable_argument_filter\":1,\"included_categories\":[\"v8." |
| 17 "cpu_profile\",\"v8.cpu_profile.hires\"],\"excluded_categories\":[\"v8." |
| 18 "runtime\"]}"; |
| 19 |
| 20 TEST(TestTraceConfigConstructor) { |
| 21 LocalContext env; |
| 22 TraceConfig* trace_config_from_JSON = TraceConfig::CreateTraceConfigFromJSON( |
| 23 env->GetIsolate(), test_trace_config_str); |
| 24 CHECK_EQ(trace_config_from_JSON->IsSamplingEnabled(), true); |
| 25 CHECK_EQ(trace_config_from_JSON->IsSystraceEnabled(), false); |
| 26 CHECK_EQ(trace_config_from_JSON->IsArgumentFilterEnabled(), true); |
| 27 CHECK_EQ(trace_config_from_JSON->IsCategoryGroupEnabled("v8"), false); |
| 28 CHECK_EQ(trace_config_from_JSON->IsCategoryGroupEnabled("v8.cpu_profile"), |
| 29 true); |
| 30 CHECK_EQ( |
| 31 trace_config_from_JSON->IsCategoryGroupEnabled("v8.cpu_profile.hires"), |
| 32 true); |
| 33 CHECK_EQ(trace_config_from_JSON->IsCategoryGroupEnabled("v8.runtime"), false); |
| 34 delete trace_config_from_JSON; |
| 35 |
| 36 TraceConfig* trace_config_default = TraceConfig::CreateDefaultTraceConfig(); |
| 37 CHECK_EQ(trace_config_default->IsSamplingEnabled(), false); |
| 38 CHECK_EQ(trace_config_default->IsSystraceEnabled(), false); |
| 39 CHECK_EQ(trace_config_default->IsArgumentFilterEnabled(), false); |
| 40 CHECK_EQ(trace_config_default->IsCategoryGroupEnabled("v8"), true); |
| 41 CHECK_EQ(trace_config_default->IsCategoryGroupEnabled("v8.cpu_profile"), |
| 42 false); |
| 43 CHECK_EQ(trace_config_default->IsCategoryGroupEnabled("v8.cpu_profile.hires"), |
| 44 false); |
| 45 CHECK_EQ(trace_config_default->IsCategoryGroupEnabled("v8.runtime"), false); |
| 46 delete trace_config_default; |
| 47 } |
| 48 |
| 49 TEST(TestTraceObject) { |
| 50 TraceObject trace_object; |
| 51 uint8_t category_enabled_flag = 41; |
| 52 trace_object.Initialize('X', &category_enabled_flag, "Test.Trace", |
| 53 "Test.Scope", 42, 123, 0, NULL, NULL, NULL, 0); |
| 54 CHECK_EQ('X', trace_object.phase()); |
| 55 CHECK_EQ(category_enabled_flag, *trace_object.category_enabled_flag()); |
| 56 CHECK_EQ("Test.Trace", trace_object.name()); |
| 57 CHECK_EQ("Test.Scope", trace_object.scope()); |
| 58 CHECK_EQ(0, trace_object.duration()); |
| 59 CHECK_EQ(0, trace_object.cpu_duration()); |
| 60 } |
| 61 |
| 62 class MockTraceWriter : public TraceWriter { |
| 63 public: |
| 64 void AppendTraceEvent(TraceObject* trace_event) override { |
| 65 events_.push_back(trace_event->name()); |
| 66 } |
| 67 |
| 68 void Flush() override {} |
| 69 |
| 70 std::vector<std::string> events() { return events_; } |
| 71 |
| 72 private: |
| 73 std::vector<std::string> events_; |
| 74 }; |
| 75 |
| 76 TEST(TestTraceBufferRingBuffer) { |
| 77 // We should be able to add kChunkSize * 2 + 1 trace events. |
| 78 const int HANDLES_COUNT = TraceBufferChunk::kChunkSize * 2 + 1; |
| 79 MockTraceWriter* writer = new MockTraceWriter(); |
| 80 TraceBuffer* ring_buffer = |
| 81 TraceBuffer::CreateTraceBufferRingBuffer(2, writer); |
| 82 std::string names[HANDLES_COUNT]; |
| 83 for (int i = 0; i < HANDLES_COUNT; ++i) { |
| 84 names[i] = "Test.EventNo" + std::to_string(i); |
| 85 } |
| 86 |
| 87 std::vector<uint64_t> handles(HANDLES_COUNT); |
| 88 uint8_t category_enabled_flag = 41; |
| 89 for (size_t i = 0; i < handles.size(); ++i) { |
| 90 TraceObject* trace_object = ring_buffer->AddTraceEvent(&handles[i]); |
| 91 CHECK_NOT_NULL(trace_object); |
| 92 trace_object->Initialize('X', &category_enabled_flag, names[i].c_str(), |
| 93 "Test.Scope", 42, 123, 0, NULL, NULL, NULL, 0); |
| 94 trace_object = ring_buffer->GetEventByHandle(handles[i]); |
| 95 CHECK_NOT_NULL(trace_object); |
| 96 CHECK_EQ('X', trace_object->phase()); |
| 97 CHECK_EQ(names[i].c_str(), trace_object->name()); |
| 98 CHECK_EQ(category_enabled_flag, *trace_object->category_enabled_flag()); |
| 99 } |
| 100 |
| 101 // We should only be able to retrieve the last kChunkSize + 1. |
| 102 for (size_t i = 0; i < TraceBufferChunk::kChunkSize; ++i) { |
| 103 CHECK_NULL(ring_buffer->GetEventByHandle(handles[i])); |
| 104 } |
| 105 |
| 106 for (size_t i = TraceBufferChunk::kChunkSize; i < handles.size(); ++i) { |
| 107 TraceObject* trace_object = ring_buffer->GetEventByHandle(handles[i]); |
| 108 CHECK_NOT_NULL(trace_object); |
| 109 // The object properties should be correct. |
| 110 CHECK_EQ('X', trace_object->phase()); |
| 111 CHECK_EQ(names[i], std::string(trace_object->name())); |
| 112 CHECK_EQ(category_enabled_flag, *trace_object->category_enabled_flag()); |
| 113 } |
| 114 |
| 115 // Check Flush(), that the writer wrote the last kChunkSize 1 event names. |
| 116 ring_buffer->Flush(); |
| 117 auto events = writer->events(); |
| 118 CHECK_EQ(TraceBufferChunk::kChunkSize + 1, events.size()); |
| 119 for (size_t i = TraceBufferChunk::kChunkSize; i < handles.size(); ++i) { |
| 120 CHECK_EQ(names[i], events[i - TraceBufferChunk::kChunkSize]); |
| 121 } |
| 122 delete ring_buffer; |
| 123 } |
| 124 |
| 125 TEST(TestJSONTraceWriter) { |
| 126 std::ostringstream stream; |
| 127 v8::Platform* old_platform = i::V8::GetCurrentPlatform(); |
| 128 v8::Platform* default_platform = v8::platform::CreateDefaultPlatform(); |
| 129 i::V8::SetPlatformForTesting(default_platform); |
| 130 // Create a scope for the tracing controller to terminate the trace writer. |
| 131 { |
| 132 TracingController tracing_controller; |
| 133 platform::SetTracingController(default_platform, &tracing_controller); |
| 134 TraceWriter* writer = TraceWriter::CreateJSONTraceWriter(stream); |
| 135 |
| 136 TraceBuffer* ring_buffer = |
| 137 TraceBuffer::CreateTraceBufferRingBuffer(1, writer); |
| 138 tracing_controller.Initialize(ring_buffer); |
| 139 tracing_controller.StartTracing(TraceConfig::CreateDefaultTraceConfig()); |
| 140 |
| 141 TraceObject trace_object; |
| 142 trace_object.InitializeForTesting( |
| 143 'X', tracing_controller.GetCategoryGroupEnabled("v8-cat"), "Test0", |
| 144 v8::internal::tracing::kGlobalScope, 42, 123, 0, NULL, NULL, NULL, 0, |
| 145 11, 22, 100, 50, 33, 44); |
| 146 writer->AppendTraceEvent(&trace_object); |
| 147 trace_object.InitializeForTesting( |
| 148 'Y', tracing_controller.GetCategoryGroupEnabled("v8-cat"), "Test1", |
| 149 v8::internal::tracing::kGlobalScope, 43, 456, 0, NULL, NULL, NULL, 0, |
| 150 55, 66, 110, 55, 77, 88); |
| 151 writer->AppendTraceEvent(&trace_object); |
| 152 tracing_controller.StopTracing(); |
| 153 } |
| 154 |
| 155 std::string trace_str = stream.str(); |
| 156 std::string expected_trace_str = |
| 157 "{\"traceEvents\":[{\"pid\":11,\"tid\":22,\"ts\":100,\"tts\":50," |
| 158 "\"ph\":\"X\",\"cat\":\"v8-cat\",\"name\":\"Test0\",\"args\":{}," |
| 159 "\"dur\":33,\"tdur\":44},{\"pid\":55,\"tid\":66,\"ts\":110,\"tts\":55," |
| 160 "\"ph\":\"Y\",\"cat\":\"v8-cat\",\"name\":\"Test1\",\"args\":{},\"dur\":" |
| 161 "77,\"tdur\":88}]}"; |
| 162 |
| 163 CHECK_EQ(expected_trace_str, trace_str); |
| 164 |
| 165 i::V8::SetPlatformForTesting(old_platform); |
| 166 } |
| 167 |
| 168 TEST(TestTracingController) { |
| 169 v8::Platform* old_platform = i::V8::GetCurrentPlatform(); |
| 170 v8::Platform* default_platform = v8::platform::CreateDefaultPlatform(); |
| 171 i::V8::SetPlatformForTesting(default_platform); |
| 172 |
| 173 TracingController tracing_controller; |
| 174 platform::SetTracingController(default_platform, &tracing_controller); |
| 175 |
| 176 MockTraceWriter* writer = new MockTraceWriter(); |
| 177 TraceBuffer* ring_buffer = |
| 178 TraceBuffer::CreateTraceBufferRingBuffer(1, writer); |
| 179 tracing_controller.Initialize(ring_buffer); |
| 180 tracing_controller.StartTracing(TraceConfig::CreateDefaultTraceConfig()); |
| 181 TRACE_EVENT0("v8", "v8.Test"); |
| 182 // cat category is not included in default config |
| 183 TRACE_EVENT0("cat", "v8.Test2"); |
| 184 TRACE_EVENT0("v8", "v8.Test3"); |
| 185 tracing_controller.StopTracing(); |
| 186 |
| 187 CHECK_EQ(2, writer->events().size()); |
| 188 CHECK_EQ("v8.Test", writer->events()[0]); |
| 189 CHECK_EQ("v8.Test3", writer->events()[1]); |
| 190 |
| 191 i::V8::SetPlatformForTesting(old_platform); |
| 192 } |
| 193 |
| 194 } // namespace tracing |
| 195 } // namespace platform |
| 196 } // namespace v8 |
OLD | NEW |