// 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(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 script; i::EmbeddedVector 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 fun = v8::Utils::OpenHandle( *v8::Local::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 aaa_name = factory->NewStringFromAscii( i::Vector(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 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* 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* 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* 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* 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 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(p1)->Delete(); CHECK_EQ(0, cpu_profiler->GetProfileCount()); CHECK_EQ(NULL, FindCpuProfile(cpu_profiler, uid1)); v8::Local 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(uid1), static_cast(uid2)); CHECK_EQ(p2, FindCpuProfile(cpu_profiler, uid2)); CHECK_EQ(NULL, FindCpuProfile(cpu_profiler, uid1)); v8::Local 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(uid1), static_cast(uid3)); CHECK_EQ(p3, FindCpuProfile(cpu_profiler, uid3)); CHECK_EQ(NULL, FindCpuProfile(cpu_profiler, uid1)); const_cast(p2)->Delete(); CHECK_EQ(1, cpu_profiler->GetProfileCount()); CHECK_EQ(NULL, FindCpuProfile(cpu_profiler, uid2)); CHECK_EQ(p3, FindCpuProfile(cpu_profiler, uid3)); const_cast(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 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 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(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(p1_t1)->Delete(); CHECK_EQ(0, cpu_profiler->GetProfileCount()); v8::Local name2 = v8::String::New("2"); cpu_profiler->StartCpuProfiling(name2); v8::Local 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(uid1), static_cast(uid2)); const v8::CpuProfile* p2 = cpu_profiler->FindCpuProfile(uid2); CHECK_NE(p2_t2, p2); v8::Local 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(uid1), static_cast(uid3)); CHECK_EQ(p3, cpu_profiler->FindCpuProfile(uid3)); const_cast(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(p2)->Delete(); CHECK_EQ(1, cpu_profiler->GetProfileCount()); CHECK_EQ(NULL, cpu_profiler->FindCpuProfile(uid2)); CHECK_EQ(p3, cpu_profiler->FindCpuProfile(uid3)); const_cast(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 string, const Vector >& 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 >& names) { int count = node->GetChildrenCount(); for (int i = 0; i < count; i++) { v8::Handle 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 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 function = v8::Local::Cast( env->Global()->Get(v8::String::New("start"))); v8::CpuProfiler* cpu_profiler = env->GetIsolate()->GetCpuProfiler(); v8::Local 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 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( const_cast(profile))->Print(); const v8::CpuProfileNode* root = profile->GetTopDownRoot(); ScopedVector > 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 function = v8::Local::Cast( env->Global()->Get(v8::String::New("start"))); v8::CpuProfiler* cpu_profiler = env->GetIsolate()->GetCpuProfiler(); v8::Local 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 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( const_cast(profile))->Print(); const v8::CpuProfileNode* root = profile->GetTopDownRoot(); ScopedVector > 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 Getter(v8::Local name, const v8::AccessorInfo& info) { TestApiCallbacks* data = fromInfo(info); data->Wait(); return v8::Int32::New(2013); } static void Setter(v8::Local name, v8::Local value, const v8::AccessorInfo& info) { TestApiCallbacks* data = fromInfo(info); data->Wait(); } static void Callback(const v8::FunctionCallbackInfo& 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(data); } static TestApiCallbacks* fromInfo( const v8::FunctionCallbackInfo& info) { void* data = v8::External::Cast(*info.Data())->Value(); return reinterpret_cast(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 func_template = v8::FunctionTemplate::New(); v8::Local instance_template = func_template->InstanceTemplate(); TestApiCallbacks accessors(100); v8::Local data = v8::External::New(&accessors); instance_template->SetAccessor( v8::String::New("foo"), &TestApiCallbacks::Getter, &TestApiCallbacks::Setter, data); v8::Local func = func_template->GetFunction(); v8::Local instance = func->NewInstance(); env->Global()->Set(v8::String::New("instance"), instance); v8::Script::Compile(v8::String::New(native_accessor_test_source))->Run(); v8::Local function = v8::Local::Cast( env->Global()->Get(v8::String::New("start"))); v8::CpuProfiler* cpu_profiler = env->GetIsolate()->GetCpuProfiler(); v8::Local profile_name = v8::String::New("my_profile"); cpu_profiler->StartCpuProfiling(profile_name); int32_t repeat_count = 1; v8::Handle 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( const_cast(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 func_template = v8::FunctionTemplate::New(); v8::Local instance_template = func_template->InstanceTemplate(); TestApiCallbacks accessors(1); v8::Local data = v8::External::New(&accessors); instance_template->SetAccessor( v8::String::New("foo"), &TestApiCallbacks::Getter, &TestApiCallbacks::Setter, data); v8::Local func = func_template->GetFunction(); v8::Local instance = func->NewInstance(); env->Global()->Set(v8::String::New("instance"), instance); v8::Script::Compile(v8::String::New(native_accessor_test_source))->Run(); v8::Local function = v8::Local::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 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 profile_name = v8::String::New("my_profile"); cpu_profiler->StartCpuProfiling(profile_name); int32_t repeat_count = 100; v8::Handle 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( const_cast(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 data = v8::External::New(&callbacks); v8::Local func_template = v8::FunctionTemplate::New(); func_template->SetClassName(v8::String::New("Test_InstanceCostructor")); v8::Local proto_template = func_template->PrototypeTemplate(); v8::Local signature = v8::Signature::New(func_template); proto_template->Set(v8::String::New("fooMethod"), v8::FunctionTemplate::New( &TestApiCallbacks::Callback, data, signature, 0)); v8::Local func = func_template->GetFunction(); v8::Local instance = func->NewInstance(); env->Global()->Set(v8::String::New("instance"), instance); v8::Script::Compile(v8::String::New(native_method_test_source))->Run(); v8::Local function = v8::Local::Cast( env->Global()->Get(v8::String::New("start"))); v8::CpuProfiler* cpu_profiler = env->GetIsolate()->GetCpuProfiler(); v8::Local profile_name = v8::String::New("my_profile"); cpu_profiler->StartCpuProfiling(profile_name); int32_t repeat_count = 1; v8::Handle 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( const_cast(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 data = v8::External::New(&callbacks); v8::Local func_template = v8::FunctionTemplate::New(); func_template->SetClassName(v8::String::New("Test_InstanceCostructor")); v8::Local proto_template = func_template->PrototypeTemplate(); v8::Local signature = v8::Signature::New(func_template); proto_template->Set(v8::String::New("fooMethod"), v8::FunctionTemplate::New( &TestApiCallbacks::Callback, data, signature, 0)); v8::Local func = func_template->GetFunction(); v8::Local instance = func->NewInstance(); env->Global()->Set(v8::String::New("instance"), instance); v8::Script::Compile(v8::String::New(native_method_test_source))->Run(); v8::Local function = v8::Local::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 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 profile_name = v8::String::New("my_profile"); cpu_profiler->StartCpuProfiling(profile_name); int32_t repeat_count = 100; v8::Handle 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( const_cast(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 function = v8::Local::Cast( env->Global()->Get(v8::String::New("start"))); v8::CpuProfiler* cpu_profiler = env->GetIsolate()->GetCpuProfiler(); v8::Local profile_name = v8::String::New("my_profile"); cpu_profiler->StartCpuProfiling(profile_name); int32_t duration_ms = 100; v8::Handle 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( const_cast(profile))->Print(); const v8::CpuProfileNode* root = profile->GetTopDownRoot(); ScopedVector > 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 function = v8::Local::Cast( env->Global()->Get(v8::String::New("start"))); v8::CpuProfiler* cpu_profiler = env->GetIsolate()->GetCpuProfiler(); v8::Local profile_name = v8::String::New("my_profile"); cpu_profiler->StartCpuProfiling(profile_name); int32_t duration_ms = 100; v8::Handle 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( const_cast(profile))->Print(); const v8::CpuProfileNode* root = profile->GetTopDownRoot(); { ScopedVector > 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 > names(1); names[0] = v8::String::New("bar"); CheckChildrenNames(startNode, names); } const v8::CpuProfileNode* unresolvedNode = FindChild(root, i::ProfileGenerator::kUnresolvedFunctionName); if (unresolvedNode) { ScopedVector > names(1); names[0] = v8::String::New("call"); CheckChildrenNames(unresolvedNode, names); } cpu_profiler->DeleteAllCpuProfiles(); }