| Galois::Runtime::anonymous_namespace{ParallelWork.h}::AbortHandler< value_type > | |
| Galois::WorkList::anonymous_namespace{WorkList.h}::AbstractWorkList< T, Concurrent > | |
| Galois::ParallelSTL::accumulate_helper< T, BinOp > | |
| Galois::ParallelSTL::accumulate_helper_reduce< BinOp > | |
| Galois::Runtime::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::Runtime::PerThreadFactory::Alloc< T > | |
| Galois::WorkList::AltChunkedFIFO< ChunkSize, T > | |
| Galois::WorkList::AltChunkedLIFO< ChunkSize, T > | |
| Galois::WorkList::AltChunkedMaster< IsLocallyLIFO, ChunkSize, Container, T > | |
| Galois::WorkList::AltChunkedQueue | |
| Galois::WorkList::AltChunkedStack | |
| Galois::Runtime::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 > | |
| llvm::APSInt | |
| llvm::ArrayRef< T > | ArrayRef - Represent a constant reference to an array (0 or more elements consecutively in memory), i.e |
| Galois::GraphLab::AsyncEngine< Graph, Operator > | |
| std::atomic< _Tp > | |
| anonymous_namespace{TID.cpp}::AtomicNextId | |
| anonymous_namespace{HWTopoLinux.cpp}::AutoLinuxPolicy | |
| Galois::Runtime::Barrier | |
| llvm::cl::basic_parser< DataType > | |
| llvm::cl::basic_parser_impl | |
| Galois::Graph::BindSegmentGraph< Graph > | Binds the segment parameter of an out-of-core graph so that it can be used in place of a non out-of-core graph |
| llvm::cl::bits< DataType, Storage, ParserClass > | |
| llvm::cl::bits_storage< DataType, StorageClass > | |
| llvm::cl::bits_storage< DataType, bool > | |
| Galois::Runtime::MM::BlockAlloc< ElemSize, SourceHeap >::Block | |
| Galois::Runtime::MM::SimpleBumpPtr< SourceHeap >::Block | |
| Galois::Runtime::MM::SimpleBumpPtrWithMallocFallback< SourceHeap >::Block | |
| Galois::Graph::OCFileGraph::Block | |
| Galois::gdeque< T, ChunkSize, ContainerTy >::Block | |
| Galois::gslist< T, ChunkSize >::Block | |
| Galois::Runtime::MM::BlockAlloc< ElemSize, SourceHeap >::Block_basic | |
| Galois::Runtime::MM::BlockAlloc< ElemSize, SourceHeap > | |
| Galois::Graph::SpatialTree2d< T >::Box2d | |
| Galois::Runtime::DeterministicImpl::anonymous_namespace{DeterministicWork.h}::BreakManager< OptionsTy > | |
| Galois::Runtime::DeterministicImpl::anonymous_namespace{DeterministicWork.h}::BreakManagerBase< OptionsTy, Enable > | |
| Galois::Runtime::DeterministicImpl::anonymous_namespace{DeterministicWork.h}::BreakManagerBase< OptionsTy, true > | |
| Galois::WorkList::BulkSynchronous< Container, T, Concurrent > | Bulk-synchronous scheduling |
| 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 > | |
| Galois::Runtime::LL::CacheLineImpl< T, REM > | |
| Galois::Runtime::LL::CacheLineImpl< T, 0 > | |
| Galois::Runtime::LL::CacheLineStorage< T > | |
| Galois::Runtime::CheckedLockObj | |
| llvm::Twine::Child | |
| Galois::LigraGraphChi::ChooseExecutor< UseGraphChi > | |
| Galois::LigraGraphChi::ChooseExecutor< false > | |
| 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 |
| Galois::WorkList::AltChunkedMaster< IsLocallyLIFO, ChunkSize, Container, T >::Chunk | |
| Galois::WorkList::ChunkedMaster< T, QT, Distributed, IsStack, ChunkSize, Concurrent >::Chunk | |
| Galois::WorkList::ChunkedFIFO< ChunkSize, T, Concurrent > | Chunked FIFO |
| Galois::WorkList::ChunkedLIFO< ChunkSize, T, Concurrent > | Chunked LIFO |
| Galois::WorkList::ChunkedMaster< T, QT, Distributed, IsStack, ChunkSize, Concurrent > | Common functionality to all chunked worklists |
| Galois::WorkList::ChunkHeader | |
| llvm::conditional< bool, T, F > | |
| llvm::conditional< false, T, F > | |
| Galois::WorkList::ConExtIterator< T > | |
| Galois::WorkList::ConExtLinkedQueue< T, concurrent > | |
| Galois::WorkList::ConExtLinkedStack< T, concurrent > | |
| Galois::WorkList::ConExtListNode< T > | |
| Galois::GraphChi::hidden::contains_node< Graph, Bag > | |
| Galois::GraphLab::Context< Graph, Operator > | |
| Galois::Graph::FileGraph::Convert32 | |
| Galois::Graph::FileGraph::Convert64 | |
| Galois::ParallelSTL::count_if_helper< Predicate > | |
| Galois::ParallelSTL::count_if_reducer | |
| anonymous_namespace{HWTopoLinux.cpp}::cpuinfo | |
| Galois::LazyObject< T >::Data | |
| Galois::WorkList::dChunkedBag< ChunkSize, T, Concurrent > | Distributed chunked bag |
| Galois::WorkList::dChunkedFIFO< ChunkSize, T, Concurrent > | Distributed chunked FIFO |
| Galois::WorkList::dChunkedLIFO< ChunkSize, T, Concurrent > | Distributed chunked LIFO |
| decimalInfo | |
| Galois::Ligra::hidden::DenseForwardOperator< Graph, Bag, EdgeOperator, Forward, IgnoreInput > | |
| 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 > | |
| Galois::Ligra::hidden::DenseOperator< Graph, Bag, EdgeOperator, Forward > | |
| anonymous_namespace{HWTopoLinux.cpp}::AutoLinuxPolicy::DensePackageEqual | |
| anonymous_namespace{HWTopoLinux.cpp}::AutoLinuxPolicy::DensePackageLessThan | Sort in package-dense manner |
| Galois::GraphChi::hidden::DenseVertexMap< CheckInput, PassWrappedGraph, Graph, WrappedGraph, VertexOperator, Bag > | |
| Galois::GraphNodeBag< BlockSize >::Densify | |
| Galois::Runtime::PerThreadFactory::Deque< T > | |
| llvm::cl::desc | |
| Galois::Runtime::DeterministicImpl::DeterministicContext< T, OptionsTy > | |
| Galois::GraphChi::hidden::DispatchOperator< PassWrappedGraph > | |
| Galois::GraphChi::hidden::DispatchOperator< false > | |
| Galois::Runtime::DeterministicImpl::DItem< T > | |
| Galois::Runtime::DeterministicImpl::anonymous_namespace{DeterministicWork.h}::DMergeLocal< OptionsTy > | Thread-local data for merging |
| Galois::Runtime::DeterministicImpl::anonymous_namespace{DeterministicWork.h}::DMergeManager< OptionsTy > | Default implementation for merging |
| Galois::Runtime::DeterministicImpl::anonymous_namespace{DeterministicWork.h}::DMergeManagerBase< OptionsTy > | |
| Galois::Runtime::DeterministicImpl::anonymous_namespace{DeterministicWork.h}::DNewItem< T > | |
| Galois::do_all_steal | Specify whether link do_all()} loops should perform work-stealing |
| Galois::Runtime::DoAllWork< FunctionTy, ReduceFunTy, RangeTy > | |
| 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 |
| Galois::Graph::LC_Morph_Graph< NodeTy, EdgeTy, HasNoLockable, UseNumaAlloc, HasOutOfLineLockable, HasId >::dst_equals | |
| Galois::WorkList::DummyIndexer< T > | |
| Galois::AtomicImpl::DummyWrapper< T > | |
| Galois::Graph::FirstGraphImpl::EdgeFactory< ETy > | |
| Galois::Graph::FirstGraphImpl::EdgeFactory< void > | |
| Galois::Graph::LC_Morph_Graph< NodeTy, EdgeTy, HasNoLockable, UseNumaAlloc, HasOutOfLineLockable, HasId >::EdgeHolder | |
| Galois::Graph::detail::EdgeInfoBase< NodeInfoPtrTy, EdgeTy > | Edge specialization for void edge data |
| Galois::Graph::OCFileGraph::EdgeReference< EdgeTy > | |
| Galois::Graph::detail::EdgesIterator< GraphTy > | Convenience wrapper around Graph.edge_begin and Graph.edge_end to allow C++11 foreach iteration of edges |
| Galois::Graph::detail::EdgeSortCompWrapper< EdgeSortValueTy, CompTy > | Converts comparison functions over EdgeTy to be over EdgeSortValue |
| Galois::Graph::detail::EdgeSortIterator< GraphNode, EdgeIndex, EdgeDst, EdgeData > | Iterator to facilitate sorting of CSR-like graphs |
| Galois::Graph::detail::EdgeSortReference< GraphNode, EdgeIndex, EdgeDst, EdgeData > | Proxy object for EdgeSortIterator |
| Galois::Graph::EdgeSortValue< GraphNode, EdgeTy > | Proxy object for detail::EdgeSortIterator |
| Galois::Graph::detail::EdgesWithNoFlagIterator< GraphTy > | |
| Galois::Runtime::EmptyFn | |
| Galois::GraphLab::EmptyMessage | |
| llvm::enable_if< Cond, T > | |
| std::enable_if< bool, _Tp > | |
| std::enable_if< true, _Tp > | |
| llvm::enable_if_c< Cond, T > | |
| llvm::enable_if_c< false, T > | |
| Galois::Runtime::DeterministicImpl::anonymous_namespace{DeterministicWork.h}::Executor< OptionsTy > | |
| Galois::WorkList::ExternRef< Container, pushinit > | |
| Galois::Runtime::MM::ExternRefGaloisAllocator< Ty, AllocTy > | |
| Galois::Runtime::MM::ExternRefGaloisAllocator< void, AllocTy > | |
| llvm::cl::extrahelp | |
| Galois::Runtime::DeterministicImpl::anonymous_namespace{DeterministicWork.h}::FIFO< chunksize, T > | Wrapper around WorkList::ChunkedFIFO to allow peek() and empty() and still have FIFO order |
| Galois::WorkList::FIFO< T, Concurrent > | Simple FIFO worklist (not scalable) |
| Galois::Graph::FileGraph | Graph serialized to a file |
| Galois::Graph::FileGraphAllocator | |
| Galois::Graph::FileGraphWriter | Simplifies writing graphs |
| Galois::ParallelSTL::find_if_helper< InputIterator, Predicate > | |
| Galois::Graph::MemScalGraph< NodeTy, EdgeTy, Directional >::first_eq_and_valid< T > | |
| Galois::Graph::FirstGraph< NodeTy, EdgeTy, Directional, HasNoLockable >::first_eq_and_valid< T > | |
| Galois::Graph::MemScalGraph< NodeTy, EdgeTy, Directional >::first_not_valid | |
| Galois::Graph::FirstGraph< NodeTy, EdgeTy, Directional, HasNoLockable >::first_not_valid | |
| Galois::Graph::FirstGraph< NodeTy, EdgeTy, Directional, HasNoLockable > | A Graph |
| Galois::Runtime::MM::FixedSizeAllocator | |
| Galois::FixedSizeBag< T, chunksize > | Unordered collection of bounded size |
| Galois::FixedSizeRing< T, chunksize > | Ordered collection of bounded size |
| Galois::flat_map< _Key, _Tp, _Compare, _Alloc > | Simple map data structure, based off a single array |
| llvm::fltSemantics | |
| Galois::Runtime::anonymous_namespace{ForEachTraits.h}::ForEachTraits< FunctionTy > | |
| Galois::Runtime::anonymous_namespace{ParallelWork.h}::ForEachWork< WorkListTy, T, FunctionTy > | |
| Galois::Runtime::MM::FreeListHeap< SourceHeap > | Maintain a freelist |
| Galois::Runtime::MM::FreeListHeap< SourceHeap >::FreeNode | |
| Galois::Runtime::MM::SelfLockFreeListHeap< SourceHeap >::FreeNode | |
| anonymous_namespace{PageAlloc.cpp}::FreeNode | |
| Galois::Runtime::PerThreadFactory::FSBAlloc< T > | |
| Galois::Runtime::MM::FSBGaloisAllocator< Ty > | |
| Galois::Runtime::MM::FSBGaloisAllocator< void > | |
| Galois::GAccumulator< T > | Accumulator for T where accumulation is sum |
| Galois::GraphLab::SyncEngine< Graph, Operator >::Gather | |
| 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, ChunkSize, ContainerTy > | 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::GetBegin | Helper functor, returns t.end() |
| Galois::TwoLevelIteratorImpl::GetCbegin< C > | |
| Galois::TwoLevelIteratorImpl::GetCend< C > | |
| Galois::TwoLevelIteratorImpl::GetCRbegin< C > | |
| Galois::TwoLevelIteratorImpl::GetCRend< C > | |
| Galois::TwoLevelIteratorImpl::GetEnd< C > | |
| Galois::GetEnd | Helper functor, returns t.end() |
| Galois::Runtime::DeterministicImpl::anonymous_namespace{DeterministicWork.h}::DNewItem< T >::GetFirst | |
| Galois::Runtime::DeterministicImpl::anonymous_namespace{DeterministicWork.h}::DMergeManager< OptionsTy >::GetNewItem | |
| Galois::TwoLevelIteratorImpl::GetRbegin< C > | |
| Galois::TwoLevelIteratorImpl::GetRend< C > | |
| Galois::TwoLevelIteratorImpl::GetStlIterKind< C, I > | |
| Galois::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::MemScalGraph< NodeTy, EdgeTy, Directional >::gNode | |
| Galois::Graph::FirstGraph< NodeTy, EdgeTy, Directional, HasNoLockable >::gNode | |
| Galois::Graph::FirstGraph< NodeTy, EdgeTy, Directional, HasNoLockable >::gNodeTypes | |
| Galois::GraphNodeBag< BlockSize > | Stores graph nodes to execute for Ligra executor |
| Galois::GraphNodeBagPair< BlockSize > | Stores graph nodes to execute for Ligra executor |
| 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 |
| Galois::has_deterministic_id< T > | Indicates the operator has a member function that optimizes the generation of unique ids for active elements |
| Galois::has_deterministic_local_state< T > | Indicates the operator has a member type that encapsulates state that is passed between the suspension and resumpsion of an operator during deterministic scheduling |
| Galois::has_deterministic_parallel_break< T > | Indicates the operator has a member function that allows a Galois::for_each loop to be exited deterministically |
| Galois::has_fixed_neighborhood< T > | Indicates that the neighborhood set does not change through out i.e |
| Galois::has_known_trivial_constructor< T > | Temporary type trait for pre-C++11 compilers, which don't support exact std::is_trivially_constructible |
| Galois::InsertBag< T, BlockSize >::header | |
| 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 > | |
| Galois::Graph::LC_InOut_Graph< GraphTy >::in_edge_iterator | |
| Galois::Graph::detail::InEdgesIterator< GraphTy > | Convenience wrapper around Graph.in_edge_begin and Graph.in_edge_end to allow C++11 foreach iteration of in edges |
| Galois::GraphLab::SyncEngine< Graph, Operator >::Initialize< IsFirst > | |
| Galois::GraphLab::AsyncEngine< Graph, Operator >::Initialize | |
| Galois::GraphNodeBag< BlockSize >::InitializeBig | |
| llvm::cl::initializer< Ty > | |
| Galois::GraphNodeBag< BlockSize >::InitializeSmall | |
| Galois::Runtime::DeterministicImpl::anonymous_namespace{DeterministicWork.h}::InOrderManager< OptionsTy > | |
| Galois::Runtime::DeterministicImpl::anonymous_namespace{DeterministicWork.h}::InOrderManagerBase< OptionsTy, Enable > | |
| Galois::Runtime::DeterministicImpl::anonymous_namespace{DeterministicWork.h}::InOrderManagerBase< OptionsTy, true > | |
| Galois::InsertBag< T, BlockSize > | Bag for only concurrent insertions |
| Galois::Graph::detail::IntrusiveId< IdTy > | |
| Galois::Graph::detail::IntrusiveId< void > | |
| 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::MemScalGraph< NodeTy, EdgeTy, Directional >::is_edge | |
| Galois::Graph::FirstGraph< NodeTy, EdgeTy, Directional, HasNoLockable >::is_edge | |
| Galois::Graph::MemScalGraph< NodeTy, EdgeTy, Directional >::is_node | |
| Galois::Graph::FirstGraph< NodeTy, EdgeTy, Directional, HasNoLockable >::is_node | |
| llvm::is_same< T, U > | Metafunction that determines whether the two given types are equivalent |
| llvm::is_same< T, T > | |
| Galois::Graph::is_segmented< 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 > | |
| Galois::Runtime::anonymous_namespace{ParallelWork.h}::AbortHandler< value_type >::Item | |
| llvm::StringMapImpl::ItemBucket | ItemBucket - The hash table consists of an array of these |
| Galois::FixedSizeRing< T, chunksize >::Iterator< U, isForward > | |
| Galois::gdeque< T, ChunkSize, ContainerTy >::Iterator< U > | |
| Galois::InsertBag< T, BlockSize >::Iterator< U > | |
| Galois::gslist< T, ChunkSize >::iterator | |
| Galois::LargeArray< T > | Large array of objects with proper specialization for void type and supporting various allocation and construction policies |
| Galois::LargeArray< void > | 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, HasNoLockable, UseNumaAlloc, HasOutOfLineLockable > | Local computation graph (i.e., graph structure does not change) |
| Galois::Graph::LC_InlineEdge_Graph< NodeTy, EdgeTy, HasNoLockable, UseNumaAlloc, HasOutOfLineLockable, HasCompressedNodePtr > | Local computation graph (i.e., graph structure does not change) |
| Galois::Graph::LC_InOut_Graph< GraphTy > | Modify a LC_Graph to have in and out edges |
| Galois::Graph::LC_Linear_Graph< NodeTy, EdgeTy, HasNoLockable, UseNumaAlloc, HasOutOfLineLockable, HasId > | Local computation graph (i.e., graph structure does not change) |
| Galois::Graph::LC_Morph_Graph< NodeTy, EdgeTy, HasNoLockable, UseNumaAlloc, HasOutOfLineLockable, HasId > | Local computation graph (i.e., graph structure does not change) |
| Galois::WorkList::LIFO< T, Concurrent > | Simple LIFO worklist (not scalable) |
| llvm::cl::list< DataType, Storage, ParserClass > | |
| Galois::Runtime::PerThreadFactory::List< T > | |
| llvm::cl::list_storage< DataType, StorageClass > | |
| llvm::cl::list_storage< DataType, bool > | |
| Galois::Graph::detail::LocalIteratorFeature< Enable > | |
| Galois::Graph::detail::LocalIteratorFeature< false > | |
| Galois::WorkList::LocalQueue< Global, Local, T > | |
| Galois::Runtime::LocalRange< T > | |
| anonymous_namespace{Termination.cpp}::LocalTerminationDetection | |
| llvm::cl::LocationClass< Ty > | |
| std::lock_guard< _Mutex > | |
| Galois::Runtime::Lockable | All objects that may be locked (nodes primarily) must inherit from Lockable |
| Galois::Runtime::MM::LockedHeap< RealHeap > | Apply a lock to a heap |
| Galois::Runtime::LockManagerBase | |
| Galois::GraphChi::hidden::logical_or | |
| Galois::loopname | Specify name to appear in statistics |
| Galois::Runtime::anonymous_namespace{ParallelWork.h}::LoopStatistics< Enabled > | |
| Galois::Runtime::anonymous_namespace{ParallelWork.h}::LoopStatistics< false > | |
| Galois::Graph::FirstGraph< NodeTy, EdgeTy, Directional, HasNoLockable >::makeGraphNode | |
| Galois::Graph::LC_Morph_Graph< NodeTy, EdgeTy, HasNoLockable, UseNumaAlloc, HasOutOfLineLockable, HasId >::makeGraphNode | |
| Galois::Graph::MemScalGraph< 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 > | |
| 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 |
| Galois::Graph::MemScalGraph< NodeTy, EdgeTy, Directional > | |
| llvm::MemSlab | MemSlab - This structure lives at the beginning of every slab allocated by the bump allocator |
| Galois::MinHeap< T, Cmp, Cont > | |
| 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::GraphLab::needs_gather_in_edges< T > | |
| Galois::GraphLab::needs_gather_out_edges< T > | |
| 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::GraphLab::needs_scatter_in_edges< T > | |
| Galois::GraphLab::needs_scatter_out_edges< T > | |
| Galois::ParallelSTL::sort_helper< Compare >::neq_to< value_type > | Not equal in terms of less-than |
| Galois::Runtime::DeterministicImpl::anonymous_namespace{DeterministicWork.h}::NewWorkManager< OptionsTy > | |
| Galois::Runtime::DeterministicImpl::anonymous_namespace{DeterministicWork.h}::NewWorkManagerBase< OptionsTy, Enable > | |
| Galois::Runtime::DeterministicImpl::anonymous_namespace{DeterministicWork.h}::NewWorkManagerBase< OptionsTy, true > | |
| Galois::Graph::SpatialTree2d< T >::Node | |
| Galois::Graph::LC_InlineEdge_Graph< NodeTy, EdgeTy, HasNoLockable, UseNumaAlloc, HasOutOfLineLockable, HasCompressedNodePtr >::NodeInfo | |
| Galois::Graph::LC_Linear_Graph< NodeTy, EdgeTy, HasNoLockable, UseNumaAlloc, HasOutOfLineLockable, HasId >::NodeInfo | |
| Galois::Graph::LC_Morph_Graph< NodeTy, EdgeTy, HasNoLockable, UseNumaAlloc, HasOutOfLineLockable, HasId >::NodeInfo | |
| Galois::Graph::detail::NodeInfoBase< NodeTy, HasLockable > | Specializations for void node data |
| Galois::Graph::detail::NodeInfoBase< void, HasLockable > | |
| Galois::Graph::detail::NodeInfoBaseTypes< NodeTy, HasLockable > | Separate types from definitions to allow incomplete types as NodeTy |
| Galois::Graph::detail::NodeInfoBaseTypes< void, HasLockable > | |
| Galois::NoDerefIterator< Iterator > | Modify an iterator so that *it == it |
| Galois::WorkList::NoGlobalQueue< T > | |
| Galois::Graph::detail::NoLockable | Empty class for HasLockable optimization |
| noncopyable | |
| Galois::Graph::OCFileGraph | Like FileGraph but allows partial loading of the graph |
| Galois::Graph::OCImmutableEdgeGraph< NodeTy, EdgeTy, HasNoLockable, HasOutOfLineLockable > | |
| 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 | |
| Galois::optional< T > | Galois version of boost::optional |
| llvm::cl::OptionDiffPrinter< ParserDT, ValDT > | |
| llvm::cl::OptionDiffPrinter< DT, DT > | |
| llvm::cl::parser< DataType >::OptionInfo | |
| Galois::Runtime::DeterministicImpl::anonymous_namespace{DeterministicWork.h}::Options< T, 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 > | |
| Galois::WorkList::OrderedByIntegerMetric< Indexer, Container, BlockPeriod, BSP, T, Index, Concurrent > | Approximate priority scheduling |
| Galois::WorkList::OrderedList< Compare, T, concurrent > | |
| Galois::Runtime::OrderedTraits< NhFunc, OpFunc > | |
| Galois::Runtime::anonymous_namespace{PerThreadWorkList.h}::OuterPerThreadWLIter< PerThrdWL > | |
| Galois::Graph::detail::OutOfLineLockableFeature< Enable > | |
| Galois::Graph::detail::OutOfLineLockableFeature< false > | |
| Galois::WorkList::OwnerComputes< OwnerFn, Container, T > | |
| Galois::Runtime::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() |
| Galois::WorkList::ChunkedMaster< T, QT, Distributed, IsStack, ChunkSize, Concurrent >::p | |
| Galois::Runtime::LL::PaddedLock< false > | |
| Galois::Runtime::LL::PaddedLock< true > | |
| PageSizeConf | |
| 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 | |
| Galois::Runtime::PerBackend | |
| Galois::WorkList::OrderedByIntegerMetric< Indexer, Container, BlockPeriod, BSP, T, Index, Concurrent >::perItem | |
| Galois::Runtime::PerPackageStorage< T > | |
| Galois::Runtime::PerThreadDeque< T > | |
| Galois::Runtime::PerThreadList< T > | |
| Galois::Runtime::PerThreadMinHeap< T, C > | |
| Galois::Runtime::PerThreadSet< T, C > | |
| Galois::Runtime::PerThreadStorage< T > | |
| Galois::Runtime::PerThreadVector< T > | |
| Galois::Runtime::PerThreadWorkList< Cont_tp > | |
| 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 > | |
| anonymous_namespace{HWTopoBlueGeneQ.cpp}::Policy | Flat machine with the correct number of threads and binding |
| anonymous_namespace{HWTopoSolaris.cpp}::Policy | |
| Galois::Runtime::PerThreadFactory::PQ< T, C > | |
| Galois::Runtime::DoAllWork< FunctionTy, ReduceFunTy, RangeTy >::PrivateState | |
| Galois::GraphLab::AsyncEngine< Graph, Operator >::Process | |
| PthreadBarrier | |
| Galois::Runtime::LL::PtrLock< T, false > | |
| Galois::Runtime::LL::PtrLock< T, true > | |
| Galois::Graph::read_default_graph_tag | |
| Galois::Graph::read_lc_inout_graph_tag | |
| Galois::Graph::read_oc_immutable_edge_graph_tag | |
| Galois::Graph::read_with_aux_graph_tag | |
| Galois::Graph::ReadGraphConstructEdgesFrom< GraphTy, Aux > | |
| Galois::Graph::ReadGraphConstructFrom< GraphTy > | |
| Galois::Graph::ReadGraphConstructNodesFrom< GraphTy, Aux > | |
| Galois::Runtime::MM::ExternRefGaloisAllocator< Ty, AllocTy >::rebind< Other > | |
| Galois::Runtime::MM::FSBGaloisAllocator< void >::rebind< Other > | |
| Galois::Runtime::MM::FSBGaloisAllocator< Ty >::rebind< Other > | |
| Galois::Runtime::MM::ExternRefGaloisAllocator< void, AllocTy >::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 & > | |
| Galois::Runtime::Releasable | |
| llvm::remove_pointer< T > | |
| llvm::remove_pointer< T * > | |
| llvm::remove_pointer< T *const > | |
| llvm::remove_pointer< T *const volatile > | |
| llvm::remove_pointer< T *volatile > | |
| Galois::WorkList::OrderedByIntegerMetric< Indexer, Container, BlockPeriod, BSP, T, Index, Concurrent >::rethread< _concurrent > | |
| Galois::WorkList::StableIterator< Iterator, Steal >::rethread< _concurrent > | Change the concurrency flag |
| Galois::WorkList::LIFO< T, Concurrent >::rethread< _concurrent > | |
| Galois::WorkList::GFIFO< T, Concurrent >::rethread< _concurrent > | |
| Galois::WorkList::OwnerComputes< OwnerFn, Container, T >::rethread< _concurrent > | |
| Galois::WorkList::NoGlobalQueue< T >::rethread< _concurrent > | |
| Galois::WorkList::OrderedList< Compare, T, concurrent >::rethread< newconcurrent > | |
| Galois::WorkList::anonymous_namespace{WorkList.h}::AbstractWorkList< T, Concurrent >::rethread< _concurrent > | Change the concurrency flag |
| Galois::WorkList::ChunkedMaster< T, QT, Distributed, IsStack, ChunkSize, Concurrent >::rethread< _concurrent > | |
| Galois::WorkList::AltChunkedMaster< IsLocallyLIFO, ChunkSize, Container, T >::rethread< _concurrent > | |
| Galois::WorkList::ExternRef< Container, pushinit >::rethread< _concurrent > | Change the concurrency flag |
| Galois::WorkList::FIFO< T, Concurrent >::rethread< _concurrent > | |
| Galois::WorkList::BulkSynchronous< Container, T, Concurrent >::rethread< _concurrent > | |
| Galois::WorkList::LocalQueue< Global, Local, T >::rethread< _concurrent > | |
| Galois::WorkList::ChunkedMaster< T, QT, Distributed, IsStack, ChunkSize, Concurrent >::retype< _T > | |
| Galois::WorkList::BulkSynchronous< Container, T, Concurrent >::retype< _T > | |
| Galois::WorkList::StableIterator< Iterator, Steal >::retype< _T > | Change the type the worklist holds |
| Galois::WorkList::ExternRef< Container, pushinit >::retype< _T > | Change the type the worklist holds |
| Galois::WorkList::LIFO< T, Concurrent >::retype< _T > | |
| Galois::WorkList::LocalQueue< Global, Local, T >::retype< _T > | |
| Galois::WorkList::OrderedList< Compare, T, concurrent >::retype< Tnew > | |
| Galois::WorkList::FIFO< T, Concurrent >::retype< _T > | |
| Galois::WorkList::GFIFO< T, Concurrent >::retype< _T > | |
| Galois::WorkList::anonymous_namespace{WorkList.h}::AbstractWorkList< T, Concurrent >::retype< _T > | Change the type the worklist holds |
| Galois::WorkList::NoGlobalQueue< T >::retype< _T > | |
| Galois::WorkList::AltChunkedMaster< IsLocallyLIFO, ChunkSize, Container, T >::retype< _T > | |
| Galois::WorkList::OwnerComputes< OwnerFn, Container, T >::retype< _T > | |
| Galois::WorkList::OrderedByIntegerMetric< Indexer, Container, BlockPeriod, BSP, T, Index, Concurrent >::retype< _T > | |
| Galois::MinHeap< 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 > | |
| Galois::GraphLab::SyncEngine< Graph, Operator >::Scatter< Container > | |
| Galois::Graph::OCFileGraph::Segment | |
| Galois::Graph::OCImmutableEdgeGraph< NodeTy, EdgeTy, HasNoLockable, HasOutOfLineLockable >::segment_type | |
| Galois::Runtime::MM::SelfLockFreeListHeap< SourceHeap > | Maintain a freelist using a lock which doesn't cover SourceHeap |
| anonymous_namespace{ThreadPool_pthread.cpp}::Semaphore | |
| Galois::Runtime::PerThreadFactory::Set< T, C > | |
| Galois::WorkList::StableIterator< Iterator, Steal >::shared_state | |
| Galois::Runtime::DoAllWork< FunctionTy, ReduceFunTy, RangeTy >::SharedState | |
| llvm::APFloat::Significand | |
| Galois::Runtime::MM::SimpleBumpPtr< SourceHeap > | This implements a bump pointer though chunks of memory |
| Galois::Runtime::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 |
| Galois::Runtime::LL::SimpleLock< false > | |
| Galois::Runtime::LL::SimpleLock< true > | |
| Galois::Runtime::SimpleRuntimeContext | |
| llvm::simplify_type< const ilist_iterator< NodeTy > > | |
| llvm::simplify_type< ilist_iterator< NodeTy > > | |
| Galois::LazyObject< void >::size_of | |
| Galois::LazyObject< T >::size_of | |
| Galois::LargeArray< T >::size_of | |
| Galois::LargeArray< void >::size_of | |
| Galois::Graph::detail::OutOfLineLockableFeature< Enable >::size_of_out_of_line | |
| Galois::Graph::detail::OutOfLineLockableFeature< false >::size_of_out_of_line | |
| Galois::Runtime::MM::SizedAllocatorFactory | |
| Galois::GraphChi::hidden::sizeof_edge< EdgeTy > | |
| Galois::GraphChi::hidden::sizeof_edge< void > | |
| llvm::SlabAllocator | SlabAllocator - This class can be used to parameterize the underlying allocation strategy for the bump allocator |
| 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::Ligra::hidden::SparseOperator< Graph, Bag, EdgeOperator, Forward > | |
| Galois::GraphChi::hidden::SparseVertexMap< PassWrappedGraph, Graph, WrappedGraph, VertexOperator > | |
| 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 |
| Galois::WorkList::squeue< bool, PS, TQ > | |
| Galois::WorkList::squeue< false, PS, TQ > | |
| Galois::WorkList::StableIterator< Iterator, Steal > | |
| Galois::Runtime::StandardRange< IterTy > | |
| Galois::start_now_t | Flag type for StatTimer |
| Galois::WorkList::StableIterator< Iterator, Steal >::state | |
| Galois::Runtime::DeterministicImpl::anonymous_namespace{DeterministicWork.h}::StateManager< OptionsTy > | |
| Galois::Runtime::DeterministicImpl::anonymous_namespace{DeterministicWork.h}::StateManagerBase< OptionsTy, Enable > | |
| Galois::Runtime::DeterministicImpl::anonymous_namespace{DeterministicWork.h}::StateManagerBase< OptionsTy, true > | |
| Galois::Runtime::LL::StaticInstance< T > | |
| Galois::Statistic | Basic per-thread statistics counter |
| Galois::StatManager | Controls lifetime of stats |
| anonymous_namespace{Support.cpp}::StatManager | |
| Galois::StatTimer | Provides statistic interface around timer |
| Galois::WorkList::StealingQueue< InnerWL > | |
| 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 |
| Galois::GraphLab::SyncEngine< Graph, Operator > | |
| Galois::Runtime::MM::SystemBaseAlloc | This is the base source of memory for all allocators |
| Galois::Runtime::TerminationDetection | |
| anonymous_namespace{ThreadPool_pthread.cpp}::ThinBarrier | |
| Galois::Runtime::MM::ThreadAwarePrivateHeap< LocalHeap > | Per-thread heaps using Galois thread aware construct |
| Galois::Runtime::DeterministicImpl::anonymous_namespace{DeterministicWork.h}::Executor< OptionsTy >::ThreadLocalData | |
| Galois::Runtime::anonymous_namespace{ParallelWork.h}::ForEachWork< WorkListTy, T, FunctionTy >::ThreadLocalData | |
| Galois::Runtime::ThreadPool | |
| anonymous_namespace{ThreadPool_pthread.cpp}::ThreadPool_pthread | |
| Galois::Runtime::LL::ThreadRWlock | |
| Galois::ThreadSafeMinHeap< T, Cmp > | 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 |
| Galois::WorkList::BulkSynchronous< Container, T, Concurrent >::TLD | |
| anonymous_namespace{Termination.cpp}::TreeTerminationDetection::TokenHolder | |
| anonymous_namespace{Termination.cpp}::LocalTerminationDetection::TokenHolder | |
| TopoBarrier | |
| Galois::Ligra::hidden::Transposer< Graph, Forward > | |
| Galois::Ligra::hidden::Transposer< Graph, false > | |
| MCSBarrier::treenode | |
| TopoBarrier::treenode | |
| anonymous_namespace{Termination.cpp}::TreeTerminationDetection | |
| Galois::HIDDEN::tuple_index< T, S, i > | |
| Galois::HIDDEN::tuple_index< T, S,-1 > | |
| 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::TwoLevelIteratorA< OuterIter, InnerIter, CategoryOrTraversal, InnerBeginFn, InnerEndFn > | Alternate implementation of ChooseTwoLevelIterator |
| Galois::TwoLevelIterBase< Outer, Inner, InnerBegFn, InnerEndFn > | Common functionality of TwoLevelIterators |
| Galois::TwoLevelRandIter< Outer, Inner, InnerBegFn, InnerEndFn > | Two-Level random access iterator |
| Galois::Runtime::MM::BlockAlloc< ElemSize, SourceHeap >::TyEq | |
| type | |
| llvm::SmallVectorBase::U | |
| Galois::Graph::FirstGraphImpl::UEdgeInfoBase< NTy, ETy, false > | |
| Galois::Graph::FirstGraphImpl::UEdgeInfoBase< NTy, ETy, true > | |
| Galois::Graph::FirstGraphImpl::UEdgeInfoBase< NTy, void, false > | |
| Galois::Graph::FirstGraphImpl::UEdgeInfoBase< NTy, void, true > | |
| Galois::UnionFindNode< T > | Intrusive union-find implementation |
| Galois::UserContext< T > | This is the object passed to the user's parallel loop |
| Galois::Runtime::UserContextAccess< T > | Backdoor to allow runtime methods to access private data in UserContext |
| Galois::flat_map< _Key, _Tp, _Compare, _Alloc >::value_compare | |
| llvm::cl::value_desc | |
| Galois::flat_map< _Key, _Tp, _Compare, _Alloc >::value_key_compare | |
| llvm::cl::ValuesClass< DataType > | |
| Galois::Runtime::PerThreadFactory::Vector< T > | |
| anonymous_namespace{CommandLine.cpp}::VersionPrinter | |
| Galois::WorkList::OrderedByIntegerMetric< Indexer, Container, BlockPeriod, BSP, T, Index, Concurrent >::with_back_scan_prevention< _bsp > | |
| Galois::WorkList::OrderedByIntegerMetric< Indexer, Container, BlockPeriod, BSP, T, Index, Concurrent >::with_block_period< _period > | |
| Galois::WorkList::ChunkedMaster< T, QT, Distributed, IsStack, ChunkSize, Concurrent >::with_chunk_size< _chunk_size > | |
| Galois::WorkList::AltChunkedMaster< IsLocallyLIFO, ChunkSize, Container, T >::with_chunk_size< _chunk_size > | |
| Galois::Graph::LC_InlineEdge_Graph< NodeTy, EdgeTy, HasNoLockable, UseNumaAlloc, HasOutOfLineLockable, HasCompressedNodePtr >::with_compressed_node_ptr< _has_compressed_node_ptr > | Compress representation of graph at the expense of one level of indirection on accessing neighbors of a node |
| Galois::WorkList::OwnerComputes< OwnerFn, Container, T >::with_container< _container > | |
| Galois::WorkList::OrderedByIntegerMetric< Indexer, Container, BlockPeriod, BSP, T, Index, Concurrent >::with_container< _container > | |
| Galois::WorkList::BulkSynchronous< Container, T, Concurrent >::with_container< _container > | |
| Galois::WorkList::LocalQueue< Global, Local, T >::with_global< _global > | |
| Galois::Graph::LC_CSR_Graph< NodeTy, EdgeTy, HasNoLockable, UseNumaAlloc, HasOutOfLineLockable >::with_id< _has_id > | |
| Galois::Graph::LC_Morph_Graph< NodeTy, EdgeTy, HasNoLockable, UseNumaAlloc, HasOutOfLineLockable, HasId >::with_id< _has_id > | |
| Galois::Graph::LC_Linear_Graph< NodeTy, EdgeTy, HasNoLockable, UseNumaAlloc, HasOutOfLineLockable, HasId >::with_id< _has_id > | |
| Galois::Graph::LC_InlineEdge_Graph< NodeTy, EdgeTy, HasNoLockable, UseNumaAlloc, HasOutOfLineLockable, HasCompressedNodePtr >::with_id< _has_id > | |
| Galois::Graph::OCImmutableEdgeGraph< NodeTy, EdgeTy, HasNoLockable, HasOutOfLineLockable >::with_id< _has_id > | |
| Galois::WorkList::OwnerComputes< OwnerFn, Container, T >::with_indexer< _indexer > | |
| Galois::WorkList::OrderedByIntegerMetric< Indexer, Container, BlockPeriod, BSP, T, Index, Concurrent >::with_indexer< _indexer > | |
| Galois::WorkList::StableIterator< Iterator, Steal >::with_iterator< _iterator > | |
| Galois::WorkList::LocalQueue< Global, Local, T >::with_local< _local > | |
| Galois::Graph::LC_InlineEdge_Graph< NodeTy, EdgeTy, HasNoLockable, UseNumaAlloc, HasOutOfLineLockable, HasCompressedNodePtr >::with_no_lockable< _has_no_lockable > | |
| Galois::Graph::OCImmutableEdgeGraph< NodeTy, EdgeTy, HasNoLockable, HasOutOfLineLockable >::with_no_lockable< _has_no_lockable > | |
| Galois::Graph::LC_Linear_Graph< NodeTy, EdgeTy, HasNoLockable, UseNumaAlloc, HasOutOfLineLockable, HasId >::with_no_lockable< _has_no_lockable > | |
| Galois::Graph::FirstGraph< NodeTy, EdgeTy, Directional, HasNoLockable >::with_no_lockable< _has_no_lockable > | If true, do not use abstract locks in graph |
| Galois::Graph::LC_CSR_Graph< NodeTy, EdgeTy, HasNoLockable, UseNumaAlloc, HasOutOfLineLockable >::with_no_lockable< _has_no_lockable > | If true, do not use abstract locks in graph |
| Galois::Graph::LC_Morph_Graph< NodeTy, EdgeTy, HasNoLockable, UseNumaAlloc, HasOutOfLineLockable, HasId >::with_no_lockable< _has_no_lockable > | |
| Galois::Graph::LC_InlineEdge_Graph< NodeTy, EdgeTy, HasNoLockable, UseNumaAlloc, HasOutOfLineLockable, HasCompressedNodePtr >::with_node_data< _node_data > | |
| Galois::Graph::LC_Morph_Graph< NodeTy, EdgeTy, HasNoLockable, UseNumaAlloc, HasOutOfLineLockable, HasId >::with_node_data< _node_data > | |
| Galois::Graph::LC_CSR_Graph< NodeTy, EdgeTy, HasNoLockable, UseNumaAlloc, HasOutOfLineLockable >::with_node_data< _node_data > | |
| Galois::Graph::LC_Linear_Graph< NodeTy, EdgeTy, HasNoLockable, UseNumaAlloc, HasOutOfLineLockable, HasId >::with_node_data< _node_data > | |
| Galois::Graph::OCImmutableEdgeGraph< NodeTy, EdgeTy, HasNoLockable, HasOutOfLineLockable >::with_node_data< _node_data > | |
| Galois::Graph::LC_InlineEdge_Graph< NodeTy, EdgeTy, HasNoLockable, UseNumaAlloc, HasOutOfLineLockable, HasCompressedNodePtr >::with_numa_alloc< _use_numa_alloc > | |
| Galois::Graph::LC_Linear_Graph< NodeTy, EdgeTy, HasNoLockable, UseNumaAlloc, HasOutOfLineLockable, HasId >::with_numa_alloc< _use_numa_alloc > | |
| Galois::Graph::LC_CSR_Graph< NodeTy, EdgeTy, HasNoLockable, UseNumaAlloc, HasOutOfLineLockable >::with_numa_alloc< _use_numa_alloc > | If true, use NUMA-aware graph allocation |
| Galois::Graph::LC_Morph_Graph< NodeTy, EdgeTy, HasNoLockable, UseNumaAlloc, HasOutOfLineLockable, HasId >::with_numa_alloc< _use_numa_alloc > | |
| Galois::Graph::OCImmutableEdgeGraph< NodeTy, EdgeTy, HasNoLockable, HasOutOfLineLockable >::with_numa_alloc< _use_numa_alloc > | |
| Galois::Graph::OCImmutableEdgeGraph< NodeTy, EdgeTy, HasNoLockable, HasOutOfLineLockable >::with_out_of_line_lockable< _has_out_of_line_lockable > | |
| Galois::Graph::LC_Morph_Graph< NodeTy, EdgeTy, HasNoLockable, UseNumaAlloc, HasOutOfLineLockable, HasId >::with_out_of_line_lockable< _has_out_of_line_lockable > | |
| Galois::Graph::LC_CSR_Graph< NodeTy, EdgeTy, HasNoLockable, UseNumaAlloc, HasOutOfLineLockable >::with_out_of_line_lockable< _has_out_of_line_lockable > | If true, store abstract locks separate from nodes |
| Galois::Graph::LC_InlineEdge_Graph< NodeTy, EdgeTy, HasNoLockable, UseNumaAlloc, HasOutOfLineLockable, HasCompressedNodePtr >::with_out_of_line_lockable< _has_out_of_line_lockable > | |
| Galois::Graph::LC_Linear_Graph< NodeTy, EdgeTy, HasNoLockable, UseNumaAlloc, HasOutOfLineLockable, HasId >::with_out_of_line_lockable< _has_out_of_line_lockable > | |
| Galois::WorkList::StableIterator< Iterator, Steal >::with_steal< _steal > | |
| Galois::wl< WLTy > | Specify worklist to use |
| Galois::wl_tag | |
| Galois::Runtime::anonymous_namespace{ParallelWork.h}::WOnEach< FunctionTy > | |
| Galois::Runtime::MM::ZeroOut< SourceHeap > | |
