Make CPU profiler unwind the inlined functions stack.

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 1492 matching lines @@
   const v8::CpuProfileNode* root = profile->GetTopDownRoot();
   const v8::CpuProfileNode* start_node = GetChild(env, root, "start");
   const v8::CpuProfileNode* native_node =
       GetChild(env, start_node, "CallJsFunction");
   const v8::CpuProfileNode* bar_node = GetChild(env, native_node, "bar");
   GetChild(env, bar_node, "foo");
 
   profile->Delete();
 }
 
+void CheckChildIsRare(const v8::Local<v8::Context>& context,
+                      const v8::CpuProfileNode* node, const char* name) {
+  const v8::CpuProfileNode* child = FindChild(context, node, name);
+  CHECK(!child || child->GetHitCount() < 10u);
+}
+
+static const char* inlining_test_source =
+    "%NeverOptimizeFunction(action);\n"
+    "%NeverOptimizeFunction(start);\n"
+    "%OptimizeFunctionOnNextCall(level1);\n"
+    "%OptimizeFunctionOnNextCall(level2);\n"
+    "%OptimizeFunctionOnNextCall(level3);\n"
+    "function action(n) {\n"
+    "  var s = 0;\n"
+    "  for (var i = 0; i < n; ++i) s += i*i*i;\n"
+    "  return s;\n"
+    "}\n"
+    "function level3() { return action(1000); }\n"
+    "function level2() { return level3() * 2; }\n"
+    "function level1() { return level2(); }\n"
+    "function start() {\n"
+    "  startProfiling('my_profile');\n"
+    "  var startTime = Date.now();\n"
+    "  do {\n"
+    "    level1();\n"
+    "  } while (Date.now() - startTime < 200);\n"
+    "}";
+
+// The test check multiple entrances/exits between JS and native code.
+//
+// [Top down]:
+//    (root) #0 1
+//      start #16 3
+//        level1 #0 4
+//          level2 #16 5
+//            level3 #16 6
+//              action #16 7
+//      (program) #0 2
+TEST(Inlining) {

[titzer, 2016/02/26 21:24:01]

Is there a way to make this test non-flaky? It currently asserts on the
distribution of the ticks in inlined frames.

E.g. could you make the CPU profiler data structures and submit queries to them
directly?

[alph, 2016/02/26 22:12:10]

It does not. It was supposed to check that there's no e.g. level3 frame inside
level1 frame.

But I can't check that reliably because frame iterator inside a signal handler
is not reliable. It may still miss a frame thus producing level1->level2
samples. This however very rare. That's why I added the threshold of 10.
This is what I wouldn't like to do as it doesn't test the codo that extracts
inlining information off the Code object.

[titzer, 2016/02/26 23:46:52]

It's still inherently flaky. Why can't you test the data structures the profiler
queries as a unit instead of running a full blown CPU profile?
That could be done in a separate test for that code path, i.e. a unit test.

[alph, 2016/02/27 08:24:02]

looks like I managed to make the test deterministic.

+  i::FLAG_allow_natives_syntax = true;
+  v8::HandleScope scope(CcTest::isolate());
+  v8::Local<v8::Context> env = CcTest::NewContext(PROFILER_EXTENSION);
+  v8::Context::Scope context_scope(env);
+
+  CompileRun(inlining_test_source);
+  v8::Local<v8::Function> function = GetFunction(env, "start");
+  v8::CpuProfile* profile = RunProfiler(env, function, NULL, 0, 1000);
+
+  const v8::CpuProfileNode* root = profile->GetTopDownRoot();
+  const v8::CpuProfileNode* start_node = GetChild(env, root, "start");
+  const v8::CpuProfileNode* level1_node = GetChild(env, start_node, "level1");
+  const v8::CpuProfileNode* level2_node = GetChild(env, level1_node, "level2");
+  const v8::CpuProfileNode* level3_node = GetChild(env, level2_node, "level3");
+  GetChild(env, level3_node, "action");
+  CheckChildIsRare(env, start_node, "level2");
+  CheckChildIsRare(env, start_node, "level3");
+  CheckChildIsRare(env, start_node, "action");
+  CheckChildIsRare(env, level1_node, "level3");
+  CheckChildIsRare(env, level1_node, "action");
+  CheckChildIsRare(env, level2_node, "action");
+
+  profile->Delete();
+}
+
 // [Top down]:
 //     0   (root) #0 1
 //     2    (program) #0 2
 //     3    (idle) #0 3
 TEST(IdleTime) {
   LocalContext env;
   v8::HandleScope scope(env->GetIsolate());
   v8::CpuProfiler* cpu_profiler = env->GetIsolate()->GetCpuProfiler();
 
   v8::Local<v8::String> profile_name = v8_str("my_profile");
@@ skipping 445 matching lines @@
   iprofile->Print();
   v8::CpuProfile* profile = reinterpret_cast<v8::CpuProfile*>(iprofile);
 
   const char* branch[] = {"", "test"};
   const ProfileNode* itest_node =
       GetSimpleBranch(env, profile, branch, arraysize(branch));
   CHECK_EQ(0U, itest_node->deopt_infos().size());
 
   iprofiler->DeleteProfile(iprofile);
 }