K>Я вот это не догнал Выравнивание размера или выравнивание адреса и как оно взаимосвязано?

union sp
{
char spinlock_data[sizeof(spinlock)];
long double align;
} aligned_data;

static InstanceTypeRef  getInstance()
{
    if( NULL == ms_instance )
    {
        static boost::mutex  instanceMutex;
        boost::lock_guard< boost::mutex >  sentinel( instanceMutex );
        if( NULL == ms_instance )
        {
            ms_instance = new InstanceType();
        }
    }
    return  * ms_instance;
}

        template <typename T> class Singletone
        {
            static T * m_instance;
            static SIMPLE_MUTEX m_mutex;
            static void CreateInstance()
            {
                SIMPLE_MUTEX::lockT lock_(m_mutex);
                static T loc_instance;
                m_instance = &loc_instance;
            }
        public:
            static T * Instance()
            {
                if (!m_instance)
                    CreateInstance();
                return m_instance;
            };
        }; // class Singletone<T>
        template <typename T> T * Singletone<T>::m_instance = NULL;
        template <typename T> SIMPLE_MUTEX Singletone<T>::m_mutex;

А>>Если какой то объект будет создан раньше того, как будет вызван этот Instance, и в своем, скажем деструкторе дернет этот Instance, то по идее instanceMutex будет уже не валидным Как можно защитится от этого ?

K>Долго вчитывался, так и не понял, что конкретно имелось ввиду

K>И надо сказать, это кое-где работает

K>Отвечая второму Анониму (предположу, что звать Олегом? ) :

K>Долго вчитывался, так и не понял, что конкретно имелось ввиду

struct mutex
{
  criticalsection_or_some_other * m;
  ~mutex(){ uninit(m); }              // 1.
  mutex(){ init(m); }                 // 2.
   lock(){ lock(m);}                  // 3.
   unlock(){ unlock(m);}              // 4.
};

struct lock
{
  mutex  & m;
  ~lock(){ m.unlock(); }              // 5.
  lock( mutex & m):m(m){ m.lock(); }  // 6.
};

template< typename T >
class singleton
{
  static T  * volatile ms_instance;
  static mutex ms_instanceMutex;

  public:
    T & getInstance()
    {
      if( NULL == ms_instance )
      {
          lock  sentinel( ms_instanceMutex ); // 7.
          if( NULL == ms_instance )
          {
              ms_instance = new T();
          }
      }
      return  * ms_instance;
    }
};

tempate< typename T >
T * volatile  singleton< T >::ms_instance; // 8.
tempate< typename T >
mutex singleton< T >::ms_mutex;            // 9.

// теперь пошел хаос с файлами проекта, и прочим, где то имеем
#include <logsingleton>
struct Test
{
  Test()
  {
    singleton< log >::getInstance().write( "foo" );
  }
};

struct TestEnter
{
  TestEnter()
  {
    Test  t;
  }
};
struct TestExit
{
  ~TestExit()
  {
    Test  t;
  }
};

testExit g_t1;
// проблема 1
// если конструирование этого объекта начнется раньше, чем 9., то в деструкторе будет вызвано 7. а там будет вызвано 6. а там деинициализированое значение барьера

testEnter g_t2; 
// проблема 2
// если конструирование этого объекта начнется раньше, чем 9., то в конструторе будет вызвано 7. а там будет вызвано 6. а там не инициализированое значение барьера, там только память выделеная под него
// проблема 3
// понять когда instance надо удалить

size_t make_index();

// Nifty (Schwarz) counter.
static struct spec_ptr_initializer
{
    // Init here.
    spec_ptr_initializer();

    // Clean-up here.
    ~spec_ptr_initializer();

    static size_t s_nifty_counter;

} spec_ptr_init;                                            // spec_ptr_initializer

namespace {

size_t g_ptr_index;

static char spinlock_data[sizeof(spinlock)];                
spinlock* ptr = reinterpret_cast<spinlock*>(&spinlock_data);// NOTE: if make reinterpret_cast from
spinlock& g_spinlock = static_cast<spinlock&>(*ptr);        // char* to spinlock& then will be warning
                                                            // [dereferencing type-punned pointer will
                                                            // break strict-aliasing rules]

}                                                           // unnamed namespace

size_t make_index()
{
    scoped_lock<spinlock> lock(&g_spinlock);
    return g_ptr_index++;
}

// Nifty counter.
size_t spec_ptr_initializer::s_nifty_counter;

// Nifty counter init.
spec_ptr_initializer::spec_ptr_initializer()
{
    if (0 == s_nifty_counter++)
    {
        new (&spinlock_data) spinlock();
        printf("%s", "Create spinlock\n");
    }
}

// Nifty counter clean-up.
spec_ptr_initializer::~spec_ptr_initializer()
{
    if (0 == --s_nifty_counter)
    {
        (&g_spinlock)->~spinlock();
        printf("%s", "Destroy spinlock\n");
    }
}

// Nifty (Schwarz) counter.
struct spec_ptr_initializer
{
    // Init here.
    spec_ptr_initializer();

    // Clean-up here.
    ~spec_ptr_initializer();

};                                                                              // spec_ptr_initializer

namespace {

spec_ptr_initializer s_spec_ptr_init;                                           // spec_ptr_initializer

}

namespace {

size_t s_nifty_counter;                                                         // Nifty counter.

size_t g_ptr_index;

static char spinlock_data[sizeof(spinlock)];                                    
spinlock* ptr = reinterpret_cast<spinlock*>(&spinlock_data);                    // NOTE: if make reinterpret_cast from
spinlock& g_spinlock = static_cast<spinlock&>(*ptr);                            // char* to spinlock& then will be warning
                                                                                // [dereferencing type-punned pointer will
                                                                                // break strict-aliasing rules]

}

Recommendation: Don't create threads during global object initialization.

Local &GetLocal()
{
  static int              guard; // Will be zeroed at load time
  spin_mutex              smx(&guard); // Spin on "guard"
  lock_scope<spin_mutex>  lock(smx);   // Scope lock of "smx"
  static Local            local;
  return local;
}

K>Спасибо А как это лучше сделать инновационным способом?

static int spinlock_data_int[(sizeof(spinlock) + sizeof(int) - 1) / sizeof(int)];
static char *spinlock_data = reinterpret_cast<char *>(spinlock_data_int);

struct sdata
{
int dummy;
char data[sizeof(spinlock)];
} spinlock_data;

K>ЗЫ. Как там в Индусии?

K>>Спасибо А как это лучше сделать инновационным способом?

AD>static int spinlock_data_int[(sizeof(spinlock) + sizeof(int) - 1) / sizeof(int)];
AD>static char *spinlock_data = reinterpret_cast<char *>(spinlock_data_int);
AD>

AD>struct sdata
AD>{
AD>int dummy;
AD>char data[sizeof(spinlock)];
AD>} spinlock_data;
AD>

AD>Как-то сталкивался с такой проблемой, когда портировал код на более старый армовский компилятор. Там std::wstring вылетал в конструкторе по умолчанию из-за невыровненных данных. Да, там тоже выделяли память статик чаром под единый инстанс пустой строки Задолбался я тогда ковыряться в недрах того STL, продираясь сквозь все эти жутко нечитаемые шаблоны в шаблонах и #ifdef.

  template<std::size_t _Len, std::size_t _Align>
    struct aligned_storage
    { 
      union type
      {
    unsigned char __data[_Len];
    struct __attribute__((__aligned__((_Align)))) { } __align; 
      };
    };

K>>ЗЫ. Как там в Индусии?

AD>Дурдом там Пришел к выводу, что все это нужно только чтобы увидеть красивую картинку перед смертью

        boost::lock_guard< boost::mutex >  sentinel( instanceMutex );
        if( NULL == ms_instance )
        {
            ms_instance = new InstanceType();
        }

push sizeof(InstanceType)
call operator__new           // => malloc
mov  [ms_instance], eax
push eax
call InstanceType::InstanceType // ctor

1. std::string* str = new std::string("abc");
2. str->data();

баг> Вы хотите сказать, что

        boost::lock_guard< boost::mutex >  sentinel( instanceMutex );
баг>        if( NULL == ms_instance )
баг>        {
баг>            ms_instance = new InstanceType();
баг>        }
баг>

баг>

баг>push sizeof(InstanceType)
баг>call operator__new           // => malloc
баг>mov  [ms_instance], eax
баг>push eax
баг>call InstanceType::InstanceType // ctor
баг>

boost::lock_guard< boost::mutex >  sentinel( instanceMutex );