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 133 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 = ThreadSafeInitOnceTrait,

[danno, 2012/03/29 07:45:17]

how about changing the default to SingleThreadInitOnceTrait for V8? This is by
far the most frequent usage pattern, I suspect. It might simplify code
elsewhere.

[Philippe, 2012/03/29 09:00:48]

Right. I was just concerned about the potential risk of making LazyInstance
non-thread-safe. But as you said in v8, that is frequent. I added a warning in
the top-level comment.

Done.

           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 = ThreadSafeInitOnceTrait,

[danno, 2012/03/29 07:45:17]

Here too

[Philippe, 2012/03/29 09:00:48]

Done.

           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 = ThreadSafeInitOnceTrait,

[danno, 2012/03/29 07:45:17]

Here too

[Philippe, 2012/03/29 09:00:48]

Done.

           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_