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

runtime/vm/scavenger.cc

Index: runtime/vm/scavenger.cc
===================================================================
--- runtime/vm/scavenger.cc	(revision 39381)
+++ runtime/vm/scavenger.cc	(working copy)
@@ -13,12 +13,12 @@
 #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 {
 
@@ -81,6 +81,7 @@
         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_(),
@@ -204,8 +205,9 @@
         //
         // 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.
@@ -240,6 +242,7 @@
   Scavenger* scavenger_;
   Heap* heap_;
   Heap* vm_heap_;
+  PageSpace* page_space_;
   intptr_t visited_count_;
   intptr_t handled_count_;
   typedef std::multimap<RawObject*, RawWeakProperty*> DelaySet;
@@ -781,6 +784,7 @@
   ASSERT(!scavenging_);
   scavenging_ = true;
   Isolate* isolate = heap_->isolate();
+  PageSpace* page_space = heap_->old_space();
   NoHandleScope no_handles(isolate);
 
   if (FLAG_verify_before_gc) {
@@ -796,6 +800,7 @@
       (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);
@@ -807,6 +812,7 @@
   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);