Don't create redundant ThreadData for Worker Threads

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"
@@ skipping 336 matching lines @@
 
 // static
 ThreadData* ThreadData::first() {
   base::AutoLock lock(*list_lock_.Pointer());
   return all_thread_data_list_head_;
 }
 
 ThreadData* ThreadData::next() const { return next_; }
 
 // static
-void ThreadData::InitializeThreadContext(const std::string& suggested_name) {
+void ThreadData::InitializeThreadContext(const std::string& suggested_name,
+                                         bool is_worker_thread) {

[dcheng, 2016/04/01 10:52:30]

Interesting, the original assumption is that worker threads are always unnamed:
https://chromium.googlesource.com/chromium/src/+/620e0190cea3663581dd91b6f6bc...

There seems to be a disconnect between what ThreadData::Get() expects (worker
threads won't set names) vs what happens today. The Windows worker pool, for
instance, doesn't call SetName().

Being able to name a worker pool seems useful, but some other worker pool
implementations, e.g.
https://code.google.com/p/chromium/codesearch#chromium/src/content/renderer/r...,
also have this problem, so you'll (probably?) have to fix those as well.

   Initialize();
   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);
+
+  if (is_worker_thread) {

[dcheng, 2016/04/01 10:52:30]

Can we just early return at the beginning for worker threads? It looks like
.Get() understands how to lazily create a ThreadData for a worker thread, so we
should be able to just rely on that.

+    // Try to reuse retired worker thread data first
+    if (first_retired_worker_) {
+      current_thread_data = first_retired_worker_;
+      first_retired_worker_ = first_retired_worker_->next_retired_worker_;
+      current_thread_data->next_retired_worker_ = NULL;
+    } else {
+      int worker_thread_number = ++worker_thread_data_creation_count_;
+      DCHECK_GT(worker_thread_number, 0);
+      current_thread_data = new ThreadData(worker_thread_number);
+    }
+    DCHECK_GT(current_thread_data->worker_thread_number_, 0);
+  }
+  else {
+    current_thread_data = new ThreadData(suggested_name);
+  }
+
+  DCHECK(current_thread_data);
   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;
@@ skipping 594 matching lines @@
 #endif
 }
 
 ProcessDataSnapshot::ProcessDataSnapshot(const ProcessDataSnapshot& other) =
     default;
 
 ProcessDataSnapshot::~ProcessDataSnapshot() {
 }
 
 }  // namespace tracked_objects