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 29 matching lines @@
 
   DISALLOW_IMPLICIT_CONSTRUCTORS(Segment);
 };
 
 
 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());
+      current_thread->DecrementMemoryCapacity(current->size());

[Cutch, 2017/03/22 17:21:49]

ditto here:

IncrementThreadMemoryCapacity / DecrementThreadMemoryCapacity

Fold all the current_thread != NULL checks into those two functions and call
those functions instead of littering the code with the checks.

[bkonyi, 2017/03/22 18:01:48]

Done.

     } else if (ApiNativeScope::Current() != NULL) {
       // If there is no current thread, we might be inside of a native scope.
-      ApiNativeScope::DecrementNativeScopeMemoryUsage(current->size());
+      ApiNativeScope::DecrementNativeScopeMemoryCapacity(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);
+  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;
 }
 
 // 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);
+  Thread* current_thread = Thread::Current();
+  if (current_thread != NULL) {
+    current_thread->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();
+
+  Thread* current_thread = Thread::Current();
+  if (current_thread != NULL) {
+    current_thread->DecrementMemoryCapacity(kInitialChunkSize);
   }
-  DeleteAll();
 }
 
 
 void Zone::DeleteAll() {
+  Thread* current_thread = Thread::Current();
+  if (current_thread != NULL) {
+    current_thread->DecrementMemoryUsage(SizeInBytes());
+  }
   // 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();
   }
@@ skipping 10 matching lines @@
     return size + initial_buffer_.size();
   }
   size += initial_buffer_.size();
   for (Segment* s = head_; s != NULL; s = s->next()) {
     size += s->size();
   }
   return size;
 }
 
 
+intptr_t Zone::FreeCapacityInBytes() const {
+  if (head_ == NULL) {
+    return initial_buffer_.start() + initial_buffer_.size() - position_;
+  } else {
+    return head_->start() + head_->size() - position_;
+  }
+}
+
+
 uword Zone::AllocateExpand(intptr_t size) {
   ASSERT(size >= 0);
   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);
 
   // First check to see if we should just chain it as a large segment.
   intptr_t max_size =
       Utils::RoundDown(kSegmentSize - sizeof(Segment), kAlignment);
   ASSERT(max_size > 0);
   if (size > max_size) {
     return AllocateLargeSegment(size);
   }
 
+  intptr_t remaining_capacity = FreeCapacityInBytes();
+
   // Allocate another segment and chain it up.
   head_ = Segment::New(kSegmentSize, head_);
 
+  Thread* current_thread = Thread::Current();
+  if (current_thread != NULL) {
+    current_thread->IncrementMemoryUsage(remaining_capacity + size);
+  }
+
   // Recompute 'position' and 'limit' based on the new head segment.
   uword result = Utils::RoundUp(head_->start(), kAlignment);
   position_ = result + size;
   limit_ = head_->end();
   ASSERT(position_ <= limit_);
   return result;
 }
 
 
 uword Zone::AllocateLargeSegment(intptr_t size) {
   ASSERT(size >= 0);
   // 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);
 
   // Create a new large segment and chain it up.
   ASSERT(Utils::IsAligned(sizeof(Segment), kAlignment));
   size += sizeof(Segment);  // Account for book keeping fields in size.
   large_segments_ = Segment::New(size, large_segments_);
 
+  Thread* current_thread = Thread::Current();
+  if (current_thread != NULL) {
+    current_thread->IncrementMemoryUsage(size);
+  }
+
   uword result = Utils::RoundUp(large_segments_->start(), kAlignment);
   return result;
 }
 
 
 char* Zone::MakeCopyOfString(const char* str) {
   intptr_t len = strlen(str) + 1;  // '\0'-terminated.
   char* copy = Alloc<char>(len);
   strncpy(copy, str, len);
   return copy;
@@ skipping 58 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