Prepares allocation for proper sync with mutator and bg threads.

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 306 matching lines @@
                      intptr_t max_semi_capacity_in_words,
                      uword object_alignment)
     : heap_(heap),
       max_semi_capacity_in_words_(max_semi_capacity_in_words),
       object_alignment_(object_alignment),
       scavenging_(false),
       delayed_weak_properties_(NULL),
       gc_time_micros_(0),
       collections_(0),
       external_size_(0),
-      failed_to_promote_(false) {
+      failed_to_promote_(false),
+      space_lock_(new Mutex()) {
   // Verify assumptions about the first word in objects which the scavenger is
   // 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);
 
   const intptr_t kVmNameSize = 128;
@@ skipping 10 matching lines @@
 
   survivor_end_ = FirstObjectStart();
 
   UpdateMaxHeapCapacity();
   UpdateMaxHeapUsage();
 }
 
 Scavenger::~Scavenger() {
   ASSERT(!scavenging_);
   to_->Delete();
+  delete space_lock_;
 }
 
 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);
@@ skipping 340 matching lines @@
 #endif                                 // defined(DEBUG)
 
       WeakProperty::Clear(cur_weak);
 
       // Advance to next weak property in the queue.
       cur_weak = reinterpret_cast<RawWeakProperty*>(next_weak);
     }
   }
 }
 
+uword Scavenger::FindTopOfSpace(Isolate* isolate) const {
+  Thread* current = heap_->isolate()->thread_registry()->active_list();
+  uword furthest_addr = 0;

[rmacnak, 2017/08/01 21:51:25]

If we make all outstanding TLABs walkable, everything from Scavenger::base_ to
Scavenger::top_ should be walkable, right? Then there is no need to find the
highest top among the TLABs or to copy from a TLAB to the Scavenger and back.

[danunez, 2017/08/01 23:25:34]

That make sense. However, I am going to split this into two functions.
1) MakeALLTLABsIterable: Fills all TLABS to make the new space iterable.
2) FindTopOfSpace: Returns the address of the last object in the new space.

2) is specifically for UsedInWords() so we do not have an incorrect size
reported in Observatory (https://github.com/dart-lang/sdk/issues/30311).

+  while (current != NULL) {
+    if (current->HasActiveTLAB() && current->top() > furthest_addr) {
+      furthest_addr = current->top();
+      heap_->FillRemainingTLAB(current);
+    }
+    current = current->next();
+  }
+  return furthest_addr;
+}
+
 uword Scavenger::FlushTLS() const {
   ASSERT(heap_ != NULL);

[rmacnak, 2017/08/01 21:51:25]

Per comment above, I think this could be replaced with MakeAllTLABsIterable...

[danunez, 2017/08/01 23:25:34]

Done.

   uword saved_top = top_;
-  if (heap_->isolate()->IsMutatorThreadScheduled() && !scavenging_) {
+  if (!scavenging_) {
     Thread* mutator_thread = heap_->isolate()->mutator_thread();
-    saved_top = mutator_thread->heap()->new_space()->top();
-    if (mutator_thread->HasActiveTLAB()) {
-      ASSERT(mutator_thread->top() <=
-             mutator_thread->heap()->new_space()->top());
-      mutator_thread->heap()->new_space()->set_top(mutator_thread->top());
+    uword furthest_addr = FindTopOfSpace(heap_->isolate());
+    if (furthest_addr > 0) {
+      ASSERT(furthest_addr <= mutator_thread->heap()->new_space()->top());
+      mutator_thread->heap()->new_space()->set_top(furthest_addr);
     }
   }
   return saved_top;
 }
 
 void Scavenger::UnflushTLS(uword value) const {

[rmacnak, 2017/08/01 21:51:25]

...which should make this a no-op.

[danunez, 2017/08/01 23:25:34]

Done.

   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::AbandonAllTLABs() {
+  Thread* current = heap_->isolate()->thread_registry()->active_list();
+  while (current != NULL) {
+    heap_->AbandonRemainingTLAB(current);
+    current = current->next();
+  }
+}
+
 void Scavenger::VisitObjectPointers(ObjectPointerVisitor* visitor) const {
   uword saved_top = FlushTLS();
   uword cur = FirstObjectStart();
   while (cur < top_) {
     RawObject* raw_obj = RawObject::FromAddr(cur);
     cur += raw_obj->VisitPointers(visitor);
   }
   UnflushTLS(saved_top);
 }
 
@@ skipping 56 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(danunez): Abandon all threads' TLABs. Every thread should be stopped
+  // here anyway.
+  AbandonAllTLABs();
 
   // 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();
@@ skipping 108 matching lines @@
   }
 
   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_);
 }
 
 }  // namespace dart