Add GCTracer metrics for a scavenger GC for DOM wrappers

src/global-handles.cc

 // Copyright 2009 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 534 matching lines @@
     ASSERT(node->is_in_new_space_list());
     if ((node->is_independent() || node->is_partially_dependent()) &&
         node->IsWeakRetainer()) {
       v->VisitPointer(node->location());
     }
   }
 }
 
 
 bool GlobalHandles::PostGarbageCollectionProcessing(
-    GarbageCollector collector) {
+    GarbageCollector collector, GCTracer* tracer) {

[Michael Starzinger, 2012/11/16 13:45:51]

I am kind of hesitant to let the GCTracer "escape" into the global handles
subsystem. Is it important for the measurements to have per GC-cycle counts?

If not, then I would suggest to use normal per-isolate counters instead (i.e.
v8-counters.h) to gather those numbers.

I wouldn't use histograms though, because apparently they are automatically
exposed via UMA and these plain measurements are not useful when aggregated over
all pages and all users.

[haraken, 2012/11/19 07:45:43]

I think yes. What I am interested in is how many global handles are
disposed/copied/promoted in each scavenger/full GC.
Then how about adding a couple of methods to global-handles.cc and having
GCTracer count up numbers in Heap::PerformGarbageCollection()?
Agreed. I am not interested in UMAs for these metrics.

   // Process weak global handle callbacks. This must be done after the
   // GC is completely done, because the callbacks may invoke arbitrary
   // API functions.
   ASSERT(isolate_->heap()->gc_state() == Heap::NOT_IN_GC);
   const int initial_post_gc_processing_count = ++post_gc_processing_count_;
   bool next_gc_likely_to_collect_more = false;
   if (collector == SCAVENGER) {
     for (int i = 0; i < new_space_nodes_.length(); ++i) {
       Node* node = new_space_nodes_[i];
       ASSERT(node->is_in_new_space_list());
@@ skipping 29 matching lines @@
       if (!it.node()->IsRetainer()) {
         next_gc_likely_to_collect_more = true;
       }
     }
   }
   // Update the list of new space nodes.
   int last = 0;
   for (int i = 0; i < new_space_nodes_.length(); ++i) {
     Node* node = new_space_nodes_[i];
     ASSERT(node->is_in_new_space_list());
-    if (node->IsRetainer() && isolate_->heap()->InNewSpace(node->object())) {
-      new_space_nodes_[last++] = node;
+    if (node->IsRetainer()) {
+      if (isolate_->heap()->InNewSpace(node->object())) {
+        new_space_nodes_[last++] = node;
+        tracer->increment_copied_nodes_in_new_space();
+      } else {
+        node->set_in_new_space_list(false);
+        tracer->increment_promoted_nodes();
+      }
     } else {
       node->set_in_new_space_list(false);
+      tracer->increment_died_nodes_in_new_space();
     }
   }
   new_space_nodes_.Rewind(last);
   return next_gc_likely_to_collect_more;
 }
 
 
 void GlobalHandles::IterateStrongRoots(ObjectVisitor* v) {
   for (NodeIterator it(this); !it.done(); it.Advance()) {
     if (it.node()->IsStrongRetainer()) {
@@ skipping 127 matching lines @@
   implicit_ref_groups_.Clear();
 }
 
 
 void GlobalHandles::TearDown() {
   // TODO(1428): invoke weak callbacks.
 }
 
 
 } }  // namespace v8::internal