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

runtime/vm/pages.cc

 // Copyright (c) 2012, 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/pages.h"
 
 #include "platform/assert.h"
 #include "vm/compiler_stats.h"
 #include "vm/gc_marker.h"
 #include "vm/gc_sweeper.h"
+#include "vm/lockers.h"
 #include "vm/object.h"
+#include "vm/thread.h"
 #include "vm/virtual_memory.h"
 
 namespace dart {
 
 DEFINE_FLAG(int, heap_growth_space_ratio, 20,
             "The desired maximum percentage of free space after GC");
 DEFINE_FLAG(int, heap_growth_time_ratio, 3,
             "The desired maximum percentage of time spent in GC");
 DEFINE_FLAG(int, heap_growth_rate, 256,
             "The max number of pages the heap can grow at a time");
 DEFINE_FLAG(bool, print_free_list_before_gc, false,
             "Print free list statistics before a GC");
 DEFINE_FLAG(bool, print_free_list_after_gc, false,
             "Print free list statistics after a GC");
 DEFINE_FLAG(bool, collect_code, true,
             "Attempt to GC infrequently used code.");
 DEFINE_FLAG(int, code_collection_interval_in_us, 30000000,
             "Time between attempts to collect unused code.");
 DEFINE_FLAG(bool, log_code_drop, false,
             "Emit a log message when pointers to unused code are dropped.");
 DEFINE_FLAG(bool, always_drop_code, false,
             "Always try to drop code if the function's usage counter is >= 0");
-DECLARE_FLAG(bool, write_protect_code);
 
 HeapPage* HeapPage::Initialize(VirtualMemory* memory, PageType type) {
   ASSERT(memory->size() > VirtualMemory::PageSize());
   bool is_executable = (type == kExecutable);
   memory->Commit(is_executable);
 
   HeapPage* result = reinterpret_cast<HeapPage*>(memory->address());
   result->memory_ = memory;
   result->next_ = NULL;
   result->executable_ = is_executable;
@@ skipping 72 matching lines @@
 }
 
 
 PageSpace::PageSpace(Heap* heap, intptr_t max_capacity_in_words)
     : freelist_(),
       heap_(heap),
       pages_(NULL),
       pages_tail_(NULL),
       large_pages_(NULL),
       max_capacity_in_words_(max_capacity_in_words),
-      sweeping_(false),
+      tasks_lock_(new Monitor()),
+      tasks_(0),
       page_space_controller_(heap,
                              FLAG_heap_growth_space_ratio,
                              FLAG_heap_growth_rate,
                              FLAG_heap_growth_time_ratio),
       gc_time_micros_(0),
       collections_(0) {
 }
 
 
 PageSpace::~PageSpace() {
+  {
+    MonitorLocker ml(tasks_lock());
+    ASSERT(tasks() == 0);
+  }
   FreePages(pages_);
   FreePages(large_pages_);
+  delete tasks_lock_;
 }
 
 
 intptr_t PageSpace::LargePageSizeInWordsFor(intptr_t size) {
   intptr_t page_size = Utils::RoundUp(size + HeapPage::ObjectStartOffset(),
                                       VirtualMemory::PageSize());
   return page_size >> kWordSizeLog2;
 }
 
 
@@ skipping 81 matching lines @@
 void PageSpace::FreePages(HeapPage* pages) {
   HeapPage* page = pages;
   while (page != NULL) {
     HeapPage* next = page->next();
     page->Deallocate();
     page = next;
   }
 }
 
 
-uword PageSpace::TryAllocate(intptr_t size,
-                             HeapPage::PageType type,
-                             GrowthPolicy growth_policy) {
+uword PageSpace::TryAllocateInternal(intptr_t size,
+                            HeapPage::PageType type,
+                            GrowthPolicy growth_policy,
+                            bool is_protected,
+                            bool is_locked) {
   ASSERT(size >= kObjectAlignment);
   ASSERT(Utils::IsAligned(size, kObjectAlignment));
   uword result = 0;
   SpaceUsage after_allocation = usage_;
   after_allocation.used_in_words += size >> kWordSizeLog2;
   if (size < kAllocatablePageSize) {
-    const bool is_protected = (type == HeapPage::kExecutable)
-        && FLAG_write_protect_code;
-    result = freelist_[type].TryAllocate(size, is_protected);
+    if (is_locked) {
+      result = freelist_[type].TryAllocateLocked(size, is_protected);
+    } else {
+      result = freelist_[type].TryAllocate(size, is_protected);
+    }
     if (result == 0) {
       // Can we grow by one page?
       after_allocation.capacity_in_words += kPageSizeInWords;
       if ((!page_space_controller_.NeedsGarbageCollection(after_allocation) ||
            growth_policy == kForceGrowth) &&
           CanIncreaseCapacityInWords(kPageSizeInWords)) {
         HeapPage* page = AllocatePage(type);
         ASSERT(page != NULL);
         // Start of the newly allocated page is the allocated object.
         result = page->object_start();
         // Enqueue the remainder in the free list.
         uword free_start = result + size;
         intptr_t free_size = page->object_end() - free_start;
         if (free_size > 0) {
-          freelist_[type].Free(free_start, free_size);
+          if (is_locked) {
+            freelist_[type].FreeLocked(free_start, free_size);
+          } else {
+            freelist_[type].Free(free_start, free_size);
+          }
         }
       }
     }
   } else {
     // Large page allocation.
     intptr_t page_size_in_words = LargePageSizeInWordsFor(size);
     if ((page_size_in_words << kWordSizeLog2) < size) {
       // On overflow we fail to allocate.
       return 0;
     }
@@ skipping 11 matching lines @@
     usage_ = after_allocation;
     if (FLAG_compiler_stats && (type == HeapPage::kExecutable)) {
       CompilerStats::code_allocated += size;
     }
   }
   ASSERT((result & kObjectAlignmentMask) == kOldObjectAlignmentOffset);
   return result;
 }
 
 
+  void PageSpace::AcquireDataLock() {
+    freelist_[HeapPage::kData].mutex()->Lock();
+  }
+
+
+  void PageSpace::ReleaseDataLock() {
+    freelist_[HeapPage::kData].mutex()->Unlock();
+  }
+
+
 void PageSpace::AllocateExternal(intptr_t size) {
   intptr_t size_in_words = size >> kWordSizeLog2;
   usage_.external_in_words += size_in_words;
   // TODO(koda): Control growth.
 }
 
 
 void PageSpace::FreeExternal(intptr_t size) {
   intptr_t size_in_words = size >> kWordSizeLog2;
   usage_.external_in_words -= size_in_words;
@@ skipping 175 matching lines @@
       if (current_page->type() == HeapPage::kExecutable) {
         current_page->WriteProtect(read_only);
       }
       current_page = NextPageAnySize(current_page);
     }
   }
 }
 
 
 void PageSpace::MarkSweep(bool invoke_api_callbacks) {
-  // MarkSweep is not reentrant. Make sure that is the case.
-  ASSERT(!sweeping_);
-  sweeping_ = true;
-  Isolate* isolate = Isolate::Current();
+  Isolate* isolate = heap_->isolate();
+  ASSERT(isolate == Isolate::Current());
+
+  // Wait for pending tasks to complete and then account for the driver task.
+  {
+    MonitorLocker locker(tasks_lock());
+    while (tasks() != 0) {
+      locker.Wait();
+    }
+    set_tasks(1);
+  }
 
   NoHandleScope no_handles(isolate);
 
   if (FLAG_print_free_list_before_gc) {
     OS::Print("Data Freelist (before GC):\n");
     freelist_[HeapPage::kData].Print();
     OS::Print("Executable Freelist (before GC):\n");
     freelist_[HeapPage::kExecutable].Print();
   }
 
@@ skipping 79 matching lines @@
     OS::Print("Executable Freelist (after GC):\n");
     freelist_[HeapPage::kExecutable].Print();
   }
 
   if (FLAG_verify_after_gc) {
     OS::PrintErr("Verifying after MarkSweep...");
     heap_->Verify();
     OS::PrintErr(" done.\n");
   }
 
-  // Done, reset the marker.
-  ASSERT(sweeping_);
-  sweeping_ = false;
+  // Done, reset the task count.
+  {
+    MonitorLocker locker(tasks_lock());
+    ASSERT(tasks() == 1);
+    set_tasks(tasks() - 1);
+  }
 }
 
 
 PageSpaceController::PageSpaceController(Heap* heap,
                                          int heap_growth_ratio,
                                          int heap_growth_max,
                                          int garbage_collection_time_ratio)
     : heap_(heap),
       is_enabled_(false),
       grow_heap_(heap_growth_max / 2),
@@ skipping 104 matching lines @@
     return 0;
   } else {
     ASSERT(total_time >= gc_time);
     int result= static_cast<int>((static_cast<double>(gc_time) /
                              static_cast<double>(total_time)) * 100);
     return result;
   }
 }
 
 }  // namespace dart