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

runtime/vm/handles.h

 // Copyright (c) 2011, 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_H_
 #define VM_HANDLES_H_
 
 #include "vm/allocation.h"
 #include "vm/flags.h"
 
@@ skipping 57 matching lines @@
   }
 };
 
 
 template <int kHandleSizeInWords, int kHandlesPerChunk, int kOffsetOfRawPtr>
 class Handles {
  public:
   Handles()
       : zone_blocks_(NULL),
         first_scoped_block_(NULL),
-        scoped_blocks_(&first_scoped_block_) {
+        scoped_blocks_(&first_scoped_block_),
+        last_visited_block_(NULL) {
   }
   ~Handles() {
     DeleteAll();
   }
 
   // Visit all object pointers stored in the various handles.
   void VisitObjectPointers(ObjectPointerVisitor* visitor);
 
+  // Visit all the scoped handles.
+  void VisitScopedHandles(ObjectPointerVisitor* visitor);
+
+  // Visit all blocks that have been added since the last time
+  // this method was called.
+  // Be careful with this, since multiple users of this method could
+  // interfere with eachother.
+  // Currently only used by GC trace facility.
+  void VisitUnvisitedScopedHandles(ObjectPointerVisitor* visitor);
+
   // Visit all of the various handles.
   void Visit(HandleVisitor* visitor);
 
   // Allocates a handle in the current handle scope. This handle is valid only
   // in the current handle scope and is destroyed when the current handle
   // scope ends.
   static uword AllocateHandle(Isolate* isolate);
 
   // Allocates a handle in the current zone. This handle will be destroyed
   // when the current zone is destroyed.
@@ skipping 22 matching lines @@
  private:
   // Base structure for managing blocks of handles.
   // Handles are allocated in Chunks (each chunk holds kHandlesPerChunk
   // handles). The chunk is uninitialized, subsequent requests for handles
   // is allocated from the chunk until we run out space in the chunk,
   // at this point another chunk is allocated. These chunks are chained
   // together.
   class HandlesBlock {
    public:
     explicit HandlesBlock(HandlesBlock* next)
-        : next_handle_slot_(0),
+        : last_visited_handle_(0),
+          next_handle_slot_(0),
           next_block_(next) { }
     ~HandlesBlock();
 
     // Reinitializes handle block for reuse.
     void ReInit();
 
     // Returns true if the handle block is full.
     bool IsFull() const {
       return next_handle_slot_ >= (kHandleSizeInWords * kHandlesPerChunk);
     }
 
     // Returns true if passed in handle belongs to this block.
     bool IsValidHandle(uword handle) const {
       uword start = reinterpret_cast<uword>(data_);
       uword end = start + (kHandleSizeInWords * kWordSize * kHandlesPerChunk);
       return (start <= handle && handle < end);
     }
 
     // Allocates space for a handle in the data area.
     uword AllocateHandle() {
       ASSERT(!IsFull());
       uword handle_address = reinterpret_cast<uword>(data_ + next_handle_slot_);
       next_handle_slot_ += kHandleSizeInWords;
       return handle_address;
     }
 
     // Visit all object pointers in the handle block.
     void VisitObjectPointers(ObjectPointerVisitor* visitor);
 
+    // Visit all the object pointers in the block since the last time this
+    // method was called.
+    void VisitUnvisitedObjectPointers(ObjectPointerVisitor* visitor);
+
     // Visit all of the handles in the handle block.
     void Visit(HandleVisitor* visitor);
 
 #if defined(DEBUG)
     // Zaps the free handle area to an uninitialized value.
     void ZapFreeHandles();
 #endif
 
     // Returns number of active handles in the handle block.
     int HandleCount() const;
 
     // Accessors.
     intptr_t next_handle_slot() const { return next_handle_slot_; }
     void set_next_handle_slot(intptr_t next_handle_slot) {
       next_handle_slot_ = next_handle_slot;
     }
     HandlesBlock* next_block() const { return next_block_; }
     void set_next_block(HandlesBlock* next) { next_block_ = next; }
 
    private:
+    // Last handle visited by VisitUnvisitedObjectPointers.  Handles
+    // at, or beyond this index are new.
+    intptr_t last_visited_handle_;
+
     uword data_[kHandleSizeInWords * kHandlesPerChunk];  // Handles area.
     intptr_t next_handle_slot_;  // Next slot for allocation in current block.
     HandlesBlock* next_block_;  // Link to next block of handles.
 
     DISALLOW_COPY_AND_ASSIGN(HandlesBlock);
   };
 
   // Deletes all the allocated handle blocks.
   void DeleteAll();
   void DeleteHandleBlocks(HandlesBlock* blocks);
@@ skipping 16 matching lines @@
   // Verifies consistency of handle blocks after a scope is destroyed.
   void VerifyScopedHandleState();
 
   // Zaps the free scoped handles to an uninitialized value.
   void ZapFreeScopedHandles();
 #endif
 
   HandlesBlock* zone_blocks_;  // List of zone handles.
   HandlesBlock first_scoped_block_;  // First block of scoped handles.
   HandlesBlock* scoped_blocks_;  // List of scoped handles.
+  // Last block visited by VisitUnvisitedHandles.
+  HandlesBlock* last_visited_block_;
 
   friend class HandleScope;
   friend class Symbols;
   DISALLOW_ALLOCATION();
   DISALLOW_COPY_AND_ASSIGN(Handles);
 };
 
 
 static const int kVMHandleSizeInWords = 2;
 static const int kVMHandlesPerChunk = 64;
@@ skipping 92 matching lines @@
 };
 #endif  // defined(DEBUG)
 
 // Macro to start a no handles scope in the code.
 #define NOHANDLESCOPE(isolate)                                                \
     dart::NoHandleScope no_vm_internal_handles_scope_(isolate);
 
 }  // namespace dart
 
 #endif  // VM_HANDLES_H_