rearrange cds/gc contents

[libcds.git] / src / hzp_gc.cpp

diff --git a/src/hzp_gc.cpp b/src/hzp_gc.cpp
index 5f38bafcd3831f93393f4a5334e6bfdc431cfaa8..a8bb004dc886b2a9c26b39e16e97e9a88405bf4b 100644 (file)
--- a/src/hzp_gc.cpp
+++ b/src/hzp_gc.cpp
@@ -9,7 +9,7 @@
         2008.02.10    Maxim.Khiszinsky    Created
 */
 
-#include <cds/gc/hzp/hzp.h>
+#include <cds/gc/hp/hp.h>
 
 #include <algorithm>    // std::sort
 #include "hzp_const.h"
@@ -58,17 +58,17 @@ namespace cds { namespace gc {
 
         GarbageCollector::~GarbageCollector()
         {
-            CDS_DEBUG_DO( const cds::OS::ThreadId nullThreadId = cds::OS::c_NullThreadId; )
-            CDS_DEBUG_DO( const cds::OS::ThreadId mainThreadId = cds::OS::getCurrentThreadId() ;)
+            CDS_DEBUG_ONLY( const cds::OS::ThreadId nullThreadId = cds::OS::c_NullThreadId; )
+            CDS_DEBUG_ONLY( const cds::OS::ThreadId mainThreadId = cds::OS::getCurrentThreadId() ;)
 
-            hplist_node * pHead = m_pListHead.load( CDS_ATOMIC::memory_order_relaxed );
-            m_pListHead.store( nullptr, CDS_ATOMIC::memory_order_relaxed );
+            hplist_node * pHead = m_pListHead.load( atomics::memory_order_relaxed );
+            m_pListHead.store( nullptr, atomics::memory_order_relaxed );
 
             hplist_node * pNext = nullptr;
             for ( hplist_node * hprec = pHead; hprec; hprec = pNext ) {
-                assert( hprec->m_idOwner.load( CDS_ATOMIC::memory_order_relaxed ) == nullThreadId
-                    || hprec->m_idOwner.load( CDS_ATOMIC::memory_order_relaxed ) == mainThreadId
-                    || !cds::OS::isThreadAlive( hprec->m_idOwner.load( CDS_ATOMIC::memory_order_relaxed ) )
+                assert( hprec->m_idOwner.load( atomics::memory_order_relaxed ) == nullThreadId
+                    || hprec->m_idOwner.load( atomics::memory_order_relaxed ) == mainThreadId
+                    || !cds::OS::isThreadAlive( hprec->m_idOwner.load( atomics::memory_order_relaxed ) )
                 );
                 details::retired_vector& vect = hprec->m_arrRetired;
                 details::retired_vector::iterator itRetired = vect.begin();
@@ -79,7 +79,7 @@ namespace cds { namespace gc {
                 }
                 vect.clear();
                 pNext = hprec->m_pNextNode;
-                hprec->m_bFree.store( true, CDS_ATOMIC::memory_order_relaxed );
+                hprec->m_bFree.store( true, atomics::memory_order_relaxed );
                 DeleteHPRec( hprec );
             }
         }
@@ -112,26 +112,26 @@ namespace cds { namespace gc {
             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_pNextNode ) {
+            for ( hprec = m_pListHead.load( atomics::memory_order_acquire ); hprec; hprec = hprec->m_pNextNode ) {
                 cds::OS::ThreadId thId = nullThreadId;
-                if ( !hprec->m_idOwner.compare_exchange_strong( thId, curThreadId, CDS_ATOMIC::memory_order_seq_cst, CDS_ATOMIC::memory_order_relaxed ) )
+                if ( !hprec->m_idOwner.compare_exchange_strong( thId, curThreadId, atomics::memory_order_seq_cst, atomics::memory_order_relaxed ) )
                     continue;
-                hprec->m_bFree.store( false, CDS_ATOMIC::memory_order_release );
+                hprec->m_bFree.store( false, atomics::memory_order_release );
                 return hprec;
             }
 
             // No HP records available for reuse
             // Allocate and push a new HP record
             hprec = NewHPRec();
-            hprec->m_idOwner.store( curThreadId, CDS_ATOMIC::memory_order_relaxed );
-            hprec->m_bFree.store( false, CDS_ATOMIC::memory_order_relaxed );
+            hprec->m_idOwner.store( curThreadId, atomics::memory_order_relaxed );
+            hprec->m_bFree.store( false, atomics::memory_order_relaxed );
 
-            CDS_ATOMIC::atomic_thread_fence( CDS_ATOMIC::memory_order_release );
+            atomics::atomic_thread_fence( atomics::memory_order_release );
 
-            hplist_node * pOldHead = m_pListHead.load( CDS_ATOMIC::memory_order_acquire );
+            hplist_node * pOldHead = m_pListHead.load( atomics::memory_order_acquire );
             do {
                 hprec->m_pNextNode = 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 ));
 
             return hprec;
         }
@@ -144,16 +144,16 @@ namespace cds { namespace gc {
             pRec->clear();
             Scan( pRec );
             hplist_node * pNode = static_cast<hplist_node *>( pRec );
-            pNode->m_idOwner.store( cds::OS::c_NullThreadId, CDS_ATOMIC::memory_order_release );
+            pNode->m_idOwner.store( cds::OS::c_NullThreadId, atomics::memory_order_release );
         }
 
         void GarbageCollector::detachAllThread()
         {
             hplist_node * pNext = nullptr;
             const cds::OS::ThreadId nullThreadId = cds::OS::c_NullThreadId;
-            for ( hplist_node * hprec = m_pListHead.load(CDS_ATOMIC::memory_order_acquire); hprec; hprec = pNext ) {
+            for ( hplist_node * hprec = m_pListHead.load(atomics::memory_order_acquire); hprec; hprec = pNext ) {
                 pNext = hprec->m_pNextNode;
-                if ( hprec->m_idOwner.load(CDS_ATOMIC::memory_order_relaxed) != nullThreadId ) {
+                if ( hprec->m_idOwner.load(atomics::memory_order_relaxed) != nullThreadId ) {
                     RetireHPRec( hprec );
                 }
             }
@@ -169,7 +169,7 @@ namespace cds { namespace gc {
 
             // Stage 1: Scan HP list and insert non-null values in plist
 
-            hplist_node * pNode = m_pListHead.load(CDS_ATOMIC::memory_order_acquire);
+            hplist_node * pNode = m_pListHead.load(atomics::memory_order_acquire);
 
             while ( pNode ) {
                 for ( size_t i = 0; i < m_nHazardPointerCount; ++i ) {
@@ -230,7 +230,7 @@ namespace cds { namespace gc {
 
             // Search guarded pointers in retired array
 
-            hplist_node * pNode = m_pListHead.load(CDS_ATOMIC::memory_order_acquire);
+            hplist_node * pNode = m_pListHead.load(atomics::memory_order_acquire);
 
             while ( pNode ) {
                 for ( size_t i = 0; i < m_nHazardPointerCount; ++i ) {
@@ -269,27 +269,27 @@ namespace cds { namespace gc {
         {
             CDS_HAZARDPTR_STATISTIC( ++m_Stat.m_HelpScanCallCount );
 
-            assert( static_cast<hplist_node *>(pThis)->m_idOwner.load(CDS_ATOMIC::memory_order_relaxed) == cds::OS::getCurrentThreadId() );
+            assert( static_cast<hplist_node *>(pThis)->m_idOwner.load(atomics::memory_order_relaxed) == cds::OS::getCurrentThreadId() );
 
             const cds::OS::ThreadId nullThreadId = cds::OS::c_NullThreadId;
             const cds::OS::ThreadId curThreadId = cds::OS::getCurrentThreadId();
-            for ( hplist_node * hprec = m_pListHead.load(CDS_ATOMIC::memory_order_acquire); hprec; hprec = hprec->m_pNextNode ) {
+            for ( hplist_node * hprec = m_pListHead.load(atomics::memory_order_acquire); hprec; hprec = hprec->m_pNextNode ) {
 
                 // If m_bFree == true then hprec->m_arrRetired is empty - we don't need to see it
-                if ( hprec->m_bFree.load(CDS_ATOMIC::memory_order_acquire) )
+                if ( hprec->m_bFree.load(atomics::memory_order_acquire) )
                     continue;
 
                 // Owns hprec if it is empty.
                 // Several threads may work concurrently so we use atomic technique only.
                 {
-                    cds::OS::ThreadId curOwner = hprec->m_idOwner.load(CDS_ATOMIC::memory_order_acquire);
+                    cds::OS::ThreadId curOwner = hprec->m_idOwner.load(atomics::memory_order_acquire);
                     if ( curOwner == nullThreadId || !cds::OS::isThreadAlive( curOwner )) {
-                        if ( !hprec->m_idOwner.compare_exchange_strong( curOwner, curThreadId, CDS_ATOMIC::memory_order_release, CDS_ATOMIC::memory_order_relaxed ))
+                        if ( !hprec->m_idOwner.compare_exchange_strong( curOwner, curThreadId, atomics::memory_order_release, atomics::memory_order_relaxed ))
                             continue;
                     }
                     else {
                         curOwner = nullThreadId;
-                        if ( !hprec->m_idOwner.compare_exchange_strong( curOwner, curThreadId, CDS_ATOMIC::memory_order_release, CDS_ATOMIC::memory_order_relaxed ))
+                        if ( !hprec->m_idOwner.compare_exchange_strong( curOwner, curThreadId, atomics::memory_order_release, atomics::memory_order_relaxed ))
                             continue;
                     }
                 }
@@ -311,8 +311,8 @@ namespace cds { namespace gc {
                 }
                 src.clear();
 
-                hprec->m_bFree.store(true, CDS_ATOMIC::memory_order_release);
-                hprec->m_idOwner.store( nullThreadId, CDS_ATOMIC::memory_order_release );
+                hprec->m_bFree.store(true, atomics::memory_order_release);
+                hprec->m_idOwner.store( nullThreadId, atomics::memory_order_release );
             }
         }
 
@@ -329,11 +329,11 @@ namespace cds { namespace gc {
                 stat.nTotalRetiredPtrCount   =
                 stat.nRetiredPtrInFreeHPRecs = 0;
 
-            for ( hplist_node * hprec = m_pListHead.load(CDS_ATOMIC::memory_order_acquire); hprec; hprec = hprec->m_pNextNode ) {
+            for ( hplist_node * hprec = m_pListHead.load(atomics::memory_order_acquire); hprec; hprec = hprec->m_pNextNode ) {
                 ++stat.nHPRecAllocated;
                 stat.nTotalRetiredPtrCount += hprec->m_arrRetired.size();
 
-                if ( hprec->m_bFree.load(CDS_ATOMIC::memory_order_relaxed) ) {
+                if ( hprec->m_bFree.load(atomics::memory_order_relaxed) ) {
                     // Free HP record
                     stat.nRetiredPtrInFreeHPRecs += hprec->m_arrRetired.size();
                 }