| amino::__list_const_iterator< T > | The const iterator of the list |
| amino::__list_iterator< T > | The iterator of the list |
| test::AASortTest | |
| amino::AbstractFuture | This is a base class for other Future implementations |
| test::Accumulate | |
| anchor | |
| atomic_address | |
| atomic_bool | |
| atomic_char | |
| atomic_flag | |
| atomic_int | |
| atomic_llong | |
| atomic_long | |
| atomic_schar | |
| atomic_short | |
| atomic_uchar | |
| atomic_uint | |
| atomic_ullong | |
| atomic_ulong | |
| atomic_ushort | |
| AtomicNumTest< ParaType, CLASS_NAME > | This test case covers mathematic operation of atomic numbers types |
| AtomicTest< ParaType > | This test case tests general functionality for all atomic types |
| BaseTest< DataType > | |
| test::BDequeTest< DequeType, ParaType, CLASS_NAME > | |
| test::BinaryFunc< ParaType > | |
| amino::BlockingDeque< T > | |
| test::CallExecutor< Executor > | |
| amino::CallStdAccumulate< iteratorT, T > | |
| amino::CallStdAccumulate_Func< iteratorT, T, FuncT > | |
| amino::CallStdForEach< iteratorT, FuncT > | |
| amino::CallStdTransformBinary< InputIterator1, InputIterator2, OutputIterator, BinaryFunction > | |
| amino::CallStdTransformUnary< InputIterator, OutputIterator, UnaryFunction > | |
| checkpoint_entry | |
| test::ConcurrentRunner | |
| amino::condition_variable | |
| test::ConditionTest | |
| test::ConditionThread | |
| controlblock_t | |
| amino::Counter< Num_Type, copier_num > | |
| test::CounterTest< CounterType, ParaType, CLASS_NAME > | |
| test::DequeTest< DequeType, ParaType, CLASS_NAME > | |
| desc | |
| test::DictionaryTest< DictType, ParaType, CLASS_NAME > | |
| amino::DictNode< K, V > | |
| test::DoNothing | |
| dw | |
| amino::EBStack< T > | This a implementation of ebstack.. |
| amino::ExecutorService | This class is intended to be inherited by executors |
| test::ExecutorTest< Executor > | |
| amino::FindStateHolder< KeyType > | State holder, which stores the pointer of the current node and the pointers of the current node's previous and next in it |
| foo | |
| amino::Future | This class reprensents a return value from Runnable object |
| amino::FutureTask | |
| test::FutureTest< Executor > | |
| hprec | |
| internal::HPRecType< T, K > | This is the class to store hazard point |
| IntConsumer | |
| IntProducer | |
| test::IteratorTest< ListType, ParaType, CLASS_NAME > | |
| job | |
| amino::List< KeyType > | This is an implementation of a lock-free linked list data structure. The implementation is according to the paper High Performance Dynamic Lock-Free Hash Tables and List-Based Sets by Maged M. Michael, 2002. To gain a complete understanding of this data structure, please first read this paper, available at: http://www.research.ibm.com/people/m/michael/spaa-2002.pdf |
| test::ListTest< ListType, ParaType, CLASS_NAME > | |
| amino::LockFreeDictionary< K, V > | |
| amino::LockFreePriorityQueue< E > | |
| amino::LockFreeQueue< T > | This queue implementation is based on the algorithm defined in the follwoing paper: Simple, fast, and practical non-blocking and blocking concurrent queue algorithms by Michael, M. M. and Scott, M. L. 1996. PODC96 ABA prevention: Maged M. Michael's SMR way The following paper pointed out that Maged Michael's queue doesn't scale well. Moir, M., Nussbaum, D., Shalev, O., and Shavit, N. 2005. Using elimination to implement scalable and lock-free FIFO queues. In Proceedings of the Seventeenth Annual ACM Symposium on Parallelism in Algorithms and Architectures (Las Vegas, Nevada, USA, July 18 - 20, 2005). SPAA '05. ACM Press, New York, NY, 253-262 |
| amino::LockFreeStack< T > | This is a lock-free stack, based on: IBM, IBM System/370 Extended Architecture, Principles of Operation, 1983 ABA prevention method is based on Maged M. Michael's: Hazard Pointers: Safe Memory Reclamation for Lock-Free Objects |
| amino::LockFreeStack< T >::StackNode | The node type, which stores the data and a next pointer in it |
| test::LockTest | |
| test::LockThread | |
| test::Logger | |
| lran2_st | |
| MathThreadFactory< ParaType, CLASS_NAME > | |
| amino::MergerTask< _merger, rand_access_iter > | This class represents a merge task which can be executed by an executor. The two merger area must be consecutive |
| meta_entry | |
| amino::mutex | |
| test::MutexTest | |
| test::MutexThread | |
| node | |
| amino::NodeType< KeyType > | The node type, which stores the data and a next pointer in it |
| amino::OrderedList< KeyType > | This is a lock-free list, based on: |
| orec | |
| test::ParallelSortTest< ParaType, CLASS_NAME > | |
| test::PatternTest< ElementT, CLASS_NAME > | |
| amino::PQNode< E > | |
| test::PQueueTest< QueueType, ParaType, CLASS_NAME > | |
| procheap | |
| test::PushThread< DequeType, ParaType, CLASS_NAME > | |
| test::QueueTest< QueueType, ParaType, CLASS_NAME > | |
| test::RandArrayGenerator< DataType > | |
| test::RandArrayGenerator< DataType * > | |
| read_entry | |
| amino::recursive_mutex | |
| test::RecursiveLockThread | |
| test::RecursiveMutexThread | |
| amino::Runnable | |
| amino::Set< KeyType > | This is an implementation of lock-free hash set data structure, based on algorithm described in two paper "Split-Ordered Lists - Lock-free Resizable Hash Tables" by Ori Shalev Tel Aviv University and Nir Shavit Tel-Aviv University and Sun Microsystems Laboratories "High Performance Dynamic Lock-Free Hash Tables and List-Based Set" by Maged M. Michael |
| amino::SetNode< KeyType > | The node type of the lock-free set, which stores the element and its hash key in it |
| test::SetTest< SetType, ParaType, CLASS_NAME > | |
| amino::ShavitQueue< T > | This is an implementation of a lock-free FIFO queue data structure. The implementation is according to the paper An Optimistic Approach to Lock-Free FIFO Queues by Edya Ladan-Mozes and Nir Shavit, 2004. To gain a complete understanding of this data structure, please first read this paper, available at: http://www.springerlink.com/content/h84dfexjftdal4p4/ |
| amino::SingleExecutor | An executor which executes task immediately in current thread |
| sizeclass | |
| internal::SMR< T, K > | SMR way to prevent ABA for lock-free data structrue based on the following paper: |
| internal::SMRListNode< T > | This class can represents a node inside retired list of SMR, and a node inside the hazard pointer list |
| internal::SMRThreadLocal< T > | |
| amino::SortTask< _sort, rand_access_iter > | This class represents a sort task which can be executed by an executor |
| amino::StackNode< T > | The node type, which stores the data and a next pointer in it |
| test::StackTest< TestType, ParaType, CLASS_NAME > | |
| amino::SyncList< T, Sequence > | This is a implementation of lock based list. It is simply added lock before every operation of ordinary list(such as the std::list<T>) |
| test::TakeThread< DequeType, ParaType, CLASS_NAME > | |
| Temp | |
| test::TestConfig | |
| test::TestThread< ParaType > | |
| thr_st | |
| amino::Thread | |
| test::Thread4Dir< DequeType, ParaType, CLASS_NAME > | |
| test::Thread4DirFactory< DequeType, ParaType, CLASS_NAME > | |
| thread_data | |
| test::ThreadDeleteKey< DictType, ParaType, CLASS_NAME > | |
| test::ThreadDeleteKeyFactory< DictType, ParaType, CLASS_NAME > | |
| test::ThreadDeleteValue< DictType, ParaType, CLASS_NAME > | |
| test::ThreadDeleteValueFactory< DictType, ParaType, CLASS_NAME > | |
| test::ThreadDequeue< QueueType, ParaType, CLASS_NAME > | |
| test::ThreadDequeueFactory< QueueType, ParaType, CLASS_NAME > | |
| test::ThreadEnDequeueFactory< QueueType, ParaType, CLASS_NAME > | |
| test::ThreadEnqueue< QueueType, ParaType, CLASS_NAME > | |
| test::ThreadEnqueueFactory< QueueType, ParaType, CLASS_NAME > | |
| test::ThreadFactory< ParaType > | |
| test::ThreadFindKey< DictType, ParaType, CLASS_NAME > | |
| test::ThreadFindKeyFactory< DictType, ParaType, CLASS_NAME > | |
| test::ThreadFindValue< DictType, ParaType, CLASS_NAME > | |
| test::ThreadFindValueFactory< DictType, ParaType, CLASS_NAME > | |
| test::ThreadInsert< DictType, ParaType, CLASS_NAME > | |
| test::ThreadInsertFactory< DictType, ParaType, CLASS_NAME > | |
| test::ThreadInsertRemoveFactory< DictType, ParaType, CLASS_NAME > | |
| ThreadMath< ParaType, CLASS_NAME > | |
| amino::ThreadPoolExecutor | An executor which pools a fix number of threads. Different tasks can reuse threads among each execution |
| test::ThreadPop< TestType, ParaType, CLASS_NAME > | |
| test::ThreadPopFactory< TestType, ParaType, CLASS_NAME > | |
| test::ThreadPush< TestType, ParaType, CLASS_NAME > | |
| test::ThreadPush_front< ListType, ParaType, CLASS_NAME > | |
| test::ThreadPush_frontFactory< ListType, ParaType, CLASS_NAME > | |
| test::ThreadPushFactory< TestType, ParaType, CLASS_NAME > | |
| test::ThreadPushPopPairFactory< TestType, ParaType, CLASS_NAME > | |
| test::ThreadPushRight< DequeType, ParaType, CLASS_NAME > | |
| test::ThreadPushRightFactory< DequeType, ParaType, CLASS_NAME > | |
| test::ThreadRemove< ListType, ParaType, CLASS_NAME > | |
| test::ThreadRemoveFactory< ListType, ParaType, CLASS_NAME > | |
| test::ThreadRunner | |
| test::UnaryFunc< ParaType > | |
| amino::unique_lock< Mutex > | |
| value | |
| amino::Value< E > | |
| test::Wait6S | |
| write_entry | |
| amino::ws_scheduler< TaskType > | A work stealing scheduler which store pointers to TaskType |
