| SizeThreadHeap< Super >::_st | |
| AbstractCoordConn< SPD, NODES_PER_ELEM, TOPO > | Common functionality and data structures |
| AbstractGeom< SPD > | Base class with common functionality |
| spanningtree::main::AbstractMain | |
| AbstractNode | |
| AbstractSimObject | |
| GaloisRuntime::WorkList::AbstractWorkList< T, concurrent > | |
| spanningtree::main::AbstractMain::ActivityBody | |
| AdaptHeap | Maintains dictionary entries through freed objects |
| HL::AdaptHeap< Dictionary, SuperHeap > | |
| GaloisRuntime::MM::AddHeader< Header, SourceHeap > | Add a header to objects |
| AddHeaderHeap | |
| Hoard::AddHeaderHeap< SuperblockType, SuperblockSize, SuperHeap > | |
| HL::AddHeap< Add, Super > | |
| anonymous_namespace{Barneshut.cpp}::AdvanceBodies | |
| HL::AlignedChunk< chunkSize, slotSize > | |
| HL::AlignedChunkHeap< maxFree, chunkSize, slotSize, Super > | |
| HL::AlignedChunkHeapFoo< maxFree, chunkSize, slotSize, Super > | |
| Hoard::AlignedMmap< Alignment_, LockType > | Route requests to the one aligned mmap instance |
| Hoard::AlignedMmapInstance< Alignment_ > | Memory allocated from here is aligned with respect to Alignment |
| HL::AlignedSlotHeap< chunkSize, slotSize, Super > | |
| Hoard::AlignedSuperblockHeap< TheLockType, SuperblockSize > | |
| Hoard::AlignedSuperblockHeapHelper< TheLockType, SuperblockSize > | |
| HL::AlignHeap< chunkSize, Super > | |
| alignmentOf< T >::alignmentFinder | |
| alignmentOf< T > | |
| AllocatedHeap< SuperHeap > | |
| AOFFHeap< SuperHeap, FreeThreshold >::allocatedObject | |
| HL::ObjectManagerBase< SuperHeap >::AllocatedObject | |
| Galois::Allocator< Ty > | |
| Galois::Allocator< void > | |
| AND2 | And with two inputs |
| HL::ANSIWrapper< SuperHeap > | |
| AOFFHeap< SuperHeap, FreeThreshold > | |
| GaloisRuntime::API_Break< false > | |
| GaloisRuntime::API_Break< true > | |
| GaloisRuntime::API_PerIter< false > | |
| GaloisRuntime::API_PerIter< true > | |
| GaloisRuntime::API_Push< false, WLT > | |
| GaloisRuntime::API_Push< true, WLT > | |
| GaloisRuntime::WorkList::Experimental::ApproxOrderByIntegerMetric< T, Indexer, ContainerTy, concurrent > | |
| HL::ZoneHeap< Super, ChunkSize >::Arena | |
| Hoard::Array< N, T > | |
| ArraySet< T > | |
| Galois::GReduceAverage< T >::AVG | |
| AVI | AVI.h DG++ |
| AVIabstractMain | Common functionality for different versions and algorithms |
| AVIComparator | A comparator class for comparing two AVI objects according to their time stamps |
| AVIorderedSerial | Serial ordered AVI algorithm |
| AVIReverseComparator | Since C++ priority_queue is a max heap, this comparator allows using C++ priority_queue as a min heap by inverting the comparison |
| AVIunordered | Unordered AVI algorithm uses two key data structures |
| AVIunorderedNoLock | AVI unordered algorithm that uses atomic integers and no abstract locks |
| BaseEvent< S, A > | The Class BaseEvent |
| BaseHeap | |
| BaseHoardManager< SuperblockType_ > | The top of the hoard manager hierarchy |
| BaseLogicGate | |
| BaseNullHeap | |
| BaseOneInputGate | |
| BaseResidue | Base class for common functionality |
| BaseTwoInputGate | |
| BasisFunctions | BasisFunctions.h DG++ |
| BasisFunctionsProvided | BasisFunctionsProvided: set of basis functions and derivatives at the quadrature points provided directly at construction |
| BasisFunctionsProvidedExternalQuad | BasisFunctionsProvided.h DG++ |
| BatchHeap< BatchNumber, SuperHeap > | |
| BigChunk< chunkSize, slotSize, Super > | |
| Hoard::BigHeap | |
| BinHeap< Bins, NumBins, Super > | |
| HL::bins< Header, 16384 > | |
| HL::bins< Header, 4096 > | |
| HL::bins< Header, 65536 > | |
| HL::bins< Header, 8192 > | |
| HL::BitIndex | |
| BitString< N > | |
| GaloisRuntime::MM::BlockAlloc< ElemSize, SourceHeap >::Block | |
| GaloisRuntime::MM::SimpleBumpPtr< SourceHeap >::Block | |
| GaloisRuntime::MM::BlockAlloc< ElemSize, SourceHeap >::Block_basic | |
| GaloisRuntime::MM::BlockAlloc< ElemSize, SourceHeap > | |
| anonymous_namespace{Barneshut.cpp}::Body | |
| Hoard::GlobalHeap< SuperblockSize, EmptinessClasses, LockType >::bogusThresholdFunctionClass | |
| BoundedFreeListHeap< numObjects, Super > | |
| anonymous_namespace{Barneshut.cpp}::BoundingBox | |
| Box3d | |
| GaloisRuntime::BreakImpl< false > | |
| GaloisRuntime::BreakImpl< true > | |
| BUF | Buffer |
| anonymous_namespace{Barneshut.cpp}::BuildOctree | |
| BumpAlloc | Obtains memory in chunks and bumps a pointer through the chunks |
| Hoard::BumpAlloc< ChunkSize, super > | |
| GaloisRuntime::cache_line_storage< T > | |
| GaloisRuntime::cache_line_storage2< T > | |
| CacheHeap< Super > | |
| CartesianHeap< SuperHeap > | |
| HL::CatchExceptionHeap< Super > | |
| Cavity | |
| Check< TYPE, CHECK > | |
| checker< T2 > | |
| CheckHeap< SuperHeap > | |
| CheckThreadHeap< NumHeaps, super > | |
| GaloisRuntime::WorkList::MP_SC_FIFO< T >::Chunk | |
| GaloisRuntime::WorkList::ChunkedMaster< T, QT, distributed, isStack, chunksize, concurrent >::Chunk | |
| HL::Chunk< chunkSize, slotSize > | |
| BigChunk< chunkSize, slotSize, Super >::ChunkBlock | |
| HL::Chunk< chunkSize, slotSize >::ChunkBlock | |
| GaloisRuntime::WorkList::ChunkedFIFO< chunksize, T, concurrent > | |
| GaloisRuntime::WorkList::ChunkedLIFO< chunksize, T, concurrent > | |
| GaloisRuntime::WorkList::ChunkedMaster< T, QT, distributed, isStack, chunksize, concurrent > | |
| ChunkHeap | Allocates memory from the superheap in chunks |
| HL::ChunkHeap< ChunkSize, SuperHeap > | |
| ClusterNode | |
| CoalesceableHeap< SuperHeap > | |
| HL::CoalesceableHeap< SuperHeap > | Manages coalesceable memory |
| CoalesceableMmapHeap | Adds headers to mmapped objects to allow coalescing |
| HL::CoalesceableMmapHeap< Mmap > | |
| CoalesceHeap | Applies splitting and coalescing |
| HL::CoalesceHeap< super > | |
| Coarsener | |
| CombineHeap | Combines MallocHeap and FreeHeap: MallocHeap for malloc, FreeHeap for the rest |
| HL::CombineHeap< MallocHeap, FreeHeap > | |
| Galois::Graph::CompareNodeData< Graph > | |
| anonymous_namespace{Barneshut.cpp}::ComputeCenterOfMass | |
| anonymous_namespace{Barneshut.cpp}::ComputeForces | |
| llvm::conditional< bool, T, F > | |
| llvm::conditional< false, T, F > | |
| GaloisRuntime::WorkList::ConExtLinkedQueue< T, concurrent > | |
| GaloisRuntime::WorkList::ConExtLinkedStack< T, concurrent > | |
| anonymous_namespace{Preflowpush.cpp}::Config | |
| anonymous_namespace{Barneshut.cpp}::Config | |
| GaloisRuntime::Configurator< Function > | |
| Hoard::ConformantHeap< Parent > | |
| constraint | |
| CoordConn | This class maintains connectivity and coordinates of the mesh read from a file |
| CountedDictionary< Dict > | |
| HL::CPUInfo | Architecture-independent wrapper to get number of CPUs |
| AbstractSimObject::CustomPriorityQueue< T, Cmp > | This implementation of PriorityQueue imitates std::prioirty_queue but allows reserving space in the underlying std::vector |
| GaloisRuntime::WorkList::dChunkedFIFO< chunksize, T, concurrent > | |
| GaloisRuntime::WorkList::dChunkedLIFO< chunksize, T, concurrent > | |
| HL::DebugHeap< Super, freeChar > | |
| deleteArray | |
| deleteObject | |
| anonymous_namespace{Barneshut.cpp}::Deref< T > | |
| DESabstractMain | The Class DESabstractMain holds common functionality for DESunorderedSerial and DESunordered |
| DESunordered | |
| DESunorderedSerial | |
| DiagonalMassForSW | DiagonalMassForSW.h DG++ |
| HL::DLBigHeapType< super > | |
| HL::DLList | |
| DLList | A "memory neutral" doubly-linked list |
| HL::DLSmallHeapType< super > | The "small heap" -- non-coalescing "fastbins" (quicklists) |
| Galois::does_not_need_context< T > | Indicates the operator doesn't need a per-iteration context |
| Galois::does_not_need_parallel_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 |
| DResidue | Computes a residue and its derivative on an element |
| GaloisRuntime::WorkList::DummyIndexer | |
| GaloisRuntime::WorkList::DummyPartitioner | |
| DummyPolicy | |
| HL::DynamicArray< ObjType > | |
| DynamicArray | A dynamic array that grows to fit any index for assignment |
| ObstackReapNS::DynStack< OBJTYPE > | |
| spanningtree::main::Edge | |
| Edge | |
| Galois::Graph::EdgeItem< NTy, ETy > | Wrapper class to have a valid type on void edges |
| Galois::Graph::EdgeItem< NTy, void > | |
| edgestruct | Edge between two mesh nodes |
| Element | Element.h: Basic Element over which fields are defined |
| Element_ | Element_: Abstract implementation of an Element class |
| ElementBoundaryTraces | ElementBoundaryTraces.h DG++ |
| ElementBoundaryTraces_ | ElementBoundaryTraces_: implementation of ElementBoundaryTraces |
| ElementGeometry | ElementGeometry.h: Geometry of an element |
| EmptyBasisFunctions | Dummy set with no basis functions |
| EmptyClass | Maintains superblocks organized by emptiness |
| Hoard::EmptyClass< SuperblockType_, EmptinessClasses > | |
| HL::EmptyHeap | |
| EmptyHoardManager< SuperblockType_ > | |
| llvm::enable_if< Cond, T > | |
| llvm::enable_if_c< Cond, T > | |
| llvm::enable_if_c< false, T > | |
| FreeSLList::Entry | |
| HL::DLList::Entry | An entry in the list |
| HL::SLList::Entry | An entry in the list |
| HL::AdaptHeap< Dictionary, SuperHeap >::Entry | |
| CountedDictionary< Dict >::Entry | |
| Event< S, A > | |
| EventRecvTimeLocalTieBrkCmp< EventTy > | EventRecvTimeLocalTieBrkCmp is used to compare two events and break ties when the receiving time of two events is the same |
| ExactlyOne | Creates a singleton of type CLASS, accessed through () |
| Hoard::ExactlyOne< CLASS > | |
| HL::ExceptionHeap< Super > | |
| Galois::Executable | |
| GaloisRuntime::MM::ExternRefGaloisAllocator< Ty, AllocTy > | |
| FaradayPolicy | |
| Femap | Femap.h: Classes for parsing and writing Femap Neutral file format DG++ |
| femapConstraintSet | |
| femapElement | |
| femapGroup | |
| FemapInput | |
| femapLoadSet | |
| femapMaterial | FemapData.h: Contains data structures that store data from Femap Neutral file format DG++ |
| femapNode | |
| FemapOutput | |
| femapProperty | |
| GaloisRuntime::WorkList::FIFO< T, concurrent > | |
| FIFODLFreelistHeap< Super > | |
| FIFOFreelistHeap< SuperHeap > | |
| Galois::Graph::FileGraph | Graph serialized to a file |
| FileObject | |
| FindMatching | |
| anonymous_namespace{Preflowpush.cpp}::FindWork< WLTy > | |
| FirstFitHeap< Super > | |
| Galois::Graph::FirstGraph< NodeTy, EdgeTy, Directional > | A Graph |
| fix_variables | |
| FixedRequestHeap | Always grabs the same size, regardless of the request size |
| Hoard::FixedRequestHeap< RequestSize, SuperHeap > | |
| GaloisRuntime::MM::FixedSizeAllocator | |
| FixedSizeHeap< SH, Size > | |
| GaloisRuntime::WorkList::FixedSizeRing< T, chunksize, concurrent > | |
| spanningtree::main::AbstractMain::ForeachBody | |
| GaloisRuntime::ForEachWork< WorkListTy, Function > | |
| anonymous_namespace{Barneshut.cpp}::ComputeForces::Frame | |
| HL::Fred | |
| AOFFHeap< SuperHeap, FreeThreshold >::freedObject | |
| HL::FreelistHeap< SuperHeap > | |
| FreelistHeap | Manage freed memory on a linked list |
| GaloisRuntime::MM::FreeListHeap< SourceHeap > | Maintain a freelist |
| GaloisRuntime::MM::FreeListHeap< SourceHeap >::FreeNode | |
| GaloisRuntime::MM::SelfLockFreeListHeap< SourceHeap >::FreeNode | |
| FirstFitHeap< Super >::freeObject | |
| FIFODLFreelistHeap< Super >::freeObject | |
| HL::UseSizeHeap< Super >::freeObject | |
| BoundedFreeListHeap< numObjects, Super >::freeObject | |
| MultiMalloc< SuperHeap >::freeObject | |
| BatchHeap< BatchNumber, SuperHeap >::freeObject | |
| FIFOFreelistHeap< SuperHeap >::freeObject | |
| MultiMalloc< SuperHeap >::FreeObject | |
| FreeSLList | A "memory neutral" singly-linked list, |
| GaloisRuntime::MM::FSBGaloisAllocator< Ty > | |
| Galois::GAccumulator< T > | |
| GaloisRuntime::galois_insert_bag< T > | |
| GaloisPolicy | |
| GateRec | The Class GateRec stores the data for a specific gate, after reading it from a netlist file |
| Galois::GAtomic< T > | Atomic Wrapper for any integer or bool type |
| Galois::GAtomic< bool > | |
| Galois::GChecked< T > | Conflict-checking wapper for any type |
| Galois::Graph::FirstGraph< NodeTy, EdgeTy, Directional >::gNode::getNeigh | |
| Hoard::GlobalHeap< SuperblockSize, EmptinessClasses, LockType > | |
| GlobalHeapWrapper | |
| ScalableHeapNS::GlobalHeapWrapper< NumHeaps, SuperHeap > | |
| GlobalVec | |
| Galois::HIDDEN::gmax< T > | |
| Galois::Graph::LC_FileGraph< NodeTy, EdgeTy >::gNode | |
| Galois::Graph::LC_FileGraph< NodeTy, void >::gNode | |
| Galois::Graph::FirstGraph< NodeTy, EdgeTy, Directional >::gNode | |
| GNodeSetCompare | |
| Galois::Graph::FirstGraph< NodeTy, EdgeTy, Directional >::GraphNode | An opaque handle to a graph node |
| Galois::GReduceAverage< T > | |
| Galois::GReduceMax< T > | |
| Galois::GReducible< T, BinFunc > | GReducible stores per thread values of a variable of type T |
| groupList | |
| groupRule | |
| HL::Guard< LockType > | |
| RequireCoalesceable< SuperHeap >::Header | |
| HL::RequireCoalesceable< SuperHeap >::Header | |
| Hoard::HeapManager< LockType, HeapType > | |
| HeapQueue< T > | |
| HEMMatcher | |
| Hoard::HoardHeap< N, NH > | |
| Hoard::HoardHeapType | |
| Hoard::HoardManager< SourceHeap, ParentHeap, SuperblockType_, EmptinessClasses, LockType, thresholdFunctionClass, HeapType > | |
| HoardManager | Manages superblocks by emptiness, returning them to the parent heap when empty enough |
| Hoard::HoardSuperblock< LockType, SuperblockSize, HeapType > | |
| Hoard::HoardSuperblockHeader< LockType, SuperblockSize, HeapType > | |
| Hoard::hoardThresholdFunctionClass | |
| GaloisRuntime::galois_insert_bag< T >::holder | |
| HL::HybridHeap< BigSize, SmallHeap, BigHeap > | |
| HybridHeap | Objects no bigger than BigSize are allocated and freed to SmallHeap |
| IgnoreInvalidFree | |
| Hoard::IgnoreInvalidFree< S > | |
| GaloisRuntime::WorkList::WorkListTracker< T, Indexer, realWL >::info | |
| GaloisRuntime::initMainThread | |
| Input | |
| AVIabstractMain::InputConfig | |
| Galois::InsertBag< T > | Bag for only concurrent insertions |
| InUseHeap< SuperHeap > | |
| INV | Inverter |
| 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 > | |
| llvm::is_same< T, U > | Metafunction that determines whether the two given types are equivalent |
| llvm::is_same< T, T > | |
| IsotropicLinearElastic | Isotropic, unstressed Linear Elastic constitutive behavior |
| 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< std::pair< T, U > > | |
| KdCell | |
| KdTree | |
| KeyValue< T > | |
| HL::KingsleyHeap< PerClassHeap, BigHeap > | |
| KingsleyHeap | The Kingsley-style allocator |
| KingsModHeap< PerClassHeap > | |
| LazyHeap< SuperHeap > | |
| LazySlotHeap< chunkSize, slotSize, Super > | |
| Galois::Graph::LC_FileGraph< NodeTy, EdgeTy > | Local computation graph (i.e., graph structure does not change) |
| Galois::Graph::LC_FileGraph< NodeTy, void > | |
| Galois::Graph::LC_FileGraph< void, void > | |
| LeafNode | |
| HL::LeaHeap< Sbrk, Mmap > | This heap approximates the algorithms used by DLmalloc 2.7.0 |
| HL::LeaMallocHeap | |
| LeaMallocHeap | A "source heap" that uses the Lea allocator |
| GaloisRuntime::WorkList::LIFO< T, concurrent > | |
| LimitedPriorityQueue< T > | |
| Line_1 | 2-point Gauss quadrature coordinates in the segment (0,1) |
| Linear< SPD > | Linear.h: a set of linear shape functions DG++ |
| LinearElasticBase | Linear Elastic constitutive behavior |
| HL::MyHashMap< Key, Value, Allocator >::ListNode | |
| ListNode< T > | |
| GaloisRuntime::WorkList::ConExtLinkedStack< T, concurrent >::ListNode | |
| GaloisRuntime::WorkList::ConExtLinkedQueue< T, concurrent >::ListNode | |
| load | |
| GaloisRuntime::WorkList::Experimental::LocalFilter< T, Indexer, LocalTy, GlobalTy > | |
| HL::LocalMallocHeap | |
| GaloisRuntime::WorkList::LocalQueues< GlobalQueueTy, LocalQueueTy, T > | |
| LocalToGlobalMap | LocalToGlobalMap class: map the local degrees of freedom of each Element to the global ones |
| LocalVec | |
| GaloisRuntime::Lockable | |
| LockedHeap | |
| HL::LockedHeap< LockType, Super > | |
| GaloisRuntime::MM::LockedHeap< RealHeap > | Apply a lock to a heap |
| Hoard::LockMallocHeap< Heap > | |
| HL::Log< Obj > | |
| HL::LogHeap< SuperHeap > | |
| LogicFunc | LogicFunc is a functor, serving as a common base type for one and two input functors |
| LogicGate | The Class LogicGate represents an abstract logic gate |
| LogicUpdate | The Class LogicUpdate is the msg carried by events |
| GaloisRuntime::WorkList::Experimental::LogOrderByIntegerMetric< T, Indexer, ContainerTy, concurrent > | |
| LooseSlotHeap< chunkSize, slotSize, emptyFraction, Super > | |
| spanningtree::main::Main | |
| Galois::Graph::FirstGraph< NodeTy, EdgeTy, Directional >::makeGraphNode | |
| Galois::Graph::FirstGraph< NodeTy, EdgeTy, Directional >::makeGraphNodePtr | |
| mallinfo | |
| HL::mallocHeap | |
| mallocHeap | A "source heap" that uses malloc and free |
| GaloisRuntime::MM::MallocWrapper | |
| HL::SelectObjectManagerHeap< SuperHeap, OMWrapper >::ObjectManagerHeapProxy2::ManageMe | |
| Hoard::ManageOneSuperblock< SuperHeap > | |
| ManageOneSuperblock | A layer that caches exactly one superblock, thus avoiding costly lookups |
| HL::ObjectManagerWrapper::Manager< S > | |
| HL::ProvideObjectManagerWrapper::Manager< S > | |
| HL::NullObjectManagerWrapper::Manager< S > | |
| HL::SelectObjectManagerHeap< SuperHeap, OMWrapper >::ObjectManagerHeapProxy1::Manager< A > | |
| MarkThreadHeap< NumHeaps, super > | |
| Material | Material.h DG++ |
| MaxwellPolicy | |
| HL::LogHeap< SuperHeap >::MemoryRequest | |
| merge | |
| mergeP | |
| Mesh | Helper class used providing methods to read in information and create the graph |
| MeshInit | |
| MetisGraph | |
| MetisNode | |
| Mmap | |
| Hoard::MmapAlloc | |
| MmapAlloc | Obtains memory from Mmap but doesn't allow it to be freed |
| HL::MmapHeap | |
| MmapHeap | A "source heap" that manages memory via calls to the VM interface |
| HL::MmapWrapper | |
| GaloisRuntime::MM::mmapWrapper | Base mmap wrapper |
| GaloisRuntime::WorkList::MP_SC_FIFO< T > | |
| ScalableHeapNS::MTHeap< NumHeaps, MmapThreshold, BaseNullHeap, BaseHeap > | |
| MultiHeap< NumHeaps, Super > | |
| MultiMalloc< SuperHeap > | |
| Hoard::EmptyClass< SuperblockType_, EmptinessClasses >::MyChecker | Precondition and postcondition checking |
| HL::MyHashMap< Key, Value, Allocator > | |
| HL::MmapHeap::MyHeap | |
| CartesianHeap< SuperHeap >::MyTreap | |
| NAND2 | Nand with two inputs |
| 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 |
| NeoHookean | NeoHookean constitutive behavior |
| NeoHookean::NeoHookenTmpVec | Holds temporary vectors used by getConstitutiveResponse Instead of allocating new arrays on the stack, we reuse the same memory in the hope of better cache efficiency There is on instance of this struct per thread |
| HL::NestedHeap< SuperHeap > | |
| NestedHeap | Hierarchical heaps |
| NetlistParser | The Class NetlistParser parses an input netlist file |
| NetlistTokenizer | NetlistTokenizer is a simple string tokenizer, which usings C strtok () function from |
| newArray | |
| newObject | |
| node | |
| anonymous_namespace{Preflowpush.cpp}::Node | |
| anonymous_namespace{SpanningTree.cpp}::Node | |
| spanningtree::main::Node | |
| Treap< KEY, VALUE >::Node | |
| Node | |
| Galois::Graph::NodeItem< NTy > | Wrapper class to have a valid type on void nodes |
| Galois::Graph::NodeItem< void > | |
| NodeWrapper | |
| GaloisRuntime::WorkList::NoInlineFilter< iWL > | |
| noncopyable | |
| HL::NOP< S > | |
| NOR2 | NOR with two inputs |
| MultiMalloc< SuperHeap >::np | |
| HL::XallocHeap< ArenaSize, SuperHeap >::Nuggie | |
| HL::NullHeap< SuperHeap > | |
| NullHeap | A source heap that does nothing |
| HL::NullObjectManagerWrapper | |
| HL::ObjectManager< SuperHeap > | |
| HL::ObjectManagerBase< SuperHeap > | |
| HL::SelectObjectManagerHeap< SuperHeap, OMWrapper >::ObjectManagerHeapProxy1 | |
| HL::SelectObjectManagerHeap< SuperHeap, OMWrapper >::ObjectManagerHeapProxy2 | |
| HL::ObjectManagerWrapper | |
| obstack | |
| ObstackReap< ReapType > | |
| anonymous_namespace{Barneshut.cpp}::Octree | A node in an octree is either an internal node or a body (leaf) |
| anonymous_namespace{Barneshut.cpp}::OctreeInternal | |
| HL::OneHeap< SuperHeap > | |
| OneInputFunc | Interface of a functor for modeling the funciton of a one input one, output logic gate |
| OneInputGate | The Class OneInputGate |
| OR2 | OR with two inputs |
| GaloisRuntime::WorkList::OrderedByIntegerMetric< Indexer, ContainerTy, T, concurrent > | |
| Output | The Class Output |
| GaloisRuntime::MM::OwnerTaggedHeap< SourceHeap > | Allow looking up parent heap pointers |
| GaloisRuntime::WorkList::MP_SC_FIFO< T >::p | |
| GaloisRuntime::WorkList::ChunkedMaster< T, QT, distributed, isStack, chunksize, concurrent >::p | |
| GaloisRuntime::WorkList::Experimental::LocalFilter< T, Indexer, LocalTy, GlobalTy >::p | |
| P12D< NF > | P12D<NF> family of elements over triangles with NF linearly interpolated fields |
| P12DElement< NF > | P12DElement.h: 2D Element with linear shape functions |
| P12DElementBoundaryTraces< NF > | P12DElementBoundaryTraces: group of traces of P12DElements |
| P12DTrace< NF > | P12DTrace: traces of P12DElements |
| P13D< NF > | Family of elements over tetrahedra with NF linearly interpolated fields |
| P13DElement< NF > | P13DElement.h: A 3D element with linear shape functions |
| P13DElementBoundaryTraces< NF > | Group of traces for P13DElement |
| P13DTrace< NF > | Traces of P13DElement |
| P1nDBoundaryTraces< NF > | Common base class for boundary traces |
| P1nDElement< NF > | P1nDElement.h: Common base class for 2D/3D elements with linear shape functions |
| P1nDTrace< NF > | Common base class for 2D/3D linear traces |
| Pad< CacheLineSize, Super > | |
| PaddedLock | |
| GaloisRuntime::PaddedLock< false > | |
| GaloisRuntime::PaddedLock< true > | |
| PadHeap< CacheLineSize, SuperHeap > | |
| Coarsener::parallelAddingEdges | |
| Coarsener::parallelMatchNodes< MatchingPolicy > | |
| RandomKwayEdgeRefiner::parallelRefine | |
| GaloisRuntime::ParallelThreadContext< Function, WorkListTy > | |
| GaloisRuntime::WorkList::PartitionedWL< Partitioner, T, ChildWLTy, concurrent > | |
| PATCH | |
| HL::PerClassHeap< SuperHeap > | |
| PerClassHeap | Enable the use of one heap for all class memory allocation |
| GaloisRuntime::PerCPU< T > | |
| PerCPUValue | |
| PerIt< T > | |
| GaloisRuntime::WorkList::OrderedByIntegerMetric< Indexer, ContainerTy, T, concurrent >::perItem | |
| GaloisRuntime::PerLevel< T > | |
| Hoard::PerThreadHoardHeap | |
| PHOThreadHeap< NumHeaps, super > | |
| PMetis | |
| anonymous_namespace{Barneshut.cpp}::Point | |
| Point3 | |
| HL::PosixLockType | |
| PosixLockType | Locking using POSIX mutex objects |
| PotentialCluster | |
| PQueue | |
| PrefetchHeap< Super > | |
| anonymous_namespace{Support.cpp}::PrintStats | |
| GaloisRuntime::WorkList::PriQueue< Compare, T, concurrent > | |
| HL::PrivateMmapHeap | |
| anonymous_namespace{Preflowpush.cpp}::Process< flag > | |
| DESunordered::process | Loop body, called by |
| AVIunordered::process | Functor for loop body |
| anonymous_namespace{SpanningTree.cpp}::Process | |
| process | |
| AVIunorderedNoLock::process | Functor for loop body |
| Hoard::ProcessHeap< SuperblockSize, EmptinessClasses, LockType, ThresholdClass > | |
| ProfileHeap< super, HeapNumber > | |
| projectInfo | |
| projectPartition | |
| HL::ProvideObjectManager< SuperHeap > | |
| HL::ProvideObjectManagerWrapper | |
| GaloisRuntime::PtrLock< T, false > | |
| GaloisRuntime::PtrLock< T, true > | |
| Quadrature | Quadrature.h DG++ |
| GaloisRuntime::QueuingLock< false > | |
| GaloisRuntime::QueuingLock< true > | |
| RandomKwayEdgeRefiner | |
| GaloisRuntime::MM::FSBGaloisAllocator< Ty >::rebind< Other > | |
| GaloisRuntime::MM::ExternRefGaloisAllocator< Ty, AllocTy >::rebind< Other > | |
| Galois::Allocator< Ty >::rebind< Other > | |
| HL::STLAllocator< T, Super >::rebind< U > | |
| Galois::Allocator< void >::rebind< Other > | |
| HL::RecursiveLockType< BaseLock > | |
| RecursiveLockType | Implements a recursive lock using some base lock representation |
| Hoard::RedirectFree< Heap, SuperblockType_ > | Routes free calls to the Superblock's owner heap |
| Galois::ReduceAssignWrap< BinFunc > | |
| anonymous_namespace{Barneshut.cpp}::ReduceBoxes | |
| GaloisRuntime::WorkList::Experimental::ReductionWL< T, LocalWL, DistPolicy > | |
| 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::WorkList::Experimental::RequestHirarchy< T, LocalWL, GlobalWL > | |
| RequireCoalesceable< SuperHeap > | Provides support for coalescing objects |
| HL::RequireCoalesceable< SuperHeap > | |
| anonymous_namespace{Preflowpush.cpp}::ResetHeights | |
| Residue | ElementalOperation.h DG++ |
| GaloisRuntime::WorkList::NoInlineFilter< iWL >::rethread< concurrent > | |
| GaloisRuntime::WorkList::FixedSizeRing< T, chunksize, concurrent >::rethread< newconcurrent > | |
| GaloisRuntime::WorkList::Experimental::LocalFilter< T, Indexer, LocalTy, GlobalTy >::rethread< newconcurrent > | Change the concurrency flag |
| GaloisRuntime::WorkList::PriQueue< Compare, T, concurrent >::rethread< newconcurrent > | |
| GaloisRuntime::WorkList::LIFO< T, concurrent >::rethread< newconcurrent > | |
| GaloisRuntime::WorkList::FIFO< T, concurrent >::rethread< newconcurrent > | |
| GaloisRuntime::WorkList::OrderedByIntegerMetric< Indexer, ContainerTy, T, concurrent >::rethread< newconcurrent > | |
| GaloisRuntime::WorkList::LocalQueues< GlobalQueueTy, LocalQueueTy, T >::rethread< newconcurrent > | |
| GaloisRuntime::WorkList::PartitionedWL< Partitioner, T, ChildWLTy, concurrent >::rethread< newconcurrent > | |
| GaloisRuntime::WorkList::Experimental::ApproxOrderByIntegerMetric< T, Indexer, ContainerTy, concurrent >::rethread< newconcurrent > | |
| GaloisRuntime::WorkList::AbstractWorkList< T, concurrent >::rethread< newconcurrent > | Change the concurrency flag |
| GaloisRuntime::WorkList::Experimental::StealingLocalWL< T, ContainerTy >::rethread< newconcurrent > | |
| GaloisRuntime::WorkList::ChunkedMaster< T, QT, distributed, isStack, chunksize, concurrent >::rethread< newconcurrent > | |
| GaloisRuntime::WorkList::MP_SC_FIFO< T >::rethread< newconcurrent > | |
| GaloisRuntime::WorkList::Experimental::LogOrderByIntegerMetric< T, Indexer, ContainerTy, concurrent >::rethread< newconcurrent > | |
| GaloisRuntime::WorkList::AbstractWorkList< T, concurrent >::retype< Tnew > | Change the type the worklist holds |
| GaloisRuntime::WorkList::OrderedByIntegerMetric< Indexer, ContainerTy, T, concurrent >::retype< Tnew > | |
| GaloisRuntime::WorkList::PriQueue< Compare, T, concurrent >::retype< Tnew > | |
| GaloisRuntime::WorkList::MP_SC_FIFO< T >::retype< Tnew > | |
| GaloisRuntime::WorkList::ChunkedMaster< T, QT, distributed, isStack, chunksize, concurrent >::retype< Tnew > | |
| GaloisRuntime::WorkList::FIFO< T, concurrent >::retype< Tnew > | |
| GaloisRuntime::WorkList::LocalQueues< GlobalQueueTy, LocalQueueTy, T >::retype< Tnew > | |
| GaloisRuntime::WorkList::LIFO< T, concurrent >::retype< Tnew > | |
| RMMatcher | Random matching algorithm |
| S | |
| Hoard::HoardManager< SourceHeap, ParentHeap, SuperblockType_, EmptinessClasses, LockType, thresholdFunctionClass, HeapType >::sanityCheck | |
| HL::Seg< ReapletSize, SizeClassComputer, TopHeap >::SanityChecker | |
| HL::SanityCheckHeap< SuperHeap > | |
| SanityCheckHeap | Checks for memory allocation usage errors at runtime |
| sassert | Implements compile-time assertion checking |
| HL::sassert< 1 > | |
| Sbrk | |
| SbrkHeap | |
| ScalableHeap< NumHeaps, BaseNullHeap, BaseHeap, Mmap > | |
| HL::Seg< ReapletSize, SizeClassComputer, TopHeap > | |
| HL::SegHeap< NumBins, getSizeClass, getClassMaxSize, LittleHeap, BigHeap > | |
| SegHeap | A segregated-fits collection of (homogeneous) heaps |
| Segment< SPD > | Segment.h: a line segment DG++ |
| HL::SelectMmapHeap< ThresholdBytes, SmallHeap, super > | Use Mmap (here the superheap) for objects above a certain size |
| HL::SelectObjectManagerHeap< SuperHeap, OMWrapper > | |
| GaloisRuntime::MM::SelfLockFreeListHeap< SourceHeap > | Maintain a freelist using a lock which doesn't cover SourceHeap |
| seq_less | |
| spanningtree::main::SerialMain | |
| Shape | Shape.h DG++ |
| ShapesEvaluated | ShapesEvaluated.h DG++ |
| ShapesEvaluated__< ShapeObj, QuadObj > | ShapesEvaluated__: This class is the one that brings the flexibility for building shape functions of different types evaluated at different quadrature points |
| ShapesP11D | Shape functions for P11D elements: Linear functions on segments |
| ShapesP12D | Shape functions for P12D elements: Linear functions on Triangles
It contains two types of traces
1) ShapesP12D::Faces are linear functions on Segments, and their degrees of freedom are those associated to the nodes of the Segment |
| ShapesP13D | ShapesEvaluatedP13D.h DG++ |
| SimInit | |
| SimObject | |
| GaloisRuntime::MM::SimpleBumpPtr< SourceHeap > | This implements a bump pointer though chunks of memory |
| GaloisRuntime::SimpleLock< T, false > | |
| GaloisRuntime::SimpleLock< T, true > | |
| SimpleMaterial | Material whose thermodynamic state depends only on the local strain |
| GaloisRuntime::SimpleRuntimeContext | |
| GaloisRuntime::SimpleRuntimeContextHandler< false > | |
| GaloisRuntime::SimpleRuntimeContextHandler< true > | |
| GaloisRuntime::MM::SizedAllocatorFactory | |
| HL::SizeHeap< SuperHeap > | Allocates extra room for the size of an object |
| HL::SizeOwner< Heap > | |
| HL::SizeOwnerHeap< Super > | |
| SizeOwnerHeap | Adds object size and owner heap information |
| SizeThreadHeap< Super > | |
| SLList | A "memory neutral" singly-linked list |
| HL::SLList | |
| SlopHeap | SlopHeap is designed to guarantee that you always have an extra N bytes available after the most recent malloc |
| HL::SlopHeap< SuperHeap, SLOP > | |
| SlotHeap< chunkSize, slotSize, Super > | |
| SlotInterface< chunkSize, slotSize, Super > | |
| ScalableHeapNS::SmallHeap< NumHeaps, MmapThreshold, BaseNullHeap, BaseHeap > | |
| Hoard::SmallHeap | |
| 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 > | |
| SNode | |
| SourceHeap | |
| Hoard::AlignedMmapInstance< Alignment_ >::SourceHeap | |
| SpecificElementFamily | SpecificElementFamily: classes that contain all Element types that form a family |
| SpecificQuadratures | SpecificQuadratures: class used just to qualify all specific quadrature objects used to build the quadrature rules |
| SpecificShapesEvaluated | Specific ShapesEvaluated types |
| SPEdge | |
| HL::SpinLockType | |
| GaloisRuntime::galois_insert_bag< T >::splicer | |
| SplitHeap< SuperHeap > | |
| SPNode | |
| GaloisRuntime::WorkList::squeues< false, TQ > | |
| GaloisRuntime::WorkList::squeues< true, TQ > | |
| StandardAVI | StandardAVI.h DG++ |
| StandardP1nDMap | StandardP1nDMap class: standard local to global map for 2D/3D elements with linear shape functions |
| HL::StaticHeap< MemorySize > | |
| Galois::statistic< T > | |
| GaloisRuntime::StatisticHandler< false > | |
| GaloisRuntime::StatisticHandler< true > | |
| Hoard::Statistics | |
| StatsHeap< SuperHeap > | |
| Galois::StatTimer | |
| GaloisRuntime::WorkList::Experimental::StealingLocalWL< T, ContainerTy > | |
| HL::STLAllocator< T, Super > | |
| STLAllocator | An allocator adapter for STL |
| StressWork | StressWork.h DG++ |
| StressWork::StressWorkTmpVec | Contains the temporary vectors used by |
| HL::StrictSegHeap< NumBins, getSizeClass, getClassMaxSize, LittleHeap, BigHeap > | |
| StrictSegHeap | A "strict" segregated-fits collection of (homogeneous) heaps |
| Subgraph | A sub-graph of the mesh |
| Super | |
| super | |
| Hoard::SuperblockStore< SuperblockSize, TheLockType > | |
| SuperHeap | |
| SuperPQueue< T > | A priority queue which combines two implementations: 1 |
| GaloisRuntime::MM::SystemBaseAlloc | This is the base source of memory for all allocators |
| GaloisRuntime::TerminationDetection | |
| Tet_1 | Class for 4 point quadrature rules for tetrahedra |
| Tet_11Point | 11 point quadrature rule for tetrahedron Degree of precision 4, number of points 11 |
| Tet_15Point | 15 point quadrature rule for tetrahedron Degree of precision 5, number of points 15 |
| Tet_4Point | QuadratureP3.h DG++ |
| TetLinearCoordConn | |
| TetLinearTraits | Important constants for linear tetrahedron |
| TetMeshInit | |
| Tetrahedron | |
| THeap< SuperHeap, FH, Threshold > | |
| TheCustomHeapType | |
| HL::SelectObjectManagerHeap< SuperHeap, OMWrapper >::TheHeap | |
| ThinLock | |
| GaloisRuntime::ThreadAware | |
| GaloisRuntime::MM::ThreadAwarePrivateHeap< LocalHeap > | Per-thread heaps using Galois thread aware construct |
| HL::ThreadHeap< NumHeaps, PerThreadHeap > | |
| ThreadHeap< NumHeaps, PerThreadHeap > | |
| Hoard::ThreadLocalAllocationBuffer< NumBins, getSizeClass, getClassSize, LargestObject, LocalHeapThreshold, SuperblockType, SuperblockSize, ParentHeap > | |
| ThreadLocalAllocationBuffer | An allocator, meant to be used for thread-local allocation |
| GaloisRuntime::ThreadPolicy | |
| GaloisRuntime::ThreadPool | |
| Hoard::ThreadPoolHeap< NumThreads, NumHeaps, PerThreadHeap_ > | |
| ThreadPoolHeap | |
| HL::Threshold< ThresholdBytes, super > | |
| ThresholdClass | |
| Galois::TimeAccumulator | A multi-start time accumulator |
| TimeItAll | |
| HL::Timer | |
| Galois::Timer | A simple timer |
| Timer | A portable class for high-resolution timing |
| Hoard::TLAB | |
| Subgraph::tmpEdge | |
| GaloisRuntime::TerminationDetection::tokenHolder | |
| TopSlotHeap< chunkSize, slotSize, Super > | |
| TraceHeap< Super, Number > | |
| Treap< KEY, VALUE > | |
| Triangle< SPD > | Triangle.h DG++ |
| Triangle_1 | 3-point Gauss quadrature coordinates in the triangle (0,0), (1,0), (0,1), and its traces |
| TriLinearCoordConn | |
| TriLinearTraits | Important constants for linear triangle |
| TriMeshInit | |
| TryHeap< Heap1, Heap2 > | |
| ScalableHeapNS::TryHeap< Threshold, Heap1, Heap2 > | |
| Tuple | |
| TwoInputFunc | Interface of a functor for modeling functionality a logic gate with two inputs and one output |
| TwoInputGate | The Class TwoInputGate |
| GaloisRuntime::MM::BlockAlloc< ElemSize, SourceHeap >::TyEq | |
| llvm::SmallVectorBase::U | |
| UniqueHeap< SuperHeap, Child > | Instantiates one instance of a class used for every malloc & free |
| Galois::Graph::VoidWrapper< void >::unit | |
| update_biases | |
| update_eta | |
| anonymous_namespace{Preflowpush.cpp}::UpdateHeights< flag, useCAS > | |
| UpdateRequest | |
| UpdateRequestIndexer | |
| GaloisRuntime::ParallelThreadContext< Function, WorkListTy >::UserAPI | |
| UseSizeHeap | Adds a getSize method to access the size of an allocated object |
| HL::UseSizeHeap< Super > | |
| Verifier | |
| HL::Seg< ReapletSize, SizeClassComputer, TopHeap >::VerifyAlignment | |
| Galois::Graph::VoidWrapper< T > | Wrapper class to have a valid type on void |
| Galois::Graph::VoidWrapper< void > | |
| VoltaPolicy | |
| spanningtree::main::AbstractMain::Worklist | |
| GaloisRuntime::WorkList::WorkListTracker< T, Indexer, realWL > | |
| HL::XallocHeap< ArenaSize, SuperHeap > | |
| XNOR2 | XNOR with two inputs |
| XOR2 | XOR with two inputs |
| GaloisRuntime::MM::ZeroOut< SourceHeap > | |
| HL::ZoneHeap< Super, ChunkSize > | |
| ZoneHeap | A zone (or arena, or region) based allocator |
