| GaloisRuntime::WorkList::AbstractWorkList< T, concurrent > | |
| Galois::ParallelSTL::accumulate_helper< T, BinOp > | |
| Galois::ParallelSTL::accumulate_helper_reduce< BinOp > | |
| GaloisRuntime::MM::AddHeader< Header, SourceHeap > | Add a header to objects |
| llvm::cl::alias | |
| llvm::cl::aliasopt | |
| llvm::AlignmentCalcImpl< T > | |
| llvm::AlignOf< T > | AlignOf - A templated class that contains an enum value representing the alignment of the template argument |
| Galois::Graph::LC_Numa_Graph< NodeTy, EdgeTy >::AllocateEdges | |
| Galois::Graph::LC_Numa_Graph< NodeTy, EdgeTy >::AllocateNodes | |
| GaloisRuntime::AlwaysLockObj | |
| llvm::APFloat | |
| llvm::APInt | APInt - This class represents arbitrary precision constant integral values |
| llvm::cl::applicator< Mod > | |
| llvm::cl::applicator< char[n]> | |
| llvm::cl::applicator< const char * > | |
| llvm::cl::applicator< const char[n]> | |
| llvm::cl::applicator< FormattingFlags > | |
| llvm::cl::applicator< MiscFlags > | |
| llvm::cl::applicator< NumOccurrencesFlag > | |
| llvm::cl::applicator< OptionHidden > | |
| llvm::cl::applicator< ValueExpected > | |
| GaloisRuntime::LCorderedExec< OperFunc, NhoodFunc, Ctxt, SourceTest >::ApplyOperator | |
| llvm::APSInt | |
| llvm::ArrayRef< T > | ArrayRef - Represent a constant reference to an array (0 or more elements consecutively in memory), i.e |
| GaloisRuntime::AtLoopExit | |
| GaloisRuntime::WorkList::AtomicChunkDequeue | |
| GaloisRuntime::WorkList::AtomicChunkLIFO | |
| anonymous_namespace{TID.cpp}::AtomicNextId | |
| Galois::Bag< T, blockSize > | Bag for serial use |
| llvm::cl::basic_parser< DataType > | |
| llvm::cl::basic_parser_impl | |
| llvm::cl::bits< DataType, Storage, ParserClass > | |
| llvm::cl::bits_storage< DataType, StorageClass > | |
| llvm::cl::bits_storage< DataType, bool > | |
| Galois::gslist< T, ChunkSize >::Block | |
| GaloisRuntime::MM::BlockAlloc< ElemSize, SourceHeap >::Block | |
| GaloisRuntime::MM::SimpleBumpPtrWithMallocFallback< SourceHeap >::Block | |
| GaloisRuntime::MM::SimpleBumpPtr< SourceHeap >::Block | |
| Galois::gdeque< T, CHUNK_SIZE >::Block | |
| GaloisRuntime::MM::BlockAlloc< ElemSize, SourceHeap >::Block_basic | |
| GaloisRuntime::MM::BlockAlloc< ElemSize, SourceHeap > | |
| Galois::Graph::SpatialTree2d< T >::Box2d | |
| GaloisRuntime::DeterministicImpl::BreakManager< FunctionTy, Enable > | |
| GaloisRuntime::DeterministicImpl::BreakManager< FunctionTy, typename boost::enable_if< has_break_fn< FunctionTy > >::type > | |
| GaloisRuntime::WorkList::BulkSynchronous< ContainerTy, T, concurrent > | |
| llvm::BumpPtrAllocator | BumpPtrAllocator - This allocator is useful for containers that need very simple memory allocation strategies |
| Galois::TwoLevelIteratorImpl::ByCategory< Outer, Inner, InnerBegFn, InnerEndFn, Cat > | |
| Galois::TwoLevelIteratorImpl::ByCategory< Outer, Inner, InnerBegFn, InnerEndFn, std::bidirectional_iterator_tag > | |
| Galois::TwoLevelIteratorImpl::ByCategory< Outer, Inner, InnerBegFn, InnerEndFn, std::forward_iterator_tag > | |
| Galois::TwoLevelIteratorImpl::ByCategory< Outer, Inner, InnerBegFn, InnerEndFn, std::random_access_iterator_tag > | |
| GaloisRuntime::LL::CacheLineImp< T, REM > | |
| GaloisRuntime::LL::CacheLineImp< T, 0 > | |
| GaloisRuntime::LL::CacheLineStorage< T > | |
| GaloisRuntime::CheckedLockObj | |
| llvm::Twine::Child | |
| Galois::TwoLevelIteratorImpl::ChooseStlIter< C, I, StlIterKind > | |
| Galois::TwoLevelIteratorImpl::ChooseStlIter< C, I, CONST > | |
| Galois::TwoLevelIteratorImpl::ChooseStlIter< C, I, CONST_REVERSE > | |
| Galois::TwoLevelIteratorImpl::ChooseStlIter< C, I, NORMAL > | |
| Galois::TwoLevelIteratorImpl::ChooseStlIter< C, I, REVERSE > | |
| Galois::ChooseStlTwoLevelIterator< Outer, Inner > | Type function to select appropriate two-level iterator |
| Galois::TwoLevelIteratorImpl::ChooseStlTwoLevelIterImpl< Outer, Inner > | |
| Galois::ChooseTwoLevelIterator< Outer, Inner, InnerBegFn, InnerEndFn > | Type function to select appropriate two-level iterator |
| GaloisRuntime::WorkList::ChunkedMaster< T, QT, distributed, isStack, chunksize, concurrent >::Chunk | |
| GaloisRuntime::WorkList::ChunkedAdaptor< separateBuffering, chunksize, gWL, T >::Chunk | |
| GaloisRuntime::WorkList::OwnerComputeChunkedMaster< T, OwnerFn, QT, distributed, isStack, chunksize, concurrent >::Chunk | |
| GaloisRuntime::WorkList::ChunkedAdaptor< separateBuffering, chunksize, gWL, T > | |
| GaloisRuntime::WorkList::ChunkedFIFO< chunksize, T, concurrent > | |
| GaloisRuntime::WorkList::ChunkedLIFO< chunksize, T, concurrent > | |
| GaloisRuntime::WorkList::ChunkedMaster< T, QT, distributed, isStack, chunksize, concurrent > | |
| GaloisRuntime::WorkList::ChunkHeader | |
| GaloisRuntime::LCorderedContext< T, Cmp, NhoodMgr_tp >::Comparator | |
| GaloisRuntime::DeterministicImpl::DMergeManager< OptionsTy, typename boost::enable_if< MergeTraits< OptionsTy > >::type >::CompareNewItems | |
| Galois::Graph::CompareNodeData< Graph > | |
| llvm::conditional< bool, T, F > | |
| llvm::conditional< false, T, F > | |
| GaloisRuntime::WorkList::ConExtIterator< T > | |
| GaloisRuntime::WorkList::ConExtLinkedQueue< T, concurrent > | |
| GaloisRuntime::WorkList::ConExtLinkedStack< T, concurrent > | |
| GaloisRuntime::WorkList::ConExtListNode< T > | |
| GaloisRuntime::ContextPool< Context > | |
| Galois::Graph::FileGraph::Convert32 | |
| Galois::Graph::FileGraph::Convert64 | |
| Galois::ParallelSTL::count_if_helper< Predicate > | |
| Galois::ParallelSTL::count_if_reducer | |
| GaloisRuntime::LCorderedExec< OperFunc, NhoodFunc, Ctxt, SourceTest >::CreateCtxtExpandNhood | |
| GaloisRuntime::WorkList::dChunkedFIFO< chunksize, T, concurrent > | |
| GaloisRuntime::WorkList::dChunkedLIFO< chunksize, T, concurrent > | |
| decimalInfo | |
| GaloisRuntime::LCorderedExec< OperFunc, NhoodFunc, Ctxt, SourceTest >::DelCtxt | |
| llvm::DenseMapInfo< T > | |
| llvm::DenseMapInfo< char > | |
| llvm::DenseMapInfo< int > | |
| llvm::DenseMapInfo< long > | |
| llvm::DenseMapInfo< long long > | |
| llvm::DenseMapInfo< std::pair< T, U > > | |
| llvm::DenseMapInfo< T * > | |
| llvm::DenseMapInfo< unsigned > | |
| llvm::DenseMapInfo< unsigned long > | |
| llvm::DenseMapInfo< unsigned long long > | |
| llvm::cl::desc | |
| GaloisRuntime::DeterministicImpl::DeterministicContext< T, CompareTy > | |
| Galois::Graph::LC_Numa_Graph< NodeTy, EdgeTy >::DistributeInfo | |
| GaloisRuntime::DeterministicImpl::DItem< T > | |
| GaloisRuntime::DeterministicImpl::DMergeLocal< OptionsTy > | Thread-local data for merging and implementations specialized for ordered and unordered implementations |
| GaloisRuntime::DeterministicImpl::DMergeManager< OptionsTy, Enable > | Default implementation for merging |
| GaloisRuntime::DeterministicImpl::DMergeManager< OptionsTy, typename boost::enable_if< MergeTraits< OptionsTy > >::type > | Implementation of merging specialized for unordered algorithms with an id function and ordered algorithms |
| GaloisRuntime::DeterministicImpl::DMergeManagerBase< OptionsTy > | |
| GaloisRuntime::DeterministicImpl::DNewItem< T > | |
| GaloisRuntime::DoAllWork< FunctionTy, ReduceFunTy, RangeTy, useStealing > | |
| Galois::does_not_need_aborts< T > | Indicates the operator doesn't need abort support |
| Galois::does_not_need_push< T > | Indicates the operator does not generate new work and push it on the worklist |
| Galois::does_not_need_stats< T > | Indicates the operator doesn't need its execution stats recorded |
| GaloisRuntime::DeterministicImpl::UnorderedOptions< _T, _Function1Ty, _Function2Ty >::DummyCompareTy | |
| GaloisRuntime::DeterministicImpl::MergeTraits< OptionsTy, typename boost::enable_if_c< OptionsTy::useOrdered >::type >::DummyIdFn | |
| GaloisRuntime::WorkList::DummyIndexer< T > | |
| Galois::AtomicImpl::DummyWrapper< T > | |
| Galois::Graph::GraphImpl::EdgeFactory< ETy > | |
| Galois::Graph::GraphImpl::EdgeFactory< void > | |
| Galois::Graph::LCGraphImpl::EdgeInfoBase< NodeInfoTy, EdgeTy > | |
| Galois::Graph::GraphImpl::EdgeItem< NTy, ETy, false > | |
| Galois::Graph::GraphImpl::EdgeItem< NTy, ETy, true > | |
| Galois::Graph::GraphImpl::EdgeItem< NTy, void, false > | |
| Galois::Graph::GraphImpl::EdgeItem< NTy, void, true > | |
| Galois::Graph::LC_CSR_Graph< NodeTy, EdgeTy >::EdgeReference | Proxy object to facilitate sorting |
| Galois::Graph::LCGraphImpl::EdgeSortCompWrapper< EdgeContainerTy, CompTy > | |
| Galois::Graph::LC_CSR_Graph< NodeTy, EdgeTy >::EdgeSortIterator | Iterator to facilitate sorting |
| Galois::Graph::LC_CSR_Graph< NodeTy, EdgeTy >::EdgeValue | |
| GaloisRuntime::EmptyFn | |
| llvm::enable_if< Cond, T > | |
| llvm::enable_if_c< Cond, T > | |
| llvm::enable_if_c< false, T > | |
| GaloisRuntime::DeterministicImpl::Executor< OptionsTy > | |
| GaloisRuntime::MM::ExternRefGaloisAllocator< Ty, AllocTy > | |
| GaloisRuntime::MM::ExternRefGaloisAllocator< void, AllocTy > | |
| llvm::cl::extrahelp | |
| GaloisRuntime::FastBarrier | Busy waiting barrier biased towards getting master thread out as soon as possible |
| GaloisRuntime::FasterBarrier | |
| GaloisRuntime::WorkList::FIFO< T, concurrent > | |
| GaloisRuntime::DeterministicImpl::FIFO< chunksize, T > | Wrapper around WorkList::ChunkedFIFO to allow peek() and empty() and still have FIFO order |
| Galois::Graph::FileGraph | Graph serialized to a file |
| Galois::Graph::FileGraphParser | Simplifies parsing graphs from files |
| Galois::ParallelSTL::find_if_helper< InputIterator, Predicate > | |
| GaloisRuntime::LCorderedExec< OperFunc, NhoodFunc, Ctxt, SourceTest >::FindInitSources | |
| Galois::Graph::FirstGraph< NodeTy, EdgeTy, Directional >::first_eq_and_valid< T > | |
| Galois::Graph::FirstGraph< NodeTy, EdgeTy, Directional >::first_not_valid | |
| Galois::Graph::FirstGraph< NodeTy, EdgeTy, Directional > | A Graph |
| GaloisRuntime::MM::FixedSizeAllocator | |
| Galois::FixedSizeRing< T, chunksize > | Ordered collection of bounded size |
| llvm::fltSemantics | |
| GaloisRuntime::ForEachTraits< FunctionTy > | |
| GaloisRuntime::ForEachWork< WorkListTy, T, FunctionTy > | |
| GaloisRuntime::MM::FreeListHeap< SourceHeap > | Maintain a freelist |
| GaloisRuntime::MM::FreeListHeap< SourceHeap >::FreeNode | |
| GaloisRuntime::MM::SelfLockFreeListHeap< SourceHeap >::FreeNode | |
| anonymous_namespace{PageAlloc.cpp}::FreeNode | |
| GaloisRuntime::MM::FSBGaloisAllocator< Ty > | |
| GaloisRuntime::MM::FSBGaloisAllocator< void > | |
| Galois::GAccumulator< T > | Accumulator for T where accumulation is sum |
| GaloisRuntime::galois_insert_bag< T > | |
| Galois::GAtomic< T > | An atomic wrapper that provides sensible atomic behavior for most primative data types |
| Galois::AtomicImpl::GAtomicBase< T, W > | Basic atomic |
| Galois::AtomicImpl::GAtomicBase< bool, W > | Specialization for bools |
| Galois::AtomicImpl::GAtomicBase< const T *, W > | Specialization for const pointers |
| Galois::AtomicImpl::GAtomicBase< T *, W > | Specialization for pointers |
| Galois::AtomicImpl::GAtomicImpl< T, W > | Common implementation |
| Galois::GAtomicPadded< T > | Cache-line padded version of GAtomic |
| Galois::GChecked< T > | Conflict-checking wrapper for any type |
| Galois::GChecked< void > | |
| Galois::GCollectionAccumulator< CollectionTy, AdaptorTy > | General accumulator for collections following STL interface where accumulate means collection union |
| Galois::gdeque< T, CHUNK_SIZE > | Like std::deque but use Galois memory management functionality |
| llvm::cl::generic_parser_base | |
| llvm::cl::generic_parser_base::GenericOptionInfo | |
| llvm::cl::GenericOptionValue | |
| Galois::TwoLevelIteratorImpl::GetBegin< C > | |
| Galois::TwoLevelIteratorImpl::GetCbegin< C > | |
| Galois::TwoLevelIteratorImpl::GetCend< C > | |
| Galois::TwoLevelIteratorImpl::GetCRbegin< C > | |
| Galois::TwoLevelIteratorImpl::GetCRend< C > | |
| Galois::TwoLevelIteratorImpl::GetEnd< C > | |
| GaloisRuntime::DeterministicImpl::DNewItem< T >::GetFirst | |
| GaloisRuntime::DeterministicImpl::DMergeManager< OptionsTy, Enable >::GetNewItem | |
| Galois::TwoLevelIteratorImpl::GetRbegin< C > | |
| Galois::TwoLevelIteratorImpl::GetRend< C > | |
| Galois::TwoLevelIteratorImpl::GetStlIterKind< C, I > | |
| GaloisRuntime::WorkList::GFIFO< T, concurrent > | |
| Galois::GFixedAllocator< Ty > | Scalable fixed-sized allocator for T that conforms to STL allocator interface but does not support variable sized allocations |
| Galois::GMapElementAccumulator< MapTy > | Accumulator for map where accumulate does element-wise addition among all entries |
| Galois::gmax< T > | Operator form of max |
| Galois::gmin< T > | Operator form of min |
| Galois::Graph::FirstGraph< NodeTy, EdgeTy, Directional >::gNode | |
| Galois::Graph::LC_FileGraph< NodeTy, EdgeTy >::gNode | |
| Galois::Graph::LC_FileGraph< void, EdgeTy >::gNode | |
| Galois::Graph::LC_FileGraph< NodeTy, void >::gNode | |
| Galois::GReduceMax< T > | Accumulator for T where accumulation is max |
| Galois::GReduceMin< T > | Accumulator for T where accumulation is min |
| Galois::GReducible< T, BinFunc > | GReducible stores per thread values of a variable of type T |
| Galois::GSetAccumulator< SetTy > | Accumulator for set where accumulation is union |
| Galois::GSimpleReducible< T, BinFunc > | Simplification of GReducible where BinFunc calculates results by value, i.e., BinFunc conforms to: |
| Galois::gslist< T, ChunkSize > | Singly linked list |
| Galois::GVectorAccumulator< VectorTy > | Accumulator for vector where accumulation is concatenation |
| Galois::GVectorElementAccumulator< VectorTy > | Accumulator for vector where a vector is treated as a map and accumulate does element-wise addition among all entries |
| GaloisRuntime::HIDDEN::H_CONSTANT | |
| GaloisRuntime::HIDDEN::H_PERCPU | |
| GaloisRuntime::HIDDEN::H_PERPACKAGE | |
| GaloisRuntime::DeterministicImpl::has_break_fn< T > | |
| Galois::has_fixed_neighborhood< T > | Indicates that the neighborhood set does not change through out i.e |
| GaloisRuntime::DeterministicImpl::has_id_fn< T > | |
| GaloisRuntime::DeterministicImpl::has_local_state< T > | Some template meta programming |
| Galois::Bag< T, blockSize >::Header | |
| GaloisRuntime::galois_insert_bag< T >::header | |
| Galois::Graph::LC_Numa_Graph< NodeTy, EdgeTy >::Header | |
| GaloisRuntime::DeterministicImpl::DMergeLocal< OptionsTy >::HeapCompare | |
| anonymous_namespace{CommandLine.cpp}::HelpPrinter | |
| llvm::ilist< NodeTy > | |
| llvm::ilist_default_traits< NodeTy > | Ilist_default_traits - Default template traits for intrusive list |
| llvm::ilist_half_node< NodeTy > | Ilist_half_node - Base class that provides prev services for sentinels |
| llvm::ilist_iterator< NodeTy > | |
| llvm::ilist_nextprev_traits< NodeTy > | Ilist_nextprev_traits - A fragment for template traits for intrusive list that provides default next/prev implementations for common operations |
| llvm::ilist_node< NodeTy > | Ilist_node - Base class that provides next/prev services for nodes that use ilist_nextprev_traits or ilist_default_traits |
| llvm::ilist_node_traits< NodeTy > | Ilist_node_traits - A fragment for template traits for intrusive list that provides default node related operations |
| llvm::ilist_sentinel_traits< NodeTy > | Ilist_sentinel_traits - A fragment for template traits for intrusive list that provides default sentinel implementations for common operations |
| llvm::ilist_traits< NodeTy > | |
| llvm::ilist_traits< const Ty > | |
| llvm::ilist_traits< RecyclerStruct > | |
| llvm::cl::initializer< Ty > | |
| GaloisRuntime::Initializer< RangeTy, WorkTy > | |
| Galois::InsertBag< T > | Bag for only concurrent insertions |
| llvm::iplist< NodeTy, Traits > | Iplist - The subset of list functionality that can safely be used on nodes of polymorphic types, i.e |
| llvm::is_base_of< Base, Derived > | Is_base_of - Metafunction to determine whether one type is a base class of (or identical to) another type |
| llvm::is_class< T > | |
| Galois::Graph::FirstGraph< NodeTy, EdgeTy, Directional >::is_edge | |
| Galois::Graph::FirstGraph< NodeTy, EdgeTy, Directional >::is_node | |
| llvm::is_same< T, U > | Metafunction that determines whether the two given types are equivalent |
| llvm::is_same< T, T > | |
| Galois::TwoLevelIteratorImpl::IsConstIter< C, I > | |
| Galois::TwoLevelIteratorImpl::IsConstIter< C, typename C::const_iterator > | |
| llvm::isPodLike< T > | IsPodLike - This is a type trait that is used to determine whether a given type can be copied around with memcpy instead of running ctors etc |
| llvm::isPodLike< ArrayRef< T > > | |
| llvm::isPodLike< std::pair< T, U > > | |
| llvm::isPodLike< StringRef > | |
| Galois::TwoLevelIteratorImpl::IsRvrsConstIter< C, I > | |
| Galois::TwoLevelIteratorImpl::IsRvrsConstIter< C, typename C::const_reverse_iterator > | |
| Galois::TwoLevelIteratorImpl::IsRvrsIter< C, I > | |
| Galois::TwoLevelIteratorImpl::IsRvrsIter< C, typename C::reverse_iterator > | |
| llvm::StringMapImpl::ItemBucket | ItemBucket - The hash table consists of an array of these |
| Galois::Bag< T, blockSize >::iterator | |
| Galois::Graph::LC_CSRInline_Graph< NodeTy, EdgeTy >::iterator | |
| GaloisRuntime::galois_insert_bag< T >::iterator | |
| Galois::gdeque< T, CHUNK_SIZE >::iterator | |
| Galois::FixedSizeRing< T, chunksize >::Iterator< U, isForward > | |
| Galois::gslist< T, ChunkSize >::iterator | |
| Galois::LargeArray< T, isLazy > | Large array of objects with proper specialization for void type |
| Galois::LargeArray< void, isLazy > | Void specialization |
| Galois::LazyArray< _Tp, _Size > | This is a container that encapsulates space for a constant size array |
| Galois::LazyObject< T > | Single (uninitialized) object with specialization for void type |
| Galois::LazyObject< void > | |
| Galois::Graph::LC_CSR_Graph< NodeTy, EdgeTy > | Local computation graph (i.e., graph structure does not change) |
| Galois::Graph::LC_CSRInline_Graph< NodeTy, EdgeTy > | Local computation graph (i.e., graph structure does not change) |
| Galois::Graph::LC_FileGraph< NodeTy, EdgeTy > | Local computation graph (i.e., graph structure does not change) THIS GRAPH SHOULD GO AWAY |
| Galois::Graph::LC_FileGraph< NodeTy, void > | |
| Galois::Graph::LC_FileGraph< void, EdgeTy > | Local computation graph (i.e., graph structure does not change) |
| Galois::Graph::LC_FileGraph< void, void > | |
| Galois::Graph::LC_Linear_Graph< NodeTy, EdgeTy > | Local computation graph (i.e., graph structure does not change) |
| Galois::Graph::LC_Numa_Graph< NodeTy, EdgeTy > | Local computation graph (i.e., graph structure does not change) Specialization of LC_Linear_Graph for NUMA architectures |
| GaloisRuntime::LCorderedContext< T, Cmp, NhoodMgr_tp > | |
| GaloisRuntime::LCorderedExec< OperFunc, NhoodFunc, Ctxt, SourceTest > | |
| GaloisRuntime::WorkList::LIFO< T, concurrent > | |
| llvm::cl::list< DataType, Storage, ParserClass > | |
| llvm::cl::list_storage< DataType, StorageClass > | |
| llvm::cl::list_storage< DataType, bool > | |
| GaloisRuntime::WorkList::ConExtLinkedQueue< T, concurrent >::ListNode | |
| GaloisRuntime::WorkList::LoadBalanceTracker< realWL, perEpoch > | |
| Galois::Graph::LC_Numa_Graph< NodeTy, EdgeTy >::local_iterator | |
| GaloisRuntime::WorkList::LocalQueues< GlobalQueueTy, LocalQueueTy, T > | |
| GaloisRuntime::LocalRange< T > | |
| anonymous_namespace{Termination.cpp}::LocalTerminationDetection | |
| GaloisRuntime::WorkList::LocalWorklist< WLTy, T > | |
| llvm::cl::LocationClass< Ty > | |
| GaloisRuntime::Lockable | All objects that may be locked (nodes primarily) must inherit from Lockable |
| GaloisRuntime::MM::LockedHeap< RealHeap > | Apply a lock to a heap |
| GaloisRuntime::LoopStatistics< Enabled > | |
| GaloisRuntime::LoopStatistics< false > | |
| Galois::Graph::FirstGraph< NodeTy, EdgeTy, Directional >::makeGraphNode | |
| llvm::MallocAllocator | |
| llvm::MallocSlabAllocator | MallocSlabAllocator - The default slab allocator for the bump allocator is an adapter class for MallocAllocator that just forwards the method calls and translates the arguments |
| Galois::ParallelSTL::map_reduce_helper< T, MapFn, ReduceFn > | |
| GaloisRuntime::MapBasedNhoodMgr< T, Cmp > | |
| GaloisRuntime::MCSBarrier | |
| llvm::sys::Memory | This class provides various memory handling functions that manipulate MemoryBlock instances |
| llvm::sys::MemoryBlock | This class encapsulates the notion of a memory block which has an address and a size |
| llvm::MemSlab | MemSlab - This structure lives at the beginning of every slab allocated by the bump allocator |
| Galois::MergeBag< T > | Like InsertBag but with random access iterators |
| GaloisRuntime::DeterministicImpl::MergeTraits< OptionsTy, Enable > | |
| GaloisRuntime::DeterministicImpl::MergeTraits< OptionsTy, typename boost::enable_if_c< has_id_fn< typename OptionsTy::Function1Ty >::value &&!OptionsTy::useOrdered >::type > | |
| GaloisRuntime::DeterministicImpl::MergeTraits< OptionsTy, typename boost::enable_if_c< OptionsTy::useOrdered >::type > | |
| llvm::APInt::ms | Magic data for optimising signed division by a constant |
| llvm::APInt::mu | Magic data for optimising unsigned division by a constant |
| llvm::cl::multi_val | |
| Galois::needs_parallel_break< T > | Indicates the operator may request the parallel loop to be suspended and a given function run in serial |
| Galois::needs_per_iter_alloc< T > | Indicates the operator may request the access to a per-iteration allocator |
| Galois::ParallelSTL::sort_helper< Compare >::neq_to< value_type > | Not equal in terms of less-than |
| GaloisRuntime::NhoodItem< Ctxt, CtxtCmp > | |
| Galois::Graph::SpatialTree2d< T >::Node | |
| Galois::Graph::LC_CSR_Graph< NodeTy, EdgeTy >::NodeInfo | |
| Galois::Graph::LC_CSRInline_Graph< NodeTy, EdgeTy >::NodeInfo | |
| Galois::Graph::LC_Linear_Graph< NodeTy, EdgeTy >::NodeInfo | |
| Galois::Graph::LC_Numa_Graph< NodeTy, EdgeTy >::NodeInfo | |
| Galois::ParallelSTL::NoDerefIterator< Iterator > | Modify an iterator so that *it == it |
| GaloisRuntime::WorkList::NoInlineFilter< iWL > | |
| noncopyable | |
| Galois::SparseBitVector::OneWord | |
| OnlineStat | |
| llvm::cl::opt< DataType, ExternalStorage, ParserClass > | |
| llvm::cl::opt_storage< DataType, ExternalStorage, isClass > | |
| llvm::cl::opt_storage< DataType, false, false > | |
| llvm::cl::opt_storage< DataType, false, true > | |
| llvm::cl::Option | |
| llvm::cl::OptionDiffPrinter< ParserDT, ValDT > | |
| llvm::cl::OptionDiffPrinter< DT, DT > | |
| llvm::cl::parser< DataType >::OptionInfo | |
| GaloisRuntime::DeterministicImpl::Options< Function1Ty, Function2Ty > | |
| llvm::cl::OptionValue< DataType > | |
| llvm::cl::OptionValue< cl::boolOrDefault > | |
| llvm::cl::OptionValue< std::string > | |
| llvm::cl::OptionValueBase< DataType, isClass > | |
| llvm::cl::OptionValueBase< DataType, false > | |
| llvm::cl::OptionValueCopy< DataType > | |
| GaloisRuntime::WorkList::OrderedByIntegerMetric< Indexer, ContainerTy, BSP, T, concurrent, retyped > | |
| GaloisRuntime::DeterministicImpl::OrderedContextComp< T, CompTy > | |
| GaloisRuntime::DeterministicImpl::OrderedOptions< _T, _Function1Ty, _Function2Ty, _CompareTy > | |
| GaloisRuntime::DeterministicImpl::OrderedTag | |
| GaloisRuntime::OrderedTraits< NhFunc, OpFunc > | |
| GaloisRuntime::WorkList::OwnerComputeChunkedLIFO< OwnerFn, chunksize, T, concurrent > | |
| GaloisRuntime::WorkList::OwnerComputeChunkedMaster< T, OwnerFn, QT, distributed, isStack, chunksize, concurrent > | |
| GaloisRuntime::WorkList::OwnerComputesWL< OwnerFn, WLTy, T > | |
| GaloisRuntime::MM::OwnerTaggedHeap< SourceHeap > | Allow looking up parent heap pointers |
| llvm::OwningArrayPtr< T > | OwningArrayPtr smart pointer - OwningArrayPtr provides the same functionality as OwningPtr, except that it works for array types |
| llvm::OwningPtr< T > | OwningPtr smart pointer - OwningPtr mimics a built-in pointer except that it guarantees deletion of the object pointed to, either on destruction of the OwningPtr or via an explicit reset() |
| GaloisRuntime::WorkList::ChunkedMaster< T, QT, distributed, isStack, chunksize, concurrent >::p | |
| GaloisRuntime::WorkList::WorkListTracker< Indexer, realWL, T >::p | |
| GaloisRuntime::WorkList::OwnerComputeChunkedMaster< T, OwnerFn, QT, distributed, isStack, chunksize, concurrent >::p | |
| GaloisRuntime::WorkList::LoadBalanceTracker< realWL, perEpoch >::p | |
| GaloisRuntime::LL::PaddedLock< false > | |
| GaloisRuntime::LL::PaddedLock< true > | |
| Galois::ParallelSTL::pair_dist | |
| llvm::cl::parser< DataType > | |
| llvm::cl::parser< bool > | |
| llvm::cl::parser< boolOrDefault > | |
| llvm::cl::parser< char > | |
| llvm::cl::parser< double > | |
| llvm::cl::parser< float > | |
| llvm::cl::parser< int > | |
| llvm::cl::parser< std::string > | |
| llvm::cl::parser< unsigned > | |
| llvm::cl::parser< unsigned long long > | |
| Galois::ParallelSTL::partition_helper< RandomAccessIterator, Predicate > | |
| Galois::ParallelSTL::partition_helper< RandomAccessIterator, Predicate >::partition_helper_state | |
| anonymous_namespace{PageAlloc.cpp}::PAState | |
| anonymous_namespace{Context.cpp}::PendingStatus | |
| GaloisRuntime::PerBackend | |
| GaloisRuntime::PerCPU< T, false > | |
| GaloisRuntime::PerCPU< T, true > | |
| GaloisRuntime::WorkList::OrderedByIntegerMetric< Indexer, ContainerTy, BSP, T, concurrent, retyped >::perItem | |
| GaloisRuntime::PerLevel< T, false > | |
| GaloisRuntime::PerLevel< T, true > | |
| GaloisRuntime::PerPackageStorage< T > | |
| GaloisRuntime::HIDDEN::PERTHING< T, BASE > | |
| GaloisRuntime::PerThreadAllocatorFactory< T > | |
| GaloisRuntime::PerThreadDeque< T > | |
| GaloisRuntime::PerThreadList< T > | |
| GaloisRuntime::WorkList::PerThreadQueues< QueueTy > | |
| GaloisRuntime::PerThreadSet< T, C > | |
| GaloisRuntime::PerThreadStorage< T > | |
| GaloisRuntime::PerThreadVector< T > | |
| GaloisRuntime::PerThreadWorkList< Cont_tp > | |
| GaloisRuntime::SimpleBarrier::PLD | |
| llvm::PointerLikeTypeTraits< T > | PointerLikeTypeTraits - This is a traits object that is used to handle pointer types and things that are just wrappers for pointers as a uniform entity |
| llvm::PointerLikeTypeTraits< const T * > | |
| llvm::PointerLikeTypeTraits< T * > | |
| llvm::PointerLikeTypeTraits< uintptr_t > | |
| GaloisRuntime::DoAllWork< FunctionTy, ReduceFunTy, RangeTy, useStealing >::PrivateState | |
| GaloisRuntime::PthreadBarrier | |
| GaloisRuntime::PtrBasedNhoodMgr< T, Cmp > | |
| GaloisRuntime::LL::PtrLock< T, false > | |
| GaloisRuntime::LL::PtrLock< T, true > | |
| GaloisRuntime::QueuingLock< false > | |
| GaloisRuntime::QueuingLock< true > | |
| GaloisRuntime::MM::ExternRefGaloisAllocator< void, AllocTy >::rebind< Other > | |
| GaloisRuntime::MM::ExternRefGaloisAllocator< Ty, AllocTy >::rebind< Other > | |
| GaloisRuntime::MM::FSBGaloisAllocator< Ty >::rebind< Other > | |
| GaloisRuntime::MM::FSBGaloisAllocator< void >::rebind< Other > | |
| llvm::Recycler< T, Size, Align > | Recycler - This class manages a linked-list of deallocated nodes and facilitates reusing deallocated memory in place of allocating new memory |
| llvm::RecyclerStruct | RecyclerStruct - Implementation detail for Recycler |
| Galois::ReduceAssignWrap< BinFunc > | Turns binary functions over values into functions over references |
| Galois::ReduceCollectionWrap< CollectionTy, AdaptorTy > | Turns functions over elements of a range into functions over collections |
| Galois::ReduceMapWrap< BinFunc > | Turns binary functions over item (value) references into functions over maps of items |
| Galois::ReduceVectorWrap< BinFunc > | Turns binary functions over item references into functions over vectors of items |
| llvm::ReferenceAdder< T > | |
| llvm::ReferenceAdder< T & > | |
| llvm::remove_pointer< T > | |
| llvm::remove_pointer< T * > | |
| llvm::remove_pointer< T *const > | |
| llvm::remove_pointer< T *const volatile > | |
| llvm::remove_pointer< T *volatile > | |
| GaloisRuntime::PtrBasedNhoodMgr< T, Cmp >::Reset | |
| GaloisRuntime::WorkList::LocalWorklist< WLTy, T >::rethread< newconcurrent > | |
| GaloisRuntime::WorkList::LIFO< T, concurrent >::rethread< newconcurrent > | |
| GaloisRuntime::WorkList::GFIFO< T, concurrent >::rethread< newconcurrent > | |
| GaloisRuntime::WorkList::OrderedByIntegerMetric< Indexer, ContainerTy, BSP, T, concurrent, retyped >::rethread< newconcurrent > | |
| GaloisRuntime::WorkList::LocalQueues< GlobalQueueTy, LocalQueueTy, T >::rethread< newconcurrent > | |
| GaloisRuntime::WorkList::ChunkedMaster< T, QT, distributed, isStack, chunksize, concurrent >::rethread< newconcurrent > | |
| GaloisRuntime::WorkList::OwnerComputeChunkedMaster< T, OwnerFn, QT, distributed, isStack, chunksize, concurrent >::rethread< newconcurrent > | |
| GaloisRuntime::WorkList::PerThreadQueues< QueueTy >::rethread< newConcurrent > | |
| GaloisRuntime::WorkList::NoInlineFilter< iWL >::rethread< concurrent > | |
| GaloisRuntime::WorkList::OwnerComputesWL< OwnerFn, WLTy, T >::rethread< newconcurrent > | |
| GaloisRuntime::WorkList::FIFO< T, concurrent >::rethread< newconcurrent > | |
| GaloisRuntime::WorkList::WorkListTracker< Indexer, realWL, T >::rethread< newconcurrent > | |
| GaloisRuntime::WorkList::LoadBalanceTracker< realWL, perEpoch >::rethread< newconcurrent > | |
| GaloisRuntime::WorkList::BulkSynchronous< ContainerTy, T, concurrent >::rethread< newconcurrent > | |
| GaloisRuntime::WorkList::AbstractWorkList< T, concurrent >::rethread< newconcurrent > | Change the concurrency flag |
| GaloisRuntime::WorkList::OrderedByIntegerMetric< Indexer, ContainerTy, BSP, T, concurrent, retyped >::retype< Tnew > | |
| GaloisRuntime::WorkList::AbstractWorkList< T, concurrent >::retype< Tnew > | Change the type the worklist holds |
| GaloisRuntime::WorkList::LIFO< T, concurrent >::retype< Tnew > | |
| GaloisRuntime::WorkList::WorkListTracker< Indexer, realWL, T >::retype< Tnew > | |
| GaloisRuntime::WorkList::OwnerComputeChunkedMaster< T, OwnerFn, QT, distributed, isStack, chunksize, concurrent >::retype< Tnew > | |
| GaloisRuntime::WorkList::LocalQueues< GlobalQueueTy, LocalQueueTy, T >::retype< Tnew > | |
| GaloisRuntime::WorkList::ChunkedMaster< T, QT, distributed, isStack, chunksize, concurrent >::retype< Tnew > | |
| GaloisRuntime::WorkList::OwnerComputesWL< OwnerFn, WLTy, T >::retype< Tnew > | |
| GaloisRuntime::WorkList::GFIFO< T, concurrent >::retype< Tnew > | |
| GaloisRuntime::WorkList::ChunkedAdaptor< separateBuffering, chunksize, gWL, T >::retype< Tnew > | |
| GaloisRuntime::WorkList::PerThreadQueues< QueueTy >::retype< Tnew > | |
| GaloisRuntime::WorkList::LoadBalanceTracker< realWL, perEpoch >::retype< Tnew > | |
| GaloisRuntime::WorkList::NoInlineFilter< iWL >::retype< Tnew > | |
| GaloisRuntime::WorkList::BulkSynchronous< ContainerTy, T, concurrent >::retype< Tnew > | |
| GaloisRuntime::WorkList::FIFO< T, concurrent >::retype< Tnew > | |
| GaloisRuntime::WorkList::LocalWorklist< WLTy, T >::retype< Tnew > | |
| Galois::ThreadSafeMinHeap< T, Cmp, Cont >::RevCmp | |
| llvm::RoundUpToPowerOfTwo< N > | |
| llvm::RoundUpToPowerOfTwoH< N, isPowerTwo > | RoundUpToPowerOfTwoH - If N is not a power of two, increase it |
| llvm::RoundUpToPowerOfTwoH< N, false > | |
| GaloisRuntime::WorkList::safe_result_of< bool, class > | Delay evaluation of result_of until we have all our types rather than dummy values |
| GaloisRuntime::WorkList::safe_result_of< false, F(ArgTypes...)> | |
| GaloisRuntime::WorkList::safe_result_of< true, F(ArgTypes...)> | |
| GaloisRuntime::MM::SelfLockFreeListHeap< SourceHeap > | Maintain a freelist using a lock which doesn't cover SourceHeap |
| anonymous_namespace{ThreadPool_pthread.cpp}::Semaphore | |
| GaloisRuntime::DoAllWork< FunctionTy, ReduceFunTy, RangeTy, useStealing >::SharedState | |
| llvm::APFloat::Significand | |
| GaloisRuntime::SimpleBarrier | Simple busy waiting barrier, not cyclic |
| GaloisRuntime::MM::SimpleBumpPtr< SourceHeap > | This implements a bump pointer though chunks of memory |
| GaloisRuntime::MM::SimpleBumpPtrWithMallocFallback< SourceHeap > | This implements a bump pointer though chunks of memory that falls back to malloc if the source heap cannot accommodate an allocation |
| GaloisRuntime::LL::SimpleLock< false > | |
| GaloisRuntime::LL::SimpleLock< true > | |
| GaloisRuntime::SimpleRuntimeContext | |
| llvm::simplify_type< const ilist_iterator< NodeTy > > | |
| llvm::simplify_type< ilist_iterator< NodeTy > > | |
| GaloisRuntime::MM::SizedAllocatorFactory | |
| llvm::SlabAllocator | SlabAllocator - This class can be used to parameterize the underlying allocation strategy for the bump allocator |
| Galois::SmallBag< T, N > | Bag that supports a small number of inline elements before defaulting to Bag<T> implementation |
| llvm::SmallPtrSet< PtrType, SmallSize > | SmallPtrSet - This class implements a set which is optimized for holding SmallSize or less elements |
| llvm::SmallPtrSetImpl | SmallPtrSetImpl - This is the common code shared among all the SmallPtrSet<>'s, which is almost everything |
| llvm::SmallPtrSetIterator< PtrTy > | SmallPtrSetIterator - This implements a const_iterator for SmallPtrSet |
| llvm::SmallPtrSetIteratorImpl | SmallPtrSetIteratorImpl - This is the common base class shared between all instances of SmallPtrSetIterator |
| llvm::SmallString< InternalLen > | SmallString - A SmallString is just a SmallVector with methods and accessors that make it work better as a string (e.g |
| llvm::SmallVector< T, N > | SmallVector - This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small |
| llvm::SmallVector< T, 0 > | Specialize SmallVector at N=0 |
| llvm::SmallVectorBase | SmallVectorBase - This is all the non-templated stuff common to all SmallVectors |
| llvm::SmallVectorImpl< T > | SmallVectorImpl - This class consists of common code factored out of the SmallVector class to reduce code duplication based on the SmallVector 'N' template parameter |
| llvm::SmallVectorTemplateBase< T, isPodLike > | SmallVectorTemplateBase<isPodLike = false> - This is where we put method implementations that are designed to work with non-POD-like T's |
| llvm::SmallVectorTemplateBase< T, true > | SmallVectorTemplateBase<isPodLike = true> - This is where we put method implementations that are designed to work with POD-like T's |
| llvm::SmallVectorTemplateCommon< T > | |
| Galois::ParallelSTL::sort_helper< Compare > | |
| SourceHeap | |
| Galois::SparseBitVector | Concurrent version of sparse bit vector |
| Galois::Graph::SpatialTree2d< T > | Stores sets of objects at specific spatial coordinates in a quad tree |
| llvm::SpecificBumpPtrAllocator< T > | SpecificBumpPtrAllocator - Same as BumpPtrAllocator but allows only elements of one type to be allocated |
| GaloisRuntime::WorkList::squeues< false, TQ > | |
| GaloisRuntime::WorkList::squeues< true, TQ > | |
| GaloisRuntime::StableSourceTest< Ctxt > | |
| GaloisRuntime::StandardRange< IterTy > | |
| GaloisRuntime::DeterministicImpl::StateManager< T, FunctionTy, Enable > | |
| GaloisRuntime::DeterministicImpl::StateManager< T, FunctionTy, typename boost::enable_if< has_local_state< FunctionTy > >::type > | |
| GaloisRuntime::LL::StaticInstance< T > | |
| Galois::Statistic | |
| anonymous_namespace{Support.cpp}::StatManager | |
| Galois::StatManager | Controls lifetime of stats. Users usually instantiate an instance in main |
| Galois::StatTimer | Provides statistic interface around timer |
| GaloisRuntime::WorkList::StealingQueues | |
| Galois::TwoLevelIteratorImpl::StlInnerIsConstIterator< Outer > | |
| Galois::TwoLevelIteratorImpl::StlInnerIsConstRvrsIterator< Outer > | |
| Galois::TwoLevelIteratorImpl::StlInnerIsIterator< Outer > | |
| Galois::TwoLevelIteratorImpl::StlInnerIsRvrsIterator< Outer > | |
| Galois::StrictObject< T > | Single object with specialization for void type |
| Galois::StrictObject< void > | |
| llvm::StringMap< ValueTy, AllocatorTy > | StringMap - This is an unconventional map that is specialized for handling keys that are "strings", which are basically ranges of bytes |
| llvm::StringMapConstIterator< ValueTy > | |
| llvm::StringMapEntry< ValueTy > | StringMapEntry - This is used to represent one value that is inserted into a StringMap |
| llvm::StringMapEntryBase | StringMapEntryBase - Shared base class of StringMapEntry instances |
| llvm::StringMapEntryInitializer< ValueTy > | StringMapEntryInitializer - This datatype can be partially specialized for various datatypes in a stringmap to allow them to be initialized when an entry is default constructed for the map |
| llvm::StringMapImpl | StringMapImpl - This is the base class of StringMap that is shared among all of its instantiations |
| llvm::StringMapIterator< ValueTy > | |
| llvm::StringRef | StringRef - Represent a constant reference to a string, i.e |
| GaloisRuntime::MM::SystemBaseAlloc | This is the base source of memory for all allocators |
| GaloisRuntime::TerminationDetection | |
| anonymous_namespace{ThreadPool_pthread.cpp}::ThinBarrier | |
| GaloisRuntime::MM::ThreadAwarePrivateHeap< LocalHeap > | Per-thread heaps using Galois thread aware construct |
| GaloisRuntime::ForEachWork< WorkListTy, T, FunctionTy >::ThreadLocalData | |
| GaloisRuntime::DeterministicImpl::Executor< OptionsTy >::ThreadLocalData | |
| GaloisRuntime::ThreadPool | |
| anonymous_namespace{ThreadPool_pthread.cpp}::ThreadPool_pthread | |
| GaloisRuntime::LL::ThreadRWlock | |
| Galois::ThreadSafeMinHeap< T, Cmp, Cont > | Thread-safe min heap |
| Galois::ThreadSafeOrderedSet< T, Cmp, Alloc > | Thread-safe ordered set |
| Galois::TimeAccumulator | A multi-start time accumulator |
| Galois::Timer | A simple timer |
| GaloisRuntime::SimpleBarrier::TLD | |
| GaloisRuntime::WorkList::BulkSynchronous< ContainerTy, T, concurrent >::TLD | |
| anonymous_namespace{Termination.cpp}::LocalTerminationDetection::TokenHolder | |
| GaloisRuntime::TopoBarrier | |
| GaloisRuntime::TopoBarrier::treenode | |
| GaloisRuntime::MCSBarrier::treenode | |
| llvm::Twine | Twine - A lightweight data structure for efficiently representing the concatenation of temporary values as strings |
| Galois::TwoLevelBiDirIter< Outer, Inner, InnerBegFn, InnerEndFn > | Two-Level bidirectional iterator |
| Galois::TwoLevelFwdIter< Outer, Inner, InnerBegFn, InnerEndFn > | Two-Level forward iterator |
| Galois::TwoLevelIterBase< Outer, Inner, InnerBegFn, InnerEndFn > | Common functionality of TwoLevelIterators |
| Galois::TwoLevelRandIter< Outer, Inner, InnerBegFn, InnerEndFn > | Two-Level random access iterator |
| GaloisRuntime::MM::BlockAlloc< ElemSize, SourceHeap >::TyEq | |
| GaloisRuntime::anonymous_namespace{PerThreadWorkList.h}::TypeFactory< PerThrdWL > | |
| Galois::Bag< T, blockSize >::U | Raw and aligned space for N elements of type T |
| llvm::SmallVectorBase::U | |
| Galois::UnionFindNode< T > | Intrusive union-find implementation |
| GaloisRuntime::DeterministicImpl::UnorderedContextComp< T > | |
| GaloisRuntime::DeterministicImpl::UnorderedOptions< _T, _Function1Ty, _Function2Ty > | |
| GaloisRuntime::DeterministicImpl::UnorderedTag | |
| GaloisRuntime::UnstableSourceTest< Ctxt, StableTest > | |
| Galois::UserContext< T > | This is the object passed to the user's parallel loop |
| GaloisRuntime::UserContextAccess< T > | Backdoor to allow runtime methods to access private data in UserContext |
| llvm::cl::value_desc | |
| llvm::cl::ValuesClass< DataType > | |
| anonymous_namespace{CommandLine.cpp}::VersionPrinter | |
| GaloisRuntime::anonymous_namespace{PerThreadWorkList.h}::WLindexer< PerThrdWL > | |
| GaloisRuntime::WOnEach< FunctionTy > | |
| GaloisRuntime::WorkList::WorkListTracker< Indexer, realWL, T > | |
| GaloisRuntime::WorkList::xChunkedLIFO< chunksize, T, concurrent > | |
| GaloisRuntime::MM::ZeroOut< SourceHeap > | |
