Wait for concurrent unmapping tasks in GC prologue.

src/heap/heap.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/heap.h"
 
 #include "src/accessors.h"
 #include "src/api.h"
 #include "src/base/bits.h"
 #include "src/base/once.h"
@@ skipping 119 matching lines @@
       gcs_since_last_deopt_(0),
       allocation_sites_scratchpad_length_(0),
       ring_buffer_full_(false),
       ring_buffer_end_(0),
       promotion_queue_(this),
       configured_(false),
       current_gc_flags_(Heap::kNoGCFlags),
       current_gc_callback_flags_(GCCallbackFlags::kNoGCCallbackFlags),
       external_string_table_(this),
       chunks_queued_for_free_(NULL),
-      pending_unmap_job_semaphore_(0),
+      concurrent_unmaping_tasks_active_(0),
+      pending_unmap_tasks_semaphore_(0),
       gc_callbacks_depth_(0),
       deserialization_complete_(false),
       concurrent_sweeping_enabled_(false),
       strong_roots_list_(NULL) {
 // Allow build-time customization of the max semispace size. Building
 // V8 with snapshots and a non-default max semispace size is much
 // easier if you can define it as part of the build environment.
 #if defined(V8_MAX_SEMISPACE_SIZE)
   max_semi_space_size_ = reserved_semispace_size_ = V8_MAX_SEMISPACE_SIZE;
 #endif
@@ skipping 5602 matching lines @@
   if (FLAG_verify_predictable) {
     PrintAlloctionsHash();
   }
 
   if (memory_reducer_ != nullptr) {
     memory_reducer_->TearDown();
     delete memory_reducer_;
     memory_reducer_ = nullptr;
   }
 
+  WaitUntilUnmappingOfFreeChunksCompleted();

[Hannes Payer (out of office), 2015/08/27 12:34:37]

We should also wait when we tear down the heap.

+
   TearDownArrayBuffers();
 
   isolate_->global_handles()->TearDown();
 
   external_string_table_.TearDown();
 
   mark_compact_collector()->TearDown();
 
   delete tracer_;
   tracer_ = nullptr;
@@ skipping 744 matching lines @@
 class Heap::UnmapFreeMemoryTask : public v8::Task {
  public:
   UnmapFreeMemoryTask(Heap* heap, MemoryChunk* head)
       : heap_(heap), head_(head) {}
   virtual ~UnmapFreeMemoryTask() {}
 
  private:
   // v8::Task overrides.
   void Run() override {
     heap_->FreeQueuedChunks(head_);
-    heap_->pending_unmap_job_semaphore_.Signal();
+    heap_->pending_unmap_tasks_semaphore_.Signal();
   }
 
   Heap* heap_;
   MemoryChunk* head_;
 
   DISALLOW_COPY_AND_ASSIGN(UnmapFreeMemoryTask);
 };
 
 
 void Heap::WaitUntilUnmappingOfFreeChunksCompleted() {
   // We start an unmap job after sweeping and after compaction.
-  pending_unmap_job_semaphore_.Wait();
-  pending_unmap_job_semaphore_.Wait();
+  if (concurrent_unmaping_tasks_active_ > 0) {
+    // There should be two concurrent unmapping tasks running.
+    DCHECK(concurrent_unmaping_tasks_active_ == 2);
+    pending_unmap_tasks_semaphore_.Wait();
+    pending_unmap_tasks_semaphore_.Wait();
+    concurrent_unmaping_tasks_active_ = 0;
+  }
 }
 
 
 void Heap::QueueMemoryChunkForFree(MemoryChunk* chunk) {
   // PreFree logically frees the memory chunk. However, the actual freeing
   // will happen on a separate thread sometime later.
   isolate_->memory_allocator()->PreFreeMemory(chunk);
 
   // The chunks added to this queue will be freed by a concurrent thread.
   chunk->set_next_chunk(chunks_queued_for_free_);
@@ skipping 16 matching lines @@
 
 void Heap::FreeQueuedChunks() {
   if (chunks_queued_for_free_ != NULL) {
     V8::GetCurrentPlatform()->CallOnBackgroundThread(
         new UnmapFreeMemoryTask(this, chunks_queued_for_free_),
         v8::Platform::kShortRunningTask);
     chunks_queued_for_free_ = NULL;
   } else {
     // If we do not have anything to unmap, we just signal the semaphore
     // that we are done.
-    pending_unmap_job_semaphore_.Signal();
+    pending_unmap_tasks_semaphore_.Signal();
   }
+  concurrent_unmaping_tasks_active_++;
 }
 
 
 void Heap::FreeQueuedChunks(MemoryChunk* list_head) {
   MemoryChunk* next;
   MemoryChunk* chunk;
   for (chunk = list_head; chunk != NULL; chunk = next) {
     next = chunk->next_chunk();
     isolate_->memory_allocator()->PerformFreeMemory(chunk);
   }
@@ skipping 193 matching lines @@
     *object_type = "CODE_TYPE";                                                \
     *object_sub_type = "CODE_AGE/" #name;                                      \
     return true;
     CODE_AGE_LIST_COMPLETE(COMPARE_AND_RETURN_NAME)
 #undef COMPARE_AND_RETURN_NAME
   }
   return false;
 }
 }  // namespace internal
 }  // namespace v8