GarbageCollector::~GarbageCollector()
{
- thread_list_node * pNode = m_pListHead.load( CDS_ATOMIC::memory_order_relaxed );
+ thread_list_node * pNode = m_pListHead.load( atomics::memory_order_relaxed );
while ( pNode ) {
- assert( pNode->m_idOwner.load(CDS_ATOMIC::memory_order_relaxed) == cds::OS::nullThreadId() );
+ assert( pNode->m_idOwner.load( atomics::memory_order_relaxed ) == cds::OS::c_NullThreadId );
clearHRCThreadDesc( pNode );
thread_list_node * pNext = pNode->m_pNext;
deleteHRCThreadDesc( pNode );
assert( pNode->m_hzp.size() == pNode->m_hzp.capacity() );
ContainerNode * pItem;
for ( size_t n = 0; n < pNode->m_arrRetired.capacity(); ++n ) {
- if ( (pItem = pNode->m_arrRetired[n].m_pNode.load( CDS_ATOMIC::memory_order_relaxed )) != nullptr ) {
+ if ( (pItem = pNode->m_arrRetired[n].m_pNode.load( atomics::memory_order_relaxed )) != nullptr ) {
pNode->m_arrRetired[n].m_funcFree( pItem );
//pItem->destroy();
- pNode->m_arrRetired[n].m_pNode.store( nullptr, CDS_ATOMIC::memory_order_relaxed );
+ pNode->m_arrRetired[n].m_pNode.store( nullptr, atomics::memory_order_relaxed );
}
}
assert( pNode->m_hzp.size() == pNode->m_hzp.capacity() );
thread_list_node * hprec;
const cds::OS::ThreadId curThreadId = cds::OS::getCurrentThreadId();
- for ( hprec = m_pListHead.load( CDS_ATOMIC::memory_order_acquire ); hprec; hprec = hprec->m_pNext ) {
- if ( hprec->m_idOwner.load( CDS_ATOMIC::memory_order_acquire ) == curThreadId ) {
+ for ( hprec = m_pListHead.load( atomics::memory_order_acquire ); hprec; hprec = hprec->m_pNext ) {
+ if ( hprec->m_idOwner.load( atomics::memory_order_acquire ) == curThreadId ) {
assert( !hprec->m_bFree );
return hprec;
}
CDS_HRC_STATISTIC( ++m_Stat.m_AllocHRCThreadDesc );
thread_list_node * hprec;
- const cds::OS::ThreadId nullThreadId = cds::OS::nullThreadId();
+ const cds::OS::ThreadId nullThreadId = cds::OS::c_NullThreadId;
const cds::OS::ThreadId curThreadId = cds::OS::getCurrentThreadId();
// First try to reuse a retired (non-active) HP record
- for ( hprec = m_pListHead.load( CDS_ATOMIC::memory_order_acquire ); hprec; hprec = hprec->m_pNext ) {
+ for ( hprec = m_pListHead.load( atomics::memory_order_acquire ); hprec; hprec = hprec->m_pNext ) {
cds::OS::ThreadId expectedThreadId = nullThreadId;
- if ( !hprec->m_idOwner.compare_exchange_strong( expectedThreadId, curThreadId, CDS_ATOMIC::memory_order_acq_rel, CDS_ATOMIC::memory_order_relaxed ) )
+ if ( !hprec->m_idOwner.compare_exchange_strong( expectedThreadId, curThreadId, atomics::memory_order_acq_rel, atomics::memory_order_relaxed ) )
continue;
hprec->m_pOwner = pThreadGC;
hprec->m_bFree = false;
// Allocate and push a new HP record
hprec = newHRCThreadDesc();
assert( hprec->m_hzp.size() == hprec->m_hzp.capacity() );
- hprec->m_idOwner.store( curThreadId, CDS_ATOMIC::memory_order_relaxed );
+ hprec->m_idOwner.store( curThreadId, atomics::memory_order_relaxed );
hprec->m_pOwner = pThreadGC;
hprec->m_bFree = false;
thread_list_node * pOldHead;
- pOldHead = m_pListHead.load( CDS_ATOMIC::memory_order_relaxed );
+ pOldHead = m_pListHead.load( atomics::memory_order_relaxed );
do {
hprec->m_pNext = pOldHead;
- } while ( !m_pListHead.compare_exchange_weak( pOldHead, hprec, CDS_ATOMIC::memory_order_release, CDS_ATOMIC::memory_order_relaxed ));
+ } while ( !m_pListHead.compare_exchange_weak( pOldHead, hprec, atomics::memory_order_release, atomics::memory_order_relaxed ));
assert( hprec->m_hzp.size() == hprec->m_hzp.capacity() );
return hprec;
if the destruction of thread object is called by the destructor
after thread termination
*/
- assert( pNode->m_idOwner.load(CDS_ATOMIC::memory_order_relaxed) != cds::OS::nullThreadId() );
+ assert( pNode->m_idOwner.load( atomics::memory_order_relaxed ) != cds::OS::c_NullThreadId );
pNode->m_pOwner = nullptr;
- pNode->m_idOwner.store( cds::OS::nullThreadId(), CDS_ATOMIC::memory_order_release );
+ pNode->m_idOwner.store( cds::OS::c_NullThreadId, atomics::memory_order_release );
assert( pNode->m_hzp.size() == pNode->m_hzp.capacity() );
}
typedef std::vector< ContainerNode * > hazard_ptr_list;
details::thread_descriptor * pRec = pThreadGC->m_pDesc;
- assert( static_cast< thread_list_node *>( pRec )->m_idOwner.load(CDS_ATOMIC::memory_order_relaxed) == cds::OS::getCurrentThreadId() );
+ assert( static_cast< thread_list_node *>( pRec )->m_idOwner.load(atomics::memory_order_relaxed) == cds::OS::getCurrentThreadId() );
// Step 1: mark all pRec->m_arrRetired items as "traced"
{
details::retired_vector::const_iterator itEnd = pRec->m_arrRetired.end();
for ( details::retired_vector::const_iterator it = pRec->m_arrRetired.begin() ; it != itEnd; ++it ) {
- ContainerNode * pNode = it->m_pNode.load( CDS_ATOMIC::memory_order_acquire );
+ ContainerNode * pNode = it->m_pNode.load( atomics::memory_order_acquire );
if ( pNode ) {
if ( pNode->m_RC.value() == 0 ) {
- pNode->m_bTrace.store( true, CDS_ATOMIC::memory_order_release );
+ pNode->m_bTrace.store( true, atomics::memory_order_release );
if ( pNode->m_RC.value() != 0 )
- pNode->m_bTrace.store( false, CDS_ATOMIC::memory_order_release );
+ pNode->m_bTrace.store( false, atomics::memory_order_release );
}
}
}
// Stage 2: Scan HP list and insert non-null values to plist
{
- thread_list_node * pNode = m_pListHead.load( CDS_ATOMIC::memory_order_acquire );
+ thread_list_node * pNode = m_pListHead.load( atomics::memory_order_acquire );
while ( pNode ) {
for ( size_t i = 0; i < m_nHazardPointerCount; ++i ) {
for ( size_t nRetired = 0; it != itEnd; ++nRetired, ++it ) {
details::retired_node& node = *it;
- ContainerNode * pNode = node.m_pNode.load(CDS_ATOMIC::memory_order_acquire);
+ ContainerNode * pNode = node.m_pNode.load(atomics::memory_order_acquire);
if ( !pNode )
continue;
- if ( pNode->m_RC.value() == 0 && pNode->m_bTrace.load(CDS_ATOMIC::memory_order_acquire) && !std::binary_search( itHPBegin, itHPEnd, pNode ) ) {
+ if ( pNode->m_RC.value() == 0 && pNode->m_bTrace.load(atomics::memory_order_acquire) && !std::binary_search( itHPBegin, itHPEnd, pNode ) ) {
// pNode may be destructed safely
- node.m_bDone.store( true, CDS_ATOMIC::memory_order_release );
- if ( node.m_nClaim.load( CDS_ATOMIC::memory_order_acquire ) == 0 ) {
+ node.m_bDone.store( true, atomics::memory_order_release );
+ if ( node.m_nClaim.load( atomics::memory_order_acquire ) == 0 ) {
pNode->terminate( pThreadGC, false );
- pNode->clean( CDS_ATOMIC::memory_order_relaxed );
+ pNode->clean( atomics::memory_order_relaxed );
node.m_funcFree( pNode );
arr.pop( nRetired );
}
pNode->terminate( pThreadGC, true );
- //node.m_bDone.store( true, CDS_ATOMIC::memory_order_release );
+ //node.m_bDone.store( true, atomics::memory_order_release );
CDS_HRC_STATISTIC( ++m_Stat.m_ScanClaimGuarded );
}
else {
CDS_HRC_STATISTIC( ++m_Stat.m_HelpScanCalls );
- const cds::OS::ThreadId nullThreadId = cds::OS::nullThreadId();
+ const cds::OS::ThreadId nullThreadId = cds::OS::c_NullThreadId;
const cds::OS::ThreadId curThreadId = cds::OS::getCurrentThreadId();
- for ( thread_list_node * pRec = m_pListHead.load(CDS_ATOMIC::memory_order_acquire); pRec; pRec = pRec->m_pNext )
+ for ( thread_list_node * pRec = m_pListHead.load(atomics::memory_order_acquire); pRec; pRec = pRec->m_pNext )
{
// If threadDesc is free then own its
cds::OS::ThreadId expectedThreadId = nullThreadId;
- if ( !pRec->m_idOwner.compare_exchange_strong(expectedThreadId, curThreadId, CDS_ATOMIC::memory_order_acquire, CDS_ATOMIC::memory_order_relaxed) )
+ if ( !pRec->m_idOwner.compare_exchange_strong(expectedThreadId, curThreadId, atomics::memory_order_acquire, atomics::memory_order_relaxed) )
{
continue;
}
details::retired_vector::iterator it = src.begin();
for ( size_t nRetired = 0; it != itEnd; ++nRetired, ++it ) {
- if ( it->m_pNode.load( CDS_ATOMIC::memory_order_relaxed ) == nullptr )
+ if ( it->m_pNode.load( atomics::memory_order_relaxed ) == nullptr )
continue;
- dest.push( it->m_pNode.load(CDS_ATOMIC::memory_order_relaxed), it->m_funcFree );
+ dest.push( it->m_pNode.load(atomics::memory_order_relaxed), it->m_funcFree );
src.pop( nRetired );
while ( dest.isFull() ) {
}
pRec->m_bFree = true;
}
- pRec->m_idOwner.store( nullThreadId, CDS_ATOMIC::memory_order_release );
+ pRec->m_idOwner.store( nullThreadId, atomics::memory_order_release );
}
}
{
CDS_HRC_STATISTIC( ++m_Stat.m_CleanUpAllCalls );
- //const cds::OS::ThreadId nullThreadId = cds::OS::nullThreadId();
- thread_list_node * pThread = m_pListHead.load(CDS_ATOMIC::memory_order_acquire);
+ //const cds::OS::ThreadId nullThreadId = cds::OS::c_NullThreadId;
+ thread_list_node * pThread = m_pListHead.load(atomics::memory_order_acquire);
while ( pThread ) {
for ( size_t i = 0; i < pThread->m_arrRetired.capacity(); ++i ) {
details::retired_node& rRetiredNode = pThread->m_arrRetired[i];
- ContainerNode * pNode = rRetiredNode.m_pNode.load(CDS_ATOMIC::memory_order_acquire);
- if ( pNode && !rRetiredNode.m_bDone.load(CDS_ATOMIC::memory_order_acquire) ) {
- rRetiredNode.m_nClaim.fetch_add( 1, CDS_ATOMIC::memory_order_release );
- if ( !rRetiredNode.m_bDone.load(CDS_ATOMIC::memory_order_acquire)
- && pNode == rRetiredNode.m_pNode.load(CDS_ATOMIC::memory_order_acquire) )
+ ContainerNode * pNode = rRetiredNode.m_pNode.load(atomics::memory_order_acquire);
+ if ( pNode && !rRetiredNode.m_bDone.load(atomics::memory_order_acquire) ) {
+ rRetiredNode.m_nClaim.fetch_add( 1, atomics::memory_order_release );
+ if ( !rRetiredNode.m_bDone.load(atomics::memory_order_acquire)
+ && pNode == rRetiredNode.m_pNode.load(atomics::memory_order_acquire) )
{
pNode->cleanUp( pThis );
}
- rRetiredNode.m_nClaim.fetch_sub( 1, CDS_ATOMIC::memory_order_release );
+ rRetiredNode.m_nClaim.fetch_sub( 1, atomics::memory_order_release );
}
}
pThread = pThread->m_pNext;
stat.nRetiredPtrInFreeHRCRecs = 0;
// Walk through HRC records
- for ( thread_list_node *hprec = m_pListHead.load(CDS_ATOMIC::memory_order_acquire); hprec; hprec = hprec->m_pNext ) {
+ for ( thread_list_node *hprec = m_pListHead.load(atomics::memory_order_acquire); hprec; hprec = hprec->m_pNext ) {
++stat.nHRCRecAllocated;
size_t nRetiredNodeCount = hprec->m_arrRetired.retiredNodeCount();
if ( hprec->m_bFree ) {