Introduce a way to grab heap stats.

test/cctest/test-heap-profiler.cc

 // Copyright 2011 the V8 project authors. All rights reserved.
 //
 // Tests for heap profiler
 
 #include "v8.h"
 
 #include "cctest.h"
 #include "heap-profiler.h"
 #include "snapshot.h"
 #include "utils-inl.h"
@@ skipping 539 matching lines @@
   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');
     memcpy(chunk.start(), buffer, chars_written);
     return kContinue;
   }
+  virtual WriteResult WriteUint32Chunk(uint32_t* buffer, int chars_written) {
+    ASSERT(false);
+    return kAbort;
+  }
   void WriteTo(i::Vector<char> dest) { buffer_.WriteTo(dest); }
   int eos_signaled() { return eos_signaled_; }
   int size() { return buffer_.size(); }
+
  private:
   i::Collector<char> buffer_;
   int eos_signaled_;
   int abort_countdown_;
 };
 
 class AsciiResource: public v8::String::ExternalAsciiStringResource {
  public:
   explicit AsciiResource(i::Vector<char> string): data_(string.start()) {
     length_ = string.length();
@@ skipping 111 matching lines @@
   v8::HandleScope scope;
   LocalContext env;
   const v8::HeapSnapshot* snapshot =
       v8::HeapProfiler::TakeSnapshot(v8_str("abort"));
   TestJSONStream stream(5);
   snapshot->Serialize(&stream, v8::HeapSnapshot::kJSON);
   CHECK_GT(stream.size(), 0);
   CHECK_EQ(0, stream.eos_signaled());
 }
 
+namespace {
+
+class TestStatsStream : public v8::OutputStream {
+ public:
+  TestStatsStream()
+    : eos_signaled_(0),
+      numbers_written_(0),
+      entries_count_(0),
+      fragments_count_(0),
+      first_fragment_index_(-1) { }
+  TestStatsStream(const TestStatsStream& stream)
+    : eos_signaled_(stream.eos_signaled_),
+      numbers_written_(stream.numbers_written_),
+      entries_count_(stream.entries_count_),
+      fragments_count_(stream.fragments_count_),
+      first_fragment_index_(stream.first_fragment_index_) { }
+  virtual ~TestStatsStream() {}
+  virtual void EndOfStream() { ++eos_signaled_; }
+  virtual WriteResult WriteAsciiChunk(char* buffer, int chars_written) {
+    ASSERT(false);
+    return kAbort;
+  }
+  virtual WriteResult WriteUint32Chunk(uint32_t* buffer, int numbers_written) {
+    ++fragments_count_;
+    ASSERT(numbers_written);
+    numbers_written_ += numbers_written;
+    entries_count_ = 0;
+    if (first_fragment_index_ == -1 && numbers_written != 0)
+      first_fragment_index_ = buffer[0];
+    for (int i = 1; i < numbers_written; i += 2)
+      entries_count_ += buffer[i];
+      
+    return kContinue;
+  }
+  int eos_signaled() { return eos_signaled_; }
+  int numbers_written() { return numbers_written_; }
+  uint32_t entries_count() const { return entries_count_; }
+  int fragments_count() const { return fragments_count_; }
+  int first_fragment_index() const { return first_fragment_index_; }
+ private:
+  int eos_signaled_;
+  int numbers_written_;
+  uint32_t entries_count_;
+  int fragments_count_;
+  int first_fragment_index_;
+};
+
+}  // namespace
+
+static TestStatsStream GetHeapStatsUpdate() {
+  TestStatsStream stream;
+  v8::HeapProfiler::PushHeapObjectsStats(&stream);
+  CHECK_EQ(1, stream.eos_signaled());
+  return stream;
+}
+
+
+TEST(HeapSnapshotObjectsStats) {
+  v8::HandleScope scope;
+  LocalContext env;
+
+  v8::HeapProfiler::StartHeapObjectsTracking();
+  for (int i = 0; i < 5; ++i) {
+    HEAP->CollectAllGarbage(i::Heap::kNoGCFlags);
+  }
+
+  {
+    // Single chunk of data expected in update. Initial data.
+    TestStatsStream stats_update = GetHeapStatsUpdate();
+    CHECK_EQ(1, stats_update.fragments_count());
+    CHECK_EQ(2, stats_update.numbers_written());
+    CHECK_EQ(0, stats_update.first_fragment_index());
+  }
+  
+  // No data expected in update because nothing has happened.
+  CHECK_EQ(0, GetHeapStatsUpdate().numbers_written());
+  {
+    v8::HandleScope inner_scope_1;
+    v8::Local<v8::String> string1 = v8_str("string1");
+    {
+      // Single chunk of data with one new entry expected in update.
+      TestStatsStream stats_update = GetHeapStatsUpdate();
+      CHECK_EQ(1, stats_update.fragments_count());
+      CHECK_EQ(2, stats_update.numbers_written());
+      CHECK_EQ(1, stats_update.entries_count());
+      CHECK_EQ(2, stats_update.first_fragment_index());
+    }
+
+    // No data expected in update because nothing happened.
+    CHECK_EQ(0, GetHeapStatsUpdate().numbers_written());
+
+    {
+      v8::HandleScope inner_scope_2;
+      v8::Local<v8::String> string2 = v8_str("string2");
+      
+      {
+        v8::HandleScope inner_scope_3;
+        v8::Handle<v8::String> string3 = v8::String::New("string3");
+        v8::Handle<v8::String> string4 = v8::String::New("string4");
+
+        {
+          // Single chunk of data with three new entries expected in update.
+          TestStatsStream stats_update = GetHeapStatsUpdate();
+          CHECK_EQ(1, stats_update.fragments_count());
+          CHECK_EQ(2, stats_update.numbers_written());
+          CHECK_EQ(3, stats_update.entries_count());
+          CHECK_EQ(4, stats_update.first_fragment_index());
+        }
+      }
+
+      {
+        // Single chunk of data with two left entries expected in update.
+        TestStatsStream stats_update = GetHeapStatsUpdate();
+        CHECK_EQ(1, stats_update.fragments_count());
+        CHECK_EQ(2, stats_update.numbers_written());
+        CHECK_EQ(1, stats_update.entries_count());
+        // Two strings from forth fragment were released.
+        CHECK_EQ(4, stats_update.first_fragment_index()); 
+      }
+    }
+
+    {
+      // Single chunk of data with 0 left entries expected in update.
+      TestStatsStream stats_update = GetHeapStatsUpdate();
+      CHECK_EQ(1, stats_update.fragments_count());
+      CHECK_EQ(2, stats_update.numbers_written());

[mnaganov (inactive), 2012/04/12 13:32:26]

Why no check for entries_count?

+      // The last string from forth fragment was released.
+      CHECK_EQ(4, stats_update.first_fragment_index()); 
+    }
+
+  }
+  {
+    // Single chunk of data with 0 left entries expected in update.
+    TestStatsStream stats_update = GetHeapStatsUpdate();
+    CHECK_EQ(1, stats_update.fragments_count());
+    CHECK_EQ(2, stats_update.numbers_written());
+    CHECK_EQ(0, stats_update.entries_count());
+    // The only string from the second fragment was released.
+    CHECK_EQ(2, stats_update.first_fragment_index()); 
+  }
+
+  v8::HeapProfiler::StopHeapObjectsTracking();
+}
+
 
 static void CheckChildrenIds(const v8::HeapSnapshot* snapshot,
                              const v8::HeapGraphNode* node,
                              int level, int max_level) {
   if (level > max_level) return;
   CHECK_EQ(node, snapshot->GetNodeById(node->GetId()));
   for (int i = 0, count = node->GetChildrenCount(); i < count; ++i) {
     const v8::HeapGraphEdge* prop = node->GetChild(i);
     const v8::HeapGraphNode* child =
         snapshot->GetNodeById(prop->GetToNode()->GetId());
@@ skipping 661 matching lines @@
   // Dipose the persistent handles in a different order.
   p_AAA.Dispose();
   CHECK_EQ(global_handle_count + 2,
            v8::HeapProfiler::GetPersistentHandleCount());
   p_CCC.Dispose();
   CHECK_EQ(global_handle_count + 1,
            v8::HeapProfiler::GetPersistentHandleCount());
   p_BBB.Dispose();
   CHECK_EQ(global_handle_count, v8::HeapProfiler::GetPersistentHandleCount());
 }