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

vm/zone.cc

 // 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.
 
 #include "vm/zone.h"
 
 #include "platform/assert.h"
 #include "platform/utils.h"
 #include "vm/flags.h"
 #include "vm/heap.h"
 #include "vm/heap_trace.h"
 #include "vm/isolate.h"
 #include "vm/os.h"
 
 namespace dart {
 
-DEFINE_DEBUG_FLAG(bool, trace_zone_sizes,
+DEFINE_DEBUG_FLAG(bool, trace_zones,
                   false, "Traces allocation sizes in the zone.");
 
 
 // Zone segments represent chunks of memory: They have starting
 // address encoded in the this pointer and a size in bytes. They are
 // chained together to form the backing storage for an expanding zone.
 class Zone::Segment {
  public:
   Segment* next() const { return next_; }
   intptr_t size() const { return size_; }
@@ skipping 49 matching lines @@
 
 Zone::Zone()
     : initial_buffer_(buffer_, kInitialChunkSize),
       position_(initial_buffer_.start()),
       limit_(initial_buffer_.end()),
       head_(NULL),
       large_segments_(NULL),
       handles_(),
       previous_(NULL) {
 #ifdef DEBUG
-    // Zap the entire initial buffer.
+  // Zap the entire initial buffer.
   memset(initial_buffer_.pointer(), kZapUninitializedByte,
          initial_buffer_.size());
 #endif
 }
 
 
 Zone::~Zone() {
+#if defined(DEBUG)
+  if (FLAG_trace_zones) {
+    DumpZoneSizes();
+  }
+#endif
   DeleteAll();
   if (HeapTrace::is_enabled()) {
     Isolate* isolate = Isolate::Current();
     isolate->heap()->trace()->TraceDeleteZone(this);
   }
-#if defined(DEBUG)
-  if (FLAG_trace_zone_sizes) {
-    DumpZoneSizes();
-  }
-#endif
 }
 
 
 void Zone::DeleteAll() {
   // Traverse the chained list of segments, zapping (in debug mode)
   // and freeing every zone segment.
   Segment::DeleteSegmentList(head_);
   Segment::DeleteSegmentList(large_segments_);
 
   // Reset zone state.
@@ skipping 19 matching lines @@
   for (Segment* s = head_->next(); s != NULL; s = s->next()) {
     size += s->size();
   }
   return size + (position_ - head_->start());
 }
 
 
 uword Zone::AllocateExpand(intptr_t size) {
 #if defined(DEBUG)
   ASSERT(size >= 0);
-  if (FLAG_trace_zone_sizes) {
+  if (FLAG_trace_zones) {
+    OS::PrintErr("*** Expanding zone 0x%"Px"\n",
+                 reinterpret_cast<intptr_t>(this));
     DumpZoneSizes();
   }
   // Make sure the requested size is already properly aligned and that
   // there isn't enough room in the Zone to satisfy the request.
   ASSERT(Utils::IsAligned(size, kAlignment));
   intptr_t free_size = (limit_ - position_);
   ASSERT(free_size <  size);
 #endif
 
   // First check to see if we should just chain it as a large segment.
@@ skipping 43 matching lines @@
   return copy;
 }
 
 
 #if defined(DEBUG)
 void Zone::DumpZoneSizes() {
   intptr_t size = 0;
   for (Segment* s = large_segments_; s != NULL; s = s->next()) {
     size += s->size();
   }
-  OS::Print("Size in bytes allocated, Total = %"Pd" Large Segments = %"Pd"\n",
-            SizeInBytes(), size);
+  OS::PrintErr("***   Zone(0x%"Px") size in bytes,"
+               " Total = %"Pd" Large Segments = %"Pd"\n",
+               reinterpret_cast<intptr_t>(this), SizeInBytes(), size);
 }
 #endif
 
 
 StackZone::StackZone(BaseIsolate* isolate)
     : StackResource(isolate),
       zone_() {
+#ifdef DEBUG
+  if (FLAG_trace_zones) {
+    OS::PrintErr("*** Starting a new Stack zone 0x%"Px"(0x%"Px")\n",
+                 reinterpret_cast<intptr_t>(this),
+                 reinterpret_cast<intptr_t>(&zone_));
+  }
+#endif
   zone_.Link(isolate->current_zone());
   isolate->set_current_zone(&zone_);
 }
 
 
 StackZone::~StackZone() {
   ASSERT(isolate()->current_zone() == &zone_);
   isolate()->set_current_zone(zone_.previous_);
+#ifdef DEBUG
+  if (FLAG_trace_zones) {
+    OS::PrintErr("*** Deleting Stack zone 0x%"Px"(0x%"Px")\n",
+                 reinterpret_cast<intptr_t>(this),
+                 reinterpret_cast<intptr_t>(&zone_));
+  }
+#endif
 }
 
 
 void Zone::VisitObjectPointers(ObjectPointerVisitor* visitor) {
   Zone* zone = this;
   while (zone != NULL) {
     zone->handles()->VisitObjectPointers(visitor);
     zone = zone->previous_;
   }
 }
 
 
 char* Zone::PrintToString(const char* format, ...) {
   va_list args;
   va_start(args, format);
   intptr_t len = OS::VSNPrint(NULL, 0, format, args);
   va_end(args);
 
   char* buffer = Alloc<char>(len + 1);
   va_list args2;
   va_start(args2, format);
   OS::VSNPrint(buffer, (len + 1), format, args2);
   va_end(args2);
 
   return buffer;
 }
 
 
 }  // namespace dart