Class List

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

Generated on 12 Apr 2013 for Galois by  doxygen 1.6.1