Adds a few single-threaded test cases for queue, stack, and set

[libcds.git] / cds / intrusive / ellen_bintree_rcu.h

diff --git a/cds/intrusive/ellen_bintree_rcu.h b/cds/intrusive/ellen_bintree_rcu.h
index 50e9cf022fe144503ecb465ca8f39a0e9b728aaa..2919d96147698dbb12afa28ea8fd1076f3dba780 100644 (file)
--- a/cds/intrusive/ellen_bintree_rcu.h
+++ b/cds/intrusive/ellen_bintree_rcu.h
@@ -53,7 +53,7 @@ namespace cds { namespace intrusive {
 
             /// Constructs leaf (bIntrenal == false) or internal (bInternal == true) node
             explicit base_node( bool bInternal )
-                : basic_node( bInternal ? internal : 0 )
+                : basic_node( bInternal )
                 , m_pNextRetired( nullptr )
             {}
         };
@@ -552,10 +552,14 @@ namespace cds { namespace intrusive {
 
     protected:
         //@cond
-        static void free_leaf_node( value_type * p )
+        static void free_leaf_node( value_type* p )
         {
             disposer()( p );
         }
+        static void free_leaf_node_void( void* p )
+        {
+            free_leaf_node( reinterpret_cast<value_type*>( p ));
+        }
 
         internal_node * alloc_internal_node() const
         {
@@ -565,10 +569,14 @@ namespace cds { namespace intrusive {
             return pNode;
         }
 
-        static void free_internal_node( internal_node * pNode )
+        static void free_internal_node( internal_node* pNode )
         {
             cxx_node_allocator().Delete( pNode );
         }
+        static void free_internal_node_void( void* pNode )
+        {
+            free_internal_node( reinterpret_cast<internal_node*>( pNode ));
+        }
 
         struct internal_node_deleter {
             void operator()( internal_node * p) const
@@ -585,10 +593,14 @@ namespace cds { namespace intrusive {
             return cxx_update_desc_allocator().New();
         }
 
-        static void free_update_desc( update_desc * pDesc )
+        static void free_update_desc( update_desc* pDesc )
         {
             cxx_update_desc_allocator().Delete( pDesc );
         }
+        static void free_update_desc_void( void* pDesc )
+        {
+            free_update_desc( reinterpret_cast<update_desc*>( pDesc ));
+        }
 
         class retired_list
         {
@@ -615,21 +627,19 @@ namespace cds { namespace intrusive {
                 cds::urcu::retired_ptr operator *()
                 {
                     if ( m_pUpdate ) {
-                        return cds::urcu::retired_ptr( reinterpret_cast<void *>( m_pUpdate ),
-                            reinterpret_cast<cds::urcu::free_retired_ptr_func>( free_update_desc ));
+                        return cds::urcu::retired_ptr( reinterpret_cast<void *>( m_pUpdate ), free_update_desc_void );
                     }
                     if ( m_pNode ) {
                         if ( m_pNode->is_leaf()) {
                             return cds::urcu::retired_ptr( reinterpret_cast<void *>( node_traits::to_value_ptr( static_cast<leaf_node *>( m_pNode ))),
-                                reinterpret_cast< cds::urcu::free_retired_ptr_func>( free_leaf_node ));
+                                free_leaf_node_void );
                         }
                         else {
                             return cds::urcu::retired_ptr( reinterpret_cast<void *>( static_cast<internal_node *>( m_pNode )),
-                                reinterpret_cast<cds::urcu::free_retired_ptr_func>( free_internal_node ));
+                                free_internal_node_void );
                         }
                     }
-                    return cds::urcu::retired_ptr( nullptr,
-                        reinterpret_cast<cds::urcu::free_retired_ptr_func>( free_update_desc ));
+                    return cds::urcu::retired_ptr( nullptr, free_update_desc_void );
                 }
 
                 void operator ++()
@@ -1385,11 +1395,11 @@ namespace cds { namespace intrusive {
             tree_node * pLeaf = static_cast<tree_node *>( pOp->iInfo.pLeaf );
             if ( pOp->iInfo.bRightLeaf ) {
                 pOp->iInfo.pParent->m_pRight.compare_exchange_strong( pLeaf, static_cast<tree_node *>( pOp->iInfo.pNew ),
-                    memory_model::memory_order_relaxed, atomics::memory_order_relaxed );
+                    memory_model::memory_order_release, atomics::memory_order_relaxed );
             }
             else {
                 pOp->iInfo.pParent->m_pLeft.compare_exchange_strong( pLeaf, static_cast<tree_node *>( pOp->iInfo.pNew ),
-                    memory_model::memory_order_relaxed, atomics::memory_order_relaxed );
+                    memory_model::memory_order_release, atomics::memory_order_relaxed );
             }
 
             update_ptr cur( pOp, update_desc::IFlag );
@@ -1650,7 +1660,7 @@ namespace cds { namespace intrusive {
 
                             update_ptr updGP( res.updGrandParent.ptr());
                             if ( res.pGrandParent->m_pUpdate.compare_exchange_strong( updGP, update_ptr( pOp, update_desc::DFlag ),
-                                memory_model::memory_order_acquire, atomics::memory_order_relaxed ))
+                                memory_model::memory_order_acq_rel, atomics::memory_order_acquire ))
                             {
                                 if ( help_delete( pOp, updRetire )) {
                                     // res.pLeaf is not deleted yet since RCU is blocked
@@ -1728,7 +1738,7 @@ namespace cds { namespace intrusive {
 
                             update_ptr updGP( res.updGrandParent.ptr());
                             if ( res.pGrandParent->m_pUpdate.compare_exchange_strong( updGP, update_ptr( pOp, update_desc::DFlag ),
-                                memory_model::memory_order_acquire, atomics::memory_order_relaxed ))
+                                memory_model::memory_order_acq_rel, atomics::memory_order_acquire ))
                             {
                                 if ( help_delete( pOp, updRetire )) {
                                     pResult = node_traits::to_value_ptr( res.pLeaf );
@@ -1793,7 +1803,7 @@ namespace cds { namespace intrusive {
 
                             update_ptr updGP( res.updGrandParent.ptr());
                             if ( res.pGrandParent->m_pUpdate.compare_exchange_strong( updGP, update_ptr( pOp, update_desc::DFlag ),
-                                memory_model::memory_order_acquire, atomics::memory_order_relaxed ))
+                                memory_model::memory_order_acq_rel, atomics::memory_order_acquire ))
                             {
                                 if ( help_delete( pOp, updRetire )) {
                                     pResult = node_traits::to_value_ptr( res.pLeaf );
@@ -1857,7 +1867,7 @@ namespace cds { namespace intrusive {
 
                             update_ptr updGP( res.updGrandParent.ptr());
                             if ( res.pGrandParent->m_pUpdate.compare_exchange_strong( updGP, update_ptr( pOp, update_desc::DFlag ),
-                                memory_model::memory_order_acquire, atomics::memory_order_relaxed ))
+                                memory_model::memory_order_acq_rel, atomics::memory_order_acquire ))
                             {
                                 if ( help_delete( pOp, updRetire )) {
                                     pResult = node_traits::to_value_ptr( res.pLeaf );
@@ -1960,7 +1970,7 @@ namespace cds { namespace intrusive {
                         pNewInternal->infinite_key( 1 );
                     }
                     pNewInternal->m_pLeft.store( static_cast<tree_node *>(pNewLeaf), memory_model::memory_order_relaxed );
-                    pNewInternal->m_pRight.store( static_cast<tree_node *>(res.pLeaf), memory_model::memory_order_release );
+                    pNewInternal->m_pRight.store( static_cast<tree_node *>(res.pLeaf), memory_model::memory_order_relaxed );
                 }
                 else {
                     assert( !res.pLeaf->is_internal());
@@ -1968,7 +1978,7 @@ namespace cds { namespace intrusive {
 
                     key_extractor()( pNewInternal->m_Key, val );
                     pNewInternal->m_pLeft.store( static_cast<tree_node *>(res.pLeaf), memory_model::memory_order_relaxed );
-                    pNewInternal->m_pRight.store( static_cast<tree_node *>(pNewLeaf), memory_model::memory_order_release );
+                    pNewInternal->m_pRight.store( static_cast<tree_node *>(pNewLeaf), memory_model::memory_order_relaxed );
                     assert( !res.pLeaf->infinite_key());
                 }
 
@@ -1981,7 +1991,7 @@ namespace cds { namespace intrusive {
 
                 update_ptr updCur( res.updParent.ptr());
                 if ( res.pParent->m_pUpdate.compare_exchange_strong( updCur, update_ptr( pOp, update_desc::IFlag ),
-                    memory_model::memory_order_acquire, atomics::memory_order_relaxed ))
+                    memory_model::memory_order_acq_rel, atomics::memory_order_acquire ))
                 {
                     // do insert
                     help_insert( pOp );