Reimplemented zone memory tracking to avoid race conditions that were causing crashes in the previo…

runtime/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/dart_api_state.h"
 #include "vm/flags.h"
@@ skipping 10 matching lines @@
  public:
   Segment* next() const { return next_; }
   intptr_t size() const { return size_; }
 
   uword start() { return address(sizeof(Segment)); }
   uword end() { return address(size_); }
 
   // Allocate or delete individual segments.
   static Segment* New(intptr_t size, Segment* next);
   static void DeleteSegmentList(Segment* segment);
+  static void IncrementMemoryCapacity(uintptr_t size);
+  static void DecrementMemoryCapacity(uintptr_t size);
 
  private:
   Segment* next_;
   intptr_t size_;
 
   // Computes the address of the nth byte in this segment.
   uword address(int n) { return reinterpret_cast<uword>(this) + n; }
 
   static void Delete(Segment* segment) { free(segment); }
 
   DISALLOW_IMPLICIT_CONSTRUCTORS(Segment);
 };
 
 
+Zone::Segment* Zone::Segment::New(intptr_t size, Zone::Segment* next) {
+  ASSERT(size >= 0);
+  Segment* result = reinterpret_cast<Segment*>(malloc(size));
+  if (result == NULL) {
+    OUT_OF_MEMORY();
+  }
+  ASSERT(Utils::IsAligned(result->start(), Zone::kAlignment));
+#ifdef DEBUG
+  // Zap the entire allocated segment (including the header).
+  memset(result, kZapUninitializedByte, size);
+#endif
+  result->next_ = next;
+  result->size_ = size;
+  IncrementMemoryCapacity(size);
+  return result;
+}
+
+
 void Zone::Segment::DeleteSegmentList(Segment* head) {
   Segment* current = head;
-  Thread* current_thread = Thread::Current();
   while (current != NULL) {
-    if (current_thread != NULL) {
-      current_thread->DecrementMemoryUsage(current->size());
-    } else if (ApiNativeScope::Current() != NULL) {
-      // If there is no current thread, we might be inside of a native scope.
-      ApiNativeScope::DecrementNativeScopeMemoryUsage(current->size());
-    }
+    DecrementMemoryCapacity(current->size());
     Segment* next = current->next();
 #ifdef DEBUG
     // Zap the entire current segment (including the header).
     memset(current, kZapDeletedByte, current->size());
 #endif
     Segment::Delete(current);
     current = next;
   }
 }
 
 
-Zone::Segment* Zone::Segment::New(intptr_t size, Zone::Segment* next) {
-  ASSERT(size >= 0);
-  Segment* result = reinterpret_cast<Segment*>(malloc(size));
-  if (result == NULL) {
-    OUT_OF_MEMORY();
-  }
-  ASSERT(Utils::IsAligned(result->start(), Zone::kAlignment));
-#ifdef DEBUG
-  // Zap the entire allocated segment (including the header).
-  memset(result, kZapUninitializedByte, size);
-#endif
-  result->next_ = next;
-  result->size_ = size;
-  Thread* current = Thread::Current();
-  if (current != NULL) {
-    current->IncrementMemoryUsage(size);
+void Zone::Segment::IncrementMemoryCapacity(uintptr_t size) {
+  Thread* current_thread = Thread::Current();
+  if (current_thread != NULL) {
+    current_thread->IncrementMemoryCapacity(size);
   } else if (ApiNativeScope::Current() != NULL) {
     // If there is no current thread, we might be inside of a native scope.
-    ApiNativeScope::IncrementNativeScopeMemoryUsage(size);
+    ApiNativeScope::IncrementNativeScopeMemoryCapacity(size);
   }
-  return result;
 }
 
+
+void Zone::Segment::DecrementMemoryCapacity(uintptr_t size) {
+  Thread* current_thread = Thread::Current();
+  if (current_thread != NULL) {
+    current_thread->DecrementMemoryCapacity(size);
+  } else if (ApiNativeScope::Current() != NULL) {
+    // If there is no current thread, we might be inside of a native scope.
+    ApiNativeScope::DecrementNativeScopeMemoryCapacity(size);
+  }
+}
+
+
 // TODO(bkonyi): We need to account for the initial chunk size when a new zone
 // is created within a new thread or ApiNativeScope when calculating high
 // watermarks or memory consumption.
 Zone::Zone()
     : initial_buffer_(buffer_, kInitialChunkSize),
       position_(initial_buffer_.start()),
       limit_(initial_buffer_.end()),
       head_(NULL),
       large_segments_(NULL),
       handles_(),
       previous_(NULL) {
   ASSERT(Utils::IsAligned(position_, kAlignment));
-  Thread* current = Thread::Current();
-  if (current != NULL) {
-    current->IncrementMemoryUsage(kInitialChunkSize);
-  }
+  Segment::IncrementMemoryCapacity(kInitialChunkSize);
 #ifdef DEBUG
   // Zap the entire initial buffer.
   memset(initial_buffer_.pointer(), kZapUninitializedByte,
          initial_buffer_.size());
 #endif
 }
 
 
 Zone::~Zone() {
   if (FLAG_trace_zones) {
     DumpZoneSizes();
   }
-  Thread* current = Thread::Current();
-  if (current != NULL) {
-    current->DecrementMemoryUsage(kInitialChunkSize);
-  }
   DeleteAll();
+  Segment::DecrementMemoryCapacity(kInitialChunkSize);
 }
 
 
 void Zone::DeleteAll() {
   // Traverse the chained list of segments, zapping (in debug mode)
   // and freeing every zone segment.
   if (head_ != NULL) {
     Segment::DeleteSegmentList(head_);
   }
   if (large_segments_ != NULL) {
     Segment::DeleteSegmentList(large_segments_);
   }
 // Reset zone state.
 #ifdef DEBUG
   memset(initial_buffer_.pointer(), kZapDeletedByte, initial_buffer_.size());
 #endif
   position_ = initial_buffer_.start();
   limit_ = initial_buffer_.end();
   head_ = NULL;
   large_segments_ = NULL;
   previous_ = NULL;
   handles_.Reset();
 }
 
 
-intptr_t Zone::SizeInBytes() const {
-  intptr_t size = 0;
+uintptr_t Zone::SizeInBytes() const {
+  uintptr_t size = 0;
   for (Segment* s = large_segments_; s != NULL; s = s->next()) {
     size += s->size();
   }
   if (head_ == NULL) {
     return size + (position_ - initial_buffer_.start());
   }
   size += initial_buffer_.size();
   for (Segment* s = head_->next(); s != NULL; s = s->next()) {
     size += s->size();
   }
   return size + (position_ - head_->start());
 }
 
 
-intptr_t Zone::CapacityInBytes() const {
-  intptr_t size = 0;
+uintptr_t Zone::CapacityInBytes() const {
+  uintptr_t size = 0;
   for (Segment* s = large_segments_; s != NULL; s = s->next()) {
     size += s->size();
   }
   if (head_ == NULL) {
     return size + initial_buffer_.size();
   }
   size += initial_buffer_.size();
   for (Segment* s = head_; s != NULL; s = s->next()) {
     size += s->size();
   }
@@ skipping 118 matching lines @@
   va_end(args);
   return buffer;
 }
 
 
 char* Zone::VPrint(const char* format, va_list args) {
   return OS::VSCreate(this, format, args);
 }
 
 
-#ifndef PRODUCT
-// TODO(bkonyi): Currently dead code. See issue #28885.
-void Zone::PrintJSON(JSONStream* stream) const {
-  JSONObject jsobj(stream);
-  intptr_t capacity = CapacityInBytes();
-  intptr_t used_size = SizeInBytes();
-  jsobj.AddProperty("type", "_Zone");
-  jsobj.AddProperty("capacity", capacity);
-  jsobj.AddProperty("used", used_size);
-}
-#endif
-
-
 StackZone::StackZone(Thread* thread) : StackResource(thread), zone_() {
   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_));
   }
   zone_.Link(thread->zone());
   thread->set_zone(&zone_);
 }
 
 
 StackZone::~StackZone() {
   ASSERT(thread()->zone() == &zone_);
   thread()->set_zone(zone_.previous_);
   if (FLAG_trace_zones) {
     OS::PrintErr("*** Deleting Stack zone 0x%" Px "(0x%" Px ")\n",
                  reinterpret_cast<intptr_t>(this),
                  reinterpret_cast<intptr_t>(&zone_));
   }
 }
 
 }  // namespace dart