  galois::runtime::AbortHandler< value_type > | |
| galois::runtime::AlwaysLockObj | |
 std::array< T > | STL class |
  galois::CopyableArray< T, N > | A subclass of std::array that is marked trivially copyable if the type is also memory copyable |
| atomic | |
| galois::CopyableAtomic< T > | Class that inherits from std::atomic to make it copyable by defining a copy constructor |
| galois::graphs::Morph_SepInOut_Graph< NodeTy, EdgeTy, Directional, InOut, HasNoLockable, SortedNeighbors, FileEdgeTy >::AuxNode | |
| galois::graphs::MorphGraph< NodeTy, EdgeTy, Directional, InOut, HasNoLockable, SortedNeighbors, FileEdgeTy >::AuxNode | Wrapper around a graph node that provides a lock for it as well as in-neighbor tracking |
| galois::graphs::MorphHyperGraph< NodeTy, EdgeTy, Directional, InOut, HasNoLockable, SortedNeighbors, FileEdgeTy >::AuxNode | Wrapper around a graph node that provides a lock for it as well as in-neighbor tracking |
| galois::substrate::Barrier | |
| binary_function | |
| galois::flat_map< _Key, _Tp, _Compare, _Alloc, _Store >::value_compare | |
| galois::ParallelSTL::sort_helper< Compare >::neq_to< value_type > | Not equal in terms of less-than |
| galois::runtime::internal::BreakManagerBase< OptionsTy, Enable > | |
 galois::runtime::internal::Executor< internal::Options< T, FunctionTy, ArgsTy > > | |
 galois::runtime::ForEachExecutor< worklists::Deterministic< T >, FunctionTy, ArgsTy > | |
| galois::graphs::BufferedGraph< EdgeDataType > | Class that loads a portion of a Galois graph from disk directly into memory buffers for access |
| galois::substrate::CacheLineStorage< T > | |
| galois::substrate::CacheLineStorage< galois::substrate::SimpleLock > | |
| galois::substrate::CacheLineStorage< shared_state > | |
| galois::substrate::CacheLineStorage< std::atomic< bool > > | |
| galois::substrate::CacheLineStorage< std::atomic< int > > | |
| galois::runtime::CheckedLockObj | |
| galois::ChooseStlTwoLevelIterator< Outer, Inner > | Type function to select appropriate two-level iterator |
| galois::ChooseTwoLevelIterator< Outer, Inner, InnerBegFn, InnerEndFn > | Type function to select appropriate two-level iterator |
| galois::runtime::ParaMeter::ChooseWL< T, SCHED > | |
| galois::runtime::ParaMeter::ChooseWL< IterationContext *, WorkListTy::SCHEDULE > | |
| galois::runtime::ParaMeter::ChooseWL< T, SchedType::FIFO > | |
| galois::runtime::ParaMeter::ChooseWL< T, SchedType::LIFO > | |
| galois::runtime::ParaMeter::ChooseWL< T, SchedType::RAND > | |
| galois::chunk_size_tag | |
| galois::chunk_size< SZ > | Specify chunk size for do_all_coupled & do_all_choice at compile time or at runtime |
| galois::worklists::ChunkHeader | |
| galois::CondStatTimer< false > | |
| galois::worklists::ConExtLinkedQueue< T, concurrent > | |
| galois::worklists::ConExtLinkedStack< T, concurrent > | |
| galois::worklists::ConExtListNode< T > | |
| ContainerTy | |
| galois::gdeque< T, ChunkSize, ContainerTy >::Block | |
| CUDA_Context_Common | |
| CUDA_Context_Common_Edges | |
| CUDA_Context_Field< Type > | |
| CUDA_Context_Field_Edges< Type > | |
| CUDA_Context_Shared | |
| CUDA_Context_Shared_Edges | |
| galois::runtime::internal::DAGManagerBase< OptionsTy, Enable > | |
| galois::runtime::internal::Executor< internal::Options< T, FunctionTy, ArgsTy > > | |
| galois::debug< ENABLE > | |
| galois::debug< 0 > | |
| galois::substrate::ThreadPool::dedicated_ty | Type for setting fastmode |
| galois::runtime::DeSerializeBuffer | Buffer for deserialization of data |
| galois::det_id_tag | Indicates the operator has a function that optimizes the generation of unique ids for active elements |
| galois::det_id< T > | |
| galois::det_parallel_break_tag | Indicates the operator has a function that allows a galois::for_each loop to be exited deterministically |
| galois::det_parallel_break< T > | |
| galois::worklists::Deterministic< T > | Deterministic execution |
| galois::DGAccumulator< Ty > | Distributed sum-reducer for getting the sum of some value across multiple hosts |
| galois::DGReduceMax< Ty > | Distributed max-reducer for getting the max of some value across multiple hosts |
| galois::DGReduceMin< Ty > | Distributed min-reducer for getting the min of some value across multiple hosts |
| galois::DGTerminator< Ty > | Distributed sum-reducer for getting the sum of some value across multiple hosts |
| galois::graphs::DistGraph< NodeTy, EdgeTy > | Base DistGraph class that all distributed graphs extend from |
| galois::graphs::MiningGraph< NodeTy, EdgeTy, Partitioner > | |
| galois::graphs::NewDistGraphGeneric< NodeTy, EdgeTy, Partitioner > | |
| galois::DoAll | Helper functor class to invoke galois::do_all on provided args Can be used to choose between galois::do_all and other equivalents such as std::for_each |
| galois::graphs::LC_Morph_Graph< NodeTy, EdgeTy, HasNoLockable, UseNumaAlloc, HasOutOfLineLockable, HasId, FileEdgeTy >::dst_equals | Functor: contains an operator to compare the destination of an edge with a particular node |
| galois::substrate::DummyLock | Dummy Lock implements the lock interface without a lock for serial code |
| galois::substrate::DummyPtrLock< T > | |
| galois::runtime::DistStatManager::HostTotalTypesImpl< _UNUSED >::DummyStat | |
| DynamicBitset | Dynamic Bitset, CUDA version |
| galois::DynamicBitSet | Concurrent dynamically allocated bitset |
| galois::graphs::LC_Morph_Graph< NodeTy, EdgeTy, HasNoLockable, UseNumaAlloc, HasOutOfLineLockable, HasId, FileEdgeTy >::EdgeHolder | Linked list structure holding together blocks of memory that stores edges |
| EdgeMarshalGraph | |
| galois::graphs::OCFileGraph::EdgeReference< EdgeTy > | |
| galois::runtime::ExternalHeapAllocator< Ty, HeapTy > | Keep a reference to an external allocator |
| galois::runtime::ExternalHeapAllocator< char, IterAllocBaseTy > | |
| galois::runtime::ExternalHeapAllocator< T, SerialNumaHeap > | |
| galois::runtime::SerialNumaAllocator< T > | |
| galois::runtime::ExternalHeapAllocator< void, HeapTy > | |
| galois::worklists::ExternalReference< Container, IgnorePushInitial > | |
| galois::substrate::ThreadPool::fastmode_ty | Type for shutting down thread |
| galois::runtime::FieldFlags | Each field has a FieldFlags object that indicates synchronization status of that field |
| galois::runtime::ParaMeter::FIFO_WL< T > | |
| galois::runtime::ParaMeter::LIFO_WL< T > | |
| galois::runtime::ParaMeter::RAND_WL< T > | |
| galois::graphs::FileGraph | Graph that mmaps Galois gr files for access |
| galois::graphs::FileGraphWriter | Simplifies writing graphs |
| galois::ParallelSTL::find_if_helper< InputIterator, Predicate > | |
| galois::runtime::Fixed2DGraphTiledExecutor< Graph, UseExp > | |
| galois::fixed_neighborhood_tag | Indicates that the neighborhood set does not change through out i.e |
| galois::fixed_neighborhood | |
| galois::runtime::FixedSizeAllocator< Ty > | A fixed size block allocator |
| galois::runtime::FixedSizeAllocator< Chunk > | |
| galois::runtime::FixedSizeAllocator< galois::gdeque::Block > | |
| galois::runtime::FixedSizeAllocator< IterationContext > | |
| galois::runtime::FixedSizeAllocator< Node > | |
| galois::runtime::FixedSizeAllocator< void > | |
| galois::FixedSizeBagBase< T, ChunkSize, Concurrent > | Unordered collection of bounded size |
| galois::runtime::FixedSizeHeap | Main scalable allocator in Galois |
| galois::FixedSizeRing< T, ChunkSize > | Ordered collection of bounded size |
| galois::flat_map< _Key, _Tp, _Compare, _Alloc, _Store > | Simple map data structure, based off a single array |
| galois::flat_map< T, std::deque< T >, Compare > | |
| galois::ForEach | |
| galois::runtime::ForEachExecutor< WorkListTy, FunctionTy, ArgsTy > | |
| galois::function_traits< T, Enable > | |
| galois::function_traits< T, typename std::enable_if< has_function_traits< T >(0)>::type > | |
| galois::internal::GAtomicImpl< T, W, CONCURRENT > | Common implementation |
| galois::internal::GAtomicImpl< T, galois::substrate::CacheLineStorage, CONCURRENT > | |
| galois::internal::GAtomicBase< T, galois::substrate::CacheLineStorage, CONCURRENT > | |
| galois::GAtomicPadded< T, CONCURRENT > | Cache-line padded version of GAtomic |
| galois::internal::GAtomicImpl< T, internal::DummyWrapper, CONCURRENT > | |
| galois::internal::GAtomicBase< T, internal::DummyWrapper, CONCURRENT > | |
| galois::GAtomic< T, CONCURRENT > | An atomic wrapper that provides sensible atomic behavior for most primative data types |
| galois::gdeque< T, ChunkSize, ContainerTy > | Like std::deque but use Galois memory management functionality |
| galois::gdeque< T > | |
| galois::gdeque< value_type > | |
| galois::get_trait_type< T, Tuple > | Returns the type associated with the given trait in a tuple |
| galois::GetBegin | Helper functor, returns t.end() |
| galois::GetEnd | Helper functor, returns t.end() |
| galois::runtime::GlobalObject | A class to be inherited from so that all child classes will have a tracked unique ID |
| galois::graphs::GluonEdgeSubstrate< GraphTy > | Gluon communication substrate that handles communication given a user graph |
| galois::graphs::GluonSubstrate< GraphTy > | Gluon communication substrate that handles communication given a user graph |
| galois::gmax< T > | Gmax is the functional form of std::max |
| galois::Reducible< T, gmax< T >, identity_value_min< T > > | |
| galois::GReduceMax< T > | Accumulator for T where accumulation is max |
| galois::gmax< Ty > | |
| galois::Reducible< Ty, gmax< Ty >, identity_value_min< Ty > > | |
| galois::GReduceMax< Ty > | |
| galois::gmin< T > | Gmax is the functional form of std::max |
| galois::Reducible< T, gmin< T >, identity_value_max< T > > | |
| galois::GReduceMin< T > | Accumulator for T where accumulation is min |
| galois::gmin< Ty > | |
| galois::Reducible< Ty, gmin< Ty >, identity_value_max< Ty > > | |
| galois::GReduceMin< Ty > | |
| galois::gslist_base< T, ChunkSize, Concurrent > | |
| has_tt_has_serialize | |
| galois::runtime::has_serialize< T > | Indicates if T has the serialize trait |
| has_tt_is_copyable | |
| galois::runtime::is_copyable< T > | Indicates if T is trivially copyable |
| has_tt_is_segmented | |
| galois::graphs::is_segmented< T > | |
| galois::substrate::HWTopoInfo | |
| galois::identity_value< T, value > | |
| galois::identity_value< bool, false > | |
| galois::Reducible< bool, std::logical_or< bool >, identity_value< bool, false > > | |
| galois::GReduceLogicalOr | Logical OR reduction |
| galois::identity_value< bool, true > | |
| galois::Reducible< bool, std::logical_and< bool >, identity_value< bool, true > > | |
| galois::GReduceLogicalAnd | Logical AND reduction |
| galois::identity_value_max< T > | |
| galois::Reducible< T, gmin< T >, identity_value_max< T > > | |
| galois::identity_value_max< Ty > | |
| galois::Reducible< Ty, gmin< Ty >, identity_value_max< Ty > > | |
| galois::identity_value_min< T > | |
| galois::Reducible< T, gmax< T >, identity_value_min< T > > | |
| galois::identity_value_min< Ty > | |
| galois::Reducible< Ty, gmax< Ty >, identity_value_min< Ty > > | |
| galois::identity_value_zero< T > | |
| galois::Reducible< T, std::plus< T >, identity_value_zero< T > > | |
| galois::GAccumulator< T > | Accumulator for T where accumulation is plus |
| galois::identity_value_zero< size_t > | |
| galois::Reducible< size_t, std::plus< size_t >, identity_value_zero< size_t > > | |
| galois::GAccumulator< size_t > | |
| galois::identity_value_zero< Ty > | |
| galois::Reducible< Ty, std::plus< Ty >, identity_value_zero< Ty > > | |
| galois::GAccumulator< Ty > | |
| galois::identity_value_zero< uint64_t > | |
| galois::Reducible< uint64_t, std::plus< uint64_t >, identity_value_zero< uint64_t > > | |
| galois::GAccumulator< uint64_t > | |
| galois::identity_value_zero< unsigned > | |
| galois::Reducible< unsigned, std::plus< unsigned >, identity_value_zero< unsigned > > | |
| galois::GAccumulator< unsigned > | |
| galois::graphs::DistGraph< NodeTy, EdgeTy >::IdLess< GraphNode, ET > | Used to sort edges in the sort edges function |
| galois::runtime::internal::IdManagerBase< OptionsTy, Enable > | |
| galois::runtime::internal::NewWorkManager< OptionsTy > | |
| galois::runtime::internal::NewWorkManager< internal::Options< T, FunctionTy, ArgsTy > > | |
| galois::runtime::internal::Executor< internal::Options< T, FunctionTy, ArgsTy > > | |
| galois::InsertBag< T, BlockSize > | Unordered collection of elements |
| galois::InsertBag< gNode * > | |
| galois::InsertBag< gNode > | |
| galois::InsertBag< NodeInfo > | |
| galois::intent_to_read_tag | Indicates that the operator uses the intent to read flag |
| galois::intent_to_read | |
| galois::runtime::internal::IntentToReadManagerBase< OptionsTy, Enable > | |
| galois::runtime::internal::Executor< internal::Options< T, FunctionTy, ArgsTy > > | |
| galois::graphs::internal::IntrusiveId< boost::mpl::if_c< HasId, uint32_t, void >::type > | |
| galois::graphs::LC_Linear_Graph< NodeTy, EdgeTy, HasNoLockable, UseNumaAlloc, HasOutOfLineLockable, HasId, FileEdgeTy >::NodeInfo | |
| galois::InvalidBitsetFnTy | A structure representing an empty bitset |
| galois::runtime::is_memory_copyable< T > | Indicates if T is memory copyable |
| galois::runtime::is_serializable< T > | Indicates if T is serializable |
| galois::runtime::iterable< It > | |
| IterationContext | |
| iterator | |
| DynamicBitsetIterator | |
| IdentityIterator | |
| iterator_adaptor | |
| galois::NoDerefIterator< Iterator > | Modify an iterator so that *it == it |
| galois::TwoLevelIteratorA< OuterIter, InnerIter, CategoryOrTraversal, InnerBeginFn, InnerEndFn > | Alternate implementation of ChooseTwoLevelIterator |
| iterator_facade | |
| galois::gdeque< T, ChunkSize, ContainerTy >::Iterator< U > | |
| galois::graphs::LC_InOut_Graph< GraphTy >::in_edge_iterator | |
| galois::InsertBag< T, BlockSize >::Iterator< U > | |
| galois::worklists::ConExtIterator< T > | |
| iterator_traits | |
| galois::TwoLevelFwdIter< Outer, Inner, InnerBegFn, InnerEndFn > | Two-Level forward iterator |
| galois::TwoLevelBiDirIter< Outer, Inner, InnerBegFn, InnerEndFn > | Two-Level bidirectional iterator |
| galois::TwoLevelRandIter< Outer, Inner, InnerBegFn, InnerEndFn > | Two-Level random access iterator |
| galois::IterRange< I > | |
| galois::LargeArray< T > | Large array of objects with proper specialization for void type and supporting various allocation and construction policies |
| galois::LargeArray< char > | |
| galois::LargeArray< EdgeInfo > | |
| galois::LargeArray< EdgeTy > | |
| galois::LargeArray< NodeInfo * > | |
| galois::LargeArray< NodeInfo > | |
| galois::LargeArray< uint32_t > | |
| galois::LargeArray< uint64_t > | |
| galois::LargeArray< void > | Void specialization |
| galois::LazyArray< _Tp, _Size > | This is a container that encapsulates space for a constant size array |
| galois::LazyArray< T, ChunkSize > | |
| galois::LazyObject< T > | Single (uninitialized) object with specialization for void type |
| galois::LazyObject< _Tp > | |
| galois::LazyObject< EdgeTy > | |
| galois::LazyObject< galois::graphs::OCImmutableEdgeGraph::segment_type > | |
| galois::LazyObject< typename WL::value_type > | |
| galois::LazyObject< void > | |
| galois::runtime::LazyRef< T > | LazyRef structure; used to store both a type and an offset to begin saving data into |
| galois::local_state_tag | Indicates the operator has a type that encapsulates state that is passed between the suspension and resumpsion of an operator during deterministic scheduling |
| galois::local_state< T > | |
| galois::graphs::internal::LocalIteratorFeature< false > | |
| galois::graphs::LC_Adaptor_Graph< NodeTy, EdgeTy, DerivedTy, GraphNodeTy, IteratorTy, EdgeIteratorTy, HasNoLockable > | |
| galois::graphs::OCImmutableEdgeGraph< NodeTy, EdgeTy, HasNoLockable, HasOutOfLineLockable > | |
| galois::graphs::LC_CSR_Graph< NodeTy, EdgeTy, true > | |
| galois::graphs::internal::LocalIteratorFeature< UseNumaAlloc > | |
| galois::graphs::LC_CSR_Graph< NodeTy, EdgeTy, HasNoLockable, UseNumaAlloc, HasOutOfLineLockable, FileEdgeTy > | Local computation graph (i.e., graph structure does not change) |
| galois::graphs::LC_CSR_CSC_Graph< NodeTy, EdgeTy, EdgeDataByValue, HasNoLockable, UseNumaAlloc, HasOutOfLineLockable, FileEdgeTy > | An bidirectional LC_CSR_Graph that allows the construction of in-edges from its outedges |
| galois::graphs::LC_CSR_Hypergraph< NodeTy, EdgeTy, HasNoLockable, UseNumaAlloc, HasOutOfLineLockable, FileEdgeTy > | Local computation graph (i.e., graph structure does not change) |
| galois::graphs::LC_InlineEdge_Graph< NodeTy, EdgeTy, HasNoLockable, UseNumaAlloc, HasOutOfLineLockable, HasCompressedNodePtr, FileEdgeTy > | Local computation graph (i.e., graph structure does not change) |
| galois::graphs::LC_Linear_Graph< NodeTy, EdgeTy, HasNoLockable, UseNumaAlloc, HasOutOfLineLockable, HasId, FileEdgeTy > | Local computation graph (i.e., graph structure does not change) |
| galois::runtime::LocalRange< T > | |
| galois::runtime::Lockable | All objects that may be locked (nodes primarily) must inherit from Lockable |
| galois::GChecked< T > | Conflict-checking wrapper for any type |
| galois::GChecked< void > | |
| logical_and | |
| galois::Reducible< bool, std::logical_and< bool >, identity_value< bool, true > > | |
| logical_or | |
| galois::Reducible< bool, std::logical_or< bool >, identity_value< bool, false > > | |
| galois::loopname_tag | Indicate name to appear in statistics |
| galois::loopname | |
| galois::runtime::LoopStatistics< Enabled > | |
| galois::runtime::ForEachExecutor< WorkListTy, FunctionTy, ArgsTy >::ThreadLocalData | |
| galois::runtime::LoopStatistics< false > | |
| galois::substrate::MachineTopoInfo | |
| galois::runtime::MallocHeap | [Example Third Party Allocator] |
| MarshalGraph | |
| galois::runtime::MemUsageTracker | Class that tracks memory usage (mainly of send and receive buffers) |
| galois::runtime::NetworkIO::message | Message structure for sending data across the network |
| galois::MinHeap< T, Cmp, Cont > | |
| galois::MinHeap< T, Cmp > | |
| galois::more_stats_tag | Indicates the operator needs detailed stats Must provide loopname to enable this flag |
| galois::more_stats | |
| galois::runtime::NamedStat< T > | |
| galois::neighborhood_visitor_tag | Indicates the operator has a function that visits the neighborhood of the operator without modifying it |
| galois::neighborhood_visitor< T > | |
| galois::runtime::NetworkInterface | A class that defines functions that a network interface in Galois should have |
| galois::runtime::NetworkIO | Class for the network IO layer which is responsible for doing sends/receives of data |
| NetworkIOMPI | MPI implementation of network IO |
| galois::no_conflicts_tag | Indicates the operator doesn't need abort support |
| galois::no_conflicts | |
| galois::no_pushes_tag | Indicates the operator does not generate new work and push it on the worklist |
| galois::no_pushes | |
| galois::no_stats_tag | Indicates the operator doesn't need its execution stats recorded |
| galois::no_stats | |
| galois::graphs::internal::NodeInfoBaseTypes< NodeTy, HasLockable > | Separate types from definitions to allow incomplete types as NodeTy |
| galois::graphs::internal::NodeInfoBase< NodeTy,!HasNoLockable &&!HasOutOfLineLockable > | |
| galois::graphs::LC_InlineEdge_Graph< NodeTy, EdgeTy, HasNoLockable, UseNumaAlloc, HasOutOfLineLockable, HasCompressedNodePtr, FileEdgeTy >::NodeInfo | |
| galois::graphs::LC_Linear_Graph< NodeTy, EdgeTy, HasNoLockable, UseNumaAlloc, HasOutOfLineLockable, HasId, FileEdgeTy >::NodeInfo | |
| galois::graphs::LC_Morph_Graph< NodeTy, EdgeTy, HasNoLockable, UseNumaAlloc, HasOutOfLineLockable, HasId, FileEdgeTy >::NodeInfo | Class that stores node info (e.g |
| galois::worklists::NoGlobalQueue< T > | |
| noncopyable | |
| galois::graphs::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 |
| galois::graphs::LC_CSR_Graph< NodeTy, EdgeTy, HasNoLockable, UseNumaAlloc, HasOutOfLineLockable, FileEdgeTy > | Local computation graph (i.e., graph structure does not change) |
| galois::graphs::LC_CSR_Hypergraph< NodeTy, EdgeTy, HasNoLockable, UseNumaAlloc, HasOutOfLineLockable, FileEdgeTy > | Local computation graph (i.e., graph structure does not change) |
| galois::graphs::LC_InlineEdge_Graph< NodeTy, EdgeTy, HasNoLockable, UseNumaAlloc, HasOutOfLineLockable, HasCompressedNodePtr, FileEdgeTy > | Local computation graph (i.e., graph structure does not change) |
| galois::graphs::LC_Linear_Graph< NodeTy, EdgeTy, HasNoLockable, UseNumaAlloc, HasOutOfLineLockable, HasId, FileEdgeTy > | Local computation graph (i.e., graph structure does not change) |
| galois::graphs::LC_Morph_Graph< NodeTy, EdgeTy, HasNoLockable, UseNumaAlloc, HasOutOfLineLockable, HasId, FileEdgeTy > | Local computation graph that allows addition of nodes (but not removals) if the maximum degree of a node is known at the time it is added |
| galois::graphs::Morph_SepInOut_Graph< NodeTy, EdgeTy, Directional, InOut, HasNoLockable, SortedNeighbors, FileEdgeTy > | A Graph |
| galois::graphs::MorphGraph< NodeTy, EdgeTy, Directional, InOut, HasNoLockable, SortedNeighbors, FileEdgeTy > | A graph that can have new nodes and edges added to it |
| galois::graphs::MorphHyperGraph< NodeTy, EdgeTy, Directional, InOut, HasNoLockable, SortedNeighbors, FileEdgeTy > | A graph that can have new nodes and edges added to it |
| galois::graphs::OCFileGraph | Like FileGraph but allows partial loading of the graph |
| galois::runtime::LockManagerBase | |
| galois::runtime::SimpleRuntimeContext | |
| galois::runtime::StaticSingleInstance< Derived > | |
| 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::worklists::BulkSynchronous< Container, T, Concurrent > | Bulk-synchronous scheduling |
| galois::worklists::LocalQueue< Global, Local, T > | |
| galois::worklists::OrderedByIntegerMetric< Indexer, Container, BlockPeriod, BSP, T, Index, UseBarrier, UseMonotonic, UseDescending, Concurrent > | Approximate priority scheduling |
| galois::worklists::OrderedList< Compare, T, concurrent > | |
| galois::worklists::OwnerComputes< OwnerFn, Container, T > | |
| galois::worklists::PerThreadChunkMaster< IsLocallyLIFO, ChunkSize, Container, T > | |
| galois::worklists::StealingQueue< InnerWL > | |
| galois::worklists::Wrapper< T, container, popBack > | Simple Container Wrapper worklist (not scalable) |
| galois::graphs::LC_CSR_Graph< NodeTy, EdgeTy, true > | |
| galois::runtime::StaticSingleInstance< PageHeap > | |
| galois::runtime::PageHeap | |
| galois::runtime::StaticSingleInstance< Pow_2_BlockHeap > | |
| galois::runtime::Pow_2_BlockHeap | |
| galois::runtime::StaticSingleInstance< SizedHeapFactory > | |
| galois::runtime::SizedHeapFactory | |
| galois::UserContext< value_type > | |
| galois::runtime::UserContextAccess< value_type > | |
| galois::graphs::OfflineGraph | |
| galois::graphs::OfflineGraphWriter | |
| galois::op_tag | For distributed Galois |
| galois::optional< T > | Galois version of boost::optional |
| galois::optional< galois::graphs::OCImmutableEdgeGraph::segment_type > | |
| galois::optional< typename WL::value_type > | |
| galois::worklists::internal::OrderedByIntegerMetricComparator< Index, UseDescending > | |
| galois::worklists::OrderedByIntegerMetric< Indexer, Container, BlockPeriod, BSP, T, Index, UseBarrier, UseMonotonic, UseDescending, Concurrent > | Approximate priority scheduling |
| galois::worklists::internal::OrderedByIntegerMetricData< T, Index, UseBarrier > | |
| galois::worklists::OrderedByIntegerMetric< Indexer, Container, BlockPeriod, BSP, T, Index, UseBarrier, UseMonotonic, UseDescending, Concurrent > | Approximate priority scheduling |
| galois::graphs::internal::OutOfLineLockableFeature< false &&!HasNoLockable > | |
| galois::graphs::LC_CSR_Graph< NodeTy, EdgeTy, true > | |
| galois::graphs::internal::OutOfLineLockableFeature< HasNoLockable > | |
| galois::graphs::LC_Adaptor_Graph< NodeTy, EdgeTy, DerivedTy, GraphNodeTy, IteratorTy, EdgeIteratorTy, HasNoLockable > | |
| galois::graphs::internal::OutOfLineLockableFeature< HasOutOfLineLockable &&!HasNoLockable > | |
| galois::graphs::LC_CSR_Graph< NodeTy, EdgeTy, HasNoLockable, UseNumaAlloc, HasOutOfLineLockable, FileEdgeTy > | Local computation graph (i.e., graph structure does not change) |
| galois::graphs::LC_CSR_Hypergraph< NodeTy, EdgeTy, HasNoLockable, UseNumaAlloc, HasOutOfLineLockable, FileEdgeTy > | Local computation graph (i.e., graph structure does not change) |
| galois::graphs::LC_InlineEdge_Graph< NodeTy, EdgeTy, HasNoLockable, UseNumaAlloc, HasOutOfLineLockable, HasCompressedNodePtr, FileEdgeTy > | Local computation graph (i.e., graph structure does not change) |
| galois::graphs::LC_Linear_Graph< NodeTy, EdgeTy, HasNoLockable, UseNumaAlloc, HasOutOfLineLockable, HasId, FileEdgeTy > | Local computation graph (i.e., graph structure does not change) |
| galois::graphs::LC_Morph_Graph< NodeTy, EdgeTy, HasNoLockable, UseNumaAlloc, HasOutOfLineLockable, HasId, FileEdgeTy > | Local computation graph that allows addition of nodes (but not removals) if the maximum degree of a node is known at the time it is added |
| galois::graphs::OCImmutableEdgeGraph< NodeTy, EdgeTy, HasNoLockable, HasOutOfLineLockable > | |
| galois::substrate::PaddedLock< concurrent > | PaddedLock is a spinlock |
| galois::worklists::OrderedList< Compare, T, concurrent > | |
| galois::substrate::PaddedLock< Concurrent > | |
| galois::substrate::PaddedLock< false > | |
| galois::substrate::PaddedLock< true > | |
| galois::Pair< T1, T2 > | Struct that contains 2 elements |
| galois::ParallelSTL::pair_dist | |
| galois::parallel_break_tag | Indicates the operator may request the parallel loop to be suspended and a given function run in serial |
| galois::parallel_break | |
| worklists::ParaMeter< T, SCHED > | |
| galois::runtime::ParaMeter::ParaMeterExecutor< T, FunctionTy, ArgsTy > | |
| ParaMeterExecutor | |
| runtime::ForEachExecutor< galois::worklists::ParaMeter< T >, FunctionTy, ArgsTy > | |
| galois::ParallelSTL::partition_helper< RandomAccessIterator, Predicate > | |
| galois::ParallelSTL::partition_helper< RandomAccessIterator, Predicate >::partition_helper_state | |
| galois::graphs::PartitioningScaffold | Default fields and functions all CuSP partitioners use; this is a class to inherit from |
| galois::graphs::CustomMasterAssignment | Policies that use a custom assignment of masters (from the user) |
| FennelP | |
| GingerP | |
| SugarColumnFlipP | |
| SugarP | |
| galois::graphs::ReadMasterAssignment | Policies that use the read assignment of nodes as the masters |
| GenericCVC | |
| GenericCVCColumnFlip | |
| GenericHVC | |
| MiningPolicyDegrees | |
| MiningPolicyNaive | |
| NoCommunication | |
| galois::per_iter_alloc_tag | Indicates the operator may request the access to a per-iteration allocator |
| galois::per_iter_alloc | |
| galois::substrate::ThreadPool::per_signal | Type to switch to dedicated mode |
| galois::substrate::PerBackend | |
| galois::substrate::PerSocketStorage< T > | |
| galois::substrate::PerSocketStorage< cWL > | |
| galois::substrate::PerSocketStorage< pWL > | |
| galois::worklists::PerThreadChunkQueue | |
| galois::worklists::PerThreadChunkStack | |
| galois::PerThreadContainer< Cont_tp > | |
| galois::PerThreadContainer< galois::gdeque< T, ChunkSize > > | |
| galois::PerThreadGdeque< T, ChunkSize > | |
| galois::PerThreadContainer< gstl::template Deque< T > > | |
| galois::PerThreadDeque< T > | |
| galois::PerThreadContainer< gstl::template List< T > > | |
| galois::PerThreadList< T > | |
| galois::PerThreadContainer< gstl::template Map< K, V, C > > | |
| galois::PerThreadMap< K, V, C > | |
| galois::PerThreadContainer< gstl::template PQ< T, C > > | |
| galois::PerThreadMinHeap< T, C > | |
| galois::PerThreadContainer< gstl::template Set< T, C > > | |
| galois::PerThreadSet< T, C > | |
| galois::PerThreadContainer< gstl::template Vector< T > > | |
| galois::PerThreadVector< T > | |
| galois::substrate::PerThreadStorage< T > | |
| galois::substrate::PerThreadStorage< bool > | |
| galois::substrate::PerThreadStorage< BumpHeap< SystemHeap > > | |
| galois::substrate::PerThreadStorage< container_type * > | |
| galois::substrate::PerThreadStorage< galois::graphs::LC_Morph_Graph::EdgeHolder * > | |
| galois::substrate::PerThreadStorage< galois::runtime::ThreadTimer > | |
| galois::substrate::PerThreadStorage< galois::worklists::Wrapper > | |
| galois::substrate::PerThreadStorage< internal::ScalarStatManager< double > > | |
| galois::substrate::PerThreadStorage< internal::ScalarStatManager< int64_t > > | |
| galois::substrate::PerThreadStorage< internal::ScalarStatManager< Str > > | |
| galois::substrate::PerThreadStorage< internal::ScalarStatManager< T > > | |
| galois::substrate::PerThreadStorage< Lock_ty > | |
| galois::substrate::PerThreadStorage< lWLTy > | |
| galois::substrate::PerThreadStorage< PerThread > | |
| galois::substrate::PerThreadStorage< size_t > | |
| galois::substrate::PerThreadStorage< SourceHeap > | |
| galois::substrate::PerThreadStorage< state > | |
| galois::substrate::PerThreadStorage< std::pair< Chunk *, Chunk * > > | |
| galois::substrate::PerThreadStorage< std::pair< header *, header * > > | |
| galois::substrate::PerThreadStorage< std::pair< InnerWL, unsigned > > | |
| galois::substrate::PerThreadStorage< ThreadData > | |
| galois::substrate::PerThreadStorage< TLD > | |
| galois::substrate::PerThreadStorage< TMap > | |
| galois::substrate::PerThreadStorage< Ty > | |
| galois::substrate::PerThreadStorage< uint64_t > | |
| galois::substrate::PerThreadStorage< unsigned > | |
| galois::runtime::PerThreadTimer< false > | |
| plus | |
| galois::Reducible< size_t, std::plus< size_t >, identity_value_zero< size_t > > | |
| galois::Reducible< T, std::plus< T >, identity_value_zero< T > > | |
| galois::Reducible< Ty, std::plus< Ty >, identity_value_zero< Ty > > | |
| galois::Reducible< uint64_t, std::plus< uint64_t >, identity_value_zero< uint64_t > > | |
| galois::Reducible< unsigned, std::plus< unsigned >, identity_value_zero< unsigned > > | |
| galois::PODResizeableArray< _Tp > | This is a container that encapsulates a resizeable array of plain-old-datatype (POD) elements |
| galois::PODResizeableArray< galois::galois::CopyableAtomic< uint64_t > > | |
| galois::PODResizeableArray< uint8_t > | |
| galois::PODResizeableArray< unsigned int > | |
| galois::runtime::Pow_2_BlockAllocator< Ty > | |
| galois::runtime::Pow_2_BlockAllocator< void > | |
| galois::gslist_base< T, ChunkSize, Concurrent >::promise_to_dealloc | Tag for methods that depend on user to deallocate memory, although gslist will destroy elements |
| galois::substrate::PtrLock< T > | PtrLock is a spinlock and a pointer |
| galois::substrate::PtrLock< Derived > | |
| galois::substrate::PtrLock< galois::runtime::LockManagerBase > | |
| galois::substrate::PtrLock< galois::worklists::ChunkHeader > | |
| galois::substrate::PtrLock< PageHeap > | |
| galois::substrate::PtrLock< Pow_2_BlockHeap > | |
| galois::substrate::PtrLock< SizedHeapFactory > | |
| galois::graphs::read_default_graph_tag | |
| galois::graphs::read_lc_inout_graph_tag | |
| galois::graphs::read_oc_immutable_edge_graph_tag | |
| galois::graphs::read_with_aux_first_graph_tag | |
| galois::graphs::read_with_aux_graph_tag | |
| galois::graphs::ReadGraphConstructEdgesFrom< GraphTy, Aux > | |
| galois::graphs::ReadGraphConstructFrom< GraphTy > | |
| galois::graphs::ReadGraphConstructInEdgesFrom< GraphTy, Aux > | |
| galois::graphs::ReadGraphConstructNodesFrom< GraphTy, Aux > | |
| galois::graphs::ReadGraphConstructOutEdgesFrom< GraphTy, Aux > | |
| galois::runtime::SerialNumaAllocator< T >::rebind< Other > | |
| galois::runtime::FixedSizeAllocator< void >::rebind< Other > | |
| galois::runtime::Pow_2_BlockAllocator< void >::rebind< Other > | |
| galois::runtime::ExternalHeapAllocator< void, HeapTy >::rebind< Other > | |
| galois::runtime::FixedSizeAllocator< Ty >::rebind< Other > | |
| galois::runtime::Pow_2_BlockAllocator< Ty >::rebind< Other > | |
| galois::runtime::ExternalHeapAllocator< Ty, HeapTy >::rebind< Other > | |
| galois::runtime::reiterator< WLTy, IterTy, Enable > | |
| galois::runtime::reiterator< WLTy, IterTy, typename std::enable_if< has_with_iterator< WLTy >(0)>::type > | |
| galois::MinHeap< T, Cmp, Cont >::RevCmp | |
| galois::runtime::RunningMax< T > | |
| galois::runtime::RunningMin< T > | |
| galois::runtime::RunningSum< T > | |
| galois::runtime::RunningVec< T > | |
| galois::runtime::ForEachExecutor< WorkListTy, FunctionTy, ArgsTy >::RunQueueState< WL > | |
| galois::graphs::OCImmutableEdgeGraph< NodeTy, EdgeTy, HasNoLockable, HasOutOfLineLockable >::segment_type | |
| galois::internal::SerCont< T, C > | |
| galois::SerFIFO< T, C > | |
| galois::SerStack< T, C > | |
| galois::runtime::SerializeBuffer | Buffer for serialization of data |
| galois::runtime::SerialNumaHeap | |
| galois::substrate::SharedMem | |
| galois::runtime::SharedMem< SM > | |
| galois::runtime::SharedMem< runtime::DistStatManager > | |
| galois::DistMemSys | Explicit class to initialize the Galois Runtime |
| galois::runtime::SharedMem< runtime::StatManager > | |
| galois::SharedMemSys | SharedMemSys is an explicit class to initialize the Galois runtime |
| galois::substrate::ThreadPool::shutdown_ty | |
| galois::substrate::SimpleLock | SimpleLock is a spinlock |
| galois::LazyObject< void >::size_of | |
| galois::LargeArray< T >::size_of | |
| galois::LazyObject< T >::size_of | |
| galois::LargeArray< void >::size_of | |
| galois::ParallelSTL::sort_helper< Compare > | |
| SourceHeap | |
| galois::runtime::AddHeader< void *, SourceHeap > | |
| galois::runtime::OwnerTaggedHeap< SourceHeap > | Allow looking up parent heap pointers |
| galois::runtime::AddHeader< Header, SourceHeap > | Add a header to objects |
| galois::runtime::BlockHeap< ElemSize, SourceHeap > | |
| galois::runtime::BumpHeap< SourceHeap > | This implements a bump pointer though chunks of memory |
| galois::runtime::BumpWithMallocHeap< 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::FreeListHeap< SourceHeap > | Maintain a freelist |
| galois::runtime::LockedHeap< SourceHeap > | Apply a lock to a heap |
| galois::runtime::SelfLockFreeListHeap< SourceHeap > | Maintain a freelist using a lock which doesn't cover SourceHeap |
| galois::runtime::ZeroOut< SourceHeap > | |
| galois::graphs::SpatialTree2d< T > | Stores sets of objects at specific spatial coordinates in a quad tree |
| galois::runtime::SpecificRange< IterTy > | SpecificRange is a range type where a threads range is specified by an an int array that tells you where each thread should begin its iteration |
| galois::worklists::StableIterator< Steal, Container, Iterator > | Low-overhead worklist when initial range is not invalidated by the operator |
| galois::runtime::StandardRange< IterTy > | |
| galois::runtime::internal::StateManagerBase< OptionsTy, Enable > | |
| galois::runtime::internal::Executor< internal::Options< T, FunctionTy, ArgsTy > > | |
| galois::substrate::StaticInstance< T > | |
| galois::runtime::StatManager | |
| galois::runtime::DistStatManager | Class responsible for tracking all statistics of a running distributed Galois program and reporting them at the end of program execution |
| galois::runtime::StatRecvHelper | |
| StatsFileManager | |
| galois::runtime::StatTotal | |
| galois::StdForEach | Helper functor to invoke std::for_each with the same interface as galois::do_all |
| galois::steal_tag | Indicate whetherlink do_all()} loops should perform work-stealing |
| galois::steal | |
| galois::runtime::ParaMeter::StepStatsBase | |
| galois::runtime::ParaMeter::OrderedStepStats | |
| galois::runtime::ParaMeter::UnorderedStepStats | |
| galois::StrictObject< T > | Single object with specialization for void type |
| galois::StrictObject< EdgeTy > | |
| galois::graphs::EdgeSortValue< GraphNode, EdgeTy > | Proxy object for internal EdgeSortReference |
| galois::StrictObject< void > | |
| galois::gstl::StrMaker< T > | |
| galois::gstl::StrMaker< const char * > | |
| galois::gstl::StrMaker< std::string > | |
| galois::gstl::StrMaker< Str > | |
| galois::runtime::SystemHeap | This is the base source of memory for all allocators |
| galois::runtime::FreeListHeap< galois::runtime::SystemHeap > | |
| galois::runtime::BumpWithMallocHeap< galois::runtime::FreeListHeap< galois::runtime::SystemHeap > > | |
| galois::runtime::ForEachExecutor< WorkListTy, FunctionTy, ArgsTy >::T1 | |
| galois::runtime::ForEachExecutor< WorkListTy, FunctionTy, ArgsTy >::T2 | |
| galois::substrate::TerminationDetection | |
| galois::runtime::ForEachExecutor< WorkListTy, FunctionTy, ArgsTy >::ThreadLocalBasics | |
| galois::runtime::ForEachExecutor< WorkListTy, FunctionTy, ArgsTy >::ThreadLocalData | |
| galois::substrate::ThreadPool | |
| galois::runtime::ThreadPrivateHeap< SourceHeap > | [Example Third Party Allocator] |
| galois::runtime::ThreadPrivateHeap< BumpHeap< SystemHeap > > | |
| galois::runtime::VariableSizeHeap | Scalable variable-size allocations |
| galois::substrate::ThreadRWlock | |
| galois::ThreadSafeMinHeap< T, Cmp > | Thread-safe min heap |
| galois::ThreadSafeOrderedSet< T, Cmp, Alloc > | Thread-safe ordered set |
| galois::runtime::ThreadTimer | |
| galois::runtime::ThreadTimers | |
| galois::runtime::PerThreadTimer< enabled > | |
| galois::runtime::PerThreadTimer< MORE_STATS > | |
| galois::substrate::ThreadTopoInfo | |
| galois::TimeAccumulator | A multi-start time accumulator |
| galois::StatTimer | Galois Timer that automatically reports stats upon destruction Provides statistic interface around timer |
| galois::CondStatTimer< Enable > | |
| galois::Timer | A simple timer |
| galois::trait_has_svalue< T, V > | |
| galois::trait_has_type< T > | |
| galois::local_state< T > | |
| galois::s_wl< T, Args > | |
| galois::trait_has_type< bool > | |
| galois::fixed_neighborhood | |
| galois::intent_to_read | |
| galois::more_stats | |
| galois::no_conflicts | |
| galois::no_pushes | |
| galois::no_stats | |
| galois::parallel_break | |
| galois::per_iter_alloc | |
| galois::steal | |
| galois::trait_has_value< T > | |
| galois::det_id< T > | |
| galois::det_parallel_break< T > | |
| galois::neighborhood_visitor< T > | |
| galois::trait_has_value< const char * > | |
| galois::loopname | |
| galois::trait_has_value< unsigned > | |
| galois::chunk_size< SZ > | Specify chunk size for do_all_coupled & do_all_choice at compile time or at runtime |
| galois::TupleOfThree< T1, T2, T3 > | Struct that contains 3 elements |
| galois::TwoLevelIterBase< Outer, Inner, InnerBegFn, InnerEndFn > | Common functionality of TwoLevelIterators |
| galois::TwoLevelFwdIter< Outer, Inner, InnerBegFn, InnerEndFn > | Two-Level forward iterator |
| type | |
| galois::graphs::LC_InOut_Graph< GraphTy > | Modify a LC_Graph to have in and out edges |
| type | |
| galois::graphs::internal::NodeInfoBase< NodeTy,!HasNoLockable &&!HasOutOfLineLockable > | |
| unary_function | |
| galois::graphs::LC_Morph_Graph< NodeTy, EdgeTy, HasNoLockable, UseNumaAlloc, HasOutOfLineLockable, HasId, FileEdgeTy >::makeGraphNode | Functor that returns pointers to NodeInfo objects given references |
| galois::worklists::DummyIndexer< T > | |
| galois::UnionFindNode< T > | Intrusive union-find implementation |
| galois::UnionFindNode< ReaderContext > | |
| galois::WhileQ< Q > | |
| galois::runtime::internal::WindowManagerBase< OptionsTy, Enable > | |
| galois::runtime::internal::Executor< internal::Options< T, FunctionTy, ArgsTy > > | |
| galois::worklists::OrderedByIntegerMetric< Indexer, Container, BlockPeriod, BSP, T, Index, UseBarrier, UseMonotonic, UseDescending, Concurrent >::with_back_scan_prevention< _bsp > | |
| galois::worklists::OrderedByIntegerMetric< Indexer, Container, BlockPeriod, BSP, T, Index, UseBarrier, UseMonotonic, UseDescending, Concurrent >::with_barrier< _use_barrier > | |
| galois::worklists::OrderedByIntegerMetric< Indexer, Container, BlockPeriod, BSP, T, Index, UseBarrier, UseMonotonic, UseDescending, Concurrent >::with_block_period< _period > | |
| galois::graphs::LC_InlineEdge_Graph< NodeTy, EdgeTy, HasNoLockable, UseNumaAlloc, HasOutOfLineLockable, HasCompressedNodePtr, FileEdgeTy >::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::worklists::StableIterator< Steal, Container, Iterator >::with_container< _container > | |
| galois::worklists::OrderedByIntegerMetric< Indexer, Container, BlockPeriod, BSP, T, Index, UseBarrier, UseMonotonic, UseDescending, Concurrent >::with_container< _container > | |
| galois::worklists::OwnerComputes< OwnerFn, Container, T >::with_container< _container > | |
| galois::worklists::OrderedByIntegerMetric< Indexer, Container, BlockPeriod, BSP, T, Index, UseBarrier, UseMonotonic, UseDescending, Concurrent >::with_descending< _use_descending > | |
| galois::graphs::MorphGraph< NodeTy, EdgeTy, Directional, InOut, HasNoLockable, SortedNeighbors, FileEdgeTy >::with_directional< _directional > | Struct used to define directionality of the graph |
| galois::graphs::Morph_SepInOut_Graph< NodeTy, EdgeTy, Directional, InOut, HasNoLockable, SortedNeighbors, FileEdgeTy >::with_directional< _directional > | |
| galois::graphs::MorphHyperGraph< NodeTy, EdgeTy, Directional, InOut, HasNoLockable, SortedNeighbors, FileEdgeTy >::with_directional< _directional > | Struct used to define directionality of the graph |
| galois::graphs::LC_Morph_Graph< NodeTy, EdgeTy, HasNoLockable, UseNumaAlloc, HasOutOfLineLockable, HasId, FileEdgeTy >::with_edge_data< _edge_data > | Struct used to define the type of edge data through the template parameter |
| galois::graphs::Morph_SepInOut_Graph< NodeTy, EdgeTy, Directional, InOut, HasNoLockable, SortedNeighbors, FileEdgeTy >::with_edge_data< _edge_data > | |
| galois::graphs::LC_InlineEdge_Graph< NodeTy, EdgeTy, HasNoLockable, UseNumaAlloc, HasOutOfLineLockable, HasCompressedNodePtr, FileEdgeTy >::with_edge_data< _edge_data > | |
| galois::graphs::MorphHyperGraph< NodeTy, EdgeTy, Directional, InOut, HasNoLockable, SortedNeighbors, FileEdgeTy >::with_edge_data< _edge_data > | Struct used to define the type of edge data in the graph |
| galois::graphs::LC_CSR_Graph< NodeTy, EdgeTy, HasNoLockable, UseNumaAlloc, HasOutOfLineLockable, FileEdgeTy >::with_edge_data< _edge_data > | |
| galois::graphs::MorphGraph< NodeTy, EdgeTy, Directional, InOut, HasNoLockable, SortedNeighbors, FileEdgeTy >::with_edge_data< _edge_data > | Struct used to define the type of edge data in the graph |
| galois::graphs::OCImmutableEdgeGraph< NodeTy, EdgeTy, HasNoLockable, HasOutOfLineLockable >::with_edge_data< _edge_data > | |
| galois::graphs::LC_CSR_Hypergraph< NodeTy, EdgeTy, HasNoLockable, UseNumaAlloc, HasOutOfLineLockable, FileEdgeTy >::with_edge_data< _edge_data > | |
| galois::graphs::LC_InOut_Graph< GraphTy >::with_edge_data< _edge_data > | |
| galois::graphs::LC_Linear_Graph< NodeTy, EdgeTy, HasNoLockable, UseNumaAlloc, HasOutOfLineLockable, HasId, FileEdgeTy >::with_edge_data< _edge_data > | |
| galois::graphs::LC_CSR_Hypergraph< NodeTy, EdgeTy, HasNoLockable, UseNumaAlloc, HasOutOfLineLockable, FileEdgeTy >::with_file_edge_data< _file_edge_data > | |
| galois::graphs::MorphHyperGraph< NodeTy, EdgeTy, Directional, InOut, HasNoLockable, SortedNeighbors, FileEdgeTy >::with_file_edge_data< _file_edge_data > | Struct used to define the type of file edge data in the graph |
| galois::graphs::Morph_SepInOut_Graph< NodeTy, EdgeTy, Directional, InOut, HasNoLockable, SortedNeighbors, FileEdgeTy >::with_file_edge_data< _file_edge_data > | |
| galois::graphs::LC_InlineEdge_Graph< NodeTy, EdgeTy, HasNoLockable, UseNumaAlloc, HasOutOfLineLockable, HasCompressedNodePtr, FileEdgeTy >::with_file_edge_data< _file_edge_data > | |
| galois::graphs::MorphGraph< NodeTy, EdgeTy, Directional, InOut, HasNoLockable, SortedNeighbors, FileEdgeTy >::with_file_edge_data< _file_edge_data > | Struct used to define the type of file edge data in the graph |
| galois::graphs::LC_Linear_Graph< NodeTy, EdgeTy, HasNoLockable, UseNumaAlloc, HasOutOfLineLockable, HasId, FileEdgeTy >::with_file_edge_data< _file_edge_data > | |
| galois::graphs::LC_CSR_Graph< NodeTy, EdgeTy, HasNoLockable, UseNumaAlloc, HasOutOfLineLockable, FileEdgeTy >::with_file_edge_data< _file_edge_data > | |
| galois::graphs::LC_Morph_Graph< NodeTy, EdgeTy, HasNoLockable, UseNumaAlloc, HasOutOfLineLockable, HasId, FileEdgeTy >::with_file_edge_data< _file_edge_data > | Struct used to define the type of file edge data through the template parameter |
| galois::graphs::LC_CSR_Hypergraph< NodeTy, EdgeTy, HasNoLockable, UseNumaAlloc, HasOutOfLineLockable, FileEdgeTy >::with_id< _has_id > | |
| galois::graphs::LC_CSR_Graph< NodeTy, EdgeTy, HasNoLockable, UseNumaAlloc, HasOutOfLineLockable, FileEdgeTy >::with_id< _has_id > | |
| galois::graphs::OCImmutableEdgeGraph< NodeTy, EdgeTy, HasNoLockable, HasOutOfLineLockable >::with_id< _has_id > | |
| galois::graphs::LC_InlineEdge_Graph< NodeTy, EdgeTy, HasNoLockable, UseNumaAlloc, HasOutOfLineLockable, HasCompressedNodePtr, FileEdgeTy >::with_id< _has_id > | |
| galois::graphs::LC_Linear_Graph< NodeTy, EdgeTy, HasNoLockable, UseNumaAlloc, HasOutOfLineLockable, HasId, FileEdgeTy >::with_id< _has_id > | |
| galois::graphs::LC_Morph_Graph< NodeTy, EdgeTy, HasNoLockable, UseNumaAlloc, HasOutOfLineLockable, HasId, FileEdgeTy >::with_id< _has_id > | Struct that allows activation of the HasId template parameter Example: using Graph = LC_Morph_Graph::with_id<true> defines LC_Morph_Graph with HasId = true |
| galois::worklists::OwnerComputes< OwnerFn, Container, T >::with_indexer< _indexer > | |
| galois::worklists::OrderedByIntegerMetric< Indexer, Container, BlockPeriod, BSP, T, Index, UseBarrier, UseMonotonic, UseDescending, Concurrent >::with_indexer< _indexer > | |
| galois::worklists::StableIterator< Steal, Container, Iterator >::with_iterator< _iterator > | |
| galois::worklists::OrderedByIntegerMetric< Indexer, Container, BlockPeriod, BSP, T, Index, UseBarrier, UseMonotonic, UseDescending, Concurrent >::with_monotonic< _use_monotonic > | |
| galois::graphs::Morph_SepInOut_Graph< NodeTy, EdgeTy, Directional, InOut, HasNoLockable, SortedNeighbors, FileEdgeTy >::with_no_lockable< _has_no_lockable > | If true, do not use abstract locks in graph |
| galois::graphs::LC_Adaptor_Graph< NodeTy, EdgeTy, DerivedTy, GraphNodeTy, IteratorTy, EdgeIteratorTy, HasNoLockable >::with_no_lockable< _has_no_lockable > | If true, do not use abstract locks in graph |
| galois::graphs::LC_Linear_Graph< NodeTy, EdgeTy, HasNoLockable, UseNumaAlloc, HasOutOfLineLockable, HasId, FileEdgeTy >::with_no_lockable< _has_no_lockable > | |
| galois::graphs::LC_CSR_Hypergraph< NodeTy, EdgeTy, HasNoLockable, UseNumaAlloc, HasOutOfLineLockable, FileEdgeTy >::with_no_lockable< _has_no_lockable > | If true, do not use abstract locks in graph |
| galois::graphs::OCImmutableEdgeGraph< NodeTy, EdgeTy, HasNoLockable, HasOutOfLineLockable >::with_no_lockable< _has_no_lockable > | |
| galois::graphs::LC_CSR_Graph< NodeTy, EdgeTy, HasNoLockable, UseNumaAlloc, HasOutOfLineLockable, FileEdgeTy >::with_no_lockable< _has_no_lockable > | If true, do not use abstract locks in graph |
| galois::graphs::LC_InlineEdge_Graph< NodeTy, EdgeTy, HasNoLockable, UseNumaAlloc, HasOutOfLineLockable, HasCompressedNodePtr, FileEdgeTy >::with_no_lockable< _has_no_lockable > | |
| galois::graphs::LC_Morph_Graph< NodeTy, EdgeTy, HasNoLockable, UseNumaAlloc, HasOutOfLineLockable, HasId, FileEdgeTy >::with_no_lockable< _has_no_lockable > | Struct used to define the HasNoLockable template parameter |
| galois::graphs::MorphGraph< NodeTy, EdgeTy, Directional, InOut, HasNoLockable, SortedNeighbors, FileEdgeTy >::with_no_lockable< _has_no_lockable > | Struct used to define the HasNoLockable template parameter as a type in the struct |
| galois::graphs::MorphHyperGraph< NodeTy, EdgeTy, Directional, InOut, HasNoLockable, SortedNeighbors, FileEdgeTy >::with_no_lockable< _has_no_lockable > | Struct used to define the HasNoLockable template parameter as a type in the struct |
| galois::graphs::MorphGraph< NodeTy, EdgeTy, Directional, InOut, HasNoLockable, SortedNeighbors, FileEdgeTy >::with_node_data< _node_data > | Struct used to define the type of node data in the graph |
| galois::graphs::Morph_SepInOut_Graph< NodeTy, EdgeTy, Directional, InOut, HasNoLockable, SortedNeighbors, FileEdgeTy >::with_node_data< _node_data > | |
| galois::graphs::OCImmutableEdgeGraph< NodeTy, EdgeTy, HasNoLockable, HasOutOfLineLockable >::with_node_data< _node_data > | |
| galois::graphs::LC_InOut_Graph< GraphTy >::with_node_data< _node_data > | |
| galois::graphs::LC_CSR_Graph< NodeTy, EdgeTy, HasNoLockable, UseNumaAlloc, HasOutOfLineLockable, FileEdgeTy >::with_node_data< _node_data > | |
| galois::graphs::MorphHyperGraph< NodeTy, EdgeTy, Directional, InOut, HasNoLockable, SortedNeighbors, FileEdgeTy >::with_node_data< _node_data > | Struct used to define the type of node data in the graph |
| galois::graphs::LC_CSR_Hypergraph< NodeTy, EdgeTy, HasNoLockable, UseNumaAlloc, HasOutOfLineLockable, FileEdgeTy >::with_node_data< _node_data > | |
| galois::graphs::LC_Linear_Graph< NodeTy, EdgeTy, HasNoLockable, UseNumaAlloc, HasOutOfLineLockable, HasId, FileEdgeTy >::with_node_data< _node_data > | |
| galois::graphs::LC_InlineEdge_Graph< NodeTy, EdgeTy, HasNoLockable, UseNumaAlloc, HasOutOfLineLockable, HasCompressedNodePtr, FileEdgeTy >::with_node_data< _node_data > | |
| galois::graphs::LC_Morph_Graph< NodeTy, EdgeTy, HasNoLockable, UseNumaAlloc, HasOutOfLineLockable, HasId, FileEdgeTy >::with_node_data< _node_data > | Struct used to define the type of node data through the template parameter |
| galois::graphs::LC_InOut_Graph< GraphTy >::with_node_data< void > | |
| galois::graphs::LC_InlineEdge_Graph< NodeTy, EdgeTy, HasNoLockable, UseNumaAlloc, HasOutOfLineLockable, HasCompressedNodePtr, FileEdgeTy >::with_numa_alloc< _use_numa_alloc > | |
| galois::graphs::LC_CSR_Hypergraph< NodeTy, EdgeTy, HasNoLockable, UseNumaAlloc, HasOutOfLineLockable, FileEdgeTy >::with_numa_alloc< _use_numa_alloc > | If true, use NUMA-aware graph allocation |
| galois::graphs::OCImmutableEdgeGraph< NodeTy, EdgeTy, HasNoLockable, HasOutOfLineLockable >::with_numa_alloc< _use_numa_alloc > | |
| galois::graphs::LC_Morph_Graph< NodeTy, EdgeTy, HasNoLockable, UseNumaAlloc, HasOutOfLineLockable, HasId, FileEdgeTy >::with_numa_alloc< _use_numa_alloc > | Struct used to define the UseNumaAlloc template parameter |
| galois::graphs::LC_CSR_Graph< NodeTy, EdgeTy, HasNoLockable, UseNumaAlloc, HasOutOfLineLockable, FileEdgeTy >::with_numa_alloc< _use_numa_alloc > | If true, use NUMA-aware graph allocation; otherwise, use NUMA interleaved allocation |
| galois::graphs::LC_Linear_Graph< NodeTy, EdgeTy, HasNoLockable, UseNumaAlloc, HasOutOfLineLockable, HasId, FileEdgeTy >::with_numa_alloc< _use_numa_alloc > | |
| galois::graphs::LC_CSR_Graph< NodeTy, EdgeTy, HasNoLockable, UseNumaAlloc, HasOutOfLineLockable, FileEdgeTy >::with_out_of_line_lockable< _has_out_of_line_lockable > | If true, store abstract locks separate from nodes |
| galois::graphs::LC_InlineEdge_Graph< NodeTy, EdgeTy, HasNoLockable, UseNumaAlloc, HasOutOfLineLockable, HasCompressedNodePtr, FileEdgeTy >::with_out_of_line_lockable< _has_out_of_line_lockable > | |
| galois::graphs::LC_CSR_Hypergraph< NodeTy, EdgeTy, HasNoLockable, UseNumaAlloc, HasOutOfLineLockable, FileEdgeTy >::with_out_of_line_lockable< _has_out_of_line_lockable > | If true, store abstract locks separate from nodes |
| galois::graphs::LC_Linear_Graph< NodeTy, EdgeTy, HasNoLockable, UseNumaAlloc, HasOutOfLineLockable, HasId, FileEdgeTy >::with_out_of_line_lockable< _has_out_of_line_lockable > | |
| galois::graphs::LC_Morph_Graph< NodeTy, EdgeTy, HasNoLockable, UseNumaAlloc, HasOutOfLineLockable, HasId, FileEdgeTy >::with_out_of_line_lockable< _has_out_of_line_lockable > | Struct used to define the HasOutOfLineLockable template parameter |
| galois::graphs::OCImmutableEdgeGraph< NodeTy, EdgeTy, HasNoLockable, HasOutOfLineLockable >::with_out_of_line_lockable< _has_out_of_line_lockable > | |
| galois::graphs::MorphHyperGraph< NodeTy, EdgeTy, Directional, InOut, HasNoLockable, SortedNeighbors, FileEdgeTy >::with_sorted_neighbors< _sorted_neighbors > | Struct used to define if neighbors are sorted or not in the graph |
| galois::graphs::Morph_SepInOut_Graph< NodeTy, EdgeTy, Directional, InOut, HasNoLockable, SortedNeighbors, FileEdgeTy >::with_sorted_neighbors< _sorted_neighbors > | |
| galois::graphs::MorphGraph< NodeTy, EdgeTy, Directional, InOut, HasNoLockable, SortedNeighbors, FileEdgeTy >::with_sorted_neighbors< _sorted_neighbors > | Struct used to define if neighbors are sorted or not in the graph |
| galois::worklists::StableIterator< Steal, Container, Iterator >::with_steal< _steal > | |
| galois::wl_tag | Indicates worklist to use |
| galois::s_wl< T, Args > | |
| Bases | |
| galois::runtime::AggregStat< T, Bases > | |
| IdFunc | |
| galois::Reducible< T, MergeFunc, IdFunc > | A Reducible stores per-thread values of a variable of type T and merges multiple values into one |
| MergeFunc | |
| galois::Reducible< T, MergeFunc, IdFunc > | A Reducible stores per-thread values of a variable of type T and merges multiple values into one |
1.8.5 
