Added code to trace zone and handles creation/deletion under flags

vm/dart_api_state.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_DART_API_STATE_H_
 #define VM_DART_API_STATE_H_
 
 #include "include/dart_api.h"
 
 #include "platform/thread.h"
 #include "vm/dart_api_impl.h"
 #include "vm/flags.h"
 #include "vm/growable_array.h"
 #include "vm/handles.h"
 #include "vm/object.h"
 #include "vm/os.h"
 #include "vm/raw_object.h"
 #include "vm/visitor.h"
 
 #include "vm/handles_impl.h"
 
 namespace dart {
 
+DECLARE_DEBUG_FLAG(bool, trace_zones);
+DECLARE_DEBUG_FLAG(bool, trace_handles);
+
 // Implementation of Zone support for very fast allocation of small chunks
 // of memory. The chunks cannot be deallocated individually, but instead
 // zones support deallocating all chunks in one fast operation when the
 // scope is exited.
 class ApiZone {
  public:
   // Create an empty zone.
   ApiZone() : zone_() {
     Isolate* isolate = Isolate::Current();
     Zone* current_zone = isolate != NULL ? isolate->current_zone() : NULL;
     zone_.Link(current_zone);
     if (isolate != NULL) {
       isolate->set_current_zone(&zone_);
     }
+#ifdef DEBUG
+    if (FLAG_trace_zones) {
+      OS::PrintErr("*** Starting a new Api zone 0x%"Px"(0x%"Px")\n",
+                   reinterpret_cast<intptr_t>(this),
+                   reinterpret_cast<intptr_t>(&zone_));
+    }
+#endif
   }
 
   // Delete all memory associated with the zone.
   ~ApiZone() {
     Isolate* isolate = Isolate::Current();
     if (isolate != NULL && isolate->current_zone() == &zone_) {
       isolate->set_current_zone(zone_.previous_);
     }
+#ifdef DEBUG
+    if (FLAG_trace_zones) {
+      OS::PrintErr("*** Deleting Api zone 0x%"Px"(0x%"Px")\n",
+                   reinterpret_cast<intptr_t>(this),
+                   reinterpret_cast<intptr_t>(&zone_));
+    }
+#endif
   }
 
   // Allocates an array sized to hold 'len' elements of type
   // 'ElementType'.  Checks for integer overflow when performing the
   // size computation.
   template <class ElementType>
   ElementType* Alloc(intptr_t len) { return zone_.Alloc<ElementType>(len); }
 
   // Allocates an array sized to hold 'len' elements of type
   // 'ElementType'.  The new array is initialized from the memory of
@@ skipping 157 matching lines @@
 // Local handles repository structure.
 static const int kLocalHandleSizeInWords = sizeof(LocalHandle) / kWordSize;
 static const int kLocalHandlesPerChunk = 64;
 static const int kOffsetOfRawPtrInLocalHandle = 0;
 class LocalHandles : Handles<kLocalHandleSizeInWords,
                              kLocalHandlesPerChunk,
                              kOffsetOfRawPtrInLocalHandle> {
  public:
   LocalHandles() : Handles<kLocalHandleSizeInWords,
                            kLocalHandlesPerChunk,
-                           kOffsetOfRawPtrInLocalHandle>() { }
-  ~LocalHandles() { }
+                           kOffsetOfRawPtrInLocalHandle>() {
+#ifdef DEBUG
+    if (FLAG_trace_handles) {
+      OS::PrintErr("*** Starting a new Local handle block 0x%"Px"\n",
+                   reinterpret_cast<intptr_t>(this));
+    }
+#endif
+  }
+  ~LocalHandles() {
+#ifdef DEBUG
+    if (FLAG_trace_handles) {
+      OS::PrintErr("***   Handle Counts for 0x(%"Px"):Scoped = %d\n",
+                   reinterpret_cast<intptr_t>(this),
+                   CountHandles());
+      OS::PrintErr("*** Deleting Local handle block 0x%"Px"\n",
+                   reinterpret_cast<intptr_t>(this));
+    }
+#endif
+  }
 
 
   // Visit all object pointers stored in the various handles.
   void VisitObjectPointers(ObjectPointerVisitor* visitor) {
     Handles<kLocalHandleSizeInWords,
             kLocalHandlesPerChunk,
             kOffsetOfRawPtrInLocalHandle>::VisitObjectPointers(visitor);
   }
 
   // Allocates a handle in the current handle scope. This handle is valid only
@@ skipping 23 matching lines @@
     sizeof(PersistentHandle) / kWordSize;
 static const int kPersistentHandlesPerChunk = 64;
 static const int kOffsetOfRawPtrInPersistentHandle = 0;
 class PersistentHandles : Handles<kPersistentHandleSizeInWords,
                                   kPersistentHandlesPerChunk,
                                   kOffsetOfRawPtrInPersistentHandle> {
  public:
   PersistentHandles() : Handles<kPersistentHandleSizeInWords,
                                 kPersistentHandlesPerChunk,
                                 kOffsetOfRawPtrInPersistentHandle>(),
-        free_list_(NULL) { }
+        free_list_(NULL) {
+#ifdef DEBUG
+    if (FLAG_trace_handles) {
+      OS::PrintErr("*** Starting a new Persistent handle block 0x%"Px"\n",
+                   reinterpret_cast<intptr_t>(this));
+    }
+#endif
+  }
   ~PersistentHandles() {
     free_list_ = NULL;
+#ifdef DEBUG
+    if (FLAG_trace_handles) {
+      OS::PrintErr("***   Handle Counts for 0x(%"Px"):Scoped = %d\n",
+                   reinterpret_cast<intptr_t>(this),
+                   CountHandles());
+      OS::PrintErr("*** Deleting Persistent handle block 0x%"Px"\n",
+                   reinterpret_cast<intptr_t>(this));
+    }
+#endif
   }
 
   // Accessors.
   PersistentHandle* free_list() const { return free_list_; }
   void set_free_list(PersistentHandle* value) { free_list_ = value; }
 
   // Visit all object pointers stored in the various handles.
   void VisitObjectPointers(ObjectPointerVisitor* visitor) {
     Handles<kPersistentHandleSizeInWords,
             kPersistentHandlesPerChunk,
@@ skipping 403 matching lines @@
           ApiNativeScope::Current()->zone()) {}
   ApiGrowableArray()
       : BaseGrowableArray<T, ValueObject>(
           ApiNativeScope::Current()->zone()) {}
 };
 
 
 }  // namespace dart
 
 #endif  // VM_DART_API_STATE_H_