[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 827 matching lines @@
   const v8::HeapGraphNode* root1 = snapshot->GetRoot();
   const_cast<i::HeapSnapshot*>(reinterpret_cast<const i::HeapSnapshot*>(
       snapshot))->GetSortedEntriesList();
   const v8::HeapGraphNode* root2 = snapshot->GetRoot();
   CHECK_EQ(root1, root2);
 }
 
 
 namespace {
 
+class OneByteResource : public v8::String::ExternalOneByteStringResource {
+ public:
+  explicit OneByteResource(i::Vector<char> string) : data_(string.start()) {
+    length_ = string.length();
+  }
+  virtual const char* data() const { return data_; }
+  virtual size_t length() const { return length_; }
+
+ private:
+  const char* data_;
+  size_t length_;
+};
+
 class TestJSONStream : public v8::OutputStream {
  public:
   TestJSONStream() : eos_signaled_(0), abort_countdown_(-1) {}
   explicit TestJSONStream(int abort_countdown)
       : eos_signaled_(0), abort_countdown_(abort_countdown) {}
   virtual ~TestJSONStream() {}
   virtual void EndOfStream() { ++eos_signaled_; }
   virtual WriteResult WriteAsciiChunk(char* buffer, int chars_written) {
     if (abort_countdown_ > 0) --abort_countdown_;
     if (abort_countdown_ == 0) return kAbort;
     CHECK_GT(chars_written, 0);
     i::Vector<char> chunk = buffer_.AddBlock(chars_written, '\0');
     i::MemCopy(chunk.start(), buffer, chars_written);
     return kContinue;
   }
   virtual WriteResult WriteUint32Chunk(uint32_t* buffer, int chars_written) {
     CHECK(false);
     return kAbort;
   }
   void WriteTo(i::Vector<char> dest) { buffer_.WriteTo(dest); }
   int eos_signaled() { return eos_signaled_; }
   int size() { return buffer_.size(); }
 
+  // Verifies that the stream contains JSON, parses, and returns the parsed
+  // result.
+  v8::Local<v8::Object> verifyAndParseJSON(LocalContext& env) {
+    i::ScopedVector<char> json(size());
+    WriteTo(json);
+
+    // Verify that string is valid JSON.
+    OneByteResource* json_res = new OneByteResource(json);
+    v8::Local<v8::String> json_string =
+        v8::String::NewExternalOneByte(env->GetIsolate(), json_res)
+            .ToLocalChecked();
+    env->Global()
+        ->Set(env.local(), v8_str("json_snapshot"), json_string)
+        .FromJust();
+    v8::Local<v8::Value> snapshot_parse_result =
+        CompileRun("var parsed = JSON.parse(json_snapshot); true;");
+    CHECK(!snapshot_parse_result.IsEmpty());
+
+    v8::Local<v8::Object> parsed = env->Global()
+                                       ->Get(env.local(), v8_str("parsed"))
+                                       .ToLocalChecked()
+                                       ->ToObject(env.local())
+                                       .ToLocalChecked();
+    return parsed;
+  }
+
  private:
   i::Collector<char> buffer_;
   int eos_signaled_;
   int abort_countdown_;
 };
 
-class OneByteResource : public v8::String::ExternalOneByteStringResource {
- public:
-  explicit OneByteResource(i::Vector<char> string) : data_(string.start()) {
-    length_ = string.length();
-  }
-  virtual const char* data() const { return data_; }
-  virtual size_t length() const { return length_; }
- private:
-  const char* data_;
-  size_t length_;
-};
-
 }  // namespace
 
 TEST(HeapSnapshotJSONSerialization) {
   v8::Isolate* isolate = CcTest::isolate();
   LocalContext env;
   v8::HandleScope scope(isolate);
   v8::HeapProfiler* heap_profiler = isolate->GetHeapProfiler();
 
 #define STRING_LITERAL_FOR_TEST \
   "\"String \\n\\r\\u0008\\u0081\\u0101\\u0801\\u8001\""
   CompileRun(
       "function A(s) { this.s = s; }\n"
       "function B(x) { this.x = x; }\n"
       "var a = new A(" STRING_LITERAL_FOR_TEST ");\n"
       "var b = new B(a);");
   const v8::HeapSnapshot* snapshot = heap_profiler->TakeHeapSnapshot();
   CHECK(ValidateSnapshot(snapshot));
 
   TestJSONStream stream;
   snapshot->Serialize(&stream, v8::HeapSnapshot::kJSON);
   CHECK_GT(stream.size(), 0);
   CHECK_EQ(1, stream.eos_signaled());
-  i::ScopedVector<char> json(stream.size());
-  stream.WriteTo(json);
 
-  // Verify that snapshot string is valid JSON.
-  OneByteResource* json_res = new OneByteResource(json);
-  v8::Local<v8::String> json_string =
-      v8::String::NewExternalOneByte(env->GetIsolate(), json_res)
-          .ToLocalChecked();
-  env->Global()
-      ->Set(env.local(), v8_str("json_snapshot"), json_string)
-      .FromJust();
-  v8::Local<v8::Value> snapshot_parse_result = CompileRun(
-      "var parsed = JSON.parse(json_snapshot); true;");
-  CHECK(!snapshot_parse_result.IsEmpty());
-
-  // Verify that snapshot object has required fields.
-  v8::Local<v8::Object> parsed_snapshot =
-      env->Global()
-          ->Get(env.local(), v8_str("parsed"))
-          .ToLocalChecked()
-          ->ToObject(env.local())
-          .ToLocalChecked();
+  v8::Local<v8::Object> parsed_snapshot = stream.verifyAndParseJSON(env);
   CHECK(parsed_snapshot->Has(env.local(), v8_str("snapshot")).FromJust());
   CHECK(parsed_snapshot->Has(env.local(), v8_str("nodes")).FromJust());
   CHECK(parsed_snapshot->Has(env.local(), v8_str("edges")).FromJust());
   CHECK(parsed_snapshot->Has(env.local(), v8_str("strings")).FromJust());
 
   // Get node and edge "member" offsets.
   v8::Local<v8::Value> meta_analysis_result = CompileRun(
       "var meta = parsed.snapshot.meta;\n"
       "var edge_count_offset = meta.node_fields.indexOf('edge_count');\n"
       "var node_fields_count = meta.node_fields.length;\n"
@@ skipping 1902 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)));
 }
+
+
+TEST(SamplingHeapProfiler) {
+  v8::HandleScope scope(v8::Isolate::GetCurrent());
+  LocalContext env;
+  v8::HeapProfiler* heap_profiler = env->GetIsolate()->GetHeapProfiler();
+
+  // GetHeapSample should return an empty stream when called before starting
+  // the sampling heap profiler.
+  TestJSONStream stream0;
+  heap_profiler->GetHeapSample(&stream0);
+  CHECK_EQ(stream0.size(), 0);
+  CHECK_EQ(1, stream0.eos_signaled());
+
+  heap_profiler->StartSamplingHeapProfiler();
+  CompileRun(
+      "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();");
+
+  TestJSONStream stream1;
+  heap_profiler->GetHeapSample(&stream1);
+  heap_profiler->StopSamplingHeapProfiler();
+
+  CHECK_GT(stream1.size(), 0);
+  CHECK_EQ(1, stream1.eos_signaled());
+
+  v8::Local<v8::Object> sample = stream1.verifyAndParseJSON(env);
+  CHECK(sample->IsArray());
+  v8::Local<v8::Value> validation_result = CompileRun(
+      "parsed.every(allocation => {\n"
+      "    return allocation.size && Array.isArray(allocation.stack) &&\n"
+      "           allocation.stack.every(frame => {\n"
+      "               return frame.hasOwnProperty('name') &&\n"
+      "                      frame.hasOwnProperty('scriptName') &&\n"
+      "                      frame.hasOwnProperty('line') &&\n"
+      "                      frame.hasOwnProperty('column');\n"
+      "           });\n"
+      "});");
+  CHECK(validation_result->IsTrue());
+
+  // Samples are reset once sampling heap profiler is stopped.
+  TestJSONStream stream2;
+  heap_profiler->GetHeapSample(&stream2);
+  CHECK_EQ(stream2.size(), 0);
+  CHECK_EQ(1, stream2.eos_signaled());
+}