projects / libcds.git / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
Changed lib version
[libcds.git] / src / hp_gc.cpp
diff --git a/src/hp_gc.cpp b/src/hp_gc.cpp
index a525c1cf289e11169c3092eabedb998cb4ed526d..b4ab05de8f64fa8aa28a6c54f03b16b964f1b381 100644 (file)
--- a/src/hp_gc.cpp
+++ b/src/hp_gc.cpp
@@ -1,11 +1,11 @@
 /*
     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/
-    
+
     Redistribution and use in source and binary forms, with or without
     modification, are permitted provided that the following conditions are met:
 
@@ -96,7 +96,7 @@ namespace cds { namespace gc {
             for ( hplist_node * hprec = pHead; hprec; hprec = pNext ) {
                 assert( hprec->m_idOwner.load( atomics::memory_order_relaxed ) == nullThreadId
                     || hprec->m_idOwner.load( atomics::memory_order_relaxed ) == mainThreadId
-                    || !cds::OS::is_thread_alive( hprec->m_idOwner.load( atomics::memory_order_relaxed ) )
+                    || !cds::OS::is_thread_alive( hprec->m_idOwner.load( atomics::memory_order_relaxed ))
                 );
                 details::retired_vector& vect = hprec->m_arrRetired;
                 details::retired_vector::iterator itRetired = vect.begin();
@@ -106,16 +106,16 @@ namespace cds { namespace gc {
                     ++itRetired;
                 }
                 vect.clear();
-                pNext = hprec->m_pNextNode;
+                pNext = hprec->m_pNextNode.load( atomics::memory_order_relaxed );
                 hprec->m_bFree.store( true, atomics::memory_order_relaxed );
                 DeleteHPRec( hprec );
             }
         }
 
-        inline GarbageCollector::hplist_node * GarbageCollector::NewHPRec()
+        inline GarbageCollector::hplist_node * GarbageCollector::NewHPRec( OS::ThreadId owner )
         {
             CDS_HAZARDPTR_STATISTIC( ++m_Stat.m_AllocNewHPRec )
-            return new hplist_node( *this );
+            return new hplist_node( *this, owner );
         }
 
         inline void GarbageCollector::DeleteHPRec( hplist_node * pNode )
@@ -134,24 +134,22 @@ namespace cds { namespace gc {
             const cds::OS::ThreadId curThreadId  = cds::OS::get_current_thread_id();
 
             // First try to reuse a retired (non-active) HP record
-            for ( hprec = m_pListHead.load( atomics::memory_order_acquire ); hprec; hprec = hprec->m_pNextNode ) {
+            for ( hprec = m_pListHead.load( atomics::memory_order_relaxed ); hprec; hprec = hprec->m_pNextNode.load( atomics::memory_order_relaxed )) {
                 cds::OS::ThreadId thId = nullThreadId;
-                if ( !hprec->m_idOwner.compare_exchange_strong( thId, curThreadId, atomics::memory_order_seq_cst, atomics::memory_order_relaxed ) )
+                if ( !hprec->m_idOwner.compare_exchange_strong( thId, curThreadId, atomics::memory_order_acquire, atomics::memory_order_relaxed ))
                     continue;
-                hprec->m_bFree.store( false, atomics::memory_order_release );
+                hprec->m_bFree.store( false, atomics::memory_order_relaxed );
                 return hprec;
             }
 
             // No HP records available for reuse
             // Allocate and push a new HP record
-            hprec = NewHPRec();
-            hprec->m_idOwner.store( curThreadId, atomics::memory_order_release );
-            hprec->m_bFree.store( false, atomics::memory_order_release );
+            hprec = NewHPRec( curThreadId );
 
-            hplist_node * pOldHead = m_pListHead.load( atomics::memory_order_acquire );
+            hplist_node * pOldHead = m_pListHead.load( atomics::memory_order_relaxed );
             do {
-                hprec->m_pNextNode = pOldHead;
-            } while ( !m_pListHead.compare_exchange_weak( pOldHead, hprec, atomics::memory_order_release, atomics::memory_order_relaxed ));
+                hprec->m_pNextNode.store( pOldHead, atomics::memory_order_relaxed );
+            } while ( !m_pListHead.compare_exchange_weak( pOldHead, hprec, atomics::memory_order_acq_rel, atomics::memory_order_acquire ));
 
             return hprec;
         }
@@ -172,8 +170,8 @@ namespace cds { namespace gc {
         {
             hplist_node * pNext = nullptr;
             const cds::OS::ThreadId nullThreadId = cds::OS::c_NullThreadId;
-            for ( hplist_node * hprec = m_pListHead.load(atomics::memory_order_acquire); hprec; hprec = pNext ) {
-                pNext = hprec->m_pNextNode;
+            for ( hplist_node * hprec = m_pListHead.load(atomics::memory_order_relaxed); hprec; hprec = pNext ) {
+                pNext = hprec->m_pNextNode.load( atomics::memory_order_relaxed );
                 if ( hprec->m_idOwner.load(atomics::memory_order_relaxed) != nullThreadId ) {
                     free_hp_record( hprec );
                 }
@@ -190,7 +188,7 @@ namespace cds { namespace gc {
 
             // Stage 1: Scan HP list and insert non-null values in plist
 
-            hplist_node * pNode = m_pListHead.load(atomics::memory_order_acquire);
+            hplist_node * pNode = m_pListHead.load(atomics::memory_order_relaxed);
 
             while ( pNode ) {
                 for ( size_t i = 0; i < m_nHazardPointerCount; ++i ) {
@@ -199,11 +197,11 @@ namespace cds { namespace gc {
                     if ( hptr )
                         plist.push_back( hptr );
                 }
-                pNode = pNode->m_pNextNode;
+                pNode = pNode->m_pNextNode.load( atomics::memory_order_relaxed );
             }
 
             // Sort plist to simplify search in
-            std::sort( plist.begin(), plist.end() );
+            std::sort( plist.begin(), plist.end());
 
             // Stage 2: Search plist
             details::retired_vector& arrRetired = pRec->m_arrRetired;
@@ -219,7 +217,7 @@ namespace cds { namespace gc {
                 std::vector< void * >::iterator itEnd = plist.end();
                 size_t nDeferredCount = 0;
                 while ( itRetired != itRetiredEnd ) {
-                    if ( std::binary_search( itBegin, itEnd, itRetired->m_p ) ) {
+                    if ( std::binary_search( itBegin, itEnd, itRetired->m_p )) {
                         arrRetired.push( *itRetired );
                         ++nDeferredCount;
                     }
@@ -269,12 +267,12 @@ namespace cds { namespace gc {
             */
 
             // Search guarded pointers in retired array
-            hplist_node * pNode = m_pListHead.load( atomics::memory_order_acquire );
+            hplist_node * pNode = m_pListHead.load( atomics::memory_order_relaxed );
 
             {
                 details::retired_ptr dummyRetired;
                 while ( pNode ) {
-                    if ( !pNode->m_bFree.load( atomics::memory_order_acquire ) ) {
+                    if ( !pNode->m_bFree.load( atomics::memory_order_relaxed )) {
                         for ( size_t i = 0; i < m_nHazardPointerCount; ++i ) {
                             pRec->sync();
                             void * hptr = pNode->m_hzp[i].get();
@@ -288,7 +286,7 @@ namespace cds { namespace gc {
                             }
                         }
                     }
-                    pNode = pNode->m_pNextNode;
+                    pNode = pNode->m_pNextNode.load( atomics::memory_order_relaxed );
                 }
             }
 
@@ -318,29 +316,31 @@ namespace cds { namespace gc {
         {
             CDS_HAZARDPTR_STATISTIC( ++m_Stat.m_HelpScanCallCount )
 
-            assert( static_cast<hplist_node *>(pThis)->m_idOwner.load(atomics::memory_order_relaxed) == cds::OS::get_current_thread_id() );
+            assert( static_cast<hplist_node *>(pThis)->m_idOwner.load(atomics::memory_order_relaxed) == cds::OS::get_current_thread_id());
 
             const cds::OS::ThreadId nullThreadId = cds::OS::c_NullThreadId;
             const cds::OS::ThreadId curThreadId = cds::OS::get_current_thread_id();
-            for ( hplist_node * hprec = m_pListHead.load(atomics::memory_order_acquire); hprec; hprec = hprec->m_pNextNode ) {
+            for ( hplist_node * hprec = m_pListHead.load(atomics::memory_order_relaxed); hprec; hprec = hprec->m_pNextNode.load( atomics::memory_order_relaxed )) {
 
                 // If m_bFree == true then hprec->m_arrRetired is empty - we don't need to see it
-                if ( hprec->m_bFree.load(atomics::memory_order_acquire) )
+                if ( hprec->m_bFree.load(atomics::memory_order_relaxed))
                     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(atomics::memory_order_acquire);
+                    cds::OS::ThreadId curOwner = hprec->m_idOwner.load(atomics::memory_order_relaxed);
                     if ( curOwner == nullThreadId || !cds::OS::is_thread_alive( curOwner )) {
-                        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, atomics::memory_order_release, atomics::memory_order_relaxed ))
+                        if ( !hprec->m_idOwner.compare_exchange_strong( curOwner, curThreadId, atomics::memory_order_acquire, atomics::memory_order_relaxed ))
                             continue;
                     }
+                    else
+                        continue;
+                    //else {
+                    //    curOwner = nullThreadId;
+                    //    if ( !hprec->m_idOwner.compare_exchange_strong( curOwner, curThreadId, atomics::memory_order_acquire, atomics::memory_order_relaxed ))
+                    //        continue;
+                    //}
                 }
 
                 // We own the thread successfully. Now, we can see whether hp_record has retired pointers.
@@ -372,7 +372,7 @@ namespace cds { namespace gc {
                 src.clear();
                 CDS_TSAN_ANNOTATE_IGNORE_WRITES_END;
 
-                hprec->m_bFree.store(true, atomics::memory_order_release);
+                hprec->m_bFree.store(true, atomics::memory_order_relaxed);
                 hprec->m_idOwner.store( nullThreadId, atomics::memory_order_release );
 
                 Scan( pThis );
@@ -392,11 +392,11 @@ namespace cds { namespace gc {
                 stat.nTotalRetiredPtrCount   =
                 stat.nRetiredPtrInFreeHPRecs = 0;
 
-            for ( hplist_node * hprec = m_pListHead.load(atomics::memory_order_acquire); hprec; hprec = hprec->m_pNextNode ) {
+            for ( hplist_node * hprec = m_pListHead.load(atomics::memory_order_relaxed); hprec; hprec = hprec->m_pNextNode.load( atomics::memory_order_relaxed )) {
                 ++stat.nHPRecAllocated;
                 stat.nTotalRetiredPtrCount += hprec->m_arrRetired.size();
 
-                if ( hprec->m_bFree.load(atomics::memory_order_relaxed) ) {
+                if ( hprec->m_bFree.load(atomics::memory_order_relaxed)) {
                     // Free HP record
                     stat.nRetiredPtrInFreeHPRecs += hprec->m_arrRetired.size();
                 }
Unnamed repository; edit this file 'description' to name the repository.