Make unused semispace available to other isolates.

runtime/vm/scavenger.cc

 // Copyright (c) 2011, 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/scavenger.h"
 
 #include <algorithm>
 #include <map>
 #include <utility>
 
 #include "vm/dart.h"
 #include "vm/dart_api_state.h"
 #include "vm/isolate.h"
 #include "vm/object.h"
 #include "vm/stack_frame.h"
 #include "vm/store_buffer.h"
+#include "vm/thread.h"
 #include "vm/verifier.h"
 #include "vm/visitor.h"
 #include "vm/weak_table.h"
 #include "vm/object_id_ring.h"
 
 namespace dart {
 
   DEFINE_FLAG(int, early_tenuring_threshold, 66, "Skip TO space when promoting"
                                                  " above this percentage.");
 
@@ skipping 251 matching lines @@
   bool prologue_weak_were_strong_;
 
   DISALLOW_COPY_AND_ASSIGN(ScavengerWeakVisitor);
 };
 
 
 // Visitor used to verify that all old->new references have been added to the
 // StoreBuffers.
 class VerifyStoreBufferPointerVisitor : public ObjectPointerVisitor {
  public:
-  VerifyStoreBufferPointerVisitor(Isolate* isolate, MemoryRegion* to)
+  VerifyStoreBufferPointerVisitor(Isolate* isolate,
+                                  const SemiSpace* to)
       : ObjectPointerVisitor(isolate), to_(to) {}
 
   void VisitPointers(RawObject** first, RawObject** last) {
     for (RawObject** current = first; current <= last; current++) {
       RawObject* obj = *current;
       if (obj->IsHeapObject() && obj->IsNewObject()) {
         ASSERT(to_->Contains(RawObject::ToAddr(obj)));
       }
     }
   }
 
  private:
-  MemoryRegion* to_;
+  const SemiSpace* to_;
 
   DISALLOW_COPY_AND_ASSIGN(VerifyStoreBufferPointerVisitor);
 };
 
 
+SemiSpace::SemiSpace(VirtualMemory* reserved)
+    : reserved_(reserved), region_(NULL, 0) {
+  if (reserved != NULL) {
+    region_ = MemoryRegion(reserved_->address(), reserved_->size());
+  }
+}
+
+
+SemiSpace::~SemiSpace() {
+  if (reserved_ != NULL) {
+#if defined(DEBUG)
+    memset(reserved_->address(), 0xf3, size());
+#endif  // defined(DEBUG)
+    delete reserved_;
+  }
+}
+
+
+Mutex* SemiSpace::mutex_ = NULL;
+SemiSpace* SemiSpace::cache_ = NULL;
+
+
+void SemiSpace::InitOnce() {
+  ASSERT(mutex_ == NULL);
+  mutex_ = new Mutex();
+  ASSERT(mutex_ != NULL);
+}
+
+
+SemiSpace* SemiSpace::New(intptr_t size) {
+  {
+    MutexLocker locker(mutex_);
+    if (cache_ != NULL && cache_->size() == size) {
+      SemiSpace* result = cache_;
+      cache_ = NULL;
+      return result;
+    }
+  }
+  if (size == 0) {
+    return new SemiSpace(NULL);
+  } else {
+    VirtualMemory* reserved = VirtualMemory::Reserve(size);
+    if (reserved == NULL || !reserved->Commit(VirtualMemory::kReadWrite)) {

[Ivan Posva, 2014/06/05 22:27:28]

(reserved == NULL)

[koda, 2014/06/05 23:04:23]

Done.

+      // TODO(koda): If cache_ is not empty, we could try to delete it.

[Ivan Posva, 2014/06/05 22:27:28]

If Commit failed you probably do not want to leak the virtual address space
associated with the reservation.

[koda, 2014/06/05 23:04:23]

Done.

+      return NULL;
+    }
+#if defined(DEBUG)
+    memset(reserved->address(), 0xf3, size);
+#endif  // defined(DEBUG)
+    return new SemiSpace(reserved);
+  }
+}
+
+
+void SemiSpace::Delete() {
+  SemiSpace* old_cache = NULL;
+  {
+    MutexLocker locker(mutex_);
+    old_cache = cache_;
+    cache_ = this;
+  }
+  delete old_cache;
+}
+
+
+void SemiSpace::WriteProtect(bool read_only) {
+  if (reserved_ != NULL) {
+    bool success = reserved_->Protect(
+        read_only ? VirtualMemory::kReadOnly : VirtualMemory::kReadWrite);
+    ASSERT(success);
+  }
+}
+
+
 Scavenger::Scavenger(Heap* heap,
                      intptr_t max_capacity_in_words,
                      uword object_alignment)
     : heap_(heap),
       object_alignment_(object_alignment),
       scavenging_(false),
       gc_time_micros_(0),
       collections_(0),
       external_size_(0) {
   // Verify assumptions about the first word in objects which the scavenger is
   // going to use for forwarding pointers.
   ASSERT(Object::tags_offset() == 0);
 
-  if (max_capacity_in_words == 0) {
-    space_ = NULL;
-    to_ = new MemoryRegion(NULL, 0);
-    from_ = new MemoryRegion(NULL, 0);
-  } else {
-    // Allocate the virtual memory for this scavenge heap.
-    space_ = VirtualMemory::Reserve(max_capacity_in_words << kWordSizeLog2);
-    if (space_ == NULL) {
-      FATAL("Out of memory.\n");
-    }
-
-    // Allocate the entire space at the beginning.
-    space_->Commit(false);
-
-    // Setup the semi spaces.
-    uword semi_space_size = space_->size() / 2;
-    ASSERT((semi_space_size & (VirtualMemory::PageSize() - 1)) == 0);
-    to_ = new MemoryRegion(space_->address(), semi_space_size);
-    uword middle = space_->start() + semi_space_size;
-    from_ = new MemoryRegion(reinterpret_cast<void*>(middle), semi_space_size);
+  const intptr_t semi_space_size = (max_capacity_in_words / 2) * kWordSize;
+  to_ = SemiSpace::New(semi_space_size);
+  if (to_ == NULL) {
+    FATAL("Out of memory.\n");
   }
-
-  // Make sure that the two semi-spaces are aligned properly.
-  ASSERT(Utils::IsAligned(to_->start(), kObjectAlignment));
-  ASSERT(Utils::IsAligned(from_->start(), kObjectAlignment));
+  from_ = NULL;
 
   // Setup local fields.
   top_ = FirstObjectStart();
   resolved_top_ = top_;
   end_ = to_->end();
 
   survivor_end_ = FirstObjectStart();
-
-#if defined(DEBUG)
-  memset(to_->pointer(), 0xf3, to_->size());
-  memset(from_->pointer(), 0xf3, from_->size());
-#endif  // defined(DEBUG)
 }
 
 
 Scavenger::~Scavenger() {
-  delete to_;
-  delete from_;
-  delete space_;
+  from_->Delete();

[Ivan Posva, 2014/06/05 22:27:28]

ASSERT(from_ == NULL)

[koda, 2014/06/05 23:04:23]

Done.

+  to_->Delete();
 }
 
 
 void Scavenger::Prologue(Isolate* isolate, bool invoke_api_callbacks) {
   if (invoke_api_callbacks && (isolate->gc_prologue_callback() != NULL)) {
     (isolate->gc_prologue_callback())();
   }
   // Flip the two semi-spaces so that to_ is always the space for allocating
   // objects.
-  MemoryRegion* temp = from_;
   from_ = to_;
-  to_ = temp;
+  to_ = SemiSpace::New(from_->size());
+  if (to_ == NULL) {
+    // TODO(koda): We could try to recover (collect old space, wait for another
+    // isolate to finish scavenge, etc.).
+    FATAL("Out of memory.\n");
+  }
   top_ = FirstObjectStart();
   resolved_top_ = top_;
   end_ = to_->end();
 }
 
 
 void Scavenger::Epilogue(Isolate* isolate,
                          ScavengerVisitor* visitor,
                          bool invoke_api_callbacks) {
   // All objects in the to space have been copied from the from space at this
   // moment.
   int promotion_ratio = static_cast<int>(
       (static_cast<double>(visitor->bytes_promoted()) /
        static_cast<double>(to_->size())) * 100.0);
   if (promotion_ratio < FLAG_early_tenuring_threshold) {
     // Remember the limit to which objects have been copied.
     survivor_end_ = top_;
   } else {
     // Move survivor end to the end of the to_ space, making all surviving
     // objects candidates for promotion.
     survivor_end_ = end_;
   }
 
 #if defined(DEBUG)
   VerifyStoreBufferPointerVisitor verify_store_buffer_visitor(isolate, to_);
   heap_->IterateOldPointers(&verify_store_buffer_visitor);
-
-  memset(from_->pointer(), 0xf3, from_->size());
 #endif  // defined(DEBUG)
+  from_->Delete();
+  from_ = NULL;
   if (invoke_api_callbacks && (isolate->gc_epilogue_callback() != NULL)) {
     (isolate->gc_epilogue_callback())();
   }
 }
 
 
 void Scavenger::IterateStoreBuffers(Isolate* isolate,
                                     ScavengerVisitor* visitor) {
   StoreBuffer* buffer = isolate->store_buffer();
   heap_->RecordData(kStoreBufferEntries, buffer->Count());
@@ skipping 317 matching lines @@
     OS::PrintErr(" done.\n");
   }
 
   // Done scavenging. Reset the marker.
   ASSERT(scavenging_);
   scavenging_ = false;
 }
 
 
 void Scavenger::WriteProtect(bool read_only) {
-  if (space_ != NULL) {
-    space_->Protect(
-        read_only ? VirtualMemory::kReadOnly : VirtualMemory::kReadWrite);
-  }
+  ASSERT(!scavenging_);
+  ASSERT(from_ == NULL);
+  to_->WriteProtect(read_only);
 }
 
 
 void Scavenger::PrintToJSONObject(JSONObject* object) {
   JSONObject space(object, "new");
   space.AddProperty("type", "@Scavenger");
   space.AddProperty("id", "heaps/new");
   space.AddProperty("name", "Scavenger");
   space.AddProperty("user_name", "new");
   space.AddProperty("collections", collections());
@@ skipping 10 matching lines @@
 }
 
 
 void Scavenger::FreeExternal(intptr_t size) {
   ASSERT(size >= 0);
   external_size_ -= size;
   ASSERT(external_size_ >= 0);
 }
 
 }  // namespace dart