1 // Copyright 2012 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/threading/thread_id_name_manager.h"
6
7 #include <stdlib.h>
8 #include <string.h>
9
10 #include "base/check.h"
11 #include "base/containers/contains.h"
12 #include "base/memory/singleton.h"
13 #include "base/strings/string_util.h"
14 #include "base/trace_event/heap_profiler_allocation_context_tracker.h" // no-presubmit-check
15
16 namespace base {
17 namespace {
18
19 static const char kDefaultName[] = "";
20 static std::string* g_default_name;
21
22 constinit thread_local const char* thread_name = kDefaultName;
23 }
24
25 ThreadIdNameManager::Observer::~Observer() = default;
26
ThreadIdNameManager()27 ThreadIdNameManager::ThreadIdNameManager()
28 : main_process_name_(nullptr), main_process_id_(kInvalidThreadId) {
29 g_default_name = new std::string(kDefaultName);
30
31 AutoLock locked(lock_);
32 name_to_interned_name_[kDefaultName] = g_default_name;
33 }
34
35 ThreadIdNameManager::~ThreadIdNameManager() = default;
36
GetInstance()37 ThreadIdNameManager* ThreadIdNameManager::GetInstance() {
38 return Singleton<ThreadIdNameManager,
39 LeakySingletonTraits<ThreadIdNameManager> >::get();
40 }
41
GetDefaultInternedString()42 const char* ThreadIdNameManager::GetDefaultInternedString() {
43 return g_default_name->c_str();
44 }
45
RegisterThread(PlatformThreadHandle::Handle handle,PlatformThreadId id)46 void ThreadIdNameManager::RegisterThread(PlatformThreadHandle::Handle handle,
47 PlatformThreadId id) {
48 AutoLock locked(lock_);
49 thread_id_to_handle_[id] = handle;
50 thread_handle_to_interned_name_[handle] =
51 name_to_interned_name_[kDefaultName];
52 }
53
AddObserver(Observer * obs)54 void ThreadIdNameManager::AddObserver(Observer* obs) {
55 AutoLock locked(lock_);
56 DCHECK(!base::Contains(observers_, obs));
57 observers_.push_back(obs);
58 }
59
RemoveObserver(Observer * obs)60 void ThreadIdNameManager::RemoveObserver(Observer* obs) {
61 AutoLock locked(lock_);
62 DCHECK(base::Contains(observers_, obs));
63 std::erase(observers_, obs);
64 }
65
SetName(const std::string & name)66 void ThreadIdNameManager::SetName(const std::string& name) {
67 PlatformThreadId id = PlatformThread::CurrentId();
68 std::string* leaked_str = nullptr;
69 {
70 AutoLock locked(lock_);
71 auto iter = name_to_interned_name_.find(name);
72 if (iter != name_to_interned_name_.end()) {
73 leaked_str = iter->second;
74 } else {
75 leaked_str = new std::string(name);
76 name_to_interned_name_[name] = leaked_str;
77 }
78
79 auto id_to_handle_iter = thread_id_to_handle_.find(id);
80
81 thread_name = leaked_str->c_str();
82 for (Observer* obs : observers_)
83 obs->OnThreadNameChanged(leaked_str->c_str());
84
85 // The main thread of a process will not be created as a Thread object which
86 // means there is no PlatformThreadHandler registered.
87 if (id_to_handle_iter == thread_id_to_handle_.end()) {
88 main_process_name_ = leaked_str;
89 main_process_id_ = id;
90 return;
91 }
92 thread_handle_to_interned_name_[id_to_handle_iter->second] = leaked_str;
93 }
94
95 // Add the leaked thread name to heap profiler context tracker. The name added
96 // is valid for the lifetime of the process. AllocationContextTracker cannot
97 // call GetName(which holds a lock) during the first allocation because it can
98 // cause a deadlock when the first allocation happens in the
99 // ThreadIdNameManager itself when holding the lock.
100 trace_event::AllocationContextTracker::SetCurrentThreadName(
101 leaked_str->c_str());
102 }
103
GetName(PlatformThreadId id)104 const char* ThreadIdNameManager::GetName(PlatformThreadId id) {
105 AutoLock locked(lock_);
106
107 if (id == main_process_id_)
108 return main_process_name_->c_str();
109
110 auto id_to_handle_iter = thread_id_to_handle_.find(id);
111 if (id_to_handle_iter == thread_id_to_handle_.end())
112 return name_to_interned_name_[kDefaultName]->c_str();
113
114 auto handle_to_name_iter =
115 thread_handle_to_interned_name_.find(id_to_handle_iter->second);
116 return handle_to_name_iter->second->c_str();
117 }
118
GetNameForCurrentThread()119 const char* ThreadIdNameManager::GetNameForCurrentThread() {
120 return thread_name;
121 }
122
RemoveName(PlatformThreadHandle::Handle handle,PlatformThreadId id)123 void ThreadIdNameManager::RemoveName(PlatformThreadHandle::Handle handle,
124 PlatformThreadId id) {
125 AutoLock locked(lock_);
126 auto handle_to_name_iter = thread_handle_to_interned_name_.find(handle);
127
128 CHECK(handle_to_name_iter != thread_handle_to_interned_name_.end(),
129 base::NotFatalUntil::M125);
130 thread_handle_to_interned_name_.erase(handle_to_name_iter);
131
132 auto id_to_handle_iter = thread_id_to_handle_.find(id);
133 CHECK(id_to_handle_iter != thread_id_to_handle_.end(),
134 base::NotFatalUntil::M125);
135 // The given |id| may have been re-used by the system. Make sure the
136 // mapping points to the provided |handle| before removal.
137 if (id_to_handle_iter->second != handle)
138 return;
139
140 thread_id_to_handle_.erase(id_to_handle_iter);
141 }
142
GetIds()143 std::vector<PlatformThreadId> ThreadIdNameManager::GetIds() {
144 AutoLock locked(lock_);
145
146 std::vector<PlatformThreadId> ids;
147 ids.reserve(thread_id_to_handle_.size());
148 for (const auto& iter : thread_id_to_handle_)
149 ids.push_back(iter.first);
150
151 return ids;
152 }
153
154 } // namespace base
155