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());
 }
 
+class TestStatsStream : public v8::OutputStream {
+ public:
+  TestStatsStream() : eos_signaled_(0), numbers_written_(0) {}
+  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) {
+    entries_count_ = 0;
+    for (int i = 1; i < numbers_written; i += 2)
+      entries_count_ += buffer[i];
+    numbers_written_ += numbers_written;
+    return kContinue;
+  }
+  int eos_signaled() { return eos_signaled_; }
+  int numbers_written() { return numbers_written_; }
+  uint32_t entries_count() const { return entries_count_; }
+ private:
+  int eos_signaled_;
+  int numbers_written_;
+  uint32_t entries_count_;
+};
+
+
+TEST(HeapSnapshotObjectsStats) {
+  v8::HandleScope scope;
+  LocalContext env;
+
+  v8::HeapProfiler::StartHeapObjectsTracking();
+
+  for (int i = 0; i < 5; ++i) {
+    HEAP->CollectAllGarbage(i::Heap::kNoGCFlags);
+  }
+
+  {
+    TestStatsStream stream;
+    v8::HeapProfiler::PushHeapObjectsStats(&stream);
+    CHECK_EQ(2, stream.numbers_written());
+    CHECK_EQ(1, stream.eos_signaled());
+  }
+
+  { // No data expected in update because nothing happened.
+    TestStatsStream stream;
+    v8::HeapProfiler::PushHeapObjectsStats(&stream);
+    CHECK_EQ(0, stream.numbers_written());
+    CHECK_EQ(1, stream.eos_signaled());
+  }
+
+  v8::Persistent<v8::String> p_string =

[mnaganov (inactive), 2012/04/11 14:35:40]

This handle can be local, you have a HandleScope at the function level, so the
string will be kept alive until you return.

+      v8::Persistent<v8::String>::New(v8_str("string"));
+
+  { // Single chunk of data expected in update.
+    TestStatsStream stream;
+    v8::HeapProfiler::PushHeapObjectsStats(&stream);
+    CHECK_EQ(2, stream.numbers_written());
+    CHECK_EQ(1, stream.entries_count());
+    CHECK_EQ(1, stream.eos_signaled());
+  }
+
+  { // No data expected in update because nothing happened.
+    TestStatsStream stream;
+    v8::HeapProfiler::PushHeapObjectsStats(&stream);
+    CHECK_EQ(0, stream.numbers_written());
+    CHECK_EQ(1, stream.eos_signaled());
+  }
+

[mnaganov (inactive), 2012/04/11 14:35:40]

I think, you should also test stats update on object deletion.

+  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());
 }