return bRes;
}
//@cond
- // Deprecated, use update()
template <typename Q, typename Func>
+ CDS_DEPRECATED("ensure() is deprecated, use update()")
std::pair<bool, bool> ensure( const Q& val, Func func )
{
return update( val, func, true );
}
//@cond
template <typename Q, typename Func>
+ CDS_DEPRECATED("ensure() is deprecated, use update()")
std::pair<bool, bool> ensure( Q const& key, Func f )
{
return update( key, f, true );
return update_at( head(), key, func, bAllowInsert );
}
//@cond
- // Deprecated, use update()
template <typename Q, typename Func>
+ CDS_DEPRECATED("ensure() is deprecated, use update()")
std::pair<bool, bool> ensure( Q const& key, Func func )
{
return update( key, func );
return bRet;
}
- /// Ensures that the item exists in the set
+ /// Updates the element
/**
The operation performs inserting or changing data with lock-free manner.
- If the \p val key not found in the set, then the new item created from \p val
- is inserted into the set. Otherwise, the functor \p func is called with the item found.
- The functor \p Func signature is:
+ If the item \p val not found in the set, then \p val is inserted iff \p bAllowInsert is \p true.
+ Otherwise, the functor \p func is called with item found.
+ The functor signature is:
\code
- struct my_functor {
- void operator()( bool bNew, value_type& item, const Q& val );
+ struct functor {
+ void operator()( bool bNew, value_type& item, Q const& val );
};
\endcode
-
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 val passed into the \p %update() function
The functor may change non-key fields of the \p item.
- 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 set.
- @warning For \ref cds_nonintrusive_MichaelList_gc "MichaelList" as the bucket see \ref cds_intrusive_item_creating "insert item troubleshooting".
- @ref cds_nonintrusive_LazyList_gc "LazyList" provides exclusive access to inserted item and does not require any node-level
+ @warning For \ref cds_intrusive_MichaelList_hp "MichaelList" as the bucket see \ref cds_intrusive_item_creating "insert item troubleshooting".
+ \ref cds_intrusive_LazyList_hp "LazyList" provides exclusive access to inserted item and does not require any node-level
synchronization.
- */
+ */
template <typename Q, typename Func>
- std::pair<bool, bool> ensure( const Q& val, Func func )
+ std::pair<bool, bool> update( const Q& val, Func func, bool bAllowUpdate = true )
{
- std::pair<bool, bool> bRet = bucket( val ).ensure( val, func );
- if ( bRet.first && bRet.second )
+ std::pair<bool, bool> bRet = bucket( val ).update( val, func, bAllowUpdate );
+ if ( bRet.second )
++m_ItemCounter;
return bRet;
}
+ //@cond
+ template <typename Q, typename Func>
+ CDS_DEPRECATED("ensure() is deprecated, use update()")
+ std::pair<bool, bool> ensure( const Q& val, Func func )
+ {
+ return update( val, func, true );
+ }
+ //@endcond
/// Inserts data of type \p value_type constructed from \p args
/**
}
//@endcond
- /// Finds the key \p key
- /** \anchor cds_nonintrusive_MichaelSet_find_val
+ /// Checks whether the set contains \p key
+ /**
The function searches the item with key equal to \p key
- and returns \p true if it is found, and \p false otherwise.
+ and returns \p true if the key 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.
+ should accept a parameter of type \p Q that can be not the same as \p value_type.
*/
template <typename Q>
+ bool contains( Q const& key )
+ {
+ return bucket( key ).contains( key );
+ }
+ //@cond
+ template <typename Q>
+ CDS_DEPRECATED("use contains()")
bool find( Q const& key )
{
- return bucket( key ).find( key );
+ return contains( key );
}
+ //@endcond
- /// Finds the key \p key using \p pred predicate for searching
+ /// Checks whether the set contains \p key using \p pred predicate for searching
/**
- The function is an analog of \ref cds_nonintrusive_MichaelSet_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 Less must imply the same element order as the comparator used for building the set.
*/
template <typename Q, typename Less>
+ bool contains( Q const& key, Less pred )
+ {
+ return bucket( key ).contains( key, pred );
+ }
+ //@cond
+ template <typename Q, typename Less>
+ CDS_DEPRECATED("use contains()")
bool find_with( Q const& key, Less pred )
{
- return bucket( key ).find_with( key, pred );
+ return contains( key, pred );
}
+ //@endcond
/// Finds the key \p key and return the item found
/** \anchor cds_nonintrusive_MichaelHashSet_hp_get
return end();
}
- /// Ensures that the item \p val exists in the set
+ /// Updates the element
/**
- The operation inserts new item if the key \p val is not found in the set.
- Otherwise, the function returns an iterator that points to item found.
+ The operation performs inserting or changing data with lock-free manner.
+
+ If the item \p val not found in the set, then \p val is inserted iff \p bAllowInsert is \p true.
Returns <tt> std::pair<iterator, bool> </tt> where \p first is an iterator pointing to
- item found or inserted, \p second is true if new item has been added or \p false if the item
- already is in the set.
+ item found or inserted, or \p end() if \p bAllowInsert is \p false,
+ \p second is true if new item has been added or \p false if the item is already in the set.
- @warning For \ref cds_nonintrusive_MichaelList_nogc "MichaelList" as the bucket see \ref cds_intrusive_item_creating "insert item troubleshooting".
- \ref cds_nonintrusive_LazyList_nogc "LazyList" provides exclusive access to inserted item and does not require any node-level
+ @warning For \ref cds_intrusive_MichaelList_hp "MichaelList" as the bucket see \ref cds_intrusive_item_creating "insert item troubleshooting".
+ \ref cds_intrusive_LazyList_hp "LazyList" provides exclusive access to inserted item and does not require any node-level
synchronization.
*/
template <typename Q>
- std::pair<iterator, bool> ensure( const Q& val )
+ std::pair<iterator, bool> update( Q const& val, bool bAllowInsert = true )
{
bucket_type& refBucket = bucket( val );
- std::pair<bucket_iterator, bool> ret = refBucket.ensure( val );
+ std::pair<bucket_iterator, bool> ret = refBucket.update( val, bAllowInsert );
if ( ret.first != refBucket.end() ) {
if ( ret.second )
++m_ItemCounter;
return std::make_pair( iterator( ret.first, &refBucket, m_Buckets + bucket_count() ), ret.second );
}
-
return std::make_pair( end(), ret.second );
}
+ //@cond
+ template <typename Q>
+ CDS_DEPRECATED("ensure() is deprecated, use update()")
+ std::pair<iterator, bool> ensure( Q const& val )
+ {
+ return update( val, true );
+ }
+ //@endcond
- /// Find the key \p key
- /** \anchor cds_nonintrusive_MichealSet_nogc_find
+ /// Checks whether the set contains \p key
+ /**
The function searches the item with key equal to \p key
and returns an iterator pointed to item found if the key is found,
- and \ref end() otherwise
+ or \ref end() otherwise.
+
+ Note the hash functor specified for class \p Traits template parameter
+ should accept a parameter of type \p Q that can be not the same as \p value_type.
*/
template <typename Q>
- iterator find( Q const& key )
+ iterator contains( Q const& key )
{
bucket_type& refBucket = bucket( key );
- bucket_iterator it = refBucket.find( key );
+ bucket_iterator it = refBucket.contains( key );
if ( it != refBucket.end() )
return iterator( it, &refBucket, m_Buckets + bucket_count() );
return end();
}
+ //@cond
+ template <typename Q>
+ CDS_DEPRECATED("use contains()")
+ iterator find( Q const& key )
+ {
+ return contains( key );
+ }
+ //@endcond
- /// Finds the key \p val using \p pred predicate for searching
+ /// Checks whether the set contains \p key using \p pred predicate for searching
/**
- The function is an analog of \ref cds_nonintrusive_MichealSet_nogc_find "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 Less must imply the same element order as the comparator used for building the set.
*/
template <typename Q, typename Less>
- iterator find_with( Q const& key, Less pred )
+ iterator contains( Q const& key, Less pred )
{
bucket_type& refBucket = bucket( key );
- bucket_iterator it = refBucket.find_with( key, pred );
+ bucket_iterator it = refBucket.contains( key, pred );
if ( it != refBucket.end() )
return iterator( it, &refBucket, m_Buckets + bucket_count() );
return end();
}
+ //@cond
+ template <typename Q, typename Less>
+ CDS_DEPRECATED("use contains()")
+ iterator find_with( Q const& key, Less pred )
+ {
+ return contains( key, pred );
+ }
+ //@endcond
/// Clears the set (not atomic)
void clear()
\ref cds_nonintrusive_LazyList_rcu "LazyList" provides exclusive access to inserted item and does not require any node-level
synchronization.
*/
+ /// Updates the element
+ /**
+ The operation performs inserting or changing data with lock-free manner.
+
+ If the item \p val not found in the set, then \p val is inserted iff \p bAllowInsert is \p true.
+ Otherwise, the functor \p func is called with item found.
+ The functor signature is:
+ \code
+ struct functor {
+ void operator()( bool bNew, value_type& item, Q const& val );
+ };
+ \endcode
+ 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 val passed into the \p %update() function
+
+ The functor may change non-key fields of the \p item.
+
+ The function applies RCU lock internally.
+
+ 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 set.
+
+ @warning For \ref cds_intrusive_MichaelList_hp "MichaelList" as the bucket see \ref cds_intrusive_item_creating "insert item troubleshooting".
+ \ref cds_intrusive_LazyList_hp "LazyList" provides exclusive access to inserted item and does not require any node-level
+ synchronization.
+ */
template <typename Q, typename Func>
- std::pair<bool, bool> ensure( const Q& val, Func func )
+ std::pair<bool, bool> update( const Q& val, Func func, bool bAllowInsert = true )
{
- std::pair<bool, bool> bRet = bucket( val ).ensure( val, func );
- if ( bRet.first && bRet.second )
+ std::pair<bool, bool> bRet = bucket( val ).update( val, func, bAllowInsert );
+ if ( bRet.second )
++m_ItemCounter;
return bRet;
+ }//@cond
+ template <typename Q, typename Func>
+ CDS_DEPRECATED("ensure() is deprecated, use update()")
+ std::pair<bool, bool> ensure( const Q& val, Func func )
+ {
+ return update( val, func, true );
}
+ //@endcond
/// Inserts data of type \p value_type created from \p args
/**
}
//@endcond
- /// Finds the key \p key
- /** \anchor cds_nonintrusive_MichealSet_rcu_find_val
-
+ /// Checks whether the set contains \p key
+ /**
The function searches the item with key equal to \p key
- and returns \p true if it is found, and \p false otherwise.
+ and returns \p true if the key 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 \p value_type.
+ should accept a parameter of type \p Q that can be not the same as \p value_type.
*/
template <typename Q>
- bool find( Q const & key )
+ bool contains( Q const& key )
{
- return bucket( key ).find( key );
+ return bucket( key ).contains( key );
}
+ //@cond
+ template <typename Q>
+ CDS_DEPRECATED("use contains()")
+ bool find( Q const& key )
+ {
+ return contains( key );
+ }
+ //@endcond
- /// Finds the key \p key using \p pred predicate for searching
+ /// Checks whether the set contains \p key using \p pred predicate for searching
/**
- The function is an analog of \ref cds_nonintrusive_MichealSet_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 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 & key, Less pred )
+ bool contains( Q const& key, Less pred )
+ {
+ return bucket( key ).contains( key, pred );
+ }
+ //@cond
+ template <typename Q, typename Less>
+ CDS_DEPRECATED("use contains()")
+ bool find_with( Q const& key, Less pred )
{
- return bucket( key ).find_with( key, pred );
+ return contains( key, pred );
}
/// Finds the key \p key and return the item found
return bRet;
}
- /// Ensures that the \p val exists in the set
+ /// Updates the element
/**
The operation performs inserting or changing data with lock-free manner.
- If the item \p val not found in the set, then \p val is inserted into the set.
+ If the item \p val not found in the set, then \p val is inserted iff \p bAllowInsert is \p true.
Otherwise, the functor \p func is called with item found.
The functor signature is:
\code
- void func( bool bNew, value_type& item, value_type& val );
+ struct functor {
+ void operator()( bool bNew, value_type& item, value_type& val );
+ };
\endcode
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 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.
synchronization.
*/
template <typename Func>
- std::pair<bool, bool> ensure( value_type& val, Func func )
+ std::pair<bool, bool> update( value_type& val, Func func, bool bAllowInsert = true )
{
- std::pair<bool, bool> bRet = bucket( val ).ensure( val, func );
- if ( bRet.first && bRet.second )
+ std::pair<bool, bool> bRet = bucket( val ).update( val, func, bAllowInsert );
+ if ( bRet.second )
++m_ItemCounter;
return bRet;
}
+ //@cond
+ template <typename Func>
+ CDS_DEPRECATED("ensure() is deprecated, use update()")
+ std::pair<bool, bool> ensure( value_type& val, Func func )
+ {
+ return update( val, func, true );
+ }
+ //@endcond
/// Unlinks the item \p val from the set
/**
}
//@endcond
- /// Finds the key \p key
- /** \anchor cds_intrusive_MichaelHashSet_hp_find_val
+ /// Checks whether the set contains \p key
+ /**
The function searches the item with key equal to \p key
- and returns \p true if it is found, and \p false otherwise.
+ and returns \p true if the key 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 can be not the same as \p value_type.
*/
template <typename Q>
+ bool contains( Q const& key )
+ {
+ return bucket( key ).contains( key );
+ }
+ //@cond
+ template <typename Q>
+ CDS_DEPRECATED("use contains()")
bool find( Q const& key )
{
- return bucket( key ).find( key );
+ return contains( key );
}
+ //@endcond
- /// Finds the key \p key using \p pred predicate for searching
+ /// Checks whether the set contains \p key using \p pred predicate for searching
/**
- The function is an analog of \ref cds_intrusive_MichaelHashSet_hp_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 set.
+ \p Less must imply the same element order as the comparator used for building the set.
*/
template <typename Q, typename Less>
+ bool contains( Q const& key, Less pred )
+ {
+ return bucket( key ).contains( key, pred );
+ }
+ //@cond
+ template <typename Q, typename Less>
+ CDS_DEPRECATED("use contains()")
bool find_with( Q const& key, Less pred )
{
- return bucket( key ).find_with( key, pred );
+ return contains( key, pred );
}
+ //@endcond
/// Finds the key \p key and return the item found
/** \anchor cds_intrusive_MichaelHashSet_hp_get
return bRet;
}
- /// Ensures that the \p item exists in the set
+ /// Updates the element
/**
The operation performs inserting or changing data with lock-free manner.
- If the item \p val not found in the set, then \p val is inserted into the set.
+ If the item \p val not found in the set, then \p val is inserted iff \p bAllowInsert is \p true.
Otherwise, the functor \p func is called with item found.
The functor signature is:
\code
- void func( bool bNew, value_type& item, value_type& val );
+ struct functor {
+ void operator()( bool bNew, value_type& item, value_type& val );
+ };
\endcode
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 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.
- The functor can change non-key fields of the \p item.
+ The functor may change non-key fields of the \p item.
- Returns std::pair<bool, bool> where \p first is \p true if operation is successfull,
+ 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 set.
@warning For \ref cds_intrusive_MichaelList_hp "MichaelList" as the bucket see \ref cds_intrusive_item_creating "insert item troubleshooting".
- \ref cds_intrusive_LazyList_nogc "LazyList" provides exclusive access to inserted item and does not require any node-level
+ \ref cds_intrusive_LazyList_hp "LazyList" provides exclusive access to inserted item and does not require any node-level
synchronization.
*/
template <typename Func>
- std::pair<bool, bool> ensure( value_type& val, Func func )
+ std::pair<bool, bool> update( value_type& val, Func func, bool bAllowInsert = true )
{
- std::pair<bool, bool> bRet = bucket( val ).ensure( val, func );
- if ( bRet.first && bRet.second )
+ std::pair<bool, bool> bRet = bucket( val ).update( val, func, bAllowInsert );
+ if ( bRet.second )
++m_ItemCounter;
return bRet;
}
+ //@cond
+ template <typename Func>
+ CDS_DEPRECATED("ensure() is deprecated, use update()")
+ std::pair<bool, bool> ensure( value_type& val, Func func )
+ {
+ return update( val, func, true );
+ }
+ //@endcond
- /// Finds the key \p key
- /** \anchor cds_intrusive_MichaelHashSet_nogc_find_val
+ /// Checks whether the set contains \p key
+ /**
The function searches the item with key equal to \p key
- and returns pointer to item found, otherwise \p nullptr.
+ and returns the pointer to an element found or \p nullptr.
Note the hash functor specified for class \p Traits template parameter
should accept a parameter of type \p Q that can be not the same as \p value_type.
*/
template <typename Q>
+ value_type * contains( Q const& key )
+ {
+ return bucket( key ).contains( key );
+ }
+ //@cond
+ template <typename Q>
+ CDS_DEPRECATED("use contains()")
value_type * find( Q const& key )
{
- return bucket( key ).find( key );
+ return contains( key );
}
+ //@endcond
- /// Finds the key \p key using \p pred predicate for searching
+ /// Checks whether the set contains \p key using \p pred predicate for searching
/**
- The function is an analog of \ref cds_intrusive_MichaelHashSet_nogc_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 set.
+ \p Less must imply the same element order as the comparator used for building the set.
*/
template <typename Q, typename Less>
+ value_type * contains( Q const& key, Less pred )
+ {
+ return bucket( key ).contains( key, pred );
+ }
+ //@cond
+ template <typename Q, typename Less>
+ CDS_DEPRECATED("use contains()")
value_type * find_with( Q const& key, Less pred )
{
- return bucket( key ).find_with( key, pred );
+ return contains( key );
}
+ //@endcond
/// Finds the key \p key
/** \anchor cds_intrusive_MichaelHashSet_nogc_find_func
return bRet;
}
- /// Ensures that the \p item exists in the set
+ /// Updates the element
/**
The operation performs inserting or changing data with lock-free manner.
- If the item \p val not found in the set, then \p val is inserted into the set.
+ If the item \p val not found in the set, then \p val is inserted iff \p bAllowInsert is \p true.
Otherwise, the functor \p func is called with item found.
The functor signature is:
\code
- void func( bool bNew, value_type& item, value_type& val );
+ struct functor {
+ void operator()( bool bNew, value_type& item, value_type& val );
+ };
\endcode
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 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.
- The functor can change non-key fields of the \p item.
+ The functor may change non-key fields of the \p item.
- Returns std::pair<bool, bool> where \p first is \p true if operation is successfull,
+ 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 set.
- @warning For \ref cds_intrusive_MichaelList_rcu "MichaelList" as the bucket see \ref cds_intrusive_item_creating "insert item troubleshooting".
- \ref cds_intrusive_LazyList_rcu "LazyList" provides exclusive access to inserted item and does not require any node-level
+ @warning For \ref cds_intrusive_MichaelList_hp "MichaelList" as the bucket see \ref cds_intrusive_item_creating "insert item troubleshooting".
+ \ref cds_intrusive_LazyList_hp "LazyList" provides exclusive access to inserted item and does not require any node-level
synchronization.
- */
+ */
template <typename Func>
- std::pair<bool, bool> ensure( value_type& val, Func func )
+ std::pair<bool, bool> update( value_type& val, Func func, bool bAllowInsert = true )
{
- std::pair<bool, bool> bRet = bucket( val ).ensure( val, func );
- if ( bRet.first && bRet.second )
+ std::pair<bool, bool> bRet = bucket( val ).update( val, func, bAllowInsert );
+ if ( bRet.second )
++m_ItemCounter;
return bRet;
}
+ //@cond
+ template <typename Func>
+ CDS_DEPRECATED("ensure() is deprecated, use update()")
+ std::pair<bool, bool> ensure( value_type& val, Func func )
+ {
+ return update( val, func, true );
+ }
+ //@endcond
/// Unlinks the item \p val from the set
/**
return p;
}
- /// Finds the key \p key
- /** \anchor cds_intrusive_MichaelHashSet_rcu_find_val
+ /// Checks whether the set 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 the key 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 can be not the same as \p value_type.
*/
template <typename Q>
+ bool contains( Q const& key )
+ {
+ return bucket( key ).contains( key );
+ }
+ //@cond
+ template <typename Q>
+ CDS_DEPRECATED("use contains()")
bool find( Q const& key )
{
- return bucket( key ).find( key );
+ return contains( key );
}
+ //@endcond
- /// Finds the key \p key using \p pred predicate for searching
+ /// Checks whether the set contains \p key using \p pred predicate for searching
/**
- The function is an analog of \ref cds_intrusive_MichaelHashSet_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 set.
+ \p Less must imply the same element order as the comparator used for building the set.
*/
template <typename Q, typename Less>
+ bool contains( Q const& key, Less pred )
+ {
+ return bucket( key ).contains( key, pred );
+ }
+ //@cond
+ template <typename Q, typename Less>
+ CDS_DEPRECATED("use contains()")
bool find_with( Q const& key, Less pred )
{
- return bucket( key ).find_with( key, pred );
+ return contains( key, pred );
}
+ //@endcond
/// Find the key \p key
/** \anchor cds_intrusive_MichaelHashSet_rcu_find_func
CPPUNIT_TEST_SUITE_REGISTRATION( Map_DelOdd );
void Map_DelOdd::setUpParams( const CppUnitMini::TestCfg& cfg ) {
- c_nMapSize = cfg.getULong("MapSize", static_cast<unsigned long>(c_nMapSize) );
- c_nInsThreadCount = cfg.getULong("InsThreadCount", static_cast<unsigned long>(c_nInsThreadCount) );
- c_nDelThreadCount = cfg.getULong("DelThreadCount", static_cast<unsigned long>(c_nDelThreadCount) );
- c_nExtractThreadCount = cfg.getULong("ExtractThreadCount", static_cast<unsigned long>(c_nExtractThreadCount) );
- c_nMaxLoadFactor = cfg.getULong("MaxLoadFactor", static_cast<unsigned long>(c_nMaxLoadFactor) );
+ c_nMapSize = cfg.getSizeT("MapSize", c_nMapSize );
+ c_nInsThreadCount = cfg.getSizeT("InsThreadCount", c_nInsThreadCount );
+ c_nDelThreadCount = cfg.getSizeT("DelThreadCount", c_nDelThreadCount );
+ c_nExtractThreadCount = cfg.getSizeT("ExtractThreadCount", c_nExtractThreadCount );
+ c_nMaxLoadFactor = cfg.getSizeT("MaxLoadFactor", c_nMaxLoadFactor );
c_bPrintGCState = cfg.getBool("PrintGCStateFlag", true );
- c_nCuckooInitialSize = cfg.getULong("CuckooInitialSize", static_cast<unsigned long>(c_nCuckooInitialSize) );
- c_nCuckooProbesetSize = cfg.getULong("CuckooProbesetSize", static_cast<unsigned long>(c_nCuckooProbesetSize) );
- c_nCuckooProbesetThreshold = cfg.getULong("CuckooProbesetThreshold", static_cast<unsigned long>(c_nCuckooProbesetThreshold) );
+ c_nCuckooInitialSize = cfg.getSizeT("CuckooInitialSize", c_nCuckooInitialSize );
+ c_nCuckooProbesetSize = cfg.getSizeT("CuckooProbesetSize", c_nCuckooProbesetSize );
+ c_nCuckooProbesetThreshold = cfg.getSizeT("CuckooProbesetThreshold", c_nCuckooProbesetThreshold );
if ( c_nInsThreadCount == 0 )
size_t c_nMaxLoadFactor = 8; // maximum load factor
size_t c_nCuckooInitialSize = 1024;// initial size for CuckooMap
size_t c_nCuckooProbesetSize = 16; // CuckooMap probeset size (only for list-based probeset)
- size_t c_nCuckooProbesetThreshold = 0; // CUckooMap probeset threshold (o - use default)
+ size_t c_nCuckooProbesetThreshold = 0; // CUckooMap probeset threshold (0 - use default)
bool c_bPrintGCState = true;
#ifdef CDS_URCU_SIGNAL_HANDLING_ENABLED
# define CDSUNIT_DECLARE_MichaelSet_RCU_signal \
- CDSUNIT_DECLARE_TEST(MichaelSet_RCU_SHB_cmp_stdAlloc) \
- CDSUNIT_DECLARE_TEST(MichaelSet_RCU_SHB_less_michaelAlloc) \
- CDSUNIT_DECLARE_TEST(MichaelSet_RCU_SHT_cmp_stdAlloc) \
- CDSUNIT_DECLARE_TEST(MichaelSet_RCU_SHT_less_michaelAlloc) \
- CDSUNIT_DECLARE_TEST(MichaelSet_Lazy_RCU_SHB_cmp_stdAlloc) \
- CDSUNIT_DECLARE_TEST(MichaelSet_Lazy_RCU_SHB_less_michaelAlloc) \
- CDSUNIT_DECLARE_TEST(MichaelSet_Lazy_RCU_SHT_cmp_stdAlloc) \
- CDSUNIT_DECLARE_TEST(MichaelSet_Lazy_RCU_SHT_less_michaelAlloc)
-
-# define CDSUNIT_DEFINE_MichaelSet_RCU_signal(IMPL, C ) \
- TEST_SET_EXTRACT(IMPL, C, MichaelSet_RCU_SHB_cmp_stdAlloc) \
- TEST_SET_EXTRACT(IMPL, C, MichaelSet_RCU_SHB_less_michaelAlloc) \
- TEST_SET_EXTRACT(IMPL, C, MichaelSet_RCU_SHT_cmp_stdAlloc) \
- TEST_SET_EXTRACT(IMPL, C, MichaelSet_RCU_SHT_less_michaelAlloc) \
- TEST_SET_EXTRACT(IMPL, C, MichaelSet_Lazy_RCU_SHB_cmp_stdAlloc) \
- TEST_SET_EXTRACT(IMPL, C, MichaelSet_Lazy_RCU_SHB_less_michaelAlloc) \
- TEST_SET_EXTRACT(IMPL, C, MichaelSet_Lazy_RCU_SHT_cmp_stdAlloc) \
- TEST_SET_EXTRACT(IMPL, C, MichaelSet_Lazy_RCU_SHT_less_michaelAlloc)
+ TEST_CASE(tag_MichaelHashSet, MichaelSet_RCU_SHB_cmp_stdAlloc) \
+ TEST_CASE(tag_MichaelHashSet, MichaelSet_RCU_SHB_less_michaelAlloc) \
+ TEST_CASE(tag_MichaelHashSet, MichaelSet_RCU_SHT_cmp_stdAlloc) \
+ TEST_CASE(tag_MichaelHashSet, MichaelSet_RCU_SHT_less_michaelAlloc) \
+ TEST_CASE(tag_MichaelHashSet, MichaelSet_Lazy_RCU_SHB_cmp_stdAlloc) \
+ TEST_CASE(tag_MichaelHashSet, MichaelSet_Lazy_RCU_SHB_less_michaelAlloc) \
+ TEST_CASE(tag_MichaelHashSet, MichaelSet_Lazy_RCU_SHT_cmp_stdAlloc) \
+ TEST_CASE(tag_MichaelHashSet, MichaelSet_Lazy_RCU_SHT_less_michaelAlloc)
# define CDSUNIT_TEST_MichaelSet_RCU_signal \
CPPUNIT_TEST(MichaelSet_RCU_SHB_cmp_stdAlloc) \
CPPUNIT_TEST(MichaelSet_Lazy_RCU_SHT_less_michaelAlloc)
#else
# define CDSUNIT_DECLARE_MichaelSet_RCU_signal
-# define CDSUNIT_DEFINE_MichaelSet_RCU_signal(IMPL, C )
# define CDSUNIT_TEST_MichaelSet_RCU_signal
#endif
#define CDSUNIT_DECLARE_MichaelSet \
- CDSUNIT_DECLARE_TEST(MichaelSet_HP_cmp_stdAlloc) \
- CDSUNIT_DECLARE_TEST(MichaelSet_HP_less_michaelAlloc) \
- CDSUNIT_DECLARE_TEST(MichaelSet_DHP_cmp_stdAlloc) \
- CDSUNIT_DECLARE_TEST(MichaelSet_DHP_less_michaelAlloc) \
- CDSUNIT_DECLARE_TEST(MichaelSet_RCU_GPI_cmp_stdAlloc) \
- CDSUNIT_DECLARE_TEST(MichaelSet_RCU_GPI_less_michaelAlloc) \
- CDSUNIT_DECLARE_TEST(MichaelSet_RCU_GPB_cmp_stdAlloc) \
- CDSUNIT_DECLARE_TEST(MichaelSet_RCU_GPB_less_michaelAlloc) \
- CDSUNIT_DECLARE_TEST(MichaelSet_RCU_GPT_cmp_stdAlloc) \
- CDSUNIT_DECLARE_TEST(MichaelSet_RCU_GPT_less_michaelAlloc) \
- CDSUNIT_DECLARE_TEST(MichaelSet_Lazy_HP_cmp_stdAlloc) \
- CDSUNIT_DECLARE_TEST(MichaelSet_Lazy_HP_less_michaelAlloc) \
- CDSUNIT_DECLARE_TEST(MichaelSet_Lazy_DHP_cmp_stdAlloc) \
- CDSUNIT_DECLARE_TEST(MichaelSet_Lazy_DHP_less_michaelAlloc) \
- CDSUNIT_DECLARE_TEST(MichaelSet_Lazy_RCU_GPI_cmp_stdAlloc) \
- CDSUNIT_DECLARE_TEST(MichaelSet_Lazy_RCU_GPI_less_michaelAlloc) \
- CDSUNIT_DECLARE_TEST(MichaelSet_Lazy_RCU_GPB_cmp_stdAlloc) \
- CDSUNIT_DECLARE_TEST(MichaelSet_Lazy_RCU_GPB_less_michaelAlloc) \
- CDSUNIT_DECLARE_TEST(MichaelSet_Lazy_RCU_GPT_cmp_stdAlloc) \
- CDSUNIT_DECLARE_TEST(MichaelSet_Lazy_RCU_GPT_less_michaelAlloc) \
+ TEST_CASE(tag_MichaelHashSet, MichaelSet_HP_cmp_stdAlloc) \
+ TEST_CASE(tag_MichaelHashSet, MichaelSet_HP_less_michaelAlloc) \
+ TEST_CASE(tag_MichaelHashSet, MichaelSet_DHP_cmp_stdAlloc) \
+ TEST_CASE(tag_MichaelHashSet, MichaelSet_DHP_less_michaelAlloc) \
+ TEST_CASE(tag_MichaelHashSet, MichaelSet_RCU_GPI_cmp_stdAlloc) \
+ TEST_CASE(tag_MichaelHashSet, MichaelSet_RCU_GPI_less_michaelAlloc) \
+ TEST_CASE(tag_MichaelHashSet, MichaelSet_RCU_GPB_cmp_stdAlloc) \
+ TEST_CASE(tag_MichaelHashSet, MichaelSet_RCU_GPB_less_michaelAlloc) \
+ TEST_CASE(tag_MichaelHashSet, MichaelSet_RCU_GPT_cmp_stdAlloc) \
+ TEST_CASE(tag_MichaelHashSet, MichaelSet_RCU_GPT_less_michaelAlloc) \
+ TEST_CASE(tag_MichaelHashSet, MichaelSet_Lazy_HP_cmp_stdAlloc) \
+ TEST_CASE(tag_MichaelHashSet, MichaelSet_Lazy_HP_less_michaelAlloc) \
+ TEST_CASE(tag_MichaelHashSet, MichaelSet_Lazy_DHP_cmp_stdAlloc) \
+ TEST_CASE(tag_MichaelHashSet, MichaelSet_Lazy_DHP_less_michaelAlloc) \
+ TEST_CASE(tag_MichaelHashSet, MichaelSet_Lazy_RCU_GPI_cmp_stdAlloc) \
+ TEST_CASE(tag_MichaelHashSet, MichaelSet_Lazy_RCU_GPI_less_michaelAlloc) \
+ TEST_CASE(tag_MichaelHashSet, MichaelSet_Lazy_RCU_GPB_cmp_stdAlloc) \
+ TEST_CASE(tag_MichaelHashSet, MichaelSet_Lazy_RCU_GPB_less_michaelAlloc) \
+ TEST_CASE(tag_MichaelHashSet, MichaelSet_Lazy_RCU_GPT_cmp_stdAlloc) \
+ TEST_CASE(tag_MichaelHashSet, MichaelSet_Lazy_RCU_GPT_less_michaelAlloc) \
CDSUNIT_DECLARE_MichaelSet_RCU_signal
-#define CDSUNIT_DEFINE_MichaelSet( IMPL, C ) \
- TEST_SET_EXTRACT(IMPL, C, MichaelSet_HP_cmp_stdAlloc) \
- TEST_SET_EXTRACT(IMPL, C, MichaelSet_HP_less_michaelAlloc) \
- TEST_SET_EXTRACT(IMPL, C, MichaelSet_DHP_cmp_stdAlloc) \
- TEST_SET_EXTRACT(IMPL, C, MichaelSet_DHP_less_michaelAlloc) \
- TEST_SET_EXTRACT(IMPL, C, MichaelSet_RCU_GPI_cmp_stdAlloc) \
- TEST_SET_EXTRACT(IMPL, C, MichaelSet_RCU_GPI_less_michaelAlloc) \
- TEST_SET_EXTRACT(IMPL, C, MichaelSet_RCU_GPB_cmp_stdAlloc) \
- TEST_SET_EXTRACT(IMPL, C, MichaelSet_RCU_GPB_less_michaelAlloc) \
- TEST_SET_EXTRACT(IMPL, C, MichaelSet_RCU_GPT_cmp_stdAlloc) \
- TEST_SET_EXTRACT(IMPL, C, MichaelSet_RCU_GPT_less_michaelAlloc) \
- TEST_SET_EXTRACT(IMPL, C, MichaelSet_Lazy_HP_cmp_stdAlloc) \
- TEST_SET_EXTRACT(IMPL, C, MichaelSet_Lazy_HP_less_michaelAlloc) \
- TEST_SET_EXTRACT(IMPL, C, MichaelSet_Lazy_DHP_cmp_stdAlloc) \
- TEST_SET_EXTRACT(IMPL, C, MichaelSet_Lazy_DHP_less_michaelAlloc) \
- TEST_SET_EXTRACT(IMPL, C, MichaelSet_Lazy_RCU_GPI_cmp_stdAlloc) \
- TEST_SET_EXTRACT(IMPL, C, MichaelSet_Lazy_RCU_GPI_less_michaelAlloc) \
- TEST_SET_EXTRACT(IMPL, C, MichaelSet_Lazy_RCU_GPB_cmp_stdAlloc) \
- TEST_SET_EXTRACT(IMPL, C, MichaelSet_Lazy_RCU_GPB_less_michaelAlloc) \
- TEST_SET_EXTRACT(IMPL, C, MichaelSet_Lazy_RCU_GPT_cmp_stdAlloc) \
- TEST_SET_EXTRACT(IMPL, C, MichaelSet_Lazy_RCU_GPT_less_michaelAlloc) \
- CDSUNIT_DEFINE_MichaelSet_RCU_signal(IMPL, C)
-
#define CDSUNIT_TEST_MichaelSet \
CPPUNIT_TEST(MichaelSet_HP_cmp_stdAlloc) \
CPPUNIT_TEST(MichaelSet_HP_less_michaelAlloc) \
#ifdef CDS_URCU_SIGNAL_HANDLING_ENABLED
# define CDSUNIT_DECLARE_SplitList_RCU_signal \
- CDSUNIT_DECLARE_TEST(SplitList_Michael_RCU_SHB_dyn_cmp)\
- CDSUNIT_DECLARE_TEST(SplitList_Michael_RCU_SHB_dyn_cmp_stat)\
- CDSUNIT_DECLARE_TEST(SplitList_Michael_RCU_SHB_st_cmp)\
- CDSUNIT_DECLARE_TEST(SplitList_Michael_RCU_SHB_dyn_less)\
- CDSUNIT_DECLARE_TEST(SplitList_Michael_RCU_SHB_st_less)\
- CDSUNIT_DECLARE_TEST(SplitList_Michael_RCU_SHB_st_less_stat)\
- CDSUNIT_DECLARE_TEST(SplitList_Michael_RCU_SHT_dyn_cmp)\
- CDSUNIT_DECLARE_TEST(SplitList_Michael_RCU_SHT_dyn_cmp_stat)\
- CDSUNIT_DECLARE_TEST(SplitList_Michael_RCU_SHT_st_cmp)\
- CDSUNIT_DECLARE_TEST(SplitList_Michael_RCU_SHT_dyn_less)\
- CDSUNIT_DECLARE_TEST(SplitList_Michael_RCU_SHT_st_less)\
- CDSUNIT_DECLARE_TEST(SplitList_Michael_RCU_SHT_st_less_stat)\
- CDSUNIT_DECLARE_TEST(SplitList_Lazy_RCU_SHB_dyn_cmp)\
- CDSUNIT_DECLARE_TEST(SplitList_Lazy_RCU_SHB_dyn_cmp_stat)\
- CDSUNIT_DECLARE_TEST(SplitList_Lazy_RCU_SHB_st_cmp)\
- CDSUNIT_DECLARE_TEST(SplitList_Lazy_RCU_SHB_dyn_less)\
- CDSUNIT_DECLARE_TEST(SplitList_Lazy_RCU_SHB_st_less)\
- CDSUNIT_DECLARE_TEST(SplitList_Lazy_RCU_SHB_st_less_stat)\
- CDSUNIT_DECLARE_TEST(SplitList_Lazy_RCU_SHT_dyn_cmp)\
- CDSUNIT_DECLARE_TEST(SplitList_Lazy_RCU_SHT_dyn_cmp_stat)\
- CDSUNIT_DECLARE_TEST(SplitList_Lazy_RCU_SHT_st_cmp)\
- CDSUNIT_DECLARE_TEST(SplitList_Lazy_RCU_SHT_dyn_less)\
- CDSUNIT_DECLARE_TEST(SplitList_Lazy_RCU_SHT_st_less)\
- CDSUNIT_DECLARE_TEST(SplitList_Lazy_RCU_SHT_st_less_stat)
-
-# define CDSUNIT_DEFINE_SplitList_RCU_signal( IMPL, C ) \
- TEST_SET_EXTRACT( IMPL, C, SplitList_Michael_RCU_SHB_dyn_cmp)\
- TEST_SET_EXTRACT( IMPL, C, SplitList_Michael_RCU_SHB_dyn_cmp_stat)\
- TEST_SET_EXTRACT( IMPL, C, SplitList_Michael_RCU_SHB_st_cmp)\
- TEST_SET_EXTRACT( IMPL, C, SplitList_Michael_RCU_SHB_dyn_less)\
- TEST_SET_EXTRACT( IMPL, C, SplitList_Michael_RCU_SHB_st_less)\
- TEST_SET_EXTRACT( IMPL, C, SplitList_Michael_RCU_SHB_st_less_stat)\
- TEST_SET_EXTRACT( IMPL, C, SplitList_Michael_RCU_SHT_dyn_cmp)\
- TEST_SET_EXTRACT( IMPL, C, SplitList_Michael_RCU_SHT_dyn_cmp_stat)\
- TEST_SET_EXTRACT( IMPL, C, SplitList_Michael_RCU_SHT_st_cmp)\
- TEST_SET_EXTRACT( IMPL, C, SplitList_Michael_RCU_SHT_dyn_less)\
- TEST_SET_EXTRACT( IMPL, C, SplitList_Michael_RCU_SHT_st_less)\
- TEST_SET_EXTRACT( IMPL, C, SplitList_Michael_RCU_SHT_st_less_stat)\
- TEST_SET_EXTRACT( IMPL, C, SplitList_Lazy_RCU_SHB_dyn_cmp)\
- TEST_SET_EXTRACT( IMPL, C, SplitList_Lazy_RCU_SHB_dyn_cmp_stat)\
- TEST_SET_EXTRACT( IMPL, C, SplitList_Lazy_RCU_SHB_st_cmp)\
- TEST_SET_EXTRACT( IMPL, C, SplitList_Lazy_RCU_SHB_dyn_less)\
- TEST_SET_EXTRACT( IMPL, C, SplitList_Lazy_RCU_SHB_st_less)\
- TEST_SET_EXTRACT( IMPL, C, SplitList_Lazy_RCU_SHB_st_less_stat)\
- TEST_SET_EXTRACT( IMPL, C, SplitList_Lazy_RCU_SHT_dyn_cmp)\
- TEST_SET_EXTRACT( IMPL, C, SplitList_Lazy_RCU_SHT_dyn_cmp_stat)\
- TEST_SET_EXTRACT( IMPL, C, SplitList_Lazy_RCU_SHT_st_cmp)\
- TEST_SET_EXTRACT( IMPL, C, SplitList_Lazy_RCU_SHT_dyn_less)\
- TEST_SET_EXTRACT( IMPL, C, SplitList_Lazy_RCU_SHT_st_less)\
- TEST_SET_EXTRACT( IMPL, C, SplitList_Lazy_RCU_SHT_st_less_stat)
+ TEST_CASE(tag_SplitListSet, SplitList_Michael_RCU_SHB_dyn_cmp)\
+ TEST_CASE(tag_SplitListSet, SplitList_Michael_RCU_SHB_dyn_cmp_stat)\
+ TEST_CASE(tag_SplitListSet, SplitList_Michael_RCU_SHB_st_cmp)\
+ TEST_CASE(tag_SplitListSet, SplitList_Michael_RCU_SHB_dyn_less)\
+ TEST_CASE(tag_SplitListSet, SplitList_Michael_RCU_SHB_st_less)\
+ TEST_CASE(tag_SplitListSet, SplitList_Michael_RCU_SHB_st_less_stat)\
+ TEST_CASE(tag_SplitListSet, SplitList_Michael_RCU_SHT_dyn_cmp)\
+ TEST_CASE(tag_SplitListSet, SplitList_Michael_RCU_SHT_dyn_cmp_stat)\
+ TEST_CASE(tag_SplitListSet, SplitList_Michael_RCU_SHT_st_cmp)\
+ TEST_CASE(tag_SplitListSet, SplitList_Michael_RCU_SHT_dyn_less)\
+ TEST_CASE(tag_SplitListSet, SplitList_Michael_RCU_SHT_st_less)\
+ TEST_CASE(tag_SplitListSet, SplitList_Michael_RCU_SHT_st_less_stat)\
+ TEST_CASE(tag_SplitListSet, SplitList_Lazy_RCU_SHB_dyn_cmp)\
+ TEST_CASE(tag_SplitListSet, SplitList_Lazy_RCU_SHB_dyn_cmp_stat)\
+ TEST_CASE(tag_SplitListSet, SplitList_Lazy_RCU_SHB_st_cmp)\
+ TEST_CASE(tag_SplitListSet, SplitList_Lazy_RCU_SHB_dyn_less)\
+ TEST_CASE(tag_SplitListSet, SplitList_Lazy_RCU_SHB_st_less)\
+ TEST_CASE(tag_SplitListSet, SplitList_Lazy_RCU_SHB_st_less_stat)\
+ TEST_CASE(tag_SplitListSet, SplitList_Lazy_RCU_SHT_dyn_cmp)\
+ TEST_CASE(tag_SplitListSet, SplitList_Lazy_RCU_SHT_dyn_cmp_stat)\
+ TEST_CASE(tag_SplitListSet, SplitList_Lazy_RCU_SHT_st_cmp)\
+ TEST_CASE(tag_SplitListSet, SplitList_Lazy_RCU_SHT_dyn_less)\
+ TEST_CASE(tag_SplitListSet, SplitList_Lazy_RCU_SHT_st_less)\
+ TEST_CASE(tag_SplitListSet, SplitList_Lazy_RCU_SHT_st_less_stat)
# define CDSUNIT_TEST_SplitList_RCU_signal \
CPPUNIT_TEST(SplitList_Michael_RCU_SHB_dyn_cmp)\
#else
# define CDSUNIT_DECLARE_SplitList_RCU_signal
-# define CDSUNIT_DEFINE_SplitList_RCU_signal( IMPL, C )
# define CDSUNIT_TEST_SplitList_RCU_signal
#endif
#define CDSUNIT_DECLARE_SplitList \
- CDSUNIT_DECLARE_TEST(SplitList_Michael_HP_dyn_cmp)\
- CDSUNIT_DECLARE_TEST(SplitList_Michael_HP_dyn_cmp_stat)\
- CDSUNIT_DECLARE_TEST(SplitList_Michael_HP_st_cmp)\
- CDSUNIT_DECLARE_TEST(SplitList_Michael_HP_dyn_less)\
- CDSUNIT_DECLARE_TEST(SplitList_Michael_HP_st_less)\
- CDSUNIT_DECLARE_TEST(SplitList_Michael_HP_st_less_stat)\
- CDSUNIT_DECLARE_TEST(SplitList_Michael_DHP_dyn_cmp)\
- CDSUNIT_DECLARE_TEST(SplitList_Michael_DHP_dyn_cmp_stat)\
- CDSUNIT_DECLARE_TEST(SplitList_Michael_DHP_st_cmp)\
- CDSUNIT_DECLARE_TEST(SplitList_Michael_DHP_dyn_less)\
- CDSUNIT_DECLARE_TEST(SplitList_Michael_DHP_st_less)\
- CDSUNIT_DECLARE_TEST(SplitList_Michael_DHP_st_less_stat)\
- CDSUNIT_DECLARE_TEST(SplitList_Michael_RCU_GPI_dyn_cmp)\
- CDSUNIT_DECLARE_TEST(SplitList_Michael_RCU_GPI_dyn_cmp_stat)\
- CDSUNIT_DECLARE_TEST(SplitList_Michael_RCU_GPI_st_cmp)\
- CDSUNIT_DECLARE_TEST(SplitList_Michael_RCU_GPI_dyn_less)\
- CDSUNIT_DECLARE_TEST(SplitList_Michael_RCU_GPI_st_less)\
- CDSUNIT_DECLARE_TEST(SplitList_Michael_RCU_GPI_st_less_stat)\
- CDSUNIT_DECLARE_TEST(SplitList_Michael_RCU_GPB_dyn_cmp)\
- CDSUNIT_DECLARE_TEST(SplitList_Michael_RCU_GPB_dyn_cmp_stat)\
- CDSUNIT_DECLARE_TEST(SplitList_Michael_RCU_GPB_st_cmp)\
- CDSUNIT_DECLARE_TEST(SplitList_Michael_RCU_GPB_dyn_less)\
- CDSUNIT_DECLARE_TEST(SplitList_Michael_RCU_GPB_st_less)\
- CDSUNIT_DECLARE_TEST(SplitList_Michael_RCU_GPB_st_less_stat)\
- CDSUNIT_DECLARE_TEST(SplitList_Michael_RCU_GPT_dyn_cmp)\
- CDSUNIT_DECLARE_TEST(SplitList_Michael_RCU_GPT_dyn_cmp_stat)\
- CDSUNIT_DECLARE_TEST(SplitList_Michael_RCU_GPT_st_cmp)\
- CDSUNIT_DECLARE_TEST(SplitList_Michael_RCU_GPT_dyn_less)\
- CDSUNIT_DECLARE_TEST(SplitList_Michael_RCU_GPT_st_less)\
- CDSUNIT_DECLARE_TEST(SplitList_Michael_RCU_GPT_st_less_stat)\
- CDSUNIT_DECLARE_TEST(SplitList_Lazy_HP_dyn_cmp)\
- CDSUNIT_DECLARE_TEST(SplitList_Lazy_HP_dyn_cmp_stat)\
- CDSUNIT_DECLARE_TEST(SplitList_Lazy_HP_st_cmp)\
- CDSUNIT_DECLARE_TEST(SplitList_Lazy_HP_dyn_less)\
- CDSUNIT_DECLARE_TEST(SplitList_Lazy_HP_st_less)\
- CDSUNIT_DECLARE_TEST(SplitList_Lazy_HP_st_less_stat)\
- CDSUNIT_DECLARE_TEST(SplitList_Lazy_DHP_dyn_cmp)\
- CDSUNIT_DECLARE_TEST(SplitList_Lazy_DHP_dyn_cmp_stat)\
- CDSUNIT_DECLARE_TEST(SplitList_Lazy_DHP_st_cmp)\
- CDSUNIT_DECLARE_TEST(SplitList_Lazy_DHP_dyn_less)\
- CDSUNIT_DECLARE_TEST(SplitList_Lazy_DHP_st_less)\
- CDSUNIT_DECLARE_TEST(SplitList_Lazy_DHP_st_less_stat)\
- CDSUNIT_DECLARE_TEST(SplitList_Lazy_RCU_GPI_dyn_cmp)\
- CDSUNIT_DECLARE_TEST(SplitList_Lazy_RCU_GPI_dyn_cmp_stat)\
- CDSUNIT_DECLARE_TEST(SplitList_Lazy_RCU_GPI_st_cmp)\
- CDSUNIT_DECLARE_TEST(SplitList_Lazy_RCU_GPI_dyn_less)\
- CDSUNIT_DECLARE_TEST(SplitList_Lazy_RCU_GPI_st_less)\
- CDSUNIT_DECLARE_TEST(SplitList_Lazy_RCU_GPI_st_less_stat)\
- CDSUNIT_DECLARE_TEST(SplitList_Lazy_RCU_GPB_dyn_cmp)\
- CDSUNIT_DECLARE_TEST(SplitList_Lazy_RCU_GPB_dyn_cmp_stat)\
- CDSUNIT_DECLARE_TEST(SplitList_Lazy_RCU_GPB_st_cmp)\
- CDSUNIT_DECLARE_TEST(SplitList_Lazy_RCU_GPB_dyn_less)\
- CDSUNIT_DECLARE_TEST(SplitList_Lazy_RCU_GPB_st_less)\
- CDSUNIT_DECLARE_TEST(SplitList_Lazy_RCU_GPB_st_less_stat)\
- CDSUNIT_DECLARE_TEST(SplitList_Lazy_RCU_GPT_dyn_cmp)\
- CDSUNIT_DECLARE_TEST(SplitList_Lazy_RCU_GPT_dyn_cmp_stat)\
- CDSUNIT_DECLARE_TEST(SplitList_Lazy_RCU_GPT_st_cmp)\
- CDSUNIT_DECLARE_TEST(SplitList_Lazy_RCU_GPT_dyn_less)\
- CDSUNIT_DECLARE_TEST(SplitList_Lazy_RCU_GPT_st_less)\
- CDSUNIT_DECLARE_TEST(SplitList_Lazy_RCU_GPT_st_less_stat)\
+ TEST_CASE(tag_SplitListSet, SplitList_Michael_HP_dyn_cmp)\
+ TEST_CASE(tag_SplitListSet, SplitList_Michael_HP_dyn_cmp_stat)\
+ TEST_CASE(tag_SplitListSet, SplitList_Michael_HP_st_cmp)\
+ TEST_CASE(tag_SplitListSet, SplitList_Michael_HP_dyn_less)\
+ TEST_CASE(tag_SplitListSet, SplitList_Michael_HP_st_less)\
+ TEST_CASE(tag_SplitListSet, SplitList_Michael_HP_st_less_stat)\
+ TEST_CASE(tag_SplitListSet, SplitList_Michael_DHP_dyn_cmp)\
+ TEST_CASE(tag_SplitListSet, SplitList_Michael_DHP_dyn_cmp_stat)\
+ TEST_CASE(tag_SplitListSet, SplitList_Michael_DHP_st_cmp)\
+ TEST_CASE(tag_SplitListSet, SplitList_Michael_DHP_dyn_less)\
+ TEST_CASE(tag_SplitListSet, SplitList_Michael_DHP_st_less)\
+ TEST_CASE(tag_SplitListSet, SplitList_Michael_DHP_st_less_stat)\
+ TEST_CASE(tag_SplitListSet, SplitList_Michael_RCU_GPI_dyn_cmp)\
+ TEST_CASE(tag_SplitListSet, SplitList_Michael_RCU_GPI_dyn_cmp_stat)\
+ TEST_CASE(tag_SplitListSet, SplitList_Michael_RCU_GPI_st_cmp)\
+ TEST_CASE(tag_SplitListSet, SplitList_Michael_RCU_GPI_dyn_less)\
+ TEST_CASE(tag_SplitListSet, SplitList_Michael_RCU_GPI_st_less)\
+ TEST_CASE(tag_SplitListSet, SplitList_Michael_RCU_GPI_st_less_stat)\
+ TEST_CASE(tag_SplitListSet, SplitList_Michael_RCU_GPB_dyn_cmp)\
+ TEST_CASE(tag_SplitListSet, SplitList_Michael_RCU_GPB_dyn_cmp_stat)\
+ TEST_CASE(tag_SplitListSet, SplitList_Michael_RCU_GPB_st_cmp)\
+ TEST_CASE(tag_SplitListSet, SplitList_Michael_RCU_GPB_dyn_less)\
+ TEST_CASE(tag_SplitListSet, SplitList_Michael_RCU_GPB_st_less)\
+ TEST_CASE(tag_SplitListSet, SplitList_Michael_RCU_GPB_st_less_stat)\
+ TEST_CASE(tag_SplitListSet, SplitList_Michael_RCU_GPT_dyn_cmp)\
+ TEST_CASE(tag_SplitListSet, SplitList_Michael_RCU_GPT_dyn_cmp_stat)\
+ TEST_CASE(tag_SplitListSet, SplitList_Michael_RCU_GPT_st_cmp)\
+ TEST_CASE(tag_SplitListSet, SplitList_Michael_RCU_GPT_dyn_less)\
+ TEST_CASE(tag_SplitListSet, SplitList_Michael_RCU_GPT_st_less)\
+ TEST_CASE(tag_SplitListSet, SplitList_Michael_RCU_GPT_st_less_stat)\
+ TEST_CASE(tag_SplitListSet, SplitList_Lazy_HP_dyn_cmp)\
+ TEST_CASE(tag_SplitListSet, SplitList_Lazy_HP_dyn_cmp_stat)\
+ TEST_CASE(tag_SplitListSet, SplitList_Lazy_HP_st_cmp)\
+ TEST_CASE(tag_SplitListSet, SplitList_Lazy_HP_dyn_less)\
+ TEST_CASE(tag_SplitListSet, SplitList_Lazy_HP_st_less)\
+ TEST_CASE(tag_SplitListSet, SplitList_Lazy_HP_st_less_stat)\
+ TEST_CASE(tag_SplitListSet, SplitList_Lazy_DHP_dyn_cmp)\
+ TEST_CASE(tag_SplitListSet, SplitList_Lazy_DHP_dyn_cmp_stat)\
+ TEST_CASE(tag_SplitListSet, SplitList_Lazy_DHP_st_cmp)\
+ TEST_CASE(tag_SplitListSet, SplitList_Lazy_DHP_dyn_less)\
+ TEST_CASE(tag_SplitListSet, SplitList_Lazy_DHP_st_less)\
+ TEST_CASE(tag_SplitListSet, SplitList_Lazy_DHP_st_less_stat)\
+ TEST_CASE(tag_SplitListSet, SplitList_Lazy_RCU_GPI_dyn_cmp)\
+ TEST_CASE(tag_SplitListSet, SplitList_Lazy_RCU_GPI_dyn_cmp_stat)\
+ TEST_CASE(tag_SplitListSet, SplitList_Lazy_RCU_GPI_st_cmp)\
+ TEST_CASE(tag_SplitListSet, SplitList_Lazy_RCU_GPI_dyn_less)\
+ TEST_CASE(tag_SplitListSet, SplitList_Lazy_RCU_GPI_st_less)\
+ TEST_CASE(tag_SplitListSet, SplitList_Lazy_RCU_GPI_st_less_stat)\
+ TEST_CASE(tag_SplitListSet, SplitList_Lazy_RCU_GPB_dyn_cmp)\
+ TEST_CASE(tag_SplitListSet, SplitList_Lazy_RCU_GPB_dyn_cmp_stat)\
+ TEST_CASE(tag_SplitListSet, SplitList_Lazy_RCU_GPB_st_cmp)\
+ TEST_CASE(tag_SplitListSet, SplitList_Lazy_RCU_GPB_dyn_less)\
+ TEST_CASE(tag_SplitListSet, SplitList_Lazy_RCU_GPB_st_less)\
+ TEST_CASE(tag_SplitListSet, SplitList_Lazy_RCU_GPB_st_less_stat)\
+ TEST_CASE(tag_SplitListSet, SplitList_Lazy_RCU_GPT_dyn_cmp)\
+ TEST_CASE(tag_SplitListSet, SplitList_Lazy_RCU_GPT_dyn_cmp_stat)\
+ TEST_CASE(tag_SplitListSet, SplitList_Lazy_RCU_GPT_st_cmp)\
+ TEST_CASE(tag_SplitListSet, SplitList_Lazy_RCU_GPT_dyn_less)\
+ TEST_CASE(tag_SplitListSet, SplitList_Lazy_RCU_GPT_st_less)\
+ TEST_CASE(tag_SplitListSet, SplitList_Lazy_RCU_GPT_st_less_stat)\
CDSUNIT_DECLARE_SplitList_RCU_signal
-#define CDSUNIT_DEFINE_SplitList( IMPL, C ) \
- TEST_SET_EXTRACT( IMPL, C, SplitList_Michael_HP_dyn_cmp)\
- TEST_SET_EXTRACT( IMPL, C, SplitList_Michael_HP_dyn_cmp_stat)\
- TEST_SET_EXTRACT( IMPL, C, SplitList_Michael_HP_st_cmp)\
- TEST_SET_EXTRACT( IMPL, C, SplitList_Michael_HP_dyn_less)\
- TEST_SET_EXTRACT( IMPL, C, SplitList_Michael_HP_st_less)\
- TEST_SET_EXTRACT( IMPL, C, SplitList_Michael_HP_st_less_stat)\
- TEST_SET_EXTRACT( IMPL, C, SplitList_Michael_DHP_dyn_cmp)\
- TEST_SET_EXTRACT( IMPL, C, SplitList_Michael_DHP_dyn_cmp_stat)\
- TEST_SET_EXTRACT( IMPL, C, SplitList_Michael_DHP_st_cmp)\
- TEST_SET_EXTRACT( IMPL, C, SplitList_Michael_DHP_dyn_less)\
- TEST_SET_EXTRACT( IMPL, C, SplitList_Michael_DHP_st_less)\
- TEST_SET_EXTRACT( IMPL, C, SplitList_Michael_DHP_st_less_stat)\
- TEST_SET_EXTRACT( IMPL, C, SplitList_Michael_RCU_GPI_dyn_cmp)\
- TEST_SET_EXTRACT( IMPL, C, SplitList_Michael_RCU_GPI_dyn_cmp_stat)\
- TEST_SET_EXTRACT( IMPL, C, SplitList_Michael_RCU_GPI_st_cmp)\
- TEST_SET_EXTRACT( IMPL, C, SplitList_Michael_RCU_GPI_dyn_less)\
- TEST_SET_EXTRACT( IMPL, C, SplitList_Michael_RCU_GPI_st_less)\
- TEST_SET_EXTRACT( IMPL, C, SplitList_Michael_RCU_GPI_st_less_stat)\
- TEST_SET_EXTRACT( IMPL, C, SplitList_Michael_RCU_GPB_dyn_cmp)\
- TEST_SET_EXTRACT( IMPL, C, SplitList_Michael_RCU_GPB_dyn_cmp_stat)\
- TEST_SET_EXTRACT( IMPL, C, SplitList_Michael_RCU_GPB_st_cmp)\
- TEST_SET_EXTRACT( IMPL, C, SplitList_Michael_RCU_GPB_dyn_less)\
- TEST_SET_EXTRACT( IMPL, C, SplitList_Michael_RCU_GPB_st_less)\
- TEST_SET_EXTRACT( IMPL, C, SplitList_Michael_RCU_GPB_st_less_stat)\
- TEST_SET_EXTRACT( IMPL, C, SplitList_Michael_RCU_GPT_dyn_cmp)\
- TEST_SET_EXTRACT( IMPL, C, SplitList_Michael_RCU_GPT_dyn_cmp_stat)\
- TEST_SET_EXTRACT( IMPL, C, SplitList_Michael_RCU_GPT_st_cmp)\
- TEST_SET_EXTRACT( IMPL, C, SplitList_Michael_RCU_GPT_dyn_less)\
- TEST_SET_EXTRACT( IMPL, C, SplitList_Michael_RCU_GPT_st_less)\
- TEST_SET_EXTRACT( IMPL, C, SplitList_Michael_RCU_GPT_st_less_stat)\
- TEST_SET_EXTRACT( IMPL, C, SplitList_Lazy_HP_dyn_cmp)\
- TEST_SET_EXTRACT( IMPL, C, SplitList_Lazy_HP_dyn_cmp_stat)\
- TEST_SET_EXTRACT( IMPL, C, SplitList_Lazy_HP_st_cmp)\
- TEST_SET_EXTRACT( IMPL, C, SplitList_Lazy_HP_dyn_less)\
- TEST_SET_EXTRACT( IMPL, C, SplitList_Lazy_HP_st_less)\
- TEST_SET_EXTRACT( IMPL, C, SplitList_Lazy_HP_st_less_stat)\
- TEST_SET_EXTRACT( IMPL, C, SplitList_Lazy_DHP_dyn_cmp)\
- TEST_SET_EXTRACT( IMPL, C, SplitList_Lazy_DHP_dyn_cmp_stat)\
- TEST_SET_EXTRACT( IMPL, C, SplitList_Lazy_DHP_st_cmp)\
- TEST_SET_EXTRACT( IMPL, C, SplitList_Lazy_DHP_dyn_less)\
- TEST_SET_EXTRACT( IMPL, C, SplitList_Lazy_DHP_st_less)\
- TEST_SET_EXTRACT( IMPL, C, SplitList_Lazy_DHP_st_less_stat)\
- TEST_SET_EXTRACT( IMPL, C, SplitList_Lazy_RCU_GPI_dyn_cmp)\
- TEST_SET_EXTRACT( IMPL, C, SplitList_Lazy_RCU_GPI_dyn_cmp_stat)\
- TEST_SET_EXTRACT( IMPL, C, SplitList_Lazy_RCU_GPI_st_cmp)\
- TEST_SET_EXTRACT( IMPL, C, SplitList_Lazy_RCU_GPI_dyn_less)\
- TEST_SET_EXTRACT( IMPL, C, SplitList_Lazy_RCU_GPI_st_less)\
- TEST_SET_EXTRACT( IMPL, C, SplitList_Lazy_RCU_GPI_st_less_stat)\
- TEST_SET_EXTRACT( IMPL, C, SplitList_Lazy_RCU_GPB_dyn_cmp)\
- TEST_SET_EXTRACT( IMPL, C, SplitList_Lazy_RCU_GPB_dyn_cmp_stat)\
- TEST_SET_EXTRACT( IMPL, C, SplitList_Lazy_RCU_GPB_st_cmp)\
- TEST_SET_EXTRACT( IMPL, C, SplitList_Lazy_RCU_GPB_dyn_less)\
- TEST_SET_EXTRACT( IMPL, C, SplitList_Lazy_RCU_GPB_st_less)\
- TEST_SET_EXTRACT( IMPL, C, SplitList_Lazy_RCU_GPB_st_less_stat)\
- TEST_SET_EXTRACT( IMPL, C, SplitList_Lazy_RCU_GPT_dyn_cmp)\
- TEST_SET_EXTRACT( IMPL, C, SplitList_Lazy_RCU_GPT_dyn_cmp_stat)\
- TEST_SET_EXTRACT( IMPL, C, SplitList_Lazy_RCU_GPT_st_cmp)\
- TEST_SET_EXTRACT( IMPL, C, SplitList_Lazy_RCU_GPT_dyn_less)\
- TEST_SET_EXTRACT( IMPL, C, SplitList_Lazy_RCU_GPT_st_less)\
- TEST_SET_EXTRACT( IMPL, C, SplitList_Lazy_RCU_GPT_st_less_stat)\
- CDSUNIT_DEFINE_SplitList_RCU_signal( IMPL, C )
-
#define CDSUNIT_TEST_SplitList \
CPPUNIT_TEST(SplitList_Michael_HP_dyn_cmp)\
CPPUNIT_TEST(SplitList_Michael_HP_dyn_cmp_stat)\
#define CDSUNIT_DECLARE_CuckooSet \
- CDSUNIT_DECLARE_TEST(CuckooStripedSet_list_unord)\
- CDSUNIT_DECLARE_TEST(CuckooStripedSet_list_unord_stat)\
- CDSUNIT_DECLARE_TEST(CuckooStripedSet_list_ord)\
- CDSUNIT_DECLARE_TEST(CuckooStripedSet_list_ord_stat)\
- CDSUNIT_DECLARE_TEST(CuckooStripedSet_vector_unord)\
- CDSUNIT_DECLARE_TEST(CuckooStripedSet_vector_ord)\
- CDSUNIT_DECLARE_TEST(CuckooStripedSet_vector_unord_stat)\
- CDSUNIT_DECLARE_TEST(CuckooStripedSet_vector_ord_stat)\
- CDSUNIT_DECLARE_TEST(CuckooRefinableSet_list_unord)\
- CDSUNIT_DECLARE_TEST(CuckooRefinableSet_list_ord)\
- CDSUNIT_DECLARE_TEST(CuckooRefinableSet_list_unord_stat)\
- CDSUNIT_DECLARE_TEST(CuckooRefinableSet_list_ord_stat)\
- CDSUNIT_DECLARE_TEST(CuckooRefinableSet_vector_unord)\
- CDSUNIT_DECLARE_TEST(CuckooRefinableSet_vector_unord_stat)\
- CDSUNIT_DECLARE_TEST(CuckooRefinableSet_vector_ord) \
- CDSUNIT_DECLARE_TEST(CuckooRefinableSet_vector_ord_stat) \
- CDSUNIT_DECLARE_TEST(CuckooStripedSet_list_unord_storehash)\
- CDSUNIT_DECLARE_TEST(CuckooStripedSet_list_ord_storehash)\
- CDSUNIT_DECLARE_TEST(CuckooStripedSet_vector_unord_storehash)\
- CDSUNIT_DECLARE_TEST(CuckooStripedSet_vector_ord_storehash)\
- CDSUNIT_DECLARE_TEST(CuckooRefinableSet_list_unord_storehash)\
- CDSUNIT_DECLARE_TEST(CuckooRefinableSet_list_ord_storehash)\
- CDSUNIT_DECLARE_TEST(CuckooRefinableSet_vector_unord_storehash)\
- CDSUNIT_DECLARE_TEST(CuckooRefinableSet_vector_ord_storehash)
-
-#define CDSUNIT_DEFINE_CuckooSet(IMPL, C) \
- TEST_SET(IMPL, C, CuckooStripedSet_list_unord)\
- TEST_SET(IMPL, C, CuckooStripedSet_list_unord_stat)\
- TEST_SET(IMPL, C, CuckooStripedSet_list_ord)\
- TEST_SET(IMPL, C, CuckooStripedSet_list_ord_stat)\
- TEST_SET(IMPL, C, CuckooStripedSet_vector_unord)\
- TEST_SET(IMPL, C, CuckooStripedSet_vector_ord)\
- TEST_SET(IMPL, C, CuckooStripedSet_vector_unord_stat)\
- TEST_SET(IMPL, C, CuckooStripedSet_vector_ord_stat)\
- TEST_SET(IMPL, C, CuckooRefinableSet_list_unord)\
- TEST_SET(IMPL, C, CuckooRefinableSet_list_ord)\
- TEST_SET(IMPL, C, CuckooRefinableSet_list_unord_stat)\
- TEST_SET(IMPL, C, CuckooRefinableSet_list_ord_stat)\
- TEST_SET(IMPL, C, CuckooRefinableSet_vector_unord)\
- TEST_SET(IMPL, C, CuckooRefinableSet_vector_unord_stat)\
- TEST_SET(IMPL, C, CuckooRefinableSet_vector_ord) \
- TEST_SET(IMPL, C, CuckooRefinableSet_vector_ord_stat) \
- TEST_SET(IMPL, C, CuckooStripedSet_list_unord_storehash)\
- TEST_SET(IMPL, C, CuckooStripedSet_list_ord_storehash)\
- TEST_SET(IMPL, C, CuckooStripedSet_vector_unord_storehash)\
- TEST_SET(IMPL, C, CuckooStripedSet_vector_ord_storehash)\
- TEST_SET(IMPL, C, CuckooRefinableSet_list_unord_storehash)\
- TEST_SET(IMPL, C, CuckooRefinableSet_list_ord_storehash)\
- TEST_SET(IMPL, C, CuckooRefinableSet_vector_unord_storehash)\
- TEST_SET(IMPL, C, CuckooRefinableSet_vector_ord_storehash)
-
+ TEST_CASE(tag_CuckooSet, CuckooStripedSet_list_unord)\
+ TEST_CASE(tag_CuckooSet, CuckooStripedSet_list_unord_stat)\
+ TEST_CASE(tag_CuckooSet, CuckooStripedSet_list_ord)\
+ TEST_CASE(tag_CuckooSet, CuckooStripedSet_list_ord_stat)\
+ TEST_CASE(tag_CuckooSet, CuckooStripedSet_vector_unord)\
+ TEST_CASE(tag_CuckooSet, CuckooStripedSet_vector_ord)\
+ TEST_CASE(tag_CuckooSet, CuckooStripedSet_vector_unord_stat)\
+ TEST_CASE(tag_CuckooSet, CuckooStripedSet_vector_ord_stat)\
+ TEST_CASE(tag_CuckooSet, CuckooRefinableSet_list_unord)\
+ TEST_CASE(tag_CuckooSet, CuckooRefinableSet_list_ord)\
+ TEST_CASE(tag_CuckooSet, CuckooRefinableSet_list_unord_stat)\
+ TEST_CASE(tag_CuckooSet, CuckooRefinableSet_list_ord_stat)\
+ TEST_CASE(tag_CuckooSet, CuckooRefinableSet_vector_unord)\
+ TEST_CASE(tag_CuckooSet, CuckooRefinableSet_vector_unord_stat)\
+ TEST_CASE(tag_CuckooSet, CuckooRefinableSet_vector_ord) \
+ TEST_CASE(tag_CuckooSet, CuckooRefinableSet_vector_ord_stat) \
+ TEST_CASE(tag_CuckooSet, CuckooStripedSet_list_unord_storehash)\
+ TEST_CASE(tag_CuckooSet, CuckooStripedSet_list_ord_storehash)\
+ TEST_CASE(tag_CuckooSet, CuckooStripedSet_vector_unord_storehash)\
+ TEST_CASE(tag_CuckooSet, CuckooStripedSet_vector_ord_storehash)\
+ TEST_CASE(tag_CuckooSet, CuckooRefinableSet_list_unord_storehash)\
+ TEST_CASE(tag_CuckooSet, CuckooRefinableSet_list_ord_storehash)\
+ TEST_CASE(tag_CuckooSet, CuckooRefinableSet_vector_unord_storehash)\
+ TEST_CASE(tag_CuckooSet, CuckooRefinableSet_vector_ord_storehash)
#define CDSUNIT_TEST_CuckooSet \
CPPUNIT_TEST(CuckooStripedSet_list_unord)\
#ifdef CDS_URCU_SIGNAL_HANDLING_ENABLED
# define CDSUNIT_DECLARE_SkipListSet_RCU_signal \
- CDSUNIT_DECLARE_TEST(SkipListSet_rcu_shb_less_pascal)\
- CDSUNIT_DECLARE_TEST(SkipListSet_rcu_shb_cmp_pascal_stat)\
- CDSUNIT_DECLARE_TEST(SkipListSet_rcu_shb_less_xorshift)\
- CDSUNIT_DECLARE_TEST(SkipListSet_rcu_shb_cmp_xorshift_stat)\
- CDSUNIT_DECLARE_TEST(SkipListSet_rcu_sht_less_pascal)\
- CDSUNIT_DECLARE_TEST(SkipListSet_rcu_sht_cmp_pascal_stat)\
- CDSUNIT_DECLARE_TEST(SkipListSet_rcu_sht_less_xorshift)\
- CDSUNIT_DECLARE_TEST(SkipListSet_rcu_sht_cmp_xorshift_stat)
-
-# define CDSUNIT_DEFINE_SkipListSet_RCU_signal( IMPL, C ) \
- TEST_SET_NOLF_EXTRACT(IMPL, C, SkipListSet_rcu_shb_less_pascal)\
- TEST_SET_NOLF_EXTRACT(IMPL, C, SkipListSet_rcu_shb_cmp_pascal_stat)\
- TEST_SET_NOLF_EXTRACT(IMPL, C, SkipListSet_rcu_shb_less_xorshift)\
- TEST_SET_NOLF_EXTRACT(IMPL, C, SkipListSet_rcu_shb_cmp_xorshift_stat)\
- TEST_SET_NOLF_EXTRACT(IMPL, C, SkipListSet_rcu_sht_less_pascal)\
- TEST_SET_NOLF_EXTRACT(IMPL, C, SkipListSet_rcu_sht_cmp_pascal_stat)\
- TEST_SET_NOLF_EXTRACT(IMPL, C, SkipListSet_rcu_sht_less_xorshift)\
- TEST_SET_NOLF_EXTRACT(IMPL, C, SkipListSet_rcu_sht_cmp_xorshift_stat)
+ TEST_CASE(tag_SkipListSet, SkipListSet_rcu_shb_less_pascal)\
+ TEST_CASE(tag_SkipListSet, SkipListSet_rcu_shb_cmp_pascal_stat)\
+ TEST_CASE(tag_SkipListSet, SkipListSet_rcu_shb_less_xorshift)\
+ TEST_CASE(tag_SkipListSet, SkipListSet_rcu_shb_cmp_xorshift_stat)\
+ TEST_CASE(tag_SkipListSet, SkipListSet_rcu_sht_less_pascal)\
+ TEST_CASE(tag_SkipListSet, SkipListSet_rcu_sht_cmp_pascal_stat)\
+ TEST_CASE(tag_SkipListSet, SkipListSet_rcu_sht_less_xorshift)\
+ TEST_CASE(tag_SkipListSet, SkipListSet_rcu_sht_cmp_xorshift_stat)
# define CDSUNIT_TEST_SkipListSet_RCU_signal \
CPPUNIT_TEST(SkipListSet_rcu_shb_less_pascal)\
#else
# define CDSUNIT_DECLARE_SkipListSet_RCU_signal
-# define CDSUNIT_DEFINE_SkipListSet_RCU_signal( IMPL, C )
# define CDSUNIT_TEST_SkipListSet_RCU_signal
#endif
#define CDSUNIT_DECLARE_SkipListSet \
- CDSUNIT_DECLARE_TEST(SkipListSet_hp_less_pascal)\
- CDSUNIT_DECLARE_TEST(SkipListSet_hp_cmp_pascal_stat)\
- CDSUNIT_DECLARE_TEST(SkipListSet_hp_less_xorshift)\
- CDSUNIT_DECLARE_TEST(SkipListSet_hp_cmp_xorshift_stat)\
- CDSUNIT_DECLARE_TEST(SkipListSet_dhp_less_pascal)\
- CDSUNIT_DECLARE_TEST(SkipListSet_dhp_cmp_pascal_stat)\
- CDSUNIT_DECLARE_TEST(SkipListSet_dhp_less_xorshift)\
- CDSUNIT_DECLARE_TEST(SkipListSet_dhp_cmp_xorshift_stat)\
- CDSUNIT_DECLARE_TEST(SkipListSet_rcu_gpi_less_pascal)\
- CDSUNIT_DECLARE_TEST(SkipListSet_rcu_gpi_cmp_pascal_stat)\
- CDSUNIT_DECLARE_TEST(SkipListSet_rcu_gpi_less_xorshift)\
- CDSUNIT_DECLARE_TEST(SkipListSet_rcu_gpi_cmp_xorshift_stat)\
- CDSUNIT_DECLARE_TEST(SkipListSet_rcu_gpb_less_pascal)\
- CDSUNIT_DECLARE_TEST(SkipListSet_rcu_gpb_cmp_pascal_stat)\
- CDSUNIT_DECLARE_TEST(SkipListSet_rcu_gpb_less_xorshift)\
- CDSUNIT_DECLARE_TEST(SkipListSet_rcu_gpb_cmp_xorshift_stat)\
- CDSUNIT_DECLARE_TEST(SkipListSet_rcu_gpt_less_pascal)\
- CDSUNIT_DECLARE_TEST(SkipListSet_rcu_gpt_cmp_pascal_stat)\
- CDSUNIT_DECLARE_TEST(SkipListSet_rcu_gpt_less_xorshift)\
- CDSUNIT_DECLARE_TEST(SkipListSet_rcu_gpt_cmp_xorshift_stat)\
+ TEST_CASE(tag_SkipListSet, SkipListSet_hp_less_pascal)\
+ TEST_CASE(tag_SkipListSet, SkipListSet_hp_cmp_pascal_stat)\
+ TEST_CASE(tag_SkipListSet, SkipListSet_hp_less_xorshift)\
+ TEST_CASE(tag_SkipListSet, SkipListSet_hp_cmp_xorshift_stat)\
+ TEST_CASE(tag_SkipListSet, SkipListSet_dhp_less_pascal)\
+ TEST_CASE(tag_SkipListSet, SkipListSet_dhp_cmp_pascal_stat)\
+ TEST_CASE(tag_SkipListSet, SkipListSet_dhp_less_xorshift)\
+ TEST_CASE(tag_SkipListSet, SkipListSet_dhp_cmp_xorshift_stat)\
+ TEST_CASE(tag_SkipListSet, SkipListSet_rcu_gpi_less_pascal)\
+ TEST_CASE(tag_SkipListSet, SkipListSet_rcu_gpi_cmp_pascal_stat)\
+ TEST_CASE(tag_SkipListSet, SkipListSet_rcu_gpi_less_xorshift)\
+ TEST_CASE(tag_SkipListSet, SkipListSet_rcu_gpi_cmp_xorshift_stat)\
+ TEST_CASE(tag_SkipListSet, SkipListSet_rcu_gpb_less_pascal)\
+ TEST_CASE(tag_SkipListSet, SkipListSet_rcu_gpb_cmp_pascal_stat)\
+ TEST_CASE(tag_SkipListSet, SkipListSet_rcu_gpb_less_xorshift)\
+ TEST_CASE(tag_SkipListSet, SkipListSet_rcu_gpb_cmp_xorshift_stat)\
+ TEST_CASE(tag_SkipListSet, SkipListSet_rcu_gpt_less_pascal)\
+ TEST_CASE(tag_SkipListSet, SkipListSet_rcu_gpt_cmp_pascal_stat)\
+ TEST_CASE(tag_SkipListSet, SkipListSet_rcu_gpt_less_xorshift)\
+ TEST_CASE(tag_SkipListSet, SkipListSet_rcu_gpt_cmp_xorshift_stat)\
CDSUNIT_DECLARE_SkipListSet_RCU_signal
-#define CDSUNIT_DEFINE_SkipListSet(IMPL, C) \
- TEST_SET_NOLF_EXTRACT(IMPL, C, SkipListSet_hp_less_pascal)\
- TEST_SET_NOLF_EXTRACT(IMPL, C, SkipListSet_hp_cmp_pascal_stat)\
- TEST_SET_NOLF_EXTRACT(IMPL, C, SkipListSet_hp_less_xorshift)\
- TEST_SET_NOLF_EXTRACT(IMPL, C, SkipListSet_hp_cmp_xorshift_stat)\
- TEST_SET_NOLF_EXTRACT(IMPL, C, SkipListSet_dhp_less_pascal)\
- TEST_SET_NOLF_EXTRACT(IMPL, C, SkipListSet_dhp_cmp_pascal_stat)\
- TEST_SET_NOLF_EXTRACT(IMPL, C, SkipListSet_dhp_less_xorshift)\
- TEST_SET_NOLF_EXTRACT(IMPL, C, SkipListSet_dhp_cmp_xorshift_stat)\
- TEST_SET_NOLF_EXTRACT(IMPL, C, SkipListSet_rcu_gpi_less_pascal)\
- TEST_SET_NOLF_EXTRACT(IMPL, C, SkipListSet_rcu_gpi_cmp_pascal_stat)\
- TEST_SET_NOLF_EXTRACT(IMPL, C, SkipListSet_rcu_gpi_less_xorshift)\
- TEST_SET_NOLF_EXTRACT(IMPL, C, SkipListSet_rcu_gpi_cmp_xorshift_stat)\
- TEST_SET_NOLF_EXTRACT(IMPL, C, SkipListSet_rcu_gpb_less_pascal)\
- TEST_SET_NOLF_EXTRACT(IMPL, C, SkipListSet_rcu_gpb_cmp_pascal_stat)\
- TEST_SET_NOLF_EXTRACT(IMPL, C, SkipListSet_rcu_gpb_less_xorshift)\
- TEST_SET_NOLF_EXTRACT(IMPL, C, SkipListSet_rcu_gpb_cmp_xorshift_stat)\
- TEST_SET_NOLF_EXTRACT(IMPL, C, SkipListSet_rcu_gpt_less_pascal)\
- TEST_SET_NOLF_EXTRACT(IMPL, C, SkipListSet_rcu_gpt_cmp_pascal_stat)\
- TEST_SET_NOLF_EXTRACT(IMPL, C, SkipListSet_rcu_gpt_less_xorshift)\
- TEST_SET_NOLF_EXTRACT(IMPL, C, SkipListSet_rcu_gpt_cmp_xorshift_stat)\
- CDSUNIT_DEFINE_SkipListSet_RCU_signal( IMPL, C )
-
#define CDSUNIT_TEST_SkipListSet \
CPPUNIT_TEST(SkipListSet_hp_less_pascal)\
CPPUNIT_TEST(SkipListSet_hp_cmp_pascal_stat)\
#ifdef CDS_URCU_SIGNAL_HANDLING_ENABLED
# define CDSUNIT_DECLARE_EllenBinTreeSet_RCU_signal \
- CDSUNIT_DECLARE_TEST(EllenBinTreeSet_rcu_shb)\
- CDSUNIT_DECLARE_TEST(EllenBinTreeSet_rcu_shb_stat)\
- CDSUNIT_DECLARE_TEST(EllenBinTreeSet_rcu_sht)\
- CDSUNIT_DECLARE_TEST(EllenBinTreeSet_rcu_sht_stat)
-
-# define CDSUNIT_DEFINE_EllenBinTreeSet_RCU_signal( IMPL, C ) \
- TEST_SET_NOLF_EXTRACT(IMPL, C, EllenBinTreeSet_rcu_shb)\
- TEST_SET_NOLF_EXTRACT(IMPL, C, EllenBinTreeSet_rcu_shb_stat)\
- TEST_SET_NOLF_EXTRACT(IMPL, C, EllenBinTreeSet_rcu_sht)\
- TEST_SET_NOLF_EXTRACT(IMPL, C, EllenBinTreeSet_rcu_sht_stat)
+ TEST_CASE(tag_EllenBinTreeSet, EllenBinTreeSet_rcu_shb)\
+ TEST_CASE(tag_EllenBinTreeSet, EllenBinTreeSet_rcu_shb_stat)\
+ TEST_CASE(tag_EllenBinTreeSet, EllenBinTreeSet_rcu_sht)\
+ TEST_CASE(tag_EllenBinTreeSet, EllenBinTreeSet_rcu_sht_stat)
# define CDSUNIT_TEST_EllenBinTreeSet_RCU_signal \
CPPUNIT_TEST(EllenBinTreeSet_rcu_shb)\
CPPUNIT_TEST(EllenBinTreeSet_rcu_sht_stat)
#else
# define CDSUNIT_DECLARE_EllenBinTreeSet_RCU_signal
-# define CDSUNIT_DEFINE_EllenBinTreeSet_RCU_signal( IMPL, C )
# define CDSUNIT_TEST_EllenBinTreeSet_RCU_signal
#endif
#define CDSUNIT_DECLARE_EllenBinTreeSet \
- CDSUNIT_DECLARE_TEST(EllenBinTreeSet_hp)\
- CDSUNIT_DECLARE_TEST(EllenBinTreeSet_yield_hp)\
- CDSUNIT_DECLARE_TEST(EllenBinTreeSet_hp_stat)\
- CDSUNIT_DECLARE_TEST(EllenBinTreeSet_dhp)\
- CDSUNIT_DECLARE_TEST(EllenBinTreeSet_yield_dhp)\
- CDSUNIT_DECLARE_TEST(EllenBinTreeSet_dhp_stat)\
- CDSUNIT_DECLARE_TEST(EllenBinTreeSet_rcu_gpi)\
- CDSUNIT_DECLARE_TEST(EllenBinTreeSet_rcu_gpi_stat)\
- CDSUNIT_DECLARE_TEST(EllenBinTreeSet_rcu_gpb)\
- CDSUNIT_DECLARE_TEST(EllenBinTreeSet_yield_rcu_gpb)\
- CDSUNIT_DECLARE_TEST(EllenBinTreeSet_rcu_gpb_stat)\
- CDSUNIT_DECLARE_TEST(EllenBinTreeSet_rcu_gpt)\
- CDSUNIT_DECLARE_TEST(EllenBinTreeSet_rcu_gpt_stat)\
+ TEST_CASE(tag_EllenBinTreeSet, EllenBinTreeSet_hp)\
+ TEST_CASE(tag_EllenBinTreeSet, EllenBinTreeSet_yield_hp)\
+ TEST_CASE(tag_EllenBinTreeSet, EllenBinTreeSet_hp_stat)\
+ TEST_CASE(tag_EllenBinTreeSet, EllenBinTreeSet_dhp)\
+ TEST_CASE(tag_EllenBinTreeSet, EllenBinTreeSet_yield_dhp)\
+ TEST_CASE(tag_EllenBinTreeSet, EllenBinTreeSet_dhp_stat)\
+ TEST_CASE(tag_EllenBinTreeSet, EllenBinTreeSet_rcu_gpi)\
+ TEST_CASE(tag_EllenBinTreeSet, EllenBinTreeSet_rcu_gpi_stat)\
+ TEST_CASE(tag_EllenBinTreeSet, EllenBinTreeSet_rcu_gpb)\
+ TEST_CASE(tag_EllenBinTreeSet, EllenBinTreeSet_yield_rcu_gpb)\
+ TEST_CASE(tag_EllenBinTreeSet, EllenBinTreeSet_rcu_gpb_stat)\
+ TEST_CASE(tag_EllenBinTreeSet, EllenBinTreeSet_rcu_gpt)\
+ TEST_CASE(tag_EllenBinTreeSet, EllenBinTreeSet_rcu_gpt_stat)\
CDSUNIT_DECLARE_EllenBinTreeSet_RCU_signal
-#define CDSUNIT_DEFINE_EllenBinTreeSet( IMPL, C ) \
- TEST_SET_NOLF_EXTRACT(IMPL, C, EllenBinTreeSet_hp)\
- TEST_SET_NOLF_EXTRACT(IMPL, C, EllenBinTreeSet_yield_hp)\
- TEST_SET_NOLF_EXTRACT(IMPL, C, EllenBinTreeSet_hp_stat)\
- TEST_SET_NOLF_EXTRACT(IMPL, C, EllenBinTreeSet_dhp)\
- TEST_SET_NOLF_EXTRACT(IMPL, C, EllenBinTreeSet_yield_dhp)\
- TEST_SET_NOLF_EXTRACT(IMPL, C, EllenBinTreeSet_dhp_stat)\
- TEST_SET_NOLF_EXTRACT(IMPL, C, EllenBinTreeSet_rcu_gpi)\
- TEST_SET_NOLF_EXTRACT(IMPL, C, EllenBinTreeSet_rcu_gpi_stat)\
- TEST_SET_NOLF_EXTRACT(IMPL, C, EllenBinTreeSet_rcu_gpb)\
- TEST_SET_NOLF_EXTRACT(IMPL, C, EllenBinTreeSet_yield_rcu_gpb)\
- TEST_SET_NOLF_EXTRACT(IMPL, C, EllenBinTreeSet_rcu_gpb_stat)\
- TEST_SET_NOLF_EXTRACT(IMPL, C, EllenBinTreeSet_rcu_gpt)\
- TEST_SET_NOLF_EXTRACT(IMPL, C, EllenBinTreeSet_rcu_gpt_stat)\
- CDSUNIT_DEFINE_EllenBinTreeSet_RCU_signal(IMPL, C)
-
#define CDSUNIT_TEST_EllenBinTreeSet \
CPPUNIT_TEST(EllenBinTreeSet_hp)\
CPPUNIT_TEST(EllenBinTreeSet_yield_hp)\
CDSUNIT_DECLARE_TEST(StripedSet_rational_hashset) \
CDSUNIT_DECLARE_TEST(StripedSet_rational_boost_unordered_set)
-#define CDSUNIT_DEFINE_StripedSet_common( IMPL, C ) \
- TEST_SET(IMPL, C, StripedSet_list) \
- TEST_SET(IMPL, C, StripedSet_vector) \
- TEST_SET(IMPL, C, StripedSet_set) \
- TEST_SET(IMPL, C, StripedSet_hashset) \
- TEST_SET(IMPL, C, StripedSet_boost_unordered_set) \
- TEST_SET(IMPL, C, StripedSet_rational_list) \
- TEST_SET(IMPL, C, StripedSet_rational_vector) \
- TEST_SET(IMPL, C, StripedSet_rational_set) \
- TEST_SET(IMPL, C, StripedSet_rational_hashset) \
- TEST_SET(IMPL, C, StripedSet_rational_boost_unordered_set)
-
#define CDSUNIT_TEST_StripedSet_common \
CPPUNIT_TEST(StripedSet_list) \
CPPUNIT_TEST(StripedSet_vector) \
CDSUNIT_DECLARE_TEST(StripedSet_rational_boost_stable_vector) \
CDSUNIT_DECLARE_TEST(StripedSet_rational_boost_set)
-# define CDSUNIT_DEFINE_StripedSet_boost_container( IMPL, C ) \
- TEST_SET(IMPL, C, StripedSet_boost_list) \
- TEST_SET(IMPL, C, StripedSet_boost_slist) \
- TEST_SET(IMPL, C, StripedSet_boost_vector) \
- TEST_SET(IMPL, C, StripedSet_boost_stable_vector) \
- TEST_SET(IMPL, C, StripedSet_boost_set) \
- TEST_SET(IMPL, C, StripedSet_rational_boost_list) \
- TEST_SET(IMPL, C, StripedSet_rational_boost_slist) \
- TEST_SET(IMPL, C, StripedSet_rational_boost_vector) \
- TEST_SET(IMPL, C, StripedSet_rational_boost_stable_vector) \
- TEST_SET(IMPL, C, StripedSet_rational_boost_set)
-
# define CDSUNIT_TEST_StripedSet_boost_container \
CPPUNIT_TEST(StripedSet_boost_list) \
CPPUNIT_TEST(StripedSet_boost_slist) \
CPPUNIT_TEST(StripedSet_rational_boost_set)
#else
# define CDSUNIT_DECLARE_StripedSet_boost_container
-# define CDSUNIT_DEFINE_StripedSet_boost_container( IMPL, C )
# define CDSUNIT_TEST_StripedSet_boost_container
#endif
# define CDSUNIT_DECLARE_StripedSet_boost_flat_container \
CDSUNIT_DECLARE_TEST(StripedSet_boost_flat_set) \
CDSUNIT_DECLARE_TEST(StripedSet_rational_boost_flat_set)
-# define CDSUNIT_DEFINE_StripedSet_boost_flat_container( IMPL, C ) \
- TEST_SET(IMPL, C, StripedSet_boost_flat_set) \
- TEST_SET(IMPL, C, StripedSet_rational_boost_flat_set)
+
# define CDSUNIT_TEST_StripedSet_boost_flat_container \
CPPUNIT_TEST(StripedSet_boost_flat_set) \
CPPUNIT_TEST(StripedSet_rational_boost_flat_set)
#else
# define CDSUNIT_DECLARE_StripedSet_boost_flat_container
-# define CDSUNIT_DEFINE_StripedSet_boost_flat_container( IMPL, C )
# define CDSUNIT_TEST_StripedSet_boost_flat_container
#endif
CDSUNIT_DECLARE_StripedSet_common \
CDSUNIT_DECLARE_StripedSet_boost_container \
CDSUNIT_DECLARE_StripedSet_boost_flat_container
-#define CDSUNIT_DEFINE_StripedSet( IMPL, C ) \
- CDSUNIT_DEFINE_StripedSet_common( IMPL, C ) \
- CDSUNIT_DEFINE_StripedSet_boost_container( IMPL, C ) \
- CDSUNIT_DEFINE_StripedSet_boost_flat_container( IMPL, C )
+
#define CDSUNIT_TEST_StripedSet \
CDSUNIT_TEST_StripedSet_common \
CDSUNIT_TEST_StripedSet_boost_container \
CDSUNIT_DECLARE_TEST(RefinableSet_rational_set) \
CDSUNIT_DECLARE_TEST(RefinableSet_rational_hashset) \
CDSUNIT_DECLARE_TEST(RefinableSet_rational_boost_unordered_set)
-#define CDSUNIT_DEFINE_RefinableSet_common(IMPL, C) \
- TEST_SET(IMPL, C, RefinableSet_list) \
- TEST_SET(IMPL, C, RefinableSet_vector) \
- TEST_SET(IMPL, C, RefinableSet_set) \
- TEST_SET(IMPL, C, RefinableSet_hashset) \
- TEST_SET(IMPL, C, RefinableSet_boost_unordered_set) \
- TEST_SET(IMPL, C, RefinableSet_rational_list) \
- TEST_SET(IMPL, C, RefinableSet_rational_vector) \
- TEST_SET(IMPL, C, RefinableSet_rational_set) \
- TEST_SET(IMPL, C, RefinableSet_rational_hashset) \
- TEST_SET(IMPL, C, RefinableSet_rational_boost_unordered_set)
+
#define CDSUNIT_TEST_RefinableSet_common \
CPPUNIT_TEST(RefinableSet_list) \
CPPUNIT_TEST(RefinableSet_vector) \
CDSUNIT_DECLARE_TEST(RefinableSet_rational_boost_vector) \
CDSUNIT_DECLARE_TEST(RefinableSet_rational_boost_stable_vector) \
CDSUNIT_DECLARE_TEST(RefinableSet_rational_boost_set)
-# define CDSUNIT_DEFINE_RefinableSet_boost_container( IMPL, C ) \
- TEST_SET(IMPL, C, RefinableSet_boost_list) \
- TEST_SET(IMPL, C, RefinableSet_boost_slist) \
- TEST_SET(IMPL, C, RefinableSet_boost_vector) \
- TEST_SET(IMPL, C, RefinableSet_boost_stable_vector) \
- TEST_SET(IMPL, C, RefinableSet_boost_set) \
- TEST_SET(IMPL, C, RefinableSet_rational_boost_list) \
- TEST_SET(IMPL, C, RefinableSet_rational_boost_slist) \
- TEST_SET(IMPL, C, RefinableSet_rational_boost_vector) \
- TEST_SET(IMPL, C, RefinableSet_rational_boost_stable_vector) \
- TEST_SET(IMPL, C, RefinableSet_rational_boost_set)
+
# define CDSUNIT_TEST_RefinableSet_boost_container \
CPPUNIT_TEST(RefinableSet_boost_list) \
CPPUNIT_TEST(RefinableSet_boost_slist) \
CPPUNIT_TEST(RefinableSet_rational_boost_set)
#else
# define CDSUNIT_DECLARE_RefinableSet_boost_container
-# define CDSUNIT_DEFINE_RefinableSet_boost_container( IMPL, C ) \
# define CDSUNIT_TEST_RefinableSet_boost_container
#endif
# define CDSUNIT_DECLARE_RefinableSet_boost_flat_container \
CDSUNIT_DECLARE_TEST(RefinableSet_boost_flat_set) \
CDSUNIT_DECLARE_TEST(RefinableSet_rational_boost_flat_set)
-# define CDSUNIT_DEFINE_RefinableSet_boost_flat_container( IMPL, C ) \
- TEST_SET(IMPL, C, RefinableSet_boost_flat_set) \
- TEST_SET(IMPL, C, RefinableSet_rational_boost_flat_set)
+
# define CDSUNIT_TEST_RefinableSet_boost_flat_container \
CPPUNIT_TEST(RefinableSet_boost_flat_set) \
CPPUNIT_TEST(RefinableSet_rational_boost_flat_set)
#else
# define CDSUNIT_DECLARE_RefinableSet_boost_flat_container
-# define CDSUNIT_DEFINE_RefinableSet_boost_flat_container( IMPL, C )
# define CDSUNIT_TEST_RefinableSet_boost_flat_container
#endif
CDSUNIT_DECLARE_RefinableSet_common \
CDSUNIT_DECLARE_RefinableSet_boost_container \
CDSUNIT_DECLARE_RefinableSet_boost_flat_container
-#define CDSUNIT_DEFINE_RefinableSet( IMPL, C ) \
- CDSUNIT_DEFINE_RefinableSet_common( IMPL, C ) \
- CDSUNIT_DEFINE_RefinableSet_boost_container( IMPL, C ) \
- CDSUNIT_DEFINE_RefinableSet_boost_flat_container( IMPL, C )
+
#define CDSUNIT_TEST_RefinableSet \
CDSUNIT_TEST_RefinableSet_common \
CDSUNIT_TEST_RefinableSet_boost_container \
namespace set2 {
CPPUNIT_TEST_SUITE_REGISTRATION( Set_DelOdd );
- size_t Set_DelOdd::c_nSetSize = 1000000;
- size_t Set_DelOdd::c_nInsThreadCount;
- size_t Set_DelOdd::c_nDelThreadCount;
- size_t Set_DelOdd::c_nExtractThreadCount;
- size_t Set_DelOdd::c_nMaxLoadFactor;
- bool Set_DelOdd::c_bPrintGCState;
-
void Set_DelOdd::setUpParams( const CppUnitMini::TestCfg& cfg )
{
c_nSetSize = cfg.getSizeT("MapSize", c_nSetSize );
c_nMaxLoadFactor = cfg.getSizeT("MaxLoadFactor", c_nMaxLoadFactor);
c_bPrintGCState = cfg.getBool("PrintGCStateFlag", true );
+ c_nCuckooInitialSize = cfg.getSizeT("CuckooInitialSize", c_nCuckooInitialSize );
+ c_nCuckooProbesetSize = cfg.getSizeT("CuckooProbesetSize", c_nCuckooProbesetSize );
+ c_nCuckooProbesetThreshold = cfg.getSizeT("CuckooProbesetThreshold", c_nCuckooProbesetThreshold );
+
if ( c_nInsThreadCount == 0 )
- c_nInsThreadCount = cds::OS::topology::processor_count();
+ c_nInsThreadCount = std::thread::hardware_concurrency();
if ( c_nDelThreadCount == 0 && c_nExtractThreadCount == 0 ) {
- c_nExtractThreadCount = cds::OS::topology::processor_count() / 2;
- c_nDelThreadCount = cds::OS::topology::processor_count() - c_nExtractThreadCount;
+ c_nExtractThreadCount = std::thread::hardware_concurrency() / 2;
+ c_nDelThreadCount = std::thread::hardware_concurrency() - c_nExtractThreadCount;
}
m_arrData.resize( c_nSetSize );
m_arrData[i] = i;
shuffle( m_arrData.begin(), m_arrData.end() );
}
-
- void Set_DelOdd::myRun(const char *in_name, bool invert /*= false*/)
- {
- setUpParams( m_Cfg.get( "Map_DelOdd" ));
-
- run_MichaelSet(in_name, invert);
- run_SplitList(in_name, invert);
- run_SkipListSet(in_name, invert);
- run_EllenBinTreeSet(in_name, invert);
- run_CuckooSet(in_name, invert);
-
- endTestCase();
- }
} // namespace set2
namespace set2 {
-# define TEST_SET(IMPL, C, X) void C::X() { test<set_type<IMPL, key_type, value_type>::X >(); }
-# define TEST_SET_EXTRACT(IMPL, C, X) void C::X() { test_extract<set_type<IMPL, key_type, value_type>::X >(); }
-# define TEST_SET_NOLF(IMPL, C, X) void C::X() { test_nolf<set_type<IMPL, key_type, value_type>::X >(); }
-# define TEST_SET_NOLF_EXTRACT(IMPL, C, X) void C::X() { test_nolf_extract<set_type<IMPL, key_type, value_type>::X >(); }
+#define TEST_CASE(TAG, X) void X();
namespace {
struct key_thread
class Set_DelOdd: public CppUnitMini::TestCase
{
- static size_t c_nSetSize; // max set size
- static size_t c_nInsThreadCount; // insert thread count
- static size_t c_nDelThreadCount; // delete thread count
- static size_t c_nExtractThreadCount; // extract thread count
- static size_t c_nMaxLoadFactor; // maximum load factor
- static bool c_bPrintGCState;
-
+ public:
+ size_t c_nSetSize =1000000; // max set size
+ size_t c_nInsThreadCount = 4; // insert thread count
+ size_t c_nDelThreadCount = 4; // delete thread count
+ size_t c_nExtractThreadCount = 4; // extract thread count
+ size_t c_nMaxLoadFactor = 8; // maximum load factor
+ bool c_bPrintGCState = true;
+
+ size_t c_nCuckooInitialSize = 1024;// initial size for CuckooSet
+ size_t c_nCuckooProbesetSize = 16; // CuckooSet probeset size (only for list-based probeset)
+ size_t c_nCuckooProbesetThreshold = 0; // CUckooSet probeset threshold (0 - use default)
+
+ size_t c_nLoadFactor = 2;
std::vector<size_t> m_arrData;
protected:
return new InsertThread( *this );
}
- struct ensure_func
+ struct update_functor
{
template <typename Q>
void operator()( bool /*bNew*/, key_value_pair const&, Q const& )
++m_nInsertFailed;
}
- ensure_func f;
+ update_functor f;
for ( size_t i = arrData.size() - 1; i > 0; --i ) {
if ( arrData[i] & 1 ) {
- rSet.ensure( key_type( arrData[i], m_nThreadNo ), f );
+ rSet.update( key_type( arrData[i], m_nThreadNo ), f, true );
}
}
m_nDeleteSuccess =
m_nDeleteFailed = 0;
+ size_t const nInsThreadCount = getTest().c_nInsThreadCount;
std::vector<size_t>& arrData = getTest().m_arrData;
+
if ( m_nThreadNo & 1 ) {
- for ( size_t k = 0; k < c_nInsThreadCount; ++k ) {
+ for ( size_t k = 0; k < nInsThreadCount; ++k ) {
for ( size_t i = 0; i < arrData.size(); ++i ) {
if ( arrData[i] & 1 ) {
if ( rSet.erase_with( arrData[i], key_less() ))
}
}
else {
- for ( size_t k = 0; k < c_nInsThreadCount; ++k ) {
+ for ( size_t k = 0; k < nInsThreadCount; ++k ) {
for ( size_t i = arrData.size() - 1; i > 0; --i ) {
if ( arrData[i] & 1 ) {
if ( rSet.erase_with( arrData[i], key_less() ))
typename Set::guarded_ptr gp;
std::vector<size_t>& arrData = getTest().m_arrData;
+ size_t const nInsThreadCount = getTest().c_nInsThreadCount;
+
if ( m_nThreadNo & 1 ) {
- for ( size_t k = 0; k < c_nInsThreadCount; ++k ) {
+ for ( size_t k = 0; k < nInsThreadCount; ++k ) {
for ( size_t i = 0; i < arrData.size(); ++i ) {
if ( arrData[i] & 1 ) {
gp = rSet.extract_with( arrData[i], key_less());
}
}
else {
- for ( size_t k = 0; k < c_nInsThreadCount; ++k ) {
+ for ( size_t k = 0; k < nInsThreadCount; ++k ) {
for ( size_t i = arrData.size() - 1; i > 0; --i ) {
if ( arrData[i] & 1 ) {
gp = rSet.extract_with( arrData[i], key_less());
typename Set::exempt_ptr xp;
std::vector<size_t>& arrData = getTest().m_arrData;
+ size_t const nInsThreadCount = getTest().c_nInsThreadCount;
+
if ( m_nThreadNo & 1 ) {
- for ( size_t k = 0; k < c_nInsThreadCount; ++k ) {
+ for ( size_t k = 0; k < nInsThreadCount; ++k ) {
for ( size_t i = 0; i < arrData.size(); ++i ) {
if ( arrData[i] & 1 ) {
if ( Set::c_bExtractLockExternal ) {
}
}
else {
- for ( size_t k = 0; k < c_nInsThreadCount; ++k ) {
+ for ( size_t k = 0; k < nInsThreadCount; ++k ) {
for ( size_t i = arrData.size() - 1; i > 0; --i ) {
if ( arrData[i] & 1 ) {
if ( Set::c_bExtractLockExternal ) {
size_t nErrorCount = 0;
for ( size_t n = 0; n < c_nSetSize; n +=2 ) {
for ( size_t i = 0; i < c_nInsThreadCount; ++i ) {
- if ( !testSet.find( key_type(n, i) ) ) {
+ if ( !testSet.contains( key_type(n, i) ) ) {
if ( ++nErrorCount < 10 ) {
CPPUNIT_MSG( "key " << n << "-" << i << " is not found!");
}
}
template <class Set>
- void test()
+ void run_test()
{
+ static_assert( !Set::c_bExtractSupported, "Set class must not support extract() method" );
+
CPPUNIT_MSG( "Insert thread count=" << c_nInsThreadCount
<< " delete thread count=" << c_nDelThreadCount
<< " set size=" << c_nSetSize
);
- for ( size_t nLoadFactor = 1; nLoadFactor <= c_nMaxLoadFactor; nLoadFactor *= 2 ) {
- CPPUNIT_MSG( "Load factor=" << nLoadFactor );
- do_test<Set>( nLoadFactor );
- if ( c_bPrintGCState )
- print_gc_state();
- }
- }
+ if ( Set::c_bLoadFactorDepended ) {
+ for ( c_nLoadFactor = 1; c_nLoadFactor <= c_nMaxLoadFactor; c_nLoadFactor *= 2 ) {
+ CPPUNIT_MSG( "Load factor=" << c_nLoadFactor );
- template <class Set>
- void test_extract()
- {
- CPPUNIT_MSG( "Insert thread count=" << c_nInsThreadCount
- << " delete thread count=" << c_nDelThreadCount
- << " extract thread count=" << c_nExtractThreadCount
- << " set size=" << c_nSetSize
- );
+ Set testSet( *this );
+ do_test_with( testSet );
+ analyze( testSet );
+
+ if ( c_bPrintGCState )
+ print_gc_state();
+ }
+ }
+ else {
+ Set testSet( *this );
+ do_test_with( testSet );
+ analyze( testSet );
- for ( size_t nLoadFactor = 1; nLoadFactor <= c_nMaxLoadFactor; nLoadFactor *= 2 ) {
- CPPUNIT_MSG( "Load factor=" << nLoadFactor );
- do_test_extract<Set>( nLoadFactor );
if ( c_bPrintGCState )
print_gc_state();
}
}
template <class Set>
- void test_nolf()
+ void run_test_extract()
{
- CPPUNIT_MSG( "Insert thread count=" << c_nInsThreadCount
- << " delete thread count=" << c_nDelThreadCount
- << " set size=" << c_nSetSize
- );
-
- {
- Set s;
- do_test_with( s );
- analyze( s );
- }
-
- if ( c_bPrintGCState )
- print_gc_state();
- }
+ static_assert( Set::c_bExtractSupported, "Set class must support extract() method" );
- template <class Set>
- void test_nolf_extract()
- {
CPPUNIT_MSG( "Insert thread count=" << c_nInsThreadCount
<< " delete thread count=" << c_nDelThreadCount
<< " extract thread count=" << c_nExtractThreadCount
<< " set size=" << c_nSetSize
);
- {
- Set s;
- do_test_extract_with( s );
- analyze( s );
+ if ( Set::c_bLoadFactorDepended ) {
+ for ( c_nLoadFactor = 1; c_nLoadFactor <= c_nMaxLoadFactor; c_nLoadFactor *= 2 ) {
+ CPPUNIT_MSG( "Load factor=" << c_nLoadFactor );
+
+ Set testSet( *this );
+ do_test_extract_with( testSet );
+ analyze( testSet );
+
+ if ( c_bPrintGCState )
+ print_gc_state();
+ }
}
+ else {
+ Set testSet( *this );
+ do_test_extract_with( testSet );
+ analyze( testSet );
- if ( c_bPrintGCState )
- print_gc_state();
+ if ( c_bPrintGCState )
+ print_gc_state();
+ }
}
void setUpParams( const CppUnitMini::TestCfg& cfg );
- void run_MichaelSet(const char *in_name, bool invert = false);
- void run_SplitList(const char *in_name, bool invert = false);
- void run_CuckooSet(const char *in_name, bool invert = false);
- void run_SkipListSet(const char *in_name, bool invert = false);
- void run_EllenBinTreeSet(const char *in_name, bool invert = false);
-
- virtual void myRun(const char *in_name, bool invert = false);
-
-
# include "set2/set_defs.h"
CDSUNIT_DECLARE_MichaelSet
CDSUNIT_DECLARE_SplitList
- CDSUNIT_DECLARE_CuckooSet
CDSUNIT_DECLARE_SkipListSet
CDSUNIT_DECLARE_EllenBinTreeSet
+ CDSUNIT_DECLARE_CuckooSet
+
+ CPPUNIT_TEST_SUITE(Set_DelOdd)
+ CDSUNIT_TEST_MichaelSet
+ CDSUNIT_TEST_SplitList
+ CDSUNIT_TEST_SkipListSet
+ CDSUNIT_TEST_EllenBinTreeSet
+ CDSUNIT_TEST_CuckooSet
+
+ //CDSUNIT_TEST_MultiLevelHashSet // the test is not suitable
+ CPPUNIT_TEST_SUITE_END();
};
} // namespace set2
#include "set2/set_delodd.h"
#include "set2/set_type_cuckoo.h"
-namespace set2 {
- CDSUNIT_DEFINE_CuckooSet( cc::cuckoo::implementation_tag, Set_DelOdd )
-
- CPPUNIT_TEST_SUITE_PART( Set_DelOdd, run_CuckooSet )
- CDSUNIT_TEST_CuckooSet
- CPPUNIT_TEST_SUITE_END_PART()
+#undef TEST_CASE
+#define TEST_CASE(TAG, X) void Set_DelOdd::X() { run_test<typename set_type< TAG, key_type, value_type>::X>(); }
+#include "set2/set_defs.h"
+namespace set2 {
+ CDSUNIT_DECLARE_CuckooSet
} // namespace set2
#include "set2/set_delodd.h"
#include "set2/set_type_ellen_bintree.h"
-namespace set2 {
- CDSUNIT_DEFINE_EllenBinTreeSet( cc::ellen_bintree::implementation_tag, Set_DelOdd )
-
- CPPUNIT_TEST_SUITE_PART( Set_DelOdd, run_EllenBinTreeSet )
- CDSUNIT_TEST_EllenBinTreeSet
- CPPUNIT_TEST_SUITE_END_PART()
+#undef TEST_CASE
+#define TEST_CASE(TAG, X) void Set_DelOdd::X() { run_test_extract<typename set_type< TAG, key_type, value_type>::X>(); }
+#include "set2/set_defs.h"
+namespace set2 {
+ CDSUNIT_DECLARE_EllenBinTreeSet
} // namespace set2
#include "set2/set_delodd.h"
#include "set2/set_type_michael.h"
-namespace set2 {
- CDSUNIT_DEFINE_MichaelSet(cc::michael_set::implementation_tag, Set_DelOdd)
-
- CPPUNIT_TEST_SUITE_PART( Set_DelOdd, run_MichaelSet )
- CDSUNIT_TEST_MichaelSet
- CPPUNIT_TEST_SUITE_END_PART()
+#undef TEST_CASE
+#define TEST_CASE(TAG, X) void Set_DelOdd::X() { run_test_extract<typename set_type< TAG, key_type, value_type>::X>(); }
+#include "set2/set_defs.h"
+namespace set2 {
+ CDSUNIT_DECLARE_MichaelSet
} // namespace set2
#include "set2/set_delodd.h"
#include "set2/set_type_skip_list.h"
-namespace set2 {
- CDSUNIT_DEFINE_SkipListSet(cc::skip_list::implementation_tag, Set_DelOdd)
-
- CPPUNIT_TEST_SUITE_PART( Set_DelOdd, run_SkipListSet )
- CDSUNIT_TEST_SkipListSet
- CPPUNIT_TEST_SUITE_END_PART()
+#undef TEST_CASE
+#define TEST_CASE(TAG, X) void Set_DelOdd::X() { run_test_extract<typename set_type< TAG, key_type, value_type>::X>(); }
+#include "set2/set_defs.h"
+namespace set2 {
+ CDSUNIT_DECLARE_SkipListSet
} // namespace set2
#include "set2/set_delodd.h"
#include "set2/set_type_split_list.h"
-namespace set2 {
- CDSUNIT_DEFINE_SplitList(cc::split_list::implementation_tag, Set_DelOdd)
-
- CPPUNIT_TEST_SUITE_PART( Set_DelOdd, run_SplitList )
- CDSUNIT_TEST_SplitList
- CPPUNIT_TEST_SUITE_END_PART()
+#undef TEST_CASE
+#define TEST_CASE(TAG, X) void Set_DelOdd::X() { run_test_extract<typename set_type< TAG, key_type, value_type>::X>(); }
+#include "set2/set_defs.h"
+namespace set2 {
+ CDSUNIT_DECLARE_SplitList
} // namespace set2
typedef cc::CuckooSet< V, Traits > cuckoo_base_class;
public:
- CuckooSet( size_t nCapacity, size_t nLoadFactor )
- : cuckoo_base_class( nCapacity / (nLoadFactor * 16), (unsigned int)4 )
+ template <typename Config>
+ CuckooSet( Config const& cfg )
+ : cuckoo_base_class(
+ cfg.c_nCuckooInitialSize,
+ static_cast<unsigned int>( cfg.c_nCuckooProbesetSize ),
+ static_cast<unsigned int>( cfg.c_nCuckooProbesetThreshold )
+ )
{}
template <typename Q, typename Pred>
{
return cuckoo_base_class::erase_with( key, typename std::conditional< cuckoo_base_class::c_isSorted, Pred, typename Pred::equal_to>::type() );
}
+
+ // for testing
+ static CDS_CONSTEXPR bool const c_bExtractSupported = false;
+ static CDS_CONSTEXPR bool const c_bLoadFactorDepended = false;
+
};
+ struct tag_CuckooSet;
template <typename Key, typename Val>
- struct set_type< cds::intrusive::cuckoo::implementation_tag, Key, Val >: public set_type_base< Key, Val >
+ struct set_type< tag_CuckooSet, Key, Val >: public set_type_base< Key, Val >
{
typedef set_type_base< Key, Val > base_class;
typedef typename base_class::key_val key_val;
namespace set2 {
+ template <class GC, typename Key, typename T, typename Traits = cc::ellen_bintree::traits >
+ class EllenBinTreeSet : public cc::EllenBinTreeSet< GC, Key, T, Traits >
+ {
+ typedef cc::EllenBinTreeSet< GC, Key, T, Traits > base_class;
+ public:
+ template <typename Config>
+ EllenBinTreeSet( Config const& /*cfg*/ )
+ {}
+
+ // for testing
+ static CDS_CONSTEXPR bool const c_bExtractSupported = true;
+ static CDS_CONSTEXPR bool const c_bLoadFactorDepended = false;
+ };
+
+ struct tag_EllenBinTreeSet;
+
template <typename Key, typename Val>
- struct set_type< cc::ellen_bintree::implementation_tag, Key, Val >: public set_type_base< Key, Val >
+ struct set_type< tag_EllenBinTreeSet, Key, Val >: public set_type_base< Key, Val >
{
typedef set_type_base< Key, Val > base_class;
typedef typename base_class::key_type key_type;
{
typedef cds::memory::pool_allocator< typename ellen_bintree_props::hp_gc::update_desc, ellen_bintree_pool::update_desc_pool_accessor > update_desc_allocator;
};
- typedef cc::EllenBinTreeSet< cds::gc::HP, key_type, key_val, traits_EllenBinTreeSet_hp > EllenBinTreeSet_hp;
+ typedef EllenBinTreeSet< cds::gc::HP, key_type, key_val, traits_EllenBinTreeSet_hp > EllenBinTreeSet_hp;
struct traits_EllenBinTreeSet_dhp : public traits_EllenBinTreeSet
{
typedef cds::memory::pool_allocator< typename ellen_bintree_props::dhp_gc::update_desc, ellen_bintree_pool::update_desc_pool_accessor > update_desc_allocator;
};
- typedef cc::EllenBinTreeSet< cds::gc::DHP, key_type, key_val, traits_EllenBinTreeSet_dhp > EllenBinTreeSet_dhp;
+ typedef EllenBinTreeSet< cds::gc::DHP, key_type, key_val, traits_EllenBinTreeSet_dhp > EllenBinTreeSet_dhp;
struct traits_EllenBinTreeSet_gpi : public traits_EllenBinTreeSet
{
typedef cds::memory::pool_allocator< typename ellen_bintree_props::gpi::update_desc, ellen_bintree_pool::update_desc_pool_accessor > update_desc_allocator;
};
- typedef cc::EllenBinTreeSet< rcu_gpi, key_type, key_val, traits_EllenBinTreeSet_gpi > EllenBinTreeSet_rcu_gpi;
+ typedef EllenBinTreeSet< rcu_gpi, key_type, key_val, traits_EllenBinTreeSet_gpi > EllenBinTreeSet_rcu_gpi;
struct traits_EllenBinTreeSet_gpb : public traits_EllenBinTreeSet
{
typedef cds::memory::pool_allocator< typename ellen_bintree_props::gpb::update_desc, ellen_bintree_pool::update_desc_pool_accessor > update_desc_allocator;
};
- typedef cc::EllenBinTreeSet< rcu_gpb, key_type, key_val, traits_EllenBinTreeSet_gpb > EllenBinTreeSet_rcu_gpb;
+ typedef EllenBinTreeSet< rcu_gpb, key_type, key_val, traits_EllenBinTreeSet_gpb > EllenBinTreeSet_rcu_gpb;
struct traits_EllenBinTreeSet_gpt : public traits_EllenBinTreeSet
{
typedef cds::memory::pool_allocator< typename ellen_bintree_props::gpt::update_desc, ellen_bintree_pool::update_desc_pool_accessor > update_desc_allocator;
};
- typedef cc::EllenBinTreeSet< rcu_gpt, key_type, key_val, traits_EllenBinTreeSet_gpt > EllenBinTreeSet_rcu_gpt;
+ typedef EllenBinTreeSet< rcu_gpt, key_type, key_val, traits_EllenBinTreeSet_gpt > EllenBinTreeSet_rcu_gpt;
#ifdef CDS_URCU_SIGNAL_HANDLING_ENABLED
struct traits_EllenBinTreeSet_shb : public traits_EllenBinTreeSet
{
typedef cds::memory::pool_allocator< typename ellen_bintree_props::shb::update_desc, ellen_bintree_pool::update_desc_pool_accessor > update_desc_allocator;
};
- typedef cc::EllenBinTreeSet< rcu_shb, key_type, key_val, traits_EllenBinTreeSet_shb > EllenBinTreeSet_rcu_shb;
+ typedef EllenBinTreeSet< rcu_shb, key_type, key_val, traits_EllenBinTreeSet_shb > EllenBinTreeSet_rcu_shb;
struct traits_EllenBinTreeSet_sht : public traits_EllenBinTreeSet
{
typedef cds::memory::pool_allocator< typename ellen_bintree_props::sht::update_desc, ellen_bintree_pool::update_desc_pool_accessor > update_desc_allocator;
};
- typedef cc::EllenBinTreeSet< rcu_sht, key_type, key_val, traits_EllenBinTreeSet_sht > EllenBinTreeSet_rcu_sht;
+ typedef EllenBinTreeSet< rcu_sht, key_type, key_val, traits_EllenBinTreeSet_sht > EllenBinTreeSet_rcu_sht;
#endif
//
{
typedef cds::memory::pool_allocator< typename ellen_bintree_props::hp_gc::update_desc, ellen_bintree_pool::update_desc_pool_accessor > update_desc_allocator;
};
- typedef cc::EllenBinTreeSet< cds::gc::HP, key_type, key_val, traits_EllenBinTreeSet_yield_hp > EllenBinTreeSet_yield_hp;
+ typedef EllenBinTreeSet< cds::gc::HP, key_type, key_val, traits_EllenBinTreeSet_yield_hp > EllenBinTreeSet_yield_hp;
struct traits_EllenBinTreeSet_yield_dhp : public traits_EllenBinTreeSet_yield
{
typedef cds::memory::pool_allocator< typename ellen_bintree_props::dhp_gc::update_desc, ellen_bintree_pool::update_desc_pool_accessor > update_desc_allocator;
};
- typedef cc::EllenBinTreeSet< cds::gc::DHP, key_type, key_val, traits_EllenBinTreeSet_yield_dhp > EllenBinTreeSet_yield_dhp;
+ typedef EllenBinTreeSet< cds::gc::DHP, key_type, key_val, traits_EllenBinTreeSet_yield_dhp > EllenBinTreeSet_yield_dhp;
struct traits_EllenBinTreeSet_yield_gpb : public traits_EllenBinTreeSet_yield
{
typedef cds::memory::pool_allocator< typename ellen_bintree_props::gpb::update_desc, ellen_bintree_pool::update_desc_pool_accessor > update_desc_allocator;
};
- typedef cc::EllenBinTreeSet< rcu_gpb, key_type, key_val, traits_EllenBinTreeSet_yield_gpb > EllenBinTreeSet_yield_rcu_gpb;
+ typedef EllenBinTreeSet< rcu_gpb, key_type, key_val, traits_EllenBinTreeSet_yield_gpb > EllenBinTreeSet_yield_rcu_gpb;
struct traits_EllenBinTreeSet_stat: public cc::ellen_bintree::make_set_traits<
{
typedef cds::memory::pool_allocator< typename ellen_bintree_props::hp_gc::update_desc, ellen_bintree_pool::update_desc_pool_accessor > update_desc_allocator;
};
- typedef cc::EllenBinTreeSet< cds::gc::HP, key_type, key_val, traits_EllenBinTreeSet_stat_hp > EllenBinTreeSet_hp_stat;
+ typedef EllenBinTreeSet< cds::gc::HP, key_type, key_val, traits_EllenBinTreeSet_stat_hp > EllenBinTreeSet_hp_stat;
struct traits_EllenBinTreeSet_stat_dhp : public traits_EllenBinTreeSet_stat
{
typedef cds::memory::pool_allocator< typename ellen_bintree_props::dhp_gc::update_desc, ellen_bintree_pool::update_desc_pool_accessor > update_desc_allocator;
};
- typedef cc::EllenBinTreeSet< cds::gc::DHP, key_type, key_val, traits_EllenBinTreeSet_stat_dhp > EllenBinTreeSet_dhp_stat;
+ typedef EllenBinTreeSet< cds::gc::DHP, key_type, key_val, traits_EllenBinTreeSet_stat_dhp > EllenBinTreeSet_dhp_stat;
struct traits_EllenBinTreeSet_stat_gpi : public traits_EllenBinTreeSet_stat
{
typedef cds::memory::pool_allocator< typename ellen_bintree_props::gpi::update_desc, ellen_bintree_pool::update_desc_pool_accessor > update_desc_allocator;
};
- typedef cc::EllenBinTreeSet< rcu_gpi, key_type, key_val, traits_EllenBinTreeSet_stat_gpi > EllenBinTreeSet_rcu_gpi_stat;
+ typedef EllenBinTreeSet< rcu_gpi, key_type, key_val, traits_EllenBinTreeSet_stat_gpi > EllenBinTreeSet_rcu_gpi_stat;
struct traits_EllenBinTreeSet_stat_gpb : public traits_EllenBinTreeSet_stat
{
typedef cds::memory::pool_allocator< typename ellen_bintree_props::gpb::update_desc, ellen_bintree_pool::update_desc_pool_accessor > update_desc_allocator;
};
- typedef cc::EllenBinTreeSet< rcu_gpb, key_type, key_val, traits_EllenBinTreeSet_stat_gpb > EllenBinTreeSet_rcu_gpb_stat;
+ typedef EllenBinTreeSet< rcu_gpb, key_type, key_val, traits_EllenBinTreeSet_stat_gpb > EllenBinTreeSet_rcu_gpb_stat;
struct traits_EllenBinTreeSet_stat_gpt : public traits_EllenBinTreeSet_stat
{
typedef cds::memory::pool_allocator< typename ellen_bintree_props::gpt::update_desc, ellen_bintree_pool::update_desc_pool_accessor > update_desc_allocator;
};
- typedef cc::EllenBinTreeSet< rcu_gpt, key_type, key_val, traits_EllenBinTreeSet_stat_gpt > EllenBinTreeSet_rcu_gpt_stat;
+ typedef EllenBinTreeSet< rcu_gpt, key_type, key_val, traits_EllenBinTreeSet_stat_gpt > EllenBinTreeSet_rcu_gpt_stat;
#ifdef CDS_URCU_SIGNAL_HANDLING_ENABLED
struct traits_EllenBinTreeSet_stat_shb : public traits_EllenBinTreeSet_stat
{
typedef cds::memory::pool_allocator< typename ellen_bintree_props::shb::update_desc, ellen_bintree_pool::update_desc_pool_accessor > update_desc_allocator;
};
- typedef cc::EllenBinTreeSet< rcu_shb, key_type, key_val, traits_EllenBinTreeSet_stat_shb > EllenBinTreeSet_rcu_shb_stat;
+ typedef EllenBinTreeSet< rcu_shb, key_type, key_val, traits_EllenBinTreeSet_stat_shb > EllenBinTreeSet_rcu_shb_stat;
struct traits_EllenBinTreeSet_stat_sht : public traits_EllenBinTreeSet_stat
{
typedef cds::memory::pool_allocator< typename ellen_bintree_props::sht::update_desc, ellen_bintree_pool::update_desc_pool_accessor > update_desc_allocator;
};
- typedef cc::EllenBinTreeSet< rcu_sht, key_type, key_val, traits_EllenBinTreeSet_stat_sht > EllenBinTreeSet_rcu_sht_stat;
+ typedef EllenBinTreeSet< rcu_sht, key_type, key_val, traits_EllenBinTreeSet_stat_sht > EllenBinTreeSet_rcu_sht_stat;
#endif
};
template <typename GC, typename Key, typename T, typename Traits>
- static inline void print_stat( cc::EllenBinTreeSet<GC, Key, T, Traits> const& s )
+ static inline void print_stat( EllenBinTreeSet<GC, Key, T, Traits> const& s )
{
CPPUNIT_MSG( s.statistics() );
}
} // namespace ellen_bintree_check
template <typename GC, typename Key, typename T, typename Traits>
- static inline void additional_check( cc::EllenBinTreeSet<GC, Key, T, Traits>& s )
+ static inline void additional_check( EllenBinTreeSet<GC, Key, T, Traits>& s )
{
GC::force_dispose();
ellen_bintree_check::check_stat( s.statistics() );
}
template <typename GC, typename Key, typename T, typename Traits>
- static inline void additional_cleanup( cc::EllenBinTreeSet<GC, Key, T, Traits>& /*s*/ )
+ static inline void additional_cleanup( EllenBinTreeSet<GC, Key, T, Traits>& /*s*/ )
{
ellen_bintree_pool::internal_node_counter::reset();
}
namespace set2 {
+ template <class GC, typename List, typename Traits = cc::michael_set::traits>
+ class MichaelHashSet : public cc::MichaelHashSet< GC, List, Traits >
+ {
+ typedef cc::MichaelHashSet< GC, List, Traits > base_class;
+ public:
+ template <class Config>
+ MichaelHashSet( Config const& cfg )
+ : base_class( cfg.c_nSetSize, cfg.c_nLoadFactor )
+ {}
+
+ // for testing
+ static CDS_CONSTEXPR bool const c_bExtractSupported = true;
+ static CDS_CONSTEXPR bool const c_bLoadFactorDepended = true;
+ };
+
+ struct tag_MichaelHashSet;
+
template <typename Key, typename Val>
- struct set_type< cc::michael_set::implementation_tag, Key, Val >: public set_type_base< Key, Val >
+ struct set_type< tag_MichaelHashSet, Key, Val >: public set_type_base< Key, Val >
{
typedef set_type_base< Key, Val > base_class;
typedef typename base_class::key_val key_val;
co::hash< hash >
>::type
{};
- typedef cc::MichaelHashSet< cds::gc::HP, typename ml::MichaelList_HP_cmp_stdAlloc, traits_MichaelSet_stdAlloc > MichaelSet_HP_cmp_stdAlloc;
- typedef cc::MichaelHashSet< cds::gc::DHP, typename ml::MichaelList_DHP_cmp_stdAlloc, traits_MichaelSet_stdAlloc > MichaelSet_DHP_cmp_stdAlloc;
- typedef cc::MichaelHashSet< rcu_gpi, typename ml::MichaelList_RCU_GPI_cmp_stdAlloc, traits_MichaelSet_stdAlloc > MichaelSet_RCU_GPI_cmp_stdAlloc;
- typedef cc::MichaelHashSet< rcu_gpb, typename ml::MichaelList_RCU_GPB_cmp_stdAlloc, traits_MichaelSet_stdAlloc > MichaelSet_RCU_GPB_cmp_stdAlloc;
- typedef cc::MichaelHashSet< rcu_gpt, typename ml::MichaelList_RCU_GPT_cmp_stdAlloc, traits_MichaelSet_stdAlloc > MichaelSet_RCU_GPT_cmp_stdAlloc;
+ typedef MichaelHashSet< cds::gc::HP, typename ml::MichaelList_HP_cmp_stdAlloc, traits_MichaelSet_stdAlloc > MichaelSet_HP_cmp_stdAlloc;
+ typedef MichaelHashSet< cds::gc::DHP, typename ml::MichaelList_DHP_cmp_stdAlloc, traits_MichaelSet_stdAlloc > MichaelSet_DHP_cmp_stdAlloc;
+ typedef MichaelHashSet< rcu_gpi, typename ml::MichaelList_RCU_GPI_cmp_stdAlloc, traits_MichaelSet_stdAlloc > MichaelSet_RCU_GPI_cmp_stdAlloc;
+ typedef MichaelHashSet< rcu_gpb, typename ml::MichaelList_RCU_GPB_cmp_stdAlloc, traits_MichaelSet_stdAlloc > MichaelSet_RCU_GPB_cmp_stdAlloc;
+ typedef MichaelHashSet< rcu_gpt, typename ml::MichaelList_RCU_GPT_cmp_stdAlloc, traits_MichaelSet_stdAlloc > MichaelSet_RCU_GPT_cmp_stdAlloc;
#ifdef CDS_URCU_SIGNAL_HANDLING_ENABLED
- typedef cc::MichaelHashSet< rcu_shb, typename ml::MichaelList_RCU_SHB_cmp_stdAlloc, traits_MichaelSet_stdAlloc > MichaelSet_RCU_SHB_cmp_stdAlloc;
- typedef cc::MichaelHashSet< rcu_sht, typename ml::MichaelList_RCU_SHT_cmp_stdAlloc, traits_MichaelSet_stdAlloc > MichaelSet_RCU_SHT_cmp_stdAlloc;
+ typedef MichaelHashSet< rcu_shb, typename ml::MichaelList_RCU_SHB_cmp_stdAlloc, traits_MichaelSet_stdAlloc > MichaelSet_RCU_SHB_cmp_stdAlloc;
+ typedef MichaelHashSet< rcu_sht, typename ml::MichaelList_RCU_SHT_cmp_stdAlloc, traits_MichaelSet_stdAlloc > MichaelSet_RCU_SHT_cmp_stdAlloc;
#endif
- typedef cc::MichaelHashSet< cds::gc::HP, typename ml::MichaelList_HP_less_stdAlloc, traits_MichaelSet_stdAlloc > MichaelSet_HP_less_stdAlloc;
- typedef cc::MichaelHashSet< cds::gc::DHP, typename ml::MichaelList_DHP_less_stdAlloc, traits_MichaelSet_stdAlloc > MichaelSet_DHP_less_stdAlloc;
- typedef cc::MichaelHashSet< rcu_gpi, typename ml::MichaelList_RCU_GPI_less_stdAlloc, traits_MichaelSet_stdAlloc > MichaelSet_RCU_GPI_less_stdAlloc;
- typedef cc::MichaelHashSet< rcu_gpb, typename ml::MichaelList_RCU_GPB_less_stdAlloc, traits_MichaelSet_stdAlloc > MichaelSet_RCU_GPB_less_stdAlloc;
- typedef cc::MichaelHashSet< rcu_gpt, typename ml::MichaelList_RCU_GPT_less_stdAlloc, traits_MichaelSet_stdAlloc > MichaelSet_RCU_GPT_less_stdAlloc;
+ typedef MichaelHashSet< cds::gc::HP, typename ml::MichaelList_HP_less_stdAlloc, traits_MichaelSet_stdAlloc > MichaelSet_HP_less_stdAlloc;
+ typedef MichaelHashSet< cds::gc::DHP, typename ml::MichaelList_DHP_less_stdAlloc, traits_MichaelSet_stdAlloc > MichaelSet_DHP_less_stdAlloc;
+ typedef MichaelHashSet< rcu_gpi, typename ml::MichaelList_RCU_GPI_less_stdAlloc, traits_MichaelSet_stdAlloc > MichaelSet_RCU_GPI_less_stdAlloc;
+ typedef MichaelHashSet< rcu_gpb, typename ml::MichaelList_RCU_GPB_less_stdAlloc, traits_MichaelSet_stdAlloc > MichaelSet_RCU_GPB_less_stdAlloc;
+ typedef MichaelHashSet< rcu_gpt, typename ml::MichaelList_RCU_GPT_less_stdAlloc, traits_MichaelSet_stdAlloc > MichaelSet_RCU_GPT_less_stdAlloc;
#ifdef CDS_URCU_SIGNAL_HANDLING_ENABLED
- typedef cc::MichaelHashSet< rcu_shb, typename ml::MichaelList_RCU_SHB_less_stdAlloc, traits_MichaelSet_stdAlloc > MichaelSet_RCU_SHB_less_stdAlloc;
- typedef cc::MichaelHashSet< rcu_sht, typename ml::MichaelList_RCU_SHT_less_stdAlloc, traits_MichaelSet_stdAlloc > MichaelSet_RCU_SHT_less_stdAlloc;
+ typedef MichaelHashSet< rcu_shb, typename ml::MichaelList_RCU_SHB_less_stdAlloc, traits_MichaelSet_stdAlloc > MichaelSet_RCU_SHB_less_stdAlloc;
+ typedef MichaelHashSet< rcu_sht, typename ml::MichaelList_RCU_SHT_less_stdAlloc, traits_MichaelSet_stdAlloc > MichaelSet_RCU_SHT_less_stdAlloc;
#endif
- typedef cc::MichaelHashSet< cds::gc::HP, typename ml::MichaelList_HP_less_stdAlloc_seqcst, traits_MichaelSet_stdAlloc > MichaelSet_HP_less_stdAlloc_seqcst;
- typedef cc::MichaelHashSet< cds::gc::DHP, typename ml::MichaelList_DHP_less_stdAlloc_seqcst, traits_MichaelSet_stdAlloc > MichaelSet_DHP_less_stdAlloc_seqcst;
- typedef cc::MichaelHashSet< rcu_gpi, typename ml::MichaelList_RCU_GPI_less_stdAlloc_seqcst, traits_MichaelSet_stdAlloc > MichaelSet_RCU_GPI_less_stdAlloc_seqcst;
- typedef cc::MichaelHashSet< rcu_gpb, typename ml::MichaelList_RCU_GPB_less_stdAlloc_seqcst, traits_MichaelSet_stdAlloc > MichaelSet_RCU_GPB_less_stdAlloc_seqcst;
- typedef cc::MichaelHashSet< rcu_gpt, typename ml::MichaelList_RCU_GPT_less_stdAlloc_seqcst, traits_MichaelSet_stdAlloc > MichaelSet_RCU_GPT_less_stdAlloc_seqcst;
+ typedef MichaelHashSet< cds::gc::HP, typename ml::MichaelList_HP_less_stdAlloc_seqcst, traits_MichaelSet_stdAlloc > MichaelSet_HP_less_stdAlloc_seqcst;
+ typedef MichaelHashSet< cds::gc::DHP, typename ml::MichaelList_DHP_less_stdAlloc_seqcst, traits_MichaelSet_stdAlloc > MichaelSet_DHP_less_stdAlloc_seqcst;
+ typedef MichaelHashSet< rcu_gpi, typename ml::MichaelList_RCU_GPI_less_stdAlloc_seqcst, traits_MichaelSet_stdAlloc > MichaelSet_RCU_GPI_less_stdAlloc_seqcst;
+ typedef MichaelHashSet< rcu_gpb, typename ml::MichaelList_RCU_GPB_less_stdAlloc_seqcst, traits_MichaelSet_stdAlloc > MichaelSet_RCU_GPB_less_stdAlloc_seqcst;
+ typedef MichaelHashSet< rcu_gpt, typename ml::MichaelList_RCU_GPT_less_stdAlloc_seqcst, traits_MichaelSet_stdAlloc > MichaelSet_RCU_GPT_less_stdAlloc_seqcst;
#ifdef CDS_URCU_SIGNAL_HANDLING_ENABLED
- typedef cc::MichaelHashSet< rcu_shb, typename ml::MichaelList_RCU_SHB_less_stdAlloc_seqcst, traits_MichaelSet_stdAlloc > MichaelSet_RCU_SHB_less_stdAlloc_seqcst;
- typedef cc::MichaelHashSet< rcu_sht, typename ml::MichaelList_RCU_SHT_less_stdAlloc_seqcst, traits_MichaelSet_stdAlloc > MichaelSet_RCU_SHT_less_stdAlloc_seqcst;
+ typedef MichaelHashSet< rcu_shb, typename ml::MichaelList_RCU_SHB_less_stdAlloc_seqcst, traits_MichaelSet_stdAlloc > MichaelSet_RCU_SHB_less_stdAlloc_seqcst;
+ typedef MichaelHashSet< rcu_sht, typename ml::MichaelList_RCU_SHT_less_stdAlloc_seqcst, traits_MichaelSet_stdAlloc > MichaelSet_RCU_SHT_less_stdAlloc_seqcst;
#endif
struct traits_MichaelSet_michaelAlloc :
co::allocator< memory::MichaelAllocator<int> >
>::type
{};
- typedef cc::MichaelHashSet< cds::gc::HP, typename ml::MichaelList_HP_cmp_michaelAlloc, traits_MichaelSet_michaelAlloc > MichaelSet_HP_cmp_michaelAlloc;
- typedef cc::MichaelHashSet< cds::gc::DHP, typename ml::MichaelList_DHP_cmp_michaelAlloc, traits_MichaelSet_michaelAlloc > MichaelSet_DHP_cmp_michaelAlloc;
- typedef cc::MichaelHashSet< rcu_gpi, typename ml::MichaelList_RCU_GPI_cmp_michaelAlloc, traits_MichaelSet_michaelAlloc > MichaelSet_RCU_GPI_cmp_michaelAlloc;
- typedef cc::MichaelHashSet< rcu_gpb, typename ml::MichaelList_RCU_GPB_cmp_michaelAlloc, traits_MichaelSet_michaelAlloc > MichaelSet_RCU_GPB_cmp_michaelAlloc;
- typedef cc::MichaelHashSet< rcu_gpt, typename ml::MichaelList_RCU_GPT_cmp_michaelAlloc, traits_MichaelSet_michaelAlloc > MichaelSet_RCU_GPT_cmp_michaelAlloc;
+ typedef MichaelHashSet< cds::gc::HP, typename ml::MichaelList_HP_cmp_michaelAlloc, traits_MichaelSet_michaelAlloc > MichaelSet_HP_cmp_michaelAlloc;
+ typedef MichaelHashSet< cds::gc::DHP, typename ml::MichaelList_DHP_cmp_michaelAlloc, traits_MichaelSet_michaelAlloc > MichaelSet_DHP_cmp_michaelAlloc;
+ typedef MichaelHashSet< rcu_gpi, typename ml::MichaelList_RCU_GPI_cmp_michaelAlloc, traits_MichaelSet_michaelAlloc > MichaelSet_RCU_GPI_cmp_michaelAlloc;
+ typedef MichaelHashSet< rcu_gpb, typename ml::MichaelList_RCU_GPB_cmp_michaelAlloc, traits_MichaelSet_michaelAlloc > MichaelSet_RCU_GPB_cmp_michaelAlloc;
+ typedef MichaelHashSet< rcu_gpt, typename ml::MichaelList_RCU_GPT_cmp_michaelAlloc, traits_MichaelSet_michaelAlloc > MichaelSet_RCU_GPT_cmp_michaelAlloc;
#ifdef CDS_URCU_SIGNAL_HANDLING_ENABLED
- typedef cc::MichaelHashSet< rcu_shb, typename ml::MichaelList_RCU_SHB_cmp_michaelAlloc, traits_MichaelSet_michaelAlloc > MichaelSet_RCU_SHB_cmp_michaelAlloc;
- typedef cc::MichaelHashSet< rcu_sht, typename ml::MichaelList_RCU_SHT_cmp_michaelAlloc, traits_MichaelSet_michaelAlloc > MichaelSet_RCU_SHT_cmp_michaelAlloc;
+ typedef MichaelHashSet< rcu_shb, typename ml::MichaelList_RCU_SHB_cmp_michaelAlloc, traits_MichaelSet_michaelAlloc > MichaelSet_RCU_SHB_cmp_michaelAlloc;
+ typedef MichaelHashSet< rcu_sht, typename ml::MichaelList_RCU_SHT_cmp_michaelAlloc, traits_MichaelSet_michaelAlloc > MichaelSet_RCU_SHT_cmp_michaelAlloc;
#endif
- typedef cc::MichaelHashSet< cds::gc::HP, typename ml::MichaelList_HP_less_michaelAlloc, traits_MichaelSet_michaelAlloc > MichaelSet_HP_less_michaelAlloc;
- typedef cc::MichaelHashSet< cds::gc::DHP, typename ml::MichaelList_DHP_less_michaelAlloc, traits_MichaelSet_michaelAlloc > MichaelSet_DHP_less_michaelAlloc;
- typedef cc::MichaelHashSet< rcu_gpi, typename ml::MichaelList_RCU_GPI_less_michaelAlloc, traits_MichaelSet_michaelAlloc > MichaelSet_RCU_GPI_less_michaelAlloc;
- typedef cc::MichaelHashSet< rcu_gpb, typename ml::MichaelList_RCU_GPB_less_michaelAlloc, traits_MichaelSet_michaelAlloc > MichaelSet_RCU_GPB_less_michaelAlloc;
- typedef cc::MichaelHashSet< rcu_gpt, typename ml::MichaelList_RCU_GPT_less_michaelAlloc, traits_MichaelSet_michaelAlloc > MichaelSet_RCU_GPT_less_michaelAlloc;
+ typedef MichaelHashSet< cds::gc::HP, typename ml::MichaelList_HP_less_michaelAlloc, traits_MichaelSet_michaelAlloc > MichaelSet_HP_less_michaelAlloc;
+ typedef MichaelHashSet< cds::gc::DHP, typename ml::MichaelList_DHP_less_michaelAlloc, traits_MichaelSet_michaelAlloc > MichaelSet_DHP_less_michaelAlloc;
+ typedef MichaelHashSet< rcu_gpi, typename ml::MichaelList_RCU_GPI_less_michaelAlloc, traits_MichaelSet_michaelAlloc > MichaelSet_RCU_GPI_less_michaelAlloc;
+ typedef MichaelHashSet< rcu_gpb, typename ml::MichaelList_RCU_GPB_less_michaelAlloc, traits_MichaelSet_michaelAlloc > MichaelSet_RCU_GPB_less_michaelAlloc;
+ typedef MichaelHashSet< rcu_gpt, typename ml::MichaelList_RCU_GPT_less_michaelAlloc, traits_MichaelSet_michaelAlloc > MichaelSet_RCU_GPT_less_michaelAlloc;
#ifdef CDS_URCU_SIGNAL_HANDLING_ENABLED
- typedef cc::MichaelHashSet< rcu_shb, typename ml::MichaelList_RCU_SHB_less_michaelAlloc, traits_MichaelSet_michaelAlloc > MichaelSet_RCU_SHB_less_michaelAlloc;
- typedef cc::MichaelHashSet< rcu_sht, typename ml::MichaelList_RCU_SHT_less_michaelAlloc, traits_MichaelSet_michaelAlloc > MichaelSet_RCU_SHT_less_michaelAlloc;
+ typedef MichaelHashSet< rcu_shb, typename ml::MichaelList_RCU_SHB_less_michaelAlloc, traits_MichaelSet_michaelAlloc > MichaelSet_RCU_SHB_less_michaelAlloc;
+ typedef MichaelHashSet< rcu_sht, typename ml::MichaelList_RCU_SHT_less_michaelAlloc, traits_MichaelSet_michaelAlloc > MichaelSet_RCU_SHT_less_michaelAlloc;
#endif
typedef lazy_list_type< Key, Val > ll;
- typedef cc::MichaelHashSet< cds::gc::HP, typename ll::LazyList_HP_cmp_stdAlloc, traits_MichaelSet_stdAlloc > MichaelSet_Lazy_HP_cmp_stdAlloc;
- typedef cc::MichaelHashSet< cds::gc::DHP, typename ll::LazyList_DHP_cmp_stdAlloc, traits_MichaelSet_stdAlloc > MichaelSet_Lazy_DHP_cmp_stdAlloc;
- typedef cc::MichaelHashSet< rcu_gpi, typename ll::LazyList_RCU_GPI_cmp_stdAlloc, traits_MichaelSet_stdAlloc > MichaelSet_Lazy_RCU_GPI_cmp_stdAlloc;
- typedef cc::MichaelHashSet< rcu_gpb, typename ll::LazyList_RCU_GPB_cmp_stdAlloc, traits_MichaelSet_stdAlloc > MichaelSet_Lazy_RCU_GPB_cmp_stdAlloc;
- typedef cc::MichaelHashSet< rcu_gpt, typename ll::LazyList_RCU_GPT_cmp_stdAlloc, traits_MichaelSet_stdAlloc > MichaelSet_Lazy_RCU_GPT_cmp_stdAlloc;
+ typedef MichaelHashSet< cds::gc::HP, typename ll::LazyList_HP_cmp_stdAlloc, traits_MichaelSet_stdAlloc > MichaelSet_Lazy_HP_cmp_stdAlloc;
+ typedef MichaelHashSet< cds::gc::DHP, typename ll::LazyList_DHP_cmp_stdAlloc, traits_MichaelSet_stdAlloc > MichaelSet_Lazy_DHP_cmp_stdAlloc;
+ typedef MichaelHashSet< rcu_gpi, typename ll::LazyList_RCU_GPI_cmp_stdAlloc, traits_MichaelSet_stdAlloc > MichaelSet_Lazy_RCU_GPI_cmp_stdAlloc;
+ typedef MichaelHashSet< rcu_gpb, typename ll::LazyList_RCU_GPB_cmp_stdAlloc, traits_MichaelSet_stdAlloc > MichaelSet_Lazy_RCU_GPB_cmp_stdAlloc;
+ typedef MichaelHashSet< rcu_gpt, typename ll::LazyList_RCU_GPT_cmp_stdAlloc, traits_MichaelSet_stdAlloc > MichaelSet_Lazy_RCU_GPT_cmp_stdAlloc;
#ifdef CDS_URCU_SIGNAL_HANDLING_ENABLED
- typedef cc::MichaelHashSet< rcu_shb, typename ll::LazyList_RCU_SHB_cmp_stdAlloc, traits_MichaelSet_stdAlloc > MichaelSet_Lazy_RCU_SHB_cmp_stdAlloc;
- typedef cc::MichaelHashSet< rcu_sht, typename ll::LazyList_RCU_SHT_cmp_stdAlloc, traits_MichaelSet_stdAlloc > MichaelSet_Lazy_RCU_SHT_cmp_stdAlloc;
+ typedef MichaelHashSet< rcu_shb, typename ll::LazyList_RCU_SHB_cmp_stdAlloc, traits_MichaelSet_stdAlloc > MichaelSet_Lazy_RCU_SHB_cmp_stdAlloc;
+ typedef MichaelHashSet< rcu_sht, typename ll::LazyList_RCU_SHT_cmp_stdAlloc, traits_MichaelSet_stdAlloc > MichaelSet_Lazy_RCU_SHT_cmp_stdAlloc;
#endif
- typedef cc::MichaelHashSet< cds::gc::HP, typename ll::LazyList_HP_less_stdAlloc, traits_MichaelSet_stdAlloc > MichaelSet_Lazy_HP_less_stdAlloc;
- typedef cc::MichaelHashSet< cds::gc::DHP, typename ll::LazyList_DHP_less_stdAlloc, traits_MichaelSet_stdAlloc > MichaelSet_Lazy_DHP_less_stdAlloc;
- typedef cc::MichaelHashSet< rcu_gpi, typename ll::LazyList_RCU_GPI_less_stdAlloc, traits_MichaelSet_stdAlloc > MichaelSet_Lazy_RCU_GPI_less_stdAlloc;
- typedef cc::MichaelHashSet< rcu_gpb, typename ll::LazyList_RCU_GPB_less_stdAlloc, traits_MichaelSet_stdAlloc > MichaelSet_Lazy_RCU_GPB_less_stdAlloc;
- typedef cc::MichaelHashSet< rcu_gpt, typename ll::LazyList_RCU_GPT_less_stdAlloc, traits_MichaelSet_stdAlloc > MichaelSet_Lazy_RCU_GPT_less_stdAlloc;
+ typedef MichaelHashSet< cds::gc::HP, typename ll::LazyList_HP_less_stdAlloc, traits_MichaelSet_stdAlloc > MichaelSet_Lazy_HP_less_stdAlloc;
+ typedef MichaelHashSet< cds::gc::DHP, typename ll::LazyList_DHP_less_stdAlloc, traits_MichaelSet_stdAlloc > MichaelSet_Lazy_DHP_less_stdAlloc;
+ typedef MichaelHashSet< rcu_gpi, typename ll::LazyList_RCU_GPI_less_stdAlloc, traits_MichaelSet_stdAlloc > MichaelSet_Lazy_RCU_GPI_less_stdAlloc;
+ typedef MichaelHashSet< rcu_gpb, typename ll::LazyList_RCU_GPB_less_stdAlloc, traits_MichaelSet_stdAlloc > MichaelSet_Lazy_RCU_GPB_less_stdAlloc;
+ typedef MichaelHashSet< rcu_gpt, typename ll::LazyList_RCU_GPT_less_stdAlloc, traits_MichaelSet_stdAlloc > MichaelSet_Lazy_RCU_GPT_less_stdAlloc;
#ifdef CDS_URCU_SIGNAL_HANDLING_ENABLED
- typedef cc::MichaelHashSet< rcu_shb, typename ll::LazyList_RCU_SHB_less_stdAlloc, traits_MichaelSet_stdAlloc > MichaelSet_Lazy_RCU_SHB_less_stdAlloc;
- typedef cc::MichaelHashSet< rcu_sht, typename ll::LazyList_RCU_SHT_less_stdAlloc, traits_MichaelSet_stdAlloc > MichaelSet_Lazy_RCU_SHT_less_stdAlloc;
+ typedef MichaelHashSet< rcu_shb, typename ll::LazyList_RCU_SHB_less_stdAlloc, traits_MichaelSet_stdAlloc > MichaelSet_Lazy_RCU_SHB_less_stdAlloc;
+ typedef MichaelHashSet< rcu_sht, typename ll::LazyList_RCU_SHT_less_stdAlloc, traits_MichaelSet_stdAlloc > MichaelSet_Lazy_RCU_SHT_less_stdAlloc;
#endif
- typedef cc::MichaelHashSet< cds::gc::HP, typename ll::LazyList_HP_less_stdAlloc_seqcst, traits_MichaelSet_stdAlloc > MichaelSet_Lazy_HP_less_stdAlloc_seqcst;
- typedef cc::MichaelHashSet< cds::gc::DHP, typename ll::LazyList_DHP_less_stdAlloc_seqcst, traits_MichaelSet_stdAlloc > MichaelSet_Lazy_DHP_less_stdAlloc_seqcst;
- typedef cc::MichaelHashSet< rcu_gpi, typename ll::LazyList_RCU_GPI_less_stdAlloc_seqcst, traits_MichaelSet_stdAlloc > MichaelSet_Lazy_RCU_GPI_less_stdAlloc_seqcst;
- typedef cc::MichaelHashSet< rcu_gpb, typename ll::LazyList_RCU_GPB_less_stdAlloc_seqcst, traits_MichaelSet_stdAlloc > MichaelSet_Lazy_RCU_GPB_less_stdAlloc_seqcst;
- typedef cc::MichaelHashSet< rcu_gpt, typename ll::LazyList_RCU_GPT_less_stdAlloc_seqcst, traits_MichaelSet_stdAlloc > MichaelSet_Lazy_RCU_GPT_less_stdAlloc_seqcst;
+ typedef MichaelHashSet< cds::gc::HP, typename ll::LazyList_HP_less_stdAlloc_seqcst, traits_MichaelSet_stdAlloc > MichaelSet_Lazy_HP_less_stdAlloc_seqcst;
+ typedef MichaelHashSet< cds::gc::DHP, typename ll::LazyList_DHP_less_stdAlloc_seqcst, traits_MichaelSet_stdAlloc > MichaelSet_Lazy_DHP_less_stdAlloc_seqcst;
+ typedef MichaelHashSet< rcu_gpi, typename ll::LazyList_RCU_GPI_less_stdAlloc_seqcst, traits_MichaelSet_stdAlloc > MichaelSet_Lazy_RCU_GPI_less_stdAlloc_seqcst;
+ typedef MichaelHashSet< rcu_gpb, typename ll::LazyList_RCU_GPB_less_stdAlloc_seqcst, traits_MichaelSet_stdAlloc > MichaelSet_Lazy_RCU_GPB_less_stdAlloc_seqcst;
+ typedef MichaelHashSet< rcu_gpt, typename ll::LazyList_RCU_GPT_less_stdAlloc_seqcst, traits_MichaelSet_stdAlloc > MichaelSet_Lazy_RCU_GPT_less_stdAlloc_seqcst;
#ifdef CDS_URCU_SIGNAL_HANDLING_ENABLED
- typedef cc::MichaelHashSet< rcu_shb, typename ll::LazyList_RCU_SHB_less_stdAlloc_seqcst, traits_MichaelSet_stdAlloc > MichaelSet_Lazy_RCU_SHB_less_stdAlloc_seqcst;
- typedef cc::MichaelHashSet< rcu_sht, typename ll::LazyList_RCU_SHT_less_stdAlloc_seqcst, traits_MichaelSet_stdAlloc > MichaelSet_Lazy_RCU_SHT_less_stdAlloc_seqcst;
+ typedef MichaelHashSet< rcu_shb, typename ll::LazyList_RCU_SHB_less_stdAlloc_seqcst, traits_MichaelSet_stdAlloc > MichaelSet_Lazy_RCU_SHB_less_stdAlloc_seqcst;
+ typedef MichaelHashSet< rcu_sht, typename ll::LazyList_RCU_SHT_less_stdAlloc_seqcst, traits_MichaelSet_stdAlloc > MichaelSet_Lazy_RCU_SHT_less_stdAlloc_seqcst;
#endif
- typedef cc::MichaelHashSet< cds::gc::HP, typename ll::LazyList_HP_cmp_michaelAlloc, traits_MichaelSet_michaelAlloc > MichaelSet_Lazy_HP_cmp_michaelAlloc;
- typedef cc::MichaelHashSet< cds::gc::DHP, typename ll::LazyList_DHP_cmp_michaelAlloc, traits_MichaelSet_michaelAlloc > MichaelSet_Lazy_DHP_cmp_michaelAlloc;
- typedef cc::MichaelHashSet< rcu_gpi, typename ll::LazyList_RCU_GPI_cmp_michaelAlloc, traits_MichaelSet_michaelAlloc > MichaelSet_Lazy_RCU_GPI_cmp_michaelAlloc;
- typedef cc::MichaelHashSet< rcu_gpb, typename ll::LazyList_RCU_GPB_cmp_michaelAlloc, traits_MichaelSet_michaelAlloc > MichaelSet_Lazy_RCU_GPB_cmp_michaelAlloc;
- typedef cc::MichaelHashSet< rcu_gpt, typename ll::LazyList_RCU_GPT_cmp_michaelAlloc, traits_MichaelSet_michaelAlloc > MichaelSet_Lazy_RCU_GPT_cmp_michaelAlloc;
+ typedef MichaelHashSet< cds::gc::HP, typename ll::LazyList_HP_cmp_michaelAlloc, traits_MichaelSet_michaelAlloc > MichaelSet_Lazy_HP_cmp_michaelAlloc;
+ typedef MichaelHashSet< cds::gc::DHP, typename ll::LazyList_DHP_cmp_michaelAlloc, traits_MichaelSet_michaelAlloc > MichaelSet_Lazy_DHP_cmp_michaelAlloc;
+ typedef MichaelHashSet< rcu_gpi, typename ll::LazyList_RCU_GPI_cmp_michaelAlloc, traits_MichaelSet_michaelAlloc > MichaelSet_Lazy_RCU_GPI_cmp_michaelAlloc;
+ typedef MichaelHashSet< rcu_gpb, typename ll::LazyList_RCU_GPB_cmp_michaelAlloc, traits_MichaelSet_michaelAlloc > MichaelSet_Lazy_RCU_GPB_cmp_michaelAlloc;
+ typedef MichaelHashSet< rcu_gpt, typename ll::LazyList_RCU_GPT_cmp_michaelAlloc, traits_MichaelSet_michaelAlloc > MichaelSet_Lazy_RCU_GPT_cmp_michaelAlloc;
#ifdef CDS_URCU_SIGNAL_HANDLING_ENABLED
- typedef cc::MichaelHashSet< rcu_shb, typename ll::LazyList_RCU_SHB_cmp_michaelAlloc, traits_MichaelSet_michaelAlloc > MichaelSet_Lazy_RCU_SHB_cmp_michaelAlloc;
- typedef cc::MichaelHashSet< rcu_sht, typename ll::LazyList_RCU_SHT_cmp_michaelAlloc, traits_MichaelSet_michaelAlloc > MichaelSet_Lazy_RCU_SHT_cmp_michaelAlloc;
+ typedef MichaelHashSet< rcu_shb, typename ll::LazyList_RCU_SHB_cmp_michaelAlloc, traits_MichaelSet_michaelAlloc > MichaelSet_Lazy_RCU_SHB_cmp_michaelAlloc;
+ typedef MichaelHashSet< rcu_sht, typename ll::LazyList_RCU_SHT_cmp_michaelAlloc, traits_MichaelSet_michaelAlloc > MichaelSet_Lazy_RCU_SHT_cmp_michaelAlloc;
#endif
- typedef cc::MichaelHashSet< cds::gc::HP, typename ll::LazyList_HP_less_michaelAlloc, traits_MichaelSet_michaelAlloc > MichaelSet_Lazy_HP_less_michaelAlloc;
- typedef cc::MichaelHashSet< cds::gc::DHP, typename ll::LazyList_DHP_less_michaelAlloc, traits_MichaelSet_michaelAlloc > MichaelSet_Lazy_DHP_less_michaelAlloc;
- typedef cc::MichaelHashSet< rcu_gpi, typename ll::LazyList_RCU_GPI_less_michaelAlloc, traits_MichaelSet_michaelAlloc > MichaelSet_Lazy_RCU_GPI_less_michaelAlloc;
- typedef cc::MichaelHashSet< rcu_gpb, typename ll::LazyList_RCU_GPB_less_michaelAlloc, traits_MichaelSet_michaelAlloc > MichaelSet_Lazy_RCU_GPB_less_michaelAlloc;
- typedef cc::MichaelHashSet< rcu_gpt, typename ll::LazyList_RCU_GPT_less_michaelAlloc, traits_MichaelSet_michaelAlloc > MichaelSet_Lazy_RCU_GPT_less_michaelAlloc;
+ typedef MichaelHashSet< cds::gc::HP, typename ll::LazyList_HP_less_michaelAlloc, traits_MichaelSet_michaelAlloc > MichaelSet_Lazy_HP_less_michaelAlloc;
+ typedef MichaelHashSet< cds::gc::DHP, typename ll::LazyList_DHP_less_michaelAlloc, traits_MichaelSet_michaelAlloc > MichaelSet_Lazy_DHP_less_michaelAlloc;
+ typedef MichaelHashSet< rcu_gpi, typename ll::LazyList_RCU_GPI_less_michaelAlloc, traits_MichaelSet_michaelAlloc > MichaelSet_Lazy_RCU_GPI_less_michaelAlloc;
+ typedef MichaelHashSet< rcu_gpb, typename ll::LazyList_RCU_GPB_less_michaelAlloc, traits_MichaelSet_michaelAlloc > MichaelSet_Lazy_RCU_GPB_less_michaelAlloc;
+ typedef MichaelHashSet< rcu_gpt, typename ll::LazyList_RCU_GPT_less_michaelAlloc, traits_MichaelSet_michaelAlloc > MichaelSet_Lazy_RCU_GPT_less_michaelAlloc;
#ifdef CDS_URCU_SIGNAL_HANDLING_ENABLED
- typedef cc::MichaelHashSet< rcu_shb, typename ll::LazyList_RCU_SHB_less_michaelAlloc, traits_MichaelSet_michaelAlloc > MichaelSet_Lazy_RCU_SHB_less_michaelAlloc;
- typedef cc::MichaelHashSet< rcu_sht, typename ll::LazyList_RCU_SHT_less_michaelAlloc, traits_MichaelSet_michaelAlloc > MichaelSet_Lazy_RCU_SHT_less_michaelAlloc;
+ typedef MichaelHashSet< rcu_shb, typename ll::LazyList_RCU_SHB_less_michaelAlloc, traits_MichaelSet_michaelAlloc > MichaelSet_Lazy_RCU_SHB_less_michaelAlloc;
+ typedef MichaelHashSet< rcu_sht, typename ll::LazyList_RCU_SHT_less_michaelAlloc, traits_MichaelSet_michaelAlloc > MichaelSet_Lazy_RCU_SHT_less_michaelAlloc;
#endif
};
namespace set2 {
+ template <typename GC, typename T, typename Traits = cc::skip_list::traits >
+ class SkipListSet : public cc::SkipListSet<GC, T, Traits>
+ {
+ typedef cc::SkipListSet<GC, T, Traits> base_class;
+ public:
+ template <typename Config>
+ SkipListSet( Config const& /*cfg*/ )
+ {}
+
+ // for testing
+ static CDS_CONSTEXPR bool const c_bExtractSupported = true;
+ static CDS_CONSTEXPR bool const c_bLoadFactorDepended = false;
+ };
+
+ struct tag_SkipListSet;
+
template <typename Key, typename Val>
- struct set_type< cc::skip_list::implementation_tag, Key, Val >: public set_type_base< Key, Val >
+ struct set_type< tag_SkipListSet, Key, Val >: public set_type_base< Key, Val >
{
typedef set_type_base< Key, Val > base_class;
typedef typename base_class::key_val key_val;
,co::item_counter< cds::atomicity::item_counter >
>::type
{};
- typedef cc::SkipListSet< cds::gc::HP, key_val, traits_SkipListSet_less_pascal > SkipListSet_hp_less_pascal;
- typedef cc::SkipListSet< cds::gc::DHP, key_val, traits_SkipListSet_less_pascal > SkipListSet_dhp_less_pascal;
- typedef cc::SkipListSet< rcu_gpi, key_val, traits_SkipListSet_less_pascal > SkipListSet_rcu_gpi_less_pascal;
- typedef cc::SkipListSet< rcu_gpb, key_val, traits_SkipListSet_less_pascal > SkipListSet_rcu_gpb_less_pascal;
- typedef cc::SkipListSet< rcu_gpt, key_val, traits_SkipListSet_less_pascal > SkipListSet_rcu_gpt_less_pascal;
+ typedef SkipListSet< cds::gc::HP, key_val, traits_SkipListSet_less_pascal > SkipListSet_hp_less_pascal;
+ typedef SkipListSet< cds::gc::DHP, key_val, traits_SkipListSet_less_pascal > SkipListSet_dhp_less_pascal;
+ typedef SkipListSet< rcu_gpi, key_val, traits_SkipListSet_less_pascal > SkipListSet_rcu_gpi_less_pascal;
+ typedef SkipListSet< rcu_gpb, key_val, traits_SkipListSet_less_pascal > SkipListSet_rcu_gpb_less_pascal;
+ typedef SkipListSet< rcu_gpt, key_val, traits_SkipListSet_less_pascal > SkipListSet_rcu_gpt_less_pascal;
#ifdef CDS_URCU_SIGNAL_HANDLING_ENABLED
- typedef cc::SkipListSet< rcu_shb, key_val, traits_SkipListSet_less_pascal > SkipListSet_rcu_shb_less_pascal;
- typedef cc::SkipListSet< rcu_sht, key_val, traits_SkipListSet_less_pascal > SkipListSet_rcu_sht_less_pascal;
+ typedef SkipListSet< rcu_shb, key_val, traits_SkipListSet_less_pascal > SkipListSet_rcu_shb_less_pascal;
+ typedef SkipListSet< rcu_sht, key_val, traits_SkipListSet_less_pascal > SkipListSet_rcu_sht_less_pascal;
#endif
class traits_SkipListSet_less_pascal_seqcst: public cc::skip_list::make_traits <
,co::item_counter< cds::atomicity::item_counter >
>::type
{};
- typedef cc::SkipListSet< cds::gc::HP, key_val, traits_SkipListSet_less_pascal_seqcst > SkipListSet_hp_less_pascal_seqcst;
- typedef cc::SkipListSet< cds::gc::DHP, key_val, traits_SkipListSet_less_pascal_seqcst > SkipListSet_dhp_less_pascal_seqcst;
- typedef cc::SkipListSet< rcu_gpi, key_val, traits_SkipListSet_less_pascal_seqcst > SkipListSet_rcu_gpi_less_pascal_seqcst;
- typedef cc::SkipListSet< rcu_gpb, key_val, traits_SkipListSet_less_pascal_seqcst > SkipListSet_rcu_gpb_less_pascal_seqcst;
- typedef cc::SkipListSet< rcu_gpt, key_val, traits_SkipListSet_less_pascal_seqcst > SkipListSet_rcu_gpt_less_pascal_seqcst;
+ typedef SkipListSet< cds::gc::HP, key_val, traits_SkipListSet_less_pascal_seqcst > SkipListSet_hp_less_pascal_seqcst;
+ typedef SkipListSet< cds::gc::DHP, key_val, traits_SkipListSet_less_pascal_seqcst > SkipListSet_dhp_less_pascal_seqcst;
+ typedef SkipListSet< rcu_gpi, key_val, traits_SkipListSet_less_pascal_seqcst > SkipListSet_rcu_gpi_less_pascal_seqcst;
+ typedef SkipListSet< rcu_gpb, key_val, traits_SkipListSet_less_pascal_seqcst > SkipListSet_rcu_gpb_less_pascal_seqcst;
+ typedef SkipListSet< rcu_gpt, key_val, traits_SkipListSet_less_pascal_seqcst > SkipListSet_rcu_gpt_less_pascal_seqcst;
#ifdef CDS_URCU_SIGNAL_HANDLING_ENABLED
- typedef cc::SkipListSet< rcu_shb, key_val, traits_SkipListSet_less_pascal_seqcst > SkipListSet_rcu_shb_less_pascal_seqcst;
- typedef cc::SkipListSet< rcu_sht, key_val, traits_SkipListSet_less_pascal_seqcst > SkipListSet_rcu_sht_less_pascal_seqcst;
+ typedef SkipListSet< rcu_shb, key_val, traits_SkipListSet_less_pascal_seqcst > SkipListSet_rcu_shb_less_pascal_seqcst;
+ typedef SkipListSet< rcu_sht, key_val, traits_SkipListSet_less_pascal_seqcst > SkipListSet_rcu_sht_less_pascal_seqcst;
#endif
class traits_SkipListSet_less_pascal_stat: public cc::skip_list::make_traits <
,co::item_counter< cds::atomicity::item_counter >
>::type
{};
- typedef cc::SkipListSet< cds::gc::HP, key_val, traits_SkipListSet_less_pascal_stat > SkipListSet_hp_less_pascal_stat;
- typedef cc::SkipListSet< cds::gc::DHP, key_val, traits_SkipListSet_less_pascal_stat > SkipListSet_dhp_less_pascal_stat;
- typedef cc::SkipListSet< rcu_gpi, key_val, traits_SkipListSet_less_pascal_stat > SkipListSet_rcu_gpi_less_pascal_stat;
- typedef cc::SkipListSet< rcu_gpb, key_val, traits_SkipListSet_less_pascal_stat > SkipListSet_rcu_gpb_less_pascal_stat;
- typedef cc::SkipListSet< rcu_gpt, key_val, traits_SkipListSet_less_pascal_stat > SkipListSet_rcu_gpt_less_pascal_stat;
+ typedef SkipListSet< cds::gc::HP, key_val, traits_SkipListSet_less_pascal_stat > SkipListSet_hp_less_pascal_stat;
+ typedef SkipListSet< cds::gc::DHP, key_val, traits_SkipListSet_less_pascal_stat > SkipListSet_dhp_less_pascal_stat;
+ typedef SkipListSet< rcu_gpi, key_val, traits_SkipListSet_less_pascal_stat > SkipListSet_rcu_gpi_less_pascal_stat;
+ typedef SkipListSet< rcu_gpb, key_val, traits_SkipListSet_less_pascal_stat > SkipListSet_rcu_gpb_less_pascal_stat;
+ typedef SkipListSet< rcu_gpt, key_val, traits_SkipListSet_less_pascal_stat > SkipListSet_rcu_gpt_less_pascal_stat;
#ifdef CDS_URCU_SIGNAL_HANDLING_ENABLED
- typedef cc::SkipListSet< rcu_shb, key_val, traits_SkipListSet_less_pascal_stat > SkipListSet_rcu_shb_less_pascal_stat;
- typedef cc::SkipListSet< rcu_sht, key_val, traits_SkipListSet_less_pascal_stat > SkipListSet_rcu_sht_less_pascal_stat;
+ typedef SkipListSet< rcu_shb, key_val, traits_SkipListSet_less_pascal_stat > SkipListSet_rcu_shb_less_pascal_stat;
+ typedef SkipListSet< rcu_sht, key_val, traits_SkipListSet_less_pascal_stat > SkipListSet_rcu_sht_less_pascal_stat;
#endif
class traits_SkipListSet_cmp_pascal: public cc::skip_list::make_traits <
,co::item_counter< cds::atomicity::item_counter >
>::type
{};
- typedef cc::SkipListSet< cds::gc::HP, key_val, traits_SkipListSet_cmp_pascal > SkipListSet_hp_cmp_pascal;
- typedef cc::SkipListSet< cds::gc::DHP, key_val, traits_SkipListSet_cmp_pascal > SkipListSet_dhp_cmp_pascal;
- typedef cc::SkipListSet< rcu_gpi, key_val, traits_SkipListSet_cmp_pascal > SkipListSet_rcu_gpi_cmp_pascal;
- typedef cc::SkipListSet< rcu_gpb, key_val, traits_SkipListSet_cmp_pascal > SkipListSet_rcu_gpb_cmp_pascal;
- typedef cc::SkipListSet< rcu_gpt, key_val, traits_SkipListSet_cmp_pascal > SkipListSet_rcu_gpt_cmp_pascal;
+ typedef SkipListSet< cds::gc::HP, key_val, traits_SkipListSet_cmp_pascal > SkipListSet_hp_cmp_pascal;
+ typedef SkipListSet< cds::gc::DHP, key_val, traits_SkipListSet_cmp_pascal > SkipListSet_dhp_cmp_pascal;
+ typedef SkipListSet< rcu_gpi, key_val, traits_SkipListSet_cmp_pascal > SkipListSet_rcu_gpi_cmp_pascal;
+ typedef SkipListSet< rcu_gpb, key_val, traits_SkipListSet_cmp_pascal > SkipListSet_rcu_gpb_cmp_pascal;
+ typedef SkipListSet< rcu_gpt, key_val, traits_SkipListSet_cmp_pascal > SkipListSet_rcu_gpt_cmp_pascal;
#ifdef CDS_URCU_SIGNAL_HANDLING_ENABLED
- typedef cc::SkipListSet< rcu_shb, key_val, traits_SkipListSet_cmp_pascal > SkipListSet_rcu_shb_cmp_pascal;
- typedef cc::SkipListSet< rcu_sht, key_val, traits_SkipListSet_cmp_pascal > SkipListSet_rcu_sht_cmp_pascal;
+ typedef SkipListSet< rcu_shb, key_val, traits_SkipListSet_cmp_pascal > SkipListSet_rcu_shb_cmp_pascal;
+ typedef SkipListSet< rcu_sht, key_val, traits_SkipListSet_cmp_pascal > SkipListSet_rcu_sht_cmp_pascal;
#endif
class traits_SkipListSet_cmp_pascal_stat: public cc::skip_list::make_traits <
,co::item_counter< cds::atomicity::item_counter >
>::type
{};
- typedef cc::SkipListSet< cds::gc::HP, key_val, traits_SkipListSet_cmp_pascal_stat > SkipListSet_hp_cmp_pascal_stat;
- typedef cc::SkipListSet< cds::gc::DHP, key_val, traits_SkipListSet_cmp_pascal_stat > SkipListSet_dhp_cmp_pascal_stat;
- typedef cc::SkipListSet< rcu_gpi, key_val, traits_SkipListSet_cmp_pascal_stat > SkipListSet_rcu_gpi_cmp_pascal_stat;
- typedef cc::SkipListSet< rcu_gpb, key_val, traits_SkipListSet_cmp_pascal_stat > SkipListSet_rcu_gpb_cmp_pascal_stat;
- typedef cc::SkipListSet< rcu_gpt, key_val, traits_SkipListSet_cmp_pascal_stat > SkipListSet_rcu_gpt_cmp_pascal_stat;
+ typedef SkipListSet< cds::gc::HP, key_val, traits_SkipListSet_cmp_pascal_stat > SkipListSet_hp_cmp_pascal_stat;
+ typedef SkipListSet< cds::gc::DHP, key_val, traits_SkipListSet_cmp_pascal_stat > SkipListSet_dhp_cmp_pascal_stat;
+ typedef SkipListSet< rcu_gpi, key_val, traits_SkipListSet_cmp_pascal_stat > SkipListSet_rcu_gpi_cmp_pascal_stat;
+ typedef SkipListSet< rcu_gpb, key_val, traits_SkipListSet_cmp_pascal_stat > SkipListSet_rcu_gpb_cmp_pascal_stat;
+ typedef SkipListSet< rcu_gpt, key_val, traits_SkipListSet_cmp_pascal_stat > SkipListSet_rcu_gpt_cmp_pascal_stat;
#ifdef CDS_URCU_SIGNAL_HANDLING_ENABLED
- typedef cc::SkipListSet< rcu_shb, key_val, traits_SkipListSet_cmp_pascal_stat > SkipListSet_rcu_shb_cmp_pascal_stat;
- typedef cc::SkipListSet< rcu_sht, key_val, traits_SkipListSet_cmp_pascal_stat > SkipListSet_rcu_sht_cmp_pascal_stat;
+ typedef SkipListSet< rcu_shb, key_val, traits_SkipListSet_cmp_pascal_stat > SkipListSet_rcu_shb_cmp_pascal_stat;
+ typedef SkipListSet< rcu_sht, key_val, traits_SkipListSet_cmp_pascal_stat > SkipListSet_rcu_sht_cmp_pascal_stat;
#endif
class traits_SkipListSet_less_xorshift: public cc::skip_list::make_traits <
,co::item_counter< cds::atomicity::item_counter >
>::type
{};
- typedef cc::SkipListSet< cds::gc::HP, key_val, traits_SkipListSet_less_xorshift > SkipListSet_hp_less_xorshift;
- typedef cc::SkipListSet< cds::gc::DHP, key_val, traits_SkipListSet_less_xorshift > SkipListSet_dhp_less_xorshift;
- typedef cc::SkipListSet< rcu_gpi, key_val, traits_SkipListSet_less_xorshift > SkipListSet_rcu_gpi_less_xorshift;
- typedef cc::SkipListSet< rcu_gpb, key_val, traits_SkipListSet_less_xorshift > SkipListSet_rcu_gpb_less_xorshift;
- typedef cc::SkipListSet< rcu_gpt, key_val, traits_SkipListSet_less_xorshift > SkipListSet_rcu_gpt_less_xorshift;
+ typedef SkipListSet< cds::gc::HP, key_val, traits_SkipListSet_less_xorshift > SkipListSet_hp_less_xorshift;
+ typedef SkipListSet< cds::gc::DHP, key_val, traits_SkipListSet_less_xorshift > SkipListSet_dhp_less_xorshift;
+ typedef SkipListSet< rcu_gpi, key_val, traits_SkipListSet_less_xorshift > SkipListSet_rcu_gpi_less_xorshift;
+ typedef SkipListSet< rcu_gpb, key_val, traits_SkipListSet_less_xorshift > SkipListSet_rcu_gpb_less_xorshift;
+ typedef SkipListSet< rcu_gpt, key_val, traits_SkipListSet_less_xorshift > SkipListSet_rcu_gpt_less_xorshift;
#ifdef CDS_URCU_SIGNAL_HANDLING_ENABLED
- typedef cc::SkipListSet< rcu_shb, key_val, traits_SkipListSet_less_xorshift > SkipListSet_rcu_shb_less_xorshift;
- typedef cc::SkipListSet< rcu_sht, key_val, traits_SkipListSet_less_xorshift > SkipListSet_rcu_sht_less_xorshift;
+ typedef SkipListSet< rcu_shb, key_val, traits_SkipListSet_less_xorshift > SkipListSet_rcu_shb_less_xorshift;
+ typedef SkipListSet< rcu_sht, key_val, traits_SkipListSet_less_xorshift > SkipListSet_rcu_sht_less_xorshift;
#endif
class traits_SkipListSet_less_xorshift_stat: public cc::skip_list::make_traits <
,co::item_counter< cds::atomicity::item_counter >
>::type
{};
- typedef cc::SkipListSet< cds::gc::HP, key_val, traits_SkipListSet_less_xorshift_stat > SkipListSet_hp_less_xorshift_stat;
- typedef cc::SkipListSet< cds::gc::DHP, key_val, traits_SkipListSet_less_xorshift_stat > SkipListSet_dhp_less_xorshift_stat;
- typedef cc::SkipListSet< rcu_gpi, key_val, traits_SkipListSet_less_xorshift_stat > SkipListSet_rcu_gpi_less_xorshift_stat;
- typedef cc::SkipListSet< rcu_gpb, key_val, traits_SkipListSet_less_xorshift_stat > SkipListSet_rcu_gpb_less_xorshift_stat;
- typedef cc::SkipListSet< rcu_gpt, key_val, traits_SkipListSet_less_xorshift_stat > SkipListSet_rcu_gpt_less_xorshift_stat;
+ typedef SkipListSet< cds::gc::HP, key_val, traits_SkipListSet_less_xorshift_stat > SkipListSet_hp_less_xorshift_stat;
+ typedef SkipListSet< cds::gc::DHP, key_val, traits_SkipListSet_less_xorshift_stat > SkipListSet_dhp_less_xorshift_stat;
+ typedef SkipListSet< rcu_gpi, key_val, traits_SkipListSet_less_xorshift_stat > SkipListSet_rcu_gpi_less_xorshift_stat;
+ typedef SkipListSet< rcu_gpb, key_val, traits_SkipListSet_less_xorshift_stat > SkipListSet_rcu_gpb_less_xorshift_stat;
+ typedef SkipListSet< rcu_gpt, key_val, traits_SkipListSet_less_xorshift_stat > SkipListSet_rcu_gpt_less_xorshift_stat;
#ifdef CDS_URCU_SIGNAL_HANDLING_ENABLED
- typedef cc::SkipListSet< rcu_shb, key_val, traits_SkipListSet_less_xorshift_stat > SkipListSet_rcu_shb_less_xorshift_stat;
- typedef cc::SkipListSet< rcu_sht, key_val, traits_SkipListSet_less_xorshift_stat > SkipListSet_rcu_sht_less_xorshift_stat;
+ typedef SkipListSet< rcu_shb, key_val, traits_SkipListSet_less_xorshift_stat > SkipListSet_rcu_shb_less_xorshift_stat;
+ typedef SkipListSet< rcu_sht, key_val, traits_SkipListSet_less_xorshift_stat > SkipListSet_rcu_sht_less_xorshift_stat;
#endif
class traits_SkipListSet_cmp_xorshift: public cc::skip_list::make_traits <
,co::item_counter< cds::atomicity::item_counter >
>::type
{};
- typedef cc::SkipListSet< cds::gc::HP, key_val, traits_SkipListSet_cmp_xorshift > SkipListSet_hp_cmp_xorshift;
- typedef cc::SkipListSet< cds::gc::DHP, key_val, traits_SkipListSet_cmp_xorshift > SkipListSet_dhp_cmp_xorshift;
- typedef cc::SkipListSet< rcu_gpi, key_val, traits_SkipListSet_cmp_xorshift > SkipListSet_rcu_gpi_cmp_xorshift;
- typedef cc::SkipListSet< rcu_gpb, key_val, traits_SkipListSet_cmp_xorshift > SkipListSet_rcu_gpb_cmp_xorshift;
- typedef cc::SkipListSet< rcu_gpt, key_val, traits_SkipListSet_cmp_xorshift > SkipListSet_rcu_gpt_cmp_xorshift;
+ typedef SkipListSet< cds::gc::HP, key_val, traits_SkipListSet_cmp_xorshift > SkipListSet_hp_cmp_xorshift;
+ typedef SkipListSet< cds::gc::DHP, key_val, traits_SkipListSet_cmp_xorshift > SkipListSet_dhp_cmp_xorshift;
+ typedef SkipListSet< rcu_gpi, key_val, traits_SkipListSet_cmp_xorshift > SkipListSet_rcu_gpi_cmp_xorshift;
+ typedef SkipListSet< rcu_gpb, key_val, traits_SkipListSet_cmp_xorshift > SkipListSet_rcu_gpb_cmp_xorshift;
+ typedef SkipListSet< rcu_gpt, key_val, traits_SkipListSet_cmp_xorshift > SkipListSet_rcu_gpt_cmp_xorshift;
#ifdef CDS_URCU_SIGNAL_HANDLING_ENABLED
- typedef cc::SkipListSet< rcu_shb, key_val, traits_SkipListSet_cmp_xorshift > SkipListSet_rcu_shb_cmp_xorshift;
- typedef cc::SkipListSet< rcu_sht, key_val, traits_SkipListSet_cmp_xorshift > SkipListSet_rcu_sht_cmp_xorshift;
+ typedef SkipListSet< rcu_shb, key_val, traits_SkipListSet_cmp_xorshift > SkipListSet_rcu_shb_cmp_xorshift;
+ typedef SkipListSet< rcu_sht, key_val, traits_SkipListSet_cmp_xorshift > SkipListSet_rcu_sht_cmp_xorshift;
#endif
class traits_SkipListSet_cmp_xorshift_stat: public cc::skip_list::make_traits <
,co::item_counter< cds::atomicity::item_counter >
>::type
{};
- typedef cc::SkipListSet< cds::gc::HP, key_val, traits_SkipListSet_cmp_xorshift_stat > SkipListSet_hp_cmp_xorshift_stat;
- typedef cc::SkipListSet< cds::gc::DHP, key_val, traits_SkipListSet_cmp_xorshift_stat > SkipListSet_dhp_cmp_xorshift_stat;
- typedef cc::SkipListSet< rcu_gpi, key_val, traits_SkipListSet_cmp_xorshift_stat > SkipListSet_rcu_gpi_cmp_xorshift_stat;
- typedef cc::SkipListSet< rcu_gpb, key_val, traits_SkipListSet_cmp_xorshift_stat > SkipListSet_rcu_gpb_cmp_xorshift_stat;
- typedef cc::SkipListSet< rcu_gpt, key_val, traits_SkipListSet_cmp_xorshift_stat > SkipListSet_rcu_gpt_cmp_xorshift_stat;
+ typedef SkipListSet< cds::gc::HP, key_val, traits_SkipListSet_cmp_xorshift_stat > SkipListSet_hp_cmp_xorshift_stat;
+ typedef SkipListSet< cds::gc::DHP, key_val, traits_SkipListSet_cmp_xorshift_stat > SkipListSet_dhp_cmp_xorshift_stat;
+ typedef SkipListSet< rcu_gpi, key_val, traits_SkipListSet_cmp_xorshift_stat > SkipListSet_rcu_gpi_cmp_xorshift_stat;
+ typedef SkipListSet< rcu_gpb, key_val, traits_SkipListSet_cmp_xorshift_stat > SkipListSet_rcu_gpb_cmp_xorshift_stat;
+ typedef SkipListSet< rcu_gpt, key_val, traits_SkipListSet_cmp_xorshift_stat > SkipListSet_rcu_gpt_cmp_xorshift_stat;
#ifdef CDS_URCU_SIGNAL_HANDLING_ENABLED
- typedef cc::SkipListSet< rcu_shb, key_val, traits_SkipListSet_cmp_xorshift_stat > SkipListSet_rcu_shb_cmp_xorshift_stat;
- typedef cc::SkipListSet< rcu_sht, key_val, traits_SkipListSet_cmp_xorshift_stat > SkipListSet_rcu_sht_cmp_xorshift_stat;
+ typedef SkipListSet< rcu_shb, key_val, traits_SkipListSet_cmp_xorshift_stat > SkipListSet_rcu_shb_cmp_xorshift_stat;
+ typedef SkipListSet< rcu_sht, key_val, traits_SkipListSet_cmp_xorshift_stat > SkipListSet_rcu_sht_cmp_xorshift_stat;
#endif
};
template <typename GC, typename T, typename Traits>
- static inline void print_stat( cc::SkipListSet<GC, T, Traits> const& s )
+ static inline void print_stat( SkipListSet<GC, T, Traits> const& s )
{
CPPUNIT_MSG( s.statistics() );
}
namespace set2 {
+ template <typename GC, typename T, typename Traits = cc::split_list::traits>
+ class SplitListSet : public cc::SplitListSet< GC, T, Traits >
+ {
+ typedef cc::SplitListSet< GC, T, Traits > base_class;
+ public:
+ template <typename Config>
+ SplitListSet( Config const& cfg )
+ : base_class( cfg.c_nSetSize, cfg.c_nLoadFactor )
+ {}
+
+ // for testing
+ static CDS_CONSTEXPR bool const c_bExtractSupported = true;
+ static CDS_CONSTEXPR bool const c_bLoadFactorDepended = true;
+ };
+
+ struct tag_SplitListSet;
+
template <typename Key, typename Val>
- struct set_type< cc::split_list::implementation_tag, Key, Val >: public set_type_base< Key, Val >
+ struct set_type< tag_SplitListSet, Key, Val >: public set_type_base< Key, Val >
{
typedef set_type_base< Key, Val > base_class;
typedef typename base_class::key_val key_val;
>
>::type
{};
- typedef cc::SplitListSet< cds::gc::HP, key_val, traits_SplitList_Michael_dyn_cmp > SplitList_Michael_HP_dyn_cmp;
- typedef cc::SplitListSet< cds::gc::DHP, key_val, traits_SplitList_Michael_dyn_cmp > SplitList_Michael_DHP_dyn_cmp;
- typedef cc::SplitListSet< rcu_gpi, key_val, traits_SplitList_Michael_dyn_cmp > SplitList_Michael_RCU_GPI_dyn_cmp;
- typedef cc::SplitListSet< rcu_gpb, key_val, traits_SplitList_Michael_dyn_cmp > SplitList_Michael_RCU_GPB_dyn_cmp;
- typedef cc::SplitListSet< rcu_gpt, key_val, traits_SplitList_Michael_dyn_cmp > SplitList_Michael_RCU_GPT_dyn_cmp;
+ typedef SplitListSet< cds::gc::HP, key_val, traits_SplitList_Michael_dyn_cmp > SplitList_Michael_HP_dyn_cmp;
+ typedef SplitListSet< cds::gc::DHP, key_val, traits_SplitList_Michael_dyn_cmp > SplitList_Michael_DHP_dyn_cmp;
+ typedef SplitListSet< rcu_gpi, key_val, traits_SplitList_Michael_dyn_cmp > SplitList_Michael_RCU_GPI_dyn_cmp;
+ typedef SplitListSet< rcu_gpb, key_val, traits_SplitList_Michael_dyn_cmp > SplitList_Michael_RCU_GPB_dyn_cmp;
+ typedef SplitListSet< rcu_gpt, key_val, traits_SplitList_Michael_dyn_cmp > SplitList_Michael_RCU_GPT_dyn_cmp;
#ifdef CDS_URCU_SIGNAL_HANDLING_ENABLED
- typedef cc::SplitListSet< rcu_shb, key_val, traits_SplitList_Michael_dyn_cmp > SplitList_Michael_RCU_SHB_dyn_cmp;
- typedef cc::SplitListSet< rcu_sht, key_val, traits_SplitList_Michael_dyn_cmp > SplitList_Michael_RCU_SHT_dyn_cmp;
+ typedef SplitListSet< rcu_shb, key_val, traits_SplitList_Michael_dyn_cmp > SplitList_Michael_RCU_SHB_dyn_cmp;
+ typedef SplitListSet< rcu_sht, key_val, traits_SplitList_Michael_dyn_cmp > SplitList_Michael_RCU_SHT_dyn_cmp;
#endif
struct traits_SplitList_Michael_dyn_cmp_stat :
>
>::type
{};
- typedef cc::SplitListSet< cds::gc::HP, key_val, traits_SplitList_Michael_dyn_cmp_stat > SplitList_Michael_HP_dyn_cmp_stat;
- typedef cc::SplitListSet< cds::gc::DHP, key_val, traits_SplitList_Michael_dyn_cmp_stat > SplitList_Michael_DHP_dyn_cmp_stat;
- typedef cc::SplitListSet< rcu_gpi, key_val, traits_SplitList_Michael_dyn_cmp_stat > SplitList_Michael_RCU_GPI_dyn_cmp_stat;
- typedef cc::SplitListSet< rcu_gpb, key_val, traits_SplitList_Michael_dyn_cmp_stat > SplitList_Michael_RCU_GPB_dyn_cmp_stat;
- typedef cc::SplitListSet< rcu_gpt, key_val, traits_SplitList_Michael_dyn_cmp_stat > SplitList_Michael_RCU_GPT_dyn_cmp_stat;
+ typedef SplitListSet< cds::gc::HP, key_val, traits_SplitList_Michael_dyn_cmp_stat > SplitList_Michael_HP_dyn_cmp_stat;
+ typedef SplitListSet< cds::gc::DHP, key_val, traits_SplitList_Michael_dyn_cmp_stat > SplitList_Michael_DHP_dyn_cmp_stat;
+ typedef SplitListSet< rcu_gpi, key_val, traits_SplitList_Michael_dyn_cmp_stat > SplitList_Michael_RCU_GPI_dyn_cmp_stat;
+ typedef SplitListSet< rcu_gpb, key_val, traits_SplitList_Michael_dyn_cmp_stat > SplitList_Michael_RCU_GPB_dyn_cmp_stat;
+ typedef SplitListSet< rcu_gpt, key_val, traits_SplitList_Michael_dyn_cmp_stat > SplitList_Michael_RCU_GPT_dyn_cmp_stat;
#ifdef CDS_URCU_SIGNAL_HANDLING_ENABLED
- typedef cc::SplitListSet< rcu_shb, key_val, traits_SplitList_Michael_dyn_cmp_stat > SplitList_Michael_RCU_SHB_dyn_cmp_stat;
- typedef cc::SplitListSet< rcu_sht, key_val, traits_SplitList_Michael_dyn_cmp_stat > SplitList_Michael_RCU_SHT_dyn_cmp_stat;
+ typedef SplitListSet< rcu_shb, key_val, traits_SplitList_Michael_dyn_cmp_stat > SplitList_Michael_RCU_SHB_dyn_cmp_stat;
+ typedef SplitListSet< rcu_sht, key_val, traits_SplitList_Michael_dyn_cmp_stat > SplitList_Michael_RCU_SHT_dyn_cmp_stat;
#endif
struct traits_SplitList_Michael_dyn_cmp_seqcst :
>
>::type
{};
- typedef cc::SplitListSet< cds::gc::HP, key_val, traits_SplitList_Michael_dyn_cmp_seqcst > SplitList_Michael_HP_dyn_cmp_seqcst;
- typedef cc::SplitListSet< cds::gc::DHP, key_val, traits_SplitList_Michael_dyn_cmp_seqcst > SplitList_Michael_DHP_dyn_cmp_seqcst;
- typedef cc::SplitListSet< rcu_gpi, key_val, traits_SplitList_Michael_dyn_cmp_seqcst > SplitList_Michael_RCU_GPI_dyn_cmp_seqcst;
- typedef cc::SplitListSet< rcu_gpb, key_val, traits_SplitList_Michael_dyn_cmp_seqcst > SplitList_Michael_RCU_GPB_dyn_cmp_seqcst;
- typedef cc::SplitListSet< rcu_gpt, key_val, traits_SplitList_Michael_dyn_cmp_seqcst > SplitList_Michael_RCU_GPT_dyn_cmp_seqcst;
+ typedef SplitListSet< cds::gc::HP, key_val, traits_SplitList_Michael_dyn_cmp_seqcst > SplitList_Michael_HP_dyn_cmp_seqcst;
+ typedef SplitListSet< cds::gc::DHP, key_val, traits_SplitList_Michael_dyn_cmp_seqcst > SplitList_Michael_DHP_dyn_cmp_seqcst;
+ typedef SplitListSet< rcu_gpi, key_val, traits_SplitList_Michael_dyn_cmp_seqcst > SplitList_Michael_RCU_GPI_dyn_cmp_seqcst;
+ typedef SplitListSet< rcu_gpb, key_val, traits_SplitList_Michael_dyn_cmp_seqcst > SplitList_Michael_RCU_GPB_dyn_cmp_seqcst;
+ typedef SplitListSet< rcu_gpt, key_val, traits_SplitList_Michael_dyn_cmp_seqcst > SplitList_Michael_RCU_GPT_dyn_cmp_seqcst;
#ifdef CDS_URCU_SIGNAL_HANDLING_ENABLED
- typedef cc::SplitListSet< rcu_shb, key_val, traits_SplitList_Michael_dyn_cmp_seqcst > SplitList_Michael_RCU_SHB_dyn_cmp_seqcst;
- typedef cc::SplitListSet< rcu_sht, key_val, traits_SplitList_Michael_dyn_cmp_seqcst > SplitList_Michael_RCU_SHT_dyn_cmp_seqcst;
+ typedef SplitListSet< rcu_shb, key_val, traits_SplitList_Michael_dyn_cmp_seqcst > SplitList_Michael_RCU_SHB_dyn_cmp_seqcst;
+ typedef SplitListSet< rcu_sht, key_val, traits_SplitList_Michael_dyn_cmp_seqcst > SplitList_Michael_RCU_SHT_dyn_cmp_seqcst;
#endif
struct traits_SplitList_Michael_st_cmp :
>
>::type
{};
- typedef cc::SplitListSet< cds::gc::HP, key_val, traits_SplitList_Michael_st_cmp > SplitList_Michael_HP_st_cmp;
- typedef cc::SplitListSet< cds::gc::DHP, key_val, traits_SplitList_Michael_st_cmp > SplitList_Michael_DHP_st_cmp;
- typedef cc::SplitListSet< rcu_gpi, key_val, traits_SplitList_Michael_st_cmp > SplitList_Michael_RCU_GPI_st_cmp;
- typedef cc::SplitListSet< rcu_gpb, key_val, traits_SplitList_Michael_st_cmp > SplitList_Michael_RCU_GPB_st_cmp;
- typedef cc::SplitListSet< rcu_gpt, key_val, traits_SplitList_Michael_st_cmp > SplitList_Michael_RCU_GPT_st_cmp;
+ typedef SplitListSet< cds::gc::HP, key_val, traits_SplitList_Michael_st_cmp > SplitList_Michael_HP_st_cmp;
+ typedef SplitListSet< cds::gc::DHP, key_val, traits_SplitList_Michael_st_cmp > SplitList_Michael_DHP_st_cmp;
+ typedef SplitListSet< rcu_gpi, key_val, traits_SplitList_Michael_st_cmp > SplitList_Michael_RCU_GPI_st_cmp;
+ typedef SplitListSet< rcu_gpb, key_val, traits_SplitList_Michael_st_cmp > SplitList_Michael_RCU_GPB_st_cmp;
+ typedef SplitListSet< rcu_gpt, key_val, traits_SplitList_Michael_st_cmp > SplitList_Michael_RCU_GPT_st_cmp;
#ifdef CDS_URCU_SIGNAL_HANDLING_ENABLED
- typedef cc::SplitListSet< rcu_shb, key_val, traits_SplitList_Michael_st_cmp > SplitList_Michael_RCU_SHB_st_cmp;
- typedef cc::SplitListSet< rcu_sht, key_val, traits_SplitList_Michael_st_cmp > SplitList_Michael_RCU_SHT_st_cmp;
+ typedef SplitListSet< rcu_shb, key_val, traits_SplitList_Michael_st_cmp > SplitList_Michael_RCU_SHB_st_cmp;
+ typedef SplitListSet< rcu_sht, key_val, traits_SplitList_Michael_st_cmp > SplitList_Michael_RCU_SHT_st_cmp;
#endif
struct traits_SplitList_Michael_st_cmp_seqcst :
>
>::type
{};
- typedef cc::SplitListSet< cds::gc::HP, key_val, traits_SplitList_Michael_st_cmp_seqcst> SplitList_Michael_HP_st_cmp_seqcst;
- typedef cc::SplitListSet< cds::gc::DHP, key_val, traits_SplitList_Michael_st_cmp_seqcst> SplitList_Michael_DHP_st_cmp_seqcst;
- typedef cc::SplitListSet< rcu_gpi, key_val, traits_SplitList_Michael_st_cmp_seqcst> SplitList_Michael_RCU_GPI_st_cmp_seqcst;
- typedef cc::SplitListSet< rcu_gpb, key_val, traits_SplitList_Michael_st_cmp_seqcst> SplitList_Michael_RCU_GPB_st_cmp_seqcst;
- typedef cc::SplitListSet< rcu_gpt, key_val, traits_SplitList_Michael_st_cmp_seqcst> SplitList_Michael_RCU_GPT_st_cmp_seqcst;
+ typedef SplitListSet< cds::gc::HP, key_val, traits_SplitList_Michael_st_cmp_seqcst> SplitList_Michael_HP_st_cmp_seqcst;
+ typedef SplitListSet< cds::gc::DHP, key_val, traits_SplitList_Michael_st_cmp_seqcst> SplitList_Michael_DHP_st_cmp_seqcst;
+ typedef SplitListSet< rcu_gpi, key_val, traits_SplitList_Michael_st_cmp_seqcst> SplitList_Michael_RCU_GPI_st_cmp_seqcst;
+ typedef SplitListSet< rcu_gpb, key_val, traits_SplitList_Michael_st_cmp_seqcst> SplitList_Michael_RCU_GPB_st_cmp_seqcst;
+ typedef SplitListSet< rcu_gpt, key_val, traits_SplitList_Michael_st_cmp_seqcst> SplitList_Michael_RCU_GPT_st_cmp_seqcst;
#ifdef CDS_URCU_SIGNAL_HANDLING_ENABLED
- typedef cc::SplitListSet< rcu_shb, key_val, traits_SplitList_Michael_st_cmp_seqcst> SplitList_Michael_RCU_SHB_st_cmp_seqcst;
- typedef cc::SplitListSet< rcu_sht, key_val, traits_SplitList_Michael_st_cmp_seqcst> SplitList_Michael_RCU_SHT_st_cmp_seqcst;
+ typedef SplitListSet< rcu_shb, key_val, traits_SplitList_Michael_st_cmp_seqcst> SplitList_Michael_RCU_SHB_st_cmp_seqcst;
+ typedef SplitListSet< rcu_sht, key_val, traits_SplitList_Michael_st_cmp_seqcst> SplitList_Michael_RCU_SHT_st_cmp_seqcst;
#endif
//HP + less
>
>::type
{};
- typedef cc::SplitListSet< cds::gc::HP, key_val, traits_SplitList_Michael_dyn_less > SplitList_Michael_HP_dyn_less;
- typedef cc::SplitListSet< cds::gc::DHP, key_val, traits_SplitList_Michael_dyn_less > SplitList_Michael_DHP_dyn_less;
- typedef cc::SplitListSet< rcu_gpi, key_val, traits_SplitList_Michael_dyn_less > SplitList_Michael_RCU_GPI_dyn_less;
- typedef cc::SplitListSet< rcu_gpb, key_val, traits_SplitList_Michael_dyn_less > SplitList_Michael_RCU_GPB_dyn_less;
- typedef cc::SplitListSet< rcu_gpt, key_val, traits_SplitList_Michael_dyn_less > SplitList_Michael_RCU_GPT_dyn_less;
+ typedef SplitListSet< cds::gc::HP, key_val, traits_SplitList_Michael_dyn_less > SplitList_Michael_HP_dyn_less;
+ typedef SplitListSet< cds::gc::DHP, key_val, traits_SplitList_Michael_dyn_less > SplitList_Michael_DHP_dyn_less;
+ typedef SplitListSet< rcu_gpi, key_val, traits_SplitList_Michael_dyn_less > SplitList_Michael_RCU_GPI_dyn_less;
+ typedef SplitListSet< rcu_gpb, key_val, traits_SplitList_Michael_dyn_less > SplitList_Michael_RCU_GPB_dyn_less;
+ typedef SplitListSet< rcu_gpt, key_val, traits_SplitList_Michael_dyn_less > SplitList_Michael_RCU_GPT_dyn_less;
#ifdef CDS_URCU_SIGNAL_HANDLING_ENABLED
- typedef cc::SplitListSet< rcu_shb, key_val, traits_SplitList_Michael_dyn_less > SplitList_Michael_RCU_SHB_dyn_less;
- typedef cc::SplitListSet< rcu_sht, key_val, traits_SplitList_Michael_dyn_less > SplitList_Michael_RCU_SHT_dyn_less;
+ typedef SplitListSet< rcu_shb, key_val, traits_SplitList_Michael_dyn_less > SplitList_Michael_RCU_SHB_dyn_less;
+ typedef SplitListSet< rcu_sht, key_val, traits_SplitList_Michael_dyn_less > SplitList_Michael_RCU_SHT_dyn_less;
#endif
struct traits_SplitList_Michael_dyn_less_seqcst :
>
>::type
{};
- typedef cc::SplitListSet< cds::gc::HP, key_val, traits_SplitList_Michael_dyn_less_seqcst > SplitList_Michael_HP_dyn_less_seqcst;
- typedef cc::SplitListSet< cds::gc::DHP, key_val, traits_SplitList_Michael_dyn_less_seqcst > SplitList_Michael_DHP_dyn_less_seqcst;
- typedef cc::SplitListSet< rcu_gpi, key_val, traits_SplitList_Michael_dyn_less_seqcst > SplitList_Michael_RCU_GPI_dyn_less_seqcst;
- typedef cc::SplitListSet< rcu_gpb, key_val, traits_SplitList_Michael_dyn_less_seqcst > SplitList_Michael_RCU_GPB_dyn_less_seqcst;
- typedef cc::SplitListSet< rcu_gpt, key_val, traits_SplitList_Michael_dyn_less_seqcst > SplitList_Michael_RCU_GPT_dyn_less_seqcst;
+ typedef SplitListSet< cds::gc::HP, key_val, traits_SplitList_Michael_dyn_less_seqcst > SplitList_Michael_HP_dyn_less_seqcst;
+ typedef SplitListSet< cds::gc::DHP, key_val, traits_SplitList_Michael_dyn_less_seqcst > SplitList_Michael_DHP_dyn_less_seqcst;
+ typedef SplitListSet< rcu_gpi, key_val, traits_SplitList_Michael_dyn_less_seqcst > SplitList_Michael_RCU_GPI_dyn_less_seqcst;
+ typedef SplitListSet< rcu_gpb, key_val, traits_SplitList_Michael_dyn_less_seqcst > SplitList_Michael_RCU_GPB_dyn_less_seqcst;
+ typedef SplitListSet< rcu_gpt, key_val, traits_SplitList_Michael_dyn_less_seqcst > SplitList_Michael_RCU_GPT_dyn_less_seqcst;
#ifdef CDS_URCU_SIGNAL_HANDLING_ENABLED
- typedef cc::SplitListSet< rcu_shb, key_val, traits_SplitList_Michael_dyn_less_seqcst > SplitList_Michael_RCU_SHB_dyn_less_seqcst;
- typedef cc::SplitListSet< rcu_sht, key_val, traits_SplitList_Michael_dyn_less_seqcst > SplitList_Michael_RCU_SHT_dyn_less_seqcst;
+ typedef SplitListSet< rcu_shb, key_val, traits_SplitList_Michael_dyn_less_seqcst > SplitList_Michael_RCU_SHB_dyn_less_seqcst;
+ typedef SplitListSet< rcu_sht, key_val, traits_SplitList_Michael_dyn_less_seqcst > SplitList_Michael_RCU_SHT_dyn_less_seqcst;
#endif
struct traits_SplitList_Michael_st_less :
>
>::type
{};
- typedef cc::SplitListSet< cds::gc::HP, key_val, traits_SplitList_Michael_st_less > SplitList_Michael_HP_st_less;
- typedef cc::SplitListSet< cds::gc::DHP, key_val, traits_SplitList_Michael_st_less > SplitList_Michael_DHP_st_less;
- typedef cc::SplitListSet< rcu_gpi, key_val, traits_SplitList_Michael_st_less > SplitList_Michael_RCU_GPI_st_less;
- typedef cc::SplitListSet< rcu_gpb, key_val, traits_SplitList_Michael_st_less > SplitList_Michael_RCU_GPB_st_less;
- typedef cc::SplitListSet< rcu_gpt, key_val, traits_SplitList_Michael_st_less > SplitList_Michael_RCU_GPT_st_less;
+ typedef SplitListSet< cds::gc::HP, key_val, traits_SplitList_Michael_st_less > SplitList_Michael_HP_st_less;
+ typedef SplitListSet< cds::gc::DHP, key_val, traits_SplitList_Michael_st_less > SplitList_Michael_DHP_st_less;
+ typedef SplitListSet< rcu_gpi, key_val, traits_SplitList_Michael_st_less > SplitList_Michael_RCU_GPI_st_less;
+ typedef SplitListSet< rcu_gpb, key_val, traits_SplitList_Michael_st_less > SplitList_Michael_RCU_GPB_st_less;
+ typedef SplitListSet< rcu_gpt, key_val, traits_SplitList_Michael_st_less > SplitList_Michael_RCU_GPT_st_less;
#ifdef CDS_URCU_SIGNAL_HANDLING_ENABLED
- typedef cc::SplitListSet< rcu_shb, key_val, traits_SplitList_Michael_st_less > SplitList_Michael_RCU_SHB_st_less;
- typedef cc::SplitListSet< rcu_sht, key_val, traits_SplitList_Michael_st_less > SplitList_Michael_RCU_SHT_st_less;
+ typedef SplitListSet< rcu_shb, key_val, traits_SplitList_Michael_st_less > SplitList_Michael_RCU_SHB_st_less;
+ typedef SplitListSet< rcu_sht, key_val, traits_SplitList_Michael_st_less > SplitList_Michael_RCU_SHT_st_less;
#endif
struct traits_SplitList_Michael_st_less_stat :
>
>::type
{};
- typedef cc::SplitListSet< cds::gc::HP, key_val, traits_SplitList_Michael_st_less_stat > SplitList_Michael_HP_st_less_stat;
- typedef cc::SplitListSet< cds::gc::DHP, key_val, traits_SplitList_Michael_st_less_stat > SplitList_Michael_DHP_st_less_stat;
- typedef cc::SplitListSet< rcu_gpi, key_val, traits_SplitList_Michael_st_less_stat > SplitList_Michael_RCU_GPI_st_less_stat;
- typedef cc::SplitListSet< rcu_gpb, key_val, traits_SplitList_Michael_st_less_stat > SplitList_Michael_RCU_GPB_st_less_stat;
- typedef cc::SplitListSet< rcu_gpt, key_val, traits_SplitList_Michael_st_less_stat > SplitList_Michael_RCU_GPT_st_less_stat;
+ typedef SplitListSet< cds::gc::HP, key_val, traits_SplitList_Michael_st_less_stat > SplitList_Michael_HP_st_less_stat;
+ typedef SplitListSet< cds::gc::DHP, key_val, traits_SplitList_Michael_st_less_stat > SplitList_Michael_DHP_st_less_stat;
+ typedef SplitListSet< rcu_gpi, key_val, traits_SplitList_Michael_st_less_stat > SplitList_Michael_RCU_GPI_st_less_stat;
+ typedef SplitListSet< rcu_gpb, key_val, traits_SplitList_Michael_st_less_stat > SplitList_Michael_RCU_GPB_st_less_stat;
+ typedef SplitListSet< rcu_gpt, key_val, traits_SplitList_Michael_st_less_stat > SplitList_Michael_RCU_GPT_st_less_stat;
#ifdef CDS_URCU_SIGNAL_HANDLING_ENABLED
- typedef cc::SplitListSet< rcu_shb, key_val, traits_SplitList_Michael_st_less_stat > SplitList_Michael_RCU_SHB_st_less_stat;
- typedef cc::SplitListSet< rcu_sht, key_val, traits_SplitList_Michael_st_less_stat > SplitList_Michael_RCU_SHT_st_less_stat;
+ typedef SplitListSet< rcu_shb, key_val, traits_SplitList_Michael_st_less_stat > SplitList_Michael_RCU_SHB_st_less_stat;
+ typedef SplitListSet< rcu_sht, key_val, traits_SplitList_Michael_st_less_stat > SplitList_Michael_RCU_SHT_st_less_stat;
#endif
struct traits_SplitList_Michael_st_less_seqcst :
>
>::type
{};
- typedef cc::SplitListSet< cds::gc::HP, key_val, traits_SplitList_Michael_st_less_seqcst > SplitList_Michael_HP_st_less_seqcst;
- typedef cc::SplitListSet< cds::gc::DHP, key_val, traits_SplitList_Michael_st_less_seqcst > SplitList_Michael_DHP_st_less_seqcst;
- typedef cc::SplitListSet< rcu_gpi, key_val, traits_SplitList_Michael_st_less_seqcst > SplitList_Michael_RCU_GPI_st_less_seqcst;
- typedef cc::SplitListSet< rcu_gpb, key_val, traits_SplitList_Michael_st_less_seqcst > SplitList_Michael_RCU_GPB_st_less_seqcst;
- typedef cc::SplitListSet< rcu_gpt, key_val, traits_SplitList_Michael_st_less_seqcst > SplitList_Michael_RCU_GPT_st_less_seqcst;
+ typedef SplitListSet< cds::gc::HP, key_val, traits_SplitList_Michael_st_less_seqcst > SplitList_Michael_HP_st_less_seqcst;
+ typedef SplitListSet< cds::gc::DHP, key_val, traits_SplitList_Michael_st_less_seqcst > SplitList_Michael_DHP_st_less_seqcst;
+ typedef SplitListSet< rcu_gpi, key_val, traits_SplitList_Michael_st_less_seqcst > SplitList_Michael_RCU_GPI_st_less_seqcst;
+ typedef SplitListSet< rcu_gpb, key_val, traits_SplitList_Michael_st_less_seqcst > SplitList_Michael_RCU_GPB_st_less_seqcst;
+ typedef SplitListSet< rcu_gpt, key_val, traits_SplitList_Michael_st_less_seqcst > SplitList_Michael_RCU_GPT_st_less_seqcst;
#ifdef CDS_URCU_SIGNAL_HANDLING_ENABLED
- typedef cc::SplitListSet< rcu_shb, key_val, traits_SplitList_Michael_st_less_seqcst > SplitList_Michael_RCU_SHB_st_less_seqcst;
- typedef cc::SplitListSet< rcu_sht, key_val, traits_SplitList_Michael_st_less_seqcst > SplitList_Michael_RCU_SHT_st_less_seqcst;
+ typedef SplitListSet< rcu_shb, key_val, traits_SplitList_Michael_st_less_seqcst > SplitList_Michael_RCU_SHB_st_less_seqcst;
+ typedef SplitListSet< rcu_sht, key_val, traits_SplitList_Michael_st_less_seqcst > SplitList_Michael_RCU_SHT_st_less_seqcst;
#endif
// ***************************************************************************
>
>::type
{};
- typedef cc::SplitListSet< cds::gc::HP, key_val, traits_SplitList_Lazy_dyn_cmp > SplitList_Lazy_HP_dyn_cmp;
- typedef cc::SplitListSet< cds::gc::DHP, key_val, traits_SplitList_Lazy_dyn_cmp > SplitList_Lazy_DHP_dyn_cmp;
- typedef cc::SplitListSet< rcu_gpi, key_val, traits_SplitList_Lazy_dyn_cmp > SplitList_Lazy_RCU_GPI_dyn_cmp;
- typedef cc::SplitListSet< rcu_gpb, key_val, traits_SplitList_Lazy_dyn_cmp > SplitList_Lazy_RCU_GPB_dyn_cmp;
- typedef cc::SplitListSet< rcu_gpt, key_val, traits_SplitList_Lazy_dyn_cmp > SplitList_Lazy_RCU_GPT_dyn_cmp;
+ typedef SplitListSet< cds::gc::HP, key_val, traits_SplitList_Lazy_dyn_cmp > SplitList_Lazy_HP_dyn_cmp;
+ typedef SplitListSet< cds::gc::DHP, key_val, traits_SplitList_Lazy_dyn_cmp > SplitList_Lazy_DHP_dyn_cmp;
+ typedef SplitListSet< rcu_gpi, key_val, traits_SplitList_Lazy_dyn_cmp > SplitList_Lazy_RCU_GPI_dyn_cmp;
+ typedef SplitListSet< rcu_gpb, key_val, traits_SplitList_Lazy_dyn_cmp > SplitList_Lazy_RCU_GPB_dyn_cmp;
+ typedef SplitListSet< rcu_gpt, key_val, traits_SplitList_Lazy_dyn_cmp > SplitList_Lazy_RCU_GPT_dyn_cmp;
#ifdef CDS_URCU_SIGNAL_HANDLING_ENABLED
- typedef cc::SplitListSet< rcu_shb, key_val, traits_SplitList_Lazy_dyn_cmp > SplitList_Lazy_RCU_SHB_dyn_cmp;
- typedef cc::SplitListSet< rcu_sht, key_val, traits_SplitList_Lazy_dyn_cmp > SplitList_Lazy_RCU_SHT_dyn_cmp;
+ typedef SplitListSet< rcu_shb, key_val, traits_SplitList_Lazy_dyn_cmp > SplitList_Lazy_RCU_SHB_dyn_cmp;
+ typedef SplitListSet< rcu_sht, key_val, traits_SplitList_Lazy_dyn_cmp > SplitList_Lazy_RCU_SHT_dyn_cmp;
#endif
struct traits_SplitList_Lazy_dyn_cmp_stat : public traits_SplitList_Lazy_dyn_cmp
{
typedef cc::split_list::stat<> stat;
};
- typedef cc::SplitListSet< cds::gc::HP, key_val, traits_SplitList_Lazy_dyn_cmp_stat > SplitList_Lazy_HP_dyn_cmp_stat;
- typedef cc::SplitListSet< cds::gc::DHP, key_val, traits_SplitList_Lazy_dyn_cmp_stat > SplitList_Lazy_DHP_dyn_cmp_stat;
- typedef cc::SplitListSet< rcu_gpi, key_val, traits_SplitList_Lazy_dyn_cmp_stat > SplitList_Lazy_RCU_GPI_dyn_cmp_stat;
- typedef cc::SplitListSet< rcu_gpb, key_val, traits_SplitList_Lazy_dyn_cmp_stat > SplitList_Lazy_RCU_GPB_dyn_cmp_stat;
- typedef cc::SplitListSet< rcu_gpt, key_val, traits_SplitList_Lazy_dyn_cmp_stat > SplitList_Lazy_RCU_GPT_dyn_cmp_stat;
+ typedef SplitListSet< cds::gc::HP, key_val, traits_SplitList_Lazy_dyn_cmp_stat > SplitList_Lazy_HP_dyn_cmp_stat;
+ typedef SplitListSet< cds::gc::DHP, key_val, traits_SplitList_Lazy_dyn_cmp_stat > SplitList_Lazy_DHP_dyn_cmp_stat;
+ typedef SplitListSet< rcu_gpi, key_val, traits_SplitList_Lazy_dyn_cmp_stat > SplitList_Lazy_RCU_GPI_dyn_cmp_stat;
+ typedef SplitListSet< rcu_gpb, key_val, traits_SplitList_Lazy_dyn_cmp_stat > SplitList_Lazy_RCU_GPB_dyn_cmp_stat;
+ typedef SplitListSet< rcu_gpt, key_val, traits_SplitList_Lazy_dyn_cmp_stat > SplitList_Lazy_RCU_GPT_dyn_cmp_stat;
#ifdef CDS_URCU_SIGNAL_HANDLING_ENABLED
- typedef cc::SplitListSet< rcu_shb, key_val, traits_SplitList_Lazy_dyn_cmp > SplitList_Lazy_RCU_SHB_dyn_cmp_stat;
- typedef cc::SplitListSet< rcu_sht, key_val, traits_SplitList_Lazy_dyn_cmp > SplitList_Lazy_RCU_SHT_dyn_cmp_stat;
+ typedef SplitListSet< rcu_shb, key_val, traits_SplitList_Lazy_dyn_cmp > SplitList_Lazy_RCU_SHB_dyn_cmp_stat;
+ typedef SplitListSet< rcu_sht, key_val, traits_SplitList_Lazy_dyn_cmp > SplitList_Lazy_RCU_SHT_dyn_cmp_stat;
#endif
struct traits_SplitList_Lazy_dyn_cmp_seqcst :
>
>::type
{};
- typedef cc::SplitListSet< cds::gc::HP, key_val, traits_SplitList_Lazy_dyn_cmp_seqcst > SplitList_Lazy_HP_dyn_cmp_seqcst;
- typedef cc::SplitListSet< cds::gc::DHP, key_val, traits_SplitList_Lazy_dyn_cmp_seqcst > SplitList_Lazy_DHP_dyn_cmp_seqcst;
- typedef cc::SplitListSet< rcu_gpi, key_val, traits_SplitList_Lazy_dyn_cmp_seqcst > SplitList_Lazy_RCU_GPI_dyn_cmp_seqcst;
- typedef cc::SplitListSet< rcu_gpb, key_val, traits_SplitList_Lazy_dyn_cmp_seqcst > SplitList_Lazy_RCU_GPB_dyn_cmp_seqcst;
- typedef cc::SplitListSet< rcu_gpt, key_val, traits_SplitList_Lazy_dyn_cmp_seqcst > SplitList_Lazy_RCU_GPT_dyn_cmp_seqcst;
+ typedef SplitListSet< cds::gc::HP, key_val, traits_SplitList_Lazy_dyn_cmp_seqcst > SplitList_Lazy_HP_dyn_cmp_seqcst;
+ typedef SplitListSet< cds::gc::DHP, key_val, traits_SplitList_Lazy_dyn_cmp_seqcst > SplitList_Lazy_DHP_dyn_cmp_seqcst;
+ typedef SplitListSet< rcu_gpi, key_val, traits_SplitList_Lazy_dyn_cmp_seqcst > SplitList_Lazy_RCU_GPI_dyn_cmp_seqcst;
+ typedef SplitListSet< rcu_gpb, key_val, traits_SplitList_Lazy_dyn_cmp_seqcst > SplitList_Lazy_RCU_GPB_dyn_cmp_seqcst;
+ typedef SplitListSet< rcu_gpt, key_val, traits_SplitList_Lazy_dyn_cmp_seqcst > SplitList_Lazy_RCU_GPT_dyn_cmp_seqcst;
#ifdef CDS_URCU_SIGNAL_HANDLING_ENABLED
- typedef cc::SplitListSet< rcu_shb, key_val, traits_SplitList_Lazy_dyn_cmp_seqcst > SplitList_Lazy_RCU_SHB_dyn_cmp_seqcst;
- typedef cc::SplitListSet< rcu_sht, key_val, traits_SplitList_Lazy_dyn_cmp_seqcst > SplitList_Lazy_RCU_SHT_dyn_cmp_seqcst;
+ typedef SplitListSet< rcu_shb, key_val, traits_SplitList_Lazy_dyn_cmp_seqcst > SplitList_Lazy_RCU_SHB_dyn_cmp_seqcst;
+ typedef SplitListSet< rcu_sht, key_val, traits_SplitList_Lazy_dyn_cmp_seqcst > SplitList_Lazy_RCU_SHT_dyn_cmp_seqcst;
#endif
struct traits_SplitList_Lazy_st_cmp :
>
>::type
{};
- typedef cc::SplitListSet< cds::gc::HP, key_val, traits_SplitList_Lazy_st_cmp > SplitList_Lazy_HP_st_cmp;
- typedef cc::SplitListSet< cds::gc::DHP, key_val, traits_SplitList_Lazy_st_cmp > SplitList_Lazy_DHP_st_cmp;
- typedef cc::SplitListSet< rcu_gpi, key_val, traits_SplitList_Lazy_st_cmp > SplitList_Lazy_RCU_GPI_st_cmp;
- typedef cc::SplitListSet< rcu_gpb, key_val, traits_SplitList_Lazy_st_cmp > SplitList_Lazy_RCU_GPB_st_cmp;
- typedef cc::SplitListSet< rcu_gpt, key_val, traits_SplitList_Lazy_st_cmp > SplitList_Lazy_RCU_GPT_st_cmp;
+ typedef SplitListSet< cds::gc::HP, key_val, traits_SplitList_Lazy_st_cmp > SplitList_Lazy_HP_st_cmp;
+ typedef SplitListSet< cds::gc::DHP, key_val, traits_SplitList_Lazy_st_cmp > SplitList_Lazy_DHP_st_cmp;
+ typedef SplitListSet< rcu_gpi, key_val, traits_SplitList_Lazy_st_cmp > SplitList_Lazy_RCU_GPI_st_cmp;
+ typedef SplitListSet< rcu_gpb, key_val, traits_SplitList_Lazy_st_cmp > SplitList_Lazy_RCU_GPB_st_cmp;
+ typedef SplitListSet< rcu_gpt, key_val, traits_SplitList_Lazy_st_cmp > SplitList_Lazy_RCU_GPT_st_cmp;
#ifdef CDS_URCU_SIGNAL_HANDLING_ENABLED
- typedef cc::SplitListSet< rcu_shb, key_val, traits_SplitList_Lazy_st_cmp > SplitList_Lazy_RCU_SHB_st_cmp;
- typedef cc::SplitListSet< rcu_sht, key_val, traits_SplitList_Lazy_st_cmp > SplitList_Lazy_RCU_SHT_st_cmp;
+ typedef SplitListSet< rcu_shb, key_val, traits_SplitList_Lazy_st_cmp > SplitList_Lazy_RCU_SHB_st_cmp;
+ typedef SplitListSet< rcu_sht, key_val, traits_SplitList_Lazy_st_cmp > SplitList_Lazy_RCU_SHT_st_cmp;
#endif
struct traits_SplitList_Lazy_st_cmp_seqcst :
>
>::type
{};
- typedef cc::SplitListSet< cds::gc::HP, key_val, traits_SplitList_Lazy_st_cmp_seqcst > SplitList_Lazy_HP_st_cmp_seqcst;
- typedef cc::SplitListSet< cds::gc::DHP, key_val, traits_SplitList_Lazy_st_cmp_seqcst > SplitList_Lazy_DHP_st_cmp_seqcst;
- typedef cc::SplitListSet< rcu_gpi, key_val, traits_SplitList_Lazy_st_cmp_seqcst > SplitList_Lazy_RCU_GPI_st_cmp_seqcst;
- typedef cc::SplitListSet< rcu_gpb, key_val, traits_SplitList_Lazy_st_cmp_seqcst > SplitList_Lazy_RCU_GPB_st_cmp_seqcst;
- typedef cc::SplitListSet< rcu_gpt, key_val, traits_SplitList_Lazy_st_cmp_seqcst > SplitList_Lazy_RCU_GPT_st_cmp_seqcst;
+ typedef SplitListSet< cds::gc::HP, key_val, traits_SplitList_Lazy_st_cmp_seqcst > SplitList_Lazy_HP_st_cmp_seqcst;
+ typedef SplitListSet< cds::gc::DHP, key_val, traits_SplitList_Lazy_st_cmp_seqcst > SplitList_Lazy_DHP_st_cmp_seqcst;
+ typedef SplitListSet< rcu_gpi, key_val, traits_SplitList_Lazy_st_cmp_seqcst > SplitList_Lazy_RCU_GPI_st_cmp_seqcst;
+ typedef SplitListSet< rcu_gpb, key_val, traits_SplitList_Lazy_st_cmp_seqcst > SplitList_Lazy_RCU_GPB_st_cmp_seqcst;
+ typedef SplitListSet< rcu_gpt, key_val, traits_SplitList_Lazy_st_cmp_seqcst > SplitList_Lazy_RCU_GPT_st_cmp_seqcst;
#ifdef CDS_URCU_SIGNAL_HANDLING_ENABLED
- typedef cc::SplitListSet< rcu_shb, key_val, traits_SplitList_Lazy_st_cmp_seqcst > SplitList_Lazy_RCU_SHB_st_cmp_seqcst;
- typedef cc::SplitListSet< rcu_sht, key_val, traits_SplitList_Lazy_st_cmp_seqcst > SplitList_Lazy_RCU_SHT_st_cmp_seqcst;
+ typedef SplitListSet< rcu_shb, key_val, traits_SplitList_Lazy_st_cmp_seqcst > SplitList_Lazy_RCU_SHB_st_cmp_seqcst;
+ typedef SplitListSet< rcu_sht, key_val, traits_SplitList_Lazy_st_cmp_seqcst > SplitList_Lazy_RCU_SHT_st_cmp_seqcst;
#endif
struct traits_SplitList_Lazy_dyn_less :
>
>::type
{};
- typedef cc::SplitListSet< cds::gc::HP, key_val, traits_SplitList_Lazy_dyn_less > SplitList_Lazy_HP_dyn_less;
- typedef cc::SplitListSet< cds::gc::DHP, key_val, traits_SplitList_Lazy_dyn_less > SplitList_Lazy_DHP_dyn_less;
- typedef cc::SplitListSet< rcu_gpi, key_val, traits_SplitList_Lazy_dyn_less > SplitList_Lazy_RCU_GPI_dyn_less;
- typedef cc::SplitListSet< rcu_gpb, key_val, traits_SplitList_Lazy_dyn_less > SplitList_Lazy_RCU_GPB_dyn_less;
- typedef cc::SplitListSet< rcu_gpt, key_val, traits_SplitList_Lazy_dyn_less > SplitList_Lazy_RCU_GPT_dyn_less;
+ typedef SplitListSet< cds::gc::HP, key_val, traits_SplitList_Lazy_dyn_less > SplitList_Lazy_HP_dyn_less;
+ typedef SplitListSet< cds::gc::DHP, key_val, traits_SplitList_Lazy_dyn_less > SplitList_Lazy_DHP_dyn_less;
+ typedef SplitListSet< rcu_gpi, key_val, traits_SplitList_Lazy_dyn_less > SplitList_Lazy_RCU_GPI_dyn_less;
+ typedef SplitListSet< rcu_gpb, key_val, traits_SplitList_Lazy_dyn_less > SplitList_Lazy_RCU_GPB_dyn_less;
+ typedef SplitListSet< rcu_gpt, key_val, traits_SplitList_Lazy_dyn_less > SplitList_Lazy_RCU_GPT_dyn_less;
#ifdef CDS_URCU_SIGNAL_HANDLING_ENABLED
- typedef cc::SplitListSet< rcu_shb, key_val, traits_SplitList_Lazy_dyn_less > SplitList_Lazy_RCU_SHB_dyn_less;
- typedef cc::SplitListSet< rcu_sht, key_val, traits_SplitList_Lazy_dyn_less > SplitList_Lazy_RCU_SHT_dyn_less;
+ typedef SplitListSet< rcu_shb, key_val, traits_SplitList_Lazy_dyn_less > SplitList_Lazy_RCU_SHB_dyn_less;
+ typedef SplitListSet< rcu_sht, key_val, traits_SplitList_Lazy_dyn_less > SplitList_Lazy_RCU_SHT_dyn_less;
#endif
struct traits_SplitList_Lazy_dyn_less_seqcst :
>
>::type
{};
- typedef cc::SplitListSet< cds::gc::HP, key_val, traits_SplitList_Lazy_dyn_less_seqcst > SplitList_Lazy_HP_dyn_less_seqcst;
- typedef cc::SplitListSet< cds::gc::DHP, key_val, traits_SplitList_Lazy_dyn_less_seqcst > SplitList_Lazy_DHP_dyn_less_seqcst;
- typedef cc::SplitListSet< rcu_gpi, key_val, traits_SplitList_Lazy_dyn_less_seqcst > SplitList_Lazy_RCU_GPI_dyn_less_seqcst;
- typedef cc::SplitListSet< rcu_gpb, key_val, traits_SplitList_Lazy_dyn_less_seqcst > SplitList_Lazy_RCU_GPB_dyn_less_seqcst;
- typedef cc::SplitListSet< rcu_gpt, key_val, traits_SplitList_Lazy_dyn_less_seqcst > SplitList_Lazy_RCU_GPT_dyn_less_seqcst;
+ typedef SplitListSet< cds::gc::HP, key_val, traits_SplitList_Lazy_dyn_less_seqcst > SplitList_Lazy_HP_dyn_less_seqcst;
+ typedef SplitListSet< cds::gc::DHP, key_val, traits_SplitList_Lazy_dyn_less_seqcst > SplitList_Lazy_DHP_dyn_less_seqcst;
+ typedef SplitListSet< rcu_gpi, key_val, traits_SplitList_Lazy_dyn_less_seqcst > SplitList_Lazy_RCU_GPI_dyn_less_seqcst;
+ typedef SplitListSet< rcu_gpb, key_val, traits_SplitList_Lazy_dyn_less_seqcst > SplitList_Lazy_RCU_GPB_dyn_less_seqcst;
+ typedef SplitListSet< rcu_gpt, key_val, traits_SplitList_Lazy_dyn_less_seqcst > SplitList_Lazy_RCU_GPT_dyn_less_seqcst;
#ifdef CDS_URCU_SIGNAL_HANDLING_ENABLED
- typedef cc::SplitListSet< rcu_shb, key_val, traits_SplitList_Lazy_dyn_less_seqcst > SplitList_Lazy_RCU_SHB_dyn_less_seqcst;
- typedef cc::SplitListSet< rcu_sht, key_val, traits_SplitList_Lazy_dyn_less_seqcst > SplitList_Lazy_RCU_SHT_dyn_less_seqcst;
+ typedef SplitListSet< rcu_shb, key_val, traits_SplitList_Lazy_dyn_less_seqcst > SplitList_Lazy_RCU_SHB_dyn_less_seqcst;
+ typedef SplitListSet< rcu_sht, key_val, traits_SplitList_Lazy_dyn_less_seqcst > SplitList_Lazy_RCU_SHT_dyn_less_seqcst;
#endif
struct traits_SplitList_Lazy_st_less :
>
>::type
{};
- typedef cc::SplitListSet< cds::gc::HP, key_val, traits_SplitList_Lazy_st_less > SplitList_Lazy_HP_st_less;
- typedef cc::SplitListSet< cds::gc::DHP, key_val, traits_SplitList_Lazy_st_less > SplitList_Lazy_DHP_st_less;
- typedef cc::SplitListSet< rcu_gpi, key_val, traits_SplitList_Lazy_st_less > SplitList_Lazy_RCU_GPI_st_less;
- typedef cc::SplitListSet< rcu_gpb, key_val, traits_SplitList_Lazy_st_less > SplitList_Lazy_RCU_GPB_st_less;
- typedef cc::SplitListSet< rcu_gpt, key_val, traits_SplitList_Lazy_st_less > SplitList_Lazy_RCU_GPT_st_less;
+ typedef SplitListSet< cds::gc::HP, key_val, traits_SplitList_Lazy_st_less > SplitList_Lazy_HP_st_less;
+ typedef SplitListSet< cds::gc::DHP, key_val, traits_SplitList_Lazy_st_less > SplitList_Lazy_DHP_st_less;
+ typedef SplitListSet< rcu_gpi, key_val, traits_SplitList_Lazy_st_less > SplitList_Lazy_RCU_GPI_st_less;
+ typedef SplitListSet< rcu_gpb, key_val, traits_SplitList_Lazy_st_less > SplitList_Lazy_RCU_GPB_st_less;
+ typedef SplitListSet< rcu_gpt, key_val, traits_SplitList_Lazy_st_less > SplitList_Lazy_RCU_GPT_st_less;
#ifdef CDS_URCU_SIGNAL_HANDLING_ENABLED
- typedef cc::SplitListSet< rcu_shb, key_val, traits_SplitList_Lazy_st_less > SplitList_Lazy_RCU_SHB_st_less;
- typedef cc::SplitListSet< rcu_sht, key_val, traits_SplitList_Lazy_st_less > SplitList_Lazy_RCU_SHT_st_less;
+ typedef SplitListSet< rcu_shb, key_val, traits_SplitList_Lazy_st_less > SplitList_Lazy_RCU_SHB_st_less;
+ typedef SplitListSet< rcu_sht, key_val, traits_SplitList_Lazy_st_less > SplitList_Lazy_RCU_SHT_st_less;
#endif
struct traits_SplitList_Lazy_st_less_seqcst :
>
>::type
{};
- typedef cc::SplitListSet< cds::gc::HP, key_val, traits_SplitList_Lazy_st_less_seqcst > SplitList_Lazy_HP_st_less_seqcst;
- typedef cc::SplitListSet< cds::gc::DHP, key_val, traits_SplitList_Lazy_st_less_seqcst > SplitList_Lazy_DHP_st_less_seqcst;
- typedef cc::SplitListSet< rcu_gpi, key_val, traits_SplitList_Lazy_st_less_seqcst > SplitList_Lazy_RCU_GPI_st_less_seqcst;
- typedef cc::SplitListSet< rcu_gpb, key_val, traits_SplitList_Lazy_st_less_seqcst > SplitList_Lazy_RCU_GPB_st_less_seqcst;
- typedef cc::SplitListSet< rcu_gpt, key_val, traits_SplitList_Lazy_st_less_seqcst > SplitList_Lazy_RCU_GPT_st_less_seqcst;
+ typedef SplitListSet< cds::gc::HP, key_val, traits_SplitList_Lazy_st_less_seqcst > SplitList_Lazy_HP_st_less_seqcst;
+ typedef SplitListSet< cds::gc::DHP, key_val, traits_SplitList_Lazy_st_less_seqcst > SplitList_Lazy_DHP_st_less_seqcst;
+ typedef SplitListSet< rcu_gpi, key_val, traits_SplitList_Lazy_st_less_seqcst > SplitList_Lazy_RCU_GPI_st_less_seqcst;
+ typedef SplitListSet< rcu_gpb, key_val, traits_SplitList_Lazy_st_less_seqcst > SplitList_Lazy_RCU_GPB_st_less_seqcst;
+ typedef SplitListSet< rcu_gpt, key_val, traits_SplitList_Lazy_st_less_seqcst > SplitList_Lazy_RCU_GPT_st_less_seqcst;
#ifdef CDS_URCU_SIGNAL_HANDLING_ENABLED
- typedef cc::SplitListSet< rcu_shb, key_val, traits_SplitList_Lazy_st_less_seqcst > SplitList_Lazy_RCU_SHB_st_less_seqcst;
- typedef cc::SplitListSet< rcu_sht, key_val, traits_SplitList_Lazy_st_less_seqcst > SplitList_Lazy_RCU_SHT_st_less_seqcst;
+ typedef SplitListSet< rcu_shb, key_val, traits_SplitList_Lazy_st_less_seqcst > SplitList_Lazy_RCU_SHB_st_less_seqcst;
+ typedef SplitListSet< rcu_sht, key_val, traits_SplitList_Lazy_st_less_seqcst > SplitList_Lazy_RCU_SHT_st_less_seqcst;
#endif
struct traits_SplitList_Lazy_st_less_stat : public traits_SplitList_Lazy_st_less
{
typedef cc::split_list::stat<> stat;
};
- typedef cc::SplitListSet< cds::gc::HP, key_val, traits_SplitList_Lazy_st_less_stat > SplitList_Lazy_HP_st_less_stat;
- typedef cc::SplitListSet< cds::gc::DHP, key_val, traits_SplitList_Lazy_st_less_stat > SplitList_Lazy_DHP_st_less_stat;
- typedef cc::SplitListSet< rcu_gpi, key_val, traits_SplitList_Lazy_st_less_stat > SplitList_Lazy_RCU_GPI_st_less_stat;
- typedef cc::SplitListSet< rcu_gpb, key_val, traits_SplitList_Lazy_st_less_stat > SplitList_Lazy_RCU_GPB_st_less_stat;
- typedef cc::SplitListSet< rcu_gpt, key_val, traits_SplitList_Lazy_st_less_stat > SplitList_Lazy_RCU_GPT_st_less_stat;
+ typedef SplitListSet< cds::gc::HP, key_val, traits_SplitList_Lazy_st_less_stat > SplitList_Lazy_HP_st_less_stat;
+ typedef SplitListSet< cds::gc::DHP, key_val, traits_SplitList_Lazy_st_less_stat > SplitList_Lazy_DHP_st_less_stat;
+ typedef SplitListSet< rcu_gpi, key_val, traits_SplitList_Lazy_st_less_stat > SplitList_Lazy_RCU_GPI_st_less_stat;
+ typedef SplitListSet< rcu_gpb, key_val, traits_SplitList_Lazy_st_less_stat > SplitList_Lazy_RCU_GPB_st_less_stat;
+ typedef SplitListSet< rcu_gpt, key_val, traits_SplitList_Lazy_st_less_stat > SplitList_Lazy_RCU_GPT_st_less_stat;
#ifdef CDS_URCU_SIGNAL_HANDLING_ENABLED
- typedef cc::SplitListSet< rcu_shb, key_val, traits_SplitList_Lazy_st_less_stat > SplitList_Lazy_RCU_SHB_st_less_stat;
- typedef cc::SplitListSet< rcu_sht, key_val, traits_SplitList_Lazy_st_less_stat > SplitList_Lazy_RCU_SHT_st_less_stat;
+ typedef SplitListSet< rcu_shb, key_val, traits_SplitList_Lazy_st_less_stat > SplitList_Lazy_RCU_SHB_st_less_stat;
+ typedef SplitListSet< rcu_sht, key_val, traits_SplitList_Lazy_st_less_stat > SplitList_Lazy_RCU_SHT_st_less_stat;
#endif
};
template <typename GC, typename T, typename Traits>
- static inline void print_stat( cc::SplitListSet<GC, T, Traits> const& s )
+ static inline void print_stat( SplitListSet<GC, T, Traits> const& s )
{
CPPUNIT_MSG( s.statistics() );
}
projects / libcds.git / commitdiff