Fast path for ThreadSpecific for main thread on TLS-slow platforms

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 26 matching lines @@
  *     only once.
  * This semantic discrepancy does not impose any problem because nowhere in
  * WebKit the repeated call bahavior is utilized.
  */
 
 #ifndef WTF_ThreadSpecific_h
 #define WTF_ThreadSpecific_h
 
 #include "wtf/Allocator.h"
 #include "wtf/Noncopyable.h"
+#include "wtf/StackUtil.h"
 #include "wtf/StdLibExtras.h"
 #include "wtf/WTF.h"
 #include "wtf/WTFExport.h"
 #include "wtf/allocator/PartitionAllocator.h"
 #include "wtf/allocator/Partitions.h"
 
 #if OS(POSIX)
 #include <pthread.h>
 #elif OS(WIN)
 #include <windows.h>
@@ skipping 49 matching lines @@
 #if OS(WIN)
     void (*destructor)(void*);
 #endif
   };
 
 #if OS(POSIX)
   pthread_key_t m_key;
 #elif OS(WIN)
   int m_index;
 #endif
+  // This member must only be accessed or modified on the main thread.
+  T* m_mainThreadStorage = nullptr;
 };
 
 #if OS(POSIX)
 
 typedef pthread_key_t ThreadSpecificKey;
 
 inline void threadSpecificKeyCreate(ThreadSpecificKey* key,
                                     void (*destructor)(void*)) {
   int error = pthread_key_create(key, destructor);
   if (error)
@@ skipping 128 matching lines @@
   delete data;
 }
 
 template <typename T>
 inline bool ThreadSpecific<T>::isSet() {
   return !!get();
 }
 
 template <typename T>
 inline ThreadSpecific<T>::operator T*() {
-  T* ptr = static_cast<T*>(get());
-  if (!ptr) {
-    // 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.
-    ptr = static_cast<T*>(Partitions::fastZeroedMalloc(
+  T* offThreadPtr;
+#if defined(__GLIBC__) || OS(ANDROID) || OS(FREEBSD)
+  // TLS is fast on these platforms.
+  // TODO(csharrison): Qualify this statement for Android.
+  T** ptr = &offThreadPtr;
+  offThreadPtr = static_cast<T*>(get());
+#else
+  T** ptr = &m_mainThreadStorage;
+  if (UNLIKELY(internal::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)) {

[haraken, 2017/01/18 05:29:42]

Can we just use if(!offThreadPtr) ? I don't fully understand why we need |ptr|.

[haraken, 2017/01/18 05:29:42]

Not related to this CL but we might want to remove the logic to instantiate
ThreadSpecific lazily. Instead we should just instantiate ThreadSpecific eagerly
when a thread gets initialized. Then we won't need the branch.

[Charlie Harrison, 2017/01/18 16:29:55]

Acknowledged, though I wonder if that would lead to slower thread initialization
for cases when we certainly don't care about a ThreadSpecific except on one or
two threads?

[Charlie Harrison, 2017/01/18 16:29:55]

We use pointer indirection here because ptr can point to offThreadPtr *or*
m_mainThreadStorage, and either can be uninitialized. This allows us to use the
same code path for the main thread case and the off thread case without
duplicating something like an inline method for "init value".

We can probably remove this if your comment below is addressed. 

[haraken, 2017/01/19 01:04:38]

Thread initialization is already heavy, so I don't really care about the
overhead :)

Also it sounds like a good idea to have different methods for a main thread case
and a non-main thread case, which enables us to remove the if branch from the
main thread case.

You can address it in a follow-up.

+    *ptr = static_cast<T*>(Partitions::fastZeroedMalloc(
         sizeof(T), WTF_HEAP_PROFILER_TYPE_NAME(T)));
-    set(ptr);
-    new (NotNull, ptr) T;
+    set(*ptr);
+    new (NotNull, *ptr) T;
   }
-  return ptr;
+  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