- Remove the from field from the the Scavenger class.

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>
 
@@ skipping 60 matching lines @@
   }
 
  private:
   bool* _addr;
   bool _value;
 };
 
 
 class ScavengerVisitor : public ObjectPointerVisitor {
  public:
-  explicit ScavengerVisitor(Isolate* isolate, Scavenger* scavenger)
+  explicit ScavengerVisitor(Isolate* isolate,
+                            Scavenger* scavenger,
+                            SemiSpace* from)
       : ObjectPointerVisitor(isolate),
         thread_(Thread::Current()),
         scavenger_(scavenger),
-        from_start_(scavenger_->from_->start()),
-        from_size_(scavenger_->from_->end() - scavenger_->from_->start()),
+        from_(from),
         heap_(scavenger->heap_),
         vm_heap_(Dart::vm_isolate()->heap()),
         page_space_(scavenger->heap_->old_space()),
         delayed_weak_stack_(),
         bytes_promoted_(0),
         visiting_old_object_(NULL),
         in_scavenge_pointer_(false) { }
 
   void VisitPointers(RawObject** first, RawObject** last) {
     for (RawObject** current = first; current <= last; current++) {
@@ skipping 52 matching lines @@
     ASSERT(!in_scavenge_pointer_);
     BoolScope bs(&in_scavenge_pointer_, true);
 #endif
 
     RawObject* raw_obj = *p;
 
     if (raw_obj->IsSmiOrOldObject()) {
       return;
     }
 
-    // The scavenger is only interested in objects located in the from space.
-    //
-    // We are using address math here and relying on the unsigned underflow
-    // in the code below to avoid having two checks.
-    uword obj_offset = reinterpret_cast<uword>(raw_obj) - from_start_;
-    if (obj_offset > from_size_) {
-      ASSERT(scavenger_->to_->Contains(RawObject::ToAddr(raw_obj)));
-      return;
-    }
-
     uword raw_addr = RawObject::ToAddr(raw_obj);
+    // The scavenger is only interested in objects located in the from space.
+    ASSERT(from_->Contains(raw_addr));
     // Read the header word of the object and determine if the object has
     // already been copied.
     uword header = *reinterpret_cast<uword*>(raw_addr);
     uword new_addr = 0;
     if (IsForwarding(header)) {
       // Get the new location of the object.
       new_addr = ForwardedAddr(header);
     } else {
       if (raw_obj->IsWatched()) {
         raw_obj->ClearWatchedBitUnsynchronized();
@@ skipping 55 matching lines @@
     *p = new_obj;
     // Update the store buffer as needed.
     if (visiting_old_object_ != NULL) {
       VerifiedMemory::Accept(reinterpret_cast<uword>(p), sizeof(*p));
       UpdateStoreBuffer(p, new_obj);
     }
   }
 
   Thread* thread_;
   Scavenger* scavenger_;
-  uword from_start_;
-  uword from_size_;
+  SemiSpace* from_;
   Heap* heap_;
   Heap* vm_heap_;
   PageSpace* page_space_;
   typedef std::multimap<RawObject*, RawWeakProperty*> DelaySet;
   DelaySet delay_set_;
   GrowableArray<RawObject*> delayed_weak_stack_;
   // TODO(cshapiro): use this value to compute survival statistics for
   // new space growth policy.
   intptr_t bytes_promoted_;
   RawObject* visiting_old_object_;
@@ skipping 158 matching lines @@
   // going to use for forwarding pointers.
   ASSERT(Object::tags_offset() == 0);
 
   // Set initial size resulting in a total of three different levels.
   const intptr_t initial_semi_capacity_in_words = max_semi_capacity_in_words /
       (FLAG_new_gen_growth_factor * FLAG_new_gen_growth_factor);
   to_ = SemiSpace::New(initial_semi_capacity_in_words);
   if (to_ == NULL) {
     FATAL("Out of memory.\n");
   }
-  from_ = NULL;
 
   // Setup local fields.
   top_ = FirstObjectStart();
   resolved_top_ = top_;
   end_ = to_->end();
 
   survivor_end_ = FirstObjectStart();
 }
 
 
 Scavenger::~Scavenger() {
   ASSERT(!scavenging_);
-  ASSERT(from_ == NULL);
   to_->Delete();
 }
 
 
 intptr_t Scavenger::NewSizeInWords(intptr_t old_size_in_words) const {
   if (stats_history_.Size() == 0) {
     return old_size_in_words;
   }
   double garbage = stats_history_.Get(0).GarbageFraction();
   if (garbage < (FLAG_new_gen_garbage_threshold / 100.0)) {
     return Utils::Minimum(max_semi_capacity_in_words_,
                           old_size_in_words * FLAG_new_gen_growth_factor);
   } else {
     return old_size_in_words;
   }
 }
 
 
-void Scavenger::Prologue(Isolate* isolate, bool invoke_api_callbacks) {
+SemiSpace* Scavenger::Prologue(Isolate* isolate, bool invoke_api_callbacks) {
   if (invoke_api_callbacks && (isolate->gc_prologue_callback() != NULL)) {
     (isolate->gc_prologue_callback())();
   }
   Thread::PrepareForGC();
   // Flip the two semi-spaces so that to_ is always the space for allocating
   // objects.
-  from_ = to_;
-  to_ = SemiSpace::New(NewSizeInWords(from_->size_in_words()));
+  SemiSpace* from = to_;
+  to_ = SemiSpace::New(NewSizeInWords(from->size_in_words()));
   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();
+  return from;
 }
 
 
 void Scavenger::Epilogue(Isolate* isolate,
+                         SemiSpace* from,
                          bool invoke_api_callbacks) {
   // All objects in the to space have been copied from the from space at this
   // moment.
   double avg_frac = stats_history_.Get(0).PromoCandidatesSuccessFraction();
   if (stats_history_.Size() >= 2) {
     // Previous scavenge is only given half as much weight.
     avg_frac += 0.5 * stats_history_.Get(1).PromoCandidatesSuccessFraction();
     avg_frac /= 1.0 + 0.5;  // Normalize.
   }
   if (avg_frac < (FLAG_early_tenuring_threshold / 100.0)) {
@@ skipping 11 matching lines @@
   // being spawned.
   {
     PageSpace* page_space = heap_->old_space();
     MonitorLocker ml(page_space->tasks_lock());
     if (page_space->tasks() == 0) {
       VerifyStoreBufferPointerVisitor verify_store_buffer_visitor(isolate, to_);
       heap_->old_space()->VisitObjectPointers(&verify_store_buffer_visitor);
     }
   }
 #endif  // defined(DEBUG)
-  from_->Delete();
-  from_ = NULL;
+  from->Delete();
   if (invoke_api_callbacks && (isolate->gc_epilogue_callback() != NULL)) {
     (isolate->gc_epilogue_callback())();
   }
 }
 
 
 void Scavenger::IterateStoreBuffers(Isolate* isolate,
                                     ScavengerVisitor* visitor) {
   // Iterating through the store buffers.
   // Grab the deduplication sets out of the isolate's consolidated store buffer.
@@ skipping 55 matching lines @@
 
 bool Scavenger::IsUnreachable(RawObject** p) {
   RawObject* raw_obj = *p;
   if (!raw_obj->IsHeapObject()) {
     return false;
   }
   if (!raw_obj->IsNewObject()) {
     return false;
   }
   uword raw_addr = RawObject::ToAddr(raw_obj);
-  if (!from_->Contains(raw_addr)) {
+  if (to_->Contains(raw_addr)) {
     return false;
   }
   uword header = *reinterpret_cast<uword*>(raw_addr);
   if (IsForwarding(header)) {
     uword new_addr = ForwardedAddr(header);
     *p = RawObject::FromAddr(new_addr);
     return false;
   }
   return true;
 }
@@ skipping 213 matching lines @@
   if (FLAG_verify_before_gc && !FLAG_concurrent_sweep) {
     OS::PrintErr("Verifying before Scavenge...");
     heap_->Verify(kForbidMarked);
     OS::PrintErr(" done.\n");
   }
 
   // Prepare for a scavenge.
   SpaceUsage usage_before = GetCurrentUsage();
   intptr_t promo_candidate_words =
       (survivor_end_ - FirstObjectStart()) / kWordSize;
-  Prologue(isolate, invoke_api_callbacks);
+  SemiSpace* from = Prologue(isolate, invoke_api_callbacks);
   // The API prologue/epilogue may create/destroy zones, so we must not
   // depend on zone allocations surviving beyond the epilogue callback.
   {
     StackZone zone(Thread::Current());
     // Setup the visitor and run the scavenge.
-    ScavengerVisitor visitor(isolate, this);
+    ScavengerVisitor visitor(isolate, this, from);
     page_space->AcquireDataLock();
     const bool prologue_weak_are_strong = !invoke_api_callbacks;
     IterateRoots(isolate, &visitor, prologue_weak_are_strong);
     int64_t start = OS::GetCurrentTimeMicros();
     ProcessToSpace(&visitor);
     int64_t middle = OS::GetCurrentTimeMicros();
     IterateWeakReferences(isolate, &visitor);
     ScavengerWeakVisitor weak_visitor(this, prologue_weak_are_strong);
     // Include the prologue weak handles, since we must process any promotion.
     const bool visit_prologue_weak_handles = true;
     IterateWeakRoots(isolate, &weak_visitor, visit_prologue_weak_handles);
     visitor.Finalize();
     ProcessWeakTables();
     page_space->ReleaseDataLock();
 
     // Scavenge finished. Run accounting.
     int64_t end = OS::GetCurrentTimeMicros();
     heap_->RecordTime(kProcessToSpace, middle - start);
     heap_->RecordTime(kIterateWeaks, end - middle);
     stats_history_.Add(
         ScavengeStats(start, end,
                       usage_before, GetCurrentUsage(),
                       promo_candidate_words,
                       visitor.bytes_promoted() >> kWordSizeLog2));
   }
-  Epilogue(isolate, invoke_api_callbacks);
+  Epilogue(isolate, from, invoke_api_callbacks);
 
   // TODO(koda): Make verification more compatible with concurrent sweep.
   if (FLAG_verify_after_gc && !FLAG_concurrent_sweep) {
     OS::PrintErr("Verifying after Scavenge...");
     heap_->Verify(kForbidMarked);
     OS::PrintErr(" done.\n");
   }
 
   // Done scavenging. Reset the marker.
   ASSERT(scavenging_);
   scavenging_ = false;
 }
 
 
 void Scavenger::WriteProtect(bool read_only) {
   ASSERT(!scavenging_);
-  ASSERT(from_ == NULL);
   to_->WriteProtect(read_only);
 }
 
 
 void Scavenger::PrintToJSONObject(JSONObject* object) const {
   Isolate* isolate = Isolate::Current();
   ASSERT(isolate != NULL);
   JSONObject space(object, "new");
   space.AddProperty("type", "HeapSpace");
   space.AddProperty("name", "new");
@@ skipping 23 matching lines @@
 }
 
 
 void Scavenger::FreeExternal(intptr_t size) {
   ASSERT(size >= 0);
   external_size_ -= size;
   ASSERT(external_size_ >= 0);
 }
 
 }  // namespace dart