X-Git-Url: http://plrg.eecs.uci.edu/git/?a=blobdiff_plain;f=test%2Funit%2Fmisc%2Fcxx11_atomic_func.cpp;h=55e61ab62a48788d515ad2ef79d9a57073171a76;hb=1c6e5db1288f85022f3e4529cdc46bddbce02eea;hp=c93e958b4e04ccb35da52a6e2003370a3e64e97f;hpb=a113e0600093eee087415c0e7bf20a02dd6c8d86;p=libcds.git diff --git a/test/unit/misc/cxx11_atomic_func.cpp b/test/unit/misc/cxx11_atomic_func.cpp index c93e958b..55e61ab6 100644 --- a/test/unit/misc/cxx11_atomic_func.cpp +++ b/test/unit/misc/cxx11_atomic_func.cpp @@ -1,7 +1,7 @@ /* This file is a part of libcds - Concurrent Data Structures library - (C) Copyright Maxim Khizhinsky (libcds.dev@gmail.com) 2006-2016 + (C) Copyright Maxim Khizhinsky (libcds.dev@gmail.com) 2006-2017 Source code repo: http://github.com/khizmax/libcds/ Download: http://sourceforge.net/projects/libcds/files/ @@ -37,6 +37,8 @@ #include "cxx11_convert_memory_order.h" +#define EXPECT_ATOMIC_IS_LOCK_FREE( x ) EXPECT_TRUE( atomics::atomic_is_lock_free( &x )); + namespace misc { class cxx11_atomic_func: public ::testing::Test @@ -47,11 +49,11 @@ namespace misc { { atomics::memory_order mo_clear = convert_to_store_order(order); - f.clear( convert_to_store_order(order) ); + f.clear( convert_to_store_order(order)); for ( int i = 0; i < 5; ++i ) { EXPECT_FALSE( atomics::atomic_flag_test_and_set_explicit( &f, order )); - EXPECT_TRUE( atomics::atomic_flag_test_and_set_explicit( &f, order ) ); + EXPECT_TRUE( atomics::atomic_flag_test_and_set_explicit( &f, order )); atomics::atomic_flag_clear_explicit( &f, mo_clear ); atomics::atomic_flag_clear_explicit( &f, mo_clear ); } @@ -64,7 +66,7 @@ namespace misc { for ( int i = 0; i < 5; ++i ) { EXPECT_FALSE( atomics::atomic_flag_test_and_set( &f )); - EXPECT_TRUE( atomics::atomic_flag_test_and_set( &f ) ); + EXPECT_TRUE( atomics::atomic_flag_test_and_set( &f )); atomics::atomic_flag_clear(&f); atomics::atomic_flag_clear(&f); } @@ -81,13 +83,12 @@ namespace misc { { typedef Integral integral_type; - EXPECT_TRUE( atomics::atomic_is_lock_free( &a ) ); + EXPECT_ATOMIC_IS_LOCK_FREE( a ); atomics::atomic_store( &a, (integral_type) 0 ); - EXPECT_EQ( a, integral_type( 0 )); EXPECT_EQ( atomics::atomic_load( &a ), integral_type( 0 )); for ( size_t nByte = 0; nByte < sizeof(Integral); ++nByte ) { - integral_type n = integral_type(42) << (nByte * 8); + integral_type n = static_cast( integral_type(42) << (nByte * 8)); EXPECT_EQ( atomics::atomic_exchange( &a, n ), (integral_type) 0 ); EXPECT_EQ( atomics::atomic_load( &a ), n ); EXPECT_EQ( atomics::atomic_exchange( &a, (integral_type) 0 ), n ); @@ -96,13 +97,13 @@ namespace misc { integral_type prev = atomics::atomic_load( &a ); for ( size_t nByte = 0; nByte < sizeof(Integral); ++nByte ) { - integral_type n = integral_type(42) << (nByte * 8); + integral_type n = static_cast( integral_type(42) << (nByte * 8)); integral_type expected = prev; EXPECT_TRUE( atomics::atomic_compare_exchange_weak( &a, &expected, n)); EXPECT_EQ( expected, prev ); EXPECT_NE( expected, n ); - EXPECT_FALSE( atomics::atomic_compare_exchange_weak( &a, &expected, n) ); + EXPECT_FALSE( atomics::atomic_compare_exchange_weak( &a, &expected, n)); EXPECT_EQ( expected, n ); prev = n; @@ -113,7 +114,7 @@ namespace misc { prev = atomics::atomic_load( &a ); for ( size_t nByte = 0; nByte < sizeof(Integral); ++nByte ) { - integral_type n = integral_type(42) << (nByte * 8); + integral_type n = static_cast( integral_type(42) << (nByte * 8)); integral_type expected = prev; EXPECT_TRUE( atomics::atomic_compare_exchange_strong( &a, &expected, n)); @@ -142,7 +143,7 @@ namespace misc { for ( size_t nByte = 0; nByte < sizeof(integral_type); ++nByte ) { integral_type prev = atomics::atomic_load( &a ); - integral_type n = integral_type(42) << (nByte * 8); + integral_type n = static_cast( integral_type(42) << (nByte * 8)); EXPECT_EQ( atomics::atomic_fetch_add( &a, n ), prev ); } @@ -151,7 +152,7 @@ namespace misc { for ( size_t nByte = sizeof(integral_type); nByte > 0; --nByte ) { integral_type prev = atomics::atomic_load( &a ); - integral_type n = integral_type(42) << ((nByte - 1) * 8); + integral_type n = static_cast( integral_type(42) << ((nByte - 1) * 8)); EXPECT_EQ( atomics::atomic_fetch_sub( &a, n ), prev ); } @@ -161,7 +162,7 @@ namespace misc { for ( size_t nBit = 0; nBit < sizeof(integral_type) * 8; ++nBit ) { integral_type prev = atomics::atomic_load( &a ); - integral_type mask = integral_type(1) << nBit; + integral_type mask = static_cast( integral_type(1) << nBit ); EXPECT_EQ( atomics::atomic_fetch_or( &a, mask ), prev ); prev = atomics::atomic_load( &a ); @@ -186,13 +187,12 @@ namespace misc { const atomics::memory_order oLoad = convert_to_load_order( order ); const atomics::memory_order oStore = convert_to_store_order( order ); - EXPECT_TRUE( atomics::atomic_is_lock_free( &a ) ); + EXPECT_ATOMIC_IS_LOCK_FREE( a ); atomics::atomic_store_explicit( &a, (integral_type) 0, oStore ); - EXPECT_EQ( a, 0 ); EXPECT_EQ( atomics::atomic_load_explicit( &a, oLoad ), (integral_type) 0 ); for ( size_t nByte = 0; nByte < sizeof(Integral); ++nByte ) { - integral_type n = integral_type(42) << (nByte * 8); + integral_type n = static_cast( integral_type(42) << (nByte * 8)); EXPECT_EQ( atomics::atomic_exchange_explicit( &a, n, order ), (integral_type) 0 ); EXPECT_EQ( atomics::atomic_load_explicit( &a, oLoad ), n ); EXPECT_EQ( atomics::atomic_exchange_explicit( &a, (integral_type) 0, order ), n ); @@ -201,7 +201,7 @@ namespace misc { integral_type prev = atomics::atomic_load_explicit( &a, oLoad ); for ( size_t nByte = 0; nByte < sizeof(Integral); ++nByte ) { - integral_type n = integral_type(42) << (nByte * 8); + integral_type n = static_cast( integral_type(42) << (nByte * 8)); integral_type expected = prev; EXPECT_TRUE( atomics::atomic_compare_exchange_weak_explicit( &a, &expected, n, order, atomics::memory_order_relaxed)); @@ -217,7 +217,7 @@ namespace misc { prev = atomics::atomic_load_explicit( &a, oLoad ); for ( size_t nByte = 0; nByte < sizeof(Integral); ++nByte ) { - integral_type n = integral_type(42) << (nByte * 8); + integral_type n = static_cast( integral_type(42) << (nByte * 8)); integral_type expected = prev; EXPECT_TRUE( atomics::atomic_compare_exchange_strong_explicit( &a, &expected, n, order, atomics::memory_order_relaxed)); @@ -248,7 +248,7 @@ namespace misc { for ( size_t nByte = 0; nByte < sizeof(integral_type); ++nByte ) { integral_type prev = atomics::atomic_load_explicit( &a, oLoad ); - integral_type n = integral_type(42) << (nByte * 8); + integral_type n = static_cast( integral_type(42) << (nByte * 8)); EXPECT_EQ( atomics::atomic_fetch_add_explicit( &a, n, order), prev); } @@ -257,7 +257,7 @@ namespace misc { for ( size_t nByte = sizeof(integral_type); nByte > 0; --nByte ) { integral_type prev = atomics::atomic_load_explicit( &a, oLoad ); - integral_type n = integral_type(42) << ((nByte - 1) * 8); + integral_type n = static_cast( integral_type(42) << ((nByte - 1) * 8)); EXPECT_EQ( atomics::atomic_fetch_sub_explicit( &a, n, order ), prev); } @@ -267,7 +267,7 @@ namespace misc { for ( size_t nBit = 0; nBit < sizeof(integral_type) * 8; ++nBit ) { integral_type prev = atomics::atomic_load_explicit( &a, oLoad ) ;; - integral_type mask = integral_type(1) << nBit; + integral_type mask = static_cast( integral_type(1) << nBit ); EXPECT_EQ( atomics::atomic_fetch_or_explicit( &a, mask, order ), prev ); prev = atomics::atomic_load_explicit( &a, oLoad ); @@ -275,7 +275,7 @@ namespace misc { EXPECT_EQ( atomics::atomic_fetch_and_explicit( &a, (integral_type) ~mask, order ), prev ); prev = atomics::atomic_load_explicit( &a, oLoad ); - EXPECT_EQ( ( prev & mask), 0); + EXPECT_EQ( ( prev & mask), integral_type( 0 )); EXPECT_EQ( atomics::atomic_fetch_xor_explicit( &a, mask, order ), prev ); prev = atomics::atomic_load_explicit( &a, oLoad ); @@ -318,7 +318,7 @@ namespace misc { template void do_test_atomic_bool(AtomicBool& a) { - EXPECT_TRUE( atomics::atomic_is_lock_free( &a ) ); + EXPECT_ATOMIC_IS_LOCK_FREE( a ); atomics::atomic_store( &a, false ); EXPECT_FALSE( a ); EXPECT_FALSE( atomics::atomic_load( &a )); @@ -355,7 +355,7 @@ namespace misc { const atomics::memory_order oStore = convert_to_store_order( order ); const atomics::memory_order oExchange = convert_to_exchange_order( order ); - EXPECT_TRUE( atomics::atomic_is_lock_free( &a ) ); + EXPECT_ATOMIC_IS_LOCK_FREE( a ); atomics::atomic_store_explicit( &a, false, oStore ); EXPECT_FALSE( a == false ); EXPECT_FALSE( atomics::atomic_load_explicit( &a, oLoad )); @@ -439,7 +439,7 @@ namespace misc { integral_type arr[8]; const integral_type aSize = sizeof(arr)/sizeof(arr[0]); for ( integral_type i = 0; i < aSize; ++i ) { - arr[size_t(i)] = i + 1; + arr[static_cast(i)] = i + 1; } atomic_pointer a; @@ -535,7 +535,7 @@ namespace misc { char arr[8]; const char aSize = sizeof(arr)/sizeof(arr[0]); for ( char i = 0; i < aSize; ++i ) { - arr[unsigned(i)] = i + 1; + arr[static_cast(i)] = i + 1; } atomic_pointer a; @@ -545,14 +545,14 @@ namespace misc { EXPECT_EQ( *reinterpret_cast(atomics::atomic_load( &a )), 1 ); p = arr; - EXPECT_TRUE( atomics::atomic_compare_exchange_weak( &a, (void **) &p, (void *)(arr + 5) )); + EXPECT_TRUE( atomics::atomic_compare_exchange_weak( &a, (void **) &p, (void *)(arr + 5))); EXPECT_EQ( p, arr + 0 ); - EXPECT_FALSE( atomics::atomic_compare_exchange_weak( &a, (void **) &p, (void *)(arr + 3) )); + EXPECT_FALSE( atomics::atomic_compare_exchange_weak( &a, (void **) &p, (void *)(arr + 3))); EXPECT_EQ( p, arr + 5 ); - EXPECT_TRUE( atomics::atomic_compare_exchange_strong( &a, (void **) &p, (void *)(arr + 3) )); + EXPECT_TRUE( atomics::atomic_compare_exchange_strong( &a, (void **) &p, (void *)(arr + 3))); EXPECT_EQ( p, arr + 5 ); - EXPECT_FALSE( atomics::atomic_compare_exchange_strong( &a, (void **) &p, (void *)(arr + 5) )); + EXPECT_FALSE( atomics::atomic_compare_exchange_strong( &a, (void **) &p, (void *)(arr + 5))); EXPECT_EQ( p, arr + 3 ); EXPECT_EQ( reinterpret_cast( atomics::atomic_exchange( &a, (void *) arr )), arr + 3 ); @@ -706,6 +706,8 @@ namespace misc { test_atomic_integral_volatile(); } +#if !( CDS_COMPILER == CDS_COMPILER_CLANG && CDS_COMPILER_VERSION < 40000 ) + //clang error with atomic fetch_add/fetch_sub TEST_F( cxx11_atomic_func, atomic_pointer_void ) { do_test_atomic_pointer_void(); @@ -714,6 +716,7 @@ namespace misc { { do_test_atomic_pointer_void(); } +#endif TEST_F( cxx11_atomic_func, atomic_pointer_char ) {