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

runtime/vm/pages.h

 // 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.
 
 #ifndef VM_PAGES_H_
 #define VM_PAGES_H_
 
 #include "vm/freelist.h"
 #include "vm/globals.h"
 #include "vm/ring_buffer.h"
 #include "vm/spaces.h"
 #include "vm/virtual_memory.h"
 
 namespace dart {
 
 DECLARE_FLAG(bool, collect_code);
 DECLARE_FLAG(bool, log_code_drop);
 DECLARE_FLAG(bool, always_drop_code);
+DECLARE_FLAG(bool, write_protect_code);
 
 // Forward declarations.
 class Heap;
 class JSONObject;
 class ObjectPointerVisitor;
 
 // A page containing old generation objects.
 class HeapPage {
  public:
   enum PageType {
@@ skipping 163 matching lines @@
   enum GrowthPolicy {
     kControlGrowth,
     kForceGrowth
   };
 
   PageSpace(Heap* heap, intptr_t max_capacity_in_words);
   ~PageSpace();
 
   uword TryAllocate(intptr_t size,
                     HeapPage::PageType type = HeapPage::kData,
-                    GrowthPolicy growth_policy = kControlGrowth);
+                    GrowthPolicy growth_policy = kControlGrowth) {
+    bool is_protected =
+        (type == HeapPage::kExecutable) && FLAG_write_protect_code;
+    return TryAllocateInternal(size, type, growth_policy, is_protected, false);

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

Comment 'false' (or use a local).

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

Done.

+  }
 
   bool NeedsGarbageCollection() const {
     return page_space_controller_.NeedsGarbageCollection(usage_) ||
            NeedsExternalGC();
   }
 
   intptr_t UsedInWords() const { return usage_.used_in_words; }
   intptr_t CapacityInWords() const { return usage_.capacity_in_words; }
   intptr_t ExternalInWords() const {
     return usage_.external_in_words;
@@ skipping 56 matching lines @@
   intptr_t collections() const {
     return collections_;
   }
 
   void PrintToJSONObject(JSONObject* object);
   void PrintHeapMapToJSONStream(Isolate* isolate, JSONStream* stream);
 
   void AllocateExternal(intptr_t size);
   void FreeExternal(intptr_t size);
 
+  // Bulk data allocation.
+  void AcquireDataLock();
+  void ReleaseDataLock();
+
+  uword TryAllocateDataLocked(intptr_t size, GrowthPolicy growth_policy) {
+    return TryAllocateInternal(size,
+                               HeapPage::kData,
+                               growth_policy,
+                               false, true);

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

Comment 'false' and 'true'.

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

Done.

+  }
+
  private:
   // Ids for time and data records in Heap::GCStats.
   enum {
     // Time
     kMarkObjects = 0,
     kResetFreeLists = 1,
     kSweepPages = 2,
     kSweepLargePages = 3,
     // Data
     kGarbageRatio = 0,
     kGCTimeFraction = 1,
     kPageGrowth = 2,
     kAllowedGrowth = 3
   };
 
+  Monitor* tasks_lock() const { return tasks_lock_; }
+  intptr_t tasks() const { return tasks_; }
+  void set_tasks(intptr_t val) { tasks_ = val; }
+
   static const intptr_t kAllocatablePageSize = 64 * KB;
 
+  uword TryAllocateInternal(intptr_t size,
+                            HeapPage::PageType type,
+                            GrowthPolicy growth_policy,
+                            bool is_protected,
+                            bool is_locked);
   HeapPage* AllocatePage(HeapPage::PageType type);
   void FreePage(HeapPage* page, HeapPage* previous_page);
   HeapPage* AllocateLargePage(intptr_t size, HeapPage::PageType type);
   void TruncateLargePage(HeapPage* page, intptr_t new_object_size_in_bytes);
   void FreeLargePage(HeapPage* page, HeapPage* previous_page);
   void FreePages(HeapPage* pages);
   HeapPage* NextPageAnySize(HeapPage* page) const {
     ASSERT(pages_tail_ == NULL || pages_tail_->next() == NULL);
     return page == pages_tail_ ? large_pages_ : page->next();
   }
@@ skipping 10 matching lines @@
   Heap* heap_;
 
   HeapPage* pages_;
   HeapPage* pages_tail_;
   HeapPage* large_pages_;
 
   // Various sizes being tracked for this generation.
   intptr_t max_capacity_in_words_;
   SpaceUsage usage_;
 
-  // Keep track whether a MarkSweep is currently running.
-  bool sweeping_;
+  // Keep track of running MarkSweep tasks.
+  Monitor* tasks_lock_;
+  intptr_t tasks_;
 
   PageSpaceController page_space_controller_;
 
   int64_t gc_time_micros_;
   intptr_t collections_;
 
   friend class PageSpaceController;
 
   DISALLOW_IMPLICIT_CONSTRUCTORS(PageSpace);
 };
 
 }  // namespace dart
 
 #endif  // VM_PAGES_H_