Release evacuation candidates after parallel sweeper threads completed.

src/mark-compact.cc

 // Copyright 2012 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 523 matching lines @@
   }
 }
 
 
 void MarkCompactCollector::WaitUntilSweepingCompleted() {
   if (sweeping_pending_) {
     for (int i = 0; i < FLAG_sweeper_threads; i++) {
       heap()->isolate()->sweeper_threads()[i]->WaitForSweeperThread();
     }
     sweeping_pending_ = false;
+    ReleaseEvacuationCandidates();
     StealMemoryFromSweeperThreads(heap()->paged_space(OLD_DATA_SPACE));
     StealMemoryFromSweeperThreads(heap()->paged_space(OLD_POINTER_SPACE));
     heap()->FreeQueuedChunks();
   }
 }
 
 
 intptr_t MarkCompactCollector::
              StealMemoryFromSweeperThreads(PagedSpace* space) {
   intptr_t freed_bytes = 0;
@@ skipping 2719 matching lines @@
   heap_->isolate()->inner_pointer_to_code_cache()->Flush();
 
 #ifdef VERIFY_HEAP
   if (FLAG_verify_heap) {
     VerifyEvacuation(heap_);
   }
 #endif
 
   slots_buffer_allocator_.DeallocateChain(&migration_slots_buffer_);
   ASSERT(migration_slots_buffer_ == NULL);
+}
+
+
+void MarkCompactCollector::ReleaseEvacuationCandidates() {
+  int npages = evacuation_candidates_.length();
   for (int i = 0; i < npages; i++) {
     Page* p = evacuation_candidates_[i];
     if (!p->IsEvacuationCandidate()) continue;
     PagedSpace* space = static_cast<PagedSpace*>(p->owner());
     space->Free(p->area_start(), p->area_size());
     p->set_scan_on_scavenge(false);
     slots_buffer_allocator_.DeallocateChain(p->slots_buffer_address());
     p->ResetLiveBytes();
     space->ReleasePage(p);
   }
@@ skipping 559 matching lines @@
   // the other spaces rely on possibly non-live maps to get the sizes for
   // non-live objects.
 
   SweepSpace(heap()->old_pointer_space(), how_to_sweep);
   SweepSpace(heap()->old_data_space(), how_to_sweep);
 
   if (how_to_sweep == PARALLEL_CONSERVATIVE) {
     // TODO(hpayer): fix race with concurrent sweeper
     StartSweeperThreads();
     if (FLAG_parallel_sweeping && !FLAG_concurrent_sweeping) {
       WaitUntilSweepingCompleted();

[Michael Starzinger, 2013/02/20 18:20:07]

The ordering of the calls is off, in the "parallel sweeping" mode this would
cause the evacuation candidates to be release before they are actually
evacuated.

I would suggest to add a FinalizeSweeping() method that is called after
WaitUntilSweepingComplete() returns on all other call-sites ...

[Hannes Payer (out of office), 2013/02/21 12:05:17]

Done.

     }
   }
 
   RemoveDeadInvalidatedCode();
   SweepSpace(heap()->code_space(), PRECISE);
 
   SweepSpace(heap()->cell_space(), PRECISE);
 
   EvacuateNewSpaceAndCandidates();
 
   // ClearNonLiveTransitions depends on precise sweeping of map space to
   // detect whether unmarked map became dead in this collection or in one
   // of the previous ones.
   SweepSpace(heap()->map_space(), PRECISE);
 
   // Deallocate unmarked objects and clear marked bits for marked objects.
   heap_->lo_space()->FreeUnmarkedObjects();
+
+  if (!AreSweeperThreadsActivated()) {

[Michael Starzinger, 2013/02/20 18:20:07]

... but called down here at this call-site. Also I would change the if-cascade
to use the same predicates:

if (how_to_sweep == PARALLEL_CONSERVATIVE) {
  if (FLAG_parallel_sweeping && !FLAG_concurrent_sweeping) {
    FinalizeSweeping();
  }
}

[Hannes Payer (out of office), 2013/02/21 12:05:17]

The right condition is "if (!FLAG_concurrent_sweeping)" since it has to be
finalized in parallel and sequential mode.

On 2013/02/20 18:20:07, Michael Starzinger wrote:

+    ReleaseEvacuationCandidates();
+  }
 }
 
 
 void MarkCompactCollector::EnableCodeFlushing(bool enable) {
 #ifdef ENABLE_DEBUGGER_SUPPORT
   if (heap()->isolate()->debug()->IsLoaded() ||
       heap()->isolate()->debug()->has_break_points()) {
     enable = false;
   }
 #endif
@@ skipping 180 matching lines @@
   while (buffer != NULL) {
     SlotsBuffer* next_buffer = buffer->next();
     DeallocateBuffer(buffer);
     buffer = next_buffer;
   }
   *buffer_address = NULL;
 }
 
 
 } }  // namespace v8::internal