X-Git-Url: http://plrg.eecs.uci.edu/git/?a=blobdiff_plain;f=src%2Fhp.cpp;h=44ec31b3e140a66daa67f5e15c3020aa8878f157;hb=425ac2caed841d88f086813b63f7bf89a0faca68;hp=99a3d1659fc2298574c891d182832519d44f5dcb;hpb=f1d0c326db54712bf9d1e4cf73e53b61afbaa8af;p=libcds.git diff --git a/src/hp.cpp b/src/hp.cpp index 99a3d165..44ec31b3 100644 --- a/src/hp.cpp +++ b/src/hp.cpp @@ -63,12 +63,12 @@ namespace cds { namespace gc { namespace hp { static T* allocate( size_t nCount ) { - return reinterpret_cast( s_alloc_memory( sizeof( value_type ) * nCount ) ); + return reinterpret_cast( s_alloc_memory( sizeof( value_type ) * nCount )); } static void deallocate( T* p, size_t /*nCount*/ ) { - s_free_memory( reinterpret_cast( p ) ); + s_free_memory( reinterpret_cast( p )); } }; @@ -103,6 +103,8 @@ namespace cds { namespace gc { namespace hp { thread_record( guard* guards, size_t guard_count, retired_ptr* retired_arr, size_t retired_capacity ) : thread_data( guards, guard_count, retired_arr, retired_capacity ) + , m_pNextNode( nullptr ) + , m_idOwner( cds::OS::c_NullThreadId ) , m_bFree( false ) {} }; @@ -140,13 +142,14 @@ namespace cds { namespace gc { namespace hp { } CDS_EXPORT_API smr::smr( size_t nHazardPtrCount, size_t nMaxThreadCount, size_t nMaxRetiredPtrCount, scan_type nScanType ) - : thread_list_( nullptr ) - , hazard_ptr_count_( nHazardPtrCount == 0 ? defaults::c_nHazardPointerPerThread : nHazardPtrCount ) + : hazard_ptr_count_( nHazardPtrCount == 0 ? defaults::c_nHazardPointerPerThread : nHazardPtrCount ) , max_thread_count_( nMaxThreadCount == 0 ? defaults::c_nMaxThreadCount : nMaxThreadCount ) , max_retired_ptr_count_( calc_retired_size( nMaxRetiredPtrCount, hazard_ptr_count_, max_thread_count_ )) , scan_type_( nScanType ) , scan_func_( nScanType == classic ? &smr::classic_scan : &smr::inplace_scan ) - {} + { + thread_list_.store( nullptr, atomics::memory_order_release ); + } CDS_EXPORT_API smr::~smr() { @@ -156,14 +159,13 @@ namespace cds { namespace gc { namespace hp { CDS_HPSTAT( statistics( s_postmortem_stat )); thread_record* pHead = thread_list_.load( atomics::memory_order_relaxed ); - thread_list_.store( nullptr, atomics::memory_order_relaxed ); + thread_list_.store( nullptr, atomics::memory_order_release ); thread_record* pNext = nullptr; for ( thread_record* hprec = pHead; hprec; hprec = pNext ) { assert( hprec->m_idOwner.load( atomics::memory_order_relaxed ) == nullThreadId - || hprec->m_idOwner.load( atomics::memory_order_relaxed ) == mainThreadId ) - ); + || hprec->m_idOwner.load( atomics::memory_order_relaxed ) == mainThreadId ); retired_array& arr = hprec->retired_; for ( retired_ptr* cur{ arr.first() }, *last{ arr.last() }; cur != last; ++cur ) { @@ -205,10 +207,13 @@ namespace cds { namespace gc { namespace hp { +--------------------------+ */ - char* mem = reinterpret_cast( s_alloc_memory( nSize )); - return new( mem ) thread_record( - reinterpret_cast( mem + sizeof( thread_record )), get_hazard_ptr_count(), - reinterpret_cast( mem + sizeof( thread_record ) + guard_array_size ), get_max_retired_ptr_count() + uint8_t* mem = reinterpret_cast( s_alloc_memory( nSize )); + + return new( mem ) thread_record( + reinterpret_cast( mem + sizeof( thread_record )), + get_hazard_ptr_count(), + reinterpret_cast( mem + sizeof( thread_record ) + guard_array_size ), + get_max_retired_ptr_count() ); } @@ -224,16 +229,14 @@ namespace cds { namespace gc { namespace hp { CDS_EXPORT_API smr::thread_record* smr::alloc_thread_data() { - //CDS_HAZARDPTR_STATISTIC( ++m_Stat.m_AllocHPRec ) - thread_record * hprec; const cds::OS::ThreadId nullThreadId = cds::OS::c_NullThreadId; const cds::OS::ThreadId curThreadId = cds::OS::get_current_thread_id(); // First try to reuse a free (non-active) HP record - for ( hprec = thread_list_.load( atomics::memory_order_acquire ); hprec; hprec = hprec->m_pNextNode.load( atomics::memory_order_relaxed ) ) { + for ( hprec = thread_list_.load( atomics::memory_order_acquire ); hprec; hprec = hprec->m_pNextNode.load( atomics::memory_order_acquire )) { cds::OS::ThreadId thId = nullThreadId; - if ( !hprec->m_idOwner.compare_exchange_strong( thId, curThreadId, atomics::memory_order_relaxed, atomics::memory_order_relaxed ) ) + if ( !hprec->m_idOwner.compare_exchange_strong( thId, curThreadId, atomics::memory_order_relaxed, atomics::memory_order_relaxed )) continue; hprec->m_bFree.store( false, atomics::memory_order_release ); return hprec; @@ -246,8 +249,8 @@ namespace cds { namespace gc { namespace hp { thread_record* pOldHead = thread_list_.load( atomics::memory_order_relaxed ); do { - hprec->m_pNextNode.store( pOldHead, atomics::memory_order_relaxed ); - } while ( !thread_list_.compare_exchange_weak( pOldHead, hprec, atomics::memory_order_release, atomics::memory_order_acquire ) ); + hprec->m_pNextNode.store( pOldHead, atomics::memory_order_release ); + } while ( !thread_list_.compare_exchange_weak( pOldHead, hprec, atomics::memory_order_release, atomics::memory_order_acquire )); return hprec; } @@ -316,7 +319,7 @@ namespace cds { namespace gc { namespace hp { } } - CDS_HPSTAT( ++pRec->scan_count_ ); + CDS_HPSTAT( ++pThreadRec->scan_count_ ); // Sort retired pointer array std::sort( first_retired, last_retired, retired_ptr::less ); @@ -384,7 +387,7 @@ namespace cds { namespace gc { namespace hp { { thread_record* pRec = static_cast( pThreadRec ); - CDS_HPSTAT( ++pRec->scan_count_ ); + CDS_HPSTAT( ++pThreadRec->scan_count_ ); std::vector< void*, allocator> plist; plist.reserve( get_max_thread_count() * get_hazard_ptr_count()); @@ -407,7 +410,7 @@ namespace cds { namespace gc { namespace hp { } // Sort plist to simplify search in - std::sort( plist.begin(), plist.end() ); + std::sort( plist.begin(), plist.end()); // Stage 2: Search plist retired_array& retired = pRec->retired_; @@ -420,7 +423,7 @@ namespace cds { namespace gc { namespace hp { auto itEnd = plist.end(); retired_ptr* insert_pos = first_retired; for ( retired_ptr* it = first_retired; it != last_retired; ++it ) { - if ( std::binary_search( itBegin, itEnd, first_retired->m_p ) ) { + if ( std::binary_search( itBegin, itEnd, first_retired->m_p )) { if ( insert_pos != it ) *insert_pos = *it; ++insert_pos; @@ -437,7 +440,7 @@ namespace cds { namespace gc { namespace hp { CDS_EXPORT_API void smr::help_scan( thread_data* pThis ) { - assert( static_cast( pThis )->m_idOwner.load( atomics::memory_order_relaxed ) == cds::OS::get_current_thread_id() ); + assert( static_cast( pThis )->m_idOwner.load( atomics::memory_order_relaxed ) == cds::OS::get_current_thread_id()); CDS_HPSTAT( ++pThis->help_scan_count_ ); @@ -457,7 +460,7 @@ namespace cds { namespace gc { namespace hp { { cds::OS::ThreadId curOwner = hprec->m_idOwner.load( atomics::memory_order_relaxed ); if ( curOwner == nullThreadId ) { - if ( !hprec->m_idOwner.compare_exchange_strong( curOwner, curThreadId, atomics::memory_order_acquire, atomics::memory_order_relaxed ) ) + if ( !hprec->m_idOwner.compare_exchange_strong( curOwner, curThreadId, atomics::memory_order_acquire, atomics::memory_order_relaxed )) continue; } else @@ -468,7 +471,7 @@ namespace cds { namespace gc { namespace hp { // If it has ones then we move them to pThis that is private for current thread. retired_array& src = hprec->retired_; retired_array& dest = pThis->retired_; - assert( !dest.full() ); + assert( !dest.full()); retired_ptr* src_first = src.first(); retired_ptr* src_last = src.last(); @@ -478,9 +481,8 @@ namespace cds { namespace gc { namespace hp { scan( pThis ); } - src.reset( 0 ); - - hprec->m_bFree.store( true, atomics::memory_order_relaxed ); + src.interthread_clear(); + hprec->m_bFree.store( true, atomics::memory_order_release ); hprec->m_idOwner.store( nullThreadId, atomics::memory_order_release ); scan( pThis ); @@ -491,8 +493,9 @@ namespace cds { namespace gc { namespace hp { { st.clear(); # ifdef CDS_ENABLE_HPSTAT - for ( thread_record* hprec = thread_list_.load( atomics::memory_order_acquire ); hprec; hprec = hprec->m_pNextNode.load( atomics::memory_order_relaxed ) ) + for ( thread_record* hprec = thread_list_.load( atomics::memory_order_acquire ); hprec; hprec = hprec->m_pNextNode.load( atomics::memory_order_relaxed )) { + CDS_TSAN_ANNOTATE_IGNORE_READS_BEGIN; ++st.thread_rec_count; st.guard_allocated += hprec->hazards_.alloc_guard_count_; st.guard_freed += hprec->hazards_.free_guard_count_; @@ -500,6 +503,7 @@ namespace cds { namespace gc { namespace hp { st.free_count += hprec->free_count_; st.scan_count += hprec->scan_count_; st.help_scan_count += hprec->help_scan_count_; + CDS_TSAN_ANNOTATE_IGNORE_READS_END; } # endif }