[heap] Use atomic marking operations in incremental marking if

src/heap/incremental-marking.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_INCREMENTAL_MARKING_H_
 #define V8_HEAP_INCREMENTAL_MARKING_H_
 
 #include "src/cancelable-task.h"
 #include "src/execution.h"
 #include "src/heap/heap.h"
@@ skipping 143 matching lines @@
   // This is the upper bound for how many times we allow finalization of
   // incremental marking to be postponed.
   static const int kMaxIdleMarkingDelayCounter = 3;
 
 #ifndef DEBUG
   static const intptr_t kActivationThreshold = 8 * MB;
 #else
   static const intptr_t kActivationThreshold = 0;
 #endif
 
+#ifdef V8_CONCURRENT_MARKING
+  static const MarkBit::AccessMode kAtomicity = MarkBit::AccessMode::ATOMIC;

[Hannes Payer (out of office), 2017/05/03 10:08:53]

I am not sure if this is the right mechanism here. There may be cases where we
do not run concurrent marking but use only incremental instead. The decision
will happen at runtime. Are you planning to change that later and using this as
a preparation CL only?

[ulan, 2017/05/03 12:09:30]

As discussed offline, in future we will have two IncrementalMarking instances
and use virtual dispatch on Step.

+#else
+  static const MarkBit::AccessMode kAtomicity = MarkBit::AccessMode::NON_ATOMIC;
+#endif
+
   void FinalizeSweeping();
 
   size_t Step(size_t bytes_to_process, CompletionAction action,
               ForceCompletionAction completion, StepOrigin step_origin);
 
   inline void RestartIfNotMarking();
 
   static void RecordWriteFromCode(HeapObject* obj, Object** slot,
                                   Isolate* isolate);
 
@@ skipping 146 matching lines @@
 
   Observer new_generation_observer_;
   Observer old_generation_observer_;
 
   DISALLOW_IMPLICIT_CONSTRUCTORS(IncrementalMarking);
 };
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_HEAP_INCREMENTAL_MARKING_H_