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

third_party/WebKit/Source/wtf/ThreadSpecific.h

 /*
  * Copyright (C) 2008 Apple Inc. All rights reserved.
  * Copyright (C) 2009 Jian Li <jianli@chromium.org>
  * Copyright (C) 2012 Patrick Gansterer <paroga@paroga.com>
  *
  * 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 250 matching lines @@
 inline bool ThreadSpecific<T>::isSet() {
   return !!get();
 }
 
 template <typename T>
 inline ThreadSpecific<T>::operator T*() {
   T* offThreadPtr;
 #if defined(__GLIBC__) || OS(ANDROID) || OS(FREEBSD)
   // TLS is fast on these platforms.
   // TODO(csharrison): Qualify this statement for Android.
+  const bool mainThreadAlwaysChecksTLS = true;
   T** ptr = &offThreadPtr;
   offThreadPtr = static_cast<T*>(get());
 #else
+  const bool mainThreadAlwaysChecksTLS = false;
   T** ptr = &m_mainThreadStorage;
-  if (UNLIKELY(internal::mayNotBeMainThread())) {
+  if (UNLIKELY(mayNotBeMainThread())) {
     offThreadPtr = static_cast<T*>(get());
     ptr = &offThreadPtr;
   }
 #endif
   // Set up thread-specific value's memory pointer before invoking constructor,
   // in case any function it calls needs to access the value, to avoid
   // recursion.
   if (UNLIKELY(!*ptr)) {
     *ptr = static_cast<T*>(Partitions::fastZeroedMalloc(
         sizeof(T), WTF_HEAP_PROFILER_TYPE_NAME(T)));
+
+    // Even if we didn't realize we're on the main thread, we might still be.
+    // We need to double-check so that |m_mainThreadStorage| is populated.
+    if (!mainThreadAlwaysChecksTLS && UNLIKELY(ptr != &m_mainThreadStorage) &&
+        isMainThread()) {
+      m_mainThreadStorage = *ptr;

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

Or is there any option to populate m_mainThreadStorage when initializing the
main thread? Will it mess up the code?

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

We have no registry of all ThreadSpecific objects, and some of them require
other parts of Blink to be initialized (e.g. many are Persistent handles into
the Oilpan heap). Some of these objects may even allocate resources when an
instance per thread is created, so I don't think it would be a good blanket
policy to initialize all of them on thread start.

As you say, this code is only hit when the object does not yet exist on the
calling thread and so isn't hot. We could possible out-of-line this at some
point if it becomes a code size issue, but most of these checks should be pretty
small, and isMainThread is already out-of-line.

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

Ah, sorry, you're totally right. Given that ThreadSpecific exists per TLS, it's
never a good idea to initialize it eagerly.

+    }
+
     set(*ptr);
     new (NotNull, *ptr) T;
   }
   return *ptr;
 }
 
 template <typename T>
 inline T* ThreadSpecific<T>::operator->() {
   return operator T*();
 }
 
 template <typename T>
 inline T& ThreadSpecific<T>::operator*() {
   return *operator T*();
 }
 
 }  // namespace WTF
 
 using WTF::ThreadSpecific;
 
 #endif  // WTF_ThreadSpecific_h