VM: Fix assertion checking number of active concurrent markers.

runtime/vm/gc_marker.cc

 // Copyright (c) 2011, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 #include "vm/gc_marker.h"
 
 #include "vm/allocation.h"
 #include "vm/dart_api_state.h"
 #include "vm/isolate.h"
 #include "vm/log.h"
@@ skipping 592 matching lines @@
           }
 
           // If no tasks are busy, there will never be more work.
           if (AtomicOperations::LoadRelaxed(num_busy_) == 0) break;
 
           // I saw some work; get busy and compete for it.
           AtomicOperations::FetchAndIncrement(num_busy_);
         } while (true);
         // Wait for all markers to stop.
         barrier_->Sync();
+#if defined(DEBUG)
         ASSERT(AtomicOperations::LoadRelaxed(num_busy_) == 0);
-
+        // Caveat: must not allow any marker to continue past the barrier
+        // before we checked num_busy, otherwise one of them might rush
+        // ahead and increment it.
+        barrier_->Sync();
+#endif
         // Check if we have any pending properties with marked keys.
         // Those might have been marked by another marker.
         more_to_mark = visitor.ProcessPendingWeakProperties();
         if (more_to_mark) {
           // We have more work to do. Notify others.
           AtomicOperations::FetchAndIncrement(num_busy_);
         }
 
         // Wait for all other markers to finish processing their pending
         // weak properties and decide if they need to continue marking.
         // Caveat: we need two barriers here to make this decision in lock step
         // between all markers and the main thread.
         barrier_->Sync();
         if (!more_to_mark && (AtomicOperations::LoadRelaxed(num_busy_) > 0)) {
-          // All markers continue to marker as long as any single marker has
+          // All markers continue to mark as long as any single marker has
           // some work to do.
           AtomicOperations::FetchAndIncrement(num_busy_);
           more_to_mark = true;
         }
         barrier_->Sync();
       } while (more_to_mark);
 
       // Phase 2: Weak processing and follow-up marking on main thread.
       barrier_->Sync();
 
@@ skipping 100 matching lines @@
             new MarkTask(this, isolate, heap_, page_space, &marking_stack,
                          &barrier, collect_code,
                          i, num_tasks, &num_busy);
         ThreadPool* pool = Dart::thread_pool();
         pool->Run(mark_task);
       }
       bool more_to_mark = false;
       do {
         // Wait for all markers to stop.
         barrier.Sync();
+#if defined(DEBUG)
+        ASSERT(AtomicOperations::LoadRelaxed(&num_busy) == 0);
+        // Caveat: must not allow any marker to continue past the barrier
+        // before we checked num_busy, otherwise one of them might rush
+        // ahead and increment it.
+        barrier.Sync();
+#endif
 
         // Wait for all markers to go through weak properties and verify
         // that there are no more objects to mark.
         // Note: we need to have two barriers here because we want all markers
         // and main thread to make decisions in lock step.
         barrier.Sync();
         more_to_mark = AtomicOperations::LoadRelaxed(&num_busy) > 0;
         barrier.Sync();
       } while (more_to_mark);
 
@@ skipping 19 matching lines @@
       // Phase 3: Finalize results from all markers (detach code, etc.).
       barrier.Exit();
     }
     ProcessWeakTables(page_space);
     ProcessObjectIdTable(isolate);
   }
   Epilogue(isolate, invoke_api_callbacks);
 }
 
 }  // namespace dart