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

runtime/vm/freelist.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/freelist.h"
 
 #include <map>
-#include <utility>
 
 #include "vm/bit_set.h"
+#include "vm/lockers.h"
 #include "vm/object.h"
 #include "vm/raw_object.h"
+#include "vm/thread.h"
 
 namespace dart {
 
 
 FreeListElement* FreeListElement::AsElement(uword addr, intptr_t size) {
   // Precondition: the (page containing the) header of the element is
   // writable.
   ASSERT(size >= kObjectAlignment);
   ASSERT(Utils::IsAligned(size, kObjectAlignment));
 
@@ skipping 19 matching lines @@
   ASSERT(OFFSET_OF(FreeListElement, tags_) == Object::tags_offset());
 }
 
 
 intptr_t FreeListElement::HeaderSizeFor(intptr_t size) {
   if (size == 0) return 0;
   return ((size > RawObject::SizeTag::kMaxSizeTag) ? 3 : 2) * kWordSize;
 }
 
 
-FreeList::FreeList() {
+FreeList::FreeList() : mutex_(new Mutex()) {
   Reset();
 }
 
 
 FreeList::~FreeList() {
-  // Nothing to release.
+  delete mutex_;
 }
 
 
 uword FreeList::TryAllocate(intptr_t size, bool is_protected) {
+  MutexLocker ml(mutex_);
+  return TryAllocateLocked(size, is_protected);
+}
+
+
+uword FreeList::TryAllocateLocked(intptr_t size, bool is_protected) {
+  DEBUG_ASSERT(mutex_->Owner() == Isolate::Current());
   // Precondition: is_protected is false or else all free list elements are
   // in non-writable pages.
 
   // Postcondition: if allocation succeeds, the allocated block is writable.
   int index = IndexForSize(size);
   if ((index != kNumLists) && free_map_.Test(index)) {
     FreeListElement* element = DequeueElement(index);
     if (is_protected) {
       bool status =
           VirtualMemory::Protect(reinterpret_cast<void*>(element),
@@ skipping 86 matching lines @@
       return reinterpret_cast<uword>(current);
     }
     previous = current;
     current = current->next();
   }
   return 0;
 }
 
 
 void FreeList::Free(uword addr, intptr_t size) {
+  MutexLocker ml(mutex_);
+  FreeLocked(addr, size);
+}
+
+
+void FreeList::FreeLocked(uword addr, intptr_t size) {

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

Assert that it's actually locked.

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

Done.

   // Precondition required by AsElement and EnqueueElement: the (page
   // containing the) header of the freed block should be writable.  This is
   // the case when called for newly allocated pages because they are
   // allocated as writable.  It is the case when called during GC sweeping
   // because the entire heap is writable.
   intptr_t index = IndexForSize(size);
   FreeListElement* element = FreeListElement::AsElement(addr, size);
   EnqueueElement(element, index);
   // Postcondition: the (page containing the) header is left writable.
 }
 
 
 void FreeList::Reset() {
+  MutexLocker ml(mutex_);
   free_map_.Reset();
   for (int i = 0; i < (kNumLists + 1); i++) {
     free_lists_[i] = NULL;
   }
 }
 
 
 intptr_t FreeList::IndexForSize(intptr_t size) {
   ASSERT(size >= kObjectAlignment);
   ASSERT(Utils::IsAligned(size, kObjectAlignment));
@@ skipping 21 matching lines @@
   FreeListElement* next = result->next();
   if (next == NULL && index != kNumLists) {
     free_map_.Set(index, false);
   }
   free_lists_[index] = next;
   return result;
 }
 
 
 intptr_t FreeList::Length(int index) const {
+  MutexLocker ml(mutex_);
   ASSERT(index >= 0);
   ASSERT(index < kNumLists);
   intptr_t result = 0;
   FreeListElement* element = free_lists_[index];
   while (element != NULL) {
     ++result;
     element = element->next();
   }
   return result;
 }
@@ skipping 50 matching lines @@
               size / kObjectAlignment,
               size,
               list_length,
               list_bytes / static_cast<double>(KB),
               large_bytes / static_cast<double>(KB));
   }
 }
 
 
 void FreeList::Print() const {
+  MutexLocker ml(mutex_);
   PrintSmall();
   PrintLarge();
 }
 
 
 void FreeList::SplitElementAfterAndEnqueue(FreeListElement* element,
                                            intptr_t size,
                                            bool is_protected) {
   // Precondition required by AsElement and EnqueueElement: either
   // element->Size() == size, or else the (page containing the) header of
@@ skipping 14 matching lines @@
       !VirtualMemory::InSamePage(remainder_address - 1, remainder_address)) {
     bool status =
         VirtualMemory::Protect(reinterpret_cast<void*>(remainder_address),
                                remainder_size,
                                VirtualMemory::kReadExecute);
     ASSERT(status);
   }
 }
 
 }  // namespace dart