Use leaky lazy instance for master lock in profiler

base/tracked_objects.cc

 // Copyright (c) 2011 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 <math.h>
 
 #include "base/format_macros.h"
 #include "base/message_loop.h"
@@ skipping 147 matching lines @@
 // static
 int ThreadData::incarnation_counter_ = 0;
 
 // static
 ThreadData* ThreadData::all_thread_data_list_head_ = NULL;
 
 // static
 ThreadData::ThreadDataPool* ThreadData::unregistered_thread_data_pool_ = NULL;
 
 // static
-base::Lock* ThreadData::list_lock_;
+base::LazyInstance<base::Lock,
+                   base::LeakyLazyInstanceTraits<base::Lock> >
+    ThreadData::list_lock_(base::LINKER_INITIALIZED);
 
 // static
 ThreadData::Status ThreadData::status_ = ThreadData::UNINITIALIZED;
 
 ThreadData::ThreadData(const std::string& suggested_name)
     : incarnation_count_for_pool_(-1),
       next_(NULL),
       is_a_worker_thread_(false) {
   DCHECK_GE(suggested_name.size(), 0u);
   thread_name_ = suggested_name;
   PushToHeadOfList();  // Which sets real incarnation_count_for_pool_.
 }
 
 ThreadData::ThreadData()
     : incarnation_count_for_pool_(-1),
       next_(NULL),
       is_a_worker_thread_(true) {
   int thread_number;
   {
-    base::AutoLock lock(*list_lock_);
+    base::AutoLock lock(*list_lock_.Pointer());
     thread_number = ++thread_number_counter_;
   }
   base::StringAppendF(&thread_name_, "WorkerThread-%d", thread_number);
   PushToHeadOfList();  // Which sets real incarnation_count_for_pool_.
 }
 
 ThreadData::~ThreadData() {}
 
 void ThreadData::PushToHeadOfList() {
   DCHECK(!next_);
-  base::AutoLock lock(*list_lock_);
+  base::AutoLock lock(*list_lock_.Pointer());
   incarnation_count_for_pool_ = incarnation_counter_;
   next_ = all_thread_data_list_head_;
   all_thread_data_list_head_ = this;
 }
 
 // static
 void ThreadData::InitializeThreadContext(const std::string& suggested_name) {
   if (!Initialize())  // Always initialize if needed.
     return;
   ThreadData* current_thread_data =
       reinterpret_cast<ThreadData*>(tls_index_.Get());
   if (current_thread_data)
     return;  // Browser tests instigate this.
   current_thread_data = new ThreadData(suggested_name);
   tls_index_.Set(current_thread_data);
 }
 
 // static
 ThreadData* ThreadData::Get() {
   if (!tls_index_.initialized())
     return NULL;  // For unittests only.
   ThreadData* registered = reinterpret_cast<ThreadData*>(tls_index_.Get());
   if (registered)
     return registered;
 
   // We must be a worker thread, since we didn't pre-register.
   ThreadData* worker_thread_data = NULL;
   {
-    base::AutoLock lock(*list_lock_);
-    if (!unregistered_thread_data_pool_->empty()) {
+    base::AutoLock lock(*list_lock_.Pointer());
+    if (unregistered_thread_data_pool_ &&
+        !unregistered_thread_data_pool_->empty()) {
       worker_thread_data =
         const_cast<ThreadData*>(unregistered_thread_data_pool_->top());
       unregistered_thread_data_pool_->pop();
     }
   }
 
   // If we can't find a previously used instance, then we have to create one.
   if (!worker_thread_data)
     worker_thread_data = new ThreadData();
 
   tls_index_.Set(worker_thread_data);
   return worker_thread_data;
 }
 
 // static
 void ThreadData::OnThreadTermination(void* thread_data) {
   if (!kTrackAllTaskObjects)
     return;  // Not compiled in.
   if (!thread_data)
     return;
   reinterpret_cast<ThreadData*>(thread_data)->OnThreadTerminationCleanup();
 }
 
 void ThreadData::OnThreadTerminationCleanup() const {
   if (!is_a_worker_thread_)
     return;
-  base::AutoLock lock(*list_lock_);
+  base::AutoLock lock(*list_lock_.Pointer());
   if (incarnation_counter_ != incarnation_count_for_pool_)
     return;  // ThreadData was constructed in an earlier unit test.
 
   // Handle case where we are in unit tests, and have become UNINITIALIZED.
   // In that case, the pool might be NULL.  We really should detect this via the
   // incarnation_counter_, but this call is rarely made, so we can afford to
   // code defensively.
-  if (unregistered_thread_data_pool_)
-    unregistered_thread_data_pool_->push(this);
+  if (!unregistered_thread_data_pool_)
+    unregistered_thread_data_pool_ = new ThreadDataPool;
+  unregistered_thread_data_pool_->push(this);
 }
 
 // static
 void ThreadData::WriteHTML(const std::string& query, std::string* output) {
   if (status_ == UNINITIALIZED)
     return;  // Not yet initialized.
 
   DataCollector collected_data;  // Gather data.
   collected_data.AddListOfLivingObjects();  // Add births that are still alive.
 
@@ skipping 252 matching lines @@
 
   DurationInt queue_duration = 0;
   DurationInt run_duration = (end_of_run - start_of_run).InMilliseconds();
   current_thread_data->TallyADeath(*birth, queue_duration, run_duration);
 }
 
 
 
 // static
 ThreadData* ThreadData::first() {
-  base::AutoLock lock(*list_lock_);
+  base::AutoLock lock(*list_lock_.Pointer());
   return all_thread_data_list_head_;
 }
 
 // This may be called from another thread.
 void ThreadData::SnapshotBirthMap(BirthMap *output) const {
   base::AutoLock lock(lock_);
   for (BirthMap::const_iterator it = birth_map_.begin();
        it != birth_map_.end(); ++it)
     (*output)[it->first] = it->second;
 }
@@ skipping 32 matching lines @@
   if (status_ != UNINITIALIZED)
     return true;
   // Initialize all leaking constants that are difficult to toggle in and out
   // of existance.
   // First call must be made when single threaded at startup.
   // Perform the "real" TLS initialization now, and leave it intact through
   // process termination.
   if (!tls_index_.initialized())  // Testing may have initialized this.
     tls_index_.Initialize(&ThreadData::OnThreadTermination);
   DCHECK(tls_index_.initialized());
-  ThreadDataPool* pool = new ThreadDataPool;
-  // TODO(jar): A linker initialized spin lock would be much safer than this
-  // allocation, which relies on being called while single threaded.
-  if (!list_lock_)  // In case testing deleted this.
-    list_lock_ = new base::Lock;
   status_ = kInitialStartupState;
 
-  base::AutoLock lock(*list_lock_);
-  DCHECK_EQ(unregistered_thread_data_pool_,
-            reinterpret_cast<ThreadDataPool*>(NULL));
-  unregistered_thread_data_pool_ = pool;
+  base::AutoLock lock(*list_lock_.Pointer());
   ++incarnation_counter_;
   return true;
 }
 
 // static
 bool ThreadData::InitializeAndSetTrackingStatus(bool status) {
   if (!Initialize())  // No-op if already initialized.
     return false;  // Not compiled in.
 
   status_ = status ? ACTIVE : DEACTIVATED;
@@ skipping 25 matching lines @@
 // static
 void ThreadData::ShutdownSingleThreadedCleanup(bool leak) {
   // This is only called from test code, where we need to cleanup so that
   // additional tests can be run.
   // We must be single threaded... but be careful anyway.
   if (!InitializeAndSetTrackingStatus(false))
     return;
   ThreadData* thread_data_list;
   ThreadDataPool* final_pool;
   {
-    base::AutoLock lock(*list_lock_);
+    base::AutoLock lock(*list_lock_.Pointer());
     thread_data_list = all_thread_data_list_head_;
     all_thread_data_list_head_ = NULL;
     final_pool = unregistered_thread_data_pool_;
     unregistered_thread_data_pool_ = NULL;
     ++incarnation_counter_;
   }
 
   // Put most global static back in pristine shape.
   thread_number_counter_ = 0;
   tls_index_.Set(NULL);
@@ skipping 599 matching lines @@
                         (combined_selectors_ & BIRTH_THREAD) ? "*" :
                           sample.birth().birth_thread()->thread_name().c_str(),
                         (combined_selectors_ & DEATH_THREAD) ? "*" :
                           sample.DeathThreadName().c_str());
   sample.birth().location().Write(!(combined_selectors_ & BIRTH_FILE),
                                   !(combined_selectors_ & BIRTH_FUNCTION),
                                   output);
 }
 
 }  // namespace tracked_objects