Makes new space iterable by filling up the mutator's TLAB

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 "vm/dart.h"
 #include "vm/dart_api_state.h"
 #include "vm/isolate.h"
 #include "vm/lockers.h"
@@ skipping 376 matching lines @@
   if (to_ == NULL) {
     // TODO(koda): We could try to recover (collect old space, wait for another
     // isolate to finish scavenge, etc.).
     OUT_OF_MEMORY();
   }
   UpdateMaxHeapCapacity();
   top_ = FirstObjectStart();
   resolved_top_ = top_;
   end_ = to_->end();
 
-  // Throw out the old information about the from space
-  if (isolate->IsMutatorThreadScheduled()) {
-    Thread* mutator_thread = isolate->mutator_thread();
-    mutator_thread->set_top(top_);
-    mutator_thread->set_end(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.
 
-  // Ensure the mutator thread now has the up-to-date top_ and end_ of the
-  // semispace
+  // Ensure the mutator thread will fail the next allocation. This will force
+  // mutator to allocate a new TLAB
   if (isolate->IsMutatorThreadScheduled()) {
     Thread* thread = isolate->mutator_thread();

[rmacnak, 2017/08/03 20:31:40]

We abandoned the TLAB at the beginning of the scavenge, so we should be about to
assert it has no TLAB here.

[danunez, 2017/08/03 20:39:21]

Yes. That is true. I will add an assertion and remove lines 410 and 411.

-    thread->set_top(top_);
-    thread->set_end(end_);
+    thread->set_top(0);
+    thread->set_end(0);
   }
 
   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)) {
     // Remember the limit to which objects have been copied.
@@ skipping 286 matching lines @@
 #endif                                 // defined(DEBUG)
 
       WeakProperty::Clear(cur_weak);
 
       // Advance to next weak property in the queue.
       cur_weak = reinterpret_cast<RawWeakProperty*>(next_weak);
     }
   }
 }
 
-void Scavenger::FlushTLS() const {
+uword Scavenger::FlushTLS() const {
   ASSERT(heap_ != NULL);
-  if (heap_->isolate()->IsMutatorThreadScheduled()) {
+  uword saved_top = top_;
+  if (heap_->isolate()->IsMutatorThreadScheduled() && !scavenging_) {
     Thread* mutator_thread = heap_->isolate()->mutator_thread();
-    mutator_thread->heap()->new_space()->set_top(mutator_thread->top());
+    saved_top = mutator_thread->heap()->new_space()->top();
+    if (mutator_thread->HasActiveTLAB()) {
+      ASSERT(mutator_thread->top() <=
+             mutator_thread->heap()->new_space()->top());
+      heap_->FillRemainingTLAB(mutator_thread);
+    }
+  }
+  return saved_top;
+}
+
+void Scavenger::UnflushTLS(uword value) const {
+  ASSERT(heap_ != NULL);
+  if (heap_->isolate()->IsMutatorThreadScheduled() && !scavenging_) {
+    Thread* mutator_thread = heap_->isolate()->mutator_thread();
+    mutator_thread->heap()->new_space()->set_top(value);
+    ASSERT(mutator_thread->top() <= mutator_thread->heap()->new_space()->top());
   }
 }
 
 void Scavenger::VisitObjectPointers(ObjectPointerVisitor* visitor) const {
-  FlushTLS();
+  uword saved_top = FlushTLS();
   uword cur = FirstObjectStart();
   while (cur < top_) {
     RawObject* raw_obj = RawObject::FromAddr(cur);
     cur += raw_obj->VisitPointers(visitor);
   }
+  UnflushTLS(saved_top);
 }
 
 void Scavenger::VisitObjects(ObjectVisitor* visitor) const {
-  FlushTLS();
+  uword saved_top = FlushTLS();
   uword cur = FirstObjectStart();
   while (cur < top_) {
     RawObject* raw_obj = RawObject::FromAddr(cur);
     visitor->VisitObject(raw_obj);
     cur += raw_obj->Size();
   }
+  UnflushTLS(saved_top);
 }
 
 void Scavenger::AddRegionsToObjectSet(ObjectSet* set) const {
   set->AddRegion(to_->start(), to_->end());
 }
 
 RawObject* Scavenger::FindObject(FindObjectVisitor* visitor) const {
   ASSERT(!scavenging_);
-  FlushTLS();
+  uword saved_top = FlushTLS();
   uword cur = FirstObjectStart();
   if (visitor->VisitRange(cur, top_)) {
     while (cur < top_) {
       RawObject* raw_obj = RawObject::FromAddr(cur);
       uword next = cur + raw_obj->Size();
       if (visitor->VisitRange(cur, next) && raw_obj->FindObject(visitor)) {
+        UnflushTLS(saved_top);
         return raw_obj;  // Found object, return it.
       }
       cur = next;
     }
     ASSERT(cur == top_);
   }
+  UnflushTLS(saved_top);
   return Object::null();
 }
 
 void Scavenger::Scavenge() {
   // TODO(cshapiro): Add a decision procedure for determining when the
   // the API callbacks should be invoked.
   Scavenge(false);
 }
 
 void Scavenger::Scavenge(bool invoke_api_callbacks) {
@@ skipping 14 matching lines @@
   scavenging_ = true;
 
   failed_to_promote_ = false;
 
   PageSpace* page_space = heap_->old_space();
   NoSafepointScope no_safepoints;
 
   int64_t post_safe_point = OS::GetCurrentMonotonicMicros();
   heap_->RecordTime(kSafePoint, post_safe_point - pre_safe_point);
 
+  if (isolate->IsMutatorThreadScheduled()) {
+    Thread* mutator_thread = isolate->mutator_thread();
+    if (mutator_thread->HasActiveTLAB()) {
+      heap_->AbandonRemainingTLAB(mutator_thread);
+    }
+  }
+
   // TODO(koda): Make verification more compatible with concurrent sweep.
   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 =
@@ skipping 91 matching lines @@
   // the scavenge.
   // The former can introduce an object that we might fail to collect.
   // The latter means even if the scavenge promotes every object in the new
   // space, the new allocation means the space is not empty,
   // causing the assertion below to fail.
   SafepointOperationScope scope(Thread::Current());
 
   // Forces the next scavenge to promote all the objects in the new space.
   survivor_end_ = top_;
 
   if (heap_->isolate()->IsMutatorThreadScheduled()) {

[rmacnak, 2017/08/03 20:31:40]

Isn't this redundant with the abdanon-tlab in Scavenge()?

[danunez, 2017/08/03 20:39:21]

The call to abandon-tlab is redundant and will be removed in favor of a single
call in Scavenge.

     Thread* mutator_thread = heap_->isolate()->mutator_thread();
-    survivor_end_ = mutator_thread->top();
+    if (mutator_thread->HasActiveTLAB()) {
+      survivor_end_ = mutator_thread->top();
+      heap_->AbandonRemainingTLAB(mutator_thread);
+    }
   }
 
   Scavenge();
 
   // It is possible for objects to stay in the new space
   // if the VM cannot create more pages for these objects.
   ASSERT((UsedInWords() == 0) || failed_to_promote_);
 }
 
+int64_t Scavenger::UsedInWords() const {
+  uword saved_top = FlushTLS();
+  int64_t used_in_words = (top_ - FirstObjectStart()) >> kWordSizeLog2;
+  UnflushTLS(saved_top);
+  return used_in_words;
+}
+
 }  // namespace dart