Merge the Merlin heap tracing to top-of-trunk.

runtime/vm/handles_impl.h

 // Copyright (c) 2012, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 #ifndef VM_HANDLES_IMPL_H_
 #define VM_HANDLES_IMPL_H_
 
+#include "vm/heap.h"
+#include "vm/heap_trace.h"
 #include "vm/visitor.h"
 
 namespace dart {
 
 DECLARE_DEBUG_FLAG(bool, trace_handles_count);
 
 template <int kHandleSizeInWords, int kHandlesPerChunk, int kOffsetOfRawPtr>
 void Handles<kHandleSizeInWords,
              kHandlesPerChunk,
              kOffsetOfRawPtr>::VisitObjectPointers(
@@ skipping 10 matching lines @@
   do {
     block->VisitObjectPointers(visitor);
     block = block->next_block();
   } while (block != NULL);
 }
 
 
 template <int kHandleSizeInWords, int kHandlesPerChunk, int kOffsetOfRawPtr>
 void Handles<kHandleSizeInWords,
              kHandlesPerChunk,
+             kOffsetOfRawPtr>::VisitScopedHandles(
+    ObjectPointerVisitor* visitor) {
+  HandlesBlock* block;
+  // Visit all scoped handles.
+  block = &first_scoped_block_;
+  do {
+    block->VisitObjectPointers(visitor);
+    block = block->next_block();
+  } while (block != NULL);
+}
+
+
+template <int kHandleSizeInWords, int kHandlesPerChunk, int kOffsetOfRawPtr>
+void Handles<kHandleSizeInWords,
+             kHandlesPerChunk,
+             kOffsetOfRawPtr>::VisitUnvisitedScopedHandles(
+    ObjectPointerVisitor* visitor) {
+    HandlesBlock* block = &first_scoped_block_;
+    while (block != NULL && block != last_visited_block_) {
+      block->VisitUnvisitedObjectPointers(visitor);
+      block = block->next_block();
+    }
+    // We want this to point to first_scoped_block.next,
+    // Because pointers are still being added to first_scoped_block
+    // So it may be "partially new", and require a partial scan.
+    last_visited_block_ = first_scoped_block_.next_block();
+}
+
+template <int kHandleSizeInWords, int kHandlesPerChunk, int kOffsetOfRawPtr>
+void Handles<kHandleSizeInWords,
+             kHandlesPerChunk,
              kOffsetOfRawPtr>::Visit(HandleVisitor* visitor) {
   // Visit all zone handles.
   HandlesBlock* block = zone_blocks_;
   while (block != NULL) {
     block->Visit(visitor);
     block = block->next_block();
   }
 
   // Visit all scoped handles.
   block = &first_scoped_block_;
   do {
     block->Visit(visitor);
     block = block->next_block();
   } while (block != NULL);

[siva, 2012/12/14 02:11:54]

Can we use the new VisitScopedHandles(visitor) here and avoid the code
duplication.

[cshapiro, 2012/12/15 19:56:49]

Sure can.  Done.

 }
 
 
 // Figure out the current handle scope using the current Isolate and
 // allocate a handle in that scope. The function assumes that a
 // current Isolate, current zone and current handle scope exist. It
 // asserts for this appropriately.
 template <int kHandleSizeInWords, int kHandlesPerChunk, int kOffsetOfRawPtr>
 uword Handles<kHandleSizeInWords,
               kHandlesPerChunk,
@@ skipping 14 matching lines @@
 // this appropriately.
 template <int kHandleSizeInWords, int kHandlesPerChunk, int kOffsetOfRawPtr>
 uword Handles<kHandleSizeInWords,
               kHandlesPerChunk,
               kOffsetOfRawPtr>::AllocateZoneHandle(Isolate* isolate) {
   ASSERT(isolate != NULL);
   ASSERT(isolate->current_zone() != NULL);
   ASSERT(isolate->no_handle_scope_depth() == 0);
   Handles* handles = isolate->current_zone()->handles();
   ASSERT(handles != NULL);
-  return handles->AllocateHandleInZone();
+  uword address = handles->AllocateHandleInZone();
+  if (HeapTrace::is_enabled()) {
+    uword zone_addr = reinterpret_cast<uword>(isolate->current_zone());
+    isolate->heap()->trace()->TraceAllocateZoneHandle(address, zone_addr);
+  }
+  return address;
 }
 
 
 // Figure out the current zone using the current Isolate and
 // check if the specified handle has been allocated in this zone.
 template <int kHandleSizeInWords, int kHandlesPerChunk, int kOffsetOfRawPtr>
 bool Handles<kHandleSizeInWords,
              kHandlesPerChunk,
              kOffsetOfRawPtr>::IsZoneHandle(uword handle) {
   // TODO(5411412): Accessing the current isolate is a performance problem,
   // consider passing it down as a parameter.
   Isolate* isolate = Isolate::Current();
   ASSERT(isolate != NULL);
   ASSERT(isolate->current_zone() != NULL);
   Handles* handles = isolate->current_zone()->handles();
   ASSERT(handles != NULL);
   return handles->IsValidZoneHandle(handle);
 }
 
 
 template <int kHandleSizeInWords, int kHandlesPerChunk, int kOffsetOfRawPtr>
 void Handles<kHandleSizeInWords,
              kHandlesPerChunk,
              kOffsetOfRawPtr>::DeleteAll() {
   // Delete all the zone allocated handle blocks.
+  // GCTrace does not need to trace this call to DeleteHandleBlocks,
+  // since the individual zone deletions will be caught
+  // by instrumentation in the BaseZone destructor.
   DeleteHandleBlocks(zone_blocks_);
   zone_blocks_ = NULL;
 
   // Delete all the scoped handle blocks.
+  // Do not trace if there is no  current isolate. This can happen during
+  // isolate shutdown.
+  if (HeapTrace::is_enabled() && Isolate::Current() != NULL) {
+    Isolate::Current()->heap()->trace()->TraceDeleteScopedHandles();
+  }
+
+
   scoped_blocks_ = first_scoped_block_.next_block();
   DeleteHandleBlocks(scoped_blocks_);
   first_scoped_block_.ReInit();
   scoped_blocks_ = &first_scoped_block_;
 }
 
 
 template <int kHandleSizeInWords, int kHandlesPerChunk, int kOffsetOfRawPtr>
 void Handles<kHandleSizeInWords,
              kHandlesPerChunk,
@@ skipping 169 matching lines @@
   for (intptr_t i = 0; i < next_handle_slot_; i += kHandleSizeInWords) {
     visitor->VisitPointer(
         reinterpret_cast<RawObject**>(&data_[i + kOffsetOfRawPtr/kWordSize]));
   }
 }
 
 
 template <int kHandleSizeInWords, int kHandlesPerChunk, int kOffsetOfRawPtr>
 void Handles<kHandleSizeInWords,
              kHandlesPerChunk,
+             kOffsetOfRawPtr>::HandlesBlock::VisitUnvisitedObjectPointers(
+                 ObjectPointerVisitor* visitor) {
+  ASSERT(visitor != NULL);
+
+  // last_visited_handle_ picks up where we were last time,
+  // so there is nothing in the intialization position of this for loop.
+
+  while (last_visited_handle_ < next_handle_slot_) {
+    last_visited_handle_ += kHandleSizeInWords;
+    uword* addr = &data_[last_visited_handle_ + kOffsetOfRawPtr / kWordSize];
+    visitor->VisitPointer(reinterpret_cast<RawObject**>(addr));
+  }
+}
+
+
+template <int kHandleSizeInWords, int kHandlesPerChunk, int kOffsetOfRawPtr>
+void Handles<kHandleSizeInWords,
+             kHandlesPerChunk,
              kOffsetOfRawPtr>::HandlesBlock::Visit(HandleVisitor* visitor) {
   ASSERT(visitor != NULL);
   for (intptr_t i = 0; i < next_handle_slot_; i += kHandleSizeInWords) {
     visitor->VisitHandle(reinterpret_cast<uword>(&data_[i]));
   }
 }
 
 
 #if defined(DEBUG)
 template <int kHandleSizeInWords, int kHandlesPerChunk, int kOffsetOfRawPtr>
@@ skipping 13 matching lines @@
 template <int kHandleSizeInWords, int kHandlesPerChunk, int kOffsetOfRawPtr>
 int Handles<kHandleSizeInWords,
             kHandlesPerChunk,
             kOffsetOfRawPtr>::HandlesBlock::HandleCount() const {
   return (next_handle_slot_ / kHandleSizeInWords);
 }
 
 }  // namespace dart
 
 #endif  // VM_HANDLES_IMPL_H_