[profiler] Implement POC Sampling Heap Profiler

test/cctest/test-heap-profiler.cc

 // Copyright 2011 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 2834 matching lines @@
   map.AddRange(ToAddress(0x180), 0x80, 6U);
   map.AddRange(ToAddress(0x180), 0x80, 7U);
   CHECK_EQ(7u, map.GetTraceNodeId(ToAddress(0x180)));
   CHECK_EQ(5u, map.GetTraceNodeId(ToAddress(0x200)));
   CHECK_EQ(3u, map.size());
 
   map.Clear();
   CHECK_EQ(0u, map.size());
   CHECK_EQ(0u, map.GetTraceNodeId(ToAddress(0x400)));
 }
+
+
+static const v8::AllocationProfile::Node* FindAllocationProfileNode(
+    v8::AllocationProfile& profile, const Vector<const char*>& names) {
+  v8::AllocationProfile::Node* node = profile.GetRootNode();
+  for (int i = 0; node != nullptr && i < names.length(); ++i) {
+    const char* name = names[i];
+    auto children = node->children;
+    node = nullptr;
+    for (v8::AllocationProfile::Node* child : children) {
+      v8::String::Utf8Value child_name(child->name);
+      if (strcmp(*child_name, name) == 0) {
+        node = child;
+        break;
+      }
+    }
+  }
+  return node;
+}
+
+
+TEST(SamplingHeapProfiler) {
+  v8::HandleScope scope(v8::Isolate::GetCurrent());
+  LocalContext env;
+  v8::HeapProfiler* heap_profiler = env->GetIsolate()->GetHeapProfiler();
+
+  // Turn off always_opt. Inlining can cause stack traces to be shorter than
+  // what we expect in this test.
+  v8::internal::FLAG_always_opt = false;
+
+  const char* script_source =
+      "var A = [];\n"
+      "function bar(size) { return new Array(size); }\n"
+      "var foo = function() {\n"
+      "  for (var i = 0; i < 1024; ++i) {\n"
+      "    A[i] = bar(1024);\n"
+      "  }\n"
+      "}\n"
+      "foo();";
+
+  // Sample should be empty if requested before sampling has started.
+  {
+    v8::AllocationProfile* profile = heap_profiler->GetAllocationProfile();
+    CHECK(profile == nullptr);
+  }
+
+  int count_512kb = 0;
+  {
+    heap_profiler->StartSamplingHeapProfiler(512 * 1024);

[alph, 2016/01/20 23:13:01]

This is a source for flakiness, as the interval is in fact a random number, so
it may happen to collect no samples. Could you suppress randomness for the test
or limit the top bound of the interval as I suggested above.

Also provided that there will be just 2 samples on average, could that be they
all fall into say (GC).

[ofrobots, 2016/01/21 03:03:28]

I like the idea to suppress randomness some of the tests. I can pursue it, but
hopefully in a follow-on CL?

On 64-bit machines, we should see ~14-15 samples. On my machine, I did 100 runs,
and I got exactly 15 samples on all 100 of those runs.  For the 32KiB observer,
I got 202 samples ~50% of the time and 203 samples otherwise.

Also note that it is not expected that we will get any samples that fall into
the '(GC)' category. GC doesn't allocate new objects, it moves objects across
spaces. Those look like allocations from a given Space's point of view, but the
profiler should deal with them correctly.

In other words, yes, there would be some differences in exactly how many samples
we capture, but this is fine for now? I can add tests that run with randomness
suppressed in a follow-on CL.

[alph, 2016/01/21 03:21:55]

oh yes, it's 2 multiplies by sizeof(intptr_t) = 16.

+    CompileRun(script_source);
+
+    v8::AllocationProfile* profile = heap_profiler->GetAllocationProfile();

[alph, 2016/01/20 23:13:01]

Please use SmartPointer wherever possible.

[ofrobots, 2016/01/21 03:03:28]

Done.

+    CHECK(profile);
+
+    const char* names[] = {"", "foo", "bar"};
+    auto node_bar = FindAllocationProfileNode(
+        *profile, Vector<const char*>(names, arraysize(names)));
+    CHECK(node_bar);
+
+    // Count the number of allocations we sampled from bar.
+    for (auto allocation : node_bar->allocations) {
+      count_512kb += allocation.count;
+    }
+
+    heap_profiler->StopSamplingHeapProfiler();
+    delete profile;
+  }
+
+  // Samples should get cleared once sampling is stopped.
+  {
+    v8::AllocationProfile* profile = heap_profiler->GetAllocationProfile();
+    CHECK(profile == nullptr);
+  }
+
+  // Sampling at a higher rate should give us more sampled objects.
+  {
+    heap_profiler->StartSamplingHeapProfiler(32 * 1024);
+    CompileRun(script_source);
+
+    v8::AllocationProfile* profile = heap_profiler->GetAllocationProfile();
+    CHECK(profile);
+
+    const char* names[] = {"", "foo", "bar"};
+    auto node_bar = FindAllocationProfileNode(
+        *profile, Vector<const char*>(names, arraysize(names)));
+    CHECK(node_bar);
+
+    // Count the number of allocations we sampled from bar.
+    int count_32kb = 0;
+    for (auto allocation : node_bar->allocations) {
+      count_32kb += allocation.count;
+    }
+
+    // We should have roughly 16x as many sampled allocations. However, since
+    // sampling is a randomized process, we use a weaker test.
+    CHECK_GT(count_32kb, count_512kb);

[alph, 2016/01/20 23:13:01]

Again, this seems to be a source for the test flakiness.

[ofrobots, 2016/01/21 03:03:28]

I am intentionally using a weak test here to avoid flakiness. I am expecting
that this is fine for now, but in a follow-on CL I can suppress randomness for
this type of tests.

+
+    heap_profiler->StopSamplingHeapProfiler();
+    delete profile;
+  }
+
+  // A more complicated test cases with deeper call graph and dynamically
+  // generated function names.
+  {
+    heap_profiler->StartSamplingHeapProfiler(128);
+    CompileRun(record_trace_tree_source);
+
+    v8::AllocationProfile* profile = heap_profiler->GetAllocationProfile();
+    CHECK(profile);
+
+    const char* names1[] = {"", "start", "f_0_0", "f_0_1", "f_0_2"};
+    auto node1 = FindAllocationProfileNode(
+        *profile, Vector<const char*>(names1, arraysize(names1)));
+    CHECK(node1);
+
+    const char* names2[] = {"", "generateFunctions"};
+    auto node2 = FindAllocationProfileNode(
+        *profile, Vector<const char*>(names2, arraysize(names2)));
+    CHECK(node2);
+
+    heap_profiler->StopSamplingHeapProfiler();
+    delete profile;
+  }
+}
+
+
+TEST(SamplingHeapProfilerApiAllocation) {
+  v8::HandleScope scope(v8::Isolate::GetCurrent());
+  LocalContext env;
+  v8::HeapProfiler* heap_profiler = env->GetIsolate()->GetHeapProfiler();
+
+  heap_profiler->StartSamplingHeapProfiler(256);
+
+  for (int i = 0; i < 8 * 1024; ++i) v8::Object::New(env->GetIsolate());
+
+  v8::AllocationProfile* profile = heap_profiler->GetAllocationProfile();
+  CHECK(profile);
+  const char* names[] = {"(V8 API)"};
+  auto node = FindAllocationProfileNode(
+      *profile, Vector<const char*>(names, arraysize(names)));
+  CHECK(node);
+
+  heap_profiler->StopSamplingHeapProfiler();
+  delete profile;
+}