[heap] Start concurrent marking simultaneously with incremental marking.

src/heap/concurrent-marking.cc

 // Copyright 2017 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/concurrent-marking.h"
 
 #include <stack>
 #include <unordered_map>
 
 #include "src/heap/heap-inl.h"
@@ skipping 32 matching lines @@
   }
 
   void FreeBitmap(Bitmap* bitmap) { free(bitmap); }
 
  private:
   std::unordered_map<MemoryChunk*, Bitmap*> bitmap_;
 };
 
 class ConcurrentMarkingVisitor : public ObjectVisitor {
  public:
-  ConcurrentMarkingVisitor() {}
+  ConcurrentMarkingVisitor() : bytes_marked_(0) {}
 
   void VisitPointers(Object** start, Object** end) override {
     for (Object** p = start; p < end; p++) {
       if (!(*p)->IsHeapObject()) continue;
       MarkObject(HeapObject::cast(*p));
     }
   }
 
   void MarkObject(HeapObject* obj) {
     if (markbits_.Mark(obj)) {
+      bytes_marked_ += obj->Size();
       marking_stack_.push(obj);
     }
   }
 
   void MarkTransitively() {
     while (!marking_stack_.empty()) {
       HeapObject* obj = marking_stack_.top();
       marking_stack_.pop();
       obj->Iterate(this);
     }
   }
 
+  size_t bytes_marked() { return bytes_marked_; }
+
  private:
+  size_t bytes_marked_;
   std::stack<HeapObject*> marking_stack_;
   ConcurrentMarkingMarkbits markbits_;
 };
 
 class ConcurrentMarking::Task : public CancelableTask {
  public:
   Task(Heap* heap, std::vector<HeapObject*>* root_set,
        base::Semaphore* on_finish)
       : CancelableTask(heap->isolate()),
         heap_(heap),
         on_finish_(on_finish),
         root_set_(root_set) {}
 
   virtual ~Task() {}
 
  private:
   // v8::internal::CancelableTask overrides.
   void RunInternal() override {
-    USE(heap_);
+    double start_time_ms = heap_->MonotonicallyIncreasingTimeInMs();

[Michael Lippautz, 2017/03/08 19:14:34]

nit: There's TimedScope in utils-inl.h
e.g.
  double t = 0.0;
  {
    TimedScope scope(&t);
    ...
  }

[ulan, 2017/03/10 16:45:26]

Done.

     for (HeapObject* obj : *root_set_) {
       marking_visitor_.MarkObject(obj);
     }
     marking_visitor_.MarkTransitively();
+    double end_time_ms = heap_->MonotonicallyIncreasingTimeInMs();
+    if (FLAG_trace_concurrent_marking) {
+      heap_->isolate()->PrintWithTimestamp(
+          "concurrently marked %dKB in %.2fms\n",
+          static_cast<int>(marking_visitor_.bytes_marked() / KB),
+          end_time_ms - start_time_ms);
+    }
     on_finish_->Signal();
   }
 
   Heap* heap_;
   base::Semaphore* on_finish_;
   ConcurrentMarkingVisitor marking_visitor_;
   std::vector<HeapObject*>* root_set_;
   DISALLOW_COPY_AND_ASSIGN(Task);
 };
 
 ConcurrentMarking::ConcurrentMarking(Heap* heap)
-    : heap_(heap), pending_task_(0) {}
+    : heap_(heap), pending_task_semaphore_(0), is_task_pending_(false) {
+  // Concurrent marking does not work with double unboxing.
+  STATIC_ASSERT(!(V8_CONCURRENT_MARKING && V8_DOUBLE_FIELDS_UNBOXING));
+  // The runtime flag should be set only if the compile time flag was set.
+  CHECK(!FLAG_concurrent_marking || V8_CONCURRENT_MARKING);
+}
 
 ConcurrentMarking::~ConcurrentMarking() {}
 
 void ConcurrentMarking::AddRoot(HeapObject* object) {
   root_set_.push_back(object);
 }
 
 void ConcurrentMarking::StartMarkingTask() {
   if (!FLAG_concurrent_marking) return;
+  is_task_pending_ = true;
 
   V8::GetCurrentPlatform()->CallOnBackgroundThread(
-      new Task(heap_, &root_set_, &pending_task_),
+      new Task(heap_, &root_set_, &pending_task_semaphore_),
       v8::Platform::kShortRunningTask);
 }
 
 void ConcurrentMarking::WaitForTaskToComplete() {
   if (!FLAG_concurrent_marking) return;
-  pending_task_.Wait();
+  pending_task_semaphore_.Wait();
+  is_task_pending_ = false;
+  root_set_.clear();
 }
 
 }  // namespace internal
 }  // namespace v8