Avoid any possibility of an Alloc during TLS thread teardown

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"
 #include "base/stringprintf.h"
 #include "base/threading/thread_restrictions.h"
 #include "build/build_config.h"
+#include "base/port.h"
 
 using base::TimeDelta;
 
 namespace tracked_objects {
 
 namespace {
 // Flag to compile out almost all of the task tracking code.
 static const bool kTrackAllTaskObjects = true;
 
 // When ThreadData is first initialized, should we start in an ACTIVE state to
@@ skipping 116 matching lines @@
 base::LazyInstance<base::Lock,
                    base::LeakyLazyInstanceTraits<base::Lock> >
     ThreadData::list_lock_ = LAZY_INSTANCE_INITIALIZER;
 
 // 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) {
+      worker_thread_number_(0) {
   DCHECK_GE(suggested_name.size(), 0u);
   thread_name_ = suggested_name;
   PushToHeadOfList();  // Which sets real incarnation_count_for_pool_.
 }
 
-ThreadData::ThreadData()
+ThreadData::ThreadData(size_t thread_number)
     : incarnation_count_for_pool_(-1),
       next_(NULL),
-      is_a_worker_thread_(true) {
-  int thread_number;
-  {
-    base::AutoLock lock(*list_lock_.Pointer());
-    thread_number = ++thread_number_counter_;
-  }
-  base::StringAppendF(&thread_name_, "WorkerThread-%d", thread_number);
+      worker_thread_number_(thread_number) {
+  CHECK_NE(thread_number, 0u);
+  base::StringAppendF(&thread_name_, "WorkerThread-%"PRIuS, thread_number);
   PushToHeadOfList();  // Which sets real incarnation_count_for_pool_.
 }
 
 ThreadData::~ThreadData() {}
 
 void ThreadData::PushToHeadOfList() {
   DCHECK(!next_);
   base::AutoLock lock(*list_lock_.Pointer());
   incarnation_count_for_pool_ = incarnation_counter_;
   next_ = all_thread_data_list_head_;
@@ skipping 15 matching lines @@
 // 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;
+  size_t thread_number = 0;
   {
     base::AutoLock lock(*list_lock_.Pointer());
-    if (unregistered_thread_data_pool_ &&
-        !unregistered_thread_data_pool_->empty()) {
+    if (!unregistered_thread_data_pool_)
+      unregistered_thread_data_pool_ = new ThreadDataPool;
+    if (!unregistered_thread_data_pool_->empty()) {
       worker_thread_data =
         const_cast<ThreadData*>(unregistered_thread_data_pool_->top());
       unregistered_thread_data_pool_->pop();
+    } else {
+      thread_number = ++thread_number_counter_;
+      unregistered_thread_data_pool_->reserve(thread_number);
     }
   }
 
   // If we can't find a previously used instance, then we have to create one.
   if (!worker_thread_data)
-    worker_thread_data = new ThreadData();
+    worker_thread_data = new ThreadData(thread_number);
+  DCHECK_GT(worker_thread_data->worker_thread_number_, 0u);
 
   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_)
+  if (!worker_thread_number_)
     return;
   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_ = new ThreadDataPool;
+  // The following will never have to do an allocation.
   unregistered_thread_data_pool_->push(this);
 }
 
 // static
 base::DictionaryValue* ThreadData::ToValue() {
   DataCollector collected_data;  // Gather data.
   collected_data.AddListOfLivingObjects();  // Add births that are still alive.
   base::ListValue* list = collected_data.ToValue();
   base::DictionaryValue* dictionary = new base::DictionaryValue();
   dictionary->Set("list", list);
@@ skipping 304 matching lines @@
     for (BirthMap::iterator it = next_thread_data->birth_map_.begin();
          next_thread_data->birth_map_.end() != it; ++it)
       delete it->second;  // Delete the Birth Records.
     next_thread_data->birth_map_.clear();
     next_thread_data->death_map_.clear();
     delete next_thread_data;  // Includes all Death Records.
   }
 }
 
 //------------------------------------------------------------------------------
+// Small partial implementation of a stack that never has to allocate during a
+// push() operation, because it is always prepared to accept the maximum number
+// of ThreadData instances (all the worker thread related instances).
+
+ThreadData::ThreadDataPool::ThreadDataPool() : empty_slot_(0) {};
+ThreadData::ThreadDataPool::~ThreadDataPool() {};
+
+bool ThreadData::ThreadDataPool::empty() const { return empty_slot_ == 0; }
+
+void ThreadData::ThreadDataPool::reserve(size_t largest_worker_pool_number) {
+  // Worker pool numbers start at 1, and exclude 0, so the number is exactly
+  // the least size needed.
+  // Due to asynchronous construction of worker-pool numbers (and associated
+  // ThreadData), we might not hear about the numbers sequentially.
+  if (largest_worker_pool_number > stack_.size())
+    stack_.resize(largest_worker_pool_number);
+}
+
+const ThreadData* ThreadData::ThreadDataPool::top() const {
+  if (empty_slot_ > 0)
+    return stack_[empty_slot_ - 1];
+  NOTREACHED();
+  return NULL;
+}
+
+void ThreadData::ThreadDataPool::push(const ThreadData* thread_data) {
+  if (empty_slot_ < stack_.size()) {
+    stack_[empty_slot_] = thread_data;
+    ++empty_slot_;
+    return;
+  }
+  NOTREACHED();
+}
+
+void ThreadData::ThreadDataPool::pop() {
+  if (empty_slot_ > 0) {
+    --empty_slot_;
+    return;
+  }
+  NOTREACHED();
+}
+
+//------------------------------------------------------------------------------
 // Individual 3-tuple of birth (place and thread) along with death thread, and
 // the accumulated stats for instances (DeathData).
 
 Snapshot::Snapshot(const BirthOnThread& birth_on_thread,
                    const ThreadData& death_thread,
                    const DeathData& death_data)
     : birth_(&birth_on_thread),
       death_thread_(&death_thread),
       death_data_(death_data) {
 }
@@ skipping 80 matching lines @@
 
 base::ListValue* DataCollector::ToValue() const {
   base::ListValue* list = new base::ListValue;
   for (size_t i = 0; i < collection_.size(); ++i) {
     list->Append(collection_[i].ToValue());
   }
   return list;
 }
 
 }  // namespace tracked_objects