Reland "[heap] Uncommit marking deque in concurrent task."

src/heap/mark-compact.cc

 // Copyright 2012 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "src/heap/mark-compact.h"
 
 #include "src/base/atomicops.h"
 #include "src/base/bits.h"
 #include "src/base/sys-info.h"
 #include "src/code-stubs.h"
@@ skipping 40 matching lines @@
       page_parallel_job_semaphore_(0),
 #ifdef DEBUG
       state_(IDLE),
 #endif
       marking_parity_(ODD_MARKING_PARITY),
       was_marked_incrementally_(false),
       evacuation_(false),
       compacting_(false),
       black_allocation_(false),
       have_code_to_deoptimize_(false),
+      marking_deque_(heap),
       code_flusher_(nullptr),
       sweeper_(heap) {
 }
 
 #ifdef VERIFY_HEAP
 class VerifyMarkingVisitor : public ObjectVisitor {
  public:
   explicit VerifyMarkingVisitor(Heap* heap) : heap_(heap) {}
 
   void VisitPointers(Object** start, Object** end) override {
@@ skipping 2039 matching lines @@
 }
 
 void MarkingDeque::SetUp() {
   backing_store_ = new base::VirtualMemory(kMaxSize);
   backing_store_committed_size_ = 0;
   if (backing_store_ == nullptr) {
     V8::FatalProcessOutOfMemory("MarkingDeque::SetUp");
   }
 }
 
-void MarkingDeque::TearDown() { delete backing_store_; }
+void MarkingDeque::TearDown() {
+  CancelOrWaitForUncommitTask();
+  delete backing_store_;
+}
 
 void MarkingDeque::StartUsing() {
+  base::LockGuard<base::Mutex> guard(&mutex_);
   if (in_use_) {
     // This can happen in mark-compact GC if the incremental marker already
     // started using the marking deque.
     return;
   }
   in_use_ = true;
   EnsureCommitted();
   array_ = reinterpret_cast<HeapObject**>(backing_store_->address());
   size_t size = FLAG_force_marking_deque_overflows
                     ? 64 * kPointerSize
                     : backing_store_committed_size_;
   DCHECK(
       base::bits::IsPowerOfTwo32(static_cast<uint32_t>(size / kPointerSize)));
   mask_ = static_cast<int>((size / kPointerSize) - 1);
   top_ = bottom_ = 0;
   overflowed_ = false;
 }
 
 void MarkingDeque::StopUsing() {
+  base::LockGuard<base::Mutex> guard(&mutex_);
   DCHECK(IsEmpty());
   DCHECK(!overflowed_);
   top_ = bottom_ = mask_ = 0;
-  Uncommit();
   in_use_ = false;
+  if (FLAG_concurrent_sweeping) {
+    StartUncommitTask();
+  } else {
+    Uncommit();
+  }
 }
 
 void MarkingDeque::Clear() {
   DCHECK(in_use_);
   top_ = bottom_ = 0;
   overflowed_ = false;
 }
 
 void MarkingDeque::Uncommit() {
-  DCHECK(in_use_);
+  DCHECK(!in_use_);
   bool success = backing_store_->Uncommit(backing_store_->address(),
                                           backing_store_committed_size_);
   backing_store_committed_size_ = 0;
   CHECK(success);
 }
 
 void MarkingDeque::EnsureCommitted() {
   DCHECK(in_use_);
   if (backing_store_committed_size_ > 0) return;
 
   for (size_t size = kMaxSize; size >= kMinSize; size /= 2) {
     if (backing_store_->Commit(backing_store_->address(), size, false)) {
       backing_store_committed_size_ = size;
       break;
     }
   }
   if (backing_store_committed_size_ == 0) {
     V8::FatalProcessOutOfMemory("MarkingDeque::EnsureCommitted");
   }
 }
 
+void MarkingDeque::StartUncommitTask() {
+  if (!uncommit_task_pending_) {
+    UncommitTask* task = new UncommitTask(heap_->isolate(), this);
+    uncommit_task_id_ = task->id();
+    uncommit_task_pending_ = true;
+    V8::GetCurrentPlatform()->CallOnBackgroundThread(
+        task, v8::Platform::kShortRunningTask);
+  }
+}
+
+void MarkingDeque::CancelOrWaitForUncommitTask() {
+  base::LockGuard<base::Mutex> guard(&mutex_);
+  if (!uncommit_task_pending_ ||
+      heap_->isolate()->cancelable_task_manager()->TryAbort(
+          uncommit_task_id_) != CancelableTaskManager::kTaskRunning) {
+    return;
+  }
+  while (uncommit_task_pending_) {
+    uncommit_task_barrier_.Wait(&mutex_);
+  }
+}
+
 class MarkCompactCollector::ObjectStatsVisitor
     : public MarkCompactCollector::HeapObjectVisitor {
  public:
   ObjectStatsVisitor(Heap* heap, ObjectStats* live_stats,
                      ObjectStats* dead_stats)
       : live_collector_(heap, live_stats), dead_collector_(heap, dead_stats) {
     DCHECK_NOT_NULL(live_stats);
     DCHECK_NOT_NULL(dead_stats);
     // Global objects are roots and thus recorded as live.
     live_collector_.CollectGlobalStatistics();
@@ skipping 1706 matching lines @@
       // The target is always in old space, we don't have to record the slot in
       // the old-to-new remembered set.
       DCHECK(!heap()->InNewSpace(target));
       RecordRelocSlot(host, &rinfo, target);
     }
   }
 }
 
 }  // namespace internal
 }  // namespace v8