REPORT("Known issue: %s\n",

__TBB_TEST_SKIP_PIC_MODE? "PIC mode is not supported" : "Compiler builtins for atomic operations aren't available");

return Harness::Skipped;

UseOperators,

UseImplicitAcqRel,

UseExplicitFullyFenced,

UseExplicitAcqRel,

UseExplicitRelaxed,

UseGlobalHelperFullyFenced,

UseGlobalHelperAcqRel,

UseGlobalHelperRelaxed

typedef unsigned char byte_type;

T prefix;

tbb::atomic<T> counter;

T suffix;

TestStruct( T i ) {

ASSERT( sizeof(*this)==3*sizeof(T), NULL );

for (size_t j = 0; j < sizeof(T); ++j) {

reinterpret_cast<byte_type*>(&prefix)[j] = byte_type(0x11*(j+1));

reinterpret_cast<byte_type*>(&suffix)[sizeof(T)-j-1] = byte_type(0x11*(j+1));

}

if ( E == UseOperators )

counter = i;

else if ( E == UseExplicitRelaxed )

counter.template store<tbb::relaxed>(i);

else

tbb::store<tbb::full_fence>( counter, i );

}

~TestStruct() {

// Check for writes outside the counter.

for (size_t j = 0; j < sizeof(T); ++j) {

ASSERT( reinterpret_cast<byte_type*>(&prefix)[j] == byte_type(0x11*(j+1)), NULL );

ASSERT( reinterpret_cast<byte_type*>(&suffix)[sizeof(T)-j-1] == byte_type(0x11*(j+1)), NULL );

}

}

static tbb::atomic<T> gCounter;

ASSERT( i!=k, "values must be distinct" );

// Test compare_and_swap that should fail

TestStruct<T> x(i);

T old = x.counter.template compare_and_swap<M>( j, k );

ASSERT( old==i, NULL );

ASSERT( x.counter==i, "old value not retained" );

// Test compare and swap that should succeed

old = x.counter.template compare_and_swap<M>( j, i );

ASSERT( old==i, NULL );

ASSERT( x.counter==j, "value not updated?" );

ASSERT( i!=k, "values must be distinct" );

// Test compare_and_swap that should fail

TestStruct<T> x(i);

T old = x.counter.compare_and_swap( j, k );

ASSERT( old==i, NULL );

ASSERT( x.counter==i, "old value not retained" );

// Test compare and swap that should succeed

old = x.counter.compare_and_swap( j, i );

ASSERT( old==i, NULL );

if( x.counter==i ) {

ASSERT( x.counter==j, "value not updated?" );

} else {

ASSERT( x.counter==j, "value trashed" );

}

// Check that atomic global variables work

TestStruct<T>::gCounter = i;

old = TestStruct<T>::gCounter.compare_and_swap( j, i );

ASSERT( old==i, NULL );

ASSERT( TestStruct<T>::gCounter==j, "value not updated?" );

TestCompareAndSwapWithExplicitOrdering<T,tbb::full_fence>(i,j,k);

TestCompareAndSwapWithExplicitOrdering<T,tbb::acquire>(i,j,k);

TestCompareAndSwapWithExplicitOrdering<T,tbb::release>(i,j,k);

TestCompareAndSwapWithExplicitOrdering<T,tbb::relaxed>(i,j,k);

ASSERT( i!=j, "values must be distinct" );

TestStruct<T> x(i);

T old = x.counter.template fetch_and_store<M>( j );

ASSERT( old==i, NULL );

ASSERT( x.counter==j, NULL );

ASSERT( i!=j, "values must be distinct" );

TestStruct<T> x(i);

T old = x.counter.fetch_and_store( j );

ASSERT( old==i, NULL );

ASSERT( x.counter==j, NULL );

// Check that atomic global variables work

TestStruct<T>::gCounter = i;

old = TestStruct<T>::gCounter.fetch_and_store( j );

ASSERT( old==i, NULL );

ASSERT( TestStruct<T>::gCounter==j, "value not updated?" );

TestFetchAndStoreWithExplicitOrdering<T,tbb::full_fence>(i,j);

TestFetchAndStoreWithExplicitOrdering<T,tbb::acquire>(i,j);

TestFetchAndStoreWithExplicitOrdering<T,tbb::release>(i,j);

TestFetchAndStoreWithExplicitOrdering<T,tbb::relaxed>(i,j);

TestStruct<T> x(i);

T actual;

T expected = i;

// Test fetch_and_add member template

for( int j=0; j<10; ++j ) {

actual = x.counter.fetch_and_add(j);

ASSERT( actual==expected, NULL );

expected += j;

}

for( int j=0; j<10; ++j ) {

actual = x.counter.fetch_and_add(-j);

ASSERT( actual==expected, NULL );

expected -= j;

}

// Test fetch_and_increment member template

ASSERT( x.counter==i, NULL );

actual = x.counter.template fetch_and_increment<M>();

ASSERT( actual==i, NULL );

ASSERT( x.counter==T(i+1), NULL );

// Test fetch_and_decrement member template

actual = x.counter.template fetch_and_decrement<M>();

ASSERT( actual==T(i+1), NULL );

ASSERT( x.counter==i, NULL );

TestStruct<T> x(i);

T value;

value = ++x.counter;

ASSERT( value==T(i+1), NULL );

value = x.counter++;

ASSERT( value==T(i+1), NULL );

value = x.counter--;

ASSERT( value==T(i+2), NULL );

value = --x.counter;

ASSERT( value==i, NULL );

T actual;

T expected = i;

for( int j=-100; j<=100; ++j ) {

expected += j;

actual = x.counter += j;

ASSERT( actual==expected, NULL );

}

for( int j=-100; j<=100; ++j ) {

expected -= j;

actual = x.counter -= j;

ASSERT( actual==expected, NULL );

}

// Test fetch_and_increment

ASSERT( x.counter==i, NULL );

actual = x.counter.fetch_and_increment();

ASSERT( actual==i, NULL );

ASSERT( x.counter==T(i+1), NULL );

// Test fetch_and_decrement

actual = x.counter.fetch_and_decrement();

ASSERT( actual==T(i+1), NULL );

ASSERT( x.counter==i, NULL );

x.counter = i;

ASSERT( x.counter==i, NULL );

// Check that atomic global variables work

TestStruct<T>::gCounter = i;

value = TestStruct<T>::gCounter.fetch_and_add( 42 );

expected = i+42;

ASSERT( value==i, NULL );

ASSERT( TestStruct<T>::gCounter==expected, "value not updated?" );

TestFetchAndAddWithExplicitOrdering<T,tbb::full_fence>(i);

TestFetchAndAddWithExplicitOrdering<T,tbb::acquire>(i);

TestFetchAndAddWithExplicitOrdering<T,tbb::release>(i);

TestFetchAndAddWithExplicitOrdering<T,tbb::relaxed>(i);

// Try const

const TestStruct<T> x(i);

ASSERT( memcmp( &i, &x.counter, sizeof(T) )==0, "write to atomic<T> broken?" );

ASSERT( x.counter==i, "read of atomic<T> broken?" );

const TestStruct<T, UseExplicitRelaxed> y(i);

ASSERT( memcmp( &i, &y.counter, sizeof(T) )==0, "relaxed write to atomic<T> broken?" );

ASSERT( tbb::load<tbb::relaxed>(y.counter) == i, "relaxed read of atomic<T> broken?" );

const TestStruct<T, UseGlobalHelperFullyFenced> z(i);

ASSERT( memcmp( &i, &z.counter, sizeof(T) )==0, "sequentially consistent write to atomic<T> broken?" );

ASSERT( z.counter.template load<tbb::full_fence>() == i, "sequentially consistent read of atomic<T> broken?" );

typedef tbb::atomic<T> atomic_t;

tbb::aligned_space<atomic_t> non_zeroed_storage;

enum {fill_value = 0xFF };

test_initialization_fixture(){

memset(non_zeroed_storage.begin(),fill_value,sizeof(non_zeroed_storage));

ASSERT( char(fill_value)==*(reinterpret_cast<char*>(non_zeroed_storage.begin()))

,"failed to fill the storage; memset error?");

}

//TODO: consider move it to destructor, even in a price of UB

void tear_down(){

non_zeroed_storage.begin()->~atomic_t();

}

void operator()(){

typedef typename test_initialization_fixture<T>::atomic_t atomic_type;

//please note that explicit braces below are needed to get zero initialization.

//in C++11, 8.5 Initializers [dcl.init], see paragraphs 10,7,5

new (this->non_zeroed_storage.begin()) atomic_type();

//TODO: add use of KNOWN_ISSUE macro on SunCC 5.11

#if !__SUNPRO_CC || __SUNPRO_CC > 0x5110

//TODO: add printing of typename to the assertion

ASSERT(char(0)==*(reinterpret_cast<char*>(this->non_zeroed_storage.begin()))

,("value initialization for tbb::atomic should do zero initialization; "

"actual value:"+to_string(this->non_zeroed_storage.begin()->load())).c_str());

#endif

this->tear_down();

};

void operator ()(){

typedef typename test_initialization_fixture<T>::atomic_t atomic_type;

new (this->non_zeroed_storage.begin()) atomic_type;

ASSERT( char(this->fill_value)==*(reinterpret_cast<char*>(this->non_zeroed_storage.begin()))

,"default initialization for atomic should do no initialization");

this->tear_down();

}

void operator()(T i){

typedef typename test_initialization_fixture<T>::atomic_t atomic_type;

new (this->non_zeroed_storage.begin()) atomic_type(i);

ASSERT(i == this->non_zeroed_storage.begin()->load()

,("tbb::atomic initialization failed; "

"value:"+to_string(this->non_zeroed_storage.begin()->load())+

"; expected:"+to_string(i)).c_str());

this->tear_down();

}

int _int;

constexpr white_box_ad_hoc_type(int a =0) : _int(a) {};

constexpr operator int() const { return _int;}

const char* ct_init_failed_msg = "translation time init failed?";

typedef tbb::atomic<int> atomic_t;

constexpr atomic_t a(8);

ASSERT(a == 8,ct_init_failed_msg);

constexpr tbb::atomic<test_constexpr_initialization_helper::white_box_ad_hoc_type> ct_atomic(10);

//for some unknown reason clang does not managed to enum syntax

#if __clang__

constexpr int ct_atomic_value_ten = (int)ct_atomic;

#else

enum {ct_atomic_value_ten = (int)ct_atomic};

#endif

__TBB_STATIC_ASSERT(ct_atomic_value_ten == 10, "translation time init failed?");

ASSERT(ct_atomic_value_ten == 10,ct_init_failed_msg);

int array[ct_atomic_value_ten];

ASSERT(Harness::array_length(array) == 10,ct_init_failed_msg);

static int order_hash;

template<int N> struct nth {

nth(){ order_hash = (order_hash<<4)+N; }

};

static nth<2> second;

static nth<3> third;

//TODO: add printing of values to the assertion

std::string type_name = auto_registered_tests_helper::type_name<T>::name;

ASSERT(tester<T>::result,("Static initialization failed for atomic " + type_name).c_str());

using namespace auto_registered_tests_helper;

for (size_t i =0; i<const_expr_tests.size(); ++i){

(*const_expr_tests[i])();

}

REMARK("ran %d consrexpr static init test \n",const_expr_tests.size());

using test_indirection_helpers::Foo;

Foo<T> item;

tbb::atomic<Foo<T>*> pointer;

pointer = &item;

for( int k=-10; k<=10; ++k ) {

// Test various syntaxes for indirection to fields with non-zero offset.

T value1=T(), value2=T();

for( size_t j=0; j<sizeof(T); ++j ) {

((char*)&value1)[j] = char(k^j);

((char*)&value2)[j] = char(k^j*j);

}

pointer->y = value1;

(*pointer).z = value2;

T result1 = (*pointer).y;

T result2 = pointer->z;

ASSERT( memcmp(&value1,&result1,sizeof(T))==0, NULL );

ASSERT( memcmp(&value2,&result2,sizeof(T))==0, NULL );

}

#if __TBB_ICC_BUILTIN_ATOMICS_POINTER_ALIASING_BROKEN

//prevent ICC compiler from assuming 'item' is unused and reusing it's storage

item.x = item.y=item.z;

#endif

REMARK("testing atomic pointer (%d)\n",int(sizeof(T)));

T array[1000];

TestOperations<T*>(&array[500],&array[250],&array[750]);

TestFetchAndAdd<T*>(&array[500]);

TestIndirection<T>();

TestParallel<T*>( "pointer" );

REMARK("testing atomic<%s>\n",name);

char array[1000];

TestOperations<Ptr>((Ptr)(void*)&array[500],(Ptr)(void*)&array[250],(Ptr)(void*)&array[750]);

TestParallel<Ptr>( name );

REMARK("testing atomic<bool>\n");

TestOperations<bool>(true,true,false);

TestOperations<bool>(false,false,true);

TestParallel<bool>( "bool" );

REMARK("testing atomic<Color>\n");

TestOperations<Color>(Red,Green,Blue);

TestParallel<Color>( "Color" );

__TBB_STATIC_ASSERT( HasImplicitConversionToInt< tbb::atomic<Color> >::value, "The implicit conversion is expected." );

REMARK("testing atomic<ScopedColor>\n");

TestOperations<ScopedColor1>(ScopedColor1::ScopedRed,ScopedColor1::ScopedGreen,ScopedColor1::ScopedBlue);

TestParallel<ScopedColor1>( "ScopedColor1" );

#if __TBB_ICC_SCOPED_ENUM_WITH_UNDERLYING_TYPE_ATOMIC_LOAD_BROKEN

REPORT("Known issue: the operation tests for a scoped enum with a specified underlying type are skipped.\n");

#else

TestOperations<ScopedColor2>(ScopedColor2::ScopedRed,ScopedColor2::ScopedGreen,ScopedColor2::ScopedBlue);

TestParallel<ScopedColor2>( "ScopedColor2" );

#endif

__TBB_STATIC_ASSERT( !HasImplicitConversionToInt< tbb::atomic<ScopedColor1> >::value, "The implicit conversion is not expected." );

__TBB_STATIC_ASSERT( !HasImplicitConversionToInt< tbb::atomic<ScopedColor1> >::value, "The implicit conversion is not expected." );

__TBB_STATIC_ASSERT( sizeof(tbb::atomic<ScopedColor1>) == sizeof(ScopedColor1), "tbb::atomic instantiated with scoped enum should have the same size as scoped enum." );

__TBB_STATIC_ASSERT( sizeof(tbb::atomic<ScopedColor2>) == sizeof(ScopedColor2), "tbb::atomic instantiated with scoped enum should have the same size as scoped enum." );

REMARK("testing atomic<%s>\n", name );

TestAlignment<T>(name);

TestOperations<T>(0.5,3.25,10.75);

TestParallel<T>( name );

// Test for pure endianness (assumed by simpler probe in __TBB_MaskedCompareAndSwap()).

bool is_big_endian = true, is_little_endian = true;

const tbb::internal::uint32_t probe = 0x03020100;

ASSERT (tbb::internal::is_aligned(&probe,4), NULL);

for( const char *pc_begin = reinterpret_cast<const char*>(&probe)

, *pc = pc_begin, *pc_end = pc_begin + sizeof(probe)

; pc != pc_end; ++pc) {

if (*pc != pc_end-1-pc) is_big_endian = false;

if (*pc != pc-pc_begin) is_little_endian = false;

}

ASSERT (!is_big_endian || !is_little_endian, NULL);

#if __TBB_ENDIANNESS==__TBB_ENDIAN_DETECT

ASSERT (is_big_endian || is_little_endian, "__TBB_ENDIANNESS should be set to __TBB_ENDIAN_UNSUPPORTED");

#elif __TBB_ENDIANNESS==__TBB_ENDIAN_BIG

ASSERT (is_big_endian, "__TBB_ENDIANNESS should NOT be set to __TBB_ENDIAN_BIG");

#elif __TBB_ENDIANNESS==__TBB_ENDIAN_LITTLE

ASSERT (is_little_endian, "__TBB_ENDIANNESS should NOT be set to __TBB_ENDIAN_LITTLE");

#elif __TBB_ENDIANNESS==__TBB_ENDIAN_UNSUPPORTED

#error Generic implementation of part-word CAS may not be used: unsupported endianness

#else

#error Unexpected value of __TBB_ENDIANNESS

#endif

T* test_space_uncontended;

T* test_space_contended;

public:

TestMaskedCAS_Body( T* _space1, T* _space2 ) : test_space_uncontended(_space1), test_space_contended(_space2) {}

void operator()( int my_idx ) const {

using tbb::internal::__TBB_MaskedCompareAndSwap;

const volatile T my_prime = T(prime[my_idx]); // 'volatile' prevents erroneous optimizations by SunCC

T* const my_ptr = test_space_uncontended+my_idx;

T old_value=0;

for( int i=0; i<numMaskedOperations; ++i, old_value+=my_prime ){

T result;

// Test uncontended case

T new_value = old_value + my_prime;

// The following CAS should always fail

result = __TBB_MaskedCompareAndSwap<T>(my_ptr,new_value,old_value-1);

ASSERT(result!=old_value-1, "masked CAS succeeded while it should fail");

ASSERT(result==*my_ptr, "masked CAS result mismatch with real value");

// The following one should succeed

result = __TBB_MaskedCompareAndSwap<T>(my_ptr,new_value,old_value);

ASSERT(result==old_value && *my_ptr==new_value, "masked CAS failed while it should succeed");

// The following one should fail again

result = __TBB_MaskedCompareAndSwap<T>(my_ptr,new_value,old_value);

ASSERT(result!=old_value, "masked CAS succeeded while it should fail");

ASSERT(result==*my_ptr, "masked CAS result mismatch with real value");

// Test contended case

for( int j=0; j<testSpaceSize; ++j ){

// try adding my_prime until success

T value;

do {

value = test_space_contended[j];

result = __TBB_MaskedCompareAndSwap<T>(test_space_contended+j,value+my_prime,value);

} while( result!=value );

}

}

}

{

static const int how_many_Ts = sizeof(intptr_t)/sizeof(T);

union {

intptr_t result;

T space[ how_many_Ts ];

};

intptr_as_array_of<T> slot;

slot.result = 0;

for( int i=0; i<slot.how_many_Ts; ++i ) {

const T my_prime = T(prime[slot_idx*slot.how_many_Ts + i]);

for( int j=0; j<numMaskedOperations; ++j )

slot.space[i] += my_prime;

}

return slot.result;

intptr_as_array_of<T> slot;

slot.result = 0;

for( int i=0; i<slot.how_many_Ts; ++i )

for( int primes=0; primes<testSpaceSize; ++primes )

for( int j=0; j<numMaskedOperations; ++j )

slot.space[i] += prime[primes];

return slot.result;

using namespace masked_cas_helpers;

REMARK("testing masked CAS<%d>\n",int(sizeof(T)));

const int num_slots = sizeof(T)*testSpaceSize/sizeof(intptr_t);

intptr_t arr1[num_slots+2]; // two more "canary" slots at boundaries

intptr_t arr2[num_slots+2];

for(int i=0; i<num_slots+2; ++i)

arr2[i] = arr1[i] = 0;

T* test_space_uncontended = (T*)(arr1+1);

T* test_space_contended = (T*)(arr2+1);

NativeParallelFor( testSpaceSize, TestMaskedCAS_Body<T>(test_space_uncontended, test_space_contended) );

ASSERT( arr1[0]==0 && arr1[num_slots+1]==0 && arr2[0]==0 && arr2[num_slots+1]==0 , "adjacent memory was overwritten" );

const intptr_t correctContendedValue = getCorrectContendedValue<T>();

for(int i=0; i<num_slots; ++i) {

ASSERT( arr1[i+1]==getCorrectUncontendedValue<T>(i), "unexpected value in an uncontended slot" );

ASSERT( arr2[i+1]==correctContendedValue, "unexpected value in a contended slot" );

}

static T s_turn,

s_ready;

static unsigned s_count1,

s_count2;

void operator() ( int id ) const {

using tbb::internal::__TBB_load_relaxed;

using tbb::internal::__TBB_store_relaxed;

if ( id == 0 ) {

while ( !__TBB_load_relaxed(s_turn) ) {

++s_count1;

__TBB_store_relaxed(s_ready, 1);

}

}

else {

while ( !__TBB_load_relaxed(s_ready) ) {

++s_count2;

continue;

}

__TBB_store_relaxed(s_turn, 1);

}

}

static tbb::atomic<T> s_turn,

s_ready;

static unsigned s_count1,

s_count2;

void operator() ( int id ) const {

if ( id == 0 ) {

while ( s_turn.template load<tbb::relaxed>() == 0 ) {

++s_count1;

s_ready.template store<tbb::relaxed>(1);

}

}

else {

while ( s_ready.template load<tbb::relaxed>() == 0 ) {

++s_count2;

continue;

}

s_turn.template store<tbb::relaxed>(1);

}

}

REMARK("testing register promotion suppression (size=%d)\n", (int)sizeof(T));

NativeParallelFor( 2, TestRelaxedLoadStorePlainBody<T>() );

NativeParallelFor( 2, TestRelaxedLoadStoreAtomicBody<T>() );

static const uintptr_t zero = 0;

const uintptr_t random_value ;

const uintptr_t inverted_random_value ;

fixture():

random_value (tbb::internal::select_size_t_constant<0x9E3779B9,0x9E3779B97F4A7C15ULL>::value),

inverted_random_value ( ~random_value)

{}

void operator()(){

//these additional variable are needed to get more meaningful expression in the assert

uintptr_t initial_value = zero;

uintptr_t atomic_or_result = initial_value;

uintptr_t atomic_or_operand = random_value;

__TBB_AtomicOR(&atomic_or_result,atomic_or_operand);

ASSERT(atomic_or_result == (initial_value | atomic_or_operand),"AtomicOR should do the OR operation");

}

void operator()(){

//these additional variable are needed to get more meaningful expression in the assert

uintptr_t initial_value = inverted_random_value;

uintptr_t atomic_and_result = initial_value;

uintptr_t atomic_and_operand = random_value;

__TBB_AtomicAND(&atomic_and_result,atomic_and_operand);

ASSERT(atomic_and_result == (initial_value & atomic_and_operand),"AtomicAND should do the AND operation");