Add ability to retrieve a thread_name given a thread_id.

base/threading/thread_id_name_manager.cc

Index: base/threading/thread_id_name_manager.cc
diff --git a/base/threading/thread_id_name_manager.cc b/base/threading/thread_id_name_manager.cc
new file mode 100644
index 0000000000000000000000000000000000000000..8b55af4229f526a980cc5c0e0971ca10c7018fa6
--- /dev/null
+++ b/base/threading/thread_id_name_manager.cc
@@ -0,0 +1,64 @@
+// 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/threading/thread_id_name_manager.h"
+
+#include <stdlib.h>
+#include <string.h>
+
+#include "base/logging.h"
+#include "base/memory/singleton.h"
+
+namespace base {
+
+ThreadIdNameManager::ThreadIdNameManager()
+    : current_version_(1) {
+}
+
+ThreadIdNameManager::~ThreadIdNameManager() {
+}
+
+ThreadIdNameManager* ThreadIdNameManager::GetInstance() {
+  return Singleton<ThreadIdNameManager,
+      LeakySingletonTraits<ThreadIdNameManager> >::get();
+}
+
+const char* ThreadIdNameManager::GetNameForId(PlatformThreadId id) {
+  base::AutoLock locked(lock_);
+  DCHECK(id_to_name_.count(id));
+  return id_to_name_[id];

[jar (doing other things), 2012/12/14 18:23:07]

I have a tiny concern about the lifetime of this character buffer.  Once the
lock is released, it could be deleted asynchronously. 

How often is this used?  Any chance a copy, such as via std:string, would be
cleaner or safer?  Am I being too paranoid here?

[dsinclair, 2012/12/14 19:13:46]

Currently, this is used in one place, the tracing framework code.

As far as I can tell from searching around, std::string isn't necessarily thread
safe either. I think the only way we'd be safe is to strdup and then make the
caller free which is getting ugly.

The other thing to keep in mind here is, we want this as fast as possible. The
tracing code maybe calling this a lot, although I can cut down that number now I
believe.

So, I'm not sure the correct solution for this, and am happy to take
suggestions.

[jar (doing other things), 2012/12/14 19:58:08]

Sorry for my seemingly confusing mention of std::string.

I was suggesting returning a std::string temporary, which was effectively an
allocated copy of the char*.  We can probably set this up so that the caller
does not explicitly call delete, but rather the temporary is discarded (in due
course) after use by the caller.

That does have a cost that involves a call to malloc (implicitly).  We do also
have a stack-allocated-string, which could allow slightly less cost... but there
is always the cost of the memcpy action :-/.

It could also be that this code is only significantly active when a person is
debugging, and hence we can afford the risk... or it could be that threads
should not go away while doing this debugging... and that is our safe haven.  I
wanted to at least talk about it.

You could also just leak the char*, rather than deleting it with the
destruction.  Assuming that threads are not created and destroyed regularly (and
named), this would be a non-problem.  Do you know if we have a lot of creation
and destruction of threads (and names)?  I didn't think we did :-/.

On 2012/12/14 19:13:46, dsinclair wrote:

[dsinclair, 2012/12/14 20:18:19]

Sorry, I was thinking the copy-on-write semantics of the std::string would kick
in but the creation from a char* would be an alloc/copy.
I don't know about in the future, but currently this would only be accessed when
you're using chrome://tracing. The trace framework has logic so the calls won't
be made unless tracing is currently enabled.

 
The name is part of the constructor for a thread, so they should always be
named. I don't know what the rate of creation is for threads in the system.

+}
+
+void ThreadIdNameManager::SetNameForId(PlatformThreadId id, const char* name) {
+  base::AutoLock locked(lock_);
+  if (id_to_name_.count(id))
+    free(id_to_name_[id]);
+
+  id_to_name_[id] = strdup(name);
+  id_to_version_[id] = current_version_++;
+}
+
+void ThreadIdNameManager::RemoveNameForId(PlatformThreadId id) {
+  if (id == base::kInvalidThreadId)
+    return;
+
+  base::AutoLock locked(lock_);
+  DCHECK(id_to_name_.count(id));
+
+  char* old_name = id_to_name_[id];
+  id_to_name_.erase(id);
+  id_to_version_.erase(id);
+  free(old_name);
+}
+
+uint32 ThreadIdNameManager::GetVersionForId(PlatformThreadId id) {
+  if (id == base::kInvalidThreadId)
+    return 0;
+
+  base::AutoLock locked(lock_);
+  DCHECK(id_to_version_.count(id));
+  return id_to_version_[id];
+}
+
+}  // namespace base