- Account for number of pending tasks in old-space collections.

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>
 
 #include "vm/dart.h"
 #include "vm/dart_api_state.h"
 #include "vm/isolate.h"
 #include "vm/lockers.h"
 #include "vm/object.h"
+#include "vm/object_id_ring.h"
 #include "vm/stack_frame.h"
 #include "vm/store_buffer.h"
 #include "vm/verifier.h"
 #include "vm/visitor.h"
 #include "vm/weak_table.h"
-#include "vm/object_id_ring.h"
 
 namespace dart {
 
 DEFINE_FLAG(int, early_tenuring_threshold, 66,
             "When more than this percentage of promotion candidates survive, "
             "promote all survivors of next scavenge.");
 DEFINE_FLAG(int, new_gen_garbage_threshold, 90,
             "Grow new gen when less than this percentage is garbage.");
 DEFINE_FLAG(int, new_gen_growth_factor, 4, "Grow new gen by this factor.");
 
@@ skipping 42 matching lines @@
 };
 
 
 class ScavengerVisitor : public ObjectPointerVisitor {
  public:
   explicit ScavengerVisitor(Isolate* isolate, Scavenger* scavenger)
       : ObjectPointerVisitor(isolate),
         scavenger_(scavenger),
         heap_(scavenger->heap_),
         vm_heap_(Dart::vm_isolate()->heap()),
+        page_space_(scavenger->heap_->old_space()),
         visited_count_(0),
         handled_count_(0),
         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++) {
       ScavengePointer(current);
@@ skipping 103 matching lines @@
         // to space.
         new_addr = scavenger_->TryAllocate(size);
         class_table->UpdateLiveNew(cid, size);
       } else {
         // TODO(iposva): Experiment with less aggressive promotion. For example
         // a coin toss determines if an object is promoted or whether it should
         // survive in this generation.
         //
         // This object is a survivor of a previous scavenge. Attempt to promote
         // the object.
-        new_addr =
-            heap_->TryAllocate(size, Heap::kOld, PageSpace::kForceGrowth);
+        new_addr = page_space_->TryAllocateDataLocked(size,
+                                                      PageSpace::kForceGrowth);
+        //    heap_->TryAllocate(size, Heap::kOld, PageSpace::kForceGrowth);

[koda, 2014/08/20 00:10:22]

Consider removing Heap::TryAllocate.

[Ivan Posva, 2014/08/20 03:50:54]

Removed Heap::TryAllocate and its used in reading full snapshots. Switched
reading of full snapshots to bulk allocation, grabbing the free list mutex at
the beginning.

         if (new_addr != 0) {
           // If promotion succeeded then we need to remember it so that it can
           // be traversed later.
           scavenger_->PushToPromotedStack(new_addr);
           bytes_promoted_ += size;
           class_table->UpdateAllocatedOld(cid, size);
         } else {
           // Promotion did not succeed. Copy into the to space instead.
           new_addr = scavenger_->TryAllocate(size);
           class_table->UpdateLiveNew(cid, size);
@@ skipping 14 matching lines @@
     *p = new_obj;
     // Update the store buffer as needed.
     if (visiting_old_object_ != NULL) {
       UpdateStoreBuffer(p, new_obj);
     }
   }
 
   Scavenger* scavenger_;
   Heap* heap_;
   Heap* vm_heap_;
+  PageSpace* page_space_;
   intptr_t visited_count_;
   intptr_t handled_count_;
   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_;
   bool in_scavenge_pointer_;
@@ skipping 521 matching lines @@
   // the API callbacks should be invoked.
   Scavenge(false);
 }
 
 
 void Scavenger::Scavenge(bool invoke_api_callbacks) {
   // Scavenging is not reentrant. Make sure that is the case.
   ASSERT(!scavenging_);
   scavenging_ = true;
   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);
   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;
+  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();
   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