#define __CDS_CONTAINER_IMPL_SKIP_LIST_SET_H
#include <cds/details/binary_functor_wrapper.h>
-#include <cds/gc/guarded_ptr.h>
#include <cds/container/details/guarded_ptr_cast.h>
namespace cds { namespace container {
Template arguments:
- \p GC - Garbage collector used.
- \p T - type to be stored in the list.
- - \p Traits - type traits. See skip_list::type_traits for explanation.
-
- It is possible to declare option-based list with cds::container::skip_list::make_traits metafunction istead of \p Traits template
- argument.
- Template argument list \p Options of cds::container::skip_list::make_traits metafunction are:
- - opt::compare - key comparison functor. No default functor is provided.
- If the option is not specified, the opt::less is used.
- - opt::less - specifies binary predicate used for key comparison. Default is \p std::less<T>.
- - opt::item_counter - the type of item counting feature. Default is \ref atomicity::empty_item_counter that is no item counting.
- - opt::memory_model - C++ memory ordering model. Can be opt::v::relaxed_ordering (relaxed memory model, the default)
- or opt::v::sequential_consistent (sequentially consisnent memory model).
- - skip_list::random_level_generator - random level generator. Can be skip_list::xorshift, skip_list::turbo_pascal or
- user-provided one. See skip_list::random_level_generator option description for explanation.
- Default is \p %skip_list::turbo_pascal.
- - opt::allocator - allocator for skip-list node. Default is \ref CDS_DEFAULT_ALLOCATOR.
- - opt::back_off - back-off strategy used. If the option is not specified, the cds::backoff::Default is used.
- - opt::stat - internal statistics. Available types: skip_list::stat, skip_list::empty_stat (the default)
-
- \warning The skip-list requires up to 67 hazard pointers that may be critical for some GCs for which
- the guard count is limited (like as gc::HP, gc::HRC). Those GCs should be explicitly initialized with
+ - \p Traits - set traits, default is \p skip_list::traits.
+ It is possible to declare option-based list with \p cds::container::skip_list::make_traits metafunction
+ istead of \p Traits template argument.
+
+ @warning The skip-list requires up to 67 hazard pointers that may be critical for some GCs for which
+ the guard count is limited (like as \p gc::HP). Those GCs should be explicitly initialized with
hazard pointer enough: \code cds::gc::HP myhp( 67 ) \endcode. Otherwise an run-time exception may be raised
when you try to create skip-list object.
- \note There are several specializations of \p %SkipListSet for each \p GC. You should include:
- - <tt><cds/container/skip_list_set_hp.h></tt> for gc::HP garbage collector
- - <tt><cds/container/skip_list_set_ptb.h></tt> for gc::PTB garbage collector
+ @note There are several specializations of \p %SkipListSet for each \p GC. You should include:
+ - <tt><cds/container/skip_list_set_hp.h></tt> for \p gc::HP garbage collector
+ - <tt><cds/container/skip_list_set_dhp.h></tt> for \p gc::DHP garbage collector
- <tt><cds/container/skip_list_set_rcu.h></tt> for \ref cds_nonintrusive_SkipListSet_rcu "RCU type"
- <tt><cds/container/skip_list_set_nogc.h></tt> for \ref cds_nonintrusive_SkipListSet_nogc "non-deletable SkipListSet"
before end of the set. Therefore, such iteration is more suitable for debugging purpose only
Remember, each iterator object requires 2 additional hazard pointers, that may be
- a limited resource for \p GC like as gc::HP and gc::HRC (for gc::PTB the count of
+ a limited resource for \p GC like \p gc::HP (for \p gc::DHP the count of
guards is unlimited).
The iterator class supports the following minimalistic interface:
bool operator !=(iterator const& i ) const;
};
\endcode
- Note, the iterator object returned by \ref end, \p cend member functions points to \p nullptr and should not be dereferenced.
-
+ Note, the iterator object returned by \p end(), \p cend() member functions points to \p nullptr and should not be dereferenced.
*/
template <
typename GC,
typename T,
#ifdef CDS_DOXYGEN_INVOKED
- typename Traits = skip_list::type_traits
+ typename Traits = skip_list::traits
#else
typename Traits
#endif
#endif
{
//@cond
- typedef details::make_skip_list_set< GC, T, Traits > maker;
+ typedef details::make_skip_list_set< GC, T, Traits > maker;
typedef typename maker::type base_class;
//@endcond
public:
- typedef typename base_class::gc gc ; ///< Garbage collector used
- typedef T value_type ; ///< @anchor cds_containewr_SkipListSet_value_type Value type stored in the set
- typedef Traits options ; ///< Options specified
-
- typedef typename base_class::back_off back_off ; ///< Back-off strategy used
- typedef typename options::allocator allocator_type ; ///< Allocator type used for allocate/deallocate the skip-list nodes
- typedef typename base_class::item_counter item_counter ; ///< Item counting policy used
- typedef typename maker::key_comparator key_comparator ; ///< key comparison functor
- typedef typename base_class::memory_model memory_model ; ///< Memory ordering. See cds::opt::memory_model option
- typedef typename options::random_level_generator random_level_generator ; ///< random level generator
- typedef typename options::stat stat ; ///< internal statistics type
+ typedef GC gc; ///< Garbage collector used
+ typedef T value_type; ///< @anchor cds_containewr_SkipListSet_value_type Value type to be stored in the set
+ typedef Traits traits; ///< Options specified
+
+ typedef typename base_class::back_off back_off; ///< Back-off strategy
+ typedef typename traits::allocator allocator_type; ///< Allocator type used for allocate/deallocate the skip-list nodes
+ typedef typename base_class::item_counter item_counter; ///< Item counting policy used
+ typedef typename maker::key_comparator key_comparator; ///< key comparison functor
+ typedef typename base_class::memory_model memory_model; ///< Memory ordering. See cds::opt::memory_model option
+ typedef typename traits::random_level_generator random_level_generator; ///< random level generator
+ typedef typename traits::stat stat; ///< internal statistics type
protected:
//@cond
public:
/// Guarded pointer
- typedef cds::gc::guarded_ptr< gc, node_type, value_type, details::guarded_ptr_cast_set<node_type, value_type> > guarded_ptr;
+ typedef typename gc::template guarded_ptr< node_type, value_type, details::guarded_ptr_cast_set<node_type, value_type> > guarded_ptr;
protected:
//@cond
}
/// Returns a forward const iterator addressing the first element in a set
- const_iterator cbegin()
+ const_iterator cbegin() const
{
return const_iterator( base_class::cbegin() );
}
}
/// Returns a forward const iterator that addresses the location succeeding the last element in a set.
- const_iterator cend()
+ const_iterator cend() const
{
return const_iterator( base_class::cend() );
}
\endcode
where \p val is the item inserted. User-defined functor \p f should guarantee that during changing
\p val no any other changes could be made on this set's item by concurrent threads.
- The user-defined functor is called only if the inserting is success. It may be passed by reference
- using \p std::ref
+ The user-defined functor is called only if the inserting is success.
*/
template <typename Q, typename Func>
bool insert( Q const& val, Func f )
with arguments:
- \p bNew - \p true if the item has been inserted, \p false otherwise
- \p item - item of the set
- - \p val - argument \p key passed into the \p ensure function
+ - \p val - argument \p key passed into the \p %ensure() function
The functor may change non-key fields of the \p item; however, \p func must guarantee
that during changing no any other modifications could be made on this item by concurrent threads.
- You may pass \p func argument by reference using \p std::ref
-
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
already is in the set.
+
+ @warning See \ref cds_intrusive_item_creating "insert item troubleshooting"
*/
template <typename Q, typename Func>
std::pair<bool, bool> ensure( const Q& val, Func func )
return bRes;
}
- /// Inserts data of type \
ref cds_containewr_SkipListSet_value_type "value_type" constructed with <tt>std::forward<Args>(args)...</tt>
+ /// Inserts data of type \
p value_type created in-place from <tt>std::forward<Args>(args)...</tt>
/**
Returns \p true if inserting successful, \p false otherwise.
*/
template <typename Q, typename Less>
bool erase_with( Q const& key, Less pred )
{
+ CDS_UNUSED( pred );
return base_class::erase_with( key, cds::details::predicate_wrapper< node_type, Less, typename maker::value_accessor >() );
}
void operator()(value_type const& val);
};
\endcode
- The functor may be passed by reference using <tt>boost:ref</tt>
Since the key of \p value_type is not explicitly specified,
template parameter \p Q defines the key type to search in the list.
and the type \p Q.
Return \p true if key is found and deleted, \p false otherwise
-
- See also: \ref erase
*/
template <typename Q, typename Func>
bool erase( Q const& key, Func f )
template <typename Q, typename Less, typename Func>
bool erase_with( Q const& key, Less pred, Func f )
{
+ CDS_UNUSED( pred );
return base_class::erase_with( key, cds::details::predicate_wrapper< node_type, Less, typename maker::value_accessor >(),
[&f]( node_type const& node) { f( node.m_Value ); } );
}
/// Extracts the item from the set with specified \p key
/** \anchor cds_nonintrusive_SkipListSet_hp_extract
The function searches an item with key equal to \p key in the set,
- unlinks it from the set, and returns it in \p result parameter.
- If the item with key equal to \p key is not found the function returns \p false.
+ unlinks it from the set, and returns it as \p guarded_ptr.
+ If \p key is not found the function returns an empty guarded pointer.
Note the compare functor should accept a parameter of type \p Q that can be not the same as \p value_type.
The item extracted is freed automatically by garbage collector \p GC
- when returned \ref guarded_ptr object will be destroyed or released.
+ when returned \p guarded_ptr object will be destroyed or released.
@note Each \p guarded_ptr object uses the GC's guard that can be limited resource.
Usage:
skip_list theList;
// ...
{
- skip_list::guarded_ptr gp;
- if ( theList.extract( gp, 5 ) ) {
+ skip_list::guarded_ptr gp(theList.extract( 5 ))
+ if ( gp ) {
// Deal with gp
// ...
}
\endcode
*/
template <typename Q>
- bool extract( guarded_ptr& result, Q const& key )
+ guarded_ptr extract( Q const& key )
{
- return base_class::extract_( result.guard(), key, typename base_class::key_comparator() );
+ guarded_ptr gp;
+ base_class::extract_( gp.guard(), key, typename base_class::key_comparator() );
+ return gp;
}
/// Extracts the item from the set with comparing functor \p pred
\p pred must imply the same element order as the comparator used for building the set.
*/
template <typename Q, typename Less>
- bool extract_with( guarded_ptr& ptr, Q const& key, Less pred )
+ guarded_ptr extract_with( Q const& key, Less pred )
{
+ CDS_UNUSED( pred );
typedef cds::details::predicate_wrapper< node_type, Less, typename maker::value_accessor > wrapped_less;
- return base_class::extract_( ptr.guard(), key, cds::opt::details::make_comparator_from_less<wrapped_less>() );
+ guarded_ptr gp;
+ base_class::extract_( gp.guard(), key, cds::opt::details::make_comparator_from_less<wrapped_less>() );
+ return gp;
}
/// Extracts an item with minimal key from the set
/**
- The function searches an item with minimal key, unlinks it, and returns the item found in \p result parameter.
- If the skip-list is empty the function returns \p false.
+ The function searches an item with minimal key, unlinks it, and returns pointer to the item found as \p guarded_ptr.
+ If the skip-list is empty the function returns an empty guarded pointer.
The item extracted is freed automatically by garbage collector \p GC
- when returned \ref guarded_ptr object will be destroyed or released.
+ when returned \p guarded_ptr object will be destroyed or released.
@note Each \p guarded_ptr object uses the GC's guard that can be limited resource.
Usage:
skip_list theList;
// ...
{
- skip_list::guarded_ptr gp;
- if ( theList.extract_min( gp )) {
+ skip_list::guarded_ptr gp( theList.extract_min());
+ if ( gp ) {
// Deal with gp
//...
}
}
\endcode
*/
- bool extract_min( guarded_ptr& result)
+ guarded_ptr extract_min()
{
- return base_class::extract_min_( result.guard() );
+ guarded_ptr gp;
+ base_class::extract_min_( gp.guard() );
+ return gp;
}
/// Extracts an item with maximal key from the set
/**
- The function searches an item with maximal key, unlinks it, and returns the pointer to item found in \p result parameter.
- If the skip-list is empty the function returns \p false.
+ The function searches an item with maximal key, unlinks it, and returns the pointer to item found as \p guarded_ptr.
+ If the skip-list is empty the function returns an empty guarded pointer.
The item found is freed by garbage collector \p GC automatically
- when returned \ref guarded_ptr object will be destroyed or released.
+ when returned \p guarded_ptr object will be destroyed or released.
@note Each \p guarded_ptr object uses the GC's guard that can be limited resource.
Usage:
skip_list theList;
// ...
{
- skip_list::guarded_ptr gp;
- if ( theList.extract_max( gp )) {
+ skip_list::guarded_ptr gp( theList.extract_max());
+ if ( gp ) {
// Deal with gp
//...
}
}
\endcode
*/
- bool extract_max( guarded_ptr& result )
+ guarded_ptr extract_max()
{
- return base_class::extract_max_( result.guard() );
+ guarded_ptr gp;
+ base_class::extract_max_( gp.guard() );
+ return gp;
}
- /// Find the key \p val
+ /// Find the \p key
/** \anchor cds_nonintrusive_SkipListSet_find_func
- The function searches the item with key equal to \p val and calls the functor \p f for item found.
+ The function searches the item with key equal to \p key and calls the functor \p f for item found.
The interface of \p Func functor is:
\code
struct functor {
- void operator()( value_type& item, Q& val );
+ void operator()( value_type& item, Q& key );
};
\endcode
- where \p item is the item found, \p val is the <tt>find</tt> function argument.
-
- You may pass \p f argument by reference using \p std::ref
+ where \p item is the item found, \p key is the <tt>find</tt> function argument.
The functor may change non-key fields of \p item. Note that the functor is only guarantee
that \p item cannot be disposed during functor is executing.
The functor does not serialize simultaneous access to the set's \p item. If such access is
possible you must provide your own synchronization schema on item level to exclude unsafe item modifications.
- The \p val argument is non-const since it can be used as \p f functor destination i.e., the functor
- can modify both arguments.
-
Note the hash functor specified for class \p Traits template parameter
should accept a parameter of type \p Q that may be not the same as \p value_type.
- The function returns \p true if \p val is found, \p false otherwise.
+ The function returns \p true if \p key is found, \p false otherwise.
*/
template <typename Q, typename Func>
- bool find( Q& val, Func f )
+ bool find( Q& key, Func f )
+ {
+ return base_class::find( key, [&f]( node_type& node, Q& v ) { f( node.m_Value, v ); });
+ }
+ //@cond
+ template <typename Q, typename Func>
+ bool find( Q const& key, Func f )
{
- return base_class::find( val, [&f]( node_type& node, Q& v ) { f( node.m_Value, v ); });
+ return base_class::find( key, [&f]( node_type& node, Q& v ) { f( node.m_Value, v ); } );
}
+ //@endcond
- /// Finds the key \p val using \p pred predicate for searching
+ /// Finds \p key using \p pred predicate for searching
/**
The function is an analog of \ref cds_nonintrusive_SkipListSet_find_func "find(Q&, Func)"
but \p pred is used for key comparing.
\p Less must imply the same element order as the comparator used for building the set.
*/
template <typename Q, typename Less, typename Func>
- bool find_with( Q& val, Less pred, Func f )
+ bool find_with( Q& key, Less pred, Func f )
{
- return base_class::find_with( val, cds::details::predicate_wrapper< node_type, Less, typename maker::value_accessor >(),
+ CDS_UNUSED( pred );
+ return base_class::find_with( key, cds::details::predicate_wrapper< node_type, Less, typename maker::value_accessor >(),
[&f]( node_type& node, Q& v ) { f( node.m_Value, v ); } );
}
-
- /// Find the key \p val
- /** \anchor cds_nonintrusive_SkipListSet_find_cfunc
-
- The function searches the item with key equal to \p val and calls the functor \p f for item found.
- The interface of \p Func functor is:
- \code
- struct functor {
- void operator()( value_type& item, Q const& val );
- };
- \endcode
- where \p item is the item found, \p val is the <tt>find</tt> function argument.
-
- You may pass \p f argument by reference using \p std::ref
-
- The functor may change non-key fields of \p item. Note that the functor is only guarantee
- that \p item cannot be disposed during functor is executing.
- The functor does not serialize simultaneous access to the set's \p item. If such access is
- possible you must provide your own synchronization schema on item level to exclude unsafe item modifications.
-
- Note the hash functor specified for class \p Traits template parameter
- should accept a parameter of type \p Q that may be not the same as \p value_type.
-
- The function returns \p true if \p val is found, \p false otherwise.
- */
- template <typename Q, typename Func>
- bool find( Q const& val, Func f )
- {
- return base_class::find( val, [&f]( node_type& node, Q const& v ) { f( node.m_Value, v ); });
- }
-
- /// Finds the key \p val using \p pred predicate for searching
- /**
- The function is an analog of \ref cds_nonintrusive_SkipListSet_find_cfunc "find(Q const&, Func)"
- but \p pred is used for key comparing.
- \p Less functor has the interface like \p std::less.
- \p Less must imply the same element order as the comparator used for building the set.
- */
+ //@cond
template <typename Q, typename Less, typename Func>
- bool find_with( Q const& val, Less cmp, Func f )
+ bool find_with( Q const& key, Less pred, Func f )
{
- return base_class::find_with( val, cds::details::predicate_wrapper< node_type, Less, typename maker::value_accessor >(),
- [&f]( node_type& node, Q const& v ) { f( node.m_Value, v ); } );
+ CDS_UNUSED( pred );
+ return base_class::find_with( key, cds::details::predicate_wrapper< node_type, Less, typename maker::value_accessor >(),
+ [&f]( node_type& node, Q& v ) { f( node.m_Value, v ); } );
}
+ //@endcond
- /// Find the key \p val
+ /// Find \p key
/** \anchor cds_nonintrusive_SkipListSet_find_val
- The function searches the item with key equal to \p val
+ The function searches the item with key equal to \p key
and returns \p true if it is found, and \p false otherwise.
Note the hash functor specified for class \p Traits template parameter
should accept a parameter of type \p Q that may be not the same as \ref value_type.
*/
template <typename Q>
- bool find( Q const& val )
+ bool find( Q const& key )
{
- return base_class::find( val );
+ return base_class::find( key );
}
- /// Finds the key \p val using \p pred predicate for searching
+ /// Finds \p key using \p pred predicate for searching
/**
The function is an analog of \ref cds_nonintrusive_SkipListSet_find_val "find(Q const&)"
but \p pred is used for key comparing.
\p Less must imply the same element order as the comparator used for building the set.
*/
template <typename Q, typename Less>
- bool find_with( Q const& val, Less pred )
+ bool find_with( Q const& key, Less pred )
{
- return base_class::find_with( val, cds::details::predicate_wrapper< node_type, Less, typename maker::value_accessor >());
+ CDS_UNUSED( pred );
+ return base_class::find_with( key, cds::details::predicate_wrapper< node_type, Less, typename maker::value_accessor >());
}
/// Finds \p key and return the item found
/** \anchor cds_nonintrusive_SkipListSet_hp_get
The function searches the item with key equal to \p key
- and assigns the item found to guarded pointer \p result.
- The function returns \p true if \p key is found, and \p false otherwise.
- If \p key is not found the \p result parameter is left unchanged.
+ and returns a guarded pointer to the item found.
+ If \p key is not found the function returns an empty guarded pointer.
It is safe when a concurrent thread erases the item returned in \p result guarded pointer.
In this case the item will be freed later by garbage collector \p GC automatically
skip_list theList;
// ...
{
- skip_list::guarded_ptr gp;
- if ( theList.get( gp, 5 ) ) {
+ skip_list::guarded_ptr gp( theList.get( 5 ));
+ if ( theList.get( 5 )) {
// Deal with gp
//...
}
should accept a parameter of type \p Q that can be not the same as \p value_type.
*/
template <typename Q>
- bool get( guarded_ptr& result, Q const& key )
+ guarded_ptr get( Q const& key )
{
- return base_class::get_with_( result.guard(), key, typename base_class::key_comparator() );
+ guarded_ptr gp;
+ base_class::get_with_( gp.guard(), key, typename base_class::key_comparator() );
+ return gp;
}
/// Finds \p key and return the item found
/**
- The function is an analog of \ref cds_nonintrusive_SkipListSet_hp_get "get( guarded_ptr&, Q const&)"
+ The function is an analog of \ref cds_nonintrusive_SkipListSet_hp_get "get(Q const&)"
but \p pred is used for comparing the keys.
\p Less functor has the semantics like \p std::less but should take arguments of type \ref value_type and \p Q
\p pred must imply the same element order as the comparator used for building the set.
*/
template <typename Q, typename Less>
- bool get_with( guarded_ptr& result, Q const& key, Less pred )
+ guarded_ptr get_with( Q const& key, Less pred )
{
+ CDS_UNUSED( pred );
typedef cds::details::predicate_wrapper< node_type, Less, typename maker::value_accessor > wrapped_less;
- return base_class::get_with_( result.guard(), key, cds::opt::details::make_comparator_from_less< wrapped_less >());
+ guarded_ptr gp;
+ base_class::get_with_( gp.guard(), key, cds::opt::details::make_comparator_from_less< wrapped_less >());
+ return gp;
}
- /// Clears the set (non-atomic).
+ /// Clears the set (not atomic).
/**
The function deletes all items from the set.
The function is not atomic, thus, in multi-threaded environment with parallel insertions
/// Returns item count in the set
/**
The value returned depends on item counter type provided by \p Traits template parameter.
- If it is atomicity::empty_item_counter this function always returns 0.
- Therefore, the function is not suitable for checking the set emptiness, use \ref empty
+ If it is \p atomicity::empty_item_counter this function always returns 0.
+ Therefore, the function is not suitable for checking the set emptiness, use \p empty()
member function for this purpose.
*/
size_t size() const
{
return base_class::statistics();
}
-
};
}} // namespace cds::container
projects / libcds.git / blobdiff