- Simplify from containment check.

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 61 matching lines @@
   bool* _addr;
   bool _value;
 };
 
 
 class ScavengerVisitor : public ObjectPointerVisitor {
  public:
   explicit ScavengerVisitor(Isolate* isolate, Scavenger* scavenger)
       : ObjectPointerVisitor(isolate),
         scavenger_(scavenger),
+        from_start_(scavenger_->from_->start()),

[koda, 2014/08/25 22:49:26]

It would be nice to somehow assert here that the "flip" of from/to has been done
(also for documentation purposes).

[Ivan Posva, 2014/08/25 22:56:23]

The "assertion" is the fact that from_ is NULL if the swap has not happened yet.
Thinking a bit more about this we should not even have a from_ in the Scavenger,
but instead we could pass it to the visitor explicitly.

+        from_size_(scavenger_->from_->end() - scavenger_->from_->start()),
         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 53 matching lines @@
     BoolScope bs(&in_scavenge_pointer_, true);
 #endif
 
     RawObject* raw_obj = *p;
 
     // Fast exit if the raw object is a Smi or an old object.
     if (!raw_obj->IsHeapObject() || raw_obj->IsOldObject()) {
       return;
     }
 
+    // Objects should be contained in the heap.
+    // TODO(iposva): Add an appropriate assert here or in the return block
+    // below.
+
+    // 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_) {
+      return;
+    }
+
     uword raw_addr = RawObject::ToAddr(raw_obj);
-    // Objects should be contained in the heap.
-    // TODO(iposva): Add an appropriate assert here or in the return block
-    // below.
-    // The scavenger is only interested in objects located in the from space.
-    if (!scavenger_->from_->Contains(raw_addr)) {
-      return;
-    }
-
     // 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->ClearWatchedBit();
@@ skipping 52 matching lines @@
     // Update the reference.
     RawObject* new_obj = RawObject::FromAddr(new_addr);
     *p = new_obj;
     // Update the store buffer as needed.
     if (visiting_old_object_ != NULL) {
       UpdateStoreBuffer(p, new_obj);
     }
   }
 
   Scavenger* scavenger_;
+  uword from_start_;
+  uword from_size_;
   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 527 matching lines @@
   Isolate* isolate = heap_->isolate();
   PageSpace* page_space = heap_->old_space();
   NoHandleScope no_handles(isolate);
 
   if (FLAG_verify_before_gc) {
     OS::PrintErr("Verifying before Scavenge...");
     heap_->Verify();
     OS::PrintErr(" done.\n");
   }
 
-  // Setup the visitor and run a scavenge.
-  ScavengerVisitor visitor(isolate, this);
+  // Prepare for a scavenge.
   SpaceUsage usage_before = GetCurrentUsage();
   intptr_t promo_candidate_words =
       (survivor_end_ - FirstObjectStart()) / kWordSize;
   Prologue(isolate, invoke_api_callbacks);
   const bool prologue_weak_are_strong = !invoke_api_callbacks;
+
+  // Setup the visitor and run the scavenge.
+  ScavengerVisitor visitor(isolate, this);
   page_space->AcquireDataLock();
   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 and epilogue.
   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, &visitor, invoke_api_callbacks);
 
   if (FLAG_verify_after_gc) {
@@ skipping 48 matching lines @@
 }
 
 
 void Scavenger::FreeExternal(intptr_t size) {
   ASSERT(size >= 0);
   external_size_ -= size;
   ASSERT(external_size_ >= 0);
 }
 
 }  // namespace dart