WTF: Initialize main-thread stack estimates when WTF starts up.

third_party/WebKit/Source/wtf/ThreadingPthreads.cpp

 /*
  * Copyright (C) 2007, 2009 Apple Inc. All rights reserved.
  * Copyright (C) 2007 Justin Haygood (jhaygood@reaktix.com)
  * Copyright (C) 2011 Research In Motion Limited. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  *
  * 1.  Redistributions of source code must retain the above copyright
@@ skipping 67 matching lines @@
 void initializeThreading() {
   // This should only be called once.
   WTFThreadData::initialize();
 
   initializeDates();
   // Force initialization of static DoubleToStringConverter converter variable
   // inside EcmaScriptConverter function while we are in single thread mode.
   double_conversion::DoubleToStringConverter::EcmaScriptConverter();
 }
 
+namespace {
+ThreadSpecificKey s_currentThreadKey;
+bool s_currentThreadKeyInitialized = false;
+}  // namespace
+
+void initializeCurrentThread() {
+  DCHECK(!s_currentThreadKeyInitialized);
+  threadSpecificKeyCreate(&s_currentThreadKey, [](void*) {});
+  s_currentThreadKeyInitialized = true;
+}
+
 ThreadIdentifier currentThread() {
-  return wtfThreadData().threadId();

[haraken, 2017/03/06 19:21:36]

A stupid question: Why can't we use wtfThreadData() whereas other places are
using wtfThreadData()?

[jbroman, 2017/03/06 20:28:09]

Cyclic dependency. If wtfThreadData() is used here, we can loop like this (until
stack overflow):

currentThread -> wtfThreadData -> ThreadSpecific::operator* -> isMainThread ->
currentThread

There are a few ways of resolving this cycle, of which this seemed simplest to
me (especially storing the thread ID doesn't require supporting destructors
etc.). It also happens to remove one pointer indirection from currentThread, and
avoids reinitializing the atomic string table et al. if the thread ID is used
during thread shutdown, which are nice side effects.

[haraken, 2017/03/06 20:46:42]

Ah, got it. Maybe it's worth having a comment :)

[jbroman, 2017/03/07 16:03:30]

Done.

+  static_assert(sizeof(ThreadIdentifier) <= sizeof(void*),
+                "ThreadIdentifier must fit in a void*.");
+  DCHECK(s_currentThreadKeyInitialized);
+  void* value = threadSpecificGet(s_currentThreadKey);
+  if (UNLIKELY(!value)) {
+    value = reinterpret_cast<void*>(
+        static_cast<intptr_t>(internal::currentThreadSyscall()));
+    DCHECK(value);
+    threadSpecificSet(s_currentThreadKey, value);
+  }
+  return reinterpret_cast<intptr_t>(threadSpecificGet(s_currentThreadKey));
 }
 
 MutexBase::MutexBase(bool recursive) {
   pthread_mutexattr_t attr;
   pthread_mutexattr_init(&attr);
   pthread_mutexattr_settype(
       &attr, recursive ? PTHREAD_MUTEX_RECURSIVE : PTHREAD_MUTEX_NORMAL);
 
   int result = pthread_mutex_init(&m_mutex.m_internalMutex, &attr);
   DCHECK_EQ(result, 0);
@@ skipping 124 matching lines @@
 }
 
 void willCreateThread() {
   s_threadCreated = true;
 }
 #endif
 
 }  // namespace WTF
 
 #endif  // OS(POSIX)