Use Atomic in IsProfilerTimingEnabled

base/tracked_objects.cc

 // Copyright (c) 2012 The Chromium 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 "base/tracked_objects.h"
 
 #include <limits.h>
 #include <stdlib.h>
 
+#include "base/atomicops.h"
 #include "base/base_switches.h"
 #include "base/command_line.h"
 #include "base/compiler_specific.h"
 #include "base/debug/leak_annotations.h"
 #include "base/logging.h"
 #include "base/process/process_handle.h"
 #include "base/profiler/alternate_timer.h"
 #include "base/strings/stringprintf.h"
 #include "base/third_party/valgrind/memcheck.h"
 #include "base/tracking_info.h"
@@ skipping 27 matching lines @@
 // Control whether an alternate time source (Now() function) is supported by
 // the ThreadData class.  This compile time flag should be set to true if we
 // want other modules (such as a memory allocator, or a thread-specific CPU time
 // clock) to be able to provide a thread-specific Now() function.  Without this
 // compile-time flag, the code will only support the wall-clock time.  This flag
 // can be flipped to efficiently disable this path (if there is a performance
 // problem with its presence).
 static const bool kAllowAlternateTimeSourceHandling = true;
 
 inline bool IsProfilerTimingEnabled() {
-  static enum {
+  enum {
     UNDEFINED_TIMING,
     ENABLED_TIMING,
     DISABLED_TIMING,
-  } timing_enabled = UNDEFINED_TIMING;
-  // This initialization is not thread-safe, so the value of |timing_enabled|
-  // can be computed multiple times. This is not an issue, as the computed value
-  // will always be the same, and is side-effect free, while needing to use a
-  // lock or a memory barrier would be more costly.
-  if (timing_enabled == UNDEFINED_TIMING) {
+  };
+  static base::subtle::Atomic32 timing_enabled = UNDEFINED_TIMING;
+  // Reading |timing_enabled| is done without barrier because multiple
+  // initialization is not an issue while the barrier can be relatively costly
+  // given that this method is sometimes called in a tight loop.
+  base::subtle::Atomic32 current_timing_enabled =
+      base::subtle::NoBarrier_Load(&timing_enabled);
+  if (current_timing_enabled == UNDEFINED_TIMING) {
     if (!CommandLine::InitializedForCurrentProcess())
       return true;
-    timing_enabled = (CommandLine::ForCurrentProcess()->GetSwitchValueASCII(
-                          switches::kProfilerTiming) ==
-                      switches::kProfilerTimingDisabledValue)
-                         ? DISABLED_TIMING
-                         : ENABLED_TIMING;
+    current_timing_enabled =
+        (CommandLine::ForCurrentProcess()->GetSwitchValueASCII(
+             switches::kProfilerTiming) ==
+         switches::kProfilerTimingDisabledValue)
+            ? DISABLED_TIMING
+            : ENABLED_TIMING;
+    base::subtle::NoBarrier_Store(&timing_enabled, current_timing_enabled);
   }
-  return timing_enabled == ENABLED_TIMING;
+  return current_timing_enabled == ENABLED_TIMING;
 }
 
 }  // namespace
 
 //------------------------------------------------------------------------------
 // DeathData tallies durations when a death takes place.
 
 DeathData::DeathData() {
   Clear();
 }
@@ skipping 801 matching lines @@
     : process_id(base::GetCurrentProcId()) {
 #else
     : process_id(0) {
 #endif
 }
 
 ProcessDataSnapshot::~ProcessDataSnapshot() {
 }
 
 }  // namespace tracked_objects