Fix performance regressions due to lazy initialization.

src/lazy-instance.h

 // Copyright 2012 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 47 matching lines @@
 // providing your own trait:
 // Example usage:
 //   struct MyCreateTrait {
 //     static void Construct(MyClass* allocated_ptr) {
 //       new (allocated_ptr) MyClass(/* extra parameters... */);
 //     }
 //   };
 //   static LazyInstance<MyClass, MyCreateTrait>::type my_instance =
 //      LAZY_INSTANCE_INITIALIZER;
 //
+// WARNING: This implementation of LazyInstance is NOT thread-safe by default.
+// See ThreadSafeInitOnceTrait declared below for that.
+//
 // Notes for advanced users:
 // LazyInstance can actually be used in two different ways:
 //
 // - "Static mode" which is the default mode since it is the most efficient
 //   (no extra heap allocation). In this mode, the instance is statically
 //   allocated (stored in the global data section at compile time).
 //   The macro LAZY_STATIC_INSTANCE_INITIALIZER (= LAZY_INSTANCE_INITIALIZER)
 //   must be used to initialize static lazy instances.
 //
 // - "Dynamic mode". In this mode, the instance is dynamically allocated and
@@ skipping 66 matching lines @@
 
 
 template <typename T>
 struct DefaultCreateTrait {
   static T* Create() {
     return new T();
   }
 };
 
 
+template <typename T>
+struct ThreadSafeInitOnceTrait {
+  template <typename Function, typename Storage>
+  static void Init(OnceType* once, Function function, Storage storage) {
+    CallOnce(once, function, storage);
+  }
+};
+
+
+// Initialization trait for users who don't care about thread-safety.
+template <typename T>
+struct SingleThreadInitOnceTrait {
+  template <typename Function, typename Storage>
+  static void Init(OnceType* once, Function function, Storage storage) {
+    if (*once == ONCE_STATE_UNINITIALIZED) {
+      function(storage);
+      *once = ONCE_STATE_DONE;
+    }
+  }
+};
+
+
 // TODO(pliard): Handle instances destruction (using global destructors).
 template <typename T, typename AllocationTrait, typename CreateTrait,
-          typename DestroyTrait  /* not used yet. */ >
+          template <class> class InitOnceTrait,
+          typename DestroyTrait  /* not used yet. */>
 struct LazyInstanceImpl {
  public:
   typedef typename AllocationTrait::StorageType StorageType;
 
  private:
   static void InitInstance(StorageType* storage) {
     AllocationTrait::template InitStorageUsingTrait<CreateTrait>(storage);
   }
 
   void Init() const {
-    CallOnce(&once_, &InitInstance, &storage_);
+    InitOnceTrait<T>::Init(
+        &once_,
+        // Casts to void* are needed here to avoid breaking strict aliasing
+        // rules.
+        reinterpret_cast<void (*)(void*)>(&InitInstance),
+        reinterpret_cast<void*>(&storage_));
   }
 
  public:
   T* Pointer() {
     Init();
     return AllocationTrait::MutableInstance(&storage_);
   }
 
   const T& Get() const {
     Init();
     return *AllocationTrait::MutableInstance(&storage_);
   }
 
   mutable OnceType once_;
   // Note that the previous field, OnceType, is an AtomicWord which guarantees
   // the correct alignment of the storage field below.
   mutable StorageType storage_;
 };
 
 
 template <typename T,
           typename CreateTrait = DefaultConstructTrait<T>,
+          template <class> class InitOnceTrait = SingleThreadInitOnceTrait,
           typename DestroyTrait = LeakyInstanceTrait<T> >
 struct LazyStaticInstance {
-  typedef LazyInstanceImpl<T, StaticallyAllocatedInstanceTrait<T>, CreateTrait,
-      DestroyTrait> type;
+  typedef LazyInstanceImpl<T, StaticallyAllocatedInstanceTrait<T>,
+      CreateTrait, InitOnceTrait, DestroyTrait> type;
 };
 
 
 template <typename T,
           typename CreateTrait = DefaultConstructTrait<T>,
+          template <class> class InitOnceTrait = SingleThreadInitOnceTrait,
           typename DestroyTrait = LeakyInstanceTrait<T> >
 struct LazyInstance {
   // A LazyInstance is a LazyStaticInstance.
-  typedef typename LazyStaticInstance<T, CreateTrait, DestroyTrait>::type type;
+  typedef typename LazyStaticInstance<T, CreateTrait, InitOnceTrait,
+      DestroyTrait>::type type;
 };
 
 
 template <typename T,
           typename CreateTrait = DefaultConstructTrait<T>,
+          template <class> class InitOnceTrait = SingleThreadInitOnceTrait,
           typename DestroyTrait = LeakyInstanceTrait<T> >
 struct LazyDynamicInstance {
-  typedef LazyInstanceImpl<T, DynamicallyAllocatedInstanceTrait<T>, CreateTrait,
-      DestroyTrait> type;
+  typedef LazyInstanceImpl<T, DynamicallyAllocatedInstanceTrait<T>,
+      CreateTrait, InitOnceTrait, DestroyTrait> type;
 };
 
 } }  // namespace v8::internal
 
 #endif  // V8_LAZY_INSTANCE_H_