typedef basket_queue::empty_stat stat;
/// C++ memory ordering model
- /**
+ /**
Can be \p opt::v::relaxed_ordering (relaxed memory model, the default)
or \p opt::v::sequential_consistent (sequentially consisnent memory model).
*/
Example: declare \p %BasketQueue with item counting and internal statistics
\code
- typedef cds::container::BasketQueue< cds::gc::HP, Foo,
+ typedef cds::container::BasketQueue< cds::gc::HP, Foo,
typename cds::container::basket_queue::make_traits<
cds::opt::item_counte< cds::atomicity::item_counter >,
cds::opt::stat< cds::intrusive::basket_queue::stat<> >
typedef cds::container::BasketQueue< cds::gc::HP, Foo, myTraits > myQueue;
// Equivalent make_traits example:
- typedef cds::container::BasketQueue< cds::gc::HP, Foo,
- typename cds::container::basket_queue::make_traits<
+ typedef cds::container::BasketQueue< cds::gc::HP, Foo,
+ typename cds::container::basket_queue::make_traits<
cds::opt::stat< cds::container::basket_queue::stat<> >,
cds::opt::item_counter< cds::atomicity::item_counter >
>::type
typedef atomicity::empty_item_counter item_counter;
/// C++ memory ordering model
- /**
+ /**
Can be \p opt::v::relaxed_ordering (relaxed memory model, the default)
or \p opt::v::sequential_consistent (sequentially consisnent memory model).
*/
\code void func( value_type& item ) ;\endcode
The argument \p item of user-defined functor \p func is the reference
- to the list's item inserted.
+ to the list's item inserted.
When \p func is called it has exclusive access to the item.
The user-defined functor is called only if the inserting is success.
constant key and alterable value.
Usually, ordered single-linked list is used as a building block for the hash table implementation.
- The complexity of searching is <tt>O(N)</tt> where \p N is the item count in the list, not in the
+ The complexity of searching is <tt>O(N)</tt> where \p N is the item count in the list, not in the
hash table.
Template arguments:
\anchor cds_nonintrusive_MichaelList_gc
Usually, ordered single-linked list is used as a building block for the hash table implementation.
- The complexity of searching is <tt>O(N)</tt>, where \p N is the item count in the list, not in the
+ The complexity of searching is <tt>O(N)</tt>, where \p N is the item count in the list, not in the
hash table.
Source:
@copydetails cds_nonintrusive_LazyList_gc
*/
template <
- typename T,
+ typename T,
#ifdef CDS_DOXYGEN_INVOKED
typename Traits = lazy_list::traits
#else
\code void func( value_type& itemValue ) ;\endcode
The argument \p itemValue of user-defined functor \p func is the reference
- to the list's item inserted.
+ to the list's item inserted.
The user-defined functor is called only if the inserting is success.
The type \p Q should contain the complete key of the node.
See \ref cds_nonintrusive_MichaelList_gc "MichaelList" for description of template parameters.
*/
- template <typename T,
+ template <typename T,
#ifdef CDS_DOXYGEN_INVOKED
class Traits = michael_list::traits
#else
//@endcond
public:
- typedef cds::urcu::gc<RCU> gc; ///< RCU
+ typedef cds::urcu::gc<RCU> gc; ///< RCU
typedef T value_type; ///< Type of value stored in the list
typedef Traits traits; ///< List traits
/** \anchor cds_nonintrusive_MichealList_rcu_erase_val
Since the key of MichaelList's item type \p value_type is not explicitly specified,
template parameter \p Q defines the key type searching in the list.
- The list item comparator should be able to compare values of the type \p value_type
+ The list item comparator should be able to compare values of the type \p value_type
and \p Q in any order.
RCU \p synchronize method can be called. RCU should not be locked.
static_assert( std::is_same<gc, typename bucket_type::gc>::value, "GC and OrderedList::gc must be the same");
// atomicity::empty_item_counter is not allowed as a item counter
- static_assert( !std::is_same<item_counter, atomicity::empty_item_counter>::value,
+ static_assert( !std::is_same<item_counter, atomicity::empty_item_counter>::value,
"atomicity::empty_item_counter is not allowed as a item counter");
m_Buckets = bucket_table_allocator().NewArray( bucket_count() );
static_assert( std::is_same<gc, typename bucket_type::gc>::value, "GC and OrderedList::gc must be the same");
// atomicity::empty_item_counter is not allowed as a item counter
- static_assert( !std::is_same<item_counter, cds::atomicity::empty_item_counter>::value,
+ static_assert( !std::is_same<item_counter, cds::atomicity::empty_item_counter>::value,
"cds::atomicity::empty_item_counter is not allowed as a item counter");
m_Buckets = bucket_table_allocator().NewArray( bucket_count() );
static_assert( std::is_same<gc, typename bucket_type::gc>::value, "GC and OrderedList::gc must be the same");
// atomicity::empty_item_counter is not allowed as a item counter
- static_assert( !std::is_same<item_counter, atomicity::empty_item_counter>::value,
+ static_assert( !std::is_same<item_counter, atomicity::empty_item_counter>::value,
"cds::atomicity::empty_item_counter is not allowed as a item counter");
m_Buckets = bucket_table_allocator().NewArray( bucket_count() );
void func( value_type& val );
\endcode
where \p val is the item inserted.
- The user-defined functor is called only if the inserting is success.
+ The user-defined functor is called only if the inserting is success.
@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
static_assert( std::is_same<gc, typename bucket_type::gc>::value, "GC and OrderedList::gc must be the same");
// atomicity::empty_item_counter is not allowed as a item counter
- static_assert( !std::is_same<item_counter, atomicity::empty_item_counter>::value,
+ static_assert( !std::is_same<item_counter, atomicity::empty_item_counter>::value,
"cds::atomicity::empty_item_counter is not allowed as a item counter");
m_Buckets = bucket_table_allocator().NewArray( bucket_count() );
Template parameters are:
- \p RCU - one of \ref cds_urcu_gc "RCU type"
- - \p OrderedList - ordered list implementation used as the bucket for hash set, for example,
+ - \p OrderedList - ordered list implementation used as the bucket for hash set, for example,
\ref cds_nonintrusive_MichaelList_rcu "MichaelList".
The ordered list implementation specifies the type \p T stored in the hash-set,
the comparison functor for the type \p T and other features specific for
typedef cds::container::MoirQueue< cds::gc::HP, Foo, myTraits > myQueue;
// Equivalent make_traits example:
- typedef cds::container::MoirQueue< cds::gc::HP, Foo,
- typename cds::container::msqueue::make_traits<
+ typedef cds::container::MoirQueue< cds::gc::HP, Foo,
+ typename cds::container::msqueue::make_traits<
cds::opt::stat< cds::container::msqueue::stat<> >,
cds::opt::item_counter< cds::atomicity::item_counter >
>::type
typedef msqueue::empty_stat stat;
/// C++ memory ordering model
- /**
+ /**
Can be \p opt::v::relaxed_ordering (relaxed memory model, the default)
or \p opt::v::sequential_consistent (sequentially consisnent memory model).
*/
Example: declare \p %MSQueue with item counting and internal statistics
\code
- typedef cds::container::MSQueue< cds::gc::HP, Foo,
+ typedef cds::container::MSQueue< cds::gc::HP, Foo,
typename cds::container::msqueue::make_traits<
cds::opt::item_counter< cds::atomicity::item_counter >,
cds::opt::stat< cds::container::msqueue::stat<> >
typedef cds::container::MSQueue< cds::gc::HP, Foo, myTraits > myQueue;
// Equivalent make_traits example:
- typedef cds::container::MSQueue< cds::gc::HP, Foo,
- typename cds::container::msqueue::make_traits<
+ typedef cds::container::MSQueue< cds::gc::HP, Foo,
+ typename cds::container::msqueue::make_traits<
cds::opt::stat< cds::container::msqueue::stat<> >,
cds::opt::item_counter< cds::atomicity::item_counter >
>::type
- opt::item_counter - the type of item counting feature. Default is \p cds::atomicity::empty_item_counter (item counting disabled)
To enable item counting use \p cds::atomicity::item_counter
- opt::stat - the type to gather internal statistics.
- Possible statistics types are: \p optimistic_queue::stat, \p optimistic_queue::empty_stat,
+ Possible statistics types are: \p optimistic_queue::stat, \p optimistic_queue::empty_stat,
user-provided class that supports \p %optimistic_queue::stat interface.
Default is \p %optimistic_queue::empty_stat.
- opt::alignment - the alignment for internal queue data. Default is \p opt::cache_line_alignment
typedef cds::container::OptimisticQueue< cds::gc::HP, Foo, myTraits > myQueue;
// Equivalent make_traits example:
- typedef cds::container::OptimisticQueue< cds::gc::HP, Foo,
- typename cds::container::optimistic_queue::make_traits<
+ typedef cds::container::OptimisticQueue< cds::gc::HP, Foo,
+ typename cds::container::optimistic_queue::make_traits<
cds::opt::stat< cds::container::optimistic_queue::stat<> >,
cds::opt::item_counter< cds::atomicity::item_counter >
>::type
Example: declare mutex-based \p %RWQueue with item counting
\code
- typedef cds::container::RWQueue< Foo,
+ typedef cds::container::RWQueue< Foo,
typename cds::container::rwqueue::make_traits<
cds::opt::item_counter< cds::atomicity::item_counter >,
cds::opt::lock_type< std::mutex >
typedef cds::container::RWQueue< Foo, myTraits > myQueue;
// Equivalent make_traits example:
- typedef cds::container::RWQueue< Foo,
- typename cds::container::rwqueue::make_traits<
+ typedef cds::container::RWQueue< Foo,
+ typename cds::container::rwqueue::make_traits<
cds::opt::item_counter< cds::atomicity::item_counter >
>::type
> myQueue;
}
};
- struct intrusive_type_traits: public original_type_traits
+ struct intrusive_type_traits: public original_type_traits
{
typedef node_disposer disposer;
};
/** @ingroup cds_nonintrusive_map
\anchor cds_nonintrusive_SplitListMap_nogc
- This specialization is so-called append-only.
+ This specialization is so-called append-only.
The map does not support the removal of list item.
See \ref cds_nonintrusive_SplitListMap_hp "SplitListMap" for description of template parameters.
\par Usage
You should decide what garbage collector you want, and what ordered list you want to use as a base. Split-ordered list
- is original data structure based on an ordered list.
+ is original data structure based on an ordered list.
Suppose, you want construct split-list set based on \p gc::DHP GC
and \p LazyList as ordered list implementation. So, you beginning your program with following include:
@warning Many member functions return an iterator pointing to an item.
The iterator can be used to set up field of the item,
- but you should provide an exclusive access to it,
+ but you should provide an exclusive access to it,
see \ref cds_intrusive_item_creating "insert item troubleshooting".
*/
template <
,cc::split_list::make_traits< // metafunction to build split-list traits
cc::split_list::ordered_list<cc::lazy_list_tag> // tag for underlying ordered list implementation
,cc::opt::hash< foo_hash > // hash functor
- ,cc::split_list::ordered_list_traits< // ordered list traits
+ ,cc::split_list::ordered_list_traits< // ordered list traits
cc::lazy_list::make_traits< // metafunction to build lazy list traits
cc::opt::less< foo_less > // less-based compare functor
>::type
typedef cds::container::TreiberStack< cds::gc::HP, Foo, myTraits > myStack;
// Equivalent make_traits example:
- typedef cds::intrusive::TreiberStack< cds::gc::HP, Foo,
+ typedef cds::intrusive::TreiberStack< cds::gc::HP, Foo,
typename cds::intrusive::treiber_stack::make_traits<
cds::opt::item_counter< cds::atomicity::item_counter >,
cds::opt::stat< cds::intrusive::treiber_stack::stat<> >
> myStack;
\endcode
*/
- template <
- typename GC,
- typename T,
- typename Traits = treiber_stack::traits
+ template <
+ typename GC,
+ typename T,
+ typename Traits = treiber_stack::traits
>
class TreiberStack
: public
Example: declare \p %TsigasCycleQueue with item counting and static iternal buffer of size 1024:
\code
- typedef cds::container::TsigasCycleQueue< Foo,
+ typedef cds::container::TsigasCycleQueue< Foo,
typename cds::container::tsigas_queue::make_traits<
cds::opt::buffer< cds::opt::v::static_buffer< void *, 1024 >,
cds::opt::item_counte< cds::atomicity::item_counter >
typedef cds::container::TsigasCycleQueue< Foo, myTraits > myQueue;
// Equivalent make_traits example:
- typedef cds::container::TsigasCycleQueue< cds::gc::HP, Foo,
- typename cds::container::tsigas_queue::make_traits<
+ typedef cds::container::TsigasCycleQueue< cds::gc::HP, Foo,
+ typename cds::container::tsigas_queue::make_traits<
cds::opt::item_counter< cds::atomicity::item_counter >
>::type
> myQueue;
};
// Queue of Foo, capacity is 1024, statically allocated buffer:
- typedef cds::container::TsigasCycleQueue< Foo,
+ typedef cds::container::TsigasCycleQueue< Foo,
typename cds::container::tsigas_queue::make_traits<
cds::opt::buffer< cds::opt::v::static_buffer< Foo, 1024 > >
>::type
*/
typedef cds::opt::v::dynamic_buffer< void * > buffer;
- /// A functor to clean item dequeued.
+ /// A functor to clean item dequeued.
/**
The functor calls the destructor for queue item.
After an item is dequeued, \p value_cleaner cleans the cell that the item has been occupied.
- \p opt::buffer - the buffer type for internal cyclic array. Possible types are:
\p opt::v::dynamic_buffer (the default), \p opt::v::static_buffer. The type of
element in the buffer is not important: it will be changed via \p rebind metafunction.
- - \p opt::value_cleaner - a functor to clean item dequeued.
+ - \p opt::value_cleaner - a functor to clean item dequeued.
The functor calls the destructor for queue item.
After an item is dequeued, \p value_cleaner cleans the cell that the item has been occupied.
If \p T is a complex type, \p value_cleaner may be the useful feature.
Example: declare \p %VyukovMPMCCycleQueue with item counting and static iternal buffer of size 1024:
\code
- typedef cds::container::VyukovMPMCCycleQueue< Foo,
+ typedef cds::container::VyukovMPMCCycleQueue< Foo,
typename cds::container::vyukov_queue::make_traits<
cds::opt::buffer< cds::opt::v::static_buffer< void *, 1024 >,
cds::opt::item_counte< cds::atomicity::item_counter >
typedef cds::container::VyukovMPMCCycleQueue< Foo, myTraits > myQueue;
// Equivalent make_traits example:
- typedef cds::container::VyukovMPMCCycleQueue< cds::gc::HP, Foo,
- typename cds::container::vykov_queue::make_traits<
+ typedef cds::container::VyukovMPMCCycleQueue< cds::gc::HP, Foo,
+ typename cds::container::vykov_queue::make_traits<
cds::opt::item_counter< cds::atomicity::item_counter >
>::type
> myQueue;
atomic& operator=(const atomic&) = delete;
#if !(CDS_COMPILER == CDS_COMPILER_MSVC && CDS_COMPILER_VERSION <= CDS_COMPILER_MSVC12)
- // MSVC12: warning C4522: multiple assignment operators specified\r
+ // MSVC12: warning C4522: multiple assignment operators specified
atomic& operator=(const atomic&) volatile = delete;
marked_ptr operator=(marked_ptr val) volatile CDS_NOEXCEPT
{
typedef basket_queue::empty_stat stat;
/// C++ memory ordering model
- /**
+ /**
Can be \p opt::v::relaxed_ordering (relaxed memory model, the default)
or \p opt::v::sequential_consistent (sequentially consisnent memory model).
*/
Example: declare \p %BasketQueue with item counting and internal statistics
\code
- typedef cds::intrusive::BasketQueue< cds::gc::HP, Foo,
+ typedef cds::intrusive::BasketQueue< cds::gc::HP, Foo,
typename cds::intrusive::basket_queue::make_traits<
cds::intrusive::opt:hook< cds::intrusive::basket_queue::base_hook< cds::opt::gc<cds:gc::HP> >>,
cds::opt::item_counte< cds::atomicity::item_counter >,
typedef cds::intrusive::BasketQueue< cds::gc::HP, Foo, myTraits > myQueue;
// Equivalent make_traits example:
- typedef cds::intrusive::BasketQueue< cds::gc::HP, Foo,
- typename cds::intrusive::basket_queue::make_traits<
+ typedef cds::intrusive::BasketQueue< cds::gc::HP, Foo,
+ typename cds::intrusive::basket_queue::make_traits<
cds::opt::stat< cds::intrusive::basket_queue::stat<> >,
cds::opt::item_counter< cds::atomicity::item_counter >
>::type
ci::basket_queue::node< hp_gc > hMember;
};
- struct barTraits: public
+ struct barTraits: public
ci::basket_queue::make_traits<
ci::opt::hook<
ci::basket_queue::member_hook<
\anchor cds_intrusive_hook_tag
\par Tags
Many hooks and nodes for intrusive containers contain template argument \p Tag.
- This argument serves as a tag, so you can derive from more than one container's node and hence put an object in multiple intrusive containers
- at the same time. An incomplete type can serve as a tag. If you specify two hooks, you must specify a different tag for each one.
- Example:
+ This argument serves as a tag, so you can derive from more than one container's node and hence put an object in multiple intrusive containers
+ at the same time. An incomplete type can serve as a tag. If you specify two hooks, you must specify a different tag for each one.
+ Example:
\code
struct tag1;
- cds::intrusive::treiber_stack::node< cds::gc::HP, tag<tag1> >
+ cds::intrusive::treiber_stack::node< cds::gc::HP, tag<tag1> >
\endcode
If no tag is specified the default \p cds::opt::none will be used.
\anchor cds_intrusive_item_creating
\par Inserting items
- Many intrusive and non-intrusive (standard-like) containers in the library have the member functions
- that take an functor argument to initialize the inserted item after it has been successfully inserted,
+ Many intrusive and non-intrusive (standard-like) containers in the library have the member functions
+ that take an functor argument to initialize the inserted item after it has been successfully inserted,
for example:
\code
template <typename Q, typename Func>
Create a new item Find key 5
with calling Foo(5) ctor
Insert the new item
- The key 5 is found -
+ The key 5 is found -
call the functor (!)
Perform complex
- initialization -
+ initialization -
call the functor
\endcode
(!): Thread 2 found the key and call its functor on incomplete initialized item.
Simultaneous access to the item also is possible. In this case Thread 1 is
- initializing the item, thread 2 is reading (or writing) the item's fields.
+ initializing the item, thread 2 is reading (or writing) the item's fields.
In any case, Thread 2 can read uninitialized or incomplete initialized fields.
- \p ensure member function race. Suppose, thread 1 and thread 2 perform
- the
+ \p ensure member function race. Suppose, thread 1 and thread 2 perform
+ the
following code:
\code
q.ensure( 5, []( bool bNew, Foo& item, int arg )
}
else {
// do some work
- if ( !item.f1 )
+ if ( !item.f1 )
item.f1 = ...;
else {
//...
key 5 not found
insert new item Foo(5) Find 5
Key 5 found
- call the functor with
+ call the functor with
bNew = false (!)
call the functor with
bNew = true
\endcode
- (!): Thread 2 executes its functor on incomplete initialized item.
+ (!): Thread 2 executes its functor on incomplete initialized item.
To protect your code from such races you can use some item-level synchronization,
for example:
}
else {
// do some work
- if ( !item.f1 )
+ if ( !item.f1 )
item.f1 = ...;
else {
//...
static const opt::link_check_type link_checker = opt::debug_check_link;
/// C++ memory ordering model
- /**
+ /**
Can be \p opt::v::relaxed_ordering (relaxed memory model, the default)
or \p opt::v::sequential_consistent (sequentially consisnent memory model).
*/
static const opt::link_check_type link_checker = opt::debug_check_link;
/// C++ memory ordering model
- /**
+ /**
Can be \p opt::v::relaxed_ordering (relaxed memory model, the default)
or \p opt::v::sequential_consistent (sequentially consisnent memory model).
*/
template <typename OrderedList, bool IsConst>
class iterator
{
- friend class iterator < OrderedList, !IsConst > ;
+ friend class iterator < OrderedList, !IsConst >;
protected:
typedef OrderedList bucket_type;
typedef typename list_iterator_selector< bucket_type, IsConst>::bucket_ptr bucket_ptr;
void onExtractFailed() { ++m_nExtractFailed; }
void onFindSuccess() { ++m_nFindSuccess; }
void onFindFailed() { ++m_nFindFailed; }
- bool onFind(bool bSuccess)
- {
+ bool onFind(bool bSuccess)
+ {
if ( bSuccess )
onFindSuccess();
else
/// Internal statistics (by default, disabled)
/**
- Possible statistics types are: \p split_list::stat (enable internal statistics),
+ Possible statistics types are: \p split_list::stat (enable internal statistics),
\p split_list::empty_stat (the default, internal statistics disabled),
user-provided class that supports \p %split_list::stat interface.
*/
/// C++ memory ordering model
- /**
+ /**
Can be \p opt::v::relaxed_ordering (relaxed memory model, the default)
or \p opt::v::sequential_consistent (sequentially consisnent memory model).
*/
- \p opt::item_counter - optional, specifies item counting policy. See \p traits::item_counter
for default type.
- \p opt::memory_model - C++ memory model for atomic operations.
- Can be \p opt::v::relaxed_ordering (relaxed memory model, the default)
+ Can be \p opt::v::relaxed_ordering (relaxed memory model, the default)
or \p opt::v::sequential_consistent (sequentially consisnent memory model).
- \p opt::allocator - optional, bucket table allocator. Default is \ref CDS_DEFAULT_ALLOCATOR.
- \p split_list::dynamic_bucket_table - use dynamic or static bucket table implementation.
- \p GC - Garbage collector used. Note the \p GC must be the same as the GC used for item type \p T (see lazy_list::node).
- \p T - type to be stored in the list. The type must be based on lazy_list::node (for lazy_list::base_hook)
or it must have a member of type lazy_list::node (for lazy_list::member_hook).
- - \p Traits - type traits. See lazy_list::traits for explanation.
+ - \p Traits - type traits. See lazy_list::traits for explanation.
It is possible to declare option-based list with cds::intrusive::lazy_list::make_traits metafunction istead of \p Traits template
argument. For example, the following traits-based declaration of \p gc::HP lazy list
\code
- \p GC - Garbage collector used. Note the \p GC must be the same as the GC used for item type \p T (see \p michael_list::node).
- \p T - type to be stored in the list. The type must be based on \p michael_list::node (for \p michael_list::base_hook)
or it must have a member of type \p michael_list::node (for \p michael_list::member_hook).
- - \p Traits - type traits, default is \p michael_list::traits. It is possible to declare option-based
+ - \p Traits - type traits, default is \p michael_list::traits. It is possible to declare option-based
list with \p cds::intrusive::michael_list::make_traits metafunction:
For example, the following traits-based declaration of \p gc::HP Michael's list
\code
typename Lock = cds::lock::Spin,
typename Tag = opt::none
#else
- typename Lock,
+ typename Lock,
typename Tag
#endif
>
See \ref cds_intrusive_MichaelList_hp "MichaelList" for description of template parameters.
*/
- template < typename T,
+ template < typename T,
#ifdef CDS_DOXYGEN_INVOKED
class Traits = michael_list::traits
#else
- \p RCU - one of \ref cds_urcu_gc "RCU type"
- \p T - type to be stored in the list; the type \p T should be based on (or has a member of type)
cds::intrusive::micheal_list::node
- - \p Traits - type traits. See \p michael_list::traits for explanation. It is possible to declare option-based
- list with \p cds::intrusive::michael_list::make_traits metafunction,
+ - \p Traits - type traits. See \p michael_list::traits for explanation. It is possible to declare option-based
+ list with \p cds::intrusive::michael_list::make_traits metafunction,
see \ref cds_intrusive_MichaelList_hp "here" for explanations.
\par Usage
typedef cds::intrusive::MichaelList<cds::urcu::gc< cds::urcu::general_buffered<> >, Foo > rcu_michael_list;
\endcode
*/
- template < typename RCU, typename T,
+ template < typename RCU, typename T,
#ifdef CDS_DOXYGEN_INVOKED
class Traits = michael_list::traits
#else
static_assert( std::is_same<gc, typename bucket_type::gc>::value, "GC and OrderedList::gc must be the same");
// atomicity::empty_item_counter is not allowed as a item counter
- static_assert( !std::is_same<item_counter, atomicity::empty_item_counter>::value,
+ static_assert( !std::is_same<item_counter, atomicity::empty_item_counter>::value,
"cds::atomicity::empty_item_counter is not allowed as a item counter");
m_Buckets = bucket_table_allocator().NewArray( bucket_count() );
static_assert( std::is_same<gc, typename bucket_type::gc>::value, "GC and OrderedList::gc must be the same");
// atomicity::empty_item_counter is not allowed as a item counter
- static_assert( !std::is_same<item_counter, atomicity::empty_item_counter>::value,
+ static_assert( !std::is_same<item_counter, atomicity::empty_item_counter>::value,
"atomicity::empty_item_counter is not allowed as a item counter");
m_Buckets = bucket_table_allocator().NewArray( bucket_count() );
static_assert( std::is_same<gc, typename bucket_type::gc>::value, "GC and OrderedList::gc must be the same");
// atomicity::empty_item_counter is not allowed as a item counter
- static_assert( !std::is_same<item_counter, atomicity::empty_item_counter>::value,
+ static_assert( !std::is_same<item_counter, atomicity::empty_item_counter>::value,
"atomicity::empty_item_counter is not allowed as a item counter");
m_Buckets = bucket_table_allocator().NewArray( bucket_count() );
- Tag - a \ref cds_intrusive_hook_tag "tag"
*/
template <class GC, typename Tag = opt::none >
- using node = cds::intrusive::single_link::node< GC, Tag > ;
+ using node = cds::intrusive::single_link::node< GC, Tag >;
/// Base hook
/**
typedef msqueue::empty_stat stat;
/// C++ memory ordering model
- /**
+ /**
Can be \p opt::v::relaxed_ordering (relaxed memory model, the default)
or \p opt::v::sequential_consistent (sequentially consisnent memory model).
*/
Example: declare \p %MSQueue with item counting and internal statistics
\code
- typedef cds::intrusive::MSQueue< cds::gc::HP, Foo,
+ typedef cds::intrusive::MSQueue< cds::gc::HP, Foo,
typename cds::intrusive::msqueue::make_traits<
cds::intrusive::opt:hook< cds::intrusive::msqueue::base_hook< cds::opt::gc<cds:gc::HP> >>,
cds::opt::item_counte< cds::atomicity::item_counter >,
typedef cds::intrusive::MSQueue< cds::gc::HP, Foo, myTraits > myQueue;
// Equivalent make_traits example:
- typedef cds::intrusive::MSQueue< cds::gc::HP, Foo,
- typename cds::intrusive::msqueue::make_traits<
+ typedef cds::intrusive::MSQueue< cds::gc::HP, Foo,
+ typename cds::intrusive::msqueue::make_traits<
cds::opt::stat< cds::intrusive::msqueue::stat<> >,
cds::opt::item_counter< cds::atomicity::item_counter >
>::type
typedef cds::atomicity::empty_item_counter item_counter;
/// C++ memory ordering model
- /**
+ /**
Can be \p opt::v::relaxed_ordering (relaxed memory model, the default)
or \p opt::v::sequential_consistent (sequentially consisnent memory model).
*/
- opt::item_counter - the type of item counting feature. Default is \p cds::atomicity::empty_item_counter (item counting disabled)
To enable item counting use \p cds::atomicity::item_counter
- opt::stat - the type to gather internal statistics.
- Possible statistics types are: \p optimistic_queue::stat, \p optimistic_queue::empty_stat,
+ Possible statistics types are: \p optimistic_queue::stat, \p optimistic_queue::empty_stat,
user-provided class that supports \p %optimistic_queue::stat interface.
Default is \p %optimistic_queue::empty_stat (internal statistics disabled).
- opt::alignment - the alignment for internal queue data. Default is \p opt::cache_line_alignment
Example: declare \p %OptimisticQueue with item counting and internal statistics
\code
- typedef cds::intrusive::OptimisticQueue< cds::gc::HP, Foo,
+ typedef cds::intrusive::OptimisticQueue< cds::gc::HP, Foo,
typename cds::intrusive::optimistic_queue::make_traits<
cds::intrusive::opt:hook< cds::intrusive::optimistic_queue::base_hook< cds::opt::gc<cds:gc::HP> >>,
cds::opt::item_counte< cds::atomicity::item_counter >,
typedef cds::intrusive::OptimisticQueue< cds::gc::HP, Foo, myTraits > myQueue;
// Equivalent make_traits example:
- typedef cds::intrusive::OptimisticQueue< cds::gc::HP, Foo,
- typename cds::intrusive::optimistic_queue::make_traits<
+ typedef cds::intrusive::OptimisticQueue< cds::gc::HP, Foo,
+ typename cds::intrusive::optimistic_queue::make_traits<
cds::opt::stat< cds::intrusive::optimistic_queue::stat<> >,
cds::opt::item_counter< cds::atomicity::item_counter >
>::type
/// Returns queue's item count
/**
- The value returned depends on \p optimistic_queue::traits::item_counter.
+ The value returned depends on \p optimistic_queue::traits::item_counter.
For \p atomicity::empty_item_counter, this function always returns 0.
@note Even if you use real item counter and it returns 0, this fact is not mean that the queue
/// SegmentedQueue internal statistics. May be used for debugging or profiling
template <typename Counter = cds::atomicity::event_counter >
- struct stat
+ struct stat
{
typedef Counter counter_type; ///< Counter type
static_assert( std::is_same<gc, typename ordered_list::gc>::value, "GC and OrderedList::gc must be the same");
// atomicity::empty_item_counter is not allowed as a item counter
- static_assert( !std::is_same<item_counter, cds::atomicity::empty_item_counter>::value,
+ static_assert( !std::is_same<item_counter, cds::atomicity::empty_item_counter>::value,
"cds::atomicity::empty_item_counter is not allowed as a item counter");
// Initialize bucket 0
dummy_node_type * pHead = get_bucket( nHash );
assert( pHead != nullptr );
- return m_Stat.onFind(
+ return m_Stat.onFind(
m_List.find_at( pHead, sv, cmp,
[&f](value_type& item, split_list::details::search_value_type<Q>& val){ f(item, val.val ); })
);
static_assert( std::is_same<gc, typename ordered_list::gc>::value, "GC and OrderedList::gc must be the same");
// atomicity::empty_item_counter is not allowed as a item counter
- static_assert( !std::is_same<item_counter, cds::atomicity::empty_item_counter>::value,
+ static_assert( !std::is_same<item_counter, cds::atomicity::empty_item_counter>::value,
"cds::atomicity::empty_item_counter is not allowed as a item counter");
// Initialize bucket 0
static_assert( std::is_same<gc, typename ordered_list::gc>::value, "GC and OrderedList::gc must be the same");
// atomicity::empty_item_counter is not allowed as a item counter
- static_assert( !std::is_same<item_counter, cds::atomicity::empty_item_counter>::value,
+ static_assert( !std::is_same<item_counter, cds::atomicity::empty_item_counter>::value,
"cds::atomicity::empty_item_counter is not allowed as a item counter");
// Initialize bucket 0
- Tag - a \ref cds_intrusive_hook_tag "tag"
*/
template <class GC, typename Tag = opt::none >
- using node = cds::intrusive::single_link::node< GC, Tag > ;
+ using node = cds::intrusive::single_link::node< GC, Tag >;
/// Base hook
/**
else
++m_PassivePopCollision;
}
- void onEliminationFailed()
+ void onEliminationFailed()
{
++m_EliminationFailed;
}
typedef cds::atomicity::empty_item_counter item_counter;
/// C++ memory ordering model
- /**
+ /**
Can be \p opt::v::relaxed_ordering (relaxed memory model, the default)
or \p opt::v::sequential_consistent (sequentially consisnent memory model).
*/
Example: declare \p %TreiberStack with elimination enabled and internal statistics
\code
- typedef cds::intrusive::TreiberStack< cds::gc::HP, Foo,
+ typedef cds::intrusive::TreiberStack< cds::gc::HP, Foo,
typename cds::intrusive::treiber_stack::make_traits<
cds::opt::enable_elimination< true >,
cds::opt::stat< cds::intrusive::treiber_stack::stat<> >
Template arguments:
- \p GC - garbage collector type: \p gc::HP, \p gc::DHP.
Garbage collecting schema must be the same as \p treiber_stack::node GC.
- - \p T - a type the stack contains. A value of type \p T must be derived
+ - \p T - a type the stack contains. A value of type \p T must be derived
from \p treiber_stack::node for \p treiber_stack::base_hook,
or it should have a member of type \p %treiber_stack::node for \p treiber_stack::member_hook,
or it should be convertible to \p %treiber_stack::node for \p treiber_stack::traits_hook.
typedef cds::intrusive::TreiberStack< cds::gc::HP, Foo, myTraits > myStack;
// Equivalent make_traits example:
- typedef cds::intrusive::TreiberStack< cds::gc::HP, Foo,
- typename cds::intrusive::treiber_stack::make_traits<
- cds::opt::stat< cds::intrusive::treiber_stack::stat<> >
+ typedef cds::intrusive::TreiberStack< cds::gc::HP, Foo,
+ typename cds::intrusive::treiber_stack::make_traits<
+ cds::opt::stat< cds::intrusive::treiber_stack::stat<> >
>::type
> myStack;
\endcode
// Stack with elimination back-off enabled
typedef ci::TreiberStack< gc,
myData,
- typename ci::treiber_stack::make_traits<
+ typename ci::treiber_stack::make_traits<
ci::opt::hook< ci::treiber_stack::base_hook< gc > >,
cds::opt::enable_elimination< true >
>::type
// ...
};
- typedef ci::TreiberStack< gc,
- myData,
- typename ci::treiber_stack::make_traits<
+ typedef ci::TreiberStack< gc,
+ myData,
+ typename ci::treiber_stack::make_traits<
ci::opt::hook< ci::treiber_stack::base_hook< gc, tag1 > >
- >::type
+ >::type
> stack1_t;
- typedef ci::TreiberStack< gc,
- myData,
+ typedef ci::TreiberStack< gc,
+ myData,
typename ci::treiber_stack::make_traits<
ci::opt::hook< ci::treiber_stack::base_hook< gc, tag2 > >
>::type
// ...
};
- typedef ci::TreiberStack< gc,
+ typedef ci::TreiberStack< gc,
myData,
typename ci::treiber_stack::make_traits<
ci::opt::hook< ci::treiber_stack::member_hook< offsetof(myData, member_hook_), gc >>
\endcode
*/
template <
- typename GC,
- typename T,
- typename Traits = treiber_stack::traits
+ typename GC,
+ typename T,
+ typename Traits = treiber_stack::traits
>
class TreiberStack
{
typedef atomicity::empty_item_counter item_counter;
/// C++ memory ordering model
- /**
+ /**
Can be \p opt::v::relaxed_ordering (relaxed memory model, the default)
or \p opt::v::sequential_consistent (sequentially consisnent memory model).
*/
Example: declare \p %TsigasCycleQueue with item counting and static iternal buffer of size 1024:
\code
- typedef cds::intrusive::TsigasCycleQueue< Foo,
+ typedef cds::intrusive::TsigasCycleQueue< Foo,
typename cds::intrusive::tsigas_queue::make_traits<
cds::opt::buffer< cds::opt::v::static_buffer< void *, 1024 >,
cds::opt::item_counte< cds::atomicity::item_counter >
typedef cds::intrusive::TsigasCycleQueue< Foo, myTraits > myQueue;
// Equivalent make_traits example:
- typedef cds::intrusive::TsigasCycleQueue< Foo,
- typename cds::intrusive::tsigas_queue::make_traits<
+ typedef cds::intrusive::TsigasCycleQueue< Foo,
+ typename cds::intrusive::tsigas_queue::make_traits<
cds::opt::item_counter< cds::atomicity::item_counter >
>::type
> myQueue;
/// Returns queue's item count
/**
- The value returned depends on \p tsigas_queue::traits::item_counter.
+ The value returned depends on \p tsigas_queue::traits::item_counter.
For \p atomicity::empty_item_counter, the function always returns 0.
*/
size_t size() const CDS_NOEXCEPT
- \p opt::buffer - the buffer type for internal cyclic array. Possible types are:
\p opt::v::dynamic_buffer (the default), \p opt::v::static_buffer. The type of
element in the buffer is not important: it will be changed via \p rebind metafunction.
- - \p opt::disposer - the functor used for dispose removed items. Default is \p opt::v::empty_disposer.
+ - \p opt::disposer - the functor used for dispose removed items. Default is \p opt::v::empty_disposer.
This option is used only in \p clear() member function.
- \p opt::item_counter - the type of item counting feature. Default is \p cds::atomicity::empty_item_counter (item counting disabled)
To enable item counting use \p cds::atomicity::item_counter
Example: declare \p %VyukovMPMCCycleQueue with item counting and static iternal buffer of size 1024:
\code
- typedef cds::intrusive::VyukovMPMCCycleQueue< Foo,
+ typedef cds::intrusive::VyukovMPMCCycleQueue< Foo,
typename cds::intrusive::vyukov_queue::make_traits<
cds::opt::buffer< cds::opt::v::static_buffer< void *, 1024 >,
cds::opt::item_counte< cds::atomicity::item_counter >
typedef cds::intrusive::VyukovMPMCCycleQueue< Foo, myTraits > myQueue;
// Equivalent make_traits example:
- typedef cds::intrusive::VyukovMPMCCycleQueue< cds::gc::HP, Foo,
- typename cds::intrusive::vykov_queue::make_traits<
+ typedef cds::intrusive::VyukovMPMCCycleQueue< cds::gc::HP, Foo,
+ typename cds::intrusive::vykov_queue::make_traits<
cds::opt::item_counter< cds::atomicity::item_counter >
>::type
> myQueue;
void fcDeque_mutex()
{
- struct deque_traits : public
+ struct deque_traits : public
cds::container::fcdeque::make_traits<
cds::opt::enable_elimination< true >
>::type
void IntrusiveLazyListHeaderTest::nogc_base_less()
{
typedef base_int_item< cds::gc::nogc > item;
- struct traits: public
+ struct traits: public
ci::lazy_list::make_traits<
ci::opt::hook< ci::lazy_list::base_hook< co::gc<cds::gc::nogc> > >
,co::less< less<item> >
void HdrTestQueue::BasketQueue_DHP_Counted_relax()
{
- typedef cds::container::BasketQueue< cds::gc::DHP, int,
+ typedef cds::container::BasketQueue< cds::gc::DHP, int,
typename cds::container::basket_queue::make_traits <
cds::opt::item_counter< cds::atomicity::item_counter >
,cds::opt::memory_model< cds::opt::v::relaxed_ordering>
void HdrTestQueue::BasketQueue_HP_Counted_relax()
{
- typedef cds::container::BasketQueue< cds::gc::HP, int,
+ typedef cds::container::BasketQueue< cds::gc::HP, int,
typename cds::container::basket_queue::make_traits <
cds::opt::item_counter< cds::atomicity::item_counter >
,cds::opt::memory_model< cds::opt::v::relaxed_ordering>
void HdrFCQueue::FCQueue_list_stat()
{
- struct queue_traits : public cds::container::fcqueue::traits
+ struct queue_traits : public cds::container::fcqueue::traits
{
typedef cds::container::fcqueue::stat<> stat;
};
typedef ci::BasketQueue< cds::gc::DHP, member_hook_item, traits_BasketQueue_member >BasketQueue_DHP_member;
/// DHP base hook + item counter
- typedef ci::BasketQueue< cds::gc::DHP, base_hook_item,
+ typedef ci::BasketQueue< cds::gc::DHP, base_hook_item,
typename ci::basket_queue::make_traits<
ci::opt::disposer< IntrusiveQueueHeaderTest::faked_disposer >
,ci::opt::hook<
typedef ci::OptimisticQueue< cds::gc::DHP, member_hook_item, traits_OptimisticQueue_DHP_member > OptimisticQueue_DHP_member;
/// DHP base hook + item counter
- typedef ci::OptimisticQueue< cds::gc::DHP, base_hook_item,
+ typedef ci::OptimisticQueue< cds::gc::DHP, base_hook_item,
typename ci::optimistic_queue::make_traits<
ci::opt::disposer< IntrusiveQueueHeaderTest::faked_disposer >
,ci::opt::hook<
> OptimisticQueue_DHP_base_ic;
// DHP member hook + item counter
- typedef ci::OptimisticQueue< cds::gc::DHP, member_hook_item,
+ typedef ci::OptimisticQueue< cds::gc::DHP, member_hook_item,
typename ci::optimistic_queue::make_traits<
cds::opt::type_traits< traits_OptimisticQueue_DHP_member >
,co::item_counter< cds::atomicity::item_counter >
typedef ci::OptimisticQueue< cds::gc::HP, member_hook_item, traits_OptimisticQueue_HP_member > OptimisticQueue_HP_member;
/// HP base hook + item counter
- typedef ci::OptimisticQueue< cds::gc::HP, base_hook_item,
+ typedef ci::OptimisticQueue< cds::gc::HP, base_hook_item,
typename ci::optimistic_queue::make_traits<
ci::opt::disposer< IntrusiveQueueHeaderTest::faked_disposer >
,ci::opt::hook<
> OptimisticQueue_HP_base_ic;
// HP member hook + item counter
- typedef ci::OptimisticQueue< cds::gc::HP, member_hook_item,
+ typedef ci::OptimisticQueue< cds::gc::HP, member_hook_item,
typename ci::optimistic_queue::make_traits<
cds::opt::type_traits< traits_OptimisticQueue_HP_member >
,co::item_counter< cds::atomicity::item_counter >
,co::item_counter< simple_item_counter >
,ci::split_list::dynamic_bucket_table<false>
>::type
- {
+ {
typedef ci::split_list::stat<> stat;
};
typedef ci::SplitListSet< cds::gc::HP, ord_list, set_traits > set;
namespace defs { namespace {
typedef cs::TreiberStack< cds::gc::DHP, int
- ,typename cs::treiber_stack::make_traits<
- cds::opt::enable_elimination<true>
+ ,typename cs::treiber_stack::make_traits<
+ cds::opt::enable_elimination<true>
>::type
> Elimination_DHP;
typedef cs::TreiberStack< cds::gc::DHP, int > Treiber_DHP;
typedef cs::TreiberStack< cds::gc::DHP, int
, typename cs::treiber_stack::make_traits<
- cds::opt::memory_model<cds::opt::v::relaxed_ordering>
+ cds::opt::memory_model<cds::opt::v::relaxed_ordering>
>::type
> Treiber_DHP_relaxed;
typedef cs::TreiberStack< cds::gc::DHP, int
, typename cs::treiber_stack::make_traits<
- cds::opt::back_off< cds::backoff::yield>
+ cds::opt::back_off< cds::backoff::yield>
>::type
> Treiber_DHP_yield;
typedef cs::TreiberStack< cds::gc::HP, int > Treiber_HP;
typedef cs::TreiberStack< cds::gc::HP, int
, typename cs::treiber_stack::make_traits<
- cds::opt::memory_model<cds::opt::v::relaxed_ordering>
+ cds::opt::memory_model<cds::opt::v::relaxed_ordering>
>::type
> Treiber_HP_relaxed;
typedef cs::TreiberStack< cds::gc::HP, int
, typename cs::treiber_stack::make_traits<
- cds::opt::back_off< cds::backoff::yield>
+ cds::opt::back_off< cds::backoff::yield>
>::type
> Treiber_HP_yield;
} // namespace std
namespace boost {
- inline size_t hash_value( map2::key_thread const& k )\r
- {\r
- return std::hash<size_t>()( k.nKey );\r
+ inline size_t hash_value( map2::key_thread const& k )
+ {
+ return std::hash<size_t>()( k.nKey );
}
template <>
struct hash<map2::key_thread>
typedef cds::intrusive::OptimisticQueue< cds::gc::DHP, T, traits_OptimisticQueue_DHP_seqcst > OptimisticQueue_DHP_seqcst;
// OptimisticQueue + item counter
- struct traits_OptimisticQueue_HP_ic: public
+ struct traits_OptimisticQueue_HP_ic: public
cds::intrusive::optimistic_queue::make_traits <
cds::intrusive::opt::hook< cds::intrusive::optimistic_queue::base_hook< cds::opt::gc< cds::gc::HP > > >
, cds::opt::item_counter< cds::atomicity::item_counter >
typedef cds::intrusive::OptimisticQueue< cds::gc::DHP, T, traits_OptimisticQueue_DHP_ic > OptimisticQueue_DHP_ic;
// OptimisticQueue + stat
- struct traits_OptimisticQueue_HP_stat: public
+ struct traits_OptimisticQueue_HP_stat: public
cds::intrusive::optimistic_queue::make_traits <
cds::intrusive::opt::hook< cds::intrusive::optimistic_queue::base_hook< cds::opt::gc< cds::gc::HP > > >
, cds::opt::stat< cds::intrusive::optimistic_queue::stat<> >
{};
typedef cds::intrusive::OptimisticQueue< cds::gc::HP, T, traits_OptimisticQueue_HP_stat > OptimisticQueue_HP_stat;
- struct traits_OptimisticQueue_DHP_stat: public
+ struct traits_OptimisticQueue_DHP_stat: public
cds::intrusive::optimistic_queue::make_traits <
cds::intrusive::opt::hook< cds::intrusive::optimistic_queue::base_hook< cds::opt::gc< cds::gc::DHP > > >
, cds::opt::stat< cds::intrusive::optimistic_queue::stat<> >
// TsigasCycleQueue
class TsigasCycleQueue_dyn
- : public cds::intrusive::TsigasCycleQueue< T,
+ : public cds::intrusive::TsigasCycleQueue< T,
typename cds::intrusive::tsigas_queue::make_traits<
cds::opt::buffer< cds::opt::v::dynamic_buffer< int > >
>::type
{};
typedef cds::intrusive::BasketQueue< cds::gc::HP, T, traits_BasketQueue_HP > BasketQueue_HP;
- struct traits_BasketQueue_HP_seqcst: public
+ struct traits_BasketQueue_HP_seqcst: public
cds::intrusive::basket_queue::make_traits <
cds::intrusive::opt::hook< cds::intrusive::basket_queue::base_hook< cds::opt::gc< cds::gc::HP > > >
, cds::opt::memory_model< cds::opt::v::sequential_consistent >
{};
typedef cds::intrusive::BasketQueue< cds::gc::DHP, T, traits_BasketQueue_DHP > BasketQueue_DHP;
- struct traits_BasketQueue_DHP_seqcst: public
+ struct traits_BasketQueue_DHP_seqcst: public
cds::intrusive::basket_queue::make_traits <
cds::intrusive::opt::hook< cds::intrusive::basket_queue::base_hook< cds::opt::gc< cds::gc::DHP > > >
, cds::opt::memory_model< cds::opt::v::sequential_consistent >
typedef cds::container::MoirQueue< cds::gc::DHP, Value, traits_MSQueue_ic > MoirQueue_DHP_ic;
// MSQueue + stat
- struct traits_MSQueue_stat: public
+ struct traits_MSQueue_stat: public
cds::container::msqueue::make_traits <
cds::opt::stat< cds::container::msqueue::stat<> >
>::type
};
typedef cds::container::RWQueue< Value, traits_RWQueue_Spin_ic > RWQueue_Spin_ic;
- struct traits_RWQueue_mutex : public
+ struct traits_RWQueue_mutex : public
cds::container::rwqueue::make_traits<
cds::opt::lock_type< std::mutex >
>::type
typedef cc::MichaelHashSet< rcu_sht, MichaelList_RCU_SHT_less_stdAlloc_seqcst, traits_MichaelSet_stdAlloc > MichaelSet_RCU_SHT_less_stdAlloc_seqcst;
#endif
- struct traits_MichaelSet_michaelAlloc :
+ struct traits_MichaelSet_michaelAlloc :
public cc::michael_set::make_traits<
co::hash< hash >,
co::allocator< memory::MichaelAllocator<int> >
typedef cds::container::TreiberStack< cds::gc::HP, T > Treiber_HP;
typedef cds::container::TreiberStack< cds::gc::DHP, T > Treiber_DHP;
- struct traits_Treiber_seqcst: public
- cds::container::treiber_stack::make_traits<
- cds::opt::memory_model<cds::opt::v::sequential_consistent>
+ struct traits_Treiber_seqcst: public
+ cds::container::treiber_stack::make_traits<
+ cds::opt::memory_model<cds::opt::v::sequential_consistent>
>::type
{};
typedef cds::container::TreiberStack< cds::gc::HP, T, traits_Treiber_seqcst > Treiber_HP_seqcst;
typedef cds::container::TreiberStack< cds::gc::HP, T, traits_Elimination_dyn_stat > Elimination_HP_dyn_stat;
typedef cds::container::TreiberStack< cds::gc::DHP, T, traits_Elimination_dyn_stat > Elimination_DHP_dyn_stat;
- struct traits_Elimination_yield: public
+ struct traits_Elimination_yield: public
cds::container::treiber_stack::make_traits <
cds::opt::enable_elimination<true>
, cds::opt::back_off<cds::backoff::yield>
typedef cds::container::TreiberStack< cds::gc::HP, T, traits_Elimination_yield > Elimination_HP_yield;
typedef cds::container::TreiberStack< cds::gc::DHP, T, traits_Elimination_yield > Elimination_DHP_yield;
- struct traits_Elimination_pause: public
+ struct traits_Elimination_pause: public
cds::container::treiber_stack::make_traits <
cds::opt::enable_elimination<true>
, cds::opt::back_off<cds::backoff::pause>
typedef cds::container::TreiberStack< cds::gc::HP, T, traits_Elimination_pause > Elimination_HP_pause;
typedef cds::container::TreiberStack< cds::gc::DHP, T, traits_Elimination_pause > Elimination_DHP_pause;
- struct traits_Elimination_exp: public
+ struct traits_Elimination_exp: public
cds::container::treiber_stack::make_traits <
cds::opt::enable_elimination<true>
,cds::opt::back_off<
projects / libcds.git / commitdiff