C ++ 0x atomare Implementierung in C ++ 98 Frage zu __sync_synchronize ()

Ich habe die folgende atomare Vorlage geschrieben, um die atomaren Operationen nachzuahmen, die im kommenden c ++ 0x-Standard verfügbar sein werden.

Ich bin mir jedoch nicht sicher, ob der __sync_synchronize () -Aufruf, den ich habe, um die Rückgabe des zugrunde liegenden Wertes notwendig ist.

Nach meinem Verständnis ist __sync_synchronize () eine vollständige Speicherbarriere, und ich bin nicht sicher, ob ich einen so kostspieligen Aufruf benötige, wenn ich den Objektwert zurückgebe.

Ich bin mir ziemlich sicher, dass es für die Einstellung des Werts erforderlich sein wird, aber ich könnte dies auch mit der Assembly implementieren.

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

Weiß jemand, ob ich das synchronize () bei der Rückgabe des Objektes definitiv brauche?

M.

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 );
    }

};

Update: Ich möchte sicherstellen, dass die Vorgänge angesichts von Lese- / Schreibänderungen aufgrund von Compileroptimierungen konsistent sind.