C ++ 0x атомарная реализация в c ++ 98 вопрос о __sync_synchronize ()

Я написал следующий атомарный шаблон с целью имитации атомарных операций, которые будут доступны в будущем стандарте c ++ 0x.

Однако я не уверен, что вызов __sync_synchronize (), который у меня есть для возврата базового значения, необходим.

Насколько я понимаю, __sync_synchronize () является полным барьером памяти, и я не уверен, что мне нужен такой дорогостоящий вызов при возврате значения объекта.

Я почти уверен, что это понадобится для установки значения, но я мог бы также реализовать это с помощью сборки.

__asm__ __volatile__ ( "rep;nop": : :"memory" );

Кто-нибудь знает, мне определенно нужна синхронизация () при возврате объекта.

М.

template < typename T >
struct atomic
{
private:
    volatile T obj;

public:
    atomic( const T & t ) :
        obj( t )
    {
    }

    inline operator T()
    {
        __sync_synchronize();   // Not sure this is overkill
        return obj;
    }

    inline atomic< T > & operator=( T val )
    {
        __sync_synchronize();   // Not sure if this is overkill
        obj = val;
        return *this;
    }

    inline T operator++()
    {
        return __sync_add_and_fetch( &obj, (T)1 );
    }

    inline T operator++( int )
    {
        return __sync_fetch_and_add( &obj, (T)1 );
    }

    inline T operator+=( T val )
    {
        return __sync_add_and_fetch( &obj, val );
    }

    inline T operator--()
    {
        return __sync_sub_and_fetch( &obj, (T)1 );
    }

    inline T operator--( int )
    {
        return __sync_fetch_and_sub( &obj, (T)1 );
    }

    inline T operator-=( T )
    {
        return __sync_sub_and_fetch( &obj, val );
    }

    // Perform an atomic CAS operation
    // returning the value before the operation
    inline T exchange( T oldVal, T newVal )
    {
        return __sync_val_compare_and_swap( &obj, oldval, newval );
    }

};

Обновление: я хочу убедиться, что операции согласованы перед лицом повторного упорядочения чтения / записи из-за оптимизации компилятора.