Replace NULL with nullptr

[libcds.git] / src / hzp_gc.cpp

diff --git a/src/hzp_gc.cpp b/src/hzp_gc.cpp
index 46d7315338997fd93d60da8790f0870559fe781c..5f38bafcd3831f93393f4a5334e6bfdc431cfaa8 100644 (file)
--- a/src/hzp_gc.cpp
+++ b/src/hzp_gc.cpp
@@ -22,7 +22,7 @@ namespace cds { namespace gc {
         /// Max array size of retired pointers
         static const size_t c_nMaxRetireNodeCount = c_nHazardPointerPerThread * c_nMaxThreadCount * 2;
 
-        GarbageCollector *    GarbageCollector::m_pHZPManager = NULL;
+        GarbageCollector *    GarbageCollector::m_pHZPManager = nullptr;
 
         void CDS_STDCALL GarbageCollector::Construct( size_t nHazardPtrCount, size_t nMaxThreadCount, size_t nMaxRetiredPtrCount, scan_type nScanType )
         {
@@ -38,7 +38,7 @@ namespace cds { namespace gc {
                     m_pHZPManager->detachAllThread();
 
                 delete m_pHZPManager;
-                m_pHZPManager = NULL;
+                m_pHZPManager = nullptr;
             }
         }
 
@@ -48,7 +48,7 @@ namespace cds { namespace gc {
             size_t nMaxRetiredPtrCount,
             scan_type nScanType
         )
-            : m_pListHead(NULL)
+            : m_pListHead( nullptr )
             ,m_bStatEnabled( true )
             ,m_nHazardPointerCount( nHazardPtrCount == 0 ? c_nHazardPointerPerThread : nHazardPtrCount )
             ,m_nMaxThreadCount( nMaxThreadCount == 0 ? c_nMaxThreadCount : nMaxThreadCount )
@@ -58,13 +58,13 @@ namespace cds { namespace gc {
 
         GarbageCollector::~GarbageCollector()
         {
-            CDS_DEBUG_DO( const std::thread::id nullThreadId = std::thread::id(); )
-            CDS_DEBUG_DO( const std::thread::id mainThreadId = std::this_thread::get_id(); )
+            CDS_DEBUG_DO( const cds::OS::ThreadId nullThreadId = cds::OS::c_NullThreadId; )
+            CDS_DEBUG_DO( 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 * pNext = NULL;
+            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
@@ -108,12 +108,12 @@ namespace cds { namespace gc {
             CDS_HAZARDPTR_STATISTIC( ++m_Stat.m_AllocHPRec );
 
             hplist_node * hprec;
-            const std::thread::id nullThreadId = std::thread::id();
-            const std::thread::id curThreadId = std::this_thread::get_id();
+            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_pNextNode ) {
-                std::thread::id thId = nullThreadId;
+                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 ) )
                     continue;
                 hprec->m_bFree.store( false, CDS_ATOMIC::memory_order_release );
@@ -138,19 +138,19 @@ namespace cds { namespace gc {
 
         void GarbageCollector::RetireHPRec( details::HPRec * pRec )
         {
-            assert( pRec != NULL );
+            assert( pRec != nullptr );
             CDS_HAZARDPTR_STATISTIC( ++m_Stat.m_RetireHPRec );
 
             pRec->clear();
             Scan( pRec );
             hplist_node * pNode = static_cast<hplist_node *>( pRec );
-            pNode->m_idOwner.store( std::thread::id(), CDS_ATOMIC::memory_order_release );
+            pNode->m_idOwner.store( cds::OS::c_NullThreadId, CDS_ATOMIC::memory_order_release );
         }
 
         void GarbageCollector::detachAllThread()
         {
-            hplist_node * pNext = NULL;
-            const std::thread::id nullThreadId = std::thread::id();
+            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 ) {
                 pNext = hprec->m_pNextNode;
                 if ( hprec->m_idOwner.load(CDS_ATOMIC::memory_order_relaxed) != nullThreadId ) {
@@ -269,10 +269,10 @@ 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 ) == std::this_thread::get_id() );
+            assert( static_cast<hplist_node *>(pThis)->m_idOwner.load(CDS_ATOMIC::memory_order_relaxed) == cds::OS::getCurrentThreadId() );
 
-            const std::thread::id nullThreadId = std::thread::id();
-            const std::thread::id curThreadId = std::this_thread::get_id();
+            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 ) {
 
                 // If m_bFree == true then hprec->m_arrRetired is empty - we don't need to see it
@@ -282,7 +282,7 @@ namespace cds { namespace gc {
                 // Owns hprec if it is empty.
                 // Several threads may work concurrently so we use atomic technique only.
                 {
-                    std::thread::id curOwner = hprec->m_idOwner.load( CDS_ATOMIC::memory_order_acquire );
+                    cds::OS::ThreadId curOwner = hprec->m_idOwner.load(CDS_ATOMIC::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 ))
                             continue;