4c5508b42f
When current function is FunctionCall builtin we have no reliable way to determine its caller function (in many cases the top of the sampled stack contains address of the caller but sometimes it does not). Instead of dropping the sample or its two top frames we simply mark the caller frame as '(unresolved function)'. It seems like a better approach that dropping whole sample as knowing the top function and the rest of the stack the user should be able to figure out what the caller was. This change adds builtin id to CodeEntry objects. It will be used later to add similar top frame analysis for FunctionApply and probably other builtins. BUG=None TBR=loislo@chromium.org Review URL: https://codereview.chromium.org/18422003 git-svn-id: http://v8.googlecode.com/svn/branches/bleeding_edge@15436 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
1103 lines
38 KiB
C++
1103 lines
38 KiB
C++
// 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;
|
|
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();
|
|
}
|
|
|