xenium
Class Hierarchy

Go to the graphical class hierarchy

This inheritance list is sorted roughly, but not completely, alphabetically:
 Cxenium::policy::abandon< T >Policy to configure the abandon strategy for generic_epoch_based reclamation
 Cxenium::harris_michael_hash_map< Key, Value, Policies >::accessorAn accessor to safely access the value of an element
 Cxenium::aligned_object< Derived, Alignment >A small helper class for correctly aligned dynamic allocations of over-aligned types
 Cxenium::aligned_object< basic_he_thread_control_block< Strategy, Derived > >
 Cxenium::aligned_object< basic_he_thread_control_block< Strategy, dynamic_he_thread_control_block< Strategy > > >
 Cxenium::aligned_object< basic_he_thread_control_block< Strategy, static_he_thread_control_block< Strategy > > >
 Cxenium::aligned_object< basic_hp_thread_control_block< Strategy, Derived > >
 Cxenium::aligned_object< basic_hp_thread_control_block< Strategy, dynamic_hp_thread_control_block< Strategy > > >
 Cxenium::aligned_object< basic_hp_thread_control_block< Strategy, static_hp_thread_control_block< Strategy > > >
 Cxenium::aligned_object< hazard_eras_block >
 Cxenium::aligned_object< hazard_pointer_block >
 Cxenium::aligned_object< thread_data >
 Cxenium::reclamation::scan::all_threadsScan all threads (default behaviour in EBR/NEBR)
 Cxenium::policy::allocation_strategy< T >Policy to configure the allocation strategy
 Cxenium::reclamation::abandon::alwaysAlways abandon the remaining retired nodes when the thread leaves its critical region
 Cxenium::policy::backoff< Backoff >Policy to configure the backoff strategy
 Cxenium::reclamation::bad_hazard_era_allocThis exception is thrown if a thread tries to allocate a new hazard era, but the number of available hazard eras is exhausted. This can only happen when xenium::reclamation::he_allocation::static_strategy is used
 Cxenium::reclamation::bad_hazard_pointer_allocThis exception is thrown if a thread tries to allocate a new hazard pointer, but the number of available hazard pointers is exhausted. This can only happen when xenium::reclamation::hp_allocation::static_strategy is used
 Cxenium::policy::buckets< Value >Policy to configure the number of buckets in harris_michael_hash_map
 Cxenium::policy::capacity< Value >Policy to configure the capacity of various containers
 Cxenium::chase_work_stealing_deque< T, Policies >A lock-free work stealing deque
 Cxenium::policy::compare< Backoff >Policy to configure the comparison function
 Cxenium::reclamation::detail::concurrent_ptr< T, N, GuardPtr >T must be derived from enable_concurrent_ptr<T>. D is a deleter
 Cxenium::reclamation::detail::concurrent_ptr< T, N >
 Cxenium::policy::container< Container >Policy to configure the internal container type of some data structures
 Cxenium::policy::default_to_weak< Value >Policy to configure whether try_push/try_pop in vyukov_bounded_queue should default to try_push_weak/try_pop_weak
 Cxenium::reclamation::he_allocation::dynamic_strategy< K, A, B >Hazard era allocation strategy for a dynamic number of hazard eras per thread
 Cxenium::reclamation::hp_allocation::dynamic_strategy< K, A, B >Hazard pointer allocation strategy for a dynamic number of hazard pointers per thread
 Cxenium::policy::entries_per_node< Value >Policy to configure the number of entries per allocated node in ramalhete_queue
 Cxenium::reclamation::generic_epoch_based< Traits >A generalized implementation of epoch based reclamation
 Cxenium::harris_michael_hash_map< Key, Value, Policies >A generic lock-free hash-map
 Cxenium::harris_michael_list_based_set< Key, Policies >A lock-free container that contains a sorted set of unique objects of type Key
 Cxenium::hash< Key >Slim wrapper around std::hash with specialization for pointer types
 Cxenium::policy::hash< T >Policy to configure the hash function
 Cxenium::hash< Key * >Specialized hash functor for pointer types to get rid of the alignment
 Cxenium::reclamation::hazard_eras< Traits >An implementation of the hazard eras scheme proposed by Ramalhete and Correia [RC17]
 Cxenium::reclamation::hazard_pointer< Traits >An implementation of the hazard pointers reclamation scheme as proposed by Michael [Mic04]
 Cxenium::policy::insert_padding< Value >Policy to configure whether to insert padding after the internal header for lock_free_ref_count reclamation
 Cxenium::harris_michael_hash_map< Key, Value, Policies >::iteratorA ForwardIterator to safely iterate the hash-map
 Cxenium::harris_michael_list_based_set< Key, Policies >::iteratorA ForwardIterator to safely iterate the list
 Cxenium::vyukov_hash_map< Key, Value, Policies >::iteratorA ForwardIterator to safely iterate vyukov_hash_map
 Cxenium::kirsch_bounded_kfifo_queue< T, Policies >A bounded lock-free multi-producer/multi-consumer k-FIFO queue
 Cxenium::kirsch_kfifo_queue< T, Policies >An unbounded lock-free multi-producer/multi-consumer k-FIFO queue
 Cxenium::left_right< T >Generic implementation of the LeftRight algorithm proposed by Ramalhete and Correia [RC15]
 Cxenium::reclamation::lock_free_ref_count< Traits >An implementation of the lock-free reference counting (LFRC) schemea as proposed by Valois [Val95, MS95]
 Cxenium::managed_ptr< T, Reclaimer >A helper struct to define that the lifetime of value objects of type T has to be managed by the specified reclaimer. (only supported by vyukov_hash_map)
 Cxenium::policy::map_to_bucket< T >Policy to configure the function that maps the hash value to a bucket in harris_michael_hash_map
 Cxenium::marked_ptr< T, MarkBits, MaxUpperMarkBits >A pointer with an embedded mark/tag value
 Cxenium::policy::memoize_hash< Value >Policy to configure whether the hash value should be stored and used during lookup operations in harris_michael_hash_map
 Cxenium::michael_scott_queue< T, Policies >An unbounded generic lock-free multi-producer/multi-consumer FIFO queue
 Cxenium::reclamation::scan::n_threads< N >Scan N threads
 Cxenium::reclamation::abandon::neverNever abandon any nodes (except when the thread terminates)
 Cxenium::no_backoffDummy backoff strategy that does nothing
 Cxenium::reclamation::scan::one_threadScan a single thread (default behaviour in DEBRA)
 Cxenium::policy::padding_bytes< Value >Policy to configure the number of padding bytes to add to each entry in kirsch_kfifo_queue and kirsch_bounded_kfifo_queue to reduce false sharing
 Cxenium::policy::pop_retries< Value >Policy to configure the number of iterations to spin on a queue entry while waiting for a pending push operation to finish
 Cxenium::reclamation::quiescent_state_basedQuiescent state based reclamation
 Cxenium::ramalhete_queue< T, Policies >A fast unbounded lock-free multi-producer/multi-consumer FIFO queue
 Cxenium::policy::reclaimer< Reclaimer >Policy to configure the reclamation scheme to be used
 Cxenium::policy::region_extension< Value >Policy to configure the extension of critical regions in generic_epoch_based reclamation
 Cxenium::policy::scan< T >Policy to configure the scan strategy for generic_epoch_based reclamation
 Cxenium::policy::scan_frequency< Value >Policy to configure the scan frequency for generic_epoch_based reclamation
 Cxenium::seqlock< T, Policies >An implementation of the sequence lock (also often referred to as "sequential lock")
 Cxenium::single_backoffSimple backoff strategy that always perfoms a single hardware_pause operation
 Cxenium::policy::slots< Value >Policy to configure the number of slots used in seqlock
 Cxenium::reclamation::stamp_itStamp-it
 Cxenium::reclamation::he_allocation::static_strategy< K, A, B >Hazard era allocation strategy for a static number of hazard eras per thread
 Cxenium::reclamation::hp_allocation::static_strategy< K, A, B >Hazard pointer allocation strategy for a static number of hazard pointers per thread
 Cxenium::policy::thread_local_free_list_size< Value >Policy to configure the size of thread-local free-lists for lock reclamation
 Cxenium::policy::value_reclaimer< T >Policy to configure the reclaimer used for internally alloced nodes in vyukov_hash_map
 Cxenium::vyukov_bounded_queue< T, Policies >A bounded generic multi-producer/multi-consumer FIFO queue
 Cxenium::vyukov_hash_map< Key, Value, Policies >A concurrent hash-map that uses fine-grained locking
 Cxenium::reclamation::abandon::when_exceeds_threshold< Threshold >Abandon the retired nodes upon leaving the critical region when the number of nodes exceeds the specified threshold