Index: src/lazy-instance.h |
diff --git a/src/lazy-instance.h b/src/lazy-instance.h |
deleted file mode 100644 |
index 09dfe2154dc2992305a0b04787d8c3cca3391193..0000000000000000000000000000000000000000 |
--- a/src/lazy-instance.h |
+++ /dev/null |
@@ -1,216 +0,0 @@ |
-// 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 |
-// with the distribution. |
-// * Neither the name of Google Inc. nor the names of its |
-// contributors may be used to endorse or promote products derived |
-// from this software without specific prior written permission. |
-// |
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS |
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT |
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR |
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT |
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (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. |
- |
-// The LazyInstance<Type, Traits> class manages a single instance of Type, |
-// which will be lazily created on the first time it's accessed. This class is |
-// useful for places you would normally use a function-level static, but you |
-// need to have guaranteed thread-safety. The Type constructor will only ever |
-// be called once, even if two threads are racing to create the object. Get() |
-// and Pointer() will always return the same, completely initialized instance. |
-// |
-// LazyInstance is completely thread safe, assuming that you create it safely. |
-// The class was designed to be POD initialized, so it shouldn't require a |
-// static constructor. It really only makes sense to declare a LazyInstance as |
-// a global variable using the LAZY_INSTANCE_INITIALIZER initializer. |
-// |
-// LazyInstance is similar to Singleton, except it does not have the singleton |
-// property. You can have multiple LazyInstance's of the same type, and each |
-// will manage a unique instance. It also preallocates the space for Type, as |
-// to avoid allocating the Type instance on the heap. This may help with the |
-// performance of creating the instance, and reducing heap fragmentation. This |
-// requires that Type be a complete type so we can determine the size. See |
-// notes for advanced users below for more explanations. |
-// |
-// Example usage: |
-// static LazyInstance<MyClass>::type my_instance = LAZY_INSTANCE_INITIALIZER; |
-// void SomeMethod() { |
-// my_instance.Get().SomeMethod(); // MyClass::SomeMethod() |
-// |
-// MyClass* ptr = my_instance.Pointer(); |
-// ptr->DoDoDo(); // MyClass::DoDoDo |
-// } |
-// |
-// Additionally you can override the way your instance is constructed by |
-// 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; |
-// |
-// 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 |
-// constructed (using new) by default. This mode is useful if you have to |
-// deal with some code already allocating the instance for you (e.g. |
-// OS::Mutex() which returns a new private OS-dependent subclass of Mutex). |
-// The macro LAZY_DYNAMIC_INSTANCE_INITIALIZER must be used to initialize |
-// dynamic lazy instances. |
- |
-#ifndef V8_LAZY_INSTANCE_H_ |
-#define V8_LAZY_INSTANCE_H_ |
- |
-#include "once.h" |
- |
-namespace v8 { |
-namespace internal { |
- |
-#define LAZY_STATIC_INSTANCE_INITIALIZER { V8_ONCE_INIT, {} } |
-#define LAZY_DYNAMIC_INSTANCE_INITIALIZER { V8_ONCE_INIT, 0 } |
- |
-// Default to static mode. |
-#define LAZY_INSTANCE_INITIALIZER LAZY_STATIC_INSTANCE_INITIALIZER |
- |
- |
-template <typename T> |
-struct LeakyInstanceTrait { |
- static void Destroy(T* /* instance */) {} |
-}; |
- |
- |
-// Traits that define how an instance is allocated and accessed. |
- |
-template <typename T> |
-struct StaticallyAllocatedInstanceTrait { |
- typedef char StorageType[sizeof(T)]; |
- |
- static T* MutableInstance(StorageType* storage) { |
- return reinterpret_cast<T*>(storage); |
- } |
- |
- template <typename ConstructTrait> |
- static void InitStorageUsingTrait(StorageType* storage) { |
- ConstructTrait::Construct(MutableInstance(storage)); |
- } |
-}; |
- |
- |
-template <typename T> |
-struct DynamicallyAllocatedInstanceTrait { |
- typedef T* StorageType; |
- |
- static T* MutableInstance(StorageType* storage) { |
- return *storage; |
- } |
- |
- template <typename CreateTrait> |
- static void InitStorageUsingTrait(StorageType* storage) { |
- *storage = CreateTrait::Create(); |
- } |
-}; |
- |
- |
-template <typename T> |
-struct DefaultConstructTrait { |
- // Constructs the provided object which was already allocated. |
- static void Construct(T* allocated_ptr) { |
- new(allocated_ptr) T(); |
- } |
-}; |
- |
- |
-template <typename T> |
-struct DefaultCreateTrait { |
- static T* Create() { |
- return new T(); |
- } |
-}; |
- |
- |
-// TODO(pliard): Handle instances destruction (using global destructors). |
-template <typename T, typename AllocationTrait, typename CreateTrait, |
- 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_); |
- } |
- |
- 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>, |
- typename DestroyTrait = LeakyInstanceTrait<T> > |
-struct LazyStaticInstance { |
- typedef LazyInstanceImpl<T, StaticallyAllocatedInstanceTrait<T>, CreateTrait, |
- DestroyTrait> type; |
-}; |
- |
- |
-template <typename T, |
- typename CreateTrait = DefaultConstructTrait<T>, |
- typename DestroyTrait = LeakyInstanceTrait<T> > |
-struct LazyInstance { |
- // A LazyInstance is a LazyStaticInstance. |
- typedef typename LazyStaticInstance<T, CreateTrait, DestroyTrait>::type type; |
-}; |
- |
- |
-template <typename T, |
- typename CreateTrait = DefaultConstructTrait<T>, |
- typename DestroyTrait = LeakyInstanceTrait<T> > |
-struct LazyDynamicInstance { |
- typedef LazyInstanceImpl<T, DynamicallyAllocatedInstanceTrait<T>, CreateTrait, |
- DestroyTrait> type; |
-}; |
- |
-} } // namespace v8::internal |
- |
-#endif // V8_LAZY_INSTANCE_H_ |