Add ALIGNAS and ALIGNOF macros to ensure proper alignment of StaticMemorySingletonTraits

base/memory/singleton.h

 // Copyright (c) 2011 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 // PLEASE READ: Do you really need a singleton?
 //
 // Singletons make it hard to determine the lifetime of an object, which can
 // lead to buggy code and spurious crashes.
 //
 // Instead of adding another singleton into the mix, try to identify either:
 //   a) An existing singleton that can manage your object's lifetime
 //   b) Locations where you can deterministically create the object and pass
 //      into other objects
 //
 // If you absolutely need a singleton, please keep them as trivial as possible
 // and ideally a leaf dependency. Singletons get problematic when they attempt
 // to do too much in their destructor or have circular dependencies.
 
 #ifndef BASE_MEMORY_SINGLETON_H_
 #define BASE_MEMORY_SINGLETON_H_
 #pragma once
 
 #include "base/at_exit.h"
 #include "base/atomicops.h"
 #include "base/base_export.h"
+#include "base/memory/aligned_memory.h"
 #include "base/third_party/dynamic_annotations/dynamic_annotations.h"
 #include "base/threading/thread_restrictions.h"
 
 namespace base {
 namespace internal {
 
 // Our AtomicWord doubles as a spinlock, where a value of
 // kBeingCreatedMarker means the spinlock is being held for creation.
 static const subtle::AtomicWord kBeingCreatedMarker = 1;
 
@@ skipping 63 matching lines @@
 // a callback the system will invoke when logging levels change. Note that
 // this is also used in e.g. Chrome Frame, where you have to allow for the
 // possibility of loading briefly into someone else's process space, and
 // so leaking is not an option, as that would sabotage the state of your host
 // process once you've unloaded.
 template <typename Type>
 struct StaticMemorySingletonTraits {
   // WARNING: User has to deal with get() in the singleton class
   // this is traits for returning NULL.
   static Type* New() {
+    // Only constructs once and returns pointer; otherwise returns NULL.
     if (base::subtle::NoBarrier_AtomicExchange(&dead_, 1))

[Sigurður Ásgeirsson, 2012/02/22 15:31:32]

I couldn't find a discussion of this anywhere in our headers, but I assume that
NoBarrier means that writes on this core prior to the atomic op are allowed to
be reordered past here?
In any case the implementation looks correct to me, the acquire/release dance in
the singleton proper should be sufficient for static buffers.

[Jeffrey Yasskin (google), 2012/02/22 18:38:42]

Both writes and reads can be reordered in either direction. On x86, only the
compiler will actually do such reordering, but on ARM and PPC (dunno about MIPS)
the processor will do it too.
I think this AtomicExchange is enough for the guarantee
StaticMemorySingletonTraits wants to provide, and that the ordering in Singleton
is enough for its guarantees.

       return NULL;
-    Type* ptr = reinterpret_cast<Type*>(buffer_);
 
-    // We are protected by a memory barrier.
-    new(ptr) Type();
-    return ptr;
+    return new(buffer_.data()) Type;

[Jeffrey Yasskin (google), 2012/02/22 18:38:42]

Since you removed the ()s after "Type", this won't zero-initialize types if they
don't have constructors. You may not actually have any singleton
constructor-less types, but I'd leave the ()s in for safety.

[jbates, 2012/02/22 19:37:15]

Done.

   }
 
   static void Delete(Type* p) {
-    base::subtle::NoBarrier_Store(&dead_, 1);

[jbates, 2012/02/21 23:39:04]

dead_ is already set to 1 at the beginning of New().

-    base::subtle::MemoryBarrier();
     if (p != NULL)
       p->Type::~Type();
   }
 
   static const bool kRegisterAtExit = true;
   static const bool kAllowedToAccessOnNonjoinableThread = true;
 
   // Exposed for unittesting.
   static void Resurrect() {
     base::subtle::NoBarrier_Store(&dead_, 0);
   }
 
  private:
-  static const size_t kBufferSize = (sizeof(Type) +
-                                     sizeof(intptr_t) - 1) / sizeof(intptr_t);
-  static intptr_t buffer_[kBufferSize];
-
+  static base::AlignedMemory<Type> buffer_;
   // Signal the object was already deleted, so it is not revived.
   static base::subtle::Atomic32 dead_;
 };
 
-template <typename Type> intptr_t
-    StaticMemorySingletonTraits<Type>::buffer_[kBufferSize];
+template <typename Type> base::AlignedMemory<Type>
+    StaticMemorySingletonTraits<Type>::buffer_;
 template <typename Type> base::subtle::Atomic32
     StaticMemorySingletonTraits<Type>::dead_ = 0;
 
 // The Singleton<Type, Traits, DifferentiatingType> class manages a single
 // instance of Type which will be created on first use and will be destroyed at
 // normal process exit). The Trait::Delete function will not be called on
 // abnormal process exit.
 //
 // DifferentiatingType is used as a key to differentiate two different
 // singletons having the same memory allocation functions but serving a
@@ skipping 128 matching lines @@
     instance_ = 0;
   }
   static base::subtle::AtomicWord instance_;
 };
 
 template <typename Type, typename Traits, typename DifferentiatingType>
 base::subtle::AtomicWord Singleton<Type, Traits, DifferentiatingType>::
     instance_ = 0;
 
 #endif  // BASE_MEMORY_SINGLETON_H_