Make unused semispace available to other isolates.

runtime/vm/scavenger.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_SCAVENGER_H_
 #define VM_SCAVENGER_H_
 
 #include "platform/assert.h"
 #include "platform/utils.h"
 #include "vm/dart.h"
 #include "vm/flags.h"
 #include "vm/globals.h"
 #include "vm/raw_object.h"
 #include "vm/spaces.h"
 #include "vm/virtual_memory.h"
 #include "vm/visitor.h"
 
 namespace dart {
 
 // Forward declarations.
 class Heap;
 class Isolate;
 class JSONObject;
 class ScavengerVisitor;
 
 DECLARE_FLAG(bool, gc_at_alloc);
 
+
+// Wrapper around VirtualMemory that adds caching and handles the empty case.
+class SemiSpace {
+ public:

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

Please use vertical space for easier reading.

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

Done.

+  static void InitOnce();
+  // Get a space of the given size. Returns NULL on out of memory. If size is 0,
+  // returns an empty space: pointer(), start() and end() all return NULL/0.
+  static SemiSpace* New(intptr_t size);
+  // Hand back an unused space. Safe to call on NULL.

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

Why would we ever want to call Delete on NULL?

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

Allowing NULL keeps it consistent with the 'delete' operator, and may save some
if-statements.

But if you prefer, we can disallow it.

[koda, 2014/06/05 23:08:29]

Actually, the commit failure check in this very CL (scavenger.cc) is an example
of when 'delete' on NULL is convenient.

+  void Delete();
+  void* pointer() const { return region_.pointer(); }
+  uword start() const { return region_.start(); }
+  uword end() const { return region_.end(); }
+  intptr_t size() const { return static_cast<intptr_t>(region_.size()); }
+  bool Contains(uword address) const { return region_.Contains(address); }
+  // Set write protection mode for this space. The space must not be protected
+  // when Delete is called.
+  // TODO(koda): Remember protection mode in VirtualMemory and assert this.
+  void WriteProtect(bool read_only);

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

Do we ever write protect a new gen?

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

Heap::WriteProtect includes new gen, but it's currently only called for the VM
isolate, whose new gen is empty.

But in any case, I think it makes sense to have VirtualMemory remember its
protection mode.

I'm fine with either:
a) Unprotect the memory in Delete if needed.
b) Only support write-protect on a heap when its new gen is empty.

What do you think?

+ private:
+  explicit SemiSpace(VirtualMemory* reserved);
+  ~SemiSpace();
+  VirtualMemory* reserved_;  // NULL for an emtpy space.
+  MemoryRegion region_;
+  static SemiSpace* cache_;
+  static Mutex* mutex_;
+};
+
+
 class Scavenger {
  public:
   Scavenger(Heap* heap, intptr_t max_capacity_in_words, uword object_alignment);
   ~Scavenger();
 
   // Check whether this Scavenger contains this address.
   // During scavenging both the to and from spaces contain "legal" objects.
   // During a scavenge this function only returns true for addresses that will
   // be part of the surviving objects.
   bool Contains(uword addr) const {
     // No reasonable algorithm should be checking for objects in from space. At
     // least unless it is debugging code. This might need to be relaxed later,
     // but currently it helps prevent dumb bugs.
-    ASSERT(!from_->Contains(addr));
+    ASSERT(from_ == NULL || !from_->Contains(addr));
     return to_->Contains(addr);
   }
 
   RawObject* FindObject(FindObjectVisitor* visitor) const;
 
   uword TryAllocate(intptr_t size) {
     ASSERT(Utils::IsAligned(size, kObjectAlignment));
     ASSERT(heap_ != Dart::vm_isolate()->heap());
 #if defined(DEBUG)
     if (FLAG_gc_at_alloc && !scavenging_) {
@@ skipping 124 matching lines @@
     ASSERT(end_ <= to_->end());
     return result;
   }
   bool PromotedStackHasMore() const {
     ASSERT(scavenging_);
     return end_ < to_->end();
   }
 
   void ProcessWeakTables();
 
-  VirtualMemory* space_;
-  MemoryRegion* to_;
-  MemoryRegion* from_;
+  SemiSpace* from_;
+  SemiSpace* to_;
 
   Heap* heap_;
 
   // Current allocation top and end. These values are being accessed directly
   // from generated code.
   uword top_;
   uword end_;
 
   // A pointer to the first unscanned object.  Scanning completes when
   // this value meets the allocation top.
@@ skipping 16 matching lines @@
 
   friend class ScavengerVisitor;
   friend class ScavengerWeakVisitor;
 
   DISALLOW_COPY_AND_ASSIGN(Scavenger);
 };
 
 }  // namespace dart
 
 #endif  // VM_SCAVENGER_H_