[heap] Uncommit marking deque in concurrent task.

src/heap/mark-compact.h

 // 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.
 
 #ifndef V8_HEAP_MARK_COMPACT_H_
 #define V8_HEAP_MARK_COMPACT_H_
 
 #include <deque>
 
 #include "src/base/bits.h"
+#include "src/base/platform/condition-variable.h"
 #include "src/heap/marking.h"
 #include "src/heap/spaces.h"
 #include "src/heap/store-buffer.h"
 
 namespace v8 {
 namespace internal {
 
 // Callback function, returns whether an object is alive. The heap size
 // of the object is returned in size. It optionally updates the offset
 // to the first live object in the page (only used for old and map objects).
@@ skipping 32 matching lines @@
 class MarkingDeque {
  public:
   MarkingDeque()
       : backing_store_(nullptr),
         backing_store_committed_size_(0),
         array_(nullptr),
         top_(0),
         bottom_(0),
         mask_(0),
         overflowed_(false),
-        in_use_(false) {}
+        in_use_(false),
+        uncommit_task_pending_(false) {}
 
   void SetUp();
   void TearDown();
 
   void StartUsing();
   void StopUsing();
   void Clear();
 
   inline bool IsFull() { return ((top_ + 1) & mask_) == bottom_; }
 
@@ skipping 41 matching lines @@
     }
   }
 
   HeapObject** array() { return array_; }
   int bottom() { return bottom_; }
   int top() { return top_; }
   int mask() { return mask_; }
   void set_top(int top) { top_ = top; }
 
  private:
+  class UncommitTask : public v8::Task {
+   public:
+    explicit UncommitTask(MarkingDeque* marking_deque)
+        : marking_deque_(marking_deque) {}
+
+   private:
+    // v8::Task overrides.
+    void Run() override {
+      base::LockGuard<base::Mutex> guard(&marking_deque_->mutex_);
+      if (!marking_deque_->in_use_) {

[Michael Lippautz, 2016/10/24 08:43:23]

Can you somewhere document with a comment that in_use_ is used to indicate
whether the deque still needs to be uncommitted? Was quite puzzled how the
StartUsing() can get away without explicit waiting for the task.

[ulan, 2016/10/24 13:14:09]

Done.

+        marking_deque_->Uncommit();
+      }
+      marking_deque_->uncommit_task_pending_ = false;
+      marking_deque_->uncommit_task_barrier_.NotifyOne();
+    }
+
+    MarkingDeque* marking_deque_;
+    DISALLOW_COPY_AND_ASSIGN(UncommitTask);
+  };
+
   static const size_t kMaxSize = 4 * MB;
   static const size_t kMinSize = 256 * KB;
 
+  // Must be called with mutex lock.
   void EnsureCommitted();
+
+  // Must be called with mutex lock.
   void Uncommit();
 
+  // Must be called with mutex lock.
+  void StartUncommitTask();
+
+  void WaitForUncommitTask();
+
+  base::Mutex mutex_;
+  base::ConditionVariable uncommit_task_barrier_;
+
   base::VirtualMemory* backing_store_;
   size_t backing_store_committed_size_;
   HeapObject** array_;
   // array_[(top - 1) & mask_] is the top element in the deque.  The Deque is
   // empty when top_ == bottom_.  It is full when top_ + 1 == bottom
   // (mod mask + 1).
   int top_;
   int bottom_;
   int mask_;
   bool overflowed_;
   bool in_use_;
+  bool uncommit_task_pending_;
 
   DISALLOW_COPY_AND_ASSIGN(MarkingDeque);
 };
 
 
 // CodeFlusher collects candidates for code flushing during marking and
 // processes those candidates after marking has completed in order to
 // reset those functions referencing code objects that would otherwise
 // be unreachable. Code objects can be referenced in two ways:
 //    - SharedFunctionInfo references unoptimized code.
@@ skipping 578 matching lines @@
 
  private:
   MarkCompactCollector* collector_;
 };
 
 V8_EXPORT_PRIVATE const char* AllocationSpaceName(AllocationSpace space);
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_HEAP_MARK_COMPACT_H_