Appease TSAN regarding data race in profiler debug counters.

runtime/vm/profiler.cc

 // Copyright (c) 2013, 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 "platform/address_sanitizer.h"
 #include "platform/memory_sanitizer.h"
 #include "platform/utils.h"
 
 #include "vm/allocation.h"
 #include "vm/atomic.h"
@@ skipping 47 matching lines @@
 void Profiler::InitOnce() {
   // Place some sane restrictions on user controlled flags.
   SetSamplePeriod(FLAG_profile_period);
   SetSampleDepth(FLAG_max_profile_depth);
   Sample::InitOnce();
   if (!FLAG_profiler) {
     return;
   }
   ASSERT(!initialized_);
   sample_buffer_ = new SampleBuffer();
+  // Zero counters.
+  memset(&counters_, 0, sizeof(counters_));
   NativeSymbolResolver::InitOnce();
   ThreadInterrupter::SetInterruptPeriod(FLAG_profile_period);
   ThreadInterrupter::Startup();
-  // Zero counters.
-  memset(&counters_, 0, sizeof(counters_));
   initialized_ = true;
 }
 
 
 void Profiler::Shutdown() {
   if (!FLAG_profiler) {
     return;
   }
   ASSERT(initialized_);
   ThreadInterrupter::Shutdown();
@@ skipping 696 matching lines @@
 #endif
 
   if (in_dart_code) {
     // We can only trust the stack pointer if we are executing Dart code.
     // See http://dartbug.com/20421 for details.
     CopyStackBuffer(sample, sp);
   }
 
   if (FLAG_profile_vm) {
     // Always walk the native stack collecting both native and Dart frames.
-    counters->stack_walker_native++;
+    AtomicOperations::IncrementInt64By(&counters->stack_walker_native, 1);
     native_stack_walker->walk();
   } else if (StubCode::HasBeenInitialized() && exited_dart_code) {
-    counters->stack_walker_dart_exit++;
+    AtomicOperations::IncrementInt64By(&counters->stack_walker_dart_exit, 1);
     // We have a valid exit frame info, use the Dart stack walker.
     dart_exit_stack_walker->walk();
   } else if (StubCode::HasBeenInitialized() && in_dart_code) {
-    counters->stack_walker_dart++;
+    AtomicOperations::IncrementInt64By(&counters->stack_walker_dart, 1);
     // We are executing Dart code. We have frame pointers.
     dart_stack_walker->walk();
   } else {
-    counters->stack_walker_none++;
+    AtomicOperations::IncrementInt64By(&counters->stack_walker_none, 1);
     sample->SetAt(0, pc);
   }
 
 #if defined(TARGET_OS_WINDOWS)
   // Use structured exception handling to trap guard page access.
   } __except(GuardPageExceptionFilter(GetExceptionInformation())) {
     // Sample collection triggered a guard page fault:
     // 1) discard entire sample.
     sample->set_ignore_sample(true);
 
@@ skipping 321 matching lines @@
 
 void Profiler::SampleThread(Thread* thread,
                             const InterruptedThreadState& state) {
   ASSERT(thread != NULL);
   OSThread* os_thread = thread->os_thread();
   ASSERT(os_thread != NULL);
   Isolate* isolate = thread->isolate();
 
   // Thread is not doing VM work.
   if (thread->task_kind() == Thread::kUnknownTask) {
-    counters_.bail_out_unknown_task++;
+    AtomicOperations::IncrementInt64By(&counters_.bail_out_unknown_task, 1);
     return;
   }
 
   if (StubCode::HasBeenInitialized() &&
       StubCode::InJumpToExceptionHandlerStub(state.pc)) {
     // The JumpToExceptionHandler stub manually adjusts the stack pointer,
     // frame pointer, and some isolate state before jumping to a catch entry.
     // It is not safe to walk the stack when executing this stub.
-    counters_.bail_out_jump_to_exception_handler++;
+    AtomicOperations::IncrementInt64By(
+        &counters_.bail_out_jump_to_exception_handler, 1);
     return;
   }
 
   const bool in_dart_code = thread->IsExecutingDartCode();
 
   uintptr_t sp = 0;
   uintptr_t fp = state.fp;
   uintptr_t pc = state.pc;
 #if defined(USING_SIMULATOR)
   Simulator* simulator = NULL;
@@ skipping 13 matching lines @@
     pc = simulator->get_pc();
 #else
     sp = state.dsp;
 #endif
   } else {
     // If we're in runtime code, use the C stack pointer.
     sp = state.csp;
   }
 
   if (!CheckIsolate(isolate)) {
-    counters_.bail_out_check_isolate++;
+    AtomicOperations::IncrementInt64By(&counters_.bail_out_check_isolate, 1);
     return;
   }
 
   if (thread->IsMutatorThread() && isolate->IsDeoptimizing()) {
-    counters_.single_frame_sample_deoptimizing++;
+    AtomicOperations::IncrementInt64By(
+        &counters_.single_frame_sample_deoptimizing, 1);
     SampleThreadSingleFrame(thread, pc);
     return;
   }
 
   if (!InitialRegisterCheck(pc, fp, sp)) {
-    counters_.single_frame_sample_register_check++;
+    AtomicOperations::IncrementInt64By(
+        &counters_.single_frame_sample_register_check, 1);
     SampleThreadSingleFrame(thread, pc);
     return;
   }
 
   uword stack_lower = 0;
   uword stack_upper = 0;
   if (!GetAndValidateIsolateStackBounds(thread,
                                         fp,
                                         sp,
                                         &stack_lower,
                                         &stack_upper)) {
-    counters_.single_frame_sample_get_and_validate_stack_bounds++;
+    AtomicOperations::IncrementInt64By(
+       &counters_.single_frame_sample_get_and_validate_stack_bounds, 1);
     // Could not get stack boundary.
     SampleThreadSingleFrame(thread, pc);
     return;
   }
 
   // At this point we have a valid stack boundary for this isolate and
   // know that our initial stack and frame pointers are within the boundary.
   SampleBuffer* sample_buffer = Profiler::sample_buffer();
   if (sample_buffer == NULL) {
     // Profiler not initialized.
@@ skipping 375 matching lines @@
 
 
 ProcessedSampleBuffer::ProcessedSampleBuffer()
     : code_lookup_table_(new CodeLookupTable(Thread::Current())) {
   ASSERT(code_lookup_table_ != NULL);
 }
 
 #endif  // !PRODUCT
 
 }  // namespace dart