Cheaper thread-safe atomic initialization of static references.

Source/wtf/Threading.h

 /*
  * Copyright (C) 2007, 2008, 2010 Apple Inc. All rights reserved.
  * Copyright (C) 2007 Justin Haygood (jhaygood@reaktix.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
  *     notice, this list of conditions and the following disclaimer.
@@ skipping 12 matching lines @@
  * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
  * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #ifndef Threading_h
 #define Threading_h
 
+#include "wtf/Atomics.h"
+#include "wtf/TypeTraits.h"
 #include "wtf/WTFExport.h"
 #include <stdint.h>
 
-// For portability, we do not use thread-safe statics natively supported by some compilers (e.g. gcc).
-#define AtomicallyInitializedStatic(T, name) \
-    WTF::lockAtomicallyInitializedStaticMutex(); \
-    static T name; \
-    WTF::unlockAtomicallyInitializedStaticMutex();
+// For portability, we do not make use of C++11 thread-safe statics, as supported
+// by some toolchains. Make use of double-checked locking to reduce overhead.
+#define AtomicallyInitializedStaticReference(T, name, initializer)      \

[Noel Gordon, 2015/01/24 01:20:06]

To "reduce overhead" relative to what?

[sof, 2015/01/24 06:20:06]

To what's on the left here in the diff? :) Doesn't the use of "double-checked
locking" give enough context for someone wanting to understand motivation?

[Noel Gordon, 2015/01/24 12:08:24]

Think _we_ understand the motivation :) but other developers reading this code
are not necessarily looking at a diff, or might not know what double-checked
locking is, or how it reduces the overhead relative to some other unspecified
thing (which is perhaps the cost of locking a mutex, the comment doesn't really
say). Perhaps in this instance, the comment at diff-left was somewhat better.

imho ... change descriptions are the best place to say such things, at least in
the Blink project. Developers can 'git blame' to find the relevant descriptions
to read and, given well-written change descriptions that explain the "why", that
helps new developers gain a deeper understanding of our code.

[sof, 2015/01/24 12:40:05]

Sounds sensible; doesn't the description here explain in a bit more detail?

+    /* Init to nullptr is thread-safe on all implementations. */        \
+    static void* name##Pointer = nullptr;                               \
+    if (!WTF::acquireLoad(&name##Pointer)) {                            \

[Noel Gordon, 2015/01/24 01:20:06]

Blink prefers the early return. Any reason not to use it here?

[sof, 2015/01/24 06:20:06]

You have to bind the reference, and at the scope the macro is used, so I don't
see the alternative you have in mind to evaluate if that is clearer.

[Noel Gordon, 2015/01/24 12:08:24]

Yes I see your point, @51 it seems, so ok.

+        WTF::lockAtomicallyInitializedStaticMutex();                    \
+        if (!WTF::acquireLoad(&name##Pointer)) {                        \
+            WTF::RemoveConst<T>::Type* initializerResult = initializer; \
+            WTF::releaseStore(&name##Pointer, initializerResult);       \
+        }                                                               \
+        WTF::unlockAtomicallyInitializedStaticMutex();                  \
+    }                                                                   \
+    T& name = *static_cast<T*>(name##Pointer)
 
 namespace WTF {
 
 #if OS(WIN)
 typedef uint32_t ThreadIdentifier;
 #else
 typedef intptr_t ThreadIdentifier;
 #endif
 
 WTF_EXPORT ThreadIdentifier currentThread();
 
 WTF_EXPORT void lockAtomicallyInitializedStaticMutex();
 WTF_EXPORT void unlockAtomicallyInitializedStaticMutex();
 
 } // namespace WTF
 
 using WTF::ThreadIdentifier;
 using WTF::currentThread;
 
 #endif // Threading_h