}
};
- class auto_lock_position {
- position& m_pos;
- public:
- auto_lock_position( position& pos )
- : m_pos(pos)
- {
- pos.lock();
- }
- ~auto_lock_position()
- {
- m_pos.unlock();
- }
- };
+ typedef std::unique_lock< position > scoped_position_lock;
typedef cds::urcu::details::check_deadlock_policy< gc, rcu_check_deadlock> check_deadlock_policy;
//@endcond
gc::template retire_ptr<clear_and_dispose>( node_traits::to_value_ptr( *pNode ) );
}
- void link_node( node_type * pNode, node_type * pPred, node_type * pCur )
+ static void link_node( node_type * pNode, node_type * pPred, node_type * pCur )
{
assert( pPred->m_pNext.load(memory_model::memory_order_relaxed).ptr() == pCur );
- pNode->m_pNext.store( marked_node_ptr(pCur), memory_model::memory_order_release );
+ pNode->m_pNext.store( marked_node_ptr(pCur), memory_model::memory_order_relaxed );
pPred->m_pNext.store( marked_node_ptr(pNode), memory_model::memory_order_release );
}
node_type * pNext = pCur->m_pNext.load(memory_model::memory_order_relaxed).ptr();
pCur->m_pNext.store( marked_node_ptr( pHead, 1 ), memory_model::memory_order_relaxed ); // logical deletion + back-link for search
- pPred->m_pNext.store( marked_node_ptr( pNext ), memory_model::memory_order_relaxed); // physically deleting
+ pPred->m_pNext.store( marked_node_ptr( pNext ), memory_model::memory_order_release); // physically deleting
}
//@endcond
assert( m_pNode != nullptr );
node_type * pNode = node_traits::to_node_ptr( m_pNode );
- node_type * pNext = pNode->m_pNext.load(memory_model::memory_order_relaxed).ptr();
+ node_type * pNext = pNode->m_pNext.load(memory_model::memory_order_acquire).ptr();
if ( pNext != nullptr )
m_pNode = node_traits::to_value_ptr( pNext );
}
// Dummy tail node could not be marked
while ( pNode->is_marked() )
- pNode = pNode->m_pNext.load(memory_model::memory_order_relaxed).ptr();
+ pNode = pNode->m_pNext.load(memory_model::memory_order_acquire).ptr();
if ( pNode != node_traits::to_node_ptr( m_pNode ) )
m_pNode = node_traits::to_value_ptr( pNode );
return insert_at( &m_Head, val, f );
}
- /// Ensures that the \p item exists in the list
+ /// Updates the item
/**
The operation performs inserting or changing data with lock-free manner.
- If the item \p val not found in the list, then \p val is inserted into the list.
+ If the item \p val not found in the list, then \p val is inserted into the list
+ iff \p bAllowInsert is \p true.
Otherwise, the functor \p func is called with item found.
The functor signature is:
\code
with arguments:
- \p bNew - \p true if the item has been inserted, \p false otherwise
- \p item - item of the list
- - \p val - argument \p val passed into the \p ensure function
+ - \p val - argument \p val passed into the \p update() function
If new item has been inserted (i.e. \p bNew is \p true) then \p item and \p val arguments
- refers to the same thing.
+ refer to the same thing.
The functor may change non-key fields of the \p item.
While the functor \p f is calling the item \p item is locked.
- Returns <tt> std::pair<bool, bool> </tt> where \p first is true if operation is successfull,
- \p second is true if new item has been added or \p false if the item with \p key
+ Returns <tt> std::pair<bool, bool> </tt> where \p first is \p true if operation is successfull,
+ \p second is \p true if new item has been added or \p false if the item with \p key
already is in the list.
- */
+ The function makes RCU lock internally.
+ */
template <typename Func>
+ std::pair<bool, bool> update( value_type& val, Func func, bool bAllowInsert = true )
+ {
+ return update_at( &m_Head, val, func, bAllowInsert );
+ }
+ //@cond
+ template <typename Func>
+ CDS_DEPRECATED("ensure() is deprecated, use update()")
std::pair<bool, bool> ensure( value_type& val, Func func )
{
- return ensure_at( &m_Head, val, func );
+ return update( val, func, true );
}
+ //@cond
/// Unlinks the item \p val from the list
/**
/// Finds the key \p key using \p pred predicate for searching
/**
- The function is an analog of \ref cds_intrusive_LazyList_rcu_find_func "find(Q&, Func)"
- but \p pred is used for key comparing.
+ The function is an analog of <tt>contains( key )</tt> but \p pred is used for key comparing.
\p Less functor has the interface like \p std::less.
\p pred must imply the same element order as the comparator used for building the list.
*/
}
//@endcond
- /// Finds the key \p key
- /** \anchor cds_intrusive_LazyList_rcu_find_val
+ /// Checks whether the list contains \p key
+ /**
The function searches the item with key equal to \p key
- and returns \p true if \p key found or \p false otherwise.
+ and returns \p true if it is found, and \p false otherwise.
*/
template <typename Q>
- bool find( Q const& key ) const
+ bool contains( Q const& key ) const
{
return find_at( const_cast<node_type *>( &m_Head ), key, key_comparator() );
}
+ //@cond
+ template <typename Q>
+ CDS_DEPRECATED("deprecated, use contains()")
+ bool find( Q const& key ) const
+ {
+ return contains( key );
+ }
+ //@endcond
- /// Finds the key \p key using \p pred predicate for searching
+ /// Checks whether the map contains \p key using \p pred predicate for searching
/**
- The function is an analog of \ref cds_intrusive_LazyList_rcu_find_val "find(Q const&)"
- but \p pred is used for key comparing.
+ The function is an analog of <tt>contains( key )</tt> but \p pred is used for key comparing.
\p Less functor has the interface like \p std::less.
- \p pred must imply the same element order as the comparator used for building the list.
+ \p Less must imply the same element order as the comparator used for building the list.
*/
template <typename Q, typename Less>
- bool find_with( Q const& key, Less pred ) const
+ bool contains( Q const& key, Less pred ) const
{
CDS_UNUSED( pred );
return find_at( const_cast<node_type *>( &m_Head ), key, cds::opt::details::make_comparator_from_less<Less>() );
}
+ //@cond
+ template <typename Q, typename Less>
+ CDS_DEPRECATED("deprecated, use contains()")
+ bool find_with( Q const& key, Less pred ) const
+ {
+ return contains( key, pred );
+ }
+ //@endcond
/// Finds the key \p key and return the item found
/** \anchor cds_intrusive_LazyList_rcu_get
assert( pNode != nullptr );
// Hack: convert node_type to value_type.
- // In principle, auxiliary node can be non-reducible to value_type
+ // Actually, an auxiliary node should not be converted to value_type
// We assume that comparator can correctly distinguish aux and regular node.
return insert_at( pHead, *node_traits::to_value_ptr( pNode ) );
}
return insert_at_locked( pHead, val );
}
- bool insert_at_locked( node_type * pHead, value_type& val )
- {
- // RCU lock should be locked!!!
- assert( gc::is_locked() );
-
- link_checker::is_empty( node_traits::to_node_ptr( val ) );
- position pos;
- key_comparator cmp;
-
- while ( true ) {
- search( pHead, val, pos );
- {
- auto_lock_position alp( pos );
- if ( validate( pos.pPred, pos.pCur )) {
- if ( pos.pCur != &m_Tail && cmp( *node_traits::to_value_ptr( *pos.pCur ), val ) == 0 ) {
- // failed: key already in list
- return false;
- }
- else {
- link_node( node_traits::to_node_ptr( val ), pos.pPred, pos.pCur );
- ++m_ItemCounter;
- return true;
- }
- }
- }
- }
- }
-
template <typename Func>
bool insert_at( node_type * pHead, value_type& val, Func f )
{
while ( true ) {
search( pHead, val, pos );
{
- auto_lock_position alp( pos );
+ scoped_position_lock sl( pos );
if ( validate( pos.pPred, pos.pCur )) {
if ( pos.pCur != &m_Tail && cmp( *node_traits::to_value_ptr( *pos.pCur ), val ) == 0 ) {
// failed: key already in list
return false;
}
- else {
- link_node( node_traits::to_node_ptr( val ), pos.pPred, pos.pCur );
- f( val );
- ++m_ItemCounter;
- return true;
- }
+
+ link_node( node_traits::to_node_ptr( val ), pos.pPred, pos.pCur );
+ f( val );
+ ++m_ItemCounter;
+ return true;
}
}
}
template <typename Func>
- std::pair<iterator, bool> ensure_at_( node_type * pHead, value_type& val, Func func )
+ std::pair<iterator, bool> update_at_( node_type * pHead, value_type& val, Func func, bool bAllowInsert )
{
rcu_lock l;
- return ensure_at_locked( pHead, val, func );
- }
-
- template <typename Func>
- std::pair<iterator, bool> ensure_at_locked( node_type * pHead, value_type& val, Func func )
- {
- // RCU lock should be locked!!!
- assert( gc::is_locked() );
-
- position pos;
- key_comparator cmp;
-
- while ( true ) {
- search( pHead, val, pos );
- {
- auto_lock_position alp( pos );
- if ( validate( pos.pPred, pos.pCur )) {
- if ( pos.pCur != &m_Tail && cmp( *node_traits::to_value_ptr( *pos.pCur ), val ) == 0 ) {
- // key already in the list
-
- func( false, *node_traits::to_value_ptr( *pos.pCur ) , val );
- return std::make_pair( iterator( pos.pCur ), false );
- }
- else {
- // new key
- link_checker::is_empty( node_traits::to_node_ptr( val ) );
-
- link_node( node_traits::to_node_ptr( val ), pos.pPred, pos.pCur );
- func( true, val, val );
- ++m_ItemCounter;
- return std::make_pair( iterator( node_traits::to_node_ptr( val )), true );
- }
- }
- }
- }
+ return update_at_locked( pHead, val, func, bAllowInsert );
}
template <typename Func>
- std::pair<bool, bool> ensure_at( node_type * pHead, value_type& val, Func func )
+ std::pair<bool, bool> update_at( node_type * pHead, value_type& val, Func func, bool bAllowInsert )
{
rcu_lock l;
- std::pair<iterator, bool> ret = ensure_at_locked( pHead, val, func );
+ std::pair<iterator, bool> ret = update_at_locked( pHead, val, func, bAllowInsert );
return std::make_pair( ret.first != end(), ret.second );
}
rcu_lock l;
search( pHead, val, pos );
{
- auto_lock_position alp( pos );
+ scoped_position_lock alp( pos );
if ( validate( pos.pPred, pos.pCur ) ) {
if ( pos.pCur != &m_Tail
&& cmp( *node_traits::to_value_ptr( *pos.pCur ), val ) == 0
}
template <typename Q, typename Compare, typename Func>
- bool erase_at( node_type * pHead, Q const& val, Compare cmp, Func f, position& pos )
+ bool erase_at( node_type * const pHead, Q const& val, Compare cmp, Func f, position& pos )
{
check_deadlock_policy::check();
rcu_lock l;
search( pHead, val, pos, cmp );
{
- auto_lock_position alp( pos );
+ scoped_position_lock alp( pos );
if ( validate( pos.pPred, pos.pCur )) {
if ( pos.pCur != &m_Tail && cmp( *node_traits::to_value_ptr( *pos.pCur ), val ) == 0 ) {
// key found
--m_ItemCounter;
nResult = 1;
}
- else {
+ else
nResult = -1;
- }
}
}
}
bool erase_at( node_type * pHead, Q const& val, Compare cmp )
{
position pos;
- return erase_at( pHead, val, cmp, [](value_type const &){}, pos );
+ return erase_at( pHead, val, cmp, [](value_type const&){}, pos );
}
template <typename Q, typename Compare>
- value_type * extract_at( node_type * pHead, Q const& val, Compare cmp )
+ value_type * extract_at( node_type * const pHead, Q const& val, Compare cmp )
{
position pos;
assert( gc::is_locked() ) ; // RCU must be locked!!!
search( pHead, val, pos, cmp );
int nResult = 0;
{
- auto_lock_position alp( pos );
+ scoped_position_lock alp( pos );
if ( validate( pos.pPred, pos.pCur )) {
if ( pos.pCur != &m_Tail && cmp( *node_traits::to_value_ptr( *pos.pCur ), val ) == 0 ) {
// key found
protected:
//@cond
template <typename Q>
- void search( node_type * pHead, Q const& key, position& pos ) const
+ void search( node_type * const pHead, Q const& key, position& pos ) const
{
search( pHead, key, pos, key_comparator() );
}
template <typename Q, typename Compare>
- void search( node_type * pHead, Q const& key, position& pos, Compare cmp ) const
+ void search( node_type * const pHead, Q const& key, position& pos, Compare cmp ) const
{
// RCU should be locked!!!
assert( gc::is_locked() );
marked_node_ptr pCur(pHead);
marked_node_ptr pPrev(pHead);
- while ( pCur.ptr() != pTail && ( pCur.ptr() == pHead || cmp( *node_traits::to_value_ptr( *pCur.ptr() ), key ) < 0 )) {
+ while ( pCur != pTail && ( pCur == pHead || cmp( *node_traits::to_value_ptr( *pCur.ptr()), key ) < 0 )) {
pPrev = pCur;
pCur = pCur->m_pNext.load(memory_model::memory_order_acquire);
}
pos.pPred = pPrev.ptr();
}
- static bool validate( node_type * pPred, node_type * pCur )
+ static bool validate( node_type * pPred, node_type * pCur ) CDS_NOEXCEPT
{
// RCU lock should be locked!!!
assert( gc::is_locked() );
}
//@endcond
+
+ private:
+ //@cond
+ bool insert_at_locked( node_type * pHead, value_type& val )
+ {
+ // RCU lock should be locked!!!
+ assert( gc::is_locked() );
+
+ link_checker::is_empty( node_traits::to_node_ptr( val ));
+ position pos;
+ key_comparator cmp;
+
+ while ( true ) {
+ search( pHead, val, pos );
+ {
+ scoped_position_lock alp( pos );
+ if ( validate( pos.pPred, pos.pCur ) ) {
+ if ( pos.pCur != &m_Tail && cmp( *node_traits::to_value_ptr( *pos.pCur ), val ) == 0 ) {
+ // failed: key already in list
+ return false;
+ }
+
+ link_node( node_traits::to_node_ptr( val ), pos.pPred, pos.pCur );
+ ++m_ItemCounter;
+ return true;
+ }
+ }
+ }
+ }
+
+ template <typename Func>
+ std::pair<iterator, bool> update_at_locked( node_type * pHead, value_type& val, Func func, bool bAllowInsert )
+ {
+ // RCU lock should be locked!!!
+ assert( gc::is_locked() );
+
+ position pos;
+ key_comparator cmp;
+
+ while ( true ) {
+ search( pHead, val, pos );
+ {
+ scoped_position_lock alp( pos );
+ if ( validate( pos.pPred, pos.pCur ) ) {
+ if ( pos.pCur != &m_Tail && cmp( *node_traits::to_value_ptr( *pos.pCur ), val ) == 0 ) {
+ // key already in the list
+
+ func( false, *node_traits::to_value_ptr( *pos.pCur ), val );
+ return std::make_pair( iterator( pos.pCur ), false );
+ }
+ else {
+ // new key
+ if ( !bAllowInsert )
+ return std::make_pair( end(), false );
+
+ link_checker::is_empty( node_traits::to_node_ptr( val ) );
+
+ link_node( node_traits::to_node_ptr( val ), pos.pPred, pos.pCur );
+ func( true, val, val );
+ ++m_ItemCounter;
+ return std::make_pair( iterator( node_traits::to_node_ptr( val ) ), true );
+ }
+ }
+ }
+ }
+ }
+ //@endcond
};
}} // namespace cds::intrusive
projects / libcds.git / blobdiff