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

runtime/vm/heap.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_HEAP_H_
 #define VM_HEAP_H_
 
 #include "platform/assert.h"
 #include "vm/allocation.h"
 #include "vm/flags.h"
 #include "vm/globals.h"
 #include "vm/pages.h"
 #include "vm/scavenger.h"
 
 namespace dart {
 
 // Forward declarations.
+class HeapTrace;
 class Isolate;
 class ObjectPointerVisitor;
 class ObjectSet;
 class VirtualMemory;
 
 DECLARE_FLAG(bool, verbose_gc);
 DECLARE_FLAG(bool, verify_before_gc);
 DECLARE_FLAG(bool, verify_after_gc);
 DECLARE_FLAG(bool, gc_at_alloc);
 
@@ skipping 113 matching lines @@
   uword TopAddress();
   uword EndAddress();
   static intptr_t new_space_offset() { return OFFSET_OF(Heap, new_space_); }
 
   // Initialize the heap and register it with the isolate.
   static void Init(Isolate* isolate);
 
   // Verify that all pointers in the heap point to the heap.
   bool Verify() const;
 
+  // Accessor function to get the HeapTrace used for tracing.  There
+  // should only ever be one of these per isolate
+  HeapTrace* trace() { return heap_trace_; }

[siva, 2012/12/05 16:06:40]

const

[cshapiro, 2012/12/08 03:23:08]

Fixed.

+
   // Print heap sizes.
   void PrintSizes() const;
 
   // Returns the [lowest, highest) addresses in the heap.
   void StartEndAddress(uword* start, uword* end) const;
 
   ObjectSet* CreateAllocatedObjectSet() const;
 
   // Generates a profile of the current and VM isolate heaps.
-  void Profile(Dart_HeapProfileWriteCallback callback, void* stream) const;
+  void Profile(Dart_FileWriteCallback callback, void* stream) const;
 
   static const char* GCReasonToString(GCReason gc_reason);
 
   // Associates a peer with an object.  If an object has a peer, it is
   // replaced.  A value of NULL disassociate an object from its peer.
   void SetPeer(RawObject* raw_obj, void* peer);
 
   // Retrieves the peer associated with an object.  Returns NULL if
   // there is no association.
   void* GetPeer(RawObject* raw_obj);
 
   // Returns the number of objects with a peer.
   int64_t PeerCount() const;
 
  private:
   Heap();
 
   uword AllocateNew(intptr_t size);
   uword AllocateOld(intptr_t size, HeapPage::PageType type);
 
   // The different spaces used for allocation.
   Scavenger* new_space_;
   PageSpace* old_space_;
 
+  // The active trace for this heap.  NULL if tracing is not enabled.
+  HeapTrace* heap_trace_;
+
   // This heap is in read-only mode: No allocation is allowed.
   bool read_only_;
 
   friend class GCTestHelper;
   DISALLOW_COPY_AND_ASSIGN(Heap);
 };
 
 
 #if defined(DEBUG)
 class NoGCScope : public StackResource {
  public:
   NoGCScope();
   ~NoGCScope();
  private:
   DISALLOW_COPY_AND_ASSIGN(NoGCScope);
 };
 #else  // defined(DEBUG)
 class NoGCScope : public ValueObject {
  public:
   NoGCScope() {}
  private:
   DISALLOW_COPY_AND_ASSIGN(NoGCScope);
 };
 #endif  // defined(DEBUG)
 
 }  // namespace dart
 
 #endif  // VM_HEAP_H_