| // Copyright 2010 the V8 project authors. All rights reserved. |
| // Redistribution and use in source and binary forms, with or without |
| // modification, are permitted provided that the following conditions are |
| // met: |
| // |
| // * Redistributions of source code must retain the above copyright |
| // notice, this list of conditions and the following disclaimer. |
| // * Redistributions in binary form must reproduce the above |
| // copyright notice, this list of conditions and the following |
| // disclaimer in the documentation and/or other materials provided |
| // with the distribution. |
| // * Neither the name of Google Inc. nor the names of its |
| // contributors may be used to endorse or promote products derived |
| // from this software without specific prior written permission. |
| // |
| // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS |
| // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT |
| // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR |
| // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT |
| // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
| // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT |
| // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
| // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| // |
| // Tests of profiles generator and utilities. |
| |
| #define V8_DISABLE_DEPRECATIONS 1 |
| #include "v8.h" |
| #include "cpu-profiler-inl.h" |
| #include "cctest.h" |
| #include "platform.h" |
| #include "utils.h" |
| #include "../include/v8-profiler.h" |
| #undef V8_DISABLE_DEPRECATIONS |
| |
| using i::CodeEntry; |
| using i::CpuProfile; |
| using i::CpuProfiler; |
| using i::CpuProfilesCollection; |
| using i::ProfileGenerator; |
| using i::ProfileNode; |
| using i::ProfilerEventsProcessor; |
| using i::ScopedVector; |
| using i::TokenEnumerator; |
| using i::Vector; |
| |
| |
| TEST(StartStop) { |
| CpuProfilesCollection profiles; |
| ProfileGenerator generator(&profiles); |
| ProfilerEventsProcessor processor(&generator); |
| processor.Start(); |
| processor.Stop(); |
| processor.Join(); |
| } |
| |
| static inline i::Address ToAddress(int n) { |
| return reinterpret_cast<i::Address>(n); |
| } |
| |
| static void EnqueueTickSampleEvent(ProfilerEventsProcessor* proc, |
| i::Address frame1, |
| i::Address frame2 = NULL, |
| i::Address frame3 = NULL) { |
| i::TickSample* sample = proc->TickSampleEvent(); |
| sample->pc = frame1; |
| sample->tos = frame1; |
| sample->frames_count = 0; |
| if (frame2 != NULL) { |
| sample->stack[0] = frame2; |
| sample->frames_count = 1; |
| } |
| if (frame3 != NULL) { |
| sample->stack[1] = frame3; |
| sample->frames_count = 2; |
| } |
| } |
| |
| namespace { |
| |
| class TestSetup { |
| public: |
| TestSetup() |
| : old_flag_prof_browser_mode_(i::FLAG_prof_browser_mode) { |
| i::FLAG_prof_browser_mode = false; |
| } |
| |
| ~TestSetup() { |
| i::FLAG_prof_browser_mode = old_flag_prof_browser_mode_; |
| } |
| |
| private: |
| bool old_flag_prof_browser_mode_; |
| }; |
| |
| } // namespace |
| |
| |
| i::Code* CreateCode(LocalContext* env) { |
| static int counter = 0; |
| i::EmbeddedVector<char, 256> script; |
| i::EmbeddedVector<char, 32> name; |
| |
| i::OS::SNPrintF(name, "function_%d", ++counter); |
| const char* name_start = name.start(); |
| i::OS::SNPrintF(script, |
| "function %s() {\n" |
| "var counter = 0;\n" |
| "for (var i = 0; i < %d; ++i) counter += i;\n" |
| "return '%s_' + counter;\n" |
| "}\n" |
| "%s();\n", name_start, counter, name_start, name_start); |
| CompileRun(script.start()); |
| i::Handle<i::JSFunction> fun = v8::Utils::OpenHandle( |
| *v8::Local<v8::Function>::Cast( |
| (*env)->Global()->Get(v8_str(name_start)))); |
| return fun->code(); |
| } |
| |
| |
| TEST(CodeEvents) { |
| CcTest::InitializeVM(); |
| LocalContext env; |
| i::Isolate* isolate = i::Isolate::Current(); |
| i::Factory* factory = isolate->factory(); |
| TestSetup test_setup; |
| |
| i::HandleScope scope(isolate); |
| |
| i::Code* aaa_code = CreateCode(&env); |
| i::Code* comment_code = CreateCode(&env); |
| i::Code* args5_code = CreateCode(&env); |
| i::Code* comment2_code = CreateCode(&env); |
| i::Code* moved_code = CreateCode(&env); |
| i::Code* args3_code = CreateCode(&env); |
| i::Code* args4_code = CreateCode(&env); |
| |
| CpuProfilesCollection* profiles = new CpuProfilesCollection; |
| profiles->StartProfiling("", 1, false); |
| ProfileGenerator generator(profiles); |
| ProfilerEventsProcessor processor(&generator); |
| processor.Start(); |
| CpuProfiler profiler(isolate, profiles, &generator, &processor); |
| |
| // Enqueue code creation events. |
| const char* aaa_str = "aaa"; |
| i::Handle<i::String> aaa_name = factory->NewStringFromAscii( |
| i::Vector<const char>(aaa_str, i::StrLength(aaa_str))); |
| profiler.CodeCreateEvent(i::Logger::FUNCTION_TAG, aaa_code, *aaa_name); |
| profiler.CodeCreateEvent(i::Logger::BUILTIN_TAG, comment_code, "comment"); |
| profiler.CodeCreateEvent(i::Logger::STUB_TAG, args5_code, 5); |
| profiler.CodeCreateEvent(i::Logger::BUILTIN_TAG, comment2_code, "comment2"); |
| profiler.CodeMoveEvent(comment2_code->address(), moved_code->address()); |
| profiler.CodeCreateEvent(i::Logger::STUB_TAG, args3_code, 3); |
| profiler.CodeCreateEvent(i::Logger::STUB_TAG, args4_code, 4); |
| |
| // Enqueue a tick event to enable code events processing. |
| EnqueueTickSampleEvent(&processor, aaa_code->address()); |
| |
| processor.Stop(); |
| processor.Join(); |
| |
| // Check the state of profile generator. |
| CodeEntry* aaa = generator.code_map()->FindEntry(aaa_code->address()); |
| CHECK_NE(NULL, aaa); |
| CHECK_EQ(aaa_str, aaa->name()); |
| |
| CodeEntry* comment = generator.code_map()->FindEntry(comment_code->address()); |
| CHECK_NE(NULL, comment); |
| CHECK_EQ("comment", comment->name()); |
| |
| CodeEntry* args5 = generator.code_map()->FindEntry(args5_code->address()); |
| CHECK_NE(NULL, args5); |
| CHECK_EQ("5", args5->name()); |
| |
| CHECK_EQ(NULL, generator.code_map()->FindEntry(comment2_code->address())); |
| |
| CodeEntry* comment2 = generator.code_map()->FindEntry(moved_code->address()); |
| CHECK_NE(NULL, comment2); |
| CHECK_EQ("comment2", comment2->name()); |
| } |
| |
| |
| template<typename T> |
| static int CompareProfileNodes(const T* p1, const T* p2) { |
| return strcmp((*p1)->entry()->name(), (*p2)->entry()->name()); |
| } |
| |
| TEST(TickEvents) { |
| TestSetup test_setup; |
| LocalContext env; |
| i::Isolate* isolate = i::Isolate::Current(); |
| i::HandleScope scope(isolate); |
| |
| i::Code* frame1_code = CreateCode(&env); |
| i::Code* frame2_code = CreateCode(&env); |
| i::Code* frame3_code = CreateCode(&env); |
| |
| CpuProfilesCollection* profiles = new CpuProfilesCollection; |
| profiles->StartProfiling("", 1, false); |
| ProfileGenerator generator(profiles); |
| ProfilerEventsProcessor processor(&generator); |
| processor.Start(); |
| CpuProfiler profiler(isolate, profiles, &generator, &processor); |
| |
| profiler.CodeCreateEvent(i::Logger::BUILTIN_TAG, frame1_code, "bbb"); |
| profiler.CodeCreateEvent(i::Logger::STUB_TAG, frame2_code, 5); |
| profiler.CodeCreateEvent(i::Logger::BUILTIN_TAG, frame3_code, "ddd"); |
| |
| EnqueueTickSampleEvent(&processor, frame1_code->instruction_start()); |
| EnqueueTickSampleEvent( |
| &processor, |
| frame2_code->instruction_start() + frame2_code->ExecutableSize() / 2, |
| frame1_code->instruction_start() + frame2_code->ExecutableSize() / 2); |
| EnqueueTickSampleEvent( |
| &processor, |
| frame3_code->instruction_end() - 1, |
| frame2_code->instruction_end() - 1, |
| frame1_code->instruction_end() - 1); |
| |
| processor.Stop(); |
| processor.Join(); |
| CpuProfile* profile = |
| profiles->StopProfiling(TokenEnumerator::kNoSecurityToken, "", 1); |
| CHECK_NE(NULL, profile); |
| |
| // Check call trees. |
| const i::List<ProfileNode*>* top_down_root_children = |
| profile->top_down()->root()->children(); |
| CHECK_EQ(1, top_down_root_children->length()); |
| CHECK_EQ("bbb", top_down_root_children->last()->entry()->name()); |
| const i::List<ProfileNode*>* top_down_bbb_children = |
| top_down_root_children->last()->children(); |
| CHECK_EQ(1, top_down_bbb_children->length()); |
| CHECK_EQ("5", top_down_bbb_children->last()->entry()->name()); |
| const i::List<ProfileNode*>* top_down_stub_children = |
| top_down_bbb_children->last()->children(); |
| CHECK_EQ(1, top_down_stub_children->length()); |
| CHECK_EQ("ddd", top_down_stub_children->last()->entry()->name()); |
| const i::List<ProfileNode*>* top_down_ddd_children = |
| top_down_stub_children->last()->children(); |
| CHECK_EQ(0, top_down_ddd_children->length()); |
| } |
| |
| |
| // http://crbug/51594 |
| // This test must not crash. |
| TEST(CrashIfStoppingLastNonExistentProfile) { |
| CcTest::InitializeVM(); |
| TestSetup test_setup; |
| CpuProfiler* profiler = i::Isolate::Current()->cpu_profiler(); |
| profiler->StartProfiling("1"); |
| profiler->StopProfiling("2"); |
| profiler->StartProfiling("1"); |
| profiler->StopProfiling(""); |
| } |
| |
| |
| // http://code.google.com/p/v8/issues/detail?id=1398 |
| // Long stacks (exceeding max frames limit) must not be erased. |
| TEST(Issue1398) { |
| TestSetup test_setup; |
| LocalContext env; |
| i::Isolate* isolate = i::Isolate::Current(); |
| i::HandleScope scope(isolate); |
| |
| i::Code* code = CreateCode(&env); |
| |
| CpuProfilesCollection* profiles = new CpuProfilesCollection; |
| profiles->StartProfiling("", 1, false); |
| ProfileGenerator generator(profiles); |
| ProfilerEventsProcessor processor(&generator); |
| processor.Start(); |
| CpuProfiler profiler(isolate, profiles, &generator, &processor); |
| |
| profiler.CodeCreateEvent(i::Logger::BUILTIN_TAG, code, "bbb"); |
| |
| i::TickSample* sample = processor.TickSampleEvent(); |
| sample->pc = code->address(); |
| sample->tos = 0; |
| sample->frames_count = i::TickSample::kMaxFramesCount; |
| for (int i = 0; i < sample->frames_count; ++i) { |
| sample->stack[i] = code->address(); |
| } |
| |
| processor.Stop(); |
| processor.Join(); |
| CpuProfile* profile = |
| profiles->StopProfiling(TokenEnumerator::kNoSecurityToken, "", 1); |
| CHECK_NE(NULL, profile); |
| |
| int actual_depth = 0; |
| const ProfileNode* node = profile->top_down()->root(); |
| while (node->children()->length() > 0) { |
| node = node->children()->last(); |
| ++actual_depth; |
| } |
| |
| CHECK_EQ(1 + i::TickSample::kMaxFramesCount, actual_depth); // +1 for PC. |
| } |
| |
| |
| TEST(DeleteAllCpuProfiles) { |
| CcTest::InitializeVM(); |
| TestSetup test_setup; |
| CpuProfiler* profiler = i::Isolate::Current()->cpu_profiler(); |
| CHECK_EQ(0, profiler->GetProfilesCount()); |
| profiler->DeleteAllProfiles(); |
| CHECK_EQ(0, profiler->GetProfilesCount()); |
| |
| profiler->StartProfiling("1"); |
| profiler->StopProfiling("1"); |
| CHECK_EQ(1, profiler->GetProfilesCount()); |
| profiler->DeleteAllProfiles(); |
| CHECK_EQ(0, profiler->GetProfilesCount()); |
| profiler->StartProfiling("1"); |
| profiler->StartProfiling("2"); |
| profiler->StopProfiling("2"); |
| profiler->StopProfiling("1"); |
| CHECK_EQ(2, profiler->GetProfilesCount()); |
| profiler->DeleteAllProfiles(); |
| CHECK_EQ(0, profiler->GetProfilesCount()); |
| |
| // Test profiling cancellation by the 'delete' command. |
| profiler->StartProfiling("1"); |
| profiler->StartProfiling("2"); |
| CHECK_EQ(0, profiler->GetProfilesCount()); |
| profiler->DeleteAllProfiles(); |
| CHECK_EQ(0, profiler->GetProfilesCount()); |
| } |
| |
| |
| static const v8::CpuProfile* FindCpuProfile(v8::CpuProfiler* profiler, |
| unsigned uid) { |
| int length = profiler->GetProfileCount(); |
| for (int i = 0; i < length; i++) { |
| const v8::CpuProfile* profile = profiler->GetCpuProfile(i); |
| if (profile->GetUid() == uid) { |
| return profile; |
| } |
| } |
| return NULL; |
| } |
| |
| |
| TEST(DeleteCpuProfile) { |
| LocalContext env; |
| v8::HandleScope scope(env->GetIsolate()); |
| v8::CpuProfiler* cpu_profiler = env->GetIsolate()->GetCpuProfiler(); |
| |
| CHECK_EQ(0, cpu_profiler->GetProfileCount()); |
| v8::Local<v8::String> name1 = v8::String::New("1"); |
| cpu_profiler->StartCpuProfiling(name1); |
| const v8::CpuProfile* p1 = cpu_profiler->StopCpuProfiling(name1); |
| CHECK_NE(NULL, p1); |
| CHECK_EQ(1, cpu_profiler->GetProfileCount()); |
| unsigned uid1 = p1->GetUid(); |
| CHECK_EQ(p1, FindCpuProfile(cpu_profiler, uid1)); |
| const_cast<v8::CpuProfile*>(p1)->Delete(); |
| CHECK_EQ(0, cpu_profiler->GetProfileCount()); |
| CHECK_EQ(NULL, FindCpuProfile(cpu_profiler, uid1)); |
| |
| v8::Local<v8::String> name2 = v8::String::New("2"); |
| cpu_profiler->StartCpuProfiling(name2); |
| const v8::CpuProfile* p2 = cpu_profiler->StopCpuProfiling(name2); |
| CHECK_NE(NULL, p2); |
| CHECK_EQ(1, cpu_profiler->GetProfileCount()); |
| unsigned uid2 = p2->GetUid(); |
| CHECK_NE(static_cast<int>(uid1), static_cast<int>(uid2)); |
| CHECK_EQ(p2, FindCpuProfile(cpu_profiler, uid2)); |
| CHECK_EQ(NULL, FindCpuProfile(cpu_profiler, uid1)); |
| v8::Local<v8::String> name3 = v8::String::New("3"); |
| cpu_profiler->StartCpuProfiling(name3); |
| const v8::CpuProfile* p3 = cpu_profiler->StopCpuProfiling(name3); |
| CHECK_NE(NULL, p3); |
| CHECK_EQ(2, cpu_profiler->GetProfileCount()); |
| unsigned uid3 = p3->GetUid(); |
| CHECK_NE(static_cast<int>(uid1), static_cast<int>(uid3)); |
| CHECK_EQ(p3, FindCpuProfile(cpu_profiler, uid3)); |
| CHECK_EQ(NULL, FindCpuProfile(cpu_profiler, uid1)); |
| const_cast<v8::CpuProfile*>(p2)->Delete(); |
| CHECK_EQ(1, cpu_profiler->GetProfileCount()); |
| CHECK_EQ(NULL, FindCpuProfile(cpu_profiler, uid2)); |
| CHECK_EQ(p3, FindCpuProfile(cpu_profiler, uid3)); |
| const_cast<v8::CpuProfile*>(p3)->Delete(); |
| CHECK_EQ(0, cpu_profiler->GetProfileCount()); |
| CHECK_EQ(NULL, FindCpuProfile(cpu_profiler, uid3)); |
| CHECK_EQ(NULL, FindCpuProfile(cpu_profiler, uid2)); |
| CHECK_EQ(NULL, FindCpuProfile(cpu_profiler, uid1)); |
| } |
| |
| |
| TEST(DeleteCpuProfileDifferentTokens) { |
| LocalContext env; |
| v8::HandleScope scope(env->GetIsolate()); |
| v8::CpuProfiler* cpu_profiler = env->GetIsolate()->GetCpuProfiler(); |
| |
| CHECK_EQ(0, cpu_profiler->GetProfileCount()); |
| v8::Local<v8::String> name1 = v8::String::New("1"); |
| cpu_profiler->StartCpuProfiling(name1); |
| const v8::CpuProfile* p1 = cpu_profiler->StopCpuProfiling(name1); |
| CHECK_NE(NULL, p1); |
| CHECK_EQ(1, cpu_profiler->GetProfileCount()); |
| unsigned uid1 = p1->GetUid(); |
| CHECK_EQ(p1, cpu_profiler->FindCpuProfile(uid1)); |
| v8::Local<v8::String> token1 = v8::String::New("token1"); |
| const v8::CpuProfile* p1_t1 = cpu_profiler->FindCpuProfile(uid1, token1); |
| CHECK_NE(NULL, p1_t1); |
| CHECK_NE(p1, p1_t1); |
| CHECK_EQ(1, cpu_profiler->GetProfileCount()); |
| const_cast<v8::CpuProfile*>(p1)->Delete(); |
| CHECK_EQ(0, cpu_profiler->GetProfileCount()); |
| CHECK_EQ(NULL, cpu_profiler->FindCpuProfile(uid1)); |
| CHECK_EQ(NULL, cpu_profiler->FindCpuProfile(uid1, token1)); |
| const_cast<v8::CpuProfile*>(p1_t1)->Delete(); |
| CHECK_EQ(0, cpu_profiler->GetProfileCount()); |
| |
| v8::Local<v8::String> name2 = v8::String::New("2"); |
| cpu_profiler->StartCpuProfiling(name2); |
| v8::Local<v8::String> token2 = v8::String::New("token2"); |
| const v8::CpuProfile* p2_t2 = cpu_profiler->StopCpuProfiling(name2, token2); |
| CHECK_NE(NULL, p2_t2); |
| CHECK_EQ(1, cpu_profiler->GetProfileCount()); |
| unsigned uid2 = p2_t2->GetUid(); |
| CHECK_NE(static_cast<int>(uid1), static_cast<int>(uid2)); |
| const v8::CpuProfile* p2 = cpu_profiler->FindCpuProfile(uid2); |
| CHECK_NE(p2_t2, p2); |
| v8::Local<v8::String> name3 = v8::String::New("3"); |
| cpu_profiler->StartCpuProfiling(name3); |
| const v8::CpuProfile* p3 = cpu_profiler->StopCpuProfiling(name3); |
| CHECK_NE(NULL, p3); |
| CHECK_EQ(2, cpu_profiler->GetProfileCount()); |
| unsigned uid3 = p3->GetUid(); |
| CHECK_NE(static_cast<int>(uid1), static_cast<int>(uid3)); |
| CHECK_EQ(p3, cpu_profiler->FindCpuProfile(uid3)); |
| const_cast<v8::CpuProfile*>(p2_t2)->Delete(); |
| CHECK_EQ(1, cpu_profiler->GetProfileCount()); |
| CHECK_EQ(NULL, cpu_profiler->FindCpuProfile(uid2)); |
| CHECK_EQ(p3, cpu_profiler->FindCpuProfile(uid3)); |
| const_cast<v8::CpuProfile*>(p2)->Delete(); |
| CHECK_EQ(1, cpu_profiler->GetProfileCount()); |
| CHECK_EQ(NULL, cpu_profiler->FindCpuProfile(uid2)); |
| CHECK_EQ(p3, cpu_profiler->FindCpuProfile(uid3)); |
| const_cast<v8::CpuProfile*>(p3)->Delete(); |
| CHECK_EQ(0, cpu_profiler->GetProfileCount()); |
| CHECK_EQ(NULL, cpu_profiler->FindCpuProfile(uid3)); |
| } |
| |
| |
| TEST(GetProfilerWhenIsolateIsNotInitialized) { |
| v8::Isolate* isolate = v8::Isolate::GetCurrent(); |
| CHECK(i::Isolate::Current()->IsDefaultIsolate()); |
| CHECK(!i::Isolate::Current()->IsInitialized()); |
| CHECK_EQ(NULL, isolate->GetCpuProfiler()); |
| { |
| v8::Isolate::Scope isolateScope(isolate); |
| LocalContext env; |
| v8::HandleScope scope(isolate); |
| CHECK_NE(NULL, isolate->GetCpuProfiler()); |
| isolate->GetCpuProfiler()->StartCpuProfiling(v8::String::New("Test")); |
| isolate->GetCpuProfiler()->StopCpuProfiling(v8::String::New("Test")); |
| } |
| CHECK(i::Isolate::Current()->IsInitialized()); |
| CHECK_NE(NULL, isolate->GetCpuProfiler()); |
| isolate->Dispose(); |
| CHECK_EQ(NULL, isolate->GetCpuProfiler()); |
| } |
| |
| |
| static bool ContainsString(v8::Handle<v8::String> string, |
| const Vector<v8::Handle<v8::String> >& vector) { |
| for (int i = 0; i < vector.length(); i++) { |
| if (string->Equals(vector[i])) |
| return true; |
| } |
| return false; |
| } |
| |
| |
| static void CheckChildrenNames(const v8::CpuProfileNode* node, |
| const Vector<v8::Handle<v8::String> >& names) { |
| int count = node->GetChildrenCount(); |
| for (int i = 0; i < count; i++) { |
| v8::Handle<v8::String> name = node->GetChild(i)->GetFunctionName(); |
| CHECK(ContainsString(name, names)); |
| // Check that there are no duplicates. |
| for (int j = 0; j < count; j++) { |
| if (j == i) continue; |
| CHECK_NE(name, node->GetChild(j)->GetFunctionName()); |
| } |
| } |
| } |
| |
| |
| static const v8::CpuProfileNode* FindChild(const v8::CpuProfileNode* node, |
| const char* name) { |
| int count = node->GetChildrenCount(); |
| v8::Handle<v8::String> nameHandle = v8::String::New(name); |
| for (int i = 0; i < count; i++) { |
| const v8::CpuProfileNode* child = node->GetChild(i); |
| if (nameHandle->Equals(child->GetFunctionName())) return child; |
| } |
| return NULL; |
| } |
| |
| |
| static const v8::CpuProfileNode* GetChild(const v8::CpuProfileNode* node, |
| const char* name) { |
| const v8::CpuProfileNode* result = FindChild(node, name); |
| CHECK(result); |
| return result; |
| } |
| |
| |
| static void CheckSimpleBranch(const v8::CpuProfileNode* node, |
| const char* names[], int length) { |
| for (int i = 0; i < length; i++) { |
| const char* name = names[i]; |
| node = GetChild(node, name); |
| int expectedChildrenCount = (i == length - 1) ? 0 : 1; |
| CHECK_EQ(expectedChildrenCount, node->GetChildrenCount()); |
| } |
| } |
| |
| |
| static const char* cpu_profiler_test_source = "function loop(timeout) {\n" |
| " this.mmm = 0;\n" |
| " var start = Date.now();\n" |
| " while (Date.now() - start < timeout) {\n" |
| " var n = 100*1000;\n" |
| " while(n > 1) {\n" |
| " n--;\n" |
| " this.mmm += n * n * n;\n" |
| " }\n" |
| " }\n" |
| "}\n" |
| "function delay() { try { loop(10); } catch(e) { } }\n" |
| "function bar() { delay(); }\n" |
| "function baz() { delay(); }\n" |
| "function foo() {\n" |
| " try {\n" |
| " delay();\n" |
| " bar();\n" |
| " delay();\n" |
| " baz();\n" |
| " } catch (e) { }\n" |
| "}\n" |
| "function start(timeout) {\n" |
| " var start = Date.now();\n" |
| " do {\n" |
| " foo();\n" |
| " var duration = Date.now() - start;\n" |
| " } while (duration < timeout);\n" |
| " return duration;\n" |
| "}\n"; |
| |
| |
| // Check that the profile tree for the script above will look like the |
| // following: |
| // |
| // [Top down]: |
| // 1062 0 (root) [-1] |
| // 1054 0 start [-1] |
| // 1054 1 foo [-1] |
| // 265 0 baz [-1] |
| // 265 1 delay [-1] |
| // 264 264 loop [-1] |
| // 525 3 delay [-1] |
| // 522 522 loop [-1] |
| // 263 0 bar [-1] |
| // 263 1 delay [-1] |
| // 262 262 loop [-1] |
| // 2 2 (program) [-1] |
| // 6 6 (garbage collector) [-1] |
| TEST(CollectCpuProfile) { |
| LocalContext env; |
| v8::HandleScope scope(env->GetIsolate()); |
| |
| v8::Script::Compile(v8::String::New(cpu_profiler_test_source))->Run(); |
| v8::Local<v8::Function> function = v8::Local<v8::Function>::Cast( |
| env->Global()->Get(v8::String::New("start"))); |
| |
| v8::CpuProfiler* cpu_profiler = env->GetIsolate()->GetCpuProfiler(); |
| v8::Local<v8::String> profile_name = v8::String::New("my_profile"); |
| |
| cpu_profiler->StartCpuProfiling(profile_name); |
| int32_t profiling_interval_ms = 200; |
| #if defined(_WIN32) || defined(_WIN64) |
| // 200ms is not enough on Windows. See |
| // https://code.google.com/p/v8/issues/detail?id=2628 |
| profiling_interval_ms = 500; |
| #endif |
| v8::Handle<v8::Value> args[] = { v8::Integer::New(profiling_interval_ms) }; |
| function->Call(env->Global(), ARRAY_SIZE(args), args); |
| const v8::CpuProfile* profile = cpu_profiler->StopCpuProfiling(profile_name); |
| |
| CHECK_NE(NULL, profile); |
| // Dump collected profile to have a better diagnostic in case of failure. |
| reinterpret_cast<i::CpuProfile*>( |
| const_cast<v8::CpuProfile*>(profile))->Print(); |
| |
| const v8::CpuProfileNode* root = profile->GetTopDownRoot(); |
| |
| ScopedVector<v8::Handle<v8::String> > names(3); |
| names[0] = v8::String::New(ProfileGenerator::kGarbageCollectorEntryName); |
| names[1] = v8::String::New(ProfileGenerator::kProgramEntryName); |
| names[2] = v8::String::New("start"); |
| CheckChildrenNames(root, names); |
| |
| const v8::CpuProfileNode* startNode = GetChild(root, "start"); |
| CHECK_EQ(1, startNode->GetChildrenCount()); |
| |
| const v8::CpuProfileNode* fooNode = GetChild(startNode, "foo"); |
| CHECK_EQ(3, fooNode->GetChildrenCount()); |
| |
| const char* barBranch[] = { "bar", "delay", "loop" }; |
| CheckSimpleBranch(fooNode, barBranch, ARRAY_SIZE(barBranch)); |
| const char* bazBranch[] = { "baz", "delay", "loop" }; |
| CheckSimpleBranch(fooNode, bazBranch, ARRAY_SIZE(bazBranch)); |
| const char* delayBranch[] = { "delay", "loop" }; |
| CheckSimpleBranch(fooNode, delayBranch, ARRAY_SIZE(delayBranch)); |
| |
| cpu_profiler->DeleteAllCpuProfiles(); |
| } |
| |
| |
| |
| static const char* cpu_profiler_test_source2 = "function loop() {}\n" |
| "function delay() { loop(); }\n" |
| "function start(count) {\n" |
| " var k = 0;\n" |
| " do {\n" |
| " delay();\n" |
| " } while (++k < count*100*1000);\n" |
| "}\n"; |
| |
| // Check that the profile tree doesn't contain unexpecte traces: |
| // - 'loop' can be called only by 'delay' |
| // - 'delay' may be called only by 'start' |
| // The profile will look like the following: |
| // |
| // [Top down]: |
| // 135 0 (root) [-1] #1 |
| // 121 72 start [-1] #3 |
| // 49 33 delay [-1] #4 |
| // 16 16 loop [-1] #5 |
| // 14 14 (program) [-1] #2 |
| TEST(SampleWhenFrameIsNotSetup) { |
| LocalContext env; |
| v8::HandleScope scope(env->GetIsolate()); |
| |
| v8::Script::Compile(v8::String::New(cpu_profiler_test_source2))->Run(); |
| v8::Local<v8::Function> function = v8::Local<v8::Function>::Cast( |
| env->Global()->Get(v8::String::New("start"))); |
| |
| v8::CpuProfiler* cpu_profiler = env->GetIsolate()->GetCpuProfiler(); |
| v8::Local<v8::String> profile_name = v8::String::New("my_profile"); |
| |
| cpu_profiler->StartCpuProfiling(profile_name); |
| int32_t repeat_count = 100; |
| #if defined(USE_SIMULATOR) |
| // Simulators are much slower. |
| repeat_count = 1; |
| #endif |
| v8::Handle<v8::Value> args[] = { v8::Integer::New(repeat_count) }; |
| function->Call(env->Global(), ARRAY_SIZE(args), args); |
| const v8::CpuProfile* profile = cpu_profiler->StopCpuProfiling(profile_name); |
| |
| CHECK_NE(NULL, profile); |
| // Dump collected profile to have a better diagnostic in case of failure. |
| reinterpret_cast<i::CpuProfile*>( |
| const_cast<v8::CpuProfile*>(profile))->Print(); |
| |
| const v8::CpuProfileNode* root = profile->GetTopDownRoot(); |
| |
| ScopedVector<v8::Handle<v8::String> > names(3); |
| names[0] = v8::String::New(ProfileGenerator::kGarbageCollectorEntryName); |
| names[1] = v8::String::New(ProfileGenerator::kProgramEntryName); |
| names[2] = v8::String::New("start"); |
| CheckChildrenNames(root, names); |
| |
| const v8::CpuProfileNode* startNode = FindChild(root, "start"); |
| // On slow machines there may be no meaningfull samples at all, skip the |
| // check there. |
| if (startNode && startNode->GetChildrenCount() > 0) { |
| CHECK_EQ(1, startNode->GetChildrenCount()); |
| const v8::CpuProfileNode* delayNode = GetChild(startNode, "delay"); |
| if (delayNode->GetChildrenCount() > 0) { |
| CHECK_EQ(1, delayNode->GetChildrenCount()); |
| GetChild(delayNode, "loop"); |
| } |
| } |
| |
| cpu_profiler->DeleteAllCpuProfiles(); |
| } |
| |
| |
| static const char* native_accessor_test_source = "function start(count) {\n" |
| " for (var i = 0; i < count; i++) {\n" |
| " var o = instance.foo;\n" |
| " instance.foo = o + 1;\n" |
| " }\n" |
| "}\n"; |
| |
| |
| class TestApiCallbacks { |
| public: |
| explicit TestApiCallbacks(int min_duration_ms) |
| : min_duration_ms_(min_duration_ms), |
| is_warming_up_(false) {} |
| |
| static v8::Handle<v8::Value> Getter(v8::Local<v8::String> name, |
| const v8::AccessorInfo& info) { |
| TestApiCallbacks* data = fromInfo(info); |
| data->Wait(); |
| return v8::Int32::New(2013); |
| } |
| |
| static void Setter(v8::Local<v8::String> name, |
| v8::Local<v8::Value> value, |
| const v8::AccessorInfo& info) { |
| TestApiCallbacks* data = fromInfo(info); |
| data->Wait(); |
| } |
| |
| static void Callback(const v8::FunctionCallbackInfo<v8::Value>& info) { |
| TestApiCallbacks* data = fromInfo(info); |
| data->Wait(); |
| } |
| |
| void set_warming_up(bool value) { is_warming_up_ = value; } |
| |
| private: |
| void Wait() { |
| if (is_warming_up_) return; |
| double start = i::OS::TimeCurrentMillis(); |
| double duration = 0; |
| while (duration < min_duration_ms_) { |
| i::OS::Sleep(1); |
| duration = i::OS::TimeCurrentMillis() - start; |
| } |
| } |
| |
| static TestApiCallbacks* fromInfo(const v8::AccessorInfo& info) { |
| void* data = v8::External::Cast(*info.Data())->Value(); |
| return reinterpret_cast<TestApiCallbacks*>(data); |
| } |
| |
| static TestApiCallbacks* fromInfo( |
| const v8::FunctionCallbackInfo<v8::Value>& info) { |
| void* data = v8::External::Cast(*info.Data())->Value(); |
| return reinterpret_cast<TestApiCallbacks*>(data); |
| } |
| |
| int min_duration_ms_; |
| bool is_warming_up_; |
| }; |
| |
| |
| // Test that native accessors are properly reported in the CPU profile. |
| // This test checks the case when the long-running accessors are called |
| // only once and the optimizer doesn't have chance to change the invocation |
| // code. |
| TEST(NativeAccessorUninitializedIC) { |
| LocalContext env; |
| v8::HandleScope scope(env->GetIsolate()); |
| |
| |
| v8::Local<v8::FunctionTemplate> func_template = v8::FunctionTemplate::New(); |
| v8::Local<v8::ObjectTemplate> instance_template = |
| func_template->InstanceTemplate(); |
| |
| TestApiCallbacks accessors(100); |
| v8::Local<v8::External> data = v8::External::New(&accessors); |
| instance_template->SetAccessor( |
| v8::String::New("foo"), &TestApiCallbacks::Getter, |
| &TestApiCallbacks::Setter, data); |
| v8::Local<v8::Function> func = func_template->GetFunction(); |
| v8::Local<v8::Object> instance = func->NewInstance(); |
| env->Global()->Set(v8::String::New("instance"), instance); |
| |
| v8::Script::Compile(v8::String::New(native_accessor_test_source))->Run(); |
| v8::Local<v8::Function> function = v8::Local<v8::Function>::Cast( |
| env->Global()->Get(v8::String::New("start"))); |
| |
| v8::CpuProfiler* cpu_profiler = env->GetIsolate()->GetCpuProfiler(); |
| v8::Local<v8::String> profile_name = v8::String::New("my_profile"); |
| |
| cpu_profiler->StartCpuProfiling(profile_name); |
| int32_t repeat_count = 1; |
| v8::Handle<v8::Value> args[] = { v8::Integer::New(repeat_count) }; |
| function->Call(env->Global(), ARRAY_SIZE(args), args); |
| const v8::CpuProfile* profile = cpu_profiler->StopCpuProfiling(profile_name); |
| |
| CHECK_NE(NULL, profile); |
| // Dump collected profile to have a better diagnostic in case of failure. |
| reinterpret_cast<i::CpuProfile*>( |
| const_cast<v8::CpuProfile*>(profile))->Print(); |
| |
| const v8::CpuProfileNode* root = profile->GetTopDownRoot(); |
| const v8::CpuProfileNode* startNode = GetChild(root, "start"); |
| GetChild(startNode, "get foo"); |
| GetChild(startNode, "set foo"); |
| |
| cpu_profiler->DeleteAllCpuProfiles(); |
| } |
| |
| |
| // Test that native accessors are properly reported in the CPU profile. |
| // This test makes sure that the accessors are called enough times to become |
| // hot and to trigger optimizations. |
| TEST(NativeAccessorMonomorphicIC) { |
| LocalContext env; |
| v8::HandleScope scope(env->GetIsolate()); |
| |
| |
| v8::Local<v8::FunctionTemplate> func_template = v8::FunctionTemplate::New(); |
| v8::Local<v8::ObjectTemplate> instance_template = |
| func_template->InstanceTemplate(); |
| |
| TestApiCallbacks accessors(1); |
| v8::Local<v8::External> data = v8::External::New(&accessors); |
| instance_template->SetAccessor( |
| v8::String::New("foo"), &TestApiCallbacks::Getter, |
| &TestApiCallbacks::Setter, data); |
| v8::Local<v8::Function> func = func_template->GetFunction(); |
| v8::Local<v8::Object> instance = func->NewInstance(); |
| env->Global()->Set(v8::String::New("instance"), instance); |
| |
| v8::Script::Compile(v8::String::New(native_accessor_test_source))->Run(); |
| v8::Local<v8::Function> function = v8::Local<v8::Function>::Cast( |
| env->Global()->Get(v8::String::New("start"))); |
| |
| { |
| // Make sure accessors ICs are in monomorphic state before starting |
| // profiling. |
| accessors.set_warming_up(true); |
| int32_t warm_up_iterations = 3; |
| v8::Handle<v8::Value> args[] = { v8::Integer::New(warm_up_iterations) }; |
| function->Call(env->Global(), ARRAY_SIZE(args), args); |
| accessors.set_warming_up(false); |
| } |
| |
| v8::CpuProfiler* cpu_profiler = env->GetIsolate()->GetCpuProfiler(); |
| v8::Local<v8::String> profile_name = v8::String::New("my_profile"); |
| |
| cpu_profiler->StartCpuProfiling(profile_name); |
| int32_t repeat_count = 100; |
| v8::Handle<v8::Value> args[] = { v8::Integer::New(repeat_count) }; |
| function->Call(env->Global(), ARRAY_SIZE(args), args); |
| const v8::CpuProfile* profile = cpu_profiler->StopCpuProfiling(profile_name); |
| |
| CHECK_NE(NULL, profile); |
| // Dump collected profile to have a better diagnostic in case of failure. |
| reinterpret_cast<i::CpuProfile*>( |
| const_cast<v8::CpuProfile*>(profile))->Print(); |
| |
| const v8::CpuProfileNode* root = profile->GetTopDownRoot(); |
| const v8::CpuProfileNode* startNode = GetChild(root, "start"); |
| GetChild(startNode, "get foo"); |
| GetChild(startNode, "set foo"); |
| |
| cpu_profiler->DeleteAllCpuProfiles(); |
| } |
| |
| |
| static const char* native_method_test_source = "function start(count) {\n" |
| " for (var i = 0; i < count; i++) {\n" |
| " instance.fooMethod();\n" |
| " }\n" |
| "}\n"; |
| |
| |
| TEST(NativeMethodUninitializedIC) { |
| LocalContext env; |
| v8::HandleScope scope(env->GetIsolate()); |
| |
| TestApiCallbacks callbacks(100); |
| v8::Local<v8::External> data = v8::External::New(&callbacks); |
| |
| v8::Local<v8::FunctionTemplate> func_template = v8::FunctionTemplate::New(); |
| func_template->SetClassName(v8::String::New("Test_InstanceCostructor")); |
| v8::Local<v8::ObjectTemplate> proto_template = |
| func_template->PrototypeTemplate(); |
| v8::Local<v8::Signature> signature = v8::Signature::New(func_template); |
| proto_template->Set(v8::String::New("fooMethod"), v8::FunctionTemplate::New( |
| &TestApiCallbacks::Callback, data, signature, 0)); |
| |
| v8::Local<v8::Function> func = func_template->GetFunction(); |
| v8::Local<v8::Object> instance = func->NewInstance(); |
| env->Global()->Set(v8::String::New("instance"), instance); |
| |
| v8::Script::Compile(v8::String::New(native_method_test_source))->Run(); |
| v8::Local<v8::Function> function = v8::Local<v8::Function>::Cast( |
| env->Global()->Get(v8::String::New("start"))); |
| |
| v8::CpuProfiler* cpu_profiler = env->GetIsolate()->GetCpuProfiler(); |
| v8::Local<v8::String> profile_name = v8::String::New("my_profile"); |
| |
| cpu_profiler->StartCpuProfiling(profile_name); |
| int32_t repeat_count = 1; |
| v8::Handle<v8::Value> args[] = { v8::Integer::New(repeat_count) }; |
| function->Call(env->Global(), ARRAY_SIZE(args), args); |
| const v8::CpuProfile* profile = cpu_profiler->StopCpuProfiling(profile_name); |
| |
| CHECK_NE(NULL, profile); |
| // Dump collected profile to have a better diagnostic in case of failure. |
| reinterpret_cast<i::CpuProfile*>( |
| const_cast<v8::CpuProfile*>(profile))->Print(); |
| |
| const v8::CpuProfileNode* root = profile->GetTopDownRoot(); |
| const v8::CpuProfileNode* startNode = GetChild(root, "start"); |
| GetChild(startNode, "fooMethod"); |
| |
| cpu_profiler->DeleteAllCpuProfiles(); |
| } |
| |
| |
| TEST(NativeMethodMonomorphicIC) { |
| LocalContext env; |
| v8::HandleScope scope(env->GetIsolate()); |
| |
| TestApiCallbacks callbacks(1); |
| v8::Local<v8::External> data = v8::External::New(&callbacks); |
| |
| v8::Local<v8::FunctionTemplate> func_template = v8::FunctionTemplate::New(); |
| func_template->SetClassName(v8::String::New("Test_InstanceCostructor")); |
| v8::Local<v8::ObjectTemplate> proto_template = |
| func_template->PrototypeTemplate(); |
| v8::Local<v8::Signature> signature = v8::Signature::New(func_template); |
| proto_template->Set(v8::String::New("fooMethod"), v8::FunctionTemplate::New( |
| &TestApiCallbacks::Callback, data, signature, 0)); |
| |
| v8::Local<v8::Function> func = func_template->GetFunction(); |
| v8::Local<v8::Object> instance = func->NewInstance(); |
| env->Global()->Set(v8::String::New("instance"), instance); |
| |
| v8::Script::Compile(v8::String::New(native_method_test_source))->Run(); |
| v8::Local<v8::Function> function = v8::Local<v8::Function>::Cast( |
| env->Global()->Get(v8::String::New("start"))); |
| { |
| // Make sure method ICs are in monomorphic state before starting |
| // profiling. |
| callbacks.set_warming_up(true); |
| int32_t warm_up_iterations = 3; |
| v8::Handle<v8::Value> args[] = { v8::Integer::New(warm_up_iterations) }; |
| function->Call(env->Global(), ARRAY_SIZE(args), args); |
| callbacks.set_warming_up(false); |
| } |
| |
| v8::CpuProfiler* cpu_profiler = env->GetIsolate()->GetCpuProfiler(); |
| v8::Local<v8::String> profile_name = v8::String::New("my_profile"); |
| |
| cpu_profiler->StartCpuProfiling(profile_name); |
| int32_t repeat_count = 100; |
| v8::Handle<v8::Value> args[] = { v8::Integer::New(repeat_count) }; |
| function->Call(env->Global(), ARRAY_SIZE(args), args); |
| const v8::CpuProfile* profile = cpu_profiler->StopCpuProfiling(profile_name); |
| |
| CHECK_NE(NULL, profile); |
| // Dump collected profile to have a better diagnostic in case of failure. |
| reinterpret_cast<i::CpuProfile*>( |
| const_cast<v8::CpuProfile*>(profile))->Print(); |
| |
| const v8::CpuProfileNode* root = profile->GetTopDownRoot(); |
| GetChild(root, "start"); |
| const v8::CpuProfileNode* startNode = GetChild(root, "start"); |
| GetChild(startNode, "fooMethod"); |
| |
| cpu_profiler->DeleteAllCpuProfiles(); |
| } |
| |
| |
| static const char* bound_function_test_source = "function foo(iterations) {\n" |
| " var r = 0;\n" |
| " for (var i = 0; i < iterations; i++) { r += i; }\n" |
| " return r;\n" |
| "}\n" |
| "function start(duration) {\n" |
| " var callback = foo.bind(this);\n" |
| " var start = Date.now();\n" |
| " while (Date.now() - start < duration) {\n" |
| " callback(10 * 1000);\n" |
| " }\n" |
| "}"; |
| |
| |
| TEST(BoundFunctionCall) { |
| LocalContext env; |
| v8::HandleScope scope(env->GetIsolate()); |
| |
| v8::Script::Compile(v8::String::New(bound_function_test_source))->Run(); |
| v8::Local<v8::Function> function = v8::Local<v8::Function>::Cast( |
| env->Global()->Get(v8::String::New("start"))); |
| |
| v8::CpuProfiler* cpu_profiler = env->GetIsolate()->GetCpuProfiler(); |
| v8::Local<v8::String> profile_name = v8::String::New("my_profile"); |
| |
| cpu_profiler->StartCpuProfiling(profile_name); |
| int32_t duration_ms = 100; |
| v8::Handle<v8::Value> args[] = { v8::Integer::New(duration_ms) }; |
| function->Call(env->Global(), ARRAY_SIZE(args), args); |
| const v8::CpuProfile* profile = cpu_profiler->StopCpuProfiling(profile_name); |
| |
| CHECK_NE(NULL, profile); |
| // Dump collected profile to have a better diagnostic in case of failure. |
| reinterpret_cast<i::CpuProfile*>( |
| const_cast<v8::CpuProfile*>(profile))->Print(); |
| |
| const v8::CpuProfileNode* root = profile->GetTopDownRoot(); |
| ScopedVector<v8::Handle<v8::String> > names(3); |
| names[0] = v8::String::New(ProfileGenerator::kGarbageCollectorEntryName); |
| names[1] = v8::String::New(ProfileGenerator::kProgramEntryName); |
| names[2] = v8::String::New("start"); |
| // Don't allow |foo| node to be at the top level. |
| CheckChildrenNames(root, names); |
| |
| const v8::CpuProfileNode* startNode = GetChild(root, "start"); |
| GetChild(startNode, "foo"); |
| |
| cpu_profiler->DeleteAllCpuProfiles(); |
| } |
| |
| |
| static const char* call_function_test_source = "function bar(iterations) {\n" |
| "}\n" |
| "function start(duration) {\n" |
| " var start = Date.now();\n" |
| " while (Date.now() - start < duration) {\n" |
| " try {\n" |
| " bar.call(this, 10 * 1000);\n" |
| " } catch(e) {}\n" |
| " }\n" |
| "}"; |
| |
| |
| // Test that if we sampled thread when it was inside FunctionCall buitin then |
| // its caller frame will be '(unresolved function)' as we have no reliable way |
| // to resolve it. |
| // |
| // [Top down]: |
| // 96 0 (root) [-1] #1 |
| // 1 1 (garbage collector) [-1] #4 |
| // 5 0 (unresolved function) [-1] #5 |
| // 5 5 call [-1] #6 |
| // 71 70 start [-1] #3 |
| // 1 1 bar [-1] #7 |
| // 19 19 (program) [-1] #2 |
| TEST(FunctionCallSample) { |
| LocalContext env; |
| v8::HandleScope scope(env->GetIsolate()); |
| |
| v8::Script::Compile(v8::String::New(call_function_test_source))->Run(); |
| v8::Local<v8::Function> function = v8::Local<v8::Function>::Cast( |
| env->Global()->Get(v8::String::New("start"))); |
| |
| v8::CpuProfiler* cpu_profiler = env->GetIsolate()->GetCpuProfiler(); |
| v8::Local<v8::String> profile_name = v8::String::New("my_profile"); |
| |
| cpu_profiler->StartCpuProfiling(profile_name); |
| int32_t duration_ms = 100; |
| #if defined(_WIN32) || defined(_WIN64) |
| // 100ms is not enough on Windows. See |
| // https://code.google.com/p/v8/issues/detail?id=2628 |
| duration_ms = 400; |
| #endif |
| v8::Handle<v8::Value> args[] = { v8::Integer::New(duration_ms) }; |
| function->Call(env->Global(), ARRAY_SIZE(args), args); |
| const v8::CpuProfile* profile = cpu_profiler->StopCpuProfiling(profile_name); |
| |
| CHECK_NE(NULL, profile); |
| // Dump collected profile to have a better diagnostic in case of failure. |
| reinterpret_cast<i::CpuProfile*>( |
| const_cast<v8::CpuProfile*>(profile))->Print(); |
| |
| const v8::CpuProfileNode* root = profile->GetTopDownRoot(); |
| { |
| ScopedVector<v8::Handle<v8::String> > names(4); |
| names[0] = v8::String::New(ProfileGenerator::kGarbageCollectorEntryName); |
| names[1] = v8::String::New(ProfileGenerator::kProgramEntryName); |
| names[2] = v8::String::New("start"); |
| names[3] = v8::String::New(i::ProfileGenerator::kUnresolvedFunctionName); |
| // Don't allow |bar| and |call| nodes to be at the top level. |
| CheckChildrenNames(root, names); |
| } |
| |
| const v8::CpuProfileNode* startNode = GetChild(root, "start"); |
| { |
| ScopedVector<v8::Handle<v8::String> > names(1); |
| names[0] = v8::String::New("bar"); |
| CheckChildrenNames(startNode, names); |
| } |
| |
| const v8::CpuProfileNode* unresolvedNode = |
| FindChild(root, i::ProfileGenerator::kUnresolvedFunctionName); |
| if (unresolvedNode) { |
| ScopedVector<v8::Handle<v8::String> > names(1); |
| names[0] = v8::String::New("call"); |
| CheckChildrenNames(unresolvedNode, names); |
| } |
| |
| cpu_profiler->DeleteAllCpuProfiles(); |
| } |
| |