Merge bleeding_edge.

test/cctest/test-cpu-profiler.cc

 // 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
@@ skipping 457 matching lines @@
     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);
+  if (!result) {
+    char buffer[100];
+    i::OS::SNPrintF(Vector<char>(buffer, ARRAY_SIZE(buffer)),
+                    "Failed to GetChild: %s", name);
+    FATAL(buffer);
+  }
   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;
@@ skipping 94 matching lines @@
 
 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:
+// Check that the profile tree doesn't contain unexpected 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
@@ skipping 470 matching lines @@
       CheckChildrenNames(unresolvedNode, names);
       GetChild(unresolvedNode, "apply");
     }
   }
 
   v8::CpuProfiler* cpu_profiler = env->GetIsolate()->GetCpuProfiler();
   cpu_profiler->DeleteAllCpuProfiles();
 }
 
 
-static const char* js_native_js_test_source = "function foo(iterations) {\n"
+static const char* js_native_js_test_source =
+"var is_profiling = false;\n"
+"function foo(iterations) {\n"
+"  if (!is_profiling) {\n"
+"    is_profiling = true;\n"
+"    startProfiling('my_profile');\n"
+"  }\n"
 "  var r = 0;\n"
 "  for (var i = 0; i < iterations; i++) { r += i; }\n"
 "  return r;\n"
 "}\n"
 "function bar(iterations) {\n"
 "  try { foo(iterations); } catch(e) {}\n"
 "}\n"
 "function start(duration) {\n"
 "  var start = Date.now();\n"
 "  while (Date.now() - start < duration) {\n"
@@ skipping 11 matching lines @@
 
 
 // [Top down]:
 //    58     0   (root) #0 1
 //     2     2    (program) #0 2
 //    56     1    start #16 3
 //    55     0      CallJsFunction #0 4
 //    55     1        bar #16 5
 //    54    54          foo #16 6
 TEST(JsNativeJsSample) {
-  LocalContext env;
+  const char* extensions[] = { "v8/profiler" };
+  v8::ExtensionConfiguration config(1, extensions);
+  LocalContext env(&config);
   v8::HandleScope scope(env->GetIsolate());
 
   v8::Local<v8::FunctionTemplate> func_template = v8::FunctionTemplate::New(
       CallJsFunction);
   v8::Local<v8::Function> func = func_template->GetFunction();
   func->SetName(v8::String::New("CallJsFunction"));
   env->Global()->Set(v8::String::New("CallJsFunction"), func);
 
   v8::Script::Compile(v8::String::New(js_native_js_test_source))->Run();
   v8::Local<v8::Function> function = v8::Local<v8::Function>::Cast(
       env->Global()->Get(v8::String::New("start")));
 
   int32_t duration_ms = 20;
   v8::Handle<v8::Value> args[] = { v8::Integer::New(duration_ms) };
   const v8::CpuProfile* profile =
-      RunProfiler(env, function, args, ARRAY_SIZE(args), 50);
+      RunProfiler(env, function, args, ARRAY_SIZE(args), 10);
 
   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* nativeFunctionNode =
       GetChild(startNode, "CallJsFunction");
 
   CHECK_EQ(1, nativeFunctionNode->GetChildrenCount());
   const v8::CpuProfileNode* barNode = GetChild(nativeFunctionNode, "bar");
 
   CHECK_EQ(1, barNode->GetChildrenCount());
   GetChild(barNode, "foo");
 
   v8::CpuProfiler* cpu_profiler = env->GetIsolate()->GetCpuProfiler();
   cpu_profiler->DeleteAllCpuProfiles();
 }
 
 
 static const char* js_native_js_runtime_js_test_source =
+"var is_profiling = false;\n"
 "function foo(iterations) {\n"
+"  if (!is_profiling) {\n"
+"    is_profiling = true;\n"
+"    startProfiling('my_profile');\n"
+"  }\n"
 "  var r = 0;\n"
 "  for (var i = 0; i < iterations; i++) { r += i; }\n"
 "  return r;\n"
 "}\n"
 "var bound = foo.bind(this);\n"
 "function bar(iterations) {\n"
 "  try { bound(iterations); } catch(e) {}\n"
 "}\n"
 "function start(duration) {\n"
 "  var start = Date.now();\n"
 "  while (Date.now() - start < duration) {\n"
 "    try {\n"
 "      CallJsFunction(bar, 10 * 1000);\n"
 "    } catch(e) {}\n"
 "  }\n"
 "}";
 
 
 // [Top down]:
 //    57     0   (root) #0 1
 //    55     1    start #16 3
 //    54     0      CallJsFunction #0 4
 //    54     3        bar #16 5
 //    51    51          foo #16 6
 //     2     2    (program) #0 2
 TEST(JsNativeJsRuntimeJsSample) {
-  LocalContext env;
+  const char* extensions[] = { "v8/profiler" };
+  v8::ExtensionConfiguration config(1, extensions);
+  LocalContext env(&config);
   v8::HandleScope scope(env->GetIsolate());
 
   v8::Local<v8::FunctionTemplate> func_template = v8::FunctionTemplate::New(
       CallJsFunction);
   v8::Local<v8::Function> func = func_template->GetFunction();
   func->SetName(v8::String::New("CallJsFunction"));
   env->Global()->Set(v8::String::New("CallJsFunction"), func);
 
   v8::Script::Compile(v8::String::New(js_native_js_runtime_js_test_source))->
       Run();
   v8::Local<v8::Function> function = v8::Local<v8::Function>::Cast(
       env->Global()->Get(v8::String::New("start")));
 
   int32_t duration_ms = 20;
   v8::Handle<v8::Value> args[] = { v8::Integer::New(duration_ms) };
   const v8::CpuProfile* profile =
-      RunProfiler(env, function, args, ARRAY_SIZE(args), 50);
+      RunProfiler(env, function, args, ARRAY_SIZE(args), 10);
 
   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());
@@ skipping 10 matching lines @@
   cpu_profiler->DeleteAllCpuProfiles();
 }
 
 
 static void CallJsFunction2(const v8::FunctionCallbackInfo<v8::Value>& info) {
   CallJsFunction(info);
 }
 
 
 static const char* js_native1_js_native2_js_test_source =
+"var is_profiling = false;\n"
 "function foo(iterations) {\n"
+"  if (!is_profiling) {\n"
+"    is_profiling = true;\n"
+"    startProfiling('my_profile');\n"
+"  }\n"
 "  var r = 0;\n"
 "  for (var i = 0; i < iterations; i++) { r += i; }\n"
 "  return r;\n"
 "}\n"
 "function bar(iterations) {\n"
 "  CallJsFunction2(foo, iterations);\n"
 "}\n"
 "function start(duration) {\n"
 "  var start = Date.now();\n"
 "  while (Date.now() - start < duration) {\n"
 "    try {\n"
 "      CallJsFunction1(bar, 10 * 1000);\n"
 "    } catch(e) {}\n"
 "  }\n"
 "}";
 
 
 // [Top down]:
 //    57     0   (root) #0 1
 //    55     1    start #16 3
 //    54     0      CallJsFunction1 #0 4
 //    54     0        bar #16 5
 //    54     0          CallJsFunction2 #0 6
 //    54    54            foo #16 7
 //     2     2    (program) #0 2
 TEST(JsNative1JsNative2JsSample) {
-  LocalContext env;
+  const char* extensions[] = { "v8/profiler" };
+  v8::ExtensionConfiguration config(1, extensions);
+  LocalContext env(&config);
   v8::HandleScope scope(env->GetIsolate());
 
   v8::Local<v8::FunctionTemplate> func_template = v8::FunctionTemplate::New(
       CallJsFunction);
   v8::Local<v8::Function> func1 = func_template->GetFunction();
   func1->SetName(v8::String::New("CallJsFunction1"));
   env->Global()->Set(v8::String::New("CallJsFunction1"), func1);
 
   v8::Local<v8::Function> func2 = v8::FunctionTemplate::New(
       CallJsFunction2)->GetFunction();
   func2->SetName(v8::String::New("CallJsFunction2"));
   env->Global()->Set(v8::String::New("CallJsFunction2"), func2);
 
   v8::Script::Compile(v8::String::New(js_native1_js_native2_js_test_source))->
       Run();
   v8::Local<v8::Function> function = v8::Local<v8::Function>::Cast(
       env->Global()->Get(v8::String::New("start")));
 
   int32_t duration_ms = 20;
   v8::Handle<v8::Value> args[] = { v8::Integer::New(duration_ms) };
   const v8::CpuProfile* profile =
-      RunProfiler(env, function, args, ARRAY_SIZE(args), 50);
+      RunProfiler(env, function, args, ARRAY_SIZE(args), 10);
 
   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());
@@ skipping 58 matching lines @@
   CHECK_EQ(0, programNode->GetChildrenCount());
   CHECK_GE(programNode->GetHitCount(), 3);
 
   const v8::CpuProfileNode* idleNode =
       GetChild(root, ProfileGenerator::kIdleEntryName);
   CHECK_EQ(0, idleNode->GetChildrenCount());
   CHECK_GE(idleNode->GetHitCount(), 3);
 
   cpu_profiler->DeleteAllCpuProfiles();
 }
+
+
+static void CheckFunctionDetails(const v8::CpuProfileNode* node,
+    const char* name, const char* script_name, int script_id,
+    int line, int column) {
+  CHECK_EQ(v8::String::New(name), node->GetFunctionName());
+  CHECK_EQ(v8::String::New(script_name), node->GetScriptResourceName());
+  CHECK_EQ(script_id, node->GetScriptId());
+  CHECK_EQ(line, node->GetLineNumber());
+  CHECK_EQ(column, node->GetColumnNumber());
+}
+
+
+TEST(FunctionDetails) {
+  const char* extensions[] = { "v8/profiler" };
+  v8::ExtensionConfiguration config(1, extensions);
+  LocalContext env(&config);
+  v8::HandleScope handleScope(env->GetIsolate());
+
+  v8::CpuProfiler* profiler = env->GetIsolate()->GetCpuProfiler();
+  CHECK_EQ(0, profiler->GetProfileCount());
+  v8::Handle<v8::Script> script_a = v8::Script::Compile(v8::String::New(
+      "    function foo\n() { try { bar(); } catch(e) {} }\n"
+      " function bar() { startProfiling(); }\n"), v8::String::New("script_a"));
+  script_a->Run();
+  v8::Handle<v8::Script> script_b = v8::Script::Compile(v8::String::New(
+      "\n\n   function baz() { try { foo(); } catch(e) {} }\n"
+      "\n\nbaz();\n"
+      "stopProfiling();\n"), v8::String::New("script_b"));
+  script_b->Run();
+  CHECK_EQ(1, profiler->GetProfileCount());
+  const v8::CpuProfile* profile = profiler->GetCpuProfile(0);
+  const v8::CpuProfileNode* current = profile->GetTopDownRoot();
+  reinterpret_cast<ProfileNode*>(
+      const_cast<v8::CpuProfileNode*>(current))->Print(0);
+  // The tree should look like this:
+  //  0   (root) 0 #1
+  //  0    (anonymous function) 19 #2 no reason script_b:1
+  //  0      baz 19 #3 TryCatchStatement script_b:3
+  //  0        foo 18 #4 TryCatchStatement script_a:2
+  //  1          bar 18 #5 no reason script_a:3
+  const v8::CpuProfileNode* root = profile->GetTopDownRoot();
+  const v8::CpuProfileNode* script = GetChild(root,
+      ProfileGenerator::kAnonymousFunctionName);
+  CheckFunctionDetails(script, ProfileGenerator::kAnonymousFunctionName,
+      "script_b", script_b->GetId(), 1, 1);
+  const v8::CpuProfileNode* baz = GetChild(script, "baz");
+  CheckFunctionDetails(baz, "baz", "script_b", script_b->GetId(), 3, 16);
+  const v8::CpuProfileNode* foo = GetChild(baz, "foo");
+  CheckFunctionDetails(foo, "foo", "script_a", script_a->GetId(), 2, 1);
+  const v8::CpuProfileNode* bar = GetChild(foo, "bar");
+  CheckFunctionDetails(bar, "bar", "script_a", script_a->GetId(), 3, 14);
+}