lazy_instance_helpers.cc (2798B)
1 // Copyright 2018 The Chromium Authors 2 // Use of this source code is governed by a BSD-style license that can be 3 // found in the LICENSE file. 4 5 #include "base/lazy_instance_helpers.h" 6 7 #include <atomic> 8 9 #include "base/at_exit.h" 10 #include "base/threading/platform_thread.h" 11 12 namespace base { 13 namespace internal { 14 15 bool NeedsLazyInstance(std::atomic<uintptr_t>& state) { 16 // Try to create the instance, if we're the first, will go from 0 to 17 // kLazyInstanceStateCreating, otherwise we've already been beaten here. 18 // The memory access has no memory ordering as state 0 and 19 // kLazyInstanceStateCreating have no associated data (memory barriers are 20 // all about ordering of memory accesses to *associated* data). 21 uintptr_t expected = 0; 22 if (state.compare_exchange_strong(expected, kLazyInstanceStateCreating, 23 std::memory_order_relaxed, 24 std::memory_order_relaxed)) { 25 // Caller must create instance 26 return true; 27 } 28 29 // It's either in the process of being created, or already created. Spin. 30 // The load has acquire memory ordering as a thread which sees 31 // state_ == STATE_CREATED needs to acquire visibility over 32 // the associated data (buf_). Pairing Release_Store is in 33 // CompleteLazyInstance(). 34 if (state.load(std::memory_order_acquire) == kLazyInstanceStateCreating) { 35 const base::TimeTicks start = base::TimeTicks::Now(); 36 do { 37 const base::TimeDelta elapsed = base::TimeTicks::Now() - start; 38 // Spin with YieldCurrentThread for at most one ms - this ensures 39 // maximum responsiveness. After that spin with Sleep(1ms) so that we 40 // don't burn excessive CPU time - this also avoids infinite loops due 41 // to priority inversions (https://crbug.com/797129). 42 if (elapsed < Milliseconds(1)) 43 PlatformThread::YieldCurrentThread(); 44 else 45 PlatformThread::Sleep(Milliseconds(1)); 46 } while (state.load(std::memory_order_acquire) == 47 kLazyInstanceStateCreating); 48 } 49 // Someone else created the instance. 50 return false; 51 } 52 53 void CompleteLazyInstance(std::atomic<uintptr_t>& state, 54 uintptr_t new_instance, 55 void (*destructor)(void*), 56 void* destructor_arg) { 57 // Instance is created, go from CREATING to CREATED (or reset it if 58 // |new_instance| is null). Releases visibility over |private_buf_| to 59 // readers. Pairing Acquire_Load is in NeedsLazyInstance(). 60 state.store(new_instance, std::memory_order_release); 61 62 // Make sure that the lazily instantiated object will get destroyed at exit. 63 if (new_instance && destructor) 64 AtExitManager::RegisterCallback(destructor, destructor_arg); 65 } 66 67 } // namespace internal 68 } // namespace base