Showing preview only (8,833K chars total). Download the full file or copy to clipboard to get everything.
Repository: IntelligentSoftwareSystems/Galois
Branch: master
Commit: b67f94206a8c
Files: 1074
Total size: 8.2 MB
Directory structure:
gitextract_7r5c247e/
├── .circleci/
│ ├── config.yml
│ └── longest_common_path.sh
├── .clang-format
├── .clang-tidy
├── .git-blame-ignore-revs
├── .gitignore
├── .gitmodules
├── .travis.yml
├── CMakeLists.txt
├── COPYRIGHT
├── LICENSE.txt
├── README.md
├── cmake/
│ ├── GaloisConfig.cmake.in
│ └── Modules/
│ ├── CheckArchFlags.cmake
│ ├── CheckCilk.cmake
│ ├── CheckEndian.cmake
│ ├── CheckHugePages.cmake
│ ├── CheckMmap.cmake
│ ├── CheckSchedSetAffinity.cmake
│ ├── FindCBLAS.cmake
│ ├── FindFortran.cmake
│ ├── FindGASNET.cmake
│ ├── FindGMP.cmake
│ ├── FindGit.cmake
│ ├── FindNUMA.cmake
│ ├── FindOpenCL.cmake
│ ├── FindPAPI.cmake
│ ├── FindQGLViewer.cmake
│ ├── FindTBB.cmake
│ ├── FindVTune.cmake
│ ├── GetGitVersion-write.cmake
│ ├── GetGitVersion.cmake
│ ├── HandleSanitizer.cmake
│ ├── LibFindMacros.cmake
│ └── UseStdMacro.cmake
├── config/
│ ├── sanitizers/
│ │ └── ubsan_blacklist.txt.in
│ └── version.txt
├── external/
│ └── bliss/
│ └── bliss/
│ ├── COPYING
│ ├── COPYING.LESSER
│ ├── abgraph.hh
│ ├── bignum.hh
│ ├── defs.hh
│ ├── graph.hh
│ ├── heap.hh
│ ├── kqueue.hh
│ ├── kstack.hh
│ ├── orbit.hh
│ ├── partition.hh
│ ├── search.h
│ ├── uintseqhash.hh
│ └── utils.hh
├── inputs/
│ ├── CMakeLists.txt
│ └── cholesky/
│ ├── matrix1.txt
│ ├── matrix1.txt.choleskyedges
│ ├── matrix1.txt.dep
│ ├── matrix1.txt.filled
│ ├── very-sparse.txt
│ ├── very-sparse.txt.choleskyedges
│ ├── very-sparse.txt.dep
│ └── very-sparse.txt.filled
├── libcusp/
│ ├── CMakeLists.txt
│ └── include/
│ └── galois/
│ └── graphs/
│ ├── BasePolicies.h
│ ├── CuSPPartitioner.h
│ ├── DistributedGraph.h
│ ├── GenericPartitioners.h
│ ├── MiningPartitioner.h
│ └── NewGeneric.h
├── libdist/
│ ├── CMakeLists.txt
│ ├── include/
│ │ └── galois/
│ │ ├── DReducible.h
│ │ ├── DTerminationDetector.h
│ │ ├── DistGalois.h
│ │ └── runtime/
│ │ ├── BareMPI.h
│ │ ├── DistStats.h
│ │ ├── LWCI.h
│ │ ├── MemUsage.h
│ │ ├── Network.h
│ │ ├── NetworkIO.h
│ │ └── Serialize.h
│ └── src/
│ ├── Barrier.cpp
│ ├── DistGalois.cpp
│ ├── DistStats.cpp
│ ├── Network.cpp
│ ├── NetworkBuffered.cpp
│ ├── NetworkIOMPI.cpp
│ └── NetworkLCI.cpp
├── libgalois/
│ ├── CMakeLists.txt
│ ├── include/
│ │ └── galois/
│ │ ├── ArrayWrapper.h
│ │ ├── AtomicHelpers.h
│ │ ├── AtomicWrapper.h
│ │ ├── Bag.h
│ │ ├── CheckedObject.h
│ │ ├── CopyableTuple.h
│ │ ├── DynamicBitset.h
│ │ ├── Endian.h
│ │ ├── FixedSizeRing.h
│ │ ├── FlatMap.h
│ │ ├── Galois.h
│ │ ├── GaloisForwardDecl.h
│ │ ├── LargeArray.h
│ │ ├── LazyArray.h
│ │ ├── LazyObject.h
│ │ ├── Loops.h
│ │ ├── Mem.h
│ │ ├── MethodFlags.h
│ │ ├── NoDerefIterator.h
│ │ ├── PODResizeableArray.h
│ │ ├── ParallelSTL.h
│ │ ├── PerThreadContainer.h
│ │ ├── PriorityQueue.h
│ │ ├── Reduction.h
│ │ ├── SharedMemSys.h
│ │ ├── Threads.h
│ │ ├── Timer.h
│ │ ├── Traits.h
│ │ ├── TwoLevelIterator.h
│ │ ├── TwoLevelIteratorA.h
│ │ ├── UnionFind.h
│ │ ├── UserContext.h
│ │ ├── Version.h
│ │ ├── config.h.in
│ │ ├── gIO.h
│ │ ├── gdeque.h
│ │ ├── graphs/
│ │ │ ├── BufferedGraph.h
│ │ │ ├── Details.h
│ │ │ ├── FileGraph.h
│ │ │ ├── Graph.h
│ │ │ ├── GraphHelpers.h
│ │ │ ├── LCGraph.h
│ │ │ ├── LC_Adaptor_Graph.h
│ │ │ ├── LC_CSR_CSC_Graph.h
│ │ │ ├── LC_CSR_Graph.h
│ │ │ ├── LC_CSR_Hypergraph.h
│ │ │ ├── LC_InOut_Graph.h
│ │ │ ├── LC_InlineEdge_Graph.h
│ │ │ ├── LC_Linear_Graph.h
│ │ │ ├── LC_Morph_Graph.h
│ │ │ ├── MorphGraph.h
│ │ │ ├── MorphHyperGraph.h
│ │ │ ├── Morph_SepInOut_Graph.h
│ │ │ ├── OCGraph.h
│ │ │ ├── OfflineGraph.h
│ │ │ ├── ReadGraph.h
│ │ │ ├── SpatialTree.h
│ │ │ └── TypeTraits.h
│ │ ├── gslist.h
│ │ ├── gstl.h
│ │ ├── optional.h
│ │ ├── runtime/
│ │ │ ├── Context.h
│ │ │ ├── Executor_Deterministic.h
│ │ │ ├── Executor_DoAll.h
│ │ │ ├── Executor_ForEach.h
│ │ │ ├── Executor_OnEach.h
│ │ │ ├── Executor_Ordered.h
│ │ │ ├── Executor_ParaMeter.h
│ │ │ ├── ExtraTraits.h
│ │ │ ├── Iterable.h
│ │ │ ├── LoopStatistics.h
│ │ │ ├── Mem.h
│ │ │ ├── OperatorReferenceTypes.h
│ │ │ ├── PagePool.h
│ │ │ ├── Profile.h
│ │ │ ├── Range.h
│ │ │ ├── SharedMem.h
│ │ │ ├── Statistics.h
│ │ │ ├── Substrate.h
│ │ │ ├── ThreadTimer.h
│ │ │ ├── TiledExecutor.h
│ │ │ ├── Tracer.h
│ │ │ └── UserContextAccess.h
│ │ ├── substrate/
│ │ │ ├── Barrier.h
│ │ │ ├── CacheLineStorage.h
│ │ │ ├── CompilerSpecific.h
│ │ │ ├── EnvCheck.h
│ │ │ ├── HWTopo.h
│ │ │ ├── NumaMem.h
│ │ │ ├── PaddedLock.h
│ │ │ ├── PageAlloc.h
│ │ │ ├── PerThreadStorage.h
│ │ │ ├── PtrLock.h
│ │ │ ├── SharedMem.h
│ │ │ ├── SimpleLock.h
│ │ │ ├── StaticInstance.h
│ │ │ ├── Termination.h
│ │ │ ├── ThreadPool.h
│ │ │ └── ThreadRWlock.h
│ │ └── worklists/
│ │ ├── AdaptiveObim.h
│ │ ├── BulkSynchronous.h
│ │ ├── Chunk.h
│ │ ├── ExternalReference.h
│ │ ├── LocalQueue.h
│ │ ├── Obim.h
│ │ ├── OrderedList.h
│ │ ├── OwnerComputes.h
│ │ ├── PerThreadChunk.h
│ │ ├── Simple.h
│ │ ├── StableIterator.h
│ │ ├── WLCompileCheck.h
│ │ ├── WorkList.h
│ │ └── WorkListHelpers.h
│ ├── src/
│ │ ├── Barrier.cpp
│ │ ├── Barrier_Counting.cpp
│ │ ├── Barrier_Dissemination.cpp
│ │ ├── Barrier_MCS.cpp
│ │ ├── Barrier_Pthread.cpp
│ │ ├── Barrier_Simple.cpp
│ │ ├── Barrier_Topo.cpp
│ │ ├── Context.cpp
│ │ ├── Deterministic.cpp
│ │ ├── DynamicBitset.cpp
│ │ ├── EnvCheck.cpp
│ │ ├── FileGraph.cpp
│ │ ├── FileGraphParallel.cpp
│ │ ├── GraphHelpers.cpp
│ │ ├── HWTopo.cpp
│ │ ├── HWTopoDarwin.cpp
│ │ ├── HWTopoLinux.cpp
│ │ ├── Mem.cpp
│ │ ├── NumaMem.cpp
│ │ ├── OCFileGraph.cpp
│ │ ├── PageAlloc.cpp
│ │ ├── PagePool.cpp
│ │ ├── ParaMeter.cpp
│ │ ├── PerThreadStorage.cpp
│ │ ├── PreAlloc.cpp
│ │ ├── Profile.cpp
│ │ ├── PtrLock.cpp
│ │ ├── SharedMem.cpp
│ │ ├── SharedMemSys.cpp
│ │ ├── SimpleLock.cpp
│ │ ├── Statistics.cpp
│ │ ├── Substrate.cpp
│ │ ├── Support.cpp
│ │ ├── Termination.cpp
│ │ ├── ThreadPool.cpp
│ │ ├── ThreadTimer.cpp
│ │ ├── Threads.cpp
│ │ ├── Timer.cpp
│ │ ├── Tracer.cpp
│ │ ├── Version.cpp.in
│ │ └── gIO.cpp
│ └── test/
│ ├── CMakeLists.txt
│ ├── README.md
│ ├── acquire.cpp
│ ├── bandwidth.cpp
│ ├── barriers.cpp
│ ├── empty-member-lcgraph.cpp
│ ├── flatmap.cpp
│ ├── floatingPointErrors.cpp
│ ├── foreach.cpp
│ ├── forward-declare-graph.cpp
│ ├── gcollections.cpp
│ ├── graph-compile.cpp
│ ├── graph.cpp
│ ├── gslist.cpp
│ ├── hwtopo.cpp
│ ├── lc-adaptor.cpp
│ ├── lock.cpp
│ ├── lockmgr.cpp
│ ├── loop-overhead.cpp
│ ├── mem.cpp
│ ├── morphgraph-removal.cpp
│ ├── morphgraph.cpp
│ ├── move.cpp
│ ├── oneach.cpp
│ ├── papi.cpp
│ ├── pc.cpp
│ ├── reduction.cpp
│ ├── sort.cpp
│ ├── static.cpp
│ ├── traits.cpp
│ ├── twoleveliteratora.cpp
│ ├── wakeup-overhead.cpp
│ └── worklists-compile.cpp
├── libgluon/
│ ├── CMakeLists.txt
│ ├── include/
│ │ └── galois/
│ │ ├── cuda/
│ │ │ ├── Context.h
│ │ │ ├── DynamicBitset.h
│ │ │ ├── EdgeContext.h
│ │ │ ├── EdgeHostDecls.h
│ │ │ └── HostDecls.h
│ │ ├── graphs/
│ │ │ ├── GluonEdgeSubstrate.h
│ │ │ └── GluonSubstrate.h
│ │ └── runtime/
│ │ ├── DataCommMode.h
│ │ ├── GlobalObj.h
│ │ ├── SyncStructures.h
│ │ └── cuda/
│ │ ├── DeviceEdgeSync.h
│ │ └── DeviceSync.h
│ └── src/
│ ├── GlobalObj.cpp
│ ├── GluonSubstrate.cpp
│ ├── SyncStructures.cpp
│ └── cuda_device.cpp
├── libgpu/
│ ├── CMakeLists.txt
│ ├── include/
│ │ ├── Timer.h
│ │ ├── abitset.h
│ │ ├── aolist.h
│ │ ├── atomic_helpers.h
│ │ ├── bmk2.h
│ │ ├── component.h
│ │ ├── counter.h
│ │ ├── csr_graph.h
│ │ ├── cuda_launch_config.hpp
│ │ ├── cutil_subset.h
│ │ ├── exclusive.h
│ │ ├── failfast.h
│ │ ├── gbar.cuh
│ │ ├── gg.h
│ │ ├── ggc_rt.h
│ │ ├── ggcuda.h
│ │ ├── instr.h
│ │ ├── internal.h
│ │ ├── lockarray.h
│ │ ├── pipe.h
│ │ ├── rv.h
│ │ ├── sharedptr.h
│ │ ├── snfile.h
│ │ ├── thread_work.h
│ │ └── worklist.h
│ └── src/
│ ├── bmk2.c
│ ├── csr_graph.cu
│ ├── ggc_rt.cu
│ ├── instr.cu
│ ├── skelapp/
│ │ └── skel.cu
│ ├── snappy.c
│ └── snappy_test.c
├── libpangolin/
│ ├── CMakeLists.txt
│ ├── README.md
│ ├── gpu/
│ │ └── pangolin/
│ │ ├── bitsets.h
│ │ ├── checker.h
│ │ ├── cutils.h
│ │ ├── element.cuh
│ │ ├── embedding.cuh
│ │ ├── graph_gpu.h
│ │ ├── miner.cuh
│ │ ├── timer.h
│ │ └── types.cuh
│ ├── include/
│ │ └── pangolin/
│ │ ├── BfsMining/
│ │ │ ├── edge_miner.h
│ │ │ ├── edge_miner_api.h
│ │ │ ├── embedding_list.h
│ │ │ ├── engine.h
│ │ │ ├── vertex_miner.h
│ │ │ └── vertex_miner_api.h
│ │ ├── base_embedding.h
│ │ ├── canonical_graph.h
│ │ ├── core.h
│ │ ├── domain_support.h
│ │ ├── edge_embedding.h
│ │ ├── edge_type.h
│ │ ├── element.h
│ │ ├── embedding.h
│ │ ├── embedding_queue.h
│ │ ├── equivalence.h
│ │ ├── gtypes.h
│ │ ├── mgraph.h
│ │ ├── miner.h
│ │ ├── ptypes.h
│ │ ├── quick_pattern.h
│ │ ├── res_man.h
│ │ ├── scan.h
│ │ ├── types.h
│ │ ├── util.h
│ │ └── vertex_embedding.h
│ └── src/
│ ├── BfsMining/
│ │ └── embedding_list.cpp
│ ├── base_embedding.cpp
│ ├── equivalence.cpp
│ ├── quick_pattern.cpp
│ └── vertex_embedding.cpp
├── libpygalois/
│ ├── CMakeLists.txt
│ └── include/
│ └── galois/
│ └── Constants.h
├── libsupport/
│ ├── CMakeLists.txt
│ ├── include/
│ │ └── galois/
│ │ ├── GetEnv.h
│ │ └── Logging.h
│ ├── src/
│ │ ├── GetEnv.cpp
│ │ └── Logging.cpp
│ └── test/
│ ├── CMakeLists.txt
│ ├── getenv.cpp
│ └── logging.cpp
├── lonestar/
│ ├── CMakeLists.txt
│ ├── analytics/
│ │ ├── CMakeLists.txt
│ │ ├── cpu/
│ │ │ ├── CMakeLists.txt
│ │ │ ├── betweennesscentrality/
│ │ │ │ ├── AsyncStructs.h
│ │ │ │ ├── BCEdge.h
│ │ │ │ ├── BCNode.h
│ │ │ │ ├── BetweennessCentrality.cpp
│ │ │ │ ├── CMakeLists.txt
│ │ │ │ ├── LevelStructs.h
│ │ │ │ ├── OuterStructs.h
│ │ │ │ ├── README.md
│ │ │ │ └── control.h
│ │ │ ├── bfs/
│ │ │ │ ├── CMakeLists.txt
│ │ │ │ ├── README.md
│ │ │ │ ├── bfs.cpp
│ │ │ │ └── bfsDirectionOpt.cpp
│ │ │ ├── bipart/
│ │ │ │ ├── CMakeLists.txt
│ │ │ │ ├── Coarsening.cpp
│ │ │ │ ├── Metric.cpp
│ │ │ │ ├── Partitioning.cpp
│ │ │ │ ├── README.md
│ │ │ │ ├── Refine.cpp
│ │ │ │ ├── bipart.cpp
│ │ │ │ └── bipart.h
│ │ │ ├── clustering/
│ │ │ │ ├── CMakeLists.txt
│ │ │ │ ├── README.md
│ │ │ │ ├── clustering.h
│ │ │ │ ├── leidenClustering.cpp
│ │ │ │ └── louvainClustering.cpp
│ │ │ ├── connected-components/
│ │ │ │ ├── CMakeLists.txt
│ │ │ │ ├── ConnectedComponents.cpp
│ │ │ │ └── README.md
│ │ │ ├── gmetis/
│ │ │ │ ├── CMakeLists.txt
│ │ │ │ ├── Coarsening.cpp
│ │ │ │ ├── GMetis.cpp
│ │ │ │ ├── GraphReader.h
│ │ │ │ ├── Metis.h
│ │ │ │ ├── Metric.cpp
│ │ │ │ ├── Partitioning.cpp
│ │ │ │ ├── README.md
│ │ │ │ └── Refine.cpp
│ │ │ ├── independentset/
│ │ │ │ ├── CMakeLists.txt
│ │ │ │ ├── IndependentSet.cpp
│ │ │ │ └── README.md
│ │ │ ├── k-core/
│ │ │ │ ├── CMakeLists.txt
│ │ │ │ ├── README.md
│ │ │ │ └── kcore.cpp
│ │ │ ├── k-truss/
│ │ │ │ ├── CMakeLists.txt
│ │ │ │ ├── K-Truss.cpp
│ │ │ │ ├── README.md
│ │ │ │ ├── Verify.cpp
│ │ │ │ └── bmktest2.py
│ │ │ ├── matching/
│ │ │ │ ├── CMakeLists.txt
│ │ │ │ ├── README.md
│ │ │ │ └── bipartite-mcm.cpp
│ │ │ ├── matrixcompletion/
│ │ │ │ ├── CMakeLists.txt
│ │ │ │ ├── README.md
│ │ │ │ ├── bipartite-gen.py
│ │ │ │ ├── commandLineParam.h
│ │ │ │ ├── matrixCompletion.cpp
│ │ │ │ ├── matrixCompletion.h
│ │ │ │ ├── parselog.sh
│ │ │ │ ├── plot.R
│ │ │ │ └── runexp.py
│ │ │ ├── pagerank/
│ │ │ │ ├── CMakeLists.txt
│ │ │ │ ├── PageRank-constants.h
│ │ │ │ ├── PageRank-pull.cpp
│ │ │ │ ├── PageRank-push.cpp
│ │ │ │ └── README.md
│ │ │ ├── pointstoanalysis/
│ │ │ │ ├── CMakeLists.txt
│ │ │ │ ├── PointsTo.cpp
│ │ │ │ ├── README.md
│ │ │ │ └── SparseBitVector.h
│ │ │ ├── preflowpush/
│ │ │ │ ├── CMakeLists.txt
│ │ │ │ ├── Preflowpush.cpp
│ │ │ │ └── README.md
│ │ │ ├── spanningtree/
│ │ │ │ ├── Boruvka.cpp
│ │ │ │ ├── CMakeLists.txt
│ │ │ │ ├── README.md
│ │ │ │ └── UnionFind.h
│ │ │ ├── sssp/
│ │ │ │ ├── CMakeLists.txt
│ │ │ │ ├── README.md
│ │ │ │ └── SSSP.cpp
│ │ │ └── triangle-counting/
│ │ │ ├── CMakeLists.txt
│ │ │ ├── README.md
│ │ │ └── Triangles.cpp
│ │ ├── distributed/
│ │ │ ├── CMakeLists.txt
│ │ │ ├── README.md
│ │ │ ├── betweennesscentrality/
│ │ │ │ ├── CMakeLists.txt
│ │ │ │ ├── README.md
│ │ │ │ ├── bc_level.cpp
│ │ │ │ ├── bc_level_cuda.cu
│ │ │ │ ├── bc_level_cuda.cuh
│ │ │ │ ├── bc_level_cuda.h
│ │ │ │ ├── bc_level_cuda.py
│ │ │ │ ├── bc_level_sync.hh
│ │ │ │ ├── bc_mr.cpp
│ │ │ │ ├── mrbc_bitset.hh
│ │ │ │ ├── mrbc_sync.hh
│ │ │ │ └── mrbc_tree.h
│ │ │ ├── bfs/
│ │ │ │ ├── CMakeLists.txt
│ │ │ │ ├── README.md
│ │ │ │ ├── bfs_pull.cpp
│ │ │ │ ├── bfs_pull_cuda.cu
│ │ │ │ ├── bfs_pull_cuda.cuh
│ │ │ │ ├── bfs_pull_cuda.h
│ │ │ │ ├── bfs_pull_cuda.py
│ │ │ │ ├── bfs_pull_sync.hh
│ │ │ │ ├── bfs_push.cpp
│ │ │ │ ├── bfs_push_cuda.cu
│ │ │ │ ├── bfs_push_cuda.cuh
│ │ │ │ ├── bfs_push_cuda.h
│ │ │ │ ├── bfs_push_cuda.py
│ │ │ │ └── bfs_push_sync.hh
│ │ │ ├── connected-components/
│ │ │ │ ├── CMakeLists.txt
│ │ │ │ ├── README.md
│ │ │ │ ├── cc_pull.cpp
│ │ │ │ ├── cc_pull_cuda.cu
│ │ │ │ ├── cc_pull_cuda.cuh
│ │ │ │ ├── cc_pull_cuda.h
│ │ │ │ ├── cc_pull_cuda.py
│ │ │ │ ├── cc_pull_sync.hh
│ │ │ │ ├── cc_push.cpp
│ │ │ │ ├── cc_push_cuda.cu
│ │ │ │ ├── cc_push_cuda.cuh
│ │ │ │ ├── cc_push_cuda.h
│ │ │ │ ├── cc_push_cuda.py
│ │ │ │ └── cc_push_sync.hh
│ │ │ ├── k-core/
│ │ │ │ ├── CMakeLists.txt
│ │ │ │ ├── README.md
│ │ │ │ ├── kcore_pull.cpp
│ │ │ │ ├── kcore_pull_cuda.cu
│ │ │ │ ├── kcore_pull_cuda.cuh
│ │ │ │ ├── kcore_pull_cuda.h
│ │ │ │ ├── kcore_pull_cuda.py
│ │ │ │ ├── kcore_pull_sync.hh
│ │ │ │ ├── kcore_push.cpp
│ │ │ │ ├── kcore_push_cuda.cu
│ │ │ │ ├── kcore_push_cuda.cuh
│ │ │ │ ├── kcore_push_cuda.h
│ │ │ │ ├── kcore_push_cuda.py
│ │ │ │ └── kcore_push_sync.hh
│ │ │ ├── matrixcompletion/
│ │ │ │ ├── CMakeLists.txt
│ │ │ │ ├── README.md
│ │ │ │ ├── matrixCompletion.cpp
│ │ │ │ └── matrixCompletion_sync.hh
│ │ │ ├── pagerank/
│ │ │ │ ├── CMakeLists.txt
│ │ │ │ ├── README.md
│ │ │ │ ├── pagerank_pull.cpp
│ │ │ │ ├── pagerank_pull_cuda.cu
│ │ │ │ ├── pagerank_pull_cuda.cuh
│ │ │ │ ├── pagerank_pull_cuda.h
│ │ │ │ ├── pagerank_pull_cuda.py
│ │ │ │ ├── pagerank_pull_sync.hh
│ │ │ │ ├── pagerank_push.cpp
│ │ │ │ ├── pagerank_push_cuda.cu
│ │ │ │ ├── pagerank_push_cuda.cuh
│ │ │ │ ├── pagerank_push_cuda.h
│ │ │ │ ├── pagerank_push_cuda.py
│ │ │ │ └── pagerank_push_sync.hh
│ │ │ ├── partition/
│ │ │ │ ├── CMakeLists.txt
│ │ │ │ └── partition.cpp
│ │ │ ├── sssp/
│ │ │ │ ├── CMakeLists.txt
│ │ │ │ ├── README.md
│ │ │ │ ├── sssp_pull.cpp
│ │ │ │ ├── sssp_pull_cuda.cu
│ │ │ │ ├── sssp_pull_cuda.cuh
│ │ │ │ ├── sssp_pull_cuda.h
│ │ │ │ ├── sssp_pull_cuda.py
│ │ │ │ ├── sssp_pull_sync.hh
│ │ │ │ ├── sssp_push.cpp
│ │ │ │ ├── sssp_push_cuda.cu
│ │ │ │ ├── sssp_push_cuda.cuh
│ │ │ │ ├── sssp_push_cuda.h
│ │ │ │ ├── sssp_push_cuda.py
│ │ │ │ └── sssp_push_sync.hh
│ │ │ └── triangle-counting/
│ │ │ ├── CMakeLists.txt
│ │ │ ├── README.md
│ │ │ ├── tc.cpp
│ │ │ ├── tc_cuda.cu
│ │ │ ├── tc_cuda.cuh
│ │ │ ├── tc_cuda.h
│ │ │ └── tc_cuda.py
│ │ └── gpu/
│ │ ├── CMakeLists.txt
│ │ ├── README.md
│ │ ├── bfs/
│ │ │ ├── CMakeLists.txt
│ │ │ ├── README.md
│ │ │ ├── bfs.cu
│ │ │ └── support.cu
│ │ ├── connected-components/
│ │ │ ├── CMakeLists.txt
│ │ │ ├── README.md
│ │ │ ├── cc.cu
│ │ │ └── support.cu
│ │ ├── independentset/
│ │ │ ├── CMakeLists.txt
│ │ │ ├── README.md
│ │ │ ├── mis.cu
│ │ │ └── support.cu
│ │ ├── matrixcompletion/
│ │ │ ├── CMakeLists.txt
│ │ │ ├── README.md
│ │ │ ├── SGDAsyncEdgeCu.h
│ │ │ ├── SGDCommonCu.h
│ │ │ ├── SGDGraphCu.h
│ │ │ ├── sgd.cu
│ │ │ └── support.cu
│ │ ├── pagerank/
│ │ │ ├── CMakeLists.txt
│ │ │ ├── README.md
│ │ │ ├── pagerank.cu
│ │ │ └── support.cu
│ │ ├── pointstoanalysis/
│ │ │ ├── CMakeLists.txt
│ │ │ ├── README.md
│ │ │ ├── andersen.cu
│ │ │ ├── andersen.h
│ │ │ ├── pta.cu
│ │ │ ├── pta_tuning.h
│ │ │ └── support.cu
│ │ ├── spanningtree/
│ │ │ ├── CMakeLists.txt
│ │ │ ├── README.md
│ │ │ ├── mst-tex.cu
│ │ │ ├── mst.cu
│ │ │ ├── mst.h
│ │ │ └── support.cu
│ │ ├── sssp/
│ │ │ ├── CMakeLists.txt
│ │ │ ├── README.md
│ │ │ ├── sssp.cu
│ │ │ └── support.cu
│ │ └── triangle-counting/
│ │ ├── CMakeLists.txt
│ │ ├── README.md
│ │ ├── support.cu
│ │ └── tc.cu
│ ├── eda/
│ │ ├── CMakeLists.txt
│ │ └── cpu/
│ │ ├── CMakeLists.txt
│ │ ├── aig-rewriting/
│ │ │ ├── CMakeLists.txt
│ │ │ ├── README.md
│ │ │ ├── algorithms/
│ │ │ │ ├── ChoiceManager.cpp
│ │ │ │ ├── ChoiceManager.h
│ │ │ │ ├── CutManager.cpp
│ │ │ │ ├── CutManager.h
│ │ │ │ ├── CutPool.cpp
│ │ │ │ ├── CutPool.h
│ │ │ │ ├── NPNManager.cpp
│ │ │ │ ├── NPNManager.h
│ │ │ │ ├── PreCompGraphManager.cpp
│ │ │ │ ├── PreCompGraphManager.h
│ │ │ │ ├── PriorityCutManager.cpp
│ │ │ │ ├── PriorityCutManager.h
│ │ │ │ ├── PriorityCutPool.cpp
│ │ │ │ ├── PriorityCutPool.h
│ │ │ │ ├── ReconvDrivenCut.cpp
│ │ │ │ ├── ReconvDrivenCut.h
│ │ │ │ ├── RewriteManager.cpp
│ │ │ │ └── RewriteManager.h
│ │ │ ├── functional/
│ │ │ │ ├── BitVectorPool.cpp
│ │ │ │ ├── BitVectorPool.h
│ │ │ │ ├── FunctionHandler.h
│ │ │ │ ├── FunctionHandler32.h
│ │ │ │ ├── FunctionUtil.cpp
│ │ │ │ └── FunctionUtil.h
│ │ │ ├── main.cpp
│ │ │ ├── misc/
│ │ │ │ └── util/
│ │ │ │ ├── utilString.cpp
│ │ │ │ └── utilString.h
│ │ │ ├── parsers/
│ │ │ │ ├── AigParser.cpp
│ │ │ │ ├── AigParser.h
│ │ │ │ ├── LookupTableParser.cpp
│ │ │ │ ├── LookupTableParser.h
│ │ │ │ ├── semantic_error.cpp
│ │ │ │ ├── semantic_error.h
│ │ │ │ ├── syntax_error.cpp
│ │ │ │ ├── syntax_error.h
│ │ │ │ ├── unexpected_eof.cpp
│ │ │ │ └── unexpected_eof.h
│ │ │ ├── subjectgraph/
│ │ │ │ └── aig/
│ │ │ │ ├── Aig.cpp
│ │ │ │ └── Aig.h
│ │ │ ├── writers/
│ │ │ │ ├── AigWriter.cpp
│ │ │ │ ├── AigWriter.h
│ │ │ │ ├── BlifWriter.cpp
│ │ │ │ └── BlifWriter.h
│ │ │ └── xxHash/
│ │ │ ├── xxhash.c
│ │ │ └── xxhash.h
│ │ └── sproute/
│ │ ├── BoilerPlate.h
│ │ ├── CMakeLists.txt
│ │ ├── DataProc.h
│ │ ├── DataType.h
│ │ ├── EdgeShift.h
│ │ ├── LICENSE
│ │ ├── README.md
│ │ ├── RSMT.h
│ │ ├── RipUp.h
│ │ ├── bitmap_image.hpp
│ │ ├── bitmap_test.cpp
│ │ ├── bookshelf_IO.c
│ │ ├── bookshelf_IO.h
│ │ ├── cong.c
│ │ ├── cong.h
│ │ ├── dist.c
│ │ ├── dist.h
│ │ ├── dl.c
│ │ ├── dl.h
│ │ ├── err.c
│ │ ├── err.h
│ │ ├── flute-ckt
│ │ ├── flute-ckt.c
│ │ ├── flute-net
│ │ ├── flute-net.c
│ │ ├── flute.h
│ │ ├── flute_mst.h
│ │ ├── global.h
│ │ ├── heap.c
│ │ ├── heap.h
│ │ ├── main.cpp
│ │ ├── maze.h
│ │ ├── maze3D.h
│ │ ├── maze_finegrain.h
│ │ ├── maze_finegrain_concurrent.h
│ │ ├── maze_finegrain_lateupdate.h
│ │ ├── maze_lock.h
│ │ ├── memAlloc.c
│ │ ├── memAlloc.h
│ │ ├── mst2.c
│ │ ├── mst2.h
│ │ ├── neighbors.c
│ │ ├── neighbors.h
│ │ ├── parallel_router_morphgraph.cpp
│ │ ├── rand-pts.c
│ │ ├── route.h
│ │ └── utility.h
│ ├── libdistbench/
│ │ ├── CMakeLists.txt
│ │ ├── include/
│ │ │ └── DistBench/
│ │ │ ├── Input.h
│ │ │ ├── MiningStart.h
│ │ │ ├── Output.h
│ │ │ └── Start.h
│ │ └── src/
│ │ ├── Input.cpp
│ │ ├── Output.cpp
│ │ └── Start.cpp
│ ├── liblonestar/
│ │ ├── CMakeLists.txt
│ │ ├── include/
│ │ │ └── Lonestar/
│ │ │ ├── BFS_SSSP.h
│ │ │ ├── BoilerPlate.h
│ │ │ └── Utils.h
│ │ └── src/
│ │ └── BoilerPlate.cpp
│ ├── mining/
│ │ ├── CMakeLists.txt
│ │ ├── README.md
│ │ ├── cpu/
│ │ │ ├── CMakeLists.txt
│ │ │ ├── frequent-subgraph-mining/
│ │ │ │ ├── CMakeLists.txt
│ │ │ │ ├── README.md
│ │ │ │ ├── fsm.cpp
│ │ │ │ └── fsm.h
│ │ │ ├── k-clique-listing/
│ │ │ │ ├── CMakeLists.txt
│ │ │ │ ├── README.md
│ │ │ │ ├── kcl.cpp
│ │ │ │ └── kcl.h
│ │ │ ├── motif-counting/
│ │ │ │ ├── CMakeLists.txt
│ │ │ │ ├── README.md
│ │ │ │ ├── motif.cpp
│ │ │ │ └── motif.h
│ │ │ ├── subgraph-listing/
│ │ │ │ ├── CMakeLists.txt
│ │ │ │ ├── README.mb
│ │ │ │ ├── sgl_cycle.cpp
│ │ │ │ └── sgl_diamond.cpp
│ │ │ └── triangle-counting/
│ │ │ ├── CMakeLists.txt
│ │ │ ├── README.md
│ │ │ ├── tc.h
│ │ │ └── tc_mine.cpp
│ │ ├── gpu/
│ │ │ ├── CMakeLists.txt
│ │ │ ├── frequent-subgraph-mining/
│ │ │ │ ├── CMakeLists.txt
│ │ │ │ ├── README.md
│ │ │ │ ├── fsm.cu
│ │ │ │ ├── fsm.h
│ │ │ │ └── fsm_gpu.cpp
│ │ │ ├── k-clique-listing/
│ │ │ │ ├── CMakeLists.txt
│ │ │ │ ├── README.md
│ │ │ │ ├── kcl.cu
│ │ │ │ ├── kcl.h
│ │ │ │ └── kcl_gpu.cpp
│ │ │ ├── motif-counting/
│ │ │ │ ├── CMakeLists.txt
│ │ │ │ ├── README.md
│ │ │ │ ├── motif.cu
│ │ │ │ ├── motif.h
│ │ │ │ └── motif_gpu.cpp
│ │ │ └── triangle-counting/
│ │ │ ├── CMakeLists.txt
│ │ │ ├── README.md
│ │ │ ├── tc.h
│ │ │ ├── tc_mine.cu
│ │ │ └── tc_mine_gpu.cpp
│ │ └── libminingbench/
│ │ ├── CMakeLists.txt
│ │ ├── include/
│ │ │ └── MiningBench/
│ │ │ └── Start.h
│ │ └── src/
│ │ ├── Input.cpp
│ │ └── Start.cpp
│ ├── scientific/
│ │ ├── CMakeLists.txt
│ │ ├── cpu/
│ │ │ ├── CMakeLists.txt
│ │ │ ├── barneshut/
│ │ │ │ ├── Barneshut.cpp
│ │ │ │ ├── CMakeLists.txt
│ │ │ │ ├── Point.h
│ │ │ │ └── README.md
│ │ │ ├── delaunayrefinement/
│ │ │ │ ├── CMakeLists.txt
│ │ │ │ ├── Cavity.h
│ │ │ │ ├── DelaunayRefinement.cpp
│ │ │ │ ├── Edge.h
│ │ │ │ ├── Element.h
│ │ │ │ ├── Mesh.h
│ │ │ │ ├── README.md
│ │ │ │ ├── Subgraph.h
│ │ │ │ ├── Tuple.h
│ │ │ │ └── Verifier.h
│ │ │ ├── delaunaytriangulation/
│ │ │ │ ├── CMakeLists.txt
│ │ │ │ ├── Cavity.h
│ │ │ │ ├── DelaunayTriangulation.cpp
│ │ │ │ ├── DelaunayTriangulationDet.cpp
│ │ │ │ ├── Element.cpp
│ │ │ │ ├── Element.h
│ │ │ │ ├── Graph.h
│ │ │ │ ├── Point.h
│ │ │ │ ├── QuadTree.h
│ │ │ │ ├── README.md
│ │ │ │ ├── Tuple.h
│ │ │ │ └── Verifier.h
│ │ │ └── longestedge/
│ │ │ ├── CMakeLists.txt
│ │ │ ├── README.md
│ │ │ ├── out/
│ │ │ │ └── .gitignore
│ │ │ ├── src/
│ │ │ │ ├── LongestEdge.cpp
│ │ │ │ ├── conditions/
│ │ │ │ │ ├── ConditionChecker.h
│ │ │ │ │ ├── DummyConditionChecker.h
│ │ │ │ │ └── TerrainConditionChecker.h
│ │ │ │ ├── libmgrs/
│ │ │ │ │ ├── LICENSE
│ │ │ │ │ ├── mgrs.c
│ │ │ │ │ ├── mgrs.h
│ │ │ │ │ ├── polarst.c
│ │ │ │ │ ├── polarst.h
│ │ │ │ │ ├── tranmerc.c
│ │ │ │ │ ├── tranmerc.h
│ │ │ │ │ ├── ups.c
│ │ │ │ │ ├── ups.h
│ │ │ │ │ ├── utm.c
│ │ │ │ │ └── utm.h
│ │ │ │ ├── model/
│ │ │ │ │ ├── Coordinates.h
│ │ │ │ │ ├── EdgeData.h
│ │ │ │ │ ├── Graph.h
│ │ │ │ │ ├── Map.cpp
│ │ │ │ │ ├── Map.h
│ │ │ │ │ ├── NodeData.h
│ │ │ │ │ └── ProductionState.h
│ │ │ │ ├── productions/
│ │ │ │ │ ├── Production.h
│ │ │ │ │ ├── Production1.h
│ │ │ │ │ ├── Production2.h
│ │ │ │ │ ├── Production3.h
│ │ │ │ │ ├── Production4.h
│ │ │ │ │ ├── Production5.h
│ │ │ │ │ └── Production6.h
│ │ │ │ ├── readers/
│ │ │ │ │ ├── AsciiReader.cpp
│ │ │ │ │ ├── AsciiReader.h
│ │ │ │ │ ├── InpReader.cpp
│ │ │ │ │ ├── InpReader.h
│ │ │ │ │ ├── SrtmReader.cpp
│ │ │ │ │ └── SrtmReader.h
│ │ │ │ ├── utils/
│ │ │ │ │ ├── ConnectivityManager.h
│ │ │ │ │ ├── GaloisUtils.h
│ │ │ │ │ ├── GraphGenerator.h
│ │ │ │ │ ├── MyGraphFormatWriter.h
│ │ │ │ │ ├── Utils.cpp
│ │ │ │ │ └── Utils.h
│ │ │ │ └── writers/
│ │ │ │ ├── InpWriter.cpp
│ │ │ │ ├── InpWriter.h
│ │ │ │ ├── TriangleFormatWriter.cpp
│ │ │ │ └── TriangleFormatWriter.h
│ │ │ └── test/
│ │ │ ├── TestMain.cpp
│ │ │ ├── catch.hpp
│ │ │ ├── model/
│ │ │ │ ├── MapTest.cpp
│ │ │ │ └── ProductionStateTest.cpp
│ │ │ ├── productions/
│ │ │ │ └── Production1Test.cpp
│ │ │ ├── testUtils.cpp
│ │ │ └── utils/
│ │ │ ├── ConnectivityManagerTest.cpp
│ │ │ └── UtilsTest.cpp
│ │ └── gpu/
│ │ ├── CMakeLists.txt
│ │ ├── README.md
│ │ ├── barneshut/
│ │ │ ├── CMakeLists.txt
│ │ │ ├── LICENSE.md
│ │ │ ├── README.md
│ │ │ ├── bh.cu
│ │ │ └── bh_tuning.h
│ │ └── delaunayrefinement/
│ │ ├── CMakeLists.txt
│ │ ├── README.md
│ │ ├── devel.h
│ │ ├── dmr-nontex.cu
│ │ ├── dmr.cu
│ │ ├── dmr.h
│ │ ├── dmrggc.inc
│ │ ├── geomprim.h
│ │ ├── main.inc
│ │ └── meshfiles.h
│ └── tutorial_examples/
│ ├── CMakeLists.txt
│ ├── ConflictAwareTorus.cpp
│ ├── CountLevels.cpp
│ ├── ExampleWrappedWorklist.cpp
│ ├── GraphTraversalPullOperator.cpp
│ ├── GraphTraversalPushOperator.cpp
│ ├── GraphTraversalSerial.cpp
│ ├── HelloWorld.cpp
│ ├── SSSPPullSimple.cpp
│ ├── SSSPPushSimple.cpp
│ ├── SSSPsimple.cpp
│ ├── SpanningTree.cpp
│ ├── ThirdPartyMalloc.cpp
│ ├── Torus.cpp
│ ├── TorusConstruction.cpp
│ └── TorusImproved.cpp
├── pyproject.toml
├── python/
│ ├── CMakeLists.txt
│ └── galois/
│ ├── CMakeLists.txt
│ ├── __init__.py
│ ├── _bfs.pyx
│ ├── _connected_components.pyx
│ ├── _pagerank.pyx
│ ├── _sssp.pyx
│ ├── bfs.py
│ ├── connected_components.py
│ ├── cpp/
│ │ ├── __init__.pxd
│ │ ├── libgalois/
│ │ │ ├── Galois.pxd
│ │ │ ├── Timer.pxd
│ │ │ ├── Worklist.pxd
│ │ │ ├── __init__.pxd
│ │ │ └── graphs/
│ │ │ ├── Graph.pxd
│ │ │ ├── Util.pxd
│ │ │ └── __init__.pxd
│ │ └── libstd/
│ │ ├── __init__.pxd
│ │ └── atomic.pxd
│ ├── pagerank.py
│ ├── shmem.pxd
│ └── shmem.pyx
├── scripts/
│ ├── CMakeLists.txt
│ ├── abelian_log_parser.py
│ ├── check_format.sh
│ ├── constraints_checking/
│ │ └── parse_dump.rb
│ ├── docker/
│ │ ├── Dockerfile
│ │ ├── Dockerfile.msan
│ │ ├── README.md
│ │ ├── msan/
│ │ │ ├── build-boost.sh
│ │ │ ├── build-llvm.sh
│ │ │ └── config-galois.sh
│ │ └── run-image.sh
│ ├── experimental/
│ │ ├── abelian_log_parser_analysis.py
│ │ ├── abelian_log_parser_deprecated.py
│ │ ├── abelian_log_parser_multipleRuns.py
│ │ ├── abelian_log_parser_multipleRuns2.py
│ │ ├── bmk2/
│ │ │ ├── __init__.py
│ │ │ ├── bispec.py
│ │ │ ├── bmk2.py
│ │ │ ├── checkers.py
│ │ │ ├── collect.py
│ │ │ ├── collect_multi.py
│ │ │ ├── common.py
│ │ │ ├── config.py
│ │ │ ├── convert.py
│ │ │ ├── convgraph.py
│ │ │ ├── core.py
│ │ │ ├── extras.py
│ │ │ ├── inputdb.py
│ │ │ ├── inputprops.py
│ │ │ ├── logproc.py
│ │ │ ├── mapfile.py
│ │ │ ├── measure_energy.py
│ │ │ ├── opdb.py
│ │ │ ├── overlays.py
│ │ │ ├── perf.py
│ │ │ ├── rsinfo.py
│ │ │ ├── sconvert.py
│ │ │ ├── summlog.py
│ │ │ └── test2.py
│ │ ├── buildFunc.sh
│ │ ├── buildMultiCompiler.sh
│ │ ├── buildMultiVersion.sh
│ │ ├── buildOnce.sh
│ │ ├── distbmk2/
│ │ │ ├── README
│ │ │ ├── bmk2.cfg
│ │ │ ├── bmkprops.py
│ │ │ ├── bmktest2.py
│ │ │ ├── dist.bispec
│ │ │ ├── dist.inputdb
│ │ │ └── dist.inputprops
│ │ ├── galois_license_fixer.py
│ │ ├── githubbmk2_setup/
│ │ │ ├── README
│ │ │ ├── bmk2.cfg
│ │ │ ├── bmkprops.py
│ │ │ ├── bmktest2.py
│ │ │ ├── defaultrunscript.sh
│ │ │ ├── lonestar.bispec
│ │ │ ├── lonestar.inputdb
│ │ │ └── lonestar.inputprops
│ │ ├── heterogeneousGalois/
│ │ │ ├── CPU_run_scripts_stampede/
│ │ │ │ ├── ruby_BFS_CC_SSSP_rmat_USA_twitter_Pull.sh
│ │ │ │ ├── ruby_BFS_CC_SSSP_rmat_USA_twitter_Pull_Vcut.sh
│ │ │ │ ├── ruby_BFS_CC_SSSP_rmat_USA_twitter_Push.sh
│ │ │ │ └── ruby_BFS_CC_SSSP_rmat_USA_twitter_Push_Vcut.sh
│ │ │ ├── README_compiler
│ │ │ ├── batch_bridges_all.sh
│ │ │ ├── batch_single-host_multi-device_all.sh
│ │ │ ├── batch_stampede_all.sh
│ │ │ ├── batch_verify.sh
│ │ │ ├── compile.sh
│ │ │ ├── compile_all.sh
│ │ │ ├── cuda_compile.sh
│ │ │ ├── run_bridges.template.sbatch
│ │ │ ├── run_bridges_all.sh
│ │ │ ├── run_single-host_multi-device_all.sh
│ │ │ ├── run_stampede.template.sbatch
│ │ │ ├── run_stampede_all.sh
│ │ │ └── verify.sh
│ │ ├── lonestarbmk2/
│ │ │ ├── README
│ │ │ ├── bmk2.cfg
│ │ │ ├── bmkprops.py
│ │ │ ├── bmktest2.py
│ │ │ ├── defaultrunscript.sh
│ │ │ ├── lonestar.bispec
│ │ │ ├── lonestar.inputdb
│ │ │ └── lonestar.inputprops
│ │ ├── older/
│ │ │ ├── backend.pl
│ │ │ ├── prune_headers_function.pl
│ │ │ ├── prune_headers_line.pl
│ │ │ ├── report.pl
│ │ │ ├── report_vtune.pl
│ │ │ ├── run_boruvka.pl
│ │ │ ├── run_clustering.pl
│ │ │ ├── run_delaunayrefinement.pl
│ │ │ ├── run_sssp.pl
│ │ │ └── vtune_sssp.pl
│ │ ├── pangolin/
│ │ │ ├── batch_verify.sh
│ │ │ ├── fsm.citeseer.2.300
│ │ │ ├── fsm.citeseer.2.500
│ │ │ ├── fsm.patent.2.1000
│ │ │ ├── fsm.patent.2.300
│ │ │ ├── fsm.patent.2.500
│ │ │ ├── fsm.patent.2.5000
│ │ │ ├── kcl.citeseer.4
│ │ │ ├── kcl.citeseer.5
│ │ │ ├── kcl.mico.4
│ │ │ ├── kcl.mico.5
│ │ │ ├── kcl.patent.3
│ │ │ ├── kcl.patent.4
│ │ │ ├── kcl.patent.5
│ │ │ ├── motif.citeseer.3
│ │ │ ├── motif.citeseer.4
│ │ │ ├── motif.mico.3
│ │ │ ├── motif.mico.4
│ │ │ ├── motif.patent.3
│ │ │ ├── motif.patent.4
│ │ │ ├── result_checker.py
│ │ │ └── verify.sh
│ │ ├── runBFS.sh
│ │ └── runSSSP.sh
│ ├── find_ifdefs.sh
│ ├── galois_log_parser.R
│ ├── galois_log_parser_minimal.R
│ ├── gitFindBigCommits.sh
│ ├── hcompiler.sh
│ ├── intel_study_scripts/
│ │ ├── README.md
│ │ ├── download_inputs.sh
│ │ ├── run_bc.sh
│ │ ├── run_bfs.sh
│ │ ├── run_cc.sh
│ │ ├── run_pr.sh
│ │ ├── run_sssp.sh
│ │ └── run_tc.sh
│ ├── iss_load_modules.sh
│ ├── make_dist.sh.in
│ ├── merge_vtune.pl
│ ├── plot_lonestar_apps.R
│ ├── quick_plot.pl
│ ├── rcat.py
│ ├── report.py
│ ├── report_vtune.pl
│ ├── result_checker.py
│ ├── run.py
│ ├── run_vtune.pl
│ ├── sparse-matrices/
│ │ ├── diff_edgelists.py
│ │ ├── iperm2order.pl
│ │ ├── mtx2edgelist.pl
│ │ └── reorder.pl
│ ├── tcp_starter.py
│ ├── visual/
│ │ ├── plot2Dmesh.m
│ │ ├── plotGraph.R
│ │ ├── plotGraph3d.R
│ │ ├── plotTimeStamps.m
│ │ └── triplot.m
│ └── vtune.sh
├── setup.py
├── tests/
│ └── test_imports.py
└── tools/
├── CMakeLists.txt
├── dist-graph-convert/
│ ├── CMakeLists.txt
│ ├── dist-graph-convert-helpers.cpp
│ ├── dist-graph-convert-helpers.h
│ └── dist-graph-convert.cpp
├── graph-convert/
│ ├── CMakeLists.txt
│ ├── graph-convert-huge.cpp
│ ├── graph-convert.cpp
│ └── test-inputs/
│ ├── sample.csv
│ ├── with-blank-lines.edgelist
│ ├── with-blank-lines.edgelist.expected
│ ├── with-comments.edgelist
│ └── with-comments.edgelist.expected
├── graph-remap/
│ ├── CMakeLists.txt
│ └── graph-remap.cpp
└── graph-stats/
├── CMakeLists.txt
└── graph-stats.cpp
================================================
FILE CONTENTS
================================================
================================================
FILE: .circleci/config.yml
================================================
version: 2.1
common_step: &cmake_build_test
- run: |
cmake --build /tmp/build --target input
if [ -n "$CIRCLE_PULL_REQUEST" ]; then \
subset=$(/bin/bash .circleci/longest_common_path.sh); \
echo "Changes of ${CIRCLE_SHA1} are all under $subset"; \
fi
cmake --build /tmp/build/${subset:-.} --parallel 2
# Run tests as non-root otherwise MPI will complain
(cd /tmp/build/${subset:-.} \
&& chown -R runner . \
&& su runner -c "ctest --output-on-failure --label-regex quick --parallel 2")
# TODO: These builds are currently configured to
# install the needed dependencies in each container
# at the start of each build. The dependencies aren't huge,
# but that is slower and does waste some bandwidth.
# We should eventually roll the set up for each
# container into a separate dockerfile and push custom
# build images to dockerhub so that setting up packages
# during the actual CI testing is no longer necessary.
jobs:
"CheckFormat":
docker:
- image: ubuntu:bionic
steps:
- checkout
- run: |
apt-get -q update -y
apt-get -q install -y apt-transport-https ca-certificates git gnupg software-properties-common wget
wget -O - https://apt.llvm.org/llvm-snapshot.gpg.key 2>/dev/null | apt-key add -
apt-add-repository -y 'deb https://apt.llvm.org/bionic/ llvm-toolchain-bionic-10 main'
apt-get -q update -y
- run: git submodule sync
- run: git submodule update --init
- run: |
apt-get -q install -y \
clang-format-10
update-alternatives --install /usr/bin/clang-format clang-format /usr/bin/clang-format-10 50
if [ -n "$CIRCLE_PULL_REQUEST" ]; then \
subset=$(/bin/bash .circleci/longest_common_path.sh); \
echo "Changes of ${CIRCLE_SHA1} are all under $subset"; \
fi
scripts/check_format.sh ${subset:-.}
"Sanitize":
docker:
- image: ubuntu:bionic
steps:
- checkout
- run: |
apt-get -q update -y
apt-get -q install -y apt-transport-https ca-certificates git gnupg software-properties-common wget
wget -O - https://apt.kitware.com/keys/kitware-archive-latest.asc 2>/dev/null | apt-key add -
wget -O - https://apt.llvm.org/llvm-snapshot.gpg.key 2>/dev/null | apt-key add -
apt-add-repository -y 'ppa:ubuntu-toolchain-r/test'
apt-add-repository -y 'deb https://apt.llvm.org/bionic/ llvm-toolchain-bionic-10 main'
apt-add-repository -y 'deb https://apt.kitware.com/ubuntu/ bionic main'
apt-add-repository -y 'ppa:mhier/libboost-latest'
apt-get -q update -y
- run: git submodule sync
- run: git submodule update --init
- run: |
apt-get -q install -y \
clang-10 \
cmake \
libboost1.70-dev \
libeigen3-dev \
openmpi-bin \
libopenmpi-dev \
llvm-7-dev \
libz-dev \
libfmt-dev
update-alternatives --install /usr/bin/clang clang /usr/bin/clang-10 50
update-alternatives --install /usr/bin/clang++ clang++ /usr/bin/clang++-10 50
chmod 755 /root
useradd runner
mkdir -p /tmp/build
cmake -S . -B /tmp/build \
-DCMAKE_C_COMPILER=clang \
-DCMAKE_CXX_COMPILER=clang++ \
-DGALOIS_USE_SANITIZER="Address;Undefined"
- <<: *cmake_build_test
"Debian":
docker:
- image: debian:10
steps:
- checkout
- run: |
apt-get -q update -y
apt-get -q install -y git
- run: git submodule sync
- run: git submodule update --init
- run: |
apt-get -q install -y \
cmake \
g++ \
gcc \
libboost-iostreams-dev \
libboost-serialization-dev \
libeigen3-dev \
libmpich-dev \
llvm-7-dev \
mpich \
zlib1g-dev \
libfmt-dev
chmod 755 /root
useradd runner
mkdir -p /tmp/build
cmake -S . -B /tmp/build \
-DGALOIS_ENABLE_DIST=ON
- <<: *cmake_build_test
"Ubuntu-18_04":
docker:
- image: ubuntu:18.04
steps:
- checkout
- run: |
apt-get -q update -y
apt-get -q install -y apt-transport-https ca-certificates git gnupg software-properties-common wget
wget -O - https://apt.kitware.com/keys/kitware-archive-latest.asc 2>/dev/null | apt-key add -
apt-add-repository 'deb https://apt.kitware.com/ubuntu/ bionic main'
apt-get -q update -y
- run: git submodule sync
- run: git submodule update --init
- run: |
apt-get -q install -y \
cmake \
g++ \
gcc \
libboost-all-dev \
libeigen3-dev \
libopenmpi-dev \
llvm-7-dev \
openmpi-bin \
ssh \
libfmt-dev
chmod 755 /root
useradd runner
mkdir -p /tmp/build
cmake -S . -B /tmp/build \
-DGALOIS_ENABLE_DIST=ON
- <<: *cmake_build_test
"Ubuntu-18_04-cuda11_0_3-build-only":
docker:
- image: nvidia/cuda:11.0.3-devel-ubuntu18.04
steps:
- checkout
- run: |
apt-get -q update -y
apt-get -q install -y apt-transport-https ca-certificates git gnupg software-properties-common wget
wget -O - https://apt.kitware.com/keys/kitware-archive-latest.asc 2>/dev/null | apt-key add -
apt-add-repository 'deb https://apt.kitware.com/ubuntu/ bionic main'
apt-get -q update -y
- run: git submodule sync
- run: git submodule update --init
- run: |
apt-get -q install -y \
cmake \
g++ \
gcc \
libboost-all-dev \
libeigen3-dev \
libopenmpi-dev \
llvm-7-dev \
openmpi-bin \
ssh \
libfmt-dev
cmake -S . -B /tmp/build \
-DGALOIS_ENABLE_DIST=ON \
-DGALOIS_ENABLE_GPU=ON
cmake --build /tmp/build --target input
cmake --build /tmp/build --parallel 2
"Ubuntu-18_04-cuda11_1_1-build-only":
docker:
- image: nvidia/cuda:11.1.1-devel-ubuntu18.04
steps:
- checkout
- run: |
apt-get -q update -y
apt-get -q install -y apt-transport-https ca-certificates git gnupg software-properties-common wget
wget -O - https://apt.kitware.com/keys/kitware-archive-latest.asc 2>/dev/null | apt-key add -
apt-add-repository 'deb https://apt.kitware.com/ubuntu/ bionic main'
apt-get -q update -y
- run: git submodule sync
- run: git submodule update --init
- run: |
apt-get -q install -y \
cmake \
g++ \
gcc \
libboost-all-dev \
libeigen3-dev \
libopenmpi-dev \
llvm-7-dev \
openmpi-bin \
ssh \
libfmt-dev
cmake -S . -B /tmp/build \
-DGALOIS_ENABLE_DIST=ON \
-DGALOIS_ENABLE_GPU=ON
cmake --build /tmp/build --target input
cmake --build /tmp/build --parallel 2
"CentOS-8-gcc":
docker:
- image: centos:8
steps:
- checkout
- run: |
# CentOS Linux 8 has reached End Of Life (EOL) on December 31st, 2021
ls /etc/yum.repos.d/ > /dev/null 2>&1
sed -i 's/mirrorlist/#mirrorlist/g' /etc/yum.repos.d/CentOS-*
sed -i 's|#baseurl=http://mirror.centos.org|baseurl=http://vault.centos.org|g' /etc/yum.repos.d/CentOS-*
- run: |
# fmt-devel is in EPEL
yum -y -q install https://dl.fedoraproject.org/pub/epel/epel-release-latest-8.noarch.rpm
# eigen3-devel needs PowerTools packages
yum -y -q install dnf-plugins-core
yum -y -q config-manager --set-enabled powertools
yum -y -q install git
- run: git submodule sync
- run: git submodule update --init
- run: |
yum -y -q install \
boost-devel \
cmake \
eigen3-devel \
gcc \
gcc-c++ \
llvm-devel \
llvm-static \
make \
mpich-devel \
ncurses-devel \
wget \
zlib-devel \
fmt-devel
wget -O - https://github.com/Kitware/CMake/releases/download/v3.17.0/cmake-3.17.0-Linux-x86_64.tar.gz | tar -xz -f - -C /usr/local
ln -s /usr/local/cmake-3.17.0-Linux-x86_64/bin/cmake /usr/local/bin/cmake
ln -s /usr/local/cmake-3.17.0-Linux-x86_64/bin/ctest /usr/local/bin/ctest
# Make the "module" command work in the subsequent shell sessions.
cat /etc/profile.d/modules.sh >> $BASH_ENV
echo "module load mpi" >> $BASH_ENV
- run: |
chmod 755 /root
useradd runner
mkdir -p /tmp/build
cmake -S . -B /tmp/build \
-DGALOIS_ENABLE_DIST=ON
- <<: *cmake_build_test
"CentOS-8-clang":
docker:
- image: centos:8
steps:
- checkout
- run: |
# CentOS Linux 8 has reached End Of Life (EOL) on December 31st, 2021
ls /etc/yum.repos.d/ > /dev/null 2>&1
sed -i 's/mirrorlist/#mirrorlist/g' /etc/yum.repos.d/CentOS-*
sed -i 's|#baseurl=http://mirror.centos.org|baseurl=http://vault.centos.org|g' /etc/yum.repos.d/CentOS-*
- run: |
# fmt-devel is in EPEL
yum -y -q install https://dl.fedoraproject.org/pub/epel/epel-release-latest-8.noarch.rpm
# eigen3-devel needs PowerTools packages
yum -y -q install dnf-plugins-core
yum -y -q config-manager --set-enabled powertools
yum -y -q install git
- run: git submodule sync
- run: git submodule update --init
- run: |
yum -y -q install \
boost-devel \
eigen3-devel \
llvm-devel \
llvm-static \
llvm-toolset \
make \
openmpi-devel \
ncurses-devel \
wget \
zlib-devel \
fmt-devel
wget -O - https://github.com/Kitware/CMake/releases/download/v3.17.0/cmake-3.17.0-Linux-x86_64.tar.gz | tar -xz -f - -C /usr/local
ln -s /usr/local/cmake-3.17.0-Linux-x86_64/bin/cmake /usr/local/bin/cmake
ln -s /usr/local/cmake-3.17.0-Linux-x86_64/bin/ctest /usr/local/bin/ctest
# Make the "module" command work in the subsequent shell sessions.
cat /etc/profile.d/modules.sh >> $BASH_ENV
echo "module load mpi" >> $BASH_ENV
- run: |
chmod 755 /root
useradd runner
mkdir -p /tmp/build
cmake -S . -B /tmp/build \
-DCMAKE_C_COMPILER=clang \
-DCMAKE_CXX_COMPILER=clang++ \
# -DGALOIS_ENABLE_DIST=ON
- <<: *cmake_build_test
"Arch":
docker:
- image: archlinux:base
steps:
- checkout
- run: |
pacman -Syu --noconfirm
pacman -q -S --noconfirm git
- run: git submodule sync
- run: git submodule update --init
- run: |
# NB(ddn): make requires libffi but its package doesn't depend on it.
pacman -q -S --noconfirm \
boost \
cmake \
eigen \
gcc \
libffi \
llvm \
make \
openmpi \
fmt
chmod 755 /root
useradd runner
mkdir -p /tmp/build
cmake -S . -B /tmp/build \
-DGALOIS_ENABLE_DIST=ON
- <<: *cmake_build_test
"Alpine":
docker:
- image: alpine:latest
steps:
- checkout
- run: |
apk add --no-cache --no-progress git bash
- run: git submodule sync
- run: git submodule update --init
- run: |
apk add --no-cache --no-progress \
boost-dev \
cmake \
eigen \
g++ \
gcc \
llvm14-dev \
llvm14-static \
make \
musl-dev \
openssh-client \
zlib-dev \
fmt-dev
chmod 755 /root
adduser -D runner
mkdir -p /tmp/build
cmake -S . -B /tmp/build
- <<: *cmake_build_test
"Fedora-gcc":
docker:
- image: fedora:latest
steps:
- checkout
- run: |
yum -y -q install git
- run: git submodule sync
- run: git submodule update --init
- run: |
yum -y -q install \
boost-devel \
cmake \
eigen3-devel \
gcc-c++ \
llvm-devel \
llvm-static \
make \
mpich-devel \
wget \
zlib-devel \
fmt-devel
chmod 755 /root
useradd runner
mkdir -p /tmp/build
# Get the "module" function set up before loading MPI.
cat /etc/profile.d/modules.sh >> $BASH_ENV
echo "module load mpi" >> $BASH_ENV
- run: |
cmake -S . -B /tmp/build \
-DGALOIS_ENABLE_DIST=ON
- <<: *cmake_build_test
"Fedora-clang":
docker:
- image: fedora:latest
steps:
- checkout
- run: |
yum -y -q install git
- run: git submodule sync
- run: git submodule update --init
- run: |
yum -y -q install \
boost-devel \
clang \
cmake \
eigen3-devel \
llvm-devel \
llvm-static \
make \
openmpi-devel \
wget \
zlib-devel \
fmt-devel
chmod 755 /root
useradd runner
mkdir -p /tmp/build
# Get the "module" function set up before loading MPI.
cat /etc/profile.d/modules.sh >> $BASH_ENV
echo "module load mpi" >> $BASH_ENV
- run: |
cmake -S . -B /tmp/build \
-DCMAKE_C_COMPILER=clang \
-DCMAKE_CXX_COMPILER=clang++ \
# -DGALOIS_ENABLE_DIST=ON
- <<: *cmake_build_test
workflows:
build:
jobs:
- "CheckFormat"
- "Sanitize"
- "Alpine":
requires:
- "CheckFormat"
# - "Sanitize"
- "Arch":
requires:
- "CheckFormat"
# - "Sanitize"
- "CentOS-8-clang":
requires:
- "CheckFormat"
# - "Sanitize"
- "CentOS-8-gcc":
requires:
- "CheckFormat"
# - "Sanitize"
- "Debian":
requires:
- "CheckFormat"
# - "Sanitize"
- "Fedora-clang":
requires:
- "CheckFormat"
# - "Sanitize"
- "Fedora-gcc":
requires:
- "CheckFormat"
# - "Sanitize"
- "Ubuntu-18_04":
requires:
- "CheckFormat"
# - "Sanitize"
- "Ubuntu-18_04-cuda11_1_1-build-only":
requires:
- "CheckFormat"
# - "Sanitize"
- "Ubuntu-18_04-cuda11_0_3-build-only":
requires:
- "CheckFormat"
# - "Sanitize"
================================================
FILE: .circleci/longest_common_path.sh
================================================
#!/bin/bash
# For PR build only; find the longest common path prefix as the build and test subset
longest_common_prefix() {
declare -a possible_prefix
declare i=0
path="${1%/}"
while [ "$path" != "." ]; do
if [[ -d $path && -f "$path/CMakeLists.txt" ]]; then
possible_prefix[$i]="$path"
fi
i=$(($i + 1))
path=$(dirname "$path");
done
lcp="."
for prefix in "${possible_prefix[@]}"; do
for path in $@; do
if [ "${path#$prefix}" = "${path}" ]; then
continue 2
fi
done
lcp="$prefix"
break
done
echo $lcp
}
base=$( \
wget -q -O - "https://api.github.com/repos/$(echo ${CIRCLE_PULL_REQUEST:19} | sed "s/\/pull\//\/pulls\//")" \
| sed -n -e "s/^.*IntelligentSoftwareSystems://p" \
| sed -n -e "s/\".*$//p" \
)
longest_common_prefix $(git -c core.quotepath=false diff --name-only $base $CIRCLE_SHA1)
================================================
FILE: .clang-format
================================================
---
Language: Cpp
BasedOnStyle: LLVM
AccessModifierOffset: -2
AlignAfterOpenBracket: true
AlignConsecutiveAssignments: true
AlignEscapedNewlinesLeft: false
AlignOperands: true
AlignTrailingComments: true
AllowAllParametersOfDeclarationOnNextLine: true
AllowShortBlocksOnASingleLine: false
AllowShortCaseLabelsOnASingleLine: false
AllowShortFunctionsOnASingleLine: All
AllowShortIfStatementsOnASingleLine: false
AllowShortLoopsOnASingleLine: false
AlwaysBreakAfterDefinitionReturnType: None
AlwaysBreakBeforeMultilineStrings: false
AlwaysBreakTemplateDeclarations: true
BinPackArguments: true
BinPackParameters: true
BreakBeforeBinaryOperators: None
BreakBeforeBraces: Attach
BreakBeforeTernaryOperators: true
BreakConstructorInitializersBeforeComma: false
ColumnLimit: 80
CommentPragmas: '^ IWYU pragma:'
ConstructorInitializerAllOnOneLineOrOnePerLine: false
ConstructorInitializerIndentWidth: 4
ContinuationIndentWidth: 4
Cpp11BracedListStyle: true
DeriveLineEnding: false
DerivePointerAlignment: false
DisableFormat: false
ExperimentalAutoDetectBinPacking: false
ForEachMacros: [ foreach, Q_FOREACH, BOOST_FOREACH ]
IndentCaseLabels: false
IndentWidth: 2
IndentWrappedFunctionNames: false
KeepEmptyLinesAtTheStartOfBlocks: true
MacroBlockBegin: ''
MacroBlockEnd: ''
MaxEmptyLinesToKeep: 1
NamespaceIndentation: None
ObjCBlockIndentWidth: 2
ObjCSpaceAfterProperty: false
ObjCSpaceBeforeProtocolList: true
PenaltyBreakBeforeFirstCallParameter: 19
PenaltyBreakComment: 300
PenaltyBreakFirstLessLess: 120
PenaltyBreakString: 1000
PenaltyExcessCharacter: 1000000
PenaltyReturnTypeOnItsOwnLine: 60
PointerAlignment: Left
SortIncludes: false
SpaceAfterCStyleCast: false
SpaceBeforeAssignmentOperators: true
SpaceBeforeParens: ControlStatements
SpaceInEmptyParentheses: false
SpacesBeforeTrailingComments: 1
SpacesInAngles: false
SpacesInContainerLiterals: true
SpacesInCStyleCastParentheses: false
SpacesInParentheses: false
SpacesInSquareBrackets: false
Standard: Cpp11
TabWidth: 4
UseTab: Never
...
================================================
FILE: .clang-tidy
================================================
---
# Enable most checks then disable (-) problematics ones:
#
# Some checks are good in principle but cannot be applied automatically either
# because they require taste or the autofix can generate wrong code:
#
# - cppcoreguidelines-pro-type-member-init: wrong code sometimes
# - google-explicit-constructor: libllvm has implicit conversions
# - modernize-use-no-discard
# - modernize-use-transparent-functors
# - modernize-use-using: autofix doesn't handle dependent type templates
# - readability-static-accessed-through-instance: wrong code sometimes
#
# No consensus:
#
# - modernize-use-trailing-return-type: also huge code churn
# - readability-convert-member-functions-to-static
# - readability-implicit-bool-conversion
Checks: |
abseil-*,
boost-*,
bugprone-*,
clang-analyzer-*,
clang-diagnostic-*,
cppcoreguidelines-*,
-cppcoreguidelines-pro-type-member-init,
google-*,
-google-explicit-constructor,
modernize-*,
-modernize-use-nodiscard,
-modernize-use-trailing-return-type,
-modernize-use-transparent-functors,
-modernize-use-using,
mpi-*,
openmp-*,
performance-*,
readability-*,
-readability-convert-member-functions-to-static,
-readability-static-accessed-through-instance,
-readability-implicit-bool-conversion,
WarningsAsErrors: ''
HeaderFilterRegex: ''
AnalyzeTemporaryDtors: false
FormatStyle: file
CheckOptions:
- key: cert-dcl16-c.NewSuffixes
value: 'L;LL;LU;LLU'
- key: cert-oop54-cpp.WarnOnlyIfThisHasSuspiciousField
value: '0'
- key: cppcoreguidelines-explicit-virtual-functions.IgnoreDestructors
value: '1'
- key: cppcoreguidelines-non-private-member-variables-in-classes.IgnoreClassesWithAllMemberVariablesBeingPublic
value: '1'
- key: google-readability-braces-around-statements.ShortStatementLines
value: '1'
- key: google-readability-function-size.StatementThreshold
value: '800'
- key: google-readability-namespace-comments.ShortNamespaceLines
value: '10'
- key: google-readability-namespace-comments.SpacesBeforeComments
value: '2'
- key: modernize-loop-convert.MaxCopySize
value: '16'
- key: modernize-loop-convert.MinConfidence
value: reasonable
- key: modernize-loop-convert.NamingStyle
value: CamelCase
- key: modernize-pass-by-value.IncludeStyle
value: llvm
- key: modernize-replace-auto-ptr.IncludeStyle
value: llvm
- key: modernize-use-nullptr.NullMacros
value: 'NULL'
...
================================================
FILE: .git-blame-ignore-revs
================================================
# Bulk-change revisions to ignore in git blame
#
# Requires git v2.23
#
# To use:
#
# git blame --ignore-revs-file .git-blame-ignore-revs
#
# or more permanently:
#
# git config blame.ignoreRevsFile .git-blame-ignore-revs
# Run clang-format.
02ecf4f4ea6ed8618a3826f98c3ea192ee38ca2d
# Re-run clang-format.
47ddbe14de2e61b87749cd20bd368f07ef3c322f
# Reorganize the lonestar directories.
6ade1c5ac3cf0c261aff7bee863e46b2c124d174
# Run clang-format.
517fca343c75f842096b661e3ff883bb93f5c09e
# Another round of clang-format
2264b05ece3f9ec2b9bf397594cc14ef99f498de
# Fix endlines for barneshut app
558ccb83ab2e388c1202396f42d0881912e6393d
================================================
FILE: .gitignore
================================================
# no editor files
*~
*.backup
/.dir-locals.el
*.orig
*.patch
/.project
.settings
.*.swo
*.swp
.vscode
# no tool generated files
.clang-complete
.clangd
compile_commands.json
cscope.out
/GPATH
/GRTAGS
/GTAGS
.tags*
tags
.ycm_extra_conf.py
# no build files
/build*
# no python build artifacts
*.pyc
/python/galois.egg-info
/python/galois/*.so
/_skbuild
================================================
FILE: .gitmodules
================================================
[submodule "moderngpu"]
path = external/moderngpu
url = https://github.com/moderngpu/moderngpu.git
[submodule "cub"]
path = external/cub
url = https://github.com/NVlabs/cub.git
[submodule "docs"]
path = docs
url = https://github.com/IntelligentSoftwareSystems/Galois-docs.git
================================================
FILE: .travis.yml
================================================
dist: bionic
language: c++
git:
submodules: true
matrix:
include:
- os: osx
osx_image: xcode11.3
before_script:
- export CC=clang
- export CXX=clang++
- brew install openmpi llvm fmt
- mkdir build
- export PATH=$PATH:/usr/local/opt/llvm/bin
- cmake -S . -B build -DCMAKE_BUILD_TYPE=Release -DGALOIS_ENABLE_DIST=ON || exit 1
- env:
- GCC_VER=7
addons:
apt:
sources:
- sourceline: 'ppa:ubuntu-toolchain-r/test'
- sourceline: 'deb https://apt.kitware.com/ubuntu/ bionic main'
key_url: 'https://apt.kitware.com/keys/kitware-archive-latest.asc'
- sourceline: 'ppa:mhier/libboost-latest'
packages:
- gcc-7
- g++-7
- cmake
- libboost1.70-dev
- libeigen3-dev
- openmpi-bin
- libopenmpi-dev
- llvm-7-dev
- libz-dev
- libfmt-dev
- env:
- GCC_VER=8
addons:
apt:
sources:
- sourceline: 'ppa:ubuntu-toolchain-r/test'
- sourceline: 'deb https://apt.kitware.com/ubuntu/ bionic main'
key_url: 'https://apt.kitware.com/keys/kitware-archive-latest.asc'
- sourceline: 'ppa:mhier/libboost-latest'
packages:
- gcc-8
- g++-8
- cmake
- libboost1.70-dev
- libeigen3-dev
- openmpi-bin
- libopenmpi-dev
- llvm-7-dev
- libz-dev
- libfmt-dev
- env:
- GCC_VER=9
addons:
apt:
sources:
- sourceline: 'ppa:ubuntu-toolchain-r/test'
- sourceline: 'deb https://apt.kitware.com/ubuntu/ bionic main'
key_url: 'https://apt.kitware.com/keys/kitware-archive-latest.asc'
- sourceline: 'ppa:mhier/libboost-latest'
packages:
- gcc-9
- g++-9
- cmake
- libboost1.70-dev
- libeigen3-dev
- openmpi-bin
- libopenmpi-dev
- llvm-7-dev
- libz-dev
- libfmt-dev
- env:
- GCC_VER=10
addons:
apt:
sources:
- sourceline: 'ppa:ubuntu-toolchain-r/test'
- sourceline: 'deb https://apt.kitware.com/ubuntu/ bionic main'
key_url: 'https://apt.kitware.com/keys/kitware-archive-latest.asc'
- sourceline: 'ppa:mhier/libboost-latest'
packages:
- gcc-10
- g++-10
- cmake
- libboost1.70-dev
- libeigen3-dev
- openmpi-bin
- libopenmpi-dev
- llvm-7-dev
- libz-dev
- libfmt-dev
- env:
- GCC_VER=10
- BUILD_TYPE=Debug
addons:
apt:
sources:
- sourceline: 'ppa:ubuntu-toolchain-r/test'
- sourceline: 'deb https://apt.kitware.com/ubuntu/ bionic main'
key_url: 'https://apt.kitware.com/keys/kitware-archive-latest.asc'
- sourceline: 'ppa:mhier/libboost-latest'
packages:
- gcc-10
- g++-10
- cmake
- libboost1.70-dev
- libeigen3-dev
- openmpi-bin
- libopenmpi-dev
- llvm-7-dev
- libz-dev
- libfmt-dev
- env:
- CLANG_VER=7
addons:
apt:
sources:
- sourceline: 'ppa:ubuntu-toolchain-r/test'
- sourceline: 'deb http://apt.llvm.org/bionic/ llvm-toolchain-bionic-7 main'
key_url: 'https://apt.llvm.org/llvm-snapshot.gpg.key'
- sourceline: 'deb https://apt.kitware.com/ubuntu/ bionic main'
key_url: 'https://apt.kitware.com/keys/kitware-archive-latest.asc'
- sourceline: 'ppa:mhier/libboost-latest'
packages:
- clang-7
- cmake
- libboost1.70-dev
- libeigen3-dev
- openmpi-bin
- libopenmpi-dev
- llvm-7-dev
- libz-dev
- libfmt-dev
- env:
- CLANG_VER=8
addons:
apt:
sources:
- sourceline: 'ppa:ubuntu-toolchain-r/test'
- sourceline: 'deb http://apt.llvm.org/bionic/ llvm-toolchain-bionic-8 main'
key_url: 'https://apt.llvm.org/llvm-snapshot.gpg.key'
- sourceline: 'deb https://apt.kitware.com/ubuntu/ bionic main'
key_url: 'https://apt.kitware.com/keys/kitware-archive-latest.asc'
- sourceline: 'ppa:mhier/libboost-latest'
packages:
- clang-8
- cmake
- libboost1.70-dev
- libeigen3-dev
- openmpi-bin
- libopenmpi-dev
- llvm-7-dev
- libz-dev
- libfmt-dev
- env:
- CLANG_VER=9
addons:
apt:
sources:
- sourceline: 'ppa:ubuntu-toolchain-r/test'
- sourceline: 'deb http://apt.llvm.org/bionic/ llvm-toolchain-bionic-9 main'
key_url: 'https://apt.llvm.org/llvm-snapshot.gpg.key'
- sourceline: 'deb https://apt.kitware.com/ubuntu/ bionic main'
key_url: 'https://apt.kitware.com/keys/kitware-archive-latest.asc'
- sourceline: 'ppa:mhier/libboost-latest'
packages:
- clang-9
- cmake
- libboost1.70-dev
- libeigen3-dev
- openmpi-bin
- libopenmpi-dev
- llvm-7-dev
- libz-dev
- libfmt-dev
- env:
- CLANG_VER=10
addons:
apt:
sources:
- sourceline: 'ppa:ubuntu-toolchain-r/test'
- sourceline: 'deb http://apt.llvm.org/bionic/ llvm-toolchain-bionic-10 main'
key_url: 'https://apt.llvm.org/llvm-snapshot.gpg.key'
- sourceline: 'deb https://apt.kitware.com/ubuntu/ bionic main'
key_url: 'https://apt.kitware.com/keys/kitware-archive-latest.asc'
- sourceline: 'ppa:mhier/libboost-latest'
packages:
- clang-10
- cmake
- libboost1.70-dev
- libeigen3-dev
- openmpi-bin
- libopenmpi-dev
- llvm-7-dev
- libz-dev
- libfmt-dev
- env:
- CLANG_VER=10
- BUILD_TYPE=Debug
addons:
apt:
sources:
- sourceline: 'ppa:ubuntu-toolchain-r/test'
- sourceline: 'deb http://apt.llvm.org/bionic/ llvm-toolchain-bionic-10 main'
key_url: 'https://apt.llvm.org/llvm-snapshot.gpg.key'
- sourceline: 'deb https://apt.kitware.com/ubuntu/ bionic main'
key_url: 'https://apt.kitware.com/keys/kitware-archive-latest.asc'
- sourceline: 'ppa:mhier/libboost-latest'
packages:
- clang-10
- cmake
- libboost1.70-dev
- libeigen3-dev
- openmpi-bin
- libopenmpi-dev
- llvm-7-dev
- libz-dev
- libfmt-dev
before_script:
# Depending on whether GCC_VER or CLANG_VER is set and nonempty,
# set CC and CXX accordingly.
- |
if [ -n "$GCC_VER" ]; then
export CC="gcc-$GCC_VER"
export CXX="g++-$GCC_VER"
fi
- |
if [ -n "$CLANG_VER" ]; then
export CC="clang-$CLANG_VER"
export CXX="clang++-$CLANG_VER"
fi
- |
# Check if BUILD_TYPE is set at all, not just whether it is empty or unset.
# See https://stackoverflow.com/a/13864829/1935144.
if [ -z ${BUILD_TYPE+x} ]; then
export BUILD_TYPE=Release
fi
- mkdir build
# Use apt-installed llvm-7-dev rather than travis-provided one which is
# picked up through the local clang-7 install in /usr/local/clang-7.
- export CMAKE_PREFIX_PATH=/usr/lib/llvm-7
# Use apt-installed cmake rather than travis-provided one
# (/usr/local/cmake-3.12.4/bin/cmake).
- /usr/bin/cmake -S . -B build -DCMAKE_PREFIX_PATH=$CMAKE_PREFIX_PATH -DCMAKE_BUILD_TYPE=$BUILD_TYPE -DGALOIS_ENABLE_DIST=ON || exit 1
script:
- make -C build input
- cmake --build build --parallel 2 || exit 1
- (cd build && ctest --output-on-failure --parallel 2 --label-regex quick) || exit 1
notifications:
email: false
================================================
FILE: CMakeLists.txt
================================================
cmake_minimum_required(VERSION 3.13)
project(Galois)
list(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/cmake/Modules")
include(GNUInstallDirs)
file(STRINGS config/version.txt GALOIS_VERSION)
string(REGEX REPLACE "[ \t\n]" "" GALOIS_VERSION ${GALOIS_VERSION})
string(REGEX REPLACE "([0-9]+)\\.([0-9]+)\\.([0-9]+)" "\\1" GALOIS_VERSION_MAJOR ${GALOIS_VERSION})
string(REGEX REPLACE "([0-9]+)\\.([0-9]+)\\.([0-9]+)" "\\2" GALOIS_VERSION_MINOR ${GALOIS_VERSION})
string(REGEX REPLACE "([0-9]+)\\.([0-9]+)\\.([0-9]+)" "\\3" GALOIS_VERSION_PATCH ${GALOIS_VERSION})
set(GALOIS_COPYRIGHT_YEAR "2018") # Also in COPYRIGHT
if(NOT CMAKE_BUILD_TYPE)
message(STATUS "No build type selected, default to Release")
# cmake default flags with relwithdebinfo is -O2 -g
# cmake default flags with release is -O3 -DNDEBUG
set(CMAKE_BUILD_TYPE "Release")
endif()
###### Options (alternatively pass as options to cmake -DName=Value) ######
###### Distributed-heterogeneous features ######
set(GALOIS_ENABLE_DIST OFF CACHE BOOL "Enable distributed features")
set(GALOIS_CUDA_CAPABILITY "" CACHE STRING "Semi-colon list of CUDA compute capability version numbers to enable GPU features") # e.g., "3.7;6.1"
set(GALOIS_COMM_STATS OFF CACHE BOOL "Report more detailed statistics of communication")
###### General features ######
set(GALOIS_ENABLE_PAPI OFF CACHE BOOL "Use PAPI counters for profiling")
set(GALOIS_ENABLE_VTUNE OFF CACHE BOOL "Use VTune for profiling")
set(GALOIS_STRICT_CONFIG OFF CACHE BOOL "Instead of falling back gracefully, fail")
set(GALOIS_GRAPH_LOCATION "" CACHE PATH "Location of inputs for tests if downloaded/stored separately.")
set(CXX_CLANG_TIDY "" CACHE STRING "Semi-colon list specifying clang-tidy command and arguments")
set(CMAKE_CXX_COMPILER_LAUNCHER "" CACHE STRING "Semi-colon list specifying command to wrap compiler invocations (e.g., ccache)")
set(USE_ARCH native CACHE STRING "Optimize for a specific processor architecture ('none' to disable)")
set(GALOIS_USE_SANITIZER "" CACHE STRING "Semi-colon list of sanitizers to use (Memory, MemoryWithOrigins, Address, Undefined, Thread)")
# This option is automatically handled by CMake.
# It makes add_library build a shared lib unless STATIC is explicitly specified.
# Putting this here is mostly just a placeholder so people know it's an option.
# Currently this is really only intended to change anything for the libgalois_shmem target.
set(BUILD_SHARED_LIBS OFF CACHE BOOL "Build shared libraries")
set(BUILD_DOCS "" CACHE STRING "Build documentation with make doc. Supported values: <unset>, external, internal. external docs hide '*-draft*' and '*-internal* documentation pages and directories when building documentation")
###### Developer features ######
set(GALOIS_PER_ROUND_STATS OFF CACHE BOOL "Report statistics of each round of execution")
set(GALOIS_NUM_TEST_GPUS "0" CACHE STRING "Number of test GPUs to use (on a single machine) for running the tests.")
set(GALOIS_USE_LCI OFF CACHE BOOL "Use LCI network runtime instead of MPI")
set(GALOIS_USE_BARE_MPI OFF CACHE BOOL "Use MPI directly (no dedicated network-runtime thread)")
set(GALOIS_NUM_TEST_THREADS "" CACHE STRING "Maximum number of threads to use when running tests (default: number of physical cores)")
if(NOT GALOIS_NUM_TEST_THREADS)
cmake_host_system_information(RESULT GALOIS_NUM_TEST_THREADS QUERY NUMBER_OF_PHYSICAL_CORES)
endif()
if(GALOIS_NUM_TEST_THREADS LESS_EQUAL 0)
set(GALOIS_NUM_TEST_THREADS 1)
endif()
###### Configure (users don't need to go beyond here) ######
include(CTest)
###### Configure compiler ######
# generate compile_commands.json
set(CMAKE_EXPORT_COMPILE_COMMANDS ON)
set(CMAKE_CXX_STANDARD 17)
set(CMAKE_CXX_STANDARD_REQUIRED ON)
set(CMAKE_CXX_EXTENSIONS OFF) #...without compiler extensions like gnu++11
set(CMAKE_POSITION_INDEPENDENT_CODE ON)
# Always include debug info
add_compile_options("$<$<COMPILE_LANGUAGE:CXX>:-g>")
# GCC
if(CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
if(CMAKE_CXX_COMPILER_VERSION VERSION_LESS 7)
message(FATAL_ERROR "gcc must be version 7 or higher. Found ${CMAKE_CXX_COMPILER_VERSION}.")
endif()
add_compile_options("$<$<COMPILE_LANGUAGE:CXX>:-Wall;-Wextra>")
if(CMAKE_CXX_COMPILER_VERSION VERSION_LESS 11)
add_compile_options("$<$<COMPILE_LANGUAGE:CXX>:-Werror>")
endif()
endif()
if(CMAKE_CXX_COMPILER_ID STREQUAL "Clang")
if(CMAKE_CXX_COMPILER_VERSION VERSION_LESS 7)
message(FATAL_ERROR "clang must be version 7 or higher. Found ${CMAKE_CXX_COMPILER_VERSION}.")
endif()
add_compile_options("$<$<COMPILE_LANGUAGE:CXX>:-Wall;-Wextra>")
if(CMAKE_CXX_COMPILER_VERSION VERSION_LESS 11)
add_compile_options("$<$<COMPILE_LANGUAGE:CXX>:-Werror>")
endif()
endif()
if(CMAKE_CXX_COMPILER_ID STREQUAL "AppleClang")
add_compile_options("$<$<COMPILE_LANGUAGE:CXX>:-Wall;-Wextra>")
if(CMAKE_CXX_COMPILER_VERSION VERSION_LESS 12)
add_compile_options("$<$<COMPILE_LANGUAGE:CXX>:-Werror>")
endif()
endif()
if(CMAKE_CXX_COMPILER_ID STREQUAL "Intel")
if(CMAKE_CXX_COMPILER_VERSION VERSION_LESS 19.0.1)
message(FATAL_ERROR "icpc must be 19.0.1 or higher. Found ${CMAKE_CXX_COMPILER_VERSION}.")
endif()
# Avoid warnings when using noinline for methods defined inside class defintion.
add_compile_options("$<$<COMPILE_LANGUAGE:CXX>:-wd2196>")
endif()
# Enable architecture-specific optimizations
include(CheckArchFlags)
if(ARCH_FLAGS_FOUND)
add_compile_options("$<$<COMPILE_LANGUAGE:CXX>:${ARCH_CXX_FLAGS}>")
add_compile_options("$<$<COMPILE_LANGUAGE:C>:${ARCH_C_FLAGS}>")
add_link_options(${ARCH_LINK_FLAGS})
endif()
if(CXX_CLANG_TIDY)
set(CMAKE_CXX_CLANG_TIDY ${CXX_CLANG_TIDY} "-header-filter=.*${PROJECT_SOURCE_DIR}.*")
# Ignore warning flags intended for the CXX program. This only works because
# the two compilers we care about, clang and gcc, both understand
# -Wno-unknown-warning-option.
add_compile_options("$<$<COMPILE_LANGUAGE:CXX>:-Wno-unknown-warning-option>")
endif()
###### Configure features ######
if(GALOIS_ENABLE_VTUNE)
set(VTune_ROOT /opt/intel/vtune_amplifier)
find_package(VTune REQUIRED)
include_directories(${VTune_INCLUDE_DIRS})
add_definitions(-DGALOIS_ENABLE_VTUNE)
endif()
if(GALOIS_ENABLE_PAPI)
find_package(PAPI REQUIRED)
include_directories(${PAPI_INCLUDE_DIRS})
add_definitions(-DGALOIS_ENABLE_PAPI)
endif()
find_package(Threads REQUIRED)
include(CheckMmap)
include(CheckHugePages)
if(NOT HAVE_HUGEPAGES AND GALOIS_STRICT_CONFIG)
message(FATAL_ERROR "Need huge pages")
endif()
find_package(Boost 1.58.0 REQUIRED COMPONENTS serialization iostreams)
find_package(LLVM REQUIRED CONFIG)
if("${LLVM_PACKAGE_VERSION}" VERSION_LESS "7")
message(FATAL_ERROR "LLVM 7 or greater is required.")
endif()
if(NOT DEFINED LLVM_ENABLE_RTTI)
message(FATAL_ERROR "Could not determine if LLVM has RTTI enabled.")
endif()
if(NOT ${LLVM_ENABLE_RTTI})
message(FATAL_ERROR "Galois requires a build of LLVM that includes RTTI. Most package managers do this already, but if you built LLVM from source you need to configure it with `-DLLVM_ENABLE_RTTI=ON`")
endif()
target_include_directories(LLVMSupport INTERFACE ${LLVM_INCLUDE_DIRS})
include(HandleSanitizer)
include(CheckEndian)
###### Test Inputs ######
if(GALOIS_GRAPH_LOCATION)
set(BASEINPUT "${GALOIS_GRAPH_LOCATION}")
set(BASEOUTPUT "${GALOIS_GRAPH_LOCATION}")
message(STATUS "Using graph input and output location ${GALOIS_GRAPH_LOCATION}")
elseif(EXISTS /net/ohm/export/iss)
set(BASEINPUT /net/ohm/export/iss/inputs)
MESSAGE(STATUS "Using graph input location /net/ohm/export/iss/inputs")
set(BASEOUTPUT /net/ohm/export/iss/dist-outputs)
MESSAGE(STATUS "Using graph output location /net/ohm/export/iss/dist-outputs")
else()
set(BASEINPUT "${PROJECT_BINARY_DIR}/inputs")
set(BASEOUTPUT "${PROJECT_BINARY_DIR}/inputs")
message(STATUS "Use 'make input' to download inputs and outputs in the build directory")
endif()
###### Source finding ######
add_custom_target(lib)
add_custom_target(apps)
# Core libraries (lib)
add_subdirectory(libsupport)
add_subdirectory(libgalois)
add_subdirectory(libpygalois)
if (GALOIS_ENABLE_DIST)
find_package(MPI REQUIRED)
add_subdirectory(libdist)
add_subdirectory(libcusp)
add_subdirectory(libgluon)
endif()
string(COMPARE NOTEQUAL "${GALOIS_CUDA_CAPABILITY}" "" GALOIS_ENABLE_GPU)
if (GALOIS_ENABLE_GPU)
enable_language(CUDA)
foreach(GENCODE ${GALOIS_CUDA_CAPABILITY})
string(REPLACE "." "" GENCODE ${GENCODE})
add_compile_options("$<$<COMPILE_LANGUAGE:CUDA>:-gencode=arch=compute_${GENCODE},code=sm_${GENCODE}>")
endforeach()
# This is necessary to allow building for CUDA 11.x (where CUB is bundled) and earlier versions (where CUB is not included)
add_definitions(-DTHRUST_IGNORE_CUB_VERSION_CHECK)
add_subdirectory(libgpu)
endif()
add_subdirectory(libpangolin)
# Applications (apps)
add_subdirectory(lonestar)
add_subdirectory(scripts)
add_subdirectory(inputs)
add_subdirectory(tools)
if(USE_EXP)
add_subdirectory(lonestar/experimental)
endif(USE_EXP)
###### Documentation ######
if(BUILD_DOCS)
set(GALOIS_ROOT ${CMAKE_CURRENT_SOURCE_DIR})
add_subdirectory(docs)
endif()
###### Installation ######
include(CMakePackageConfigHelpers)
write_basic_package_version_file(
${CMAKE_CURRENT_BINARY_DIR}/GaloisConfigVersion.cmake
VERSION ${GALOIS_VERSION}
COMPATIBILITY SameMajorVersion
)
configure_package_config_file(
cmake/GaloisConfig.cmake.in
${CMAKE_CURRENT_BINARY_DIR}/GaloisConfig.cmake
INSTALL_DESTINATION "${CMAKE_INSTALL_LIBDIR}/cmake/Galois"
PATH_VARS CMAKE_INSTALL_INCLUDEDIR CMAKE_INSTALL_LIBDIR CMAKE_INSTALL_BINDIR
)
install(
FILES "${CMAKE_CURRENT_BINARY_DIR}/GaloisConfigVersion.cmake" "${CMAKE_CURRENT_BINARY_DIR}/GaloisConfig.cmake"
DESTINATION "${CMAKE_INSTALL_LIBDIR}/cmake/Galois"
COMPONENT dev
)
install(
EXPORT GaloisTargets
NAMESPACE Galois::
DESTINATION "${CMAKE_INSTALL_LIBDIR}/cmake/Galois"
COMPONENT dev
)
###### Distribution ######
set(CPACK_GENERATOR "TGZ")
set(CPACK_ARCHIVE_COMPONENT_INSTALL ON)
set(CPACK_RESOURCE_FILE_LICENSE "${CMAKE_CURRENT_SOURCE_DIR}/COPYRIGHT")
set(CPACK_RESOURCE_FILE_README "${CMAKE_CURRENT_SOURCE_DIR}/README.md")
set(CPACK_PACKAGE_VERSION_MAJOR ${GALOIS_VERSION_MAJOR})
set(CPACK_PACKAGE_VERSION_MINOR ${GALOIS_VERSION_MINOR})
set(CPACK_PACKAGE_VERSION_PATCH ${GALOIS_VERSION_PATCH})
include(CPack)
================================================
FILE: COPYRIGHT
================================================
Galois, a framework to exploit amorphous data-parallelism in irregular
programs.
Copyright (C) 2018, The University of Texas at Austin. All rights reserved.
UNIVERSITY EXPRESSLY DISCLAIMS ANY AND ALL WARRANTIES CONCERNING THIS
SOFTWARE AND DOCUMENTATION, INCLUDING ANY WARRANTIES OF MERCHANTABILITY,
FITNESS FOR ANY PARTICULAR PURPOSE, NON-INFRINGEMENT AND WARRANTIES OF
PERFORMANCE, AND ANY WARRANTY THAT MIGHT OTHERWISE ARISE FROM COURSE OF
DEALING OR USAGE OF TRADE. NO WARRANTY IS EITHER EXPRESS OR IMPLIED WITH
RESPECT TO THE USE OF THE SOFTWARE OR DOCUMENTATION. Under no circumstances
shall University be liable for incidental, special, indirect, direct or
consequential damages or loss of profits, interruption of business, or
related expenses which may arise from use of Software or Documentation,
including but not limited to those resulting from defects in Software and/or
Documentation, or loss or inaccuracy of data of any kind.
This software is released under the terms of the 3-Clause BSD License (a
copy is located in LICENSE.txt at the top-level directory).
================================================
FILE: LICENSE.txt
================================================
The 3-Clause BSD License
Copyright 2018 The University of Texas at Austin
Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
3. Neither the name of the copyright holder nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
================================================
FILE: README.md
================================================
Overview
========
[](https://circleci.com/gh/IntelligentSoftwareSystems/Galois)
[](https://travis-ci.org/IntelligentSoftwareSystems/Galois)
Galois is a C++ library designed to ease parallel programming, especially for
applications with irregular parallelism (e.g., irregular amount of work in parallel
sections, irregular memory accesses and branching patterns). It implements
an implicitly parallel programming model, where the programmer replaces serial loop
constructs (e.g. for and while) and serial data structures in their algorithms with parallel loop
constructs and concurrent data structures provided by Galois to express their algorithms.
Galois is designed so that the programmer does not have to deal with low-level parallel programming constructs such as
threads, locks, barriers, condition variables, etc.
Highlights include:
- Parallel *for_each* loop that handles dependencies between iterations, as well as
dynamic work creation, and a *do_all* loop for simple parallelism. Both provide load balancing and excellent
scalability on multi-socket systems
- A concurrent graph library designed for graph analytics algorithms as well as
other domains such as irregular meshes.
- Scalable concurrent containers such as bag, vector, list, etc.
Galois is released under the BSD-3-Clause license.
Building Galois
===============
You can checkout the latest release by typing (in a terminal):
```Shell
git clone -b release-5.0 https://github.com/IntelligentSoftwareSystems/Galois
```
The master branch will be regularly updated, so you may try out the latest
development code as well by checking out master branch:
```Shell
git clone https://github.com/IntelligentSoftwareSystems/Galois
```
Dependencies
------------
Galois builds, runs, and has been tested on GNU/Linux. Even though
Galois may build on systems similar to Linux, we have not tested correctness or performance, so please
beware.
At the minimum, Galois depends on the following software:
- A modern C++ compiler compliant with the C++-17 standard (gcc >= 7, Intel >= 19.0.1, clang >= 7.0)
- CMake (>= 3.13)
- Boost library (>= 1.58.0, we recommend building/installing the full library)
- libllvm (>= 7.0 with RTTI support)
- libfmt (>= 4.0)
Here are the dependencies for the optional features:
- Linux HUGE_PAGES support (please see [www.kernel.org/doc/Documentation/vm/hugetlbpage.txt](https://www.kernel.org/doc/Documentation/vm/hugetlbpage.txt)). Performance will most likely degrade without HUGE_PAGES
enabled. Galois uses 2MB huge page size and relies on the kernel configuration to set aside a large amount of 2MB pages. For example, our performance testing machine (4x14 cores, 192GB RAM) is configured to support up to 65536 2MB pages:
```Shell
cat /proc/meminfo | fgrep Huge
AnonHugePages: 104448 kB
HugePages_Total: 65536
HugePages_Free: 65536
HugePages_Rsvd: 0
HugePages_Surp: 0
Hugepagesize: 2048 kB
```
- libnuma support. Performance may degrade without it. Please install
libnuma-dev on Debian like systems, and numactl-dev on Red Hat like systems.
- Doxygen (>= 1.8.5) for compiling documentation as webpages or latex files
- PAPI (>= 5.2.0.0 ) for profiling sections of code
- Vtune (>= 2017 ) for profiling sections of code
- MPICH2 (>= 3.2) if you are interested in building and running distributed system
applications in Galois
- CUDA (>= 8.0 and < 11.0) if you want to build GPU or distributed heterogeneous applications.
Note that versions >= 11.0 use an incompatible CUB module and will fail to execute.
- Eigen (3.3.1 works for us) for some matrix-completion app variants
Compiling and Testing Galois
----------------------------
We use CMake to streamline building, testing and installing Galois. In the
following, we will highlight some common commands.
Let's assume that `SRC_DIR` is the directory where the source code for Galois
resides, and you wish to build Galois in some `BUILD_DIR`. Run the following
commands to set up a build directory:
```Shell
SRC_DIR=`pwd` # Or top-level Galois source dir
BUILD_DIR=<path-to-your-build-dir>
mkdir -p $BUILD_DIR
cmake -S $SRC_DIR -B $BUILD_DIR -DCMAKE_BUILD_TYPE=Release
```
You can also set up a `Debug` build by running the following instead of the last command above:
```Shell
cmake -S $SRC_DIR -B $BUILD_DIR -DCMAKE_BUILD_TYPE=Debug
```
Galois applications are in `lonestar` directory. In order to build a particular application:
```Shell
make -C $BUILD_DIR/lonestar/<app-dir-name> -j
# or alternatively
make -C $BUILD_DIR <app-executable-name> -j
# or
cmake --build $BUILD_DIR <app-executable-name> --parallel
```
You can also build everything by running `make -j` in the top-level of build directory, but that may
take a lot of time.
Setting the `BUILD_SHARED_LIBS` to `ON` when calling CMake will make the core runtime library be built as a shared object instead of a static library.
The tests for the core runtime will be built by default when you run `make`
with no target specified. They can be also built explicitly with:
```Shell
make -C $BUILD_DIR/test
```
We provide a few sample inputs that can be downloaded by running:
```Shell
make -C $BUILD_DIR input
```
`make input` will download a tarball of inputs and extract it to
`$BUILD_DIR/inputs/small_inputs` directory. The tarball is downloaded to
`$BUILD_DIR/inputs`
Most of the Galois apps have corresponding tests.
These tests depend on downloading the reference inputs and building the corresponding apps and test binaries.
Once the reference inputs have been downloaded and everything has been built,
the tests for the core library and all the apps can be run by running:
```Shell
make test
# or alternatively
ctest
```
in the build directory.
Running Galois Applications
===========================
Graph Format
------------
Many Galois/Lonestar applications work with graphs. We store graphs in a binary format
called *galois graph file*
(`.gr` file extension). Other formats such as edge-list or Matrix-Market can be
converted to `.gr` format with `graph-convert` tool provided in galois.
You can build graph-convert as follows:
```Shell
cd $BUILD_DIR
make graph-convert
./tools/graph-convert/graph-convert --help
```
Other applications, such as Delaunay Mesh Refinement may read special file formats
or some may even generate random inputs on the fly.
Running
-------
All Lonestar applications take a `-t` command-line option to specify the number of
threads to use. All applications run a basic sanity check (often insufficient for
correctness) on the program output, which can be turned off with the `-noverify` option. You
can specify `-help` command-line option to print all available options.
Upon successful completion, each application will produce some stats regarding running
time of various sections, parallel loop iterations and memory usage, etc. These
stats are in CSV format and can be redirected to a file using `-statFile` option.
Please refer to the manual for details on stats.
Running LonestarGPU applications
--------------------------
Please refer to `lonestar/analytics/gpu/README.md` and `lonestar/scientific/gpu/README.md` for more details on
compiling and running LonestarGPU applications.
Running Distributed Galois
--------------------------
Please refer to `lonestar/analytics/distributed/README.md` for more details on
running distributed benchmarks.
Documentation
=============
Galois documentation is produced using doxygen, included in this repository, which includes a tutorial, a user's
manual and API documentation for the Galois library.
Users can build doxygen documentation in the build directory using:
```Shell
cd $BUILD_DIR
make doc
your-fav-browser html/index.html &
```
See online documentation at:
[http://iss.ices.utexas.edu/?p=projects/galois](http://iss.ices.utexas.edu/?p=projects/galois)
Source-Tree Organization
========================
- `libgalois` contains the source code for the shared-memory Galois library, e.g., runtime, graphs, worklists, etc.
- `lonestar` contains the Lonestar benchmark applications and tutorial examples for Galois
- `libdist` contains the source code for the distributed-memory and heterogeneous Galois library
- `lonestardist` contains the source code for the distributed-memory and heterogeneous
benchmark applications. Please refer to `lonestardist/README.md` for instructions on
building and running these apps.
- `tools` contains various helper programs such as graph-converter to convert
between graph file formats and graph-stats to print graph properties
Using Galois as a library
=========================
There are two common ways to use Galois as a library. One way is to copy this
repository into your own CMake project, typically using a git submodule. Then
you can put the following in your CMakeLists.txt:
```CMake
add_subdirectory(galois EXCLUDE_FROM_ALL)
add_executable(app ...)
target_link_libraries(app Galois::shmem)
```
The other common method is to install Galois outside your project and import it
as a package.
If you want to install Galois, assuming that you wish to install it under
`INSTALL_DIR`:
```Shell
cmake -DCMAKE_INSTALL_PREFIX=$INSTALL_DIR $SRC_DIR
make install
```
Then, you can put something like the following in CMakeLists.txt:
```CMake
list(APPEND CMAKE_PREFIX_PATH ${INSTALL_DIR})
find_package(Galois REQUIRED)
add_executable(app ...)
target_link_libraries(app Galois::shmem)
```
If you are not using CMake, the corresponding basic commands (although the
specific commands vary by system) are:
```Shell
c++ -std=c++14 app.cpp -I$INSTALL_DIR/include -L$INSTALL_DIR/lib -lgalois_shmem
```
Third-Party Libraries and Licensing
====================
Galois includes some third party libraries that do not use the same license as
Galois. This includes the bliss library (located in lonestar/include/Mining/bliss)
and Modern GPU (located in libgpu/moderngpu). Please be aware of this when
using Galois.
Contact Us
==========
For bugs, please raise an
[issue](https://github.com/IntelligentSoftwareSystems/Galois/issues) on
GiHub.
Questions and comments are also welcome at the Galois users mailing list:
[galois-users@utlists.utexas.edu](galois-users@utlists.utexas.edu). You may
[subscribe here](https://utlists.utexas.edu/sympa/subscribe/galois-users).
If you find a bug, it would help us if you sent (1) the command line and
program inputs and outputs and (2) a core dump, preferably from an executable
built with the debug build.
You can enable core dumps by setting `ulimit -c unlimited` before running your
program. The location where the core dumps will be stored can be determined with
`cat /proc/sys/kernel/core_pattern`.
To create a debug build, assuming you will build Galois in `BUILD_DIR` and the
source is in `SRC_DIR`:
```Shell
cmake -S $SRC_DIR -B $BUILD_DIR -DCMAKE_BUILD_TYPE=Debug
make -C $BUILD_DIR
```
A simple way to capture relevant debugging details is to use the `script`
command, which will record your terminal input and output. For example,
```Shell
script debug-log.txt
ulimit -c unlimited
cat /proc/sys/kernel/core_pattern
make -C $BUILD_DIR <my-app> VERBOSE=1
my-app with-failing-input
exit
```
This will generate a file `debug-log.txt`, which you can send to the mailing
list:[galois-users@utlists.utexas.edu](galois-users@utlists.utexas.edu) for
further debugging or supply when opening a GitHub issue.
================================================
FILE: cmake/GaloisConfig.cmake.in
================================================
# Config file for the Galois package
#
# It exports the following targets:
# Galois::shmem
# Galois::dist
# ...
# (see GaloisTargets.cmake for all of them)
#
# It defines the following variables for legacy importing:
# Galois_INCLUDE_DIRS
# Galois_LIBRARIES
# Galois_LIBRARY_DIRS
# Galois_BIN_DIRS
include(CMakeFindDependencyMacro)
@PACKAGE_INIT@
set_and_check(Galois_INCLUDE_DIRS "@PACKAGE_CMAKE_INSTALL_INCLUDEDIR@")
set_and_check(Galois_LIBRARY_DIRS "@PACKAGE_CMAKE_INSTALL_LIBDIR@")
set_and_check(Galois_BIN_DIRS "@PACKAGE_CMAKE_INSTALL_BINDIR@")
set(Galois_LIBRARIES galois_shmem)
find_dependency(Threads REQUIRED)
find_dependency(Boost 1.58.0 REQUIRED COMPONENTS serialization iostreams)
if (@GALOIS_ENABLE_DIST@)
find_dependency(MPI REQUIRED)
endif()
get_filename_component(GALOIS_CMAKE_DIR "${CMAKE_CURRENT_LIST_FILE}" PATH)
if(NOT Galois::shmem)
include("${GALOIS_CMAKE_DIR}/GaloisTargets.cmake")
endif()
================================================
FILE: cmake/Modules/CheckArchFlags.cmake
================================================
# Find architecture-specific flags
#
# Once done this will define
# ARCH_FLAGS_FOUND
# ARCH_CXX_FLAGS - Compiler flags to enable architecture-specific optimizations
# ARCH_C_FLAGS - Compiler flags to enable architecture-specific optimizations
# ARCH_LINK_FLAGS - Compiler flags to enable architecture-specific optimizations
include(CheckCXXCompilerFlag)
if(NOT USE_ARCH OR USE_ARCH STREQUAL "none" OR ARCH_FLAGS_FOUND)
set(ARCH_CXX_FLAGS_CANDIDATES)
else()
set(ARCH_CXX_FLAGS_CANDIDATES "-march=${USE_ARCH}")
endif()
if(USE_ARCH STREQUAL "mic")
if(CMAKE_CXX_COMPILER_ID MATCHES "Intel")
list(APPEND ARCH_CXX_FLAGS_CANDIDATES -mmic)
endif()
if(CMAKE_COMPILER_IS_GNUCC)
list(APPEND ARCH_CXX_FLAGS_CANDIDATES -march=knc)
endif()
endif()
foreach(FLAG ${ARCH_CXX_FLAGS_CANDIDATES})
message(STATUS "Try architecture flag = [${FLAG}]")
unset(ARCH_CXX_FLAGS_DETECTED)
check_cxx_compiler_flag("${FLAG}" ARCH_CXX_FLAGS_DETECTED)
if(ARCH_CXX_FLAGS_DETECTED)
set(ARCH_FLAGS_FOUND "YES")
set(ARCH_CXX_FLAGS "${FLAG}")
set(ARCH_C_FLAGS "${FLAG}")
set(ARCH_LINK_FLAGS "${FLAG}")
endif()
endforeach()
================================================
FILE: cmake/Modules/CheckCilk.cmake
================================================
include(CheckCXXSourceCompiles)
set(Cilk_CXX_TEST_SOURCE
"
#include <cilk/cilk.h>
int main(){ cilk_for(int i=0;i<1; ++i); }
")
CHECK_CXX_SOURCE_COMPILES("${Cilk_CXX_TEST_SOURCE}" HAVE_CILK)
if(HAVE_CILK)
message(STATUS "A compiler with CILK support found")
endif()
================================================
FILE: cmake/Modules/CheckEndian.cmake
================================================
include(TestBigEndian)
TEST_BIG_ENDIAN(HAVE_BIG_ENDIAN)
include(CheckIncludeFiles)
CHECK_INCLUDE_FILES(endian.h HAVE_ENDIAN_H)
include(CheckSymbolExists)
CHECK_SYMBOL_EXISTS(le64toh "endian.h" HAVE_LE64TOH)
CHECK_SYMBOL_EXISTS(le32toh "endian.h" HAVE_LE32TOH)
CHECK_SYMBOL_EXISTS(htobe64 "endian.h" HAVE_HTOBE64)
CHECK_SYMBOL_EXISTS(htobe32 "endian.h" HAVE_HTOBE32)
CHECK_SYMBOL_EXISTS(htole64 "endian.h" HAVE_HTOLE64)
CHECK_SYMBOL_EXISTS(htole32 "endian.h" HAVE_HTOLE32)
================================================
FILE: cmake/Modules/CheckHugePages.cmake
================================================
include(CheckCSourceRuns)
set(HugePages_C_TEST_SOURCE
"
#ifdef __linux__
#include <linux/mman.h>
#endif
#include <sys/mman.h>
int main(int c, char** argv) {
void *ptr = mmap(0, 2*1024*1024, PROT_READ|PROT_WRITE, MAP_HUGETLB, -1, 0);
return ptr != MAP_FAILED;
}
")
if(HAVE_HUGEPAGES)
else()
CHECK_C_SOURCE_RUNS("${HugePages_C_TEST_SOURCE}" HAVE_HUGEPAGES_INTERNAL)
if(HAVE_HUGEPAGES_INTERNAL)
message(STATUS "Huge pages found")
set(HAVE_HUGEPAGES "${HAVE_HUGEPAGES_INTERNAL}" CACHE BOOL "Have hugepages")
endif()
endif()
================================================
FILE: cmake/Modules/CheckMmap.cmake
================================================
include(CheckCSourceCompiles)
set(Mmap64_C_TEST_SOURCE
"
#ifdef __linux__
#include <linux/mman.h>
#endif
#include <sys/mman.h>
int main(int c, char** argv) {
void *ptr = mmap64(0, 2*1024*1024, PROT_READ|PROT_WRITE, MAP_PRIVATE, -1, 0);
return 0;
}
")
if(HAVE_MMAP64)
else()
CHECK_C_SOURCE_COMPILES("${Mmap64_C_TEST_SOURCE}" HAVE_MMAP64_INTERNAL)
if(HAVE_MMAP64_INTERNAL)
message(STATUS "mmap64 found")
set(HAVE_MMAP64 "${HAVE_MMAP64_INTERNAL}" CACHE BOOL "Have mmap64")
endif()
endif()
================================================
FILE: cmake/Modules/CheckSchedSetAffinity.cmake
================================================
include(CheckSymbolExists)
if(SCHED_SETAFFINITY_FOUND)
else()
set(CMAKE_REQUIRED_DEFINITIONS -D_GNU_SOURCE)
CHECK_SYMBOL_EXISTS(sched_setaffinity sched.h HAVE_SCHED_SETAFFINITY_INTERNAL)
if(HAVE_SCHED_SETAFFINITY_INTERNAL)
message(STATUS "sched_setaffinity found")
set(SCHED_SETAFFINITY_FOUND "${HAVE_SCHED_SETAFFINITY_INTERNAL}")
set(SCHED_SETAFFINITY_LIBRARIES rt)
endif()
endif()
================================================
FILE: cmake/Modules/FindCBLAS.cmake
================================================
# Copyright 2009-2011 The VOTCA Development Team (http://www.votca.org)
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
#
#! \file
#! \ingroup FindPackage
#! \brief Find CBLAS
#!
#! Find the native CBLAS headers and libraries.
#!
#! - `CBLAS_LIBRARIES` - List of libraries when using cblas.
#! - `CBLAS_INCLUDE_DIRS` - List of include directories
#! - `CBLAS_FOUND` - True if cblas found.
#!
#! Cblas can be provided by libblas (Ubuntu), cblas or gslcblas, it will be searched for in
#! this order.
include(LibFindMacros)
if (UNIX)
find_package(PkgConfig QUIET)
pkg_check_modules(CBLAS_PKGCONF QUIET cblas)
endif()
if (NOT CBLAS_FOUND)
if(CBLAS_PKGCONF_FOUND)
foreach(NEW_CBLAS_LIB ${CBLAS_PKGCONF_LIBRARIES})
find_library(LIB_${NEW_CBLAS_LIB} ${NEW_CBLAS_LIB} HINTS ${CBLAS_PKGCONF_LIBRARY_DIRS})
if(NOT LIB_${NEW_CBLAS_LIB})
message(FATAL_ERROR "Could not find ${NEW_CBLAS_LIB} where pkgconfig said it is: ${CBLAS_PKGCONF_LIBRARY_DIRS}")
else(NOT LIB_${NEW_CBLAS_LIB})
message(STATUS "Found ${LIB_${NEW_CBLAS_LIB}}.")
endif(NOT LIB_${NEW_CBLAS_LIB})
set(CBLAS_LIBRARY ${CBLAS_LIBRARY} ${LIB_${NEW_CBLAS_LIB}})
endforeach(NEW_CBLAS_LIB)
else(CBLAS_PKGCONF_FOUND)
set(CBLAS_HINT_PATH $ENV{CBLASDIR}/lib $ENV{CBLASDIR}/lib64 $ENV{UIBK_GSL_LIB})
# Check if libblas provides cblas (Ubuntu)
find_library(BLAS_LIBRARY NAMES blas PATHS ${CBLAS_HINT_PATH})
if(BLAS_LIBRARY)
include(CheckSymbolExists)
set(CMAKE_REQUIRED_LIBRARIES ${BLAS_LIBRARY})
check_symbol_exists(cblas_scopy "cblas.h" BLAS_HAS_CBLAS)
endif(BLAS_LIBRARY)
set(CBLAS_CANDIDATES cblas gslcblas)
if(BLAS_HAS_CBLAS)
message(STATUS "libblas provides cblas.")
set(CBLAS_CANDIDATES blas ${CBLAS_CANDIDATES})
endif(BLAS_HAS_CBLAS)
find_library(CBLAS_LIBRARY
NAMES ${CBLAS_CANDIDATES}
PATHS ${CBLAS_HINT_PATH}
)
endif(CBLAS_PKGCONF_FOUND)
if("${CBLAS_LIBRARY}" MATCHES gslcblas)
set(CBLAS_INCLUDE_CANDIDATE gsl/gsl_cblas.h)
else("${CBLAS_LIBRARY}" MATCHES gslcblas)
set(CBLAS_INCLUDE_CANDIDATE cblas.h)
endif("${CBLAS_LIBRARY}" MATCHES gslcblas)
find_path(CBLAS_INCLUDE_DIR ${CBLAS_INCLUDE_CANDIDATE} HINTS ${CBLAS_PKGCONF_INCLUDE_DIRS} $ENV{CBLASDIR}/include $ENV{UIBK_GSL_INC})
# Set the include dir variables and the libraries and let libfind_process do the rest.
# NOTE: Singular variables for this library, plural for libraries this this lib depends on.
set(CBLAS_PROCESS_INCLUDES CBLAS_INCLUDE_DIR)
set(CBLAS_PROCESS_LIBS CBLAS_LIBRARY)
libfind_process(CBLAS)
message(STATUS "Using '${CBLAS_LIBRARIES}' for cblas.")
endif(NOT CBLAS_FOUND)
================================================
FILE: cmake/Modules/FindFortran.cmake
================================================
# Check if Fortran is possibly around before using enable_lanauge because
# enable_language(... OPTIONAL) does not fail gracefully if language is not
# found:
# http://public.kitware.com/Bug/view.php?id=9220
set(Fortran_EXECUTABLE)
if(Fortran_EXECUTABLE)
set(Fortran_FIND_QUIETLY TRUE)
endif()
find_program(Fortran_EXECUTABLE NAMES gfortran ifort g77 f77 g90 f90)
include(FindPackageHandleStandardArgs)
find_package_handle_standard_args(Fortran DEFAULT_MSG Fortran_EXECUTABLE)
if(FORTRAN_FOUND)
set(Fortran_FOUND TRUE)
endif()
================================================
FILE: cmake/Modules/FindGASNET.cmake
================================================
# Find the GasNet librairy
# GASNET_FOUND - system has GasNet lib
# GASNET_INCLUDE_DIR - the GasNet include directory
# GASNET_LIBRARIES - Libraries needed to use GasNet
if(GASNET_INCLUDE_DIRS AND GASNET_LIBRARIES)
set(GASNET_FIND_QUIETLY TRUE)
endif()
find_path(GASNET_INCLUDE_DIRS NAMES gasnet.h)
find_library(GASNET_LIBRARY_1 NAMES gasnet amudp HINTS ${GASNET_INCLUDE_DIRS}/../lib )
find_library(GASNET_LIBRARY_2 NAMES gasnet gasnet-udp-par HINTS ${GASNET_INCLUDE_DIRS}/../lib )
set(GASNET_LIBRARIES ${GASNET_LIBRARY_2} ${GASNET_LIBRARY_1})
include(FindPackageHandleStandardArgs)
find_package_handle_standard_args(GASNET DEFAULT_MSG GASNET_INCLUDE_DIRS GASNET_LIBRARIES)
mark_as_advanced(GASNET_INCLUDE_DIRS GASNET_LIBRARIES)
================================================
FILE: cmake/Modules/FindGMP.cmake
================================================
# Find the GMP librairies
# GMP_FOUND - system has GMP lib
# GMP_INCLUDE_DIR - the GMP include directory
# GMP_LIBRARIES - Libraries needed to use GMP
# Copyright (c) 2006, Laurent Montel, <montel@kde.org>
#
# Redistribution and use is allowed according to the terms of the BSD license.
# For details see the accompanying COPYING-CMAKE-SCRIPTS file.
if(GMP_INCLUDE_DIRS AND GMP_LIBRARIES AND GMPXX_LIBRARIES)
set(GMP_FIND_QUIETLY TRUE)
endif()
find_path(GMP_INCLUDE_DIRS NAMES gmp.h)
find_library(GMP_LIBRARIES NAMES gmp libgmp)
find_library(GMPXX_LIBRARIES NAMES gmpxx libgmpxx)
include(FindPackageHandleStandardArgs)
find_package_handle_standard_args(GMP DEFAULT_MSG GMP_INCLUDE_DIRS GMP_LIBRARIES)
mark_as_advanced(GMP_INCLUDE_DIRS GMP_LIBRARIES GMPXX_LIBRARIES)
================================================
FILE: cmake/Modules/FindGit.cmake
================================================
# The module defines the following variables:
# GIT_EXECUTABLE - path to git command line client
# GIT_FOUND - true if the command line client was found
# Example usage:
# find_package(Git)
# if(GIT_FOUND)
# message("git found: ${GIT_EXECUTABLE}")
# endif()
#=============================================================================
# Copyright 2010 Kitware, Inc.
#
# Distributed under the OSI-approved BSD License (the "License");
# see accompanying file Copyright.txt for details.
#
# This software is distributed WITHOUT ANY WARRANTY; without even the
# implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
# See the License for more information.
#=============================================================================
# (To distributed this file outside of CMake, substitute the full
# License text for the above reference.)
# Look for 'git' or 'eg' (easy git)
#
set(git_names git eg)
# Prefer .cmd variants on Windows unless running in a Makefile
# in the MSYS shell.
#
if(WIN32)
if(NOT CMAKE_GENERATOR MATCHES "MSYS")
set(git_names git.cmd git eg.cmd eg)
endif()
endif()
find_program(GIT_EXECUTABLE
NAMES ${git_names}
DOC "git command line client"
)
mark_as_advanced(GIT_EXECUTABLE)
# Handle the QUIETLY and REQUIRED arguments and set GIT_FOUND to TRUE if
# all listed variables are TRUE
include(FindPackageHandleStandardArgs)
find_package_handle_standard_args(Git DEFAULT_MSG GIT_EXECUTABLE)
================================================
FILE: cmake/Modules/FindNUMA.cmake
================================================
# Find numa library
# Once done this will define
# NUMA_FOUND - libnuma found
# NUMA_OLD - old libnuma API
if(NOT NUMA_FOUND)
find_library(NUMA_LIBRARY NAMES numa PATH_SUFFIXES lib lib64)
if(NUMA_LIBRARY)
include(CheckLibraryExists)
check_library_exists(${NUMA_LIBRARY} numa_available "" NUMA_FOUND_INTERNAL)
if(NUMA_FOUND_INTERNAL)
check_library_exists(${NUMA_LIBRARY} numa_allocate_nodemask "" NUMA_NEW_INTERNAL)
if(NOT NUMA_NEW_INTERNAL)
set(NUMA_OLD "yes" CACHE)
endif()
endif()
include(FindPackageHandleStandardArgs)
find_package_handle_standard_args(NUMA DEFAULT_MSG NUMA_LIBRARY)
mark_as_advanced(NUMA_FOUND)
endif()
endif()
================================================
FILE: cmake/Modules/FindOpenCL.cmake
================================================
#
# This file taken from FindOpenCL project @ http://gitorious.com/findopencl
#
# - Try to find OpenCL
# This module tries to find an OpenCL implementation on your system. It supports
# AMD / ATI, Apple and NVIDIA implementations, but should work, too.
#
# Once done this will define
# OPENCL_FOUND - system has OpenCL
# OPENCL_INCLUDE_DIRS - the OpenCL include directory
# OPENCL_LIBRARIES - link these to use OpenCL
#
# WIN32 should work, but is untested
FIND_PACKAGE( PackageHandleStandardArgs )
SET (OPENCL_VERSION_STRING "0.1.0")
SET (OPENCL_VERSION_MAJOR 0)
SET (OPENCL_VERSION_MINOR 1)
SET (OPENCL_VERSION_PATCH 0)
IF (APPLE)
FIND_LIBRARY(OPENCL_LIBRARIES OpenCL DOC "OpenCL lib for OSX")
FIND_PATH(OPENCL_INCLUDE_DIRS opencl/cl.h DOC "Include for OpenCL on OSX")
FIND_PATH(_OPENCL_CPP_INCLUDE_DIRS opencl/cl.hpp DOC "Include for OpenCL CPP bindings on OSX")
ELSE (APPLE)
IF (WIN32)
FIND_PATH(OPENCL_INCLUDE_DIRS CL/cl.h)
FIND_PATH(_OPENCL_CPP_INCLUDE_DIRS CL/cl.hpp)
# The AMD SDK currently installs both x86 and x86_64 libraries
# This is only a hack to find out architecture
IF( ${CMAKE_SYSTEM_PROCESSOR} STREQUAL "AMD64" )
SET(OPENCL_LIB_DIR "$ENV{ATISTREAMSDKROOT}/lib/x86_64")
SET(OPENCL_LIB_DIR "$ENV{ATIINTERNALSTREAMSDKROOT}/lib/x86_64")
ELSE (${CMAKE_SYSTEM_PROCESSOR} STREQUAL "AMD64")
SET(OPENCL_LIB_DIR "$ENV{ATISTREAMSDKROOT}/lib/x86")
SET(OPENCL_LIB_DIR "$ENV{ATIINTERNALSTREAMSDKROOT}/lib/x86")
ENDIF( ${CMAKE_SYSTEM_PROCESSOR} STREQUAL "AMD64" )
# find out if the user asked for a 64-bit build, and use the corresponding
# 64 or 32 bit NVIDIA library paths to the search:
STRING(REGEX MATCH "Win64" ISWIN64 ${CMAKE_GENERATOR})
IF("${ISWIN64}" STREQUAL "Win64")
FIND_LIBRARY(OPENCL_LIBRARIES OpenCL.lib ${OPENCL_LIB_DIR} $ENV{CUDA_LIB_PATH} $ENV{CUDA_PATH}/lib/x64)
ELSE("${ISWIN64}" STREQUAL "Win64")
FIND_LIBRARY(OPENCL_LIBRARIES OpenCL.lib ${OPENCL_LIB_DIR} $ENV{CUDA_LIB_PATH} $ENV{CUDA_PATH}/lib/Win32)
ENDIF("${ISWIN64}" STREQUAL "Win64")
GET_FILENAME_COMPONENT(_OPENCL_INC_CAND ${OPENCL_LIB_DIR}/../../include ABSOLUTE)
# On Win32 search relative to the library
FIND_PATH(OPENCL_INCLUDE_DIRS CL/cl.h PATHS "${_OPENCL_INC_CAND}" $ENV{CUDA_INC_PATH} $ENV{CUDA_PATH}/include)
FIND_PATH(_OPENCL_CPP_INCLUDE_DIRS CL/cl.hpp PATHS "${_OPENCL_INC_CAND}" $ENV{CUDA_INC_PATH} $ENV{CUDA_PATH}/include)
ELSE (WIN32)
# Unix style platforms
FIND_LIBRARY(OPENCL_LIBRARIES OpenCL
ENV LD_LIBRARY_PATH
)
GET_FILENAME_COMPONENT(OPENCL_LIB_DIR ${OPENCL_LIBRARIES} PATH)
GET_FILENAME_COMPONENT(_OPENCL_INC_CAND ${OPENCL_LIB_DIR}/../../include ABSOLUTE)
# The AMD SDK currently does not place its headers
# in /usr/include, therefore also search relative
# to the library
FIND_PATH(OPENCL_INCLUDE_DIRS CL/cl.h PATHS ${_OPENCL_INC_CAND} $ENV{OPENCL_INCLUDE_DIRS} "/usr/local/cuda/include")
FIND_PATH(_OPENCL_CPP_INCLUDE_DIRS CL/cl.hpp PATHS ${_OPENCL_INC_CAND} $ENV{OPENCL_LIB_DIR} "/usr/local/cuda/include")
ENDIF (WIN32)
ENDIF (APPLE)
FIND_PACKAGE_HANDLE_STANDARD_ARGS( OpenCL DEFAULT_MSG OPENCL_LIBRARIES OPENCL_INCLUDE_DIRS )
IF( _OPENCL_CPP_INCLUDE_DIRS )
SET( OPENCL_HAS_CPP_BINDINGS TRUE )
LIST( APPEND OPENCL_INCLUDE_DIRS ${_OPENCL_CPP_INCLUDE_DIRS} )
# This is often the same, so clean up
LIST( REMOVE_DUPLICATES OPENCL_INCLUDE_DIRS )
ENDIF( _OPENCL_CPP_INCLUDE_DIRS )
MARK_AS_ADVANCED(
OPENCL_INCLUDE_DIRS
)
================================================
FILE: cmake/Modules/FindPAPI.cmake
================================================
# Find PAPI libraries
# Once done this will define
# PAPI_FOUND - System has PAPI
# PAPI_INCLUDE_DIRS - The PAPI include directories
# PAPI_LIBRARIES - The libraries needed to use PAPI
if(PAPI_INCLUDE_DIRS AND PAPI_LIBRARIES)
set(PAPI_FIND_QUIETLY TRUE)
endif()
# XXX(ddn): our system papi is broken so ignore for now
# find_path(PAPI_INCLUDE_DIRS papi.h HINTS ${PAPI_ROOT} PATH_SUFFIXES include NO_DEFAULT_PATH )
find_path(PAPI_INCLUDE_DIRS papi.h HINTS ${PAPI_ROOT} ENV TACC_PAPI_DIR PATH_SUFFIXES include)
message(STATUS "PAPI_INCLUDE_DIRS: ${PAPI_INCLUDE_DIRS}")
find_library(PAPI_LIBRARY NAMES papi HINTS ${PAPI_ROOT} ENV TACC_PAPI_DIR PATH_SUFFIXES lib lib64)
message(STATUS "PAPI_LIBRARY: ${PAPI_LIBRARY}")
find_library(PAPI_LIBRARIES NAMES rt PATH_SUFFIXES lib lib64)
include(FindPackageHandleStandardArgs)
find_package_handle_standard_args(PAPI DEFAULT_MSG PAPI_LIBRARY PAPI_LIBRARIES PAPI_INCLUDE_DIRS)
if(PAPI_FOUND)
set(PAPI_LIBRARIES ${PAPI_LIBRARY} ${PAPI_LIBRARIES})
endif()
mark_as_advanced(PAPI_INCLUDE_DIRS PAPI_LIBRARIES)
================================================
FILE: cmake/Modules/FindQGLViewer.cmake
================================================
# Find QGLViewer libraries
# Once done this will define
# QGLViewer_FOUND - System has QGLViewer
# QGLViewer_INCLUDE_DIRS - The QGLViewer include directories
# QGLViewer_LIBRARIES - The libraries needed to use QGLViewer
if(QGLViewer_INCLUDE_DIRS AND QGLVIEWER_LIBRARIES)
set(QGLViewer_FIND_QUIETLY TRUE)
endif()
find_path(QGLViewer_INCLUDE_DIRS NAMES QGLViewer/qglviewer.h)
find_library(QGLViewer_LIBRARIES NAMES QGLViewer PATH_SUFFIXES lib lib64)
include(FindPackageHandleStandardArgs)
find_package_handle_standard_args(QGLViewer DEFAULT_MSG QGLViewer_INCLUDE_DIRS QGLViewer_LIBRARIES)
if(QGLVIEWER_FOUND)
set(QGLViewer_FOUND TRUE)
endif()
mark_as_advanced(QGLViewer_INCLUDE_DIRS QGLViewer_LIBRARIES)
================================================
FILE: cmake/Modules/FindTBB.cmake
================================================
# Locate Intel Threading Building Blocks include paths and libraries
# FindTBB.cmake can be found at https://code.google.com/p/findtbb/
# Written by Hannes Hofmann <hannes.hofmann _at_ informatik.uni-erlangen.de>
# Improvements by Gino van den Bergen <gino _at_ dtecta.com>,
# Florian Uhlig <F.Uhlig _at_ gsi.de>,
# Jiri Marsik <jiri.marsik89 _at_ gmail.com>
# The MIT License
#
# Copyright (c) 2011 Hannes Hofmann
#
# Permission is hereby granted, free of charge, to any person obtaining a copy
# of this software and associated documentation files (the "Software"), to deal
# in the Software without restriction, including without limitation the rights
# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
# copies of the Software, and to permit persons to whom the Software is
# furnished to do so, subject to the following conditions:
#
# The above copyright notice and this permission notice shall be included in
# all copies or substantial portions of the Software.
#
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
# THE SOFTWARE.
# GvdB: This module uses the environment variable TBB_ARCH_PLATFORM which defines architecture and compiler.
# e.g. "ia32/vc8" or "em64t/cc4.1.0_libc2.4_kernel2.6.16.21"
# TBB_ARCH_PLATFORM is set by the build script tbbvars[.bat|.sh|.csh], which can be found
# in the TBB installation directory (TBB_INSTALL_DIR).
#
# GvdB: Mac OS X distribution places libraries directly in lib directory.
#
# For backwards compatibility, you may explicitely set the CMake variables TBB_ARCHITECTURE and TBB_COMPILER.
# TBB_ARCHITECTURE [ ia32 | em64t | itanium ]
# which architecture to use
# TBB_COMPILER e.g. vc9 or cc3.2.3_libc2.3.2_kernel2.4.21 or cc4.0.1_os10.4.9
# which compiler to use (detected automatically on Windows)
# This module respects
# TBB_INSTALL_DIR or $ENV{TBB21_INSTALL_DIR} or $ENV{TBB_INSTALL_DIR}
# This module defines
# TBB_INCLUDE_DIRS, where to find task_scheduler_init.h, etc.
# TBB_LIBRARY_DIRS, where to find libtbb, libtbbmalloc
# TBB_DEBUG_LIBRARY_DIRS, where to find libtbb_debug, libtbbmalloc_debug
# TBB_INSTALL_DIR, the base TBB install directory
# TBB_LIBRARIES, the libraries to link against to use TBB.
# TBB_DEBUG_LIBRARIES, the libraries to link against to use TBB with debug symbols.
# TBB_FOUND, If false, don't try to use TBB.
# TBB_INTERFACE_VERSION, as defined in tbb/tbb_stddef.h
if (WIN32)
# has em64t/vc8 em64t/vc9
# has ia32/vc7.1 ia32/vc8 ia32/vc9
set(_TBB_DEFAULT_INSTALL_DIR "C:/Program Files/Intel/TBB" "C:/Program Files (x86)/Intel/TBB")
set(_TBB_LIB_NAME "tbb")
set(_TBB_LIB_MALLOC_NAME "${_TBB_LIB_NAME}malloc")
set(_TBB_LIB_DEBUG_NAME "${_TBB_LIB_NAME}_debug")
set(_TBB_LIB_MALLOC_DEBUG_NAME "${_TBB_LIB_MALLOC_NAME}_debug")
if (MSVC71)
set (_TBB_COMPILER "vc7.1")
endif(MSVC71)
if (MSVC80)
set(_TBB_COMPILER "vc8")
endif(MSVC80)
if (MSVC90)
set(_TBB_COMPILER "vc9")
endif(MSVC90)
if(MSVC10)
set(_TBB_COMPILER "vc10")
endif(MSVC10)
# Todo: add other Windows compilers such as ICL.
set(_TBB_ARCHITECTURE ${TBB_ARCHITECTURE})
endif (WIN32)
if (UNIX)
if (APPLE)
# MAC
set(_TBB_DEFAULT_INSTALL_DIR "/Library/Frameworks/Intel_TBB.framework/Versions")
# libs: libtbb.dylib, libtbbmalloc.dylib, *_debug
set(_TBB_LIB_NAME "tbb")
set(_TBB_LIB_MALLOC_NAME "${_TBB_LIB_NAME}malloc")
set(_TBB_LIB_DEBUG_NAME "${_TBB_LIB_NAME}_debug")
set(_TBB_LIB_MALLOC_DEBUG_NAME "${_TBB_LIB_MALLOC_NAME}_debug")
# default flavor on apple: ia32/cc4.0.1_os10.4.9
# Jiri: There is no reason to presume there is only one flavor and
# that user's setting of variables should be ignored.
if(NOT TBB_COMPILER)
set(_TBB_COMPILER "cc4.0.1_os10.4.9")
elseif (NOT TBB_COMPILER)
set(_TBB_COMPILER ${TBB_COMPILER})
endif(NOT TBB_COMPILER)
if(NOT TBB_ARCHITECTURE)
set(_TBB_ARCHITECTURE "ia32")
elseif(NOT TBB_ARCHITECTURE)
set(_TBB_ARCHITECTURE ${TBB_ARCHITECTURE})
endif(NOT TBB_ARCHITECTURE)
else (APPLE)
# LINUX
set(_TBB_DEFAULT_INSTALL_DIR "/opt/intel/tbb" "/usr/local/include" "/usr/include")
set(_TBB_LIB_NAME "tbb")
set(_TBB_LIB_MALLOC_NAME "${_TBB_LIB_NAME}malloc")
set(_TBB_LIB_DEBUG_NAME "${_TBB_LIB_NAME}_debug")
set(_TBB_LIB_MALLOC_DEBUG_NAME "${_TBB_LIB_MALLOC_NAME}_debug")
# has em64t/cc3.2.3_libc2.3.2_kernel2.4.21 em64t/cc3.3.3_libc2.3.3_kernel2.6.5 em64t/cc3.4.3_libc2.3.4_kernel2.6.9 em64t/cc4.1.0_libc2.4_kernel2.6.16.21
# has ia32/*
# has itanium/*
set(_TBB_COMPILER ${TBB_COMPILER})
set(_TBB_ARCHITECTURE ${TBB_ARCHITECTURE})
endif (APPLE)
endif (UNIX)
if (CMAKE_SYSTEM MATCHES "SunOS.*")
# SUN
# not yet supported
# has em64t/cc3.4.3_kernel5.10
# has ia32/*
endif (CMAKE_SYSTEM MATCHES "SunOS.*")
#-- Clear the public variables
set (TBB_FOUND "NO")
#-- Find TBB install dir and set ${_TBB_INSTALL_DIR} and cached ${TBB_INSTALL_DIR}
# first: use CMake variable TBB_INSTALL_DIR
if (TBB_INSTALL_DIR)
set (_TBB_INSTALL_DIR ${TBB_INSTALL_DIR})
endif (TBB_INSTALL_DIR)
# second: use environment variable
if (NOT _TBB_INSTALL_DIR)
if (NOT "$ENV{TBBROOT}" STREQUAL "")
set (_TBB_INSTALL_DIR $ENV{TBBROOT})
endif()
if (NOT "$ENV{TBB_INSTALL_DIR}" STREQUAL "")
set (_TBB_INSTALL_DIR $ENV{TBB_INSTALL_DIR})
endif (NOT "$ENV{TBB_INSTALL_DIR}" STREQUAL "")
# Intel recommends setting TBB21_INSTALL_DIR
if (NOT "$ENV{TBB21_INSTALL_DIR}" STREQUAL "")
set (_TBB_INSTALL_DIR $ENV{TBB21_INSTALL_DIR})
endif (NOT "$ENV{TBB21_INSTALL_DIR}" STREQUAL "")
if (NOT "$ENV{TBB22_INSTALL_DIR}" STREQUAL "")
set (_TBB_INSTALL_DIR $ENV{TBB22_INSTALL_DIR})
endif (NOT "$ENV{TBB22_INSTALL_DIR}" STREQUAL "")
if (NOT "$ENV{TBB30_INSTALL_DIR}" STREQUAL "")
set (_TBB_INSTALL_DIR $ENV{TBB30_INSTALL_DIR})
endif (NOT "$ENV{TBB30_INSTALL_DIR}" STREQUAL "")
endif (NOT _TBB_INSTALL_DIR)
# third: try to find path automatically
if (NOT _TBB_INSTALL_DIR)
if (_TBB_DEFAULT_INSTALL_DIR)
set (_TBB_INSTALL_DIR ${_TBB_DEFAULT_INSTALL_DIR})
endif (_TBB_DEFAULT_INSTALL_DIR)
endif (NOT _TBB_INSTALL_DIR)
# sanity check
if (NOT _TBB_INSTALL_DIR)
message ("ERROR: Unable to find Intel TBB install directory. ${_TBB_INSTALL_DIR}")
else (NOT _TBB_INSTALL_DIR)
# finally: set the cached CMake variable TBB_INSTALL_DIR
if (NOT TBB_INSTALL_DIR)
set (TBB_INSTALL_DIR ${_TBB_INSTALL_DIR} CACHE PATH "Intel TBB install directory")
mark_as_advanced(TBB_INSTALL_DIR)
endif (NOT TBB_INSTALL_DIR)
#-- A macro to rewrite the paths of the library. This is necessary, because
# find_library() always found the em64t/vc9 version of the TBB libs
macro(TBB_CORRECT_LIB_DIR var_name)
# if (NOT "${_TBB_ARCHITECTURE}" STREQUAL "em64t")
string(REPLACE em64t "${_TBB_ARCHITECTURE}" ${var_name} ${${var_name}})
# endif (NOT "${_TBB_ARCHITECTURE}" STREQUAL "em64t")
string(REPLACE ia32 "${_TBB_ARCHITECTURE}" ${var_name} ${${var_name}})
string(REPLACE vc7.1 "${_TBB_COMPILER}" ${var_name} ${${var_name}})
string(REPLACE vc8 "${_TBB_COMPILER}" ${var_name} ${${var_name}})
string(REPLACE vc9 "${_TBB_COMPILER}" ${var_name} ${${var_name}})
string(REPLACE vc10 "${_TBB_COMPILER}" ${var_name} ${${var_name}})
endmacro(TBB_CORRECT_LIB_DIR var_content)
#-- Look for include directory and set ${TBB_INCLUDE_DIR}
set (TBB_INC_SEARCH_DIR ${_TBB_INSTALL_DIR}/include)
# Jiri: tbbvars now sets the CPATH environment variable to the directory
# containing the headers.
find_path(TBB_INCLUDE_DIR
tbb/task_scheduler_init.h
PATHS ${TBB_INC_SEARCH_DIR} ENV CPATH
)
mark_as_advanced(TBB_INCLUDE_DIR)
#-- Look for libraries
# GvdB: $ENV{TBB_ARCH_PLATFORM} is set by the build script tbbvars[.bat|.sh|.csh]
if (NOT $ENV{TBB_ARCH_PLATFORM} STREQUAL "")
set (_TBB_LIBRARY_DIR
${_TBB_INSTALL_DIR}/lib/$ENV{TBB_ARCH_PLATFORM}
${_TBB_INSTALL_DIR}/$ENV{TBB_ARCH_PLATFORM}/lib
)
endif (NOT $ENV{TBB_ARCH_PLATFORM} STREQUAL "")
# Jiri: This block isn't mutually exclusive with the previous one
# (hence no else), instead I test if the user really specified
# the variables in question.
if ((NOT ${TBB_ARCHITECTURE} STREQUAL "") AND (NOT ${TBB_COMPILER} STREQUAL ""))
# HH: deprecated
message(STATUS "[Warning] FindTBB.cmake: The use of TBB_ARCHITECTURE and TBB_COMPILER is deprecated and may not be supported in future versions. Please set \$ENV{TBB_ARCH_PLATFORM} (using tbbvars.[bat|csh|sh]).")
# Jiri: It doesn't hurt to look in more places, so I store the hints from
# ENV{TBB_ARCH_PLATFORM} and the TBB_ARCHITECTURE and TBB_COMPILER
# variables and search them both.
set (_TBB_LIBRARY_DIR "${_TBB_INSTALL_DIR}/${_TBB_ARCHITECTURE}/${_TBB_COMPILER}/lib" ${_TBB_LIBRARY_DIR})
endif ((NOT ${TBB_ARCHITECTURE} STREQUAL "") AND (NOT ${TBB_COMPILER} STREQUAL ""))
# GvdB: Mac OS X distribution places libraries directly in lib directory.
list(APPEND _TBB_LIBRARY_DIR ${_TBB_INSTALL_DIR}/lib)
# Jiri: No reason not to check the default paths. From recent versions,
# tbbvars has started exporting the LIBRARY_PATH and LD_LIBRARY_PATH
# variables, which now point to the directories of the lib files.
# It all makes more sense to use the ${_TBB_LIBRARY_DIR} as a HINTS
# argument instead of the implicit PATHS as it isn't hard-coded
# but computed by system introspection. Searching the LIBRARY_PATH
# and LD_LIBRARY_PATH environment variables is now even more important
# that tbbvars doesn't export TBB_ARCH_PLATFORM and it facilitates
# the use of TBB built from sources.
find_library(TBB_LIBRARY ${_TBB_LIB_NAME} HINTS ${_TBB_LIBRARY_DIR}
PATHS ENV LIBRARY_PATH ENV LD_LIBRARY_PATH)
find_library(TBB_MALLOC_LIBRARY ${_TBB_LIB_MALLOC_NAME} HINTS ${_TBB_LIBRARY_DIR}
PATHS ENV LIBRARY_PATH ENV LD_LIBRARY_PATH)
#Extract path from TBB_LIBRARY name
get_filename_component(TBB_LIBRARY_DIR ${TBB_LIBRARY} PATH)
#TBB_CORRECT_LIB_DIR(TBB_LIBRARY)
#TBB_CORRECT_LIB_DIR(TBB_MALLOC_LIBRARY)
mark_as_advanced(TBB_LIBRARY TBB_MALLOC_LIBRARY)
#-- Look for debug libraries
# Jiri: Changed the same way as for the release libraries.
find_library(TBB_LIBRARY_DEBUG ${_TBB_LIB_DEBUG_NAME} HINTS ${_TBB_LIBRARY_DIR}
PATHS ENV LIBRARY_PATH ENV LD_LIBRARY_PATH)
find_library(TBB_MALLOC_LIBRARY_DEBUG ${_TBB_LIB_MALLOC_DEBUG_NAME} HINTS ${_TBB_LIBRARY_DIR}
PATHS ENV LIBRARY_PATH ENV LD_LIBRARY_PATH)
# Jiri: Self-built TBB stores the debug libraries in a separate directory.
# Extract path from TBB_LIBRARY_DEBUG name
get_filename_component(TBB_LIBRARY_DEBUG_DIR ${TBB_LIBRARY_DEBUG} PATH)
#TBB_CORRECT_LIB_DIR(TBB_LIBRARY_DEBUG)
#TBB_CORRECT_LIB_DIR(TBB_MALLOC_LIBRARY_DEBUG)
mark_as_advanced(TBB_LIBRARY_DEBUG TBB_MALLOC_LIBRARY_DEBUG)
if (TBB_INCLUDE_DIR)
if (TBB_LIBRARY)
set (TBB_FOUND "YES")
set (TBB_LIBRARIES ${TBB_LIBRARY} ${TBB_MALLOC_LIBRARY} ${TBB_LIBRARIES})
set (TBB_DEBUG_LIBRARIES ${TBB_LIBRARY_DEBUG} ${TBB_MALLOC_LIBRARY_DEBUG} ${TBB_DEBUG_LIBRARIES})
set (TBB_INCLUDE_DIRS ${TBB_INCLUDE_DIR} CACHE PATH "TBB include directory" FORCE)
set (TBB_LIBRARY_DIRS ${TBB_LIBRARY_DIR} CACHE PATH "TBB library directory" FORCE)
# Jiri: Self-built TBB stores the debug libraries in a separate directory.
set (TBB_DEBUG_LIBRARY_DIRS ${TBB_LIBRARY_DEBUG_DIR} CACHE PATH "TBB debug library directory" FORCE)
mark_as_advanced(TBB_INCLUDE_DIRS TBB_LIBRARY_DIRS TBB_DEBUG_LIBRARY_DIRS TBB_LIBRARIES TBB_DEBUG_LIBRARIES)
message(STATUS "Found Intel TBB")
endif (TBB_LIBRARY)
endif (TBB_INCLUDE_DIR)
if (NOT TBB_FOUND)
message("ERROR: Intel TBB NOT found!")
message(STATUS "Looked for Threading Building Blocks in ${_TBB_INSTALL_DIR}")
# do only throw fatal, if this pkg is REQUIRED
if (TBB_FIND_REQUIRED)
message(FATAL_ERROR "Could NOT find TBB library.")
endif (TBB_FIND_REQUIRED)
endif (NOT TBB_FOUND)
endif (NOT _TBB_INSTALL_DIR)
if (TBB_FOUND)
set(TBB_INTERFACE_VERSION 0)
# FILE(READ "${TBB_INCLUDE_DIRS}/tbb/tbb_stddef.h" _TBB_VERSION_CONTENTS)
STRING(REGEX REPLACE ".*#define TBB_INTERFACE_VERSION ([0-9]+).*" "\\1" TBB_INTERFACE_VERSION "${_TBB_VERSION_CONTENTS}")
set(TBB_INTERFACE_VERSION "${TBB_INTERFACE_VERSION}")
endif (TBB_FOUND)
================================================
FILE: cmake/Modules/FindVTune.cmake
================================================
# Find VTune libraries
# Once done this will define
# VTune_FOUND - System has VTune
# VTune_INCLUDE_DIRS - The VTune include directories
# VTune_LIBRARIES - The libraries needed to use VTune
message(STATUS "${VTune_INCLUDE_DIRS}")
if(VTune_INCLUDE_DIRS AND VTune_LIBRARIES)
set(VTune_FIND_QUIETLY TRUE)
endif()
set(VTune_LIBRARY_PATH_CANDIDATES lib lib64 lib32 bin64/k1om bin32/k1om)
find_path(VTune_INCLUDE_DIRS ittnotify.h PATHS ${VTune_ROOT} PATH_SUFFIXES include)
find_library(VTune_LIBRARY NAMES ittnotify PATHS ${VTune_ROOT} PATH_SUFFIXES ${VTune_LIBRARY_PATH_CANDIDATES})
find_library(VTune_LIBRARIES NAMES dl PATH_SUFFIXES lib lib64 lib32)
include(FindPackageHandleStandardArgs)
find_package_handle_standard_args(VTune DEFAULT_MSG VTune_LIBRARY VTune_LIBRARIES VTune_INCLUDE_DIRS)
if(VTUNE_FOUND)
set(VTune_FOUND on)
set(VTune_LIBRARIES ${VTune_LIBRARY} ${VTune_LIBRARIES})
endif()
mark_as_advanced(VTune_INCLUDE_DIRS VTune_LIBRARIES)
================================================
FILE: cmake/Modules/GetGitVersion-write.cmake
================================================
### Don't include directly, for use by GetSVNVersion.cmake
find_package(Git)
# Extract svn info into MY_XXX variables
if(GIT_FOUND)
execute_process(COMMAND ${GIT_EXECUTABLE} rev-parse --verify --short HEAD
WORKING_DIRECTORY ${SOURCE_DIR}
OUTPUT_VARIABLE GIT_REVISION
OUTPUT_STRIP_TRAILING_WHITESPACE)
file(WRITE include/galois/revision.h.txt "#define GALOIS_REVISION \"${GIT_REVISION}\"\n")
else()
file(WRITE include/galois/revision.h.txt "#define GALOIS_REVISION \"0\"\n")
endif()
execute_process(COMMAND ${CMAKE_COMMAND} -E copy_if_different include/galois/revision.h.txt include/galois/revision.h)
================================================
FILE: cmake/Modules/GetGitVersion.cmake
================================================
# DUMMY is a non-existent file to force regeneration of svn header every build
add_custom_target(revision ALL DEPENDS DUMMY ${PROJECT_BINARY_DIR}/include/galois/revision.h)
find_file(_MODULE "GetGitVersion-write.cmake" PATHS ${CMAKE_MODULE_PATH})
add_custom_command(OUTPUT DUMMY ${PROJECT_BINARY_DIR}/include/galois/revision.h
COMMAND ${CMAKE_COMMAND} -DSOURCE_DIR=${CMAKE_SOURCE_DIR}
-DCMAKE_MODULE_PATH="${CMAKE_SOURCE_DIR}/cmake/Modules/" -P ${_MODULE})
set(_MODULE off)
set_source_files_properties(${PROJECT_BINARY_DIR}/include/galois/revision.h
PROPERTIES GENERATED TRUE
HEADER_FILE_ONLY TRUE)
================================================
FILE: cmake/Modules/HandleSanitizer.cmake
================================================
# Galois: taken from:
# https://github.com/llvm/llvm-project/blob/master/llvm/cmake/modules/HandleLLVMOptions.cmake
include(CheckCCompilerFlag)
include(CheckCXXCompilerFlag)
string(TOUPPER "${CMAKE_BUILD_TYPE}" uppercase_CMAKE_BUILD_TYPE)
if(NOT GALOIS_USE_SANITIZER)
return()
endif()
function(append value)
foreach(variable ${ARGN})
set(${variable} "${${variable}} ${value}" PARENT_SCOPE)
endforeach(variable)
endfunction()
function(append_if condition value)
if (${condition})
foreach(variable ${ARGN})
set(${variable} "${${variable}} ${value}" PARENT_SCOPE)
endforeach(variable)
endif()
endfunction()
macro(add_flag_if_supported flag name)
check_c_compiler_flag("-Werror ${flag}" "C_SUPPORTS_${name}")
append_if("C_SUPPORTS_${name}" "${flag}" CMAKE_C_FLAGS)
check_cxx_compiler_flag("-Werror ${flag}" "CXX_SUPPORTS_${name}")
append_if("CXX_SUPPORTS_${name}" "${flag}" CMAKE_CXX_FLAGS)
endmacro()
macro(append_common_sanitizer_flags)
# Append -fno-omit-frame-pointer and turn on debug info to get better
# stack traces.
add_flag_if_supported("-fno-omit-frame-pointer" FNO_OMIT_FRAME_POINTER)
if (NOT uppercase_CMAKE_BUILD_TYPE STREQUAL "DEBUG" AND
NOT uppercase_CMAKE_BUILD_TYPE STREQUAL "RELWITHDEBINFO")
add_flag_if_supported("-gline-tables-only" GLINE_TABLES_ONLY)
endif()
# Use -O1 even in debug mode, otherwise sanitizers slowdown is too large.
if (uppercase_CMAKE_BUILD_TYPE STREQUAL "DEBUG")
add_flag_if_supported("-O1" O1)
endif()
endmacro()
if (GALOIS_USE_SANITIZER STREQUAL "Address")
append_common_sanitizer_flags()
append("-fsanitize=address" CMAKE_C_FLAGS CMAKE_CXX_FLAGS)
elseif (GALOIS_USE_SANITIZER STREQUAL "HWAddress")
append_common_sanitizer_flags()
append("-fsanitize=hwaddress" CMAKE_C_FLAGS CMAKE_CXX_FLAGS)
elseif (GALOIS_USE_SANITIZER MATCHES "Memory(WithOrigins)?")
append_common_sanitizer_flags()
append("-fsanitize=memory" CMAKE_C_FLAGS CMAKE_CXX_FLAGS)
if(GALOIS_USE_SANITIZER STREQUAL "MemoryWithOrigins")
append("-fsanitize-memory-track-origins" CMAKE_C_FLAGS CMAKE_CXX_FLAGS)
endif()
elseif (GALOIS_USE_SANITIZER STREQUAL "Undefined")
append_common_sanitizer_flags()
append("-fsanitize=undefined -fno-sanitize-recover=all"
CMAKE_C_FLAGS CMAKE_CXX_FLAGS)
elseif (GALOIS_USE_SANITIZER STREQUAL "Thread")
append_common_sanitizer_flags()
append("-fsanitize=thread" CMAKE_C_FLAGS CMAKE_CXX_FLAGS)
elseif (GALOIS_USE_SANITIZER STREQUAL "DataFlow")
append("-fsanitize=dataflow" CMAKE_C_FLAGS CMAKE_CXX_FLAGS)
elseif (GALOIS_USE_SANITIZER STREQUAL "Address;Undefined" OR
GALOIS_USE_SANITIZER STREQUAL "Undefined;Address")
append_common_sanitizer_flags()
append("-fsanitize=address,undefined -fno-sanitize-recover=all"
CMAKE_C_FLAGS CMAKE_CXX_FLAGS)
elseif (GALOIS_USE_SANITIZER STREQUAL "Leaks")
append_common_sanitizer_flags()
append("-fsanitize=leak" CMAKE_C_FLAGS CMAKE_CXX_FLAGS)
else()
message(FATAL_ERROR "Unsupported value of GALOIS_USE_SANITIZER: ${GALOIS_USE_SANITIZER}")
endif()
if (GALOIS_USE_SANITIZER MATCHES "(Undefined;)?Address(;Undefined)?")
add_flag_if_supported("-fsanitize-address-use-after-scope"
FSANITIZE_USE_AFTER_SCOPE_FLAG)
endif()
if (GALOIS_USE_SANITIZE_COVERAGE)
append("-fsanitize=fuzzer-no-link" CMAKE_C_FLAGS CMAKE_CXX_FLAGS)
endif()
if (GALOIS_USE_SANITIZER MATCHES ".*Undefined.*")
set(BLACKLIST_CONFIGURE_FILE "${PROJECT_SOURCE_DIR}/config/sanitizers/ubsan_blacklist.txt.in")
if (EXISTS "${BLACKLIST_CONFIGURE_FILE}")
set(BLACKLIST_FILE "${PROJECT_BINARY_DIR}/config/sanitizers/ubsan_blacklist.txt")
configure_file("${BLACKLIST_CONFIGURE_FILE}" "${BLACKLIST_FILE}")
append("-fsanitize-blacklist=${BLACKLIST_FILE}"
CMAKE_C_FLAGS CMAKE_CXX_FLAGS)
endif()
endif()
================================================
FILE: cmake/Modules/LibFindMacros.cmake
================================================
# Copyright Raimar Sandner 2012–2014. Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.txt)
#! \file
#! \ingroup Helpers
#! \brief Improved versions of %CMake's `find_package`
#! \ingroup Helpers
#! \brief Works the same as `find_package`, but forwards the "REQUIRED" and "QUIET" arguments
#! used for the current package.
#!
#! For this to work, the first parameter must be the prefix of the current package, then the
#! prefix of the new package etc, which are passed to `find_package`.
macro (libfind_package PREFIX)
set (LIBFIND_PACKAGE_ARGS ${ARGN})
if (${PREFIX}_FIND_QUIETLY)
set (LIBFIND_PACKAGE_ARGS ${LIBFIND_PACKAGE_ARGS} QUIET)
endif (${PREFIX}_FIND_QUIETLY)
if (${PREFIX}_FIND_REQUIRED)
set (LIBFIND_PACKAGE_ARGS ${LIBFIND_PACKAGE_ARGS} REQUIRED)
endif (${PREFIX}_FIND_REQUIRED)
find_package(${LIBFIND_PACKAGE_ARGS})
endmacro (libfind_package)
#! \ingroup Helpers
#! \brief Do the final processing once the paths have been detected.
#!
#! If include dirs are needed, `${PREFIX}_PROCESS_INCLUDES` should be set to contain
#! all the variables, each of which contain one include directory.
#! Ditto for `${PREFIX}_PROCESS_LIBS` and library files.
#! Will set `${PREFIX}_FOUND`, `${PREFIX}_INCLUDE_DIRS` and `${PREFIX}_LIBRARIES`.
#! Also handles errors in case library detection was required, etc.
macro (libfind_process PREFIX)
# Skip processing if already processed during this run
if (NOT ${PREFIX}_FOUND)
# Start with the assumption that the library was found
set (${PREFIX}_FOUND TRUE)
# Process all includes and set _FOUND to false if any are missing
foreach (i ${${PREFIX}_PROCESS_INCLUDES})
if (${i})
set (${PREFIX}_INCLUDE_DIRS ${${PREFIX}_INCLUDE_DIRS} ${${i}})
mark_as_advanced(${i})
else (${i})
set (${PREFIX}_FOUND FALSE)
endif (${i})
endforeach (i)
# Process all libraries and set _FOUND to false if any are missing
foreach (i ${${PREFIX}_PROCESS_LIBS})
if (${i})
set (${PREFIX}_LIBRARIES ${${PREFIX}_LIBRARIES} ${${i}})
mark_as_advanced(${i})
else (${i})
set (${PREFIX}_FOUND FALSE)
endif (${i})
endforeach (i)
# Print message and/or exit on fatal error
if (${PREFIX}_FOUND)
if (NOT ${PREFIX}_FIND_QUIETLY)
message (STATUS "Found ${PREFIX} ${${PREFIX}_VERSION}")
endif (NOT ${PREFIX}_FIND_QUIETLY)
else (${PREFIX}_FOUND)
if (${PREFIX}_FIND_REQUIRED)
foreach (i ${${PREFIX}_PROCESS_INCLUDES} ${${PREFIX}_PROCESS_LIBS})
message("${i}=${${i}}")
endforeach (i)
message (FATAL_ERROR "Required library ${PREFIX} NOT FOUND.\nInstall the library (dev version) and try again. If the library is already installed, use ccmake to set the missing variables manually.")
endif (${PREFIX}_FIND_REQUIRED)
endif (${PREFIX}_FOUND)
endif (NOT ${PREFIX}_FOUND)
endmacro (libfind_process)
================================================
FILE: cmake/Modules/UseStdMacro.cmake
================================================
add_definitions(-D__STDC_LIMIT_MACROS)
add_definitions(-D__STDC_CONSTANT_MACROS)
================================================
FILE: config/sanitizers/ubsan_blacklist.txt.in
================================================
[undefined]
src:@PROJECT_SOURCE_DIR@/external/bliss/*
================================================
FILE: config/version.txt
================================================
6.0.0
================================================
FILE: external/bliss/bliss/COPYING
================================================
GNU GENERAL PUBLIC LICENSE
Version 3, 29 June 2007
Copyright (C) 2007 Free Software Foundation, Inc. <http://fsf.org/>
Everyone is permitted to copy and distribute verbatim copies
of this license document, but changing it is not allowed.
Preamble
The GNU General Public License is a free, copyleft license for
software and other kinds of works.
The licenses for most software and other practical works are designed
to take away your freedom to share and change the works. By contrast,
the GNU General Public License is intended to guarantee your freedom to
share and change all versions of a program--to make sure it remains free
software for all its users. We, the Free Software Foundation, use the
GNU General Public License for most of our software; it applies also to
any other work released this way by its authors. You can apply it to
your programs, too.
When we speak of free software, we are referring to freedom, not
price. Our General Public Licenses are designed to make sure that you
have the freedom to distribute copies of free software (and charge for
them if you wish), that you receive source code or can get it if you
want it, that you can change the software or use pieces of it in new
free programs, and that you know you can do these things.
To protect your rights, we need to prevent others from denying you
these rights or asking you to surrender the rights. Therefore, you have
certain responsibilities if you distribute copies of the software, or if
you modify it: responsibilities to respect the freedom of others.
For example, if you distribute copies of such a program, whether
gratis or for a fee, you must pass on to the recipients the same
freedoms that you received. You must make sure that they, too, receive
or can get the source code. And you must show them these terms so they
know their rights.
Developers that use the GNU GPL protect your rights with two steps:
(1) assert copyright on the software, and (2) offer you this License
giving you legal permission to copy, distribute and/or modify it.
For the developers' and authors' protection, the GPL clearly explains
that there is no warranty for this free software. For both users' and
authors' sake, the GPL requires that modified versions be marked as
changed, so that their problems will not be attributed erroneously to
authors of previous versions.
Some devices are designed to deny users access to install or run
modified versions of the software inside them, although the manufacturer
can do so. This is fundamentally incompatible with the aim of
protecting users' freedom to change the software. The systematic
pattern of such abuse occurs in the area of products for individuals to
use, which is precisely where it is most unacceptable. Therefore, we
have designed this version of the GPL to prohibit the practice for those
products. If such problems arise substantially in other domains, we
stand ready to extend this provision to those domains in future versions
of the GPL, as needed to protect the freedom of users.
Finally, every program is threatened constantly by software patents.
States should not allow patents to restrict development and use of
software on general-purpose computers, but in those that do, we wish to
avoid the special danger that patents applied to a free program could
make it effectively proprietary. To prevent this, the GPL assures that
patents cannot be used to render the program non-free.
The precise terms and conditions for copying, distribution and
modification follow.
TERMS AND CONDITIONS
0. Definitions.
"This License" refers to version 3 of the GNU General Public License.
"Copyright" also means copyright-like laws that apply to other kinds of
works, such as semiconductor masks.
"The Program" refers to any copyrightable work licensed under this
License. Each licensee is addressed as "you". "Licensees" and
"recipients" may be individuals or organizations.
To "modify" a work means to copy from or adapt all or part of the work
in a fashion requiring copyright permission, other than the making of an
exact copy. The resulting work is called a "modified version" of the
earlier work or a work "based on" the earlier work.
A "covered work" means either the unmodified Program or a work based
on the Program.
To "propagate" a work means to do anything with it that, without
permission, would make you directly or secondarily liable for
infringement under applicable copyright law, except executing it on a
computer or modifying a private copy. Propagation includes copying,
distribution (with or without modification), making available to the
public, and in some countries other activities as well.
To "convey" a work means any kind of propagation that enables other
parties to make or receive copies. Mere interaction with a user through
a computer network, with no transfer of a copy, is not conveying.
An interactive user interface displays "Appropriate Legal Notices"
to the extent that it includes a convenient and prominently visible
feature that (1) displays an appropriate copyright notice, and (2)
tells the user that there is no warranty for the work (except to the
extent that warranties are provided), that licensees may convey the
work under this License, and how to view a copy of this License. If
the interface presents a list of user commands or options, such as a
menu, a prominent item in the list meets this criterion.
1. Source Code.
The "source code" for a work means the preferred form of the work
for making modifications to it. "Object code" means any non-source
form of a work.
A "Standard Interface" means an interface that either is an official
standard defined by a recognized standards body, or, in the case of
interfaces specified for a particular programming language, one that
is widely used among developers working in that language.
The "System Libraries" of an executable work include anything, other
than the work as a whole, that (a) is included in the normal form of
packaging a Major Component, but which is not part of that Major
Component, and (b) serves only to enable use of the work with that
Major Component, or to implement a Standard Interface for which an
implementation is available to the public in source code form. A
"Major Component", in this context, means a major essential component
(kernel, window system, and so on) of the specific operating system
(if any) on which the executable work runs, or a compiler used to
produce the work, or an object code interpreter used to run it.
The "Corresponding Source" for a work in object code form means all
the source code needed to generate, install, and (for an executable
work) run the object code and to modify the work, including scripts to
control those activities. However, it does not include the work's
System Libraries, or general-purpose tools or generally available free
programs which are used unmodified in performing those activities but
which are not part of the work. For example, Corresponding Source
includes interface definition files associated with source files for
the work, and the source code for shared libraries and dynamically
linked subprograms that the work is specifically designed to require,
such as by intimate data communication or control flow between those
subprograms and other parts of the work.
The Corresponding Source need not include anything that users
can regenerate automatically from other parts of the Corresponding
Source.
The Corresponding Source for a work in source code form is that
same work.
2. Basic Permissions.
All rights granted under this License are granted for the term of
copyright on the Program, and are irrevocable provided the stated
conditions are met. This License explicitly affirms your unlimited
permission to run the unmodified Program. The output from running a
covered work is covered by this License only if the output, given its
content, constitutes a covered work. This License acknowledges your
rights of fair use or other equivalent, as provided by copyright law.
You may make, run and propagate covered works that you do not
convey, without conditions so long as your license otherwise remains
in force. You may convey covered works to others for the sole purpose
of having them make modifications exclusively for you, or provide you
with facilities for running those works, provided that you comply with
the terms of this License in conveying all material for which you do
not control copyright. Those thus making or running the covered works
for you must do so exclusively on your behalf, under your direction
and control, on terms that prohibit them from making any copies of
your copyrighted material outside their relationship with you.
Conveying under any other circumstances is permitted solely under
the conditions stated below. Sublicensing is not allowed; section 10
makes it unnecessary.
3. Protecting Users' Legal Rights From Anti-Circumvention Law.
No covered work shall be deemed part of an effective technological
measure under any applicable law fulfilling obligations under article
11 of the WIPO copyright treaty adopted on 20 December 1996, or
similar laws prohibiting or restricting circumvention of such
measures.
When you convey a covered work, you waive any legal power to forbid
circumvention of technological measures to the extent such circumvention
is effected by exercising rights under this License with respect to
the covered work, and you disclaim any intention to limit operation or
modification of the work as a means of enforcing, against the work's
users, your or third parties' legal rights to forbid circumvention of
technological measures.
4. Conveying Verbatim Copies.
You may convey verbatim copies of the Program's source code as you
receive it, in any medium, provided that you conspicuously and
appropriately publish on each copy an appropriate copyright notice;
keep intact all notices stating that this License and any
non-permissive terms added in accord with section 7 apply to the code;
keep intact all notices of the absence of any warranty; and give all
recipients a copy of this License along with the Program.
You may charge any price or no price for each copy that you convey,
and you may offer support or warranty protection for a fee.
5. Conveying Modified Source Versions.
You may convey a work based on the Program, or the modifications to
produce it from the Program, in the form of source code under the
terms of section 4, provided that you also meet all of these conditions:
a) The work must carry prominent notices stating that you modified
it, and giving a relevant date.
b) The work must carry prominent notices stating that it is
released under this License and any conditions added under section
7. This requirement modifies the requirement in section 4 to
"keep intact all notices".
c) You must license the entire work, as a whole, under this
License to anyone who comes into possession of a copy. This
License will therefore apply, along with any applicable section 7
additional terms, to the whole of the work, and all its parts,
regardless of how they are packaged. This License gives no
permission to license the work in any other way, but it does not
invalidate such permission if you have separately received it.
d) If the work has interactive user interfaces, each must display
Appropriate Legal Notices; however, if the Program has interactive
interfaces that do not display Appropriate Legal Notices, your
work need not make them do so.
A compilation of a covered work with other separate and independent
works, which are not by their nature extensions of the covered work,
and which are not combined with it such as to form a larger program,
in or on a volume of a storage or distribution medium, is called an
"aggregate" if the compilation and its resulting copyright are not
used to limit the access or legal rights of the compilation's users
beyond what the individual works permit. Inclusion of a covered work
in an aggregate does not cause this License to apply to the other
parts of the aggregate.
6. Conveying Non-Source Forms.
You may convey a covered work in object code form under the terms
of sections 4 and 5, provided that you also convey the
machine-readable Corresponding Source under the terms of this License,
in one of these ways:
a) Convey the object code in, or embodied in, a physical product
(including a physical distribution medium), accompanied by the
Corresponding Source fixed on a durable physical medium
customarily used for software interchange.
b) Convey the object code in, or embodied in, a physical product
(including a physical distribution medium), accompanied by a
written offer, valid for at least three years and valid for as
long as you offer spare parts or customer support for that product
model, to give anyone who possesses the object code either (1) a
copy of the Corresponding Source for all the software in the
product that is covered by this License, on a durable physical
medium customarily used for software interchange, for a price no
more than your reasonable cost of physically performing this
conveying of source, or (2) access to copy the
Corresponding Source from a network server at no charge.
c) Convey individual copies of the object code with a copy of the
written offer to provide the Corresponding Source. This
alternative is allowed only occasionally and noncommercially, and
only if you received the object code with such an offer, in accord
with subsection 6b.
d) Convey the object code by offering access from a designated
place (gratis or for a charge), and offer equivalent access to the
Corresponding Source in the same way through the same place at no
further charge. You need not require recipients to copy the
Corresponding Source along with the object code. If the place to
copy the object code is a network server, the Corresponding Source
may be on a different server (operated by you or a third party)
that supports equivalent copying facilities, provided you maintain
clear directions next to the object code saying where to find the
Corresponding Source. Regardless of what server hosts the
Corresponding Source, you remain obligated to ensure that it is
available for as long as needed to satisfy these requirements.
e) Convey the object code using peer-to-peer transmission, provided
you inform other peers where the object code and Corresponding
Source of the work are being offered to the general public at no
charge under subsection 6d.
A separable portion of the object code, whose source code is excluded
from the Corresponding Source as a System Library, need not be
included in conveying the object code work.
A "User Product" is either (1) a "consumer product", which means any
tangible personal property which is normally used for personal, family,
or household purposes, or (2) anything designed or sold for incorporation
into a dwelling. In determining whether a product is a consumer product,
doubtful cases shall be resolved in favor of coverage. For a particular
product received by a particular user, "normally used" refers to a
typical or common use of that class of product, regardless of the status
of the particular user or of the way in which the particular user
actually uses, or expects or is expected to use, the product. A product
is a consumer product regardless of whether the product has substantial
commercial, industrial or non-consumer uses, unless such uses represent
the only significant mode of use of the product.
"Installation Information" for a User Product means any methods,
procedures, authorization keys, or other information required to install
and execute modified versions of a covered work in that User Product from
a modified version of its Corresponding Source. The information must
suffice to ensure that the continued functioning of the modified object
code is in no case prevented or interfered with solely because
modification has been made.
If you convey an object code work under this section in, or with, or
specifically for use in, a User Product, and the conveying occurs as
part of a transaction in which the right of possession and use of the
User Product is transferred to the recipient in perpetuity or for a
fixed term (regardless of how the transaction is characterized), the
Corresponding Source conveyed under this section must be accompanied
by the Installation Information. But this requirement does not apply
if neither you nor any third party retains the ability to install
modified object code on the User Product (for example, the work has
been installed in ROM).
The requirement to provide Installation Information does not include a
requirement to continue to provide support service, warranty, or updates
for a work that has been modified or installed by the recipient, or for
the User Product in which it has been modified or installed. Access to a
network may be denied when the modification itself materially and
adversely affects the operation of the network or violates the rules and
protocols for communication across the network.
Corresponding Source conveyed, and Installation Information provided,
in accord with this section must be in a format that is publicly
documented (and with an implementation available to the public in
source code form), and must require no special password or key for
unpacking, reading or copying.
7. Additional Terms.
"Additional permissions" are terms that supplement the terms of this
License by making exceptions from one or more of its conditions.
Additional permissions that are applicable to the entire Program shall
be treated as though they were included in this License, to the extent
that they are valid under applicable law. If additional permissions
apply only to part of the Program, that part may be used separately
under those permissions, but the entire Program remains governed by
this License without regard to the additional permissions.
When you convey a copy of a covered work, you may at your option
remove any additional permissions from that copy, or from any part of
it. (Additional permissions may be written to require their own
removal in certain cases when you modify the work.) You may place
additional permissions on material, added by you to a covered work,
for which you have or can give appropriate copyright permission.
Notwithstanding any other provision of this License, for material you
add to a covered work, you may (if authorized by the copyright holders of
that material) supplement the terms of this License with terms:
a) Disclaiming warranty or limiting liability differently from the
terms of sections 15 and 16 of this License; or
b) Requiring preservation of specified reasonable legal notices or
author attributions in that material or in the Appropriate Legal
Notices displayed by works containing it; or
c) Prohibiting misrepresentation of the origin of that material, or
requiring that modified versions of such material be marked in
reasonable ways as different from the original version; or
d) Limiting the use for publicity purposes of names of licensors or
authors of the material; or
e) Declining to grant rights under trademark law for use of some
trade names, trademarks, or service marks; or
f) Requiring indemnification of licensors and authors of that
material by anyone who conveys the material (or modified versions of
it) with contractual assumptions of liability to the recipient, for
any liability that these contractual assumptions directly impose on
those licensors and authors.
All other non-permissive additional terms are considered "further
restrictions" within the meaning of section 10. If the Program as you
received it, or any part of it, contains a notice stating that it is
governed by this License along with a term that is a further
restriction, you may remove that term. If a license document contains
a further restriction but permits relicensing or conveying under this
License, you may add to a covered work material governed by the terms
of that license document, provided that the further restriction does
not survive such relicensing or conveying.
If you add terms to a covered work in accord with this section, you
must place, in the relevant source files, a statement of the
additional terms that apply to those files, or a notice indicating
where to find the applicable terms.
Additional terms, permissive or non-permissive, may be stated in the
form of a separately written license, or stated as exceptions;
the above requirements apply either way.
8. Termination.
You may not propagate or modify a covered work except as expressly
provided under this License. Any attempt otherwise to propagate or
modify it is void, and will automatically terminate your rights under
this License (including any patent licenses granted under the third
paragraph of section 11).
However, if you cease all violation of this License, then your
license from a particular copyright holder is reinstated (a)
provisionally, unless and until the copyright holder explicitly and
finally terminates your license, and (b) permanently, if the copyright
holder fails to notify you of the violation by some reasonable means
prior to 60 days after the cessation.
Moreover, your license from a particular copyright holder is
reinstated permanently if the copyright holder notifies you of the
violation by some reasonable means, this is the first time you have
received notice of violation of this License (for any work) from that
copyright holder, and you cure the violation prior to 30 days after
your receipt of the notice.
Termination of your rights under this section does not terminate the
licenses of parties who have received copies or rights from you under
this License. If your rights have been terminated and not permanently
reinstated, you do not qualify to receive new licenses for the same
material under section 10.
9. Acceptance Not Required for Having Copies.
You are not required to accept this License in order to receive or
run a copy of the Program. Ancillary propagation of a covered work
occurring solely as a consequence of using peer-to-peer transmission
to receive a copy likewise does not require acceptance. However,
nothing other than this License grants you permission to propagate or
modify any covered work. These actions infringe copyright if you do
not accept this License. Therefore, by modifying or propagating a
covered work, you indicate your acceptance of this License to do so.
10. Automatic Licensing of Downstream Recipients.
Each time you convey a covered work, the recipient automatically
receives a license from the original licensors, to run, modify and
propagate that work, subject to this License. You are not responsible
for enforcing compliance by third parties with this License.
An "entity transaction" is a transaction transferring control of an
organization, or substantially all assets of one, or subdividing an
organization, or merging organizations. If propagation of a covered
work results from an entity transaction, each party to that
transaction who receives a copy of the work also receives whatever
licenses to the work the party's predecessor in interest had or could
give under the previous paragraph, plus a right to possession of the
Corresponding Source of the work from the predecessor in interest, if
the predecessor has it or can get it with reasonable efforts.
You may not impose any further restrictions on the exercise of the
rights granted or affirmed under this License. For example, you may
not impose a license fee, royalty, or other charge for exercise of
rights granted under this License, and you may not initiate litigation
(including a cross-claim or counterclaim in a lawsuit) alleging that
any patent claim is infringed by making, using, selling, offering for
sale, or importing the Program or any portion of it.
11. Patents.
A "contributor" is a copyright holder who authorizes use under this
License of the Program or a work on which the Program is based. The
work thus licensed is called the contributor's "contributor version".
A contributor's "essential patent claims" are all patent claims
owned or controlled by the contributor, whether already acquired or
hereafter acquired, that would be infringed by some manner, permitted
by this License, of making, using, or selling its contributor version,
but do not include claims that would be infringed only as a
consequence of further modification of the contributor version. For
purposes of this definition, "control" includes the right to grant
patent sublicenses in a manner consistent with the requirements of
this License.
Each contributor grants you a non-exclusive, worldwide, royalty-free
patent license under the contributor's essential patent claims, to
make, use, sell, offer for sale, import and otherwise run, modify and
propagate the contents of its contributor version.
In the following three paragraphs, a "patent license" is any express
agreement or commitment, however denominated, not to enforce a patent
(such as an express permission to practice a patent or covenant not to
sue for patent infringement). To "grant" such a patent license to a
party means to make such an agreement or commitment not to enforce a
patent against the party.
If you convey a covered work, knowingly relying on a patent license,
and the Corresponding Source of the work is not available for anyone
to copy, free of charge and under the terms of this License, through a
publicly available network server or other readily accessible means,
then you must either (1) cause the Corresponding Source to be so
available, or (2) arrange to deprive yourself of the benefit of the
patent license for this particular work, or (3) arrange, in a manner
consistent with the requirements of this License, to extend the patent
license to downstream recipients. "Knowingly relying" means you have
actual knowledge that, but for the patent license, your conveying the
covered work in a country, or your recipient's use of the covered work
in a country, would infringe one or more identifiable patents in that
country that you have reason to believe are valid.
If, pursuant to or in connection with a single transaction or
arrangement, you convey, or propagate by procuring conveyance of, a
covered work, and grant a patent license to some of the parties
receiving the covered work authorizing them to use, propagate, modify
or convey a specific copy of the covered work, then the patent license
you grant is automatically extended to all recipients of the covered
work and works based on it.
A patent license is "discriminatory" if it does not include within
the scope of its coverage, prohibits the exercise of, or is
conditioned on the non-exercise of one or more of the rights that are
specifically granted under this License. You may not convey a covered
work if you are a party to an arrangement with a third party that is
in the business of distributing software, under which you make payment
to the third party based on the extent of your activity of conveying
the work, and under which the third party grants, to any of the
parties who would receive the covered work from you, a discriminatory
patent license (a) in connection with copies of the covered work
conveyed by you (or copies made from those copies), or (b) primarily
for and in connection with specific products or compilations that
contain the covered work, unless you entered into that arrangement,
or that patent license was granted, prior to 28 March 2007.
Nothing in this License shall be construed as excluding or limiting
any implied license or other defenses to infringement that may
otherwise be available to you under applicable patent law.
12. No Surrender of Others' Freedom.
If conditions are imposed on you (whether by court order, agreement or
otherwise) that contradict the conditions of this License, they do not
excuse you from the conditions of this License. If you cannot convey a
covered work so as to satisfy simultaneously your obligations under this
License and any other pertinent obligations, then as a consequence you may
not convey it at all. For example, if you agree to terms that obligate you
to collect a royalty for further conveying from those to whom you convey
the Program, the only way you could satisfy both those terms and this
License would be to refrain entirely from conveying the Program.
13. Use with the GNU Affero General Public License.
Notwithstanding any other provision of this License, you have
permission to link or combine any covered work with a work licensed
under version 3 of the GNU Affero General Public License into a single
combined work, and to convey the resulting work. The terms of this
License will continue to apply to the part which is the covered work,
but the special requirements of the GNU Affero General Public License,
section 13, concerning interaction through a network will apply to the
combination as such.
14. Revised Versions of this License.
The Free Software Foundation may publish revised and/or new versions of
the GNU General Public License from time to time. Such new versions will
be similar in spirit to the present version, but may differ in detail to
address new problems or concerns.
Each version is given a distinguishing version number. If the
Program specifies that a certain numbered version of the GNU General
Public License "or any later version" applies to it, you have the
option of following the terms and conditions either of that numbered
version or of any later version published by the Free Software
Foundation. If the Program does not specify a version number of the
GNU General Public License, you may choose any version ever published
by the Free Software Foundation.
If the Program specifies that a proxy can decide which future
versions of the GNU General Public License can be used, that proxy's
public statement of acceptance of a version permanently authorizes you
to choose that version for the Program.
Later license versions may give you additional or different
permissions. However, no additional obligations are imposed on any
author or copyright holder as a result of your choosing to follow a
later version.
15. Disclaimer of Warranty.
THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY
APPLICABLE LAW. EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT
HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY
OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO,
THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM
IS WITH YOU. SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF
ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
16. Limitation of Liability.
IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS
THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY
GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE
USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF
DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD
PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS),
EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF
SUCH DAMAGES.
17. Interpretation of Sections 15 and 16.
If the disclaimer of warranty and limitation of liability provided
above cannot be given local legal effect according to their terms,
reviewing courts shall apply local law that most closely approximates
an absolute waiver of all civil liability in connection with the
Program, unless a warranty or assumption of liability accompanies a
copy of the Program in return for a fee.
END OF TERMS AND CONDITIONS
How to Apply These Terms to Your New Programs
If you develop a new program, and you want it to be of the greatest
possible use to the public, the best way to achieve this is to make it
free software which everyone can redistribute and change under these terms.
To do so, attach the following notices to the program. It is safest
to attach them to the start of each source file to most effectively
state the exclusion of warranty; and each file should have at least
the "copyright" line and a pointer to where the full notice is found.
<one line to give the program's name and a brief idea of what it does.>
Copyright (C) <year> <name of author>
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
Also add information on how to contact you by electronic and paper mail.
If the program does terminal interaction, make it output a short
notice like this when it starts in an interactive mode:
<program> Copyright (C) <year> <name of author>
This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
This is free software, and you are welcome to redistribute it
under certain conditions; type `show c' for details.
The hypothetical commands `show w' and `show c' should show the appropriate
parts of the General Public License. Of course, your program's commands
might be different; for a GUI interface, you would use an "about box".
You should also get your employer (if you work as a programmer) or school,
if any, to sign a "copyright disclaimer" for the program, if necessary.
For more information on this, and how to apply and follow the GNU GPL, see
<http://www.gnu.org/licenses/>.
The GNU General Public License does not permit incorporating your program
into proprietary programs. If your program is a subroutine library, you
may consider it more useful to permit linking proprietary applications with
the library. If this is what you want to do, use the GNU Lesser General
Public License instead of this License. But first, please read
<http://www.gnu.org/philosophy/why-not-lgpl.html>.
================================================
FILE: external/bliss/bliss/COPYING.LESSER
================================================
GNU LESSER GENERAL PUBLIC LICENSE
Version 3, 29 June 2007
Copyright (C) 2007 Free Software Foundation, Inc. <http://fsf.org/>
Everyone is permitted to copy and distribute verbatim copies
of this license document, but changing it is not allowed.
This version of the GNU Lesser General Public License incorporates
the terms and conditions of version 3 of the GNU General Public
License, supplemented by the additional permissions listed below.
0. Additional Definitions.
As used herein, "this License" refers to version 3 of the GNU Lesser
General Public License, and the "GNU GPL" refers to version 3 of the GNU
General Public License.
"The Library" refers to a covered work governed by this License,
other than an Application or a Combined Work as defined below.
An "Application" is any work that makes use of an interface provided
by the Library, but which is not otherwise based on the Library.
Defining a subclass of a class defined by the Library is deemed a mode
of using an interface provided by the Library.
A "Combined Work" is a work produced by combining or linking an
Application with the Library. The particular version of the Library
with which the Combined Work was made is also called the "Linked
Version".
The "Minimal Corresponding Source" for a Combined Work means the
Corresponding Source for the Combined Work, excluding any source code
for portions of the Combined Work that, considered in isolation, are
based on the Application, and not on the Linked Version.
The "Corresponding Application Code" for a Combined Work means the
object code and/or source code for the Application, including any data
and utility programs needed for reproducing the Combined Work from the
Application, but excluding the System Libraries of the Combined Work.
1. Exception to Section 3 of the GNU GPL.
You may convey a covered work under sections 3 and 4 of this License
without being bound by section 3 of the GNU GPL.
2. Conveying Modified Versions.
If you modify a copy of the Library, and, in your modifications, a
facility refers to a function or data to be supplied by an Application
that uses the facility (other than as an argument passed when the
facility is invoked), then you may convey a copy of the modified
version:
a) under this License, provided that you make a good faith effort to
ensure that, in the event an Application does not supply the
function or data, the facility still operates, and performs
whatever part of its purpose remains meaningful, or
b) under the GNU GPL, with none of the additional permissions of
this License applicable to that copy.
3. Object Code Incorporating Material from Library Header Files.
The object code form of an Application may incorporate material from
a header file that is part of the Library. You may convey such object
code under terms of your choice, provided that, if the incorporated
material is not limited to numerical parameters, data structure
layouts and accessors, or small macros, inline functions and templates
(ten or fewer lines in length), you do both of the following:
a) Give prominent notice with each copy of the object code that the
Library is used in it and that the Library and its use are
covered by this License.
b) Accompany the object code with a copy of the GNU GPL and this license
document.
4. Combined Works.
You may convey a Combined Work under terms of your choice that,
taken together, effectively do not restrict modification of the
portions of the Library contained in the Combined Work and reverse
engineering for debugging such modifications, if you also do each of
the following:
a) Give prominent notice with each copy of the Combined Work that
the Library is used in it and that the Library and its use are
covered by this License.
b) Accompany the Combined Work with a copy of the GNU GPL and this license
document.
c) For a Combined Work that displays copyright notices during
execution, include the copyright notice for the Library among
these notices, as well as a reference directing the user to the
copies of the GNU GPL and this license document.
d) Do one of the following:
0) Convey the Minimal Corresponding Source under the terms of this
License, and the Corresponding Application Code in a form
suitable for, and under terms that permit, the user to
recombine or relink the Application with a modified version of
the Linked Version to produce a modified Combined Work, in the
manner specified by section 6 of the GNU GPL for conveying
Corresponding Source.
1) Use a suitable shared library mechanism for linking with the
Library. A suitable mechanism is one that (a) uses at run time
a copy of the Library already present on the user's computer
system, and (b) will operate properly with a modified version
of the Library that is interface-compatible with the Linked
Version.
e) Provide Installation Information, but only if you would otherwise
be required to provide such information under section 6 of the
GNU GPL, and only to the extent that such information is
necessary to install and execute a modified version of the
Combined Work produced by recombining or relinking the
Application with a modified version of the Linked Version. (If
you use option 4d0, the Installation Information must accompany
the Minimal Corresponding Source and Corresponding Application
Code. If you use option 4d1, you must provide the Installation
Information in the manner specified by section 6 of the GNU GPL
for conveying Corresponding Source.)
5. Combined Libraries.
You may place library facilities that are a work based on the
Library side by side in a single library together with other library
facilities that are not Applications and are not covered by this
License, and convey such a combined library under terms of your
choice, if you do both of the following:
a) Accompany the combined library with a copy of the same work based
on the Library, uncombined with any other library facilities,
conveyed under the terms of this License.
b) Give prominent notice with the combined library that part of it
is a work based on the Library, and explaining where to find the
accompanying uncombined form of the same work.
6. Revised Versions of the GNU Lesser General Public License.
The Free Software Foundation may publish revised and/or new versions
of the GNU Lesser General Public License from time to time. Such new
versions will be similar in spirit to the present version, but may
differ in detail to address new problems or concerns.
Each version is given a distinguishing version number. If the
Library as you received it specifies that a certain numbered version
of the GNU Lesser General Public License "or any later version"
applies to it, you have the option of following the terms and
conditions either of that published version or of any later version
published by the Free Software Foundation. If the Library as you
received it does not specify a version number of the GNU Lesser
General Public License, you may choose any version of the GNU Lesser
General Public License ever published by the Free Software Foundation.
If the Library as you received it specifies that a proxy can decide
whether future versions of the GNU Lesser General Public License shall
apply, that proxy's public statement of acceptance of any version is
permanent authorization for you to choose that version for the
Library.
================================================
FILE: external/bliss/bliss/abgraph.hh
================================================
#ifndef BLISS_AB_GRAPH_HH
#define BLISS_AB_GRAPH_HH
#include <set>
#include <list>
#include <cstdio>
#include <vector>
#include <cassert>
#include <climits>
#include <algorithm>
namespace bliss {
class AbstractGraph;
}
#include "kstack.hh"
#include "kqueue.hh"
#include "heap.hh"
#include "orbit.hh"
#include "partition.hh"
#include "bignum.hh"
#include "uintseqhash.hh"
namespace bliss {
void fatal_error(const char* fmt, ...) {
va_list ap;
va_start(ap, fmt);
fprintf(stderr,"Bliss fatal error: ");
vfprintf(stderr, fmt, ap);
fprintf(stderr, "\nAborting!\n");
va_end(ap);
exit(1);
}
#define _INTERNAL_ERROR() fatal_error("%s:%d: internal error",__FILE__,__LINE__)
#define _OUT_OF_MEMORY() fatal_error("%s:%d: out of memory",__FILE__,__LINE__)
typedef std::pair<unsigned,unsigned> Index;
class TreeNode {
//friend class AbstractGraph;
public:
unsigned int split_cell_first;
int split_element;
static const int SPLIT_START = -1;
static const int SPLIT_END = -2;
Partition::BacktrackPoint partition_bt_point;
unsigned int certificate_index;
static const char NO = -1;
static const char MAYBE = 0;
static const char YES = 1;
/* First path stuff */
bool fp_on;
bool fp_cert_equal;
char fp_extendable;
/* Best path stuff */
bool in_best_path;
int cmp_to_best_path;
unsigned int failure_recording_ival;
/* Component recursion related data */
unsigned int cr_cep_stack_size;
unsigned int cr_cep_index;
unsigned int cr_level;
bool needs_long_prune;
unsigned int long_prune_begin;
std::set<unsigned int, std::less<unsigned int> > long_prune_redundant;
UintSeqHash eqref_hash;
unsigned int subcertificate_length;
};
typedef struct {
unsigned int splitting_element;
unsigned int certificate_index;
unsigned int subcertificate_length;
UintSeqHash eqref_hash;
} PathInfo;
// \brief Statistics returned by the bliss search algorithm.
class Stats {
friend class AbstractGraph;
/** \internal The size of the automorphism group. */
BigNum group_size;
/** \internal An approximation (due to possible overflows) of
* the size of the automorphism group. */
long double group_size_approx;
/** \internal The number of nodes in the search tree. */
long unsigned int nof_nodes;
/** \internal The number of leaf nodes in the search tree. */
long unsigned int nof_leaf_nodes;
/** \internal The number of bad nodes in the search tree. */
long unsigned int nof_bad_nodes;
/** \internal The number of canonical representative updates. */
long unsigned int nof_canupdates;
/** \internal The number of generator permutations. */
long unsigned int nof_generators;
/** \internal The maximal depth of the search tree. */
unsigned long int max_level;
/** */
void reset() {
group_size.assign(1);
group_size_approx = 1.0;
nof_nodes = 0;
nof_leaf_nodes = 0;
nof_bad_nodes = 0;
nof_canupdates = 0;
nof_generators = 0;
max_level = 0;
}
public:
Stats() { reset(); }
/** Print the statistics. */
size_t print(FILE* const fp) const {
size_t r = 0;
r += fprintf(fp, "Nodes: %lu\n", nof_nodes);
r += fprintf(fp, "Leaf nodes: %lu\n", nof_leaf_nodes);
r += fprintf(fp, "Bad nodes: %lu\n", nof_bad_nodes);
r += fprintf(fp, "Canrep updates: %lu\n", nof_canupdates);
r += fprintf(fp, "Generators: %lu\n", nof_generators);
r += fprintf(fp, "Max level: %lu\n", max_level);
r += fprintf(fp, "|Aut|: ")+group_size.print(fp)+fprintf(fp, "\n");
fflush(fp);
return r;
}
/** An approximation (due to possible overflows/rounding errors) of
* the size of the automorphism group. */
long double get_group_size_approx() const {return group_size_approx;}
/** The number of nodes in the search tree. */
long unsigned int get_nof_nodes() const {return nof_nodes;}
/** The number of leaf nodes in the search tree. */
long unsigned int get_nof_leaf_nodes() const {return nof_leaf_nodes;}
/** The number of bad nodes in the search tree. */
long unsigned int get_nof_bad_nodes() const {return nof_bad_nodes;}
/** The number of canonical representative updates. */
long unsigned int get_nof_canupdates() const {return nof_canupdates;}
/** The number of generator permutations. */
long unsigned int get_nof_generators() const {return nof_generators;}
/** The maximal depth of the search tree. */
unsigned long int get_max_level() const {return max_level;}
};
// \brief An abstract base class for different types of graphs.
class AbstractGraph {
friend class Partition;
public:
//AbstractGraph();
// Constructor and destructor routines for the abstract graph class
AbstractGraph() {
// Initialize stuff
first_path_labeling = 0;
first_path_labeling_inv = 0;
best_path_labeling = 0;
best_path_labeling_inv = 0;
first_path_automorphism = 0;
best_path_automorphism = 0;
in_search = false;
// Default value for using "long prune"
opt_use_long_prune = true;
// Default value for using failure recording
opt_use_failure_recording = true;
// Default value for using component recursion
opt_use_comprec = true;
verbose_level = 0;
verbstr = stdout;
report_hook = 0;
report_user_param = 0;
}
//virtual ~AbstractGraph();
virtual ~AbstractGraph() {
if(first_path_labeling) {
free(first_path_labeling); first_path_labeling = 0; }
if(first_path_labeling_inv) {
free(first_path_labeling_inv); first_path_labeling_inv = 0; }
if(best_path_labeling) {
free(best_path_labeling); best_path_labeling = 0; }
if(best_path_labeling_inv) {
free(best_path_labeling_inv); best_path_labeling_inv = 0; }
if(first_path_automorphism) {
free(first_path_automorphism); first_path_automorphism = 0; }
if(best_path_automorphism) {
free(best_path_automorphism); best_path_automorphism = 0; }
report_hook = 0;
report_user_param = 0;
}
//Set the verbose output level for the algorithms.
// \param level the level of verbose output, 0 means no verbose output
//void set_verbose_level(const unsigned int level);
void set_verbose_level(const unsigned int level) {
verbose_level = level;
}
/**
* Set the file stream for the verbose output.
* \param fp the file stream; if null, no verbose output is written
*/
//void set_verbose_file(FILE * const fp);
void set_verbose_file(FILE* const fp) {
verbstr = fp;
}
/**
* Add a new vertex with color \a color in the graph and return its index.
*/
virtual unsigned int add_vertex(const unsigned int color = 0) = 0;
/**
* Add an edge between vertices \a source and \a target.
* Duplicate edges between vertices are ignored but try to avoid introducing
* them in the first place as they are not ignored immediately but will
* consume memory and computation resources for a while.
*/
virtual void add_edge(const unsigned int source, const unsigned int target, Index index) = 0;
/**
* Change the color of the vertex \a vertex to \a color.
*/
virtual void change_color(const unsigned int vertex, const unsigned int color) = 0;
/**
* Check whether \a perm is an automorphism of this graph.
* Unoptimized, mainly for debugging purposes.
*/
//virtual bool is_automorphism(const std::vector<unsigned int>& perm) const;
virtual bool is_automorphism(const std::vector<unsigned int>& perm) const {
_INTERNAL_ERROR();
return false;
}
/** Activate/deactivate failure recording.
* May not be called during the search, i.e. from an automorphism reporting
* hook function.
* \param active if true, activate failure recording, deactivate otherwise
*/
void set_failure_recording(const bool active) {assert(!in_search); opt_use_failure_recording = active;}
/** Activate/deactivate component recursion.
* The choice affects the computed canonical labelings;
* therefore, if you want to compare whether two graphs are isomorphic by
* computing and comparing (for equality) their canonical versions,
* be sure to use the same choice for both graphs.
* May not be called during the search, i.e. from an automorphism reporting
* hook function.
* \param active if true, activate component recursion, deactivate otherwise
*/
void set_component_recursion(const bool active) {assert(!in_search); opt_use_comprec = active;}
/**
* Return the number of vertices in the graph.
*/
virtual unsigned int get_nof_vertices() const = 0;
/**
* Return a new graph that is the result of applying the permutation \a perm
* to this graph. This graph is not modified.
* \a perm must contain N=this.get_nof_vertices() elements and be a bijection
* on {0,1,...,N-1}, otherwise the result is undefined or a segfault.
*/
virtual AbstractGraph* permute(const unsigned* const perm) const = 0;
virtual AbstractGraph* permute(const std::vector<unsigned int>& perm) const = 0;
/**
* Find a set of generators for the automorphism group of the graph.
* The function \a hook (if non-null) is called each time a new generator
* for the automorphism group is found.
* The first argument \a user_param for the hook is the
* \a hook_user_param given below,
* the second argument \a n is the length of the automorphism (equal to
* get_nof_vertices()) and
* the third argument \a aut is the automorphism
* (a bijection on {0,...,get_nof_vertices()-1}).
* The memory for the automorphism \a aut will be invalidated immediately
* after the return from the hook function;
* if you want to use the automorphism later, you have to take a copy of it.
* Do not call any member functions in the hook.
* The search statistics are copied in \a stats.
*/
//void find_automorphisms(Stats& stats, void (*hook)(void* user_param, unsigned int n, const unsigned int* aut), void* hook_user_param);
void find_automorphisms(Stats& stats, void (*hook)(void *user_param, unsigned int n, const unsigned int *aut), void *user_param) {
report_hook = hook;
report_user_param = user_param;
search(false, stats);
if(first_path_labeling) {
free(first_path_labeling);
first_path_labeling = 0;
}
if(best_path_labeling) {
free(best_path_labeling);
best_path_labeling = 0;
}
}
/**
* Otherwise the same as find_automorphisms() except that
* a canonical labeling of the graph (a bijection on
* {0,...,get_nof_vertices()-1}) is returned.
* The memory allocated for the returned canonical labeling will remain
* valid only until the next call to a member function with the exception
* that constant member functions (for example, bliss::Graph::permute()) can
* be called without invalidating the labeling.
* To compute the canonical version of an undirected graph, call this
* function and then bliss::Graph::permute() with the returned canonical
* labeling.
* Note that the computed canonical version may depend on the applied version
* of bliss as well as on some other options (for instance, the splitting
* heuristic selected with bliss::Graph::set_splitting_heuristic()).
*/
//const unsigned int* canonical_form(Stats& stats, void (*hook)(void* user_param, unsigned int n, const unsigned int* aut), void* hook_user_param);
const unsigned * canonical_form(Stats& stats, void (*hook)(void *user_param, unsigned int n, const unsigned int *aut), void *user_param) {
report_hook = hook;
report_user_param = user_param;
search(true, stats);
return best_path_labeling;
}
/**
* Write the graph to a file in a variant of the DIMACS format.
* See the <A href="http://www.tcs.hut.fi/Software/bliss/">bliss website</A>
* for the definition of the file format.
* Note that in the DIMACS file the vertices are numbered from 1 to N while
* in this C++ API they are from 0 to N-1.
* Thus the vertex n in the file corresponds to the vertex n-1 in the API.
* \param fp the file stream where the graph is written
*/
virtual void write_dimacs(FILE * const fp) = 0;
/**
* Write the graph to a file in the graphviz dotty format.
* \param fp the file stream where the graph is written
*/
virtual void write_dot(FILE * const fp) = 0;
/**
* Write the graph in a file in the graphviz dotty format.
* Do nothing if the file cannot be written.
* \param file_name the name of the file to which the graph is written
*/
virtual void write_dot(const char * const file_name) = 0;
/**
* Get a hash value for the graph.
* \return the hash value
*/
virtual unsigned int get_hash() = 0;
/**
* Disable/enable the "long prune" method.
* The choice affects the computed canonical labelings;
* therefore, if you want to compare whether two graphs are isomorphic by
* computing and comparing (for equality) their canonical versions,
* be sure to use the same choice for both graphs.
* May not be called during the search, i.e. from an automorphism reporting
* hook function.
* \param active if true, activate "long prune", deactivate otherwise
*/
void set_long_prune_activity(const bool active) {
assert(!in_search);
opt_use_long_prune = active;
}
protected:
/** \internal
* How much verbose output is produced (0 means none) */
unsigned int verbose_level;
/** \internal
* The output stream for verbose output. */
FILE *verbstr;
protected:
/** \internal
* The ordered partition used in the search algorithm. */
Partition p;
/** \internal
* Whether the search for automorphisms and a canonical labeling is
* in progress.
*/
bool in_search;
/** \internal
* Is failure recording in use?
*/
bool opt_use_failure_recording;
/* The "tree-specific" invariant value for the point when current path
* got different from the first path */
unsigned int failure_recording_fp_deviation;
/** \internal
* Is component recursion in use?
*/
bool opt_use_comprec;
unsigned int refine_current_path_certificate_index;
bool refine_compare_certificate;
bool refine_equal_to_first;
unsigned int refine_first_path_subcertificate_end;
int refine_cmp_to_best;
unsigned int refine_best_path_subcertificate_end;
static const unsigned int CERT_SPLIT = 0; //UINT_MAX;
static const unsigned int CERT_EDGE = 1; //UINT_MAX-1;
/** \internal
* Add a triple (v1,v2,v3) in the certificate.
* May modify refine_equal_to_first and refine_cmp_to_best.
* May also update eqref_hash and failure_recording_fp_deviation. */
//void cert_add(const unsigned int v1, const unsigned int v2, const unsigned int v3);
// Certificate building
void cert_add(const unsigned int v1, const unsigned int v2, const unsigned int v3) {
if(refine_compare_certificate) {
if(refine_equal_to_first) {
/* So far equivalent to the first path... */
unsigned int index = certificate_current_path.size();
if(index >= refine_first_path_subcertificate_end) {
refine_equal_to_first = false;
} else if(certificate_first_path[index] != v1) {
refine_equal_to_first = false;
} else if(certificate_first_path[++index] != v2) {
refine_equal_to_first = false;
} else if(certificate_first_path[++index] != v3) {
refine_equal_to_first = false;
} if(opt_use_failure_recording and !refine_equal_to_first) {
/* We just became different from the first path,
* remember the deviation point tree-specific invariant
* for the use of failure recording */
UintSeqHash h;
h.update(v1);
h.update(v2);
h.update(v3);
h.update(index);
h.update(eqref_hash.get_value());
failure_recording_fp_deviation = h.get_value();
}
}
if(refine_cmp_to_best == 0) {
/* So far equivalent to the current best path... */
unsigned int index = certificate_current_path.size();
if(index >= refine_best_path_subcertificate_end) {
refine_cmp_to_best = 1;
} else if(v1 > certificate_best_path[index]) {
refine_cmp_to_best = 1;
} else if(v1 < certificate_best_path[index]) {
refine_cmp_to_best = -1;
} else if(v2 > certificate_best_path[++index]) {
refine_cmp_to_best = 1;
} else if(v2 < certificate_best_path[index]) {
refine_cmp_to_best = -1;
} else if(v3 > certificate_best_path[++index]) {
refine_cmp_to_best = 1;
} else if(v3 < certificate_best_path[index]) {
refine_cmp_to_best = -1;
}
}
if((refine_equal_to_first == false) and (refine_cmp_to_best < 0))
return;
}
/* Update the current path certificate */
certificate_current_path.push_back(v1);
certificate_current_path.push_back(v2);
certificate_current_path.push_back(v3);
}
/** \internal
* Add a redundant triple (v1,v2,v3) in the certificate.
* Can also just dicard the triple.
* May modify refine_equal_to_first and refine_cmp_to_best.
* May also update eqref_hash and failure_recording_fp_deviation. */
//void cert_add_redundant(const unsigned int x, const unsigned int y, const unsigned int z);
void cert_add_redundant(const unsigned int v1, const unsigned int v2, const unsigned int v3) {
return cert_add(v1, v2, v3);
}
/**\internal
* Is the long prune method in use?
*/
bool opt_use_long_prune;
/**\internal
* Maximum amount of memory (in megabytes) available for
* the long prune method
*/
static const unsigned int long_prune_options_max_mem = 50;
/**\internal
* Maximum amount of automorphisms stored for the long prune method;
* less than this is stored if the memory limit above is reached first
*/
static const unsigned int long_prune_options_max_stored_auts = 100;
unsigned int long_prune_max_stored_autss;
std::vector<std::vector<bool> *> long_prune_fixed;
std::vector<std::vector<bool> *> long_prune_mcrs;
std::vector<bool> long_prune_temp;
unsigned int long_prune_begin;
unsigned int long_prune_end;
/** \internal
* Initialize the "long prune" data structures.
*/
//void long_prune_init();
/** \internal
* Release the memory allocated for "long prune" data structures.
*/
//void long_prune_deallocate();
//void long_prune_add_automorphism(const unsigned int *aut);
//std::vector<bool>& long_prune_get_fixed(const unsigned int index);
//std::vector<bool>& long_prune_allocget_fixed(const unsigned int index);
//std::vector<bool>& long_prune_get_mcrs(const unsigned int index);
//std::vector<bool>& long_prune_allocget_mcrs(const unsigned int index);
/** \internal
* Swap the i:th and j:th stored automorphism information;
* i and j must be "in window, i.e. in [long_prune_begin,long_prune_end[
*/
//void long_prune_swap(const unsigned int i, const unsigned int j);
//Long prune code
void long_prune_init() {
const unsigned int N = get_nof_vertices();
long_prune_temp.clear();
long_prune_temp.resize(N);
/* Of how many automorphisms we can store information in
the predefined, fixed amount of memory? */
const unsigned int nof_fitting_in_max_mem =
(long_prune_options_max_mem * 1024 * 1024) / (((N * 2) / 8)+1);
long_prune_max_stored_autss = long_prune_options_max_stored_auts;
/* Had some problems with g++ in using (a<b)?a:b when constants involved,
so had to make this in a stupid way... */
if(nof_fitting_in_max_mem < long_prune_options_max_stored_auts)
long_prune_max_stored_autss = nof_fitting_in_max_mem;
long_prune_deallocate();
long_prune_fixed.resize(N, 0);
long_prune_mcrs.resize(N, 0);
long_prune_begin = 0;
long_prune_end = 0;
}
void long_prune_deallocate() {
while(!long_prune_fixed.empty()) {
delete long_prune_fixed.back();
long_prune_fixed.pop_back();
}
while(!long_prune_mcrs.empty()) {
delete long_prune_mcrs.back();
long_prune_mcrs.pop_back();
}
}
void long_prune_swap(const unsigned int i, const unsigned int j) {
const unsigned int real_i = i % long_prune_max_stored_autss;
const unsigned int real_j = j % long_prune_max_stored_autss;
std::vector<bool>* tmp = long_prune_fixed[real_i];
long_prune_fixed[real_i] = long_prune_fixed[real_j];
long_prune_fixed[real_j] = tmp;
tmp = long_prune_mcrs[real_i];
long_prune_mcrs[real_i] = long_prune_mcrs[real_j];
long_prune_mcrs[real_j] = tmp;
}
std::vector<bool>& long_prune_allocget_fixed(const unsigned int index) {
const unsigned int i = index % long_prune_max_stored_autss;
if(!long_prune_fixed[i])
long_prune_fixed[i] = new std::vector<bool>(get_nof_vertices());
return *long_prune_fixed[i];
}
std::vector<bool>& long_prune_get_fixed(const unsigned int index) {
return *long_prune_fixed[index % long_prune_max_stored_autss];
}
std::vector<bool>& long_prune_allocget_mcrs(const unsigned int index) {
const unsigned int i = index % long_prune_max_stored_autss;
if(!long_prune_mcrs[i])
long_prune_mcrs[i] = new std::vector<bool>(get_nof_vertices());
return *long_prune_mcrs[i];
}
std::vector<bool>& long_prune_get_mcrs(const unsigned int index) {
return *long_prune_mcrs[index % long_prune_max_stored_autss];
}
void long_prune_add_automorphism(const unsigned int* aut) {
if(long_prune_max_stored_autss == 0) return;
const unsigned int N = get_nof_vertices();
/* If the buffer of stored auts is full, remove the oldest aut */
if(long_prune_end - long_prune_begin == long_prune_max_stored_autss) {
long_prune_begin++;
}
long_prune_end++;
std::vector<bool>& fixed = long_prune_allocget_fixed(long_prune_end-1);
std::vector<bool>& mcrs = long_prune_allocget_mcrs(long_prune_end-1);
/* Mark nodes that are (i) fixed or (ii) minimal orbit representatives
* under the automorphism 'aut' */
for(unsigned int i = 0; i < N; i++) {
fixed[i] = (aut[i] == i);
if(long_prune_temp[i] == false) {
mcrs[i] = true;
unsigned int j = aut[i];
while(j != i) {
long_prune_temp[j] = true;
j = aut[j];
}
} else {
mcrs[i] = false;
}
/* Clear the temp array on-the-fly... */
long_prune_temp[i] = false;
}
}
/*
* Data structures and routines for refining the partition p into equitable
*/
Heap neighbour_heap;
virtual bool split_neighbourhood_of_unit_cell(Partition::Cell *) = 0;
virtual bool split_neighbourhood_of_cell(Partition::Cell * const) = 0;
//void refine_to_equitable();
//void refine_to_equitable(Partition::Cell * const unit_cell);
//void refine_to_equitable(Partition::Cell * const unit_cell1, Partition::Cell * const unit_cell2);
void refine_to_equitable() {
/* Start refinement from all cells -> push 'em all in the splitting queue */
for(Partition::Cell* cell = p.first_cell; cell; cell = cell->next)
p.splitting_queue_add(cell);
do_refine_to_equitable();
}
void refine_to_equitable(Partition::Cell* const unit_cell) {
p.splitting_queue_add(unit_cell);
do_refine_to_equitable();
}
void refine_to_equitable(Partition::Cell* const unit_cell1, Partition::Cell* const unit_cell2) {
p.splitting_queue_add(unit_cell1);
p.splitting_queue_add(unit_cell2);
do_refine_to_equitable();
}
/** \internal
* \return false if it was detected that the current certificate
* is different from the first and/or best (whether this is checked
* depends on in_search and refine_compare_certificate flags.
*/
//bool do_refine_to_equitable();
bool do_refine_to_equitable() {
eqref_hash.reset();
while(!p.splitting_queue_is_empty()) {
Partition::Cell* const cell = p.splitting_queue_pop();
if(cell->is_unit()) {
if(in_search) {
const unsigned int index = cell->first;
if(first_path_automorphism) {
/* Build the (potential) automorphism on-the-fly */
first_path_automorphism[first_path_labeling_inv[index]] =
p.elements[index];
}
if(best_path_automorphism) {
/* Build the (potential) automorphism on-the-fly */
best_path_automorphism[best_path_labeling_inv[index]] =
p.elements[index];
}
}
const bool worse = split_neighbourhood_of_unit_cell(cell);
if(in_search and worse) goto worse_exit;
}
else {
const bool worse = split_neighbourhood_of_cell(cell);
if(in_search and worse) goto worse_exit;
}
}
return true;
worse_exit:
/* Clear splitting_queue */
p.splitting_queue_clear();
return false;
}
unsigned int eqref_max_certificate_index;
/** \internal
* Whether eqref_hash is updated during equitable refinement process.
*/
bool compute_eqref_hash;
UintSeqHash eqref_hash;
/** \internal
* Check whether the current partition p is equitable.
* Performance: very slow, use only for debugging purposes.
*/
virtual bool is_equitable() const = 0;
unsigned int *first_path_labeling;
unsigned int *first_path_labeling_inv;
Orbit first_path_orbits;
unsigned int *first_path_automorphism;
unsigned int *best_path_labeling;
unsigned int *best_path_labeling_inv;
Orbit best_path_orbits;
unsigned int *best_path_automorphism;
//void update_labeling(unsigned int * const lab);
/** \internal
* Assign the labeling induced by the current partition 'this.p' to
* \a labeling.
* That is, if the partition is [[2,0],[1]],
* then \a labeling will map 0 to 1, 1 to 2, and 2 to 0.
*/
void update_labeling(unsigned int* const labeling) {
const unsigned int N = get_nof_vertices();
unsigned int* ep = p.elements;
for(unsigned int i = 0; i < N; i++, ep++)
labeling[*ep] = i;
}
//void update_labeling_and_its_inverse(unsigned int * const lab, unsigned int * const lab_inv);
/** \internal
* The same as update_labeling() except that the inverse of the labeling
* is also produced and assigned to \a labeling_inv.
*/
void update_labeling_and_its_inverse(unsigned int* const labeling, unsigned int* const labeling_inv) {
const unsigned int N = get_nof_vertices();
unsigned int* ep = p.elements;
unsigned int* clip = labeling_inv;
for(unsigned int i = 0; i < N; ) {
labeling[*ep] = i;
i++;
*clip = *ep;
ep++;
clip++;
}
}
void update_orbit_information(Orbit &o, const unsigned int *perm) {
const unsigned int N = get_nof_vertices();
for(unsigned int i = 0; i < N; i++)
if(perm[i] != i) o.merge_orbits(i, perm[i]);
}
//void reset_permutation(unsigned int *perm);
/* Mainly for debugging purposes */
//virtual bool is_automorphism(unsigned int* const perm);
// \internal
// Reset the permutation \a perm to the identity permutation.
void reset_permutation(unsigned int* perm) {
const unsigned int N = get_nof_vertices();
for(unsigned int i = 0; i < N; i++, perm++)
*perm = i;
}
virtual bool is_automorphism(unsigned int* const perm) {
_INTERNAL_ERROR();
return false;
}
std::vector<unsigned int> certificate_current_path;
std::vector<unsigned int> certificate_first_path;
std::vector<unsigned int> certificate_best_path;
unsigned int certificate_index;
virtual void initialize_certificate() = 0;
virtual void remove_duplicate_edges() = 0;
virtual void make_initial_equitable_partition() = 0;
virtual Partition::Cell* find_next_cell_to_be_splitted(Partition::Cell *cell) = 0;
//void search(const bool canonical, Stats &stats);
#include "search.h"
void (*report_hook)(void *user_param, unsigned int n, const unsigned int *aut);
void *report_user_param;
/*
*
* Nonuniform component recursion (NUCR)
*
*/
/** The currently traversed component */
unsigned int cr_level;
/** \internal
* The "Component End Point" data structure
*/
class CR_CEP {
public:
/** At which level in the search was this CEP created */
unsigned int creation_level;
/** The current component has been fully traversed when the partition has
* this many discrete cells left */
unsigned int discrete_cell_limit;
/** The component to be traversed after the current one */
unsigned int next_cr_level;
/** The next component end point */
unsigned int next_cep_index;
bool first_checked;
bool best_checked;
};
/** \internal
* A stack for storing Component End Points
*/
std::vector<CR_CEP> cr_cep_stack;
/** \internal
* Find the first non-uniformity component at the component recursion
* level \a level.
* The component is stored in \a cr_component.
* If no component is found, \a cr_component is empty.
* Returns false if all the cells in the component recursion level \a level
* were discrete.
* Modifies the max_ival and max_ival_count fields of Partition:Cell
* (assumes that they are 0 when called and
* quarantees that they are 0 when returned).
*/
virtual bool nucr_find_first_component(const unsigned int level) = 0;
virtual bool nucr_find_first_component(const unsigned int level,
std::vector<unsigned int>& component,
unsigned int& component_elements,
Partition::Cell*& sh_return) = 0;
/** \internal
* The non-uniformity component found by nucr_find_first_component()
* is stored here.
*/
std::vector<unsigned int> cr_component;
/** \internal
* The number of vertices in the component \a cr_component
*/
unsigned int cr_component_elements;
};
// Assumes that the elements in the cell are sorted according to their invariant values.
Partition::Cell* Partition::split_cell(Partition::Cell* const original_cell) {
Partition::Cell* cell = original_cell;
const bool original_cell_was_in_splitting_queue =
original_cell->in_splitting_queue;
Partition::Cell* largest_new_cell = 0;
while(true) {
unsigned int* ep = elements + cell->first;
const unsigned int* const lp = ep + cell->length;
const unsigned int ival = invariant_values[*ep];
invariant_values[*ep] = 0;
element_to_cell_map[*ep] = cell;
in_pos[*ep] = ep;
ep++;
while(ep < lp) {
const unsigned int e = *ep;
if(invariant_values[e] != ival)
break;
invariant_values[e] = 0;
in_pos[e] = ep;
ep++;
element_to_cell_map[e] = cell;
}
if(ep == lp) break;
Partition::Cell* const new_cell = aux_split_in_two(cell, (ep - elements) - cell->first);
if(graph and graph->compute_eqref_hash) {
graph->eqref_hash.update(new_cell->first);
graph->eqref_hash.update(new_cell->length);
graph->eqref_hash.update(ival);
}
/* Add cells in splitting_queue */
assert(!new_cell->is_in_splitting_queue());
if(original_cell_was_in_splitting_queue)
{
/* In this case, all new cells are inserted in splitting_queue */
assert(cell->is_in_splitting_queue());
splitting_queue_add(new_cell);
}
else
{
/* Otherwise, we can omit one new cell from splitting_queue */
assert(!cell->is_in_splitting_queue());
if(largest_new_cell == 0) {
largest_new_cell = cell;
} else {
assert(!largest_new_cell->is_in_splitting_queue());
if(cell->length > largest_new_cell->length) {
splitting_queue_add(largest_new_cell);
largest_new_cell = cell;
} else {
splitting_queue_add(cell);
}
}
}
/* Process the rest of the cell */
cell = new_cell;
}
if(original_cell == cell) {
/* All the elements in cell had the same invariant value */
return cell;
}
/* Add cells in splitting_queue */
if(!original_cell_was_in_splitting_queue) {
/* Also consider the last new cell */
assert(largest_new_cell);
if(cell->length > largest_new_cell->length) {
splitting_queue_add(largest_new_cell);
largest_new_cell = cell;
} else {
splitting_queue_add(cell);
}
if(largest_new_cell->is_unit()) {
/* Needed in certificate computation */
splitting_queue_add(largest_new_cell);
}
}
return cell;
}
}
#endif
================================================
FILE: external/bliss/bliss/bignum.hh
================================================
#ifndef BLISS_BIGNUM_HH
#define BLISS_BIGNUM_HH
/*
Copyright (c) 2003-2015 Tommi Junttila
Released under the GNU Lesser General Public License version 3.
This file is part of bliss.
bliss is free software: you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation, version 3 of the License.
bliss is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public License
along with bliss. If not, see <http://www.gnu.org/licenses/>.
*/
#if defined(BLISS_USE_GMP)
#include <gmp.h>
#endif
#include <cstdlib>
#include <cstdio>
#include "defs.hh"
namespace bliss {
/**
* \brief A very simple class for big integers (or approximation of them).
*
* If the compile time flag BLISS_USE_GMP is set,
* then the GNU Multiple Precision Arithmetic library (GMP) is used to
* obtain arbitrary precision, otherwise "long double" is used to
* approximate big integers.
*/
#if defined(BLISS_USE_GMP)
class BigNum
{
mpz_t v;
public:
/**
* Create a new big number and set it to zero.
*/
BigNum() {mpz_init(v); }
/**
* Destroy the number.
*/
~BigNum() {mpz_clear(v); }
/**
* Set the number to \a n.
*/
void assign(const int n) {mpz_set_si(v, n); }
/**
* Multiply the number with \a n.
*/
void multiply(const int n) {mpz_mul_si(v, v, n); }
/**
* Print the number in the file stream \a fp.
*/
size_t print(FILE* const fp) const {return mpz_out_str(fp, 10, v); }
};
#else
class BigNum
{
long double v;
public:
/**
* Create a new big number and set it to zero.
*/
BigNum(): v(0.0) {}
/**
* Set the number to \a n.
*/
void assign(const int n) {v = (long double)n; }
/**
* Multiply the number with \a n.
*/
void multiply(const int n) {v *= (long double)n; }
/**
* Print the number in the file stream \a fp.
*/
size_t print(FILE* const fp) const {return fprintf(fp, "%Lg", v); }
};
#endif
} //namespace bliss
#endif
================================================
FILE: external/bliss/bliss/defs.hh
================================================
#ifndef BLISS_DEFS_HH
#define BLISS_DEFS_HH
#include <cassert>
#include <cstdarg>
/*
Copyright (c) 2003-2015 Tommi Junttila
Released under the GNU Lesser General Public License version 3.
This file is part of bliss.
bliss is free software: you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation, version 3 of the License.
bliss is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public License
along with bliss. If not, see <http://www.gnu.org/licenses/>.
*/
namespace bliss {
/**
* The version number of bliss.
*/
static const char * const version = "0.73";
/*
* If a fatal error (out of memory, internal error) is encountered,
* this function is called.
* There should not be a return from this function but exit or
* a jump to code that deallocates the AbstractGraph instance that called this.
*/
void fatal_error(const char* fmt, ...);
#if defined(BLISS_DEBUG)
#define BLISS_CONSISTENCY_CHECKS
#define BLISS_EXPENSIVE_CONSISTENCY_CHECKS
#endif
#if defined(BLISS_CONSISTENCY_CHECKS)
/* Force a check that the found automorphisms are valid */
#define BLISS_VERIFY_AUTOMORPHISMS
#endif
#if defined(BLISS_CONSISTENCY_CHECKS)
/* Force a check that the generated partitions are equitable */
#define BLISS_VERIFY_EQUITABLEDNESS
#endif
} // namespace bliss
/*! \mainpage Bliss
*
* \section intro_sec Introduction
*
* This is the source code documentation of bliss,
* produced by running <A href="http://www.doxygen.org">doxygen</A> in
* the source directory.
* The algorithms and data structures used in bliss are documented in
* the papers found at the
* <A href="http://www.tcs.hut.fi/Software/bliss">bliss web site</A>.
*
*
* \section compile_sec Compiling
*
* Compiling bliss in Linux should be easy, just execute
* \code
* make
* \endcode
* in the bliss source directory.
* This will produce the executable program \c bliss as well as
* the library file \c libbliss.a that can be linked in other programs.
* If you have the <A href="http://gmplib.org/">GNU Multiple Precision
* Arithmetic Library</A> (GMP) installed in your machine, you can also use
* \code
* make gmp
* \endcode
* to enable exact computation of automorphism group sizes.
*
* When linking the bliss library \c libbliss.a in other programs,
* remember to include the standard c++ library
* (and the GMP library if you compiled bliss to include it).
* For instance,
* \code gcc -o test test.c -lstdc++ -lgmp -lbliss\endcode
*
* \section cppapi_sec The C++ language API
*
* The C++ language API is the main API to bliss;
* all other APIs are just more or less complete variants of it.
* The C++ API consists basically of the public methods in
* the classes bliss::AbstractGraph, bliss::Graph, and bliss::Digraph.
* For an example of its use,
* see the \ref executable "source of the bliss executable".
*
*
* \section capi_sec The C language API
*
* The C language API is given in the file bliss_C.h.
* It is currently more restricted than the C++ API so
* consider using the C++ API whenever possible.
*/
#endif
================================================
FILE: external/bliss/bliss/graph.hh
================================================
#ifndef BLISS_GRAPH_HH
#define BLISS_GRAPH_HH
#include "abgraph.hh"
namespace bliss {
#ifdef USE_DOMAIN
typedef std::pair<unsigned, Index> IndexEdge;
#else
typedef unsigned IndexEdge;
#endif
#if defined(BLISS_CONSISTENCY_CHECKS)
static bool is_permutation(const unsigned int N, const unsigned int* perm) {
if(N == 0) return true;
std::vector<bool> m(N, false);
for(unsigned int i = 0; i < N; i++) {
if(perm[i] >= N) return false;
if(m[perm[i]]) return false;
m[perm[i]] = true;
}
return true;
}
#endif
static bool is_permutation(const std::vector<unsigned int>& perm) {
const unsigned int N = perm.size();
if(N == 0)
return true;
std::vector<bool> m(N, false);
for(unsigned int i = 0; i < N; i++) {
if(perm[i] >= N) return false;
if(m[perm[i]]) return false;
m[perm[i]] = true;
}
return true;
}
// \brief The class for undirected, vertex colored graphs.
// Multiple edges between vertices are not allowed (i.e., are ignored).
class Graph : public AbstractGraph {
public:
/**
* The possible splitting heuristics.
* The selected splitting heuristics affects the computed canonical
* labelings; therefore, if you want to compare whether two graphs
* are isomorphic by computing and comparing (for equality) their
* canonical versions, be sure to use the same splitting heuristics
* for both graphs.
*/
typedef enum {
/** First non-unit cell.
* Very fast but may result in large search spaces on difficult graphs.
* Use for large but easy graphs. */
shs_f = 0,
/** First smallest non-unit cell.
* Fast, should usually produce smaller search spaces than shs_f. */
shs_fs,
/** First largest non-unit cell.
* Fast, should usually produce smaller search spaces than shs_f. */
shs_fl,
/** First maximally non-trivially connected non-unit cell.
* Not so fast, should usually produce smaller search spaces than shs_f,
* shs_fs, and shs_fl. */
shs_fm,
/** First smallest maximally non-trivially connected non-unit cell.
* Not so fast, should usually produce smaller search spaces than shs_f,
* shs_fs, and shs_fl. */
shs_fsm,
/** First largest maximally non-trivially connected non-unit cell.
* Not so fast, should usually produce smaller search spaces than shs_f,
* shs_fs, and shs_fl. */
shs_flm
} SplittingHeuristic;
//moved from protected scope by Zhiqiang
class Vertex {
public:
Vertex() { color = 0;}
~Vertex(){ ; }
#ifdef USE_DOMAIN
void add_edge(const unsigned other_vertex, Index index) {
edges.push_back(std::make_pair(other_vertex, index));
#else
void add_edge(const unsigned other_vertex) {
edges.push_back(other_vertex);
#endif
}
void remove_duplicate_edges(std::vector<bool>& tmp) {
#if defined(BLISS_CONSISTENCY_CHECKS)
/* Pre-conditions */
for(unsigned int i = 0; i < tmp.size(); i++) assert(tmp[i] == false);
#endif
for(std::vector<IndexEdge>::iterator iter = edges.begin(); iter != edges.end(); ) {
#ifdef USE_DOMAIN
const unsigned int dest_vertex = iter->first; //cxh
#else
const unsigned int dest_vertex = *iter;
#endif
if(tmp[dest_vertex] == true) {
/* A duplicate edge found! */
iter = edges.erase(iter);
} else {
/* Not seen earlier, mark as seen */
tmp[dest_vertex] = true;
iter++;
}
}
/* Clear tmp */
for(std::vector<IndexEdge>::iterator iter = edges.begin(); iter != edges.end(); iter++) {
#ifdef USE_DOMAIN
tmp[iter->first] = false;// cxh
#else
tmp[*iter] = false;
#endif
}
#if defined(BLISS_CONSISTENCY_CHECKS)
/* Post-conditions */
for(unsigned int i = 0; i < tmp.size(); i++) assert(tmp[i] == false);
#endif
}
void sort_edges() { std::sort(edges.begin(), edges.end()); }
unsigned color;
//std::vector<unsigned> edges;
std::vector<IndexEdge> edges; // cxh: add the edge ids from the embedding
unsigned nof_edges() const {return edges.size(); }
};
//added by Zhiqiang
std::vector<Vertex> & get_vertices_rstream() { return vertices; }
void sort_edges_rstream() { sort_edges(); }
protected:
std::vector<Vertex> vertices;
void sort_edges() {
for(unsigned int i = 0; i < get_nof_vertices(); i++)
vertices[i].sort_edges();
}
void remove_duplicate_edges() {
std::vector<bool> tmp(vertices.size(), false);
for(std::vector<Vertex>::iterator vi = vertices.begin();
vi != vertices.end();
vi++)
{
#if defined(BLISS_EXPENSIVE_CONSISTENCY_CHECKS)
for(unsigned int i = 0; i < tmp.size(); i++) assert(tmp[i] == false);
#endif
(*vi).remove_duplicate_edges(tmp);
}
}
// \internal Partition independent invariant.
// Return the color of the vertex. Time complexity: O(1)
static unsigned int vertex_color_invariant(const Graph* const g, const unsigned int v) {
return g->vertices[v].color;
}
/** \internal
* Partition independent invariant.
* Returns the degree of the vertex.
* DUPLICATE EDGES MUST HAVE BEEN REMOVED BEFORE.
* Time complexity: O(1).
*/
// Return the degree of the vertex. Time complexity: O(1)
static unsigned int degree_invariant(const Graph* const g, const unsigned int v) {
return g->vertices[v].nof_edges();
}
/** \internal
* Partition independent invariant.
* Returns 1 if there is an edge from the vertex to itself, 0 if not.
* Time complexity: O(k), where k is the number of edges leaving the vertex.
*/
// Return 1 if the vertex v has a self-loop, 0 otherwise
// Time complexity: O(E_v), where E_v is the number of edges leaving v
static unsigned selfloop_invariant(const Graph* const g, const unsigned int v) {
const Vertex& vertex = g->vertices[v];
for(std::vector<IndexEdge>::const_iterator ei = vertex.edges.begin(); ei != vertex.edges.end(); ei++) {
#ifdef USE_DOMAIN
if(ei->first == v) return 1; // cxh
#else
if(*ei == v) return 1;
#endif
}
return 0;
}
// Refine the partition p according to a partition independent invariant
bool refine_according_to_invariant(unsigned int (*inv)(const Graph* const g, const unsigned int v)) {
bool refined = false;
for(Partition::Cell* cell = p.first_nonsingleton_cell; cell; ) {
Partition::Cell* const next_cell = cell->next_nonsingleton;
const unsigned int* ep = p.elements + cell->first;
for(unsigned int i = cell->length; i > 0; i--, ep++) {
const unsigned int ival = inv(this, *ep);
p.invariant_values[*ep] = ival;
if(ival > cell->max_ival) {
cell->max_ival = ival;
cell->max_ival_count = 1;
}
else if(ival == cell->max_ival) {
cell->max_ival_count++;
}
}
Partition::Cell* const last_new_cell = p.zplit_cell(cell, true);
refined |= (last_new_cell != cell);
cell = next_cell;
}
return refined;
}
// Routines needed when refining the partition p into equitable
// Split the neighbourhood of a cell according to the equitable invariant
bool split_neighbourhood_of_cell(Partition::Cell* const cell) {
const bool was_equal_to_first = refine_equal_to_first;
if(compute_eqref_hash) {
eqref_hash.update(cell->first);
eqref_hash.update(cell->length);
}
const unsigned int* ep = p.elements + cell->first;
for(unsigned int i = cell->length; i > 0; i--) {
const Vertex& v = vertices[*ep++];
std::vector<IndexEdge>::const_iterator ei = v.edges.begin();
for(unsigned int j = v.nof_edges(); j != 0; j--) {
#ifdef USE_DOMAIN
const unsigned int dest_vertex = (ei++)->first; // cxh
#else
const unsigned int dest_vertex = *ei++;
#endif
Partition::Cell * const neighbour_cell = p.get_cell(dest_vertex);
if(neighbour_cell->is_unit())
continue;
const unsigned int ival = ++p.invariant_values[dest_vertex];
if(ival > neighbour_cell->max_ival) {
neighbour_cell->max_ival = ival;
neighbour_cell->max_ival_count = 1;
if(ival == 1) {
neighbour_heap.insert(neighbour_cell->first);
}
}
else if(ival == neighbour_cell->max_ival) {
neighbour_cell->max_ival_count++;
}
}
}
while(!neighbour_heap.is_empty()) {
const unsigned int start = neighbour_heap.remove();
Partition::Cell * const neighbour_cell = p.get_cell(p.elements[start]);
if(compute_eqref_hash) {
eqref_hash.update(neighbour_cell->first);
eqref_hash.update(neighbour_cell->length);
eqref_hash.update(neighbour_cell->max_ival);
eqref_hash.update(neighbour_cell->max_ival_count);
}
Partition::Cell* const last_new_cell = p.zplit_cell(neighbour_cell, true);
// Update certificate and hash if needed
const Partition::Cell* c = neighbour_cell;
while(1) {
if(in_search) {
// Build certificate
cert_add_redundant(CERT_SPLIT, c->first, c->length);
// No need to continue?
if(refine_compare_certificate and
(refine_equal_to_first == false) and
(refine_cmp_to_best < 0))
goto worse_exit;
}
if(compute_eqref_hash) {
eqref_hash.update(c->first);
eqref_hash.update(c->length);
}
if(c == last_new_cell) break;
c = c->next;
}
}
if(refine_compare_certificate and (refine_equal_to_first == false) and (refine_cmp_to_best < 0))
return true;
return false;
worse_exit:
// Clear neighbour heap
UintSeqHash rest;
while(!neighbour_heap.is_empty()) {
const unsigned int start = neighbour_heap.remove();
Partition::Cell * const neighbour_cell = p.get_cell(p.elements[start]);
if(opt_use_failure_recording and was_equal_to_first) {
rest.update(neighbour_cell->first);
rest.update(neighbour_cell->length);
rest.update(neighbour_cell->max_ival);
rest.update(neighbour_cell->max_ival_count);
}
neighbour_cell->max_ival = 0;
neighbour_cell->max_ival_count = 0;
p.clear_ivs(neighbour_cell);
}
if(opt_use_failure_recording and was_equal_to_first) {
for(unsigned int i = p.splitting_queue.size(); i > 0; i--) {
Partition::Cell* const cell = p.splitting_queue.pop_front();
rest.update(cell->first);
rest.update(cell->length);
p.splitting_queue.push_back(cell);
}
rest.update(failure_recording_fp_deviation);
failure_recording_fp_deviation = rest.get_value();
}
return true;
}
bool split_neighbourhood_of_unit_cell(Partition::Cell* const unit_cell) {
const bool was_equal_to_first = refine_equal_to_first;
if(compute_eqref_hash) {
eqref_hash.update(0x87654321);
eqref_hash.update(unit_cell->first);
eqref_hash.update(1);
}
const Vertex& v = vertices[p.elements[unit_cell->first]];
std::vector<IndexEdge>::const_iterator ei = v.edges.begin();
for(unsigned int j = v.nof_edges(); j > 0; j--) {
#ifdef USE_DOMAIN
const unsigned int dest_vertex = (ei++)->first; // cxh
#else
const unsigned int dest_vertex = *ei++;
#endif
Partition::Cell * const neighbour_cell = p.get_cell(dest_vertex);
if(neighbour_cell->is_unit()) {
if(in_search) {
/* Remember neighbour in order to generate certificate */
neighbour_heap.insert(neighbour_cell->first);
}
continue;
}
if(neighbour_cell->max_ival_count == 0) {
neighbour_heap.insert(neighbour_cell->first);
}
neighbour_cell->max_ival_count++;
unsigned int * const swap_position =
p.elements + neighbour_cell->first + neighbour_cell->length -
neighbour_cell->max_ival_count;
*p.in_pos[dest_vertex] = *swap_position;
p.in_pos[*swap_position] = p.in_pos[dest_vertex];
*swap_position = dest_vertex;
p.in_pos[dest_vertex] = swap_position;
}
while(!neighbour_heap.is_empty()) {
const unsigned int start = neighbour_heap.remove();
Partition::Cell* neighbour_cell = p.get_cell(p.elements[start]);
#if defined(BLISS_CONSISTENCY_CHECKS)
if(neighbour_cell->is_unit()) { } else { }
#endif
if(compute_eqref_hash) {
eqref_hash.update(neighbour_cell->first);
eqref_hash.update(neighbour_cell->length);
eqref_hash.update(neighbour_cell->max_ival_count);
}
if(neighbour_cell->length > 1 and neighbour_cell->max_ival_count != neighbour_cell->length) {
Partition::Cell * const new_cell =
p.aux_split_in_two(neighbour_cell, neighbour_cell->length - neighbour_cell->max_ival_count);
unsigned int *ep = p.elements + new_cell->first;
unsigned int * const lp = p.elements+new_cell->first+new_cell->length;
while(ep < lp) {
p.element_to_cell_map[*ep] = new_cell;
ep++;
}
neighbour_cell->max_ival_count = 0;
if(compute_eqref_hash) {
/* Update hash */
eqref_hash.update(neighbour_cell->first);
eqref_hash.update(neighbour_cell->length);
eqref_hash.update(0);
eqref_hash.update(new_cell->first);
eqref_hash.update(new_cell->length);
eqref_hash.update(1);
}
/* Add cells in splitting_queue */
if(neighbour_cell->is_in_splitting_queue()) {
/* Both cells must be included in splitting_queue in order
to ensure refinement into equitable partition */
p.splitting_queue_add(new_cell);
} else {
Partition::Cell *min_cell, *max_cell;
if(neighbour_cell->length <= new_cell->length) {
min_cell = neighbour_cell;
max_cell = new_cell;
} else {
min_cell = new_cell;
max_cell = neighbour_cell;
}
/* Put the smaller cell in splitting_queue */
p.splitting_queue_add(min_cell);
if(max_cell->is_unit()) {
/* Put the "larger" cell also in splitting_queue */
p.splitting_queue_add(max_cell);
}
}
/* Update pointer for certificate generation */
neighbour_cell = new_cell;
} else {
/* neighbour_cell->length == 1 ||
neighbour_cell->max_ival_count == neighbour_cell->length */
neighbour_cell->max_ival_count = 0;
}
/*
* Build certificate if required
*/
if(in_search) {
for(unsigned int i = neighbour_cell->first, j = neighbour_cell->length; j > 0; j--, i++) {
/* Build certificate */
cert_add(CERT_EDGE, unit_cell->first, i);
/* No need to continue? */
if(refine_compare_certificate and (refine_equal_to_first == false) and (refine_cmp_to_best < 0))
goto worse_exit;
}
} /* if(in_search) */
} /* while(!neighbour_heap.is_empty()) */
if(refine_compare_certificate and
(refine_equal_to_first == false) and
(refine_cmp_to_best < 0))
return true;
return false;
worse_exit:
/* Clear neighbour heap */
UintSeqHash rest;
while(!neighbour_heap.is_empty()) {
const unsigned int start = neighbour_heap.remove();
Partition::Cell * const neighbour_cell = p.get_cell(p.elements[start]);
if(opt_use_failure_recording and was_equal_to_first) {
rest.update(neighbour_cell->first);
rest.update(neighbour_cell->length);
rest.update(neighbour_cell->max_ival_count);
}
neighbour_cell->max_ival_count = 0;
}
if(opt_use_failure_recording and was_equal_to_first) {
rest.update(failure_recording_fp_deviation);
failure_recording_fp_deviation = rest.get_value();
}
return true;
}
// Build the initial equitable partition
void make_initial_equitable_partition() {
refine_according_to_invariant(&vertex_color_invariant);
p.splitting_queue_clear();
//p.print_signature(stderr); fprintf(stderr, "\n");
refine_according_to_invariant(&selfloop_invariant);
p.splitting_queue_clear();
//p.print_signature(stderr); fprintf(stderr, "\n");
refine_according_to_invariant(°ree_invariant);
p.splitting_queue_clear();
//p.print_signature(stderr); fprintf(stderr, "\n");
refine_to_equitable();
//p.print_signature(stderr); fprintf(stderr, "\n");
}
// \internal
// \copydoc AbstractGraph::is_equitable() const
//Check whether the current partition p is equitable.
//Performance: very slow, use only for debugging purposes.
bool is_equitable() const {
const unsigned int N = get_nof_vertices();
if(N == 0) return true;
std::vector<unsigned int> first_count = std::vector<unsigned int>(N, 0);
std::vector<unsigned int> other_count = std::vector<unsigned int>(N, 0);
for(Partition::Cell *cell = p.first_cell; cell; cell = cell->next) {
if(cell->is_unit()) continue;
unsigned int *ep = p.elements + cell->first;
const Vertex &first_vertex = vertices[*ep++];
/* Count how many edges lead from the first vertex to
* the neighbouring cells */
for(std::vector<IndexEdge>::const_iterator ei = first_vertex.edges.begin(); ei != first_vertex.edges.end(); ei++) {
#ifdef USE_DOMAIN
first_count[p.get_cell(ei->first)->first]++; // cxh
#else
first_count[p.get_cell(*ei)->first]++;
#endif
}
/* Count and compare to the edges of the other vertices */
for(unsigned int i = cell->length; i > 1; i--) {
const Vertex &vertex = vertices[*ep++];
for(std::vector<IndexEdge>::const_iterator ei = vertex.edges.begin(); ei != vertex.edges.end(); ei++) {
#ifdef USE_DOMAIN
other_count[p.get_cell(ei->first)->first]++; // cxh
#else
other_count[p.get_cell(*ei)->first]++;
#endif
}
for(Partition::Cell *cell2 = p.first_cell; cell2; cell2 = cell2->next) {
if(first_count[cell2->first] != other_count[cell2->first]) {
/* Not equitable */
return false;
}
other_count[cell2->first] = 0;
}
}
/* Reset first_count */
for(unsigned int i = 0; i < N; i++) first_count[i] = 0;
}
return true;
}
/* Splitting heuristics, documented in more detail in graph.cc */
SplittingHeuristic sh;
// Find the next cell to be splitted
Partition::Cell* find_next_cell_to_be_splitted(Partition::Cell* cell) {
switch(sh) {
case shs_f: return sh_first();
case shs_fs: return sh_first_smallest();
case shs_fl: return sh_first_largest();
case shs_fm: return sh_first_max_neighbours();
case shs_fsm: return sh_first_smallest_max_neighbours();
case shs_flm: return sh_first_largest_max_neighbours();
default: fatal_error("Internal error - unknown splitting heuristics");
return 0;
}
}
// \internal
// A splitting heuristic.
// Returns the first nonsingleton cell in the current partition.
Partition::Cell* sh_first() {
Partition::Cell* best_cell = 0;
for(Partition::Cell* cell = p.first_nonsingleton_cell; cell; cell = cell->next_nonsingleton) {
if(opt_use_comprec and p.cr_get_level(cell->first) != cr_level)
continue;
best_cell = cell;
break;
}
return best_cell;
}
// \internal A splitting heuristic.
// Returns the first smallest nonsingleton cell in the current partition.
Partition::Cell* sh_first_smallest() {
Partition::Cell* best_cell = 0;
unsigned int best_size = UINT_MAX;
for(Partition::Cell* cell = p.first_nonsingleton_cell; cell; cell = cell->next_nonsingleton) {
if(opt_use_comprec and p.cr_get_level(cell->first) != cr_level) continue;
if(cell->length < best_size) {
best_size = cell->length;
best_cell = cell;
}
}
return best_cell;
}
// \internal A splitting heuristic.
// Returns the first largest nonsingleton cell in the current partition.
Partition::Cell* sh_first_largest() {
Partition::Cell* best_cell = 0;
unsigned int best_size = 0;
for(Partition::Cell* cell = p.first_nonsingleton_cell; cell; cell = cell->next_nonsingleton) {
if(opt_use_comprec and p.cr_get_level(cell->first) != cr_level)
continue;
if(cell->length > best_size) {
best_size = cell->length;
best_cell = cell;
}
}
return best_cell;
}
// \internal
// A splitting heuristic.
// Returns the first nonsingleton cell with max number of neighbouring nonsingleton cells.
// Assumes that the partition p is equitable.
// Assumes that the max_ival fields of the cells are all 0.
Partition::Cell* sh_first_max_neighbours() {
Partition::Cell* best_cell = 0;
int best_value = -1;
KStack<Partition::Cell*> neighbour_cells_visited;
neighbour_cells_visited.init(get_nof_vertices());
for(Partition::Cell* cell = p.first_nonsingleton_cell; cell; cell = cell->next_nonsingleton) {
if(opt_use_comprec and p.cr_get_level(cell->first) != cr_level)
continue;
const Vertex& v = vertices[p.elements[cell->first]];
std::vector<IndexEdge>::const_iterator ei = v.edges.begin();
for(unsigned int j = v.nof_edges(); j > 0; j--) {
#ifdef USE_DOMAIN
Partition::Cell * const neighbour_cell = p.get_cell((ei++)->first)
gitextract_7r5c247e/
├── .circleci/
│ ├── config.yml
│ └── longest_common_path.sh
├── .clang-format
├── .clang-tidy
├── .git-blame-ignore-revs
├── .gitignore
├── .gitmodules
├── .travis.yml
├── CMakeLists.txt
├── COPYRIGHT
├── LICENSE.txt
├── README.md
├── cmake/
│ ├── GaloisConfig.cmake.in
│ └── Modules/
│ ├── CheckArchFlags.cmake
│ ├── CheckCilk.cmake
│ ├── CheckEndian.cmake
│ ├── CheckHugePages.cmake
│ ├── CheckMmap.cmake
│ ├── CheckSchedSetAffinity.cmake
│ ├── FindCBLAS.cmake
│ ├── FindFortran.cmake
│ ├── FindGASNET.cmake
│ ├── FindGMP.cmake
│ ├── FindGit.cmake
│ ├── FindNUMA.cmake
│ ├── FindOpenCL.cmake
│ ├── FindPAPI.cmake
│ ├── FindQGLViewer.cmake
│ ├── FindTBB.cmake
│ ├── FindVTune.cmake
│ ├── GetGitVersion-write.cmake
│ ├── GetGitVersion.cmake
│ ├── HandleSanitizer.cmake
│ ├── LibFindMacros.cmake
│ └── UseStdMacro.cmake
├── config/
│ ├── sanitizers/
│ │ └── ubsan_blacklist.txt.in
│ └── version.txt
├── external/
│ └── bliss/
│ └── bliss/
│ ├── COPYING
│ ├── COPYING.LESSER
│ ├── abgraph.hh
│ ├── bignum.hh
│ ├── defs.hh
│ ├── graph.hh
│ ├── heap.hh
│ ├── kqueue.hh
│ ├── kstack.hh
│ ├── orbit.hh
│ ├── partition.hh
│ ├── search.h
│ ├── uintseqhash.hh
│ └── utils.hh
├── inputs/
│ ├── CMakeLists.txt
│ └── cholesky/
│ ├── matrix1.txt
│ ├── matrix1.txt.choleskyedges
│ ├── matrix1.txt.dep
│ ├── matrix1.txt.filled
│ ├── very-sparse.txt
│ ├── very-sparse.txt.choleskyedges
│ ├── very-sparse.txt.dep
│ └── very-sparse.txt.filled
├── libcusp/
│ ├── CMakeLists.txt
│ └── include/
│ └── galois/
│ └── graphs/
│ ├── BasePolicies.h
│ ├── CuSPPartitioner.h
│ ├── DistributedGraph.h
│ ├── GenericPartitioners.h
│ ├── MiningPartitioner.h
│ └── NewGeneric.h
├── libdist/
│ ├── CMakeLists.txt
│ ├── include/
│ │ └── galois/
│ │ ├── DReducible.h
│ │ ├── DTerminationDetector.h
│ │ ├── DistGalois.h
│ │ └── runtime/
│ │ ├── BareMPI.h
│ │ ├── DistStats.h
│ │ ├── LWCI.h
│ │ ├── MemUsage.h
│ │ ├── Network.h
│ │ ├── NetworkIO.h
│ │ └── Serialize.h
│ └── src/
│ ├── Barrier.cpp
│ ├── DistGalois.cpp
│ ├── DistStats.cpp
│ ├── Network.cpp
│ ├── NetworkBuffered.cpp
│ ├── NetworkIOMPI.cpp
│ └── NetworkLCI.cpp
├── libgalois/
│ ├── CMakeLists.txt
│ ├── include/
│ │ └── galois/
│ │ ├── ArrayWrapper.h
│ │ ├── AtomicHelpers.h
│ │ ├── AtomicWrapper.h
│ │ ├── Bag.h
│ │ ├── CheckedObject.h
│ │ ├── CopyableTuple.h
│ │ ├── DynamicBitset.h
│ │ ├── Endian.h
│ │ ├── FixedSizeRing.h
│ │ ├── FlatMap.h
│ │ ├── Galois.h
│ │ ├── GaloisForwardDecl.h
│ │ ├── LargeArray.h
│ │ ├── LazyArray.h
│ │ ├── LazyObject.h
│ │ ├── Loops.h
│ │ ├── Mem.h
│ │ ├── MethodFlags.h
│ │ ├── NoDerefIterator.h
│ │ ├── PODResizeableArray.h
│ │ ├── ParallelSTL.h
│ │ ├── PerThreadContainer.h
│ │ ├── PriorityQueue.h
│ │ ├── Reduction.h
│ │ ├── SharedMemSys.h
│ │ ├── Threads.h
│ │ ├── Timer.h
│ │ ├── Traits.h
│ │ ├── TwoLevelIterator.h
│ │ ├── TwoLevelIteratorA.h
│ │ ├── UnionFind.h
│ │ ├── UserContext.h
│ │ ├── Version.h
│ │ ├── config.h.in
│ │ ├── gIO.h
│ │ ├── gdeque.h
│ │ ├── graphs/
│ │ │ ├── BufferedGraph.h
│ │ │ ├── Details.h
│ │ │ ├── FileGraph.h
│ │ │ ├── Graph.h
│ │ │ ├── GraphHelpers.h
│ │ │ ├── LCGraph.h
│ │ │ ├── LC_Adaptor_Graph.h
│ │ │ ├── LC_CSR_CSC_Graph.h
│ │ │ ├── LC_CSR_Graph.h
│ │ │ ├── LC_CSR_Hypergraph.h
│ │ │ ├── LC_InOut_Graph.h
│ │ │ ├── LC_InlineEdge_Graph.h
│ │ │ ├── LC_Linear_Graph.h
│ │ │ ├── LC_Morph_Graph.h
│ │ │ ├── MorphGraph.h
│ │ │ ├── MorphHyperGraph.h
│ │ │ ├── Morph_SepInOut_Graph.h
│ │ │ ├── OCGraph.h
│ │ │ ├── OfflineGraph.h
│ │ │ ├── ReadGraph.h
│ │ │ ├── SpatialTree.h
│ │ │ └── TypeTraits.h
│ │ ├── gslist.h
│ │ ├── gstl.h
│ │ ├── optional.h
│ │ ├── runtime/
│ │ │ ├── Context.h
│ │ │ ├── Executor_Deterministic.h
│ │ │ ├── Executor_DoAll.h
│ │ │ ├── Executor_ForEach.h
│ │ │ ├── Executor_OnEach.h
│ │ │ ├── Executor_Ordered.h
│ │ │ ├── Executor_ParaMeter.h
│ │ │ ├── ExtraTraits.h
│ │ │ ├── Iterable.h
│ │ │ ├── LoopStatistics.h
│ │ │ ├── Mem.h
│ │ │ ├── OperatorReferenceTypes.h
│ │ │ ├── PagePool.h
│ │ │ ├── Profile.h
│ │ │ ├── Range.h
│ │ │ ├── SharedMem.h
│ │ │ ├── Statistics.h
│ │ │ ├── Substrate.h
│ │ │ ├── ThreadTimer.h
│ │ │ ├── TiledExecutor.h
│ │ │ ├── Tracer.h
│ │ │ └── UserContextAccess.h
│ │ ├── substrate/
│ │ │ ├── Barrier.h
│ │ │ ├── CacheLineStorage.h
│ │ │ ├── CompilerSpecific.h
│ │ │ ├── EnvCheck.h
│ │ │ ├── HWTopo.h
│ │ │ ├── NumaMem.h
│ │ │ ├── PaddedLock.h
│ │ │ ├── PageAlloc.h
│ │ │ ├── PerThreadStorage.h
│ │ │ ├── PtrLock.h
│ │ │ ├── SharedMem.h
│ │ │ ├── SimpleLock.h
│ │ │ ├── StaticInstance.h
│ │ │ ├── Termination.h
│ │ │ ├── ThreadPool.h
│ │ │ └── ThreadRWlock.h
│ │ └── worklists/
│ │ ├── AdaptiveObim.h
│ │ ├── BulkSynchronous.h
│ │ ├── Chunk.h
│ │ ├── ExternalReference.h
│ │ ├── LocalQueue.h
│ │ ├── Obim.h
│ │ ├── OrderedList.h
│ │ ├── OwnerComputes.h
│ │ ├── PerThreadChunk.h
│ │ ├── Simple.h
│ │ ├── StableIterator.h
│ │ ├── WLCompileCheck.h
│ │ ├── WorkList.h
│ │ └── WorkListHelpers.h
│ ├── src/
│ │ ├── Barrier.cpp
│ │ ├── Barrier_Counting.cpp
│ │ ├── Barrier_Dissemination.cpp
│ │ ├── Barrier_MCS.cpp
│ │ ├── Barrier_Pthread.cpp
│ │ ├── Barrier_Simple.cpp
│ │ ├── Barrier_Topo.cpp
│ │ ├── Context.cpp
│ │ ├── Deterministic.cpp
│ │ ├── DynamicBitset.cpp
│ │ ├── EnvCheck.cpp
│ │ ├── FileGraph.cpp
│ │ ├── FileGraphParallel.cpp
│ │ ├── GraphHelpers.cpp
│ │ ├── HWTopo.cpp
│ │ ├── HWTopoDarwin.cpp
│ │ ├── HWTopoLinux.cpp
│ │ ├── Mem.cpp
│ │ ├── NumaMem.cpp
│ │ ├── OCFileGraph.cpp
│ │ ├── PageAlloc.cpp
│ │ ├── PagePool.cpp
│ │ ├── ParaMeter.cpp
│ │ ├── PerThreadStorage.cpp
│ │ ├── PreAlloc.cpp
│ │ ├── Profile.cpp
│ │ ├── PtrLock.cpp
│ │ ├── SharedMem.cpp
│ │ ├── SharedMemSys.cpp
│ │ ├── SimpleLock.cpp
│ │ ├── Statistics.cpp
│ │ ├── Substrate.cpp
│ │ ├── Support.cpp
│ │ ├── Termination.cpp
│ │ ├── ThreadPool.cpp
│ │ ├── ThreadTimer.cpp
│ │ ├── Threads.cpp
│ │ ├── Timer.cpp
│ │ ├── Tracer.cpp
│ │ ├── Version.cpp.in
│ │ └── gIO.cpp
│ └── test/
│ ├── CMakeLists.txt
│ ├── README.md
│ ├── acquire.cpp
│ ├── bandwidth.cpp
│ ├── barriers.cpp
│ ├── empty-member-lcgraph.cpp
│ ├── flatmap.cpp
│ ├── floatingPointErrors.cpp
│ ├── foreach.cpp
│ ├── forward-declare-graph.cpp
│ ├── gcollections.cpp
│ ├── graph-compile.cpp
│ ├── graph.cpp
│ ├── gslist.cpp
│ ├── hwtopo.cpp
│ ├── lc-adaptor.cpp
│ ├── lock.cpp
│ ├── lockmgr.cpp
│ ├── loop-overhead.cpp
│ ├── mem.cpp
│ ├── morphgraph-removal.cpp
│ ├── morphgraph.cpp
│ ├── move.cpp
│ ├── oneach.cpp
│ ├── papi.cpp
│ ├── pc.cpp
│ ├── reduction.cpp
│ ├── sort.cpp
│ ├── static.cpp
│ ├── traits.cpp
│ ├── twoleveliteratora.cpp
│ ├── wakeup-overhead.cpp
│ └── worklists-compile.cpp
├── libgluon/
│ ├── CMakeLists.txt
│ ├── include/
│ │ └── galois/
│ │ ├── cuda/
│ │ │ ├── Context.h
│ │ │ ├── DynamicBitset.h
│ │ │ ├── EdgeContext.h
│ │ │ ├── EdgeHostDecls.h
│ │ │ └── HostDecls.h
│ │ ├── graphs/
│ │ │ ├── GluonEdgeSubstrate.h
│ │ │ └── GluonSubstrate.h
│ │ └── runtime/
│ │ ├── DataCommMode.h
│ │ ├── GlobalObj.h
│ │ ├── SyncStructures.h
│ │ └── cuda/
│ │ ├── DeviceEdgeSync.h
│ │ └── DeviceSync.h
│ └── src/
│ ├── GlobalObj.cpp
│ ├── GluonSubstrate.cpp
│ ├── SyncStructures.cpp
│ └── cuda_device.cpp
├── libgpu/
│ ├── CMakeLists.txt
│ ├── include/
│ │ ├── Timer.h
│ │ ├── abitset.h
│ │ ├── aolist.h
│ │ ├── atomic_helpers.h
│ │ ├── bmk2.h
│ │ ├── component.h
│ │ ├── counter.h
│ │ ├── csr_graph.h
│ │ ├── cuda_launch_config.hpp
│ │ ├── cutil_subset.h
│ │ ├── exclusive.h
│ │ ├── failfast.h
│ │ ├── gbar.cuh
│ │ ├── gg.h
│ │ ├── ggc_rt.h
│ │ ├── ggcuda.h
│ │ ├── instr.h
│ │ ├── internal.h
│ │ ├── lockarray.h
│ │ ├── pipe.h
│ │ ├── rv.h
│ │ ├── sharedptr.h
│ │ ├── snfile.h
│ │ ├── thread_work.h
│ │ └── worklist.h
│ └── src/
│ ├── bmk2.c
│ ├── csr_graph.cu
│ ├── ggc_rt.cu
│ ├── instr.cu
│ ├── skelapp/
│ │ └── skel.cu
│ ├── snappy.c
│ └── snappy_test.c
├── libpangolin/
│ ├── CMakeLists.txt
│ ├── README.md
│ ├── gpu/
│ │ └── pangolin/
│ │ ├── bitsets.h
│ │ ├── checker.h
│ │ ├── cutils.h
│ │ ├── element.cuh
│ │ ├── embedding.cuh
│ │ ├── graph_gpu.h
│ │ ├── miner.cuh
│ │ ├── timer.h
│ │ └── types.cuh
│ ├── include/
│ │ └── pangolin/
│ │ ├── BfsMining/
│ │ │ ├── edge_miner.h
│ │ │ ├── edge_miner_api.h
│ │ │ ├── embedding_list.h
│ │ │ ├── engine.h
│ │ │ ├── vertex_miner.h
│ │ │ └── vertex_miner_api.h
│ │ ├── base_embedding.h
│ │ ├── canonical_graph.h
│ │ ├── core.h
│ │ ├── domain_support.h
│ │ ├── edge_embedding.h
│ │ ├── edge_type.h
│ │ ├── element.h
│ │ ├── embedding.h
│ │ ├── embedding_queue.h
│ │ ├── equivalence.h
│ │ ├── gtypes.h
│ │ ├── mgraph.h
│ │ ├── miner.h
│ │ ├── ptypes.h
│ │ ├── quick_pattern.h
│ │ ├── res_man.h
│ │ ├── scan.h
│ │ ├── types.h
│ │ ├── util.h
│ │ └── vertex_embedding.h
│ └── src/
│ ├── BfsMining/
│ │ └── embedding_list.cpp
│ ├── base_embedding.cpp
│ ├── equivalence.cpp
│ ├── quick_pattern.cpp
│ └── vertex_embedding.cpp
├── libpygalois/
│ ├── CMakeLists.txt
│ └── include/
│ └── galois/
│ └── Constants.h
├── libsupport/
│ ├── CMakeLists.txt
│ ├── include/
│ │ └── galois/
│ │ ├── GetEnv.h
│ │ └── Logging.h
│ ├── src/
│ │ ├── GetEnv.cpp
│ │ └── Logging.cpp
│ └── test/
│ ├── CMakeLists.txt
│ ├── getenv.cpp
│ └── logging.cpp
├── lonestar/
│ ├── CMakeLists.txt
│ ├── analytics/
│ │ ├── CMakeLists.txt
│ │ ├── cpu/
│ │ │ ├── CMakeLists.txt
│ │ │ ├── betweennesscentrality/
│ │ │ │ ├── AsyncStructs.h
│ │ │ │ ├── BCEdge.h
│ │ │ │ ├── BCNode.h
│ │ │ │ ├── BetweennessCentrality.cpp
│ │ │ │ ├── CMakeLists.txt
│ │ │ │ ├── LevelStructs.h
│ │ │ │ ├── OuterStructs.h
│ │ │ │ ├── README.md
│ │ │ │ └── control.h
│ │ │ ├── bfs/
│ │ │ │ ├── CMakeLists.txt
│ │ │ │ ├── README.md
│ │ │ │ ├── bfs.cpp
│ │ │ │ └── bfsDirectionOpt.cpp
│ │ │ ├── bipart/
│ │ │ │ ├── CMakeLists.txt
│ │ │ │ ├── Coarsening.cpp
│ │ │ │ ├── Metric.cpp
│ │ │ │ ├── Partitioning.cpp
│ │ │ │ ├── README.md
│ │ │ │ ├── Refine.cpp
│ │ │ │ ├── bipart.cpp
│ │ │ │ └── bipart.h
│ │ │ ├── clustering/
│ │ │ │ ├── CMakeLists.txt
│ │ │ │ ├── README.md
│ │ │ │ ├── clustering.h
│ │ │ │ ├── leidenClustering.cpp
│ │ │ │ └── louvainClustering.cpp
│ │ │ ├── connected-components/
│ │ │ │ ├── CMakeLists.txt
│ │ │ │ ├── ConnectedComponents.cpp
│ │ │ │ └── README.md
│ │ │ ├── gmetis/
│ │ │ │ ├── CMakeLists.txt
│ │ │ │ ├── Coarsening.cpp
│ │ │ │ ├── GMetis.cpp
│ │ │ │ ├── GraphReader.h
│ │ │ │ ├── Metis.h
│ │ │ │ ├── Metric.cpp
│ │ │ │ ├── Partitioning.cpp
│ │ │ │ ├── README.md
│ │ │ │ └── Refine.cpp
│ │ │ ├── independentset/
│ │ │ │ ├── CMakeLists.txt
│ │ │ │ ├── IndependentSet.cpp
│ │ │ │ └── README.md
│ │ │ ├── k-core/
│ │ │ │ ├── CMakeLists.txt
│ │ │ │ ├── README.md
│ │ │ │ └── kcore.cpp
│ │ │ ├── k-truss/
│ │ │ │ ├── CMakeLists.txt
│ │ │ │ ├── K-Truss.cpp
│ │ │ │ ├── README.md
│ │ │ │ ├── Verify.cpp
│ │ │ │ └── bmktest2.py
│ │ │ ├── matching/
│ │ │ │ ├── CMakeLists.txt
│ │ │ │ ├── README.md
│ │ │ │ └── bipartite-mcm.cpp
│ │ │ ├── matrixcompletion/
│ │ │ │ ├── CMakeLists.txt
│ │ │ │ ├── README.md
│ │ │ │ ├── bipartite-gen.py
│ │ │ │ ├── commandLineParam.h
│ │ │ │ ├── matrixCompletion.cpp
│ │ │ │ ├── matrixCompletion.h
│ │ │ │ ├── parselog.sh
│ │ │ │ ├── plot.R
│ │ │ │ └── runexp.py
│ │ │ ├── pagerank/
│ │ │ │ ├── CMakeLists.txt
│ │ │ │ ├── PageRank-constants.h
│ │ │ │ ├── PageRank-pull.cpp
│ │ │ │ ├── PageRank-push.cpp
│ │ │ │ └── README.md
│ │ │ ├── pointstoanalysis/
│ │ │ │ ├── CMakeLists.txt
│ │ │ │ ├── PointsTo.cpp
│ │ │ │ ├── README.md
│ │ │ │ └── SparseBitVector.h
│ │ │ ├── preflowpush/
│ │ │ │ ├── CMakeLists.txt
│ │ │ │ ├── Preflowpush.cpp
│ │ │ │ └── README.md
│ │ │ ├── spanningtree/
│ │ │ │ ├── Boruvka.cpp
│ │ │ │ ├── CMakeLists.txt
│ │ │ │ ├── README.md
│ │ │ │ └── UnionFind.h
│ │ │ ├── sssp/
│ │ │ │ ├── CMakeLists.txt
│ │ │ │ ├── README.md
│ │ │ │ └── SSSP.cpp
│ │ │ └── triangle-counting/
│ │ │ ├── CMakeLists.txt
│ │ │ ├── README.md
│ │ │ └── Triangles.cpp
│ │ ├── distributed/
│ │ │ ├── CMakeLists.txt
│ │ │ ├── README.md
│ │ │ ├── betweennesscentrality/
│ │ │ │ ├── CMakeLists.txt
│ │ │ │ ├── README.md
│ │ │ │ ├── bc_level.cpp
│ │ │ │ ├── bc_level_cuda.cu
│ │ │ │ ├── bc_level_cuda.cuh
│ │ │ │ ├── bc_level_cuda.h
│ │ │ │ ├── bc_level_cuda.py
│ │ │ │ ├── bc_level_sync.hh
│ │ │ │ ├── bc_mr.cpp
│ │ │ │ ├── mrbc_bitset.hh
│ │ │ │ ├── mrbc_sync.hh
│ │ │ │ └── mrbc_tree.h
│ │ │ ├── bfs/
│ │ │ │ ├── CMakeLists.txt
│ │ │ │ ├── README.md
│ │ │ │ ├── bfs_pull.cpp
│ │ │ │ ├── bfs_pull_cuda.cu
│ │ │ │ ├── bfs_pull_cuda.cuh
│ │ │ │ ├── bfs_pull_cuda.h
│ │ │ │ ├── bfs_pull_cuda.py
│ │ │ │ ├── bfs_pull_sync.hh
│ │ │ │ ├── bfs_push.cpp
│ │ │ │ ├── bfs_push_cuda.cu
│ │ │ │ ├── bfs_push_cuda.cuh
│ │ │ │ ├── bfs_push_cuda.h
│ │ │ │ ├── bfs_push_cuda.py
│ │ │ │ └── bfs_push_sync.hh
│ │ │ ├── connected-components/
│ │ │ │ ├── CMakeLists.txt
│ │ │ │ ├── README.md
│ │ │ │ ├── cc_pull.cpp
│ │ │ │ ├── cc_pull_cuda.cu
│ │ │ │ ├── cc_pull_cuda.cuh
│ │ │ │ ├── cc_pull_cuda.h
│ │ │ │ ├── cc_pull_cuda.py
│ │ │ │ ├── cc_pull_sync.hh
│ │ │ │ ├── cc_push.cpp
│ │ │ │ ├── cc_push_cuda.cu
│ │ │ │ ├── cc_push_cuda.cuh
│ │ │ │ ├── cc_push_cuda.h
│ │ │ │ ├── cc_push_cuda.py
│ │ │ │ └── cc_push_sync.hh
│ │ │ ├── k-core/
│ │ │ │ ├── CMakeLists.txt
│ │ │ │ ├── README.md
│ │ │ │ ├── kcore_pull.cpp
│ │ │ │ ├── kcore_pull_cuda.cu
│ │ │ │ ├── kcore_pull_cuda.cuh
│ │ │ │ ├── kcore_pull_cuda.h
│ │ │ │ ├── kcore_pull_cuda.py
│ │ │ │ ├── kcore_pull_sync.hh
│ │ │ │ ├── kcore_push.cpp
│ │ │ │ ├── kcore_push_cuda.cu
│ │ │ │ ├── kcore_push_cuda.cuh
│ │ │ │ ├── kcore_push_cuda.h
│ │ │ │ ├── kcore_push_cuda.py
│ │ │ │ └── kcore_push_sync.hh
│ │ │ ├── matrixcompletion/
│ │ │ │ ├── CMakeLists.txt
│ │ │ │ ├── README.md
│ │ │ │ ├── matrixCompletion.cpp
│ │ │ │ └── matrixCompletion_sync.hh
│ │ │ ├── pagerank/
│ │ │ │ ├── CMakeLists.txt
│ │ │ │ ├── README.md
│ │ │ │ ├── pagerank_pull.cpp
│ │ │ │ ├── pagerank_pull_cuda.cu
│ │ │ │ ├── pagerank_pull_cuda.cuh
│ │ │ │ ├── pagerank_pull_cuda.h
│ │ │ │ ├── pagerank_pull_cuda.py
│ │ │ │ ├── pagerank_pull_sync.hh
│ │ │ │ ├── pagerank_push.cpp
│ │ │ │ ├── pagerank_push_cuda.cu
│ │ │ │ ├── pagerank_push_cuda.cuh
│ │ │ │ ├── pagerank_push_cuda.h
│ │ │ │ ├── pagerank_push_cuda.py
│ │ │ │ └── pagerank_push_sync.hh
│ │ │ ├── partition/
│ │ │ │ ├── CMakeLists.txt
│ │ │ │ └── partition.cpp
│ │ │ ├── sssp/
│ │ │ │ ├── CMakeLists.txt
│ │ │ │ ├── README.md
│ │ │ │ ├── sssp_pull.cpp
│ │ │ │ ├── sssp_pull_cuda.cu
│ │ │ │ ├── sssp_pull_cuda.cuh
│ │ │ │ ├── sssp_pull_cuda.h
│ │ │ │ ├── sssp_pull_cuda.py
│ │ │ │ ├── sssp_pull_sync.hh
│ │ │ │ ├── sssp_push.cpp
│ │ │ │ ├── sssp_push_cuda.cu
│ │ │ │ ├── sssp_push_cuda.cuh
│ │ │ │ ├── sssp_push_cuda.h
│ │ │ │ ├── sssp_push_cuda.py
│ │ │ │ └── sssp_push_sync.hh
│ │ │ └── triangle-counting/
│ │ │ ├── CMakeLists.txt
│ │ │ ├── README.md
│ │ │ ├── tc.cpp
│ │ │ ├── tc_cuda.cu
│ │ │ ├── tc_cuda.cuh
│ │ │ ├── tc_cuda.h
│ │ │ └── tc_cuda.py
│ │ └── gpu/
│ │ ├── CMakeLists.txt
│ │ ├── README.md
│ │ ├── bfs/
│ │ │ ├── CMakeLists.txt
│ │ │ ├── README.md
│ │ │ ├── bfs.cu
│ │ │ └── support.cu
│ │ ├── connected-components/
│ │ │ ├── CMakeLists.txt
│ │ │ ├── README.md
│ │ │ ├── cc.cu
│ │ │ └── support.cu
│ │ ├── independentset/
│ │ │ ├── CMakeLists.txt
│ │ │ ├── README.md
│ │ │ ├── mis.cu
│ │ │ └── support.cu
│ │ ├── matrixcompletion/
│ │ │ ├── CMakeLists.txt
│ │ │ ├── README.md
│ │ │ ├── SGDAsyncEdgeCu.h
│ │ │ ├── SGDCommonCu.h
│ │ │ ├── SGDGraphCu.h
│ │ │ ├── sgd.cu
│ │ │ └── support.cu
│ │ ├── pagerank/
│ │ │ ├── CMakeLists.txt
│ │ │ ├── README.md
│ │ │ ├── pagerank.cu
│ │ │ └── support.cu
│ │ ├── pointstoanalysis/
│ │ │ ├── CMakeLists.txt
│ │ │ ├── README.md
│ │ │ ├── andersen.cu
│ │ │ ├── andersen.h
│ │ │ ├── pta.cu
│ │ │ ├── pta_tuning.h
│ │ │ └── support.cu
│ │ ├── spanningtree/
│ │ │ ├── CMakeLists.txt
│ │ │ ├── README.md
│ │ │ ├── mst-tex.cu
│ │ │ ├── mst.cu
│ │ │ ├── mst.h
│ │ │ └── support.cu
│ │ ├── sssp/
│ │ │ ├── CMakeLists.txt
│ │ │ ├── README.md
│ │ │ ├── sssp.cu
│ │ │ └── support.cu
│ │ └── triangle-counting/
│ │ ├── CMakeLists.txt
│ │ ├── README.md
│ │ ├── support.cu
│ │ └── tc.cu
│ ├── eda/
│ │ ├── CMakeLists.txt
│ │ └── cpu/
│ │ ├── CMakeLists.txt
│ │ ├── aig-rewriting/
│ │ │ ├── CMakeLists.txt
│ │ │ ├── README.md
│ │ │ ├── algorithms/
│ │ │ │ ├── ChoiceManager.cpp
│ │ │ │ ├── ChoiceManager.h
│ │ │ │ ├── CutManager.cpp
│ │ │ │ ├── CutManager.h
│ │ │ │ ├── CutPool.cpp
│ │ │ │ ├── CutPool.h
│ │ │ │ ├── NPNManager.cpp
│ │ │ │ ├── NPNManager.h
│ │ │ │ ├── PreCompGraphManager.cpp
│ │ │ │ ├── PreCompGraphManager.h
│ │ │ │ ├── PriorityCutManager.cpp
│ │ │ │ ├── PriorityCutManager.h
│ │ │ │ ├── PriorityCutPool.cpp
│ │ │ │ ├── PriorityCutPool.h
│ │ │ │ ├── ReconvDrivenCut.cpp
│ │ │ │ ├── ReconvDrivenCut.h
│ │ │ │ ├── RewriteManager.cpp
│ │ │ │ └── RewriteManager.h
│ │ │ ├── functional/
│ │ │ │ ├── BitVectorPool.cpp
│ │ │ │ ├── BitVectorPool.h
│ │ │ │ ├── FunctionHandler.h
│ │ │ │ ├── FunctionHandler32.h
│ │ │ │ ├── FunctionUtil.cpp
│ │ │ │ └── FunctionUtil.h
│ │ │ ├── main.cpp
│ │ │ ├── misc/
│ │ │ │ └── util/
│ │ │ │ ├── utilString.cpp
│ │ │ │ └── utilString.h
│ │ │ ├── parsers/
│ │ │ │ ├── AigParser.cpp
│ │ │ │ ├── AigParser.h
│ │ │ │ ├── LookupTableParser.cpp
│ │ │ │ ├── LookupTableParser.h
│ │ │ │ ├── semantic_error.cpp
│ │ │ │ ├── semantic_error.h
│ │ │ │ ├── syntax_error.cpp
│ │ │ │ ├── syntax_error.h
│ │ │ │ ├── unexpected_eof.cpp
│ │ │ │ └── unexpected_eof.h
│ │ │ ├── subjectgraph/
│ │ │ │ └── aig/
│ │ │ │ ├── Aig.cpp
│ │ │ │ └── Aig.h
│ │ │ ├── writers/
│ │ │ │ ├── AigWriter.cpp
│ │ │ │ ├── AigWriter.h
│ │ │ │ ├── BlifWriter.cpp
│ │ │ │ └── BlifWriter.h
│ │ │ └── xxHash/
│ │ │ ├── xxhash.c
│ │ │ └── xxhash.h
│ │ └── sproute/
│ │ ├── BoilerPlate.h
│ │ ├── CMakeLists.txt
│ │ ├── DataProc.h
│ │ ├── DataType.h
│ │ ├── EdgeShift.h
│ │ ├── LICENSE
│ │ ├── README.md
│ │ ├── RSMT.h
│ │ ├── RipUp.h
│ │ ├── bitmap_image.hpp
│ │ ├── bitmap_test.cpp
│ │ ├── bookshelf_IO.c
│ │ ├── bookshelf_IO.h
│ │ ├── cong.c
│ │ ├── cong.h
│ │ ├── dist.c
│ │ ├── dist.h
│ │ ├── dl.c
│ │ ├── dl.h
│ │ ├── err.c
│ │ ├── err.h
│ │ ├── flute-ckt
│ │ ├── flute-ckt.c
│ │ ├── flute-net
│ │ ├── flute-net.c
│ │ ├── flute.h
│ │ ├── flute_mst.h
│ │ ├── global.h
│ │ ├── heap.c
│ │ ├── heap.h
│ │ ├── main.cpp
│ │ ├── maze.h
│ │ ├── maze3D.h
│ │ ├── maze_finegrain.h
│ │ ├── maze_finegrain_concurrent.h
│ │ ├── maze_finegrain_lateupdate.h
│ │ ├── maze_lock.h
│ │ ├── memAlloc.c
│ │ ├── memAlloc.h
│ │ ├── mst2.c
│ │ ├── mst2.h
│ │ ├── neighbors.c
│ │ ├── neighbors.h
│ │ ├── parallel_router_morphgraph.cpp
│ │ ├── rand-pts.c
│ │ ├── route.h
│ │ └── utility.h
│ ├── libdistbench/
│ │ ├── CMakeLists.txt
│ │ ├── include/
│ │ │ └── DistBench/
│ │ │ ├── Input.h
│ │ │ ├── MiningStart.h
│ │ │ ├── Output.h
│ │ │ └── Start.h
│ │ └── src/
│ │ ├── Input.cpp
│ │ ├── Output.cpp
│ │ └── Start.cpp
│ ├── liblonestar/
│ │ ├── CMakeLists.txt
│ │ ├── include/
│ │ │ └── Lonestar/
│ │ │ ├── BFS_SSSP.h
│ │ │ ├── BoilerPlate.h
│ │ │ └── Utils.h
│ │ └── src/
│ │ └── BoilerPlate.cpp
│ ├── mining/
│ │ ├── CMakeLists.txt
│ │ ├── README.md
│ │ ├── cpu/
│ │ │ ├── CMakeLists.txt
│ │ │ ├── frequent-subgraph-mining/
│ │ │ │ ├── CMakeLists.txt
│ │ │ │ ├── README.md
│ │ │ │ ├── fsm.cpp
│ │ │ │ └── fsm.h
│ │ │ ├── k-clique-listing/
│ │ │ │ ├── CMakeLists.txt
│ │ │ │ ├── README.md
│ │ │ │ ├── kcl.cpp
│ │ │ │ └── kcl.h
│ │ │ ├── motif-counting/
│ │ │ │ ├── CMakeLists.txt
│ │ │ │ ├── README.md
│ │ │ │ ├── motif.cpp
│ │ │ │ └── motif.h
│ │ │ ├── subgraph-listing/
│ │ │ │ ├── CMakeLists.txt
│ │ │ │ ├── README.mb
│ │ │ │ ├── sgl_cycle.cpp
│ │ │ │ └── sgl_diamond.cpp
│ │ │ └── triangle-counting/
│ │ │ ├── CMakeLists.txt
│ │ │ ├── README.md
│ │ │ ├── tc.h
│ │ │ └── tc_mine.cpp
│ │ ├── gpu/
│ │ │ ├── CMakeLists.txt
│ │ │ ├── frequent-subgraph-mining/
│ │ │ │ ├── CMakeLists.txt
│ │ │ │ ├── README.md
│ │ │ │ ├── fsm.cu
│ │ │ │ ├── fsm.h
│ │ │ │ └── fsm_gpu.cpp
│ │ │ ├── k-clique-listing/
│ │ │ │ ├── CMakeLists.txt
│ │ │ │ ├── README.md
│ │ │ │ ├── kcl.cu
│ │ │ │ ├── kcl.h
│ │ │ │ └── kcl_gpu.cpp
│ │ │ ├── motif-counting/
│ │ │ │ ├── CMakeLists.txt
│ │ │ │ ├── README.md
│ │ │ │ ├── motif.cu
│ │ │ │ ├── motif.h
│ │ │ │ └── motif_gpu.cpp
│ │ │ └── triangle-counting/
│ │ │ ├── CMakeLists.txt
│ │ │ ├── README.md
│ │ │ ├── tc.h
│ │ │ ├── tc_mine.cu
│ │ │ └── tc_mine_gpu.cpp
│ │ └── libminingbench/
│ │ ├── CMakeLists.txt
│ │ ├── include/
│ │ │ └── MiningBench/
│ │ │ └── Start.h
│ │ └── src/
│ │ ├── Input.cpp
│ │ └── Start.cpp
│ ├── scientific/
│ │ ├── CMakeLists.txt
│ │ ├── cpu/
│ │ │ ├── CMakeLists.txt
│ │ │ ├── barneshut/
│ │ │ │ ├── Barneshut.cpp
│ │ │ │ ├── CMakeLists.txt
│ │ │ │ ├── Point.h
│ │ │ │ └── README.md
│ │ │ ├── delaunayrefinement/
│ │ │ │ ├── CMakeLists.txt
│ │ │ │ ├── Cavity.h
│ │ │ │ ├── DelaunayRefinement.cpp
│ │ │ │ ├── Edge.h
│ │ │ │ ├── Element.h
│ │ │ │ ├── Mesh.h
│ │ │ │ ├── README.md
│ │ │ │ ├── Subgraph.h
│ │ │ │ ├── Tuple.h
│ │ │ │ └── Verifier.h
│ │ │ ├── delaunaytriangulation/
│ │ │ │ ├── CMakeLists.txt
│ │ │ │ ├── Cavity.h
│ │ │ │ ├── DelaunayTriangulation.cpp
│ │ │ │ ├── DelaunayTriangulationDet.cpp
│ │ │ │ ├── Element.cpp
│ │ │ │ ├── Element.h
│ │ │ │ ├── Graph.h
│ │ │ │ ├── Point.h
│ │ │ │ ├── QuadTree.h
│ │ │ │ ├── README.md
│ │ │ │ ├── Tuple.h
│ │ │ │ └── Verifier.h
│ │ │ └── longestedge/
│ │ │ ├── CMakeLists.txt
│ │ │ ├── README.md
│ │ │ ├── out/
│ │ │ │ └── .gitignore
│ │ │ ├── src/
│ │ │ │ ├── LongestEdge.cpp
│ │ │ │ ├── conditions/
│ │ │ │ │ ├── ConditionChecker.h
│ │ │ │ │ ├── DummyConditionChecker.h
│ │ │ │ │ └── TerrainConditionChecker.h
│ │ │ │ ├── libmgrs/
│ │ │ │ │ ├── LICENSE
│ │ │ │ │ ├── mgrs.c
│ │ │ │ │ ├── mgrs.h
│ │ │ │ │ ├── polarst.c
│ │ │ │ │ ├── polarst.h
│ │ │ │ │ ├── tranmerc.c
│ │ │ │ │ ├── tranmerc.h
│ │ │ │ │ ├── ups.c
│ │ │ │ │ ├── ups.h
│ │ │ │ │ ├── utm.c
│ │ │ │ │ └── utm.h
│ │ │ │ ├── model/
│ │ │ │ │ ├── Coordinates.h
│ │ │ │ │ ├── EdgeData.h
│ │ │ │ │ ├── Graph.h
│ │ │ │ │ ├── Map.cpp
│ │ │ │ │ ├── Map.h
│ │ │ │ │ ├── NodeData.h
│ │ │ │ │ └── ProductionState.h
│ │ │ │ ├── productions/
│ │ │ │ │ ├── Production.h
│ │ │ │ │ ├── Production1.h
│ │ │ │ │ ├── Production2.h
│ │ │ │ │ ├── Production3.h
│ │ │ │ │ ├── Production4.h
│ │ │ │ │ ├── Production5.h
│ │ │ │ │ └── Production6.h
│ │ │ │ ├── readers/
│ │ │ │ │ ├── AsciiReader.cpp
│ │ │ │ │ ├── AsciiReader.h
│ │ │ │ │ ├── InpReader.cpp
│ │ │ │ │ ├── InpReader.h
│ │ │ │ │ ├── SrtmReader.cpp
│ │ │ │ │ └── SrtmReader.h
│ │ │ │ ├── utils/
│ │ │ │ │ ├── ConnectivityManager.h
│ │ │ │ │ ├── GaloisUtils.h
│ │ │ │ │ ├── GraphGenerator.h
│ │ │ │ │ ├── MyGraphFormatWriter.h
│ │ │ │ │ ├── Utils.cpp
│ │ │ │ │ └── Utils.h
│ │ │ │ └── writers/
│ │ │ │ ├── InpWriter.cpp
│ │ │ │ ├── InpWriter.h
│ │ │ │ ├── TriangleFormatWriter.cpp
│ │ │ │ └── TriangleFormatWriter.h
│ │ │ └── test/
│ │ │ ├── TestMain.cpp
│ │ │ ├── catch.hpp
│ │ │ ├── model/
│ │ │ │ ├── MapTest.cpp
│ │ │ │ └── ProductionStateTest.cpp
│ │ │ ├── productions/
│ │ │ │ └── Production1Test.cpp
│ │ │ ├── testUtils.cpp
│ │ │ └── utils/
│ │ │ ├── ConnectivityManagerTest.cpp
│ │ │ └── UtilsTest.cpp
│ │ └── gpu/
│ │ ├── CMakeLists.txt
│ │ ├── README.md
│ │ ├── barneshut/
│ │ │ ├── CMakeLists.txt
│ │ │ ├── LICENSE.md
│ │ │ ├── README.md
│ │ │ ├── bh.cu
│ │ │ └── bh_tuning.h
│ │ └── delaunayrefinement/
│ │ ├── CMakeLists.txt
│ │ ├── README.md
│ │ ├── devel.h
│ │ ├── dmr-nontex.cu
│ │ ├── dmr.cu
│ │ ├── dmr.h
│ │ ├── dmrggc.inc
│ │ ├── geomprim.h
│ │ ├── main.inc
│ │ └── meshfiles.h
│ └── tutorial_examples/
│ ├── CMakeLists.txt
│ ├── ConflictAwareTorus.cpp
│ ├── CountLevels.cpp
│ ├── ExampleWrappedWorklist.cpp
│ ├── GraphTraversalPullOperator.cpp
│ ├── GraphTraversalPushOperator.cpp
│ ├── GraphTraversalSerial.cpp
│ ├── HelloWorld.cpp
│ ├── SSSPPullSimple.cpp
│ ├── SSSPPushSimple.cpp
│ ├── SSSPsimple.cpp
│ ├── SpanningTree.cpp
│ ├── ThirdPartyMalloc.cpp
│ ├── Torus.cpp
│ ├── TorusConstruction.cpp
│ └── TorusImproved.cpp
├── pyproject.toml
├── python/
│ ├── CMakeLists.txt
│ └── galois/
│ ├── CMakeLists.txt
│ ├── __init__.py
│ ├── _bfs.pyx
│ ├── _connected_components.pyx
│ ├── _pagerank.pyx
│ ├── _sssp.pyx
│ ├── bfs.py
│ ├── connected_components.py
│ ├── cpp/
│ │ ├── __init__.pxd
│ │ ├── libgalois/
│ │ │ ├── Galois.pxd
│ │ │ ├── Timer.pxd
│ │ │ ├── Worklist.pxd
│ │ │ ├── __init__.pxd
│ │ │ └── graphs/
│ │ │ ├── Graph.pxd
│ │ │ ├── Util.pxd
│ │ │ └── __init__.pxd
│ │ └── libstd/
│ │ ├── __init__.pxd
│ │ └── atomic.pxd
│ ├── pagerank.py
│ ├── shmem.pxd
│ └── shmem.pyx
├── scripts/
│ ├── CMakeLists.txt
│ ├── abelian_log_parser.py
│ ├── check_format.sh
│ ├── constraints_checking/
│ │ └── parse_dump.rb
│ ├── docker/
│ │ ├── Dockerfile
│ │ ├── Dockerfile.msan
│ │ ├── README.md
│ │ ├── msan/
│ │ │ ├── build-boost.sh
│ │ │ ├── build-llvm.sh
│ │ │ └── config-galois.sh
│ │ └── run-image.sh
│ ├── experimental/
│ │ ├── abelian_log_parser_analysis.py
│ │ ├── abelian_log_parser_deprecated.py
│ │ ├── abelian_log_parser_multipleRuns.py
│ │ ├── abelian_log_parser_multipleRuns2.py
│ │ ├── bmk2/
│ │ │ ├── __init__.py
│ │ │ ├── bispec.py
│ │ │ ├── bmk2.py
│ │ │ ├── checkers.py
│ │ │ ├── collect.py
│ │ │ ├── collect_multi.py
│ │ │ ├── common.py
│ │ │ ├── config.py
│ │ │ ├── convert.py
│ │ │ ├── convgraph.py
│ │ │ ├── core.py
│ │ │ ├── extras.py
│ │ │ ├── inputdb.py
│ │ │ ├── inputprops.py
│ │ │ ├── logproc.py
│ │ │ ├── mapfile.py
│ │ │ ├── measure_energy.py
│ │ │ ├── opdb.py
│ │ │ ├── overlays.py
│ │ │ ├── perf.py
│ │ │ ├── rsinfo.py
│ │ │ ├── sconvert.py
│ │ │ ├── summlog.py
│ │ │ └── test2.py
│ │ ├── buildFunc.sh
│ │ ├── buildMultiCompiler.sh
│ │ ├── buildMultiVersion.sh
│ │ ├── buildOnce.sh
│ │ ├── distbmk2/
│ │ │ ├── README
│ │ │ ├── bmk2.cfg
│ │ │ ├── bmkprops.py
│ │ │ ├── bmktest2.py
│ │ │ ├── dist.bispec
│ │ │ ├── dist.inputdb
│ │ │ └── dist.inputprops
│ │ ├── galois_license_fixer.py
│ │ ├── githubbmk2_setup/
│ │ │ ├── README
│ │ │ ├── bmk2.cfg
│ │ │ ├── bmkprops.py
│ │ │ ├── bmktest2.py
│ │ │ ├── defaultrunscript.sh
│ │ │ ├── lonestar.bispec
│ │ │ ├── lonestar.inputdb
│ │ │ └── lonestar.inputprops
│ │ ├── heterogeneousGalois/
│ │ │ ├── CPU_run_scripts_stampede/
│ │ │ │ ├── ruby_BFS_CC_SSSP_rmat_USA_twitter_Pull.sh
│ │ │ │ ├── ruby_BFS_CC_SSSP_rmat_USA_twitter_Pull_Vcut.sh
│ │ │ │ ├── ruby_BFS_CC_SSSP_rmat_USA_twitter_Push.sh
│ │ │ │ └── ruby_BFS_CC_SSSP_rmat_USA_twitter_Push_Vcut.sh
│ │ │ ├── README_compiler
│ │ │ ├── batch_bridges_all.sh
│ │ │ ├── batch_single-host_multi-device_all.sh
│ │ │ ├── batch_stampede_all.sh
│ │ │ ├── batch_verify.sh
│ │ │ ├── compile.sh
│ │ │ ├── compile_all.sh
│ │ │ ├── cuda_compile.sh
│ │ │ ├── run_bridges.template.sbatch
│ │ │ ├── run_bridges_all.sh
│ │ │ ├── run_single-host_multi-device_all.sh
│ │ │ ├── run_stampede.template.sbatch
│ │ │ ├── run_stampede_all.sh
│ │ │ └── verify.sh
│ │ ├── lonestarbmk2/
│ │ │ ├── README
│ │ │ ├── bmk2.cfg
│ │ │ ├── bmkprops.py
│ │ │ ├── bmktest2.py
│ │ │ ├── defaultrunscript.sh
│ │ │ ├── lonestar.bispec
│ │ │ ├── lonestar.inputdb
│ │ │ └── lonestar.inputprops
│ │ ├── older/
│ │ │ ├── backend.pl
│ │ │ ├── prune_headers_function.pl
│ │ │ ├── prune_headers_line.pl
│ │ │ ├── report.pl
│ │ │ ├── report_vtune.pl
│ │ │ ├── run_boruvka.pl
│ │ │ ├── run_clustering.pl
│ │ │ ├── run_delaunayrefinement.pl
│ │ │ ├── run_sssp.pl
│ │ │ └── vtune_sssp.pl
│ │ ├── pangolin/
│ │ │ ├── batch_verify.sh
│ │ │ ├── fsm.citeseer.2.300
│ │ │ ├── fsm.citeseer.2.500
│ │ │ ├── fsm.patent.2.1000
│ │ │ ├── fsm.patent.2.300
│ │ │ ├── fsm.patent.2.500
│ │ │ ├── fsm.patent.2.5000
│ │ │ ├── kcl.citeseer.4
│ │ │ ├── kcl.citeseer.5
│ │ │ ├── kcl.mico.4
│ │ │ ├── kcl.mico.5
│ │ │ ├── kcl.patent.3
│ │ │ ├── kcl.patent.4
│ │ │ ├── kcl.patent.5
│ │ │ ├── motif.citeseer.3
│ │ │ ├── motif.citeseer.4
│ │ │ ├── motif.mico.3
│ │ │ ├── motif.mico.4
│ │ │ ├── motif.patent.3
│ │ │ ├── motif.patent.4
│ │ │ ├── result_checker.py
│ │ │ └── verify.sh
│ │ ├── runBFS.sh
│ │ └── runSSSP.sh
│ ├── find_ifdefs.sh
│ ├── galois_log_parser.R
│ ├── galois_log_parser_minimal.R
│ ├── gitFindBigCommits.sh
│ ├── hcompiler.sh
│ ├── intel_study_scripts/
│ │ ├── README.md
│ │ ├── download_inputs.sh
│ │ ├── run_bc.sh
│ │ ├── run_bfs.sh
│ │ ├── run_cc.sh
│ │ ├── run_pr.sh
│ │ ├── run_sssp.sh
│ │ └── run_tc.sh
│ ├── iss_load_modules.sh
│ ├── make_dist.sh.in
│ ├── merge_vtune.pl
│ ├── plot_lonestar_apps.R
│ ├── quick_plot.pl
│ ├── rcat.py
│ ├── report.py
│ ├── report_vtune.pl
│ ├── result_checker.py
│ ├── run.py
│ ├── run_vtune.pl
│ ├── sparse-matrices/
│ │ ├── diff_edgelists.py
│ │ ├── iperm2order.pl
│ │ ├── mtx2edgelist.pl
│ │ └── reorder.pl
│ ├── tcp_starter.py
│ ├── visual/
│ │ ├── plot2Dmesh.m
│ │ ├── plotGraph.R
│ │ ├── plotGraph3d.R
│ │ ├── plotTimeStamps.m
│ │ └── triplot.m
│ └── vtune.sh
├── setup.py
├── tests/
│ └── test_imports.py
└── tools/
├── CMakeLists.txt
├── dist-graph-convert/
│ ├── CMakeLists.txt
│ ├── dist-graph-convert-helpers.cpp
│ ├── dist-graph-convert-helpers.h
│ └── dist-graph-convert.cpp
├── graph-convert/
│ ├── CMakeLists.txt
│ ├── graph-convert-huge.cpp
│ ├── graph-convert.cpp
│ └── test-inputs/
│ ├── sample.csv
│ ├── with-blank-lines.edgelist
│ ├── with-blank-lines.edgelist.expected
│ ├── with-comments.edgelist
│ └── with-comments.edgelist.expected
├── graph-remap/
│ ├── CMakeLists.txt
│ └── graph-remap.cpp
└── graph-stats/
├── CMakeLists.txt
└── graph-stats.cpp
Copy disabled (too large)
Download .txt
Showing preview only (379,598K chars total). Download the full file to get everything.
SYMBOL INDEX (7139 symbols across 560 files)
FILE: external/bliss/bliss/abgraph.hh
type bliss (line 11) | namespace bliss {
class AbstractGraph (line 12) | class AbstractGraph
method AbstractGraph (line 148) | AbstractGraph() {
method set_verbose_level (line 189) | void set_verbose_level(const unsigned int level) {
method set_verbose_file (line 198) | void set_verbose_file(FILE* const fp) {
method is_automorphism (line 225) | virtual bool is_automorphism(const std::vector<unsigned int>& perm) ...
method set_failure_recording (line 235) | void set_failure_recording(const bool active) {assert(!in_search); o...
method set_component_recursion (line 246) | void set_component_recursion(const bool active) {assert(!in_search);...
method find_automorphisms (line 279) | void find_automorphisms(Stats& stats, void (*hook)(void *user_param,...
method set_long_prune_activity (line 354) | void set_long_prune_activity(const bool active) {
method cert_add (line 405) | void cert_add(const unsigned int v1, const unsigned int v2, const un...
method cert_add_redundant (line 464) | void cert_add_redundant(const unsigned int v1, const unsigned int v2...
method long_prune_init (line 507) | void long_prune_init() {
method long_prune_deallocate (line 527) | void long_prune_deallocate() {
method long_prune_swap (line 538) | void long_prune_swap(const unsigned int i, const unsigned int j) {
method long_prune_add_automorphism (line 571) | void long_prune_add_automorphism(const unsigned int* aut) {
method refine_to_equitable (line 609) | void refine_to_equitable() {
method refine_to_equitable (line 616) | void refine_to_equitable(Partition::Cell* const unit_cell) {
method refine_to_equitable (line 621) | void refine_to_equitable(Partition::Cell* const unit_cell1, Partitio...
method do_refine_to_equitable (line 632) | bool do_refine_to_equitable() {
method update_labeling (line 692) | void update_labeling(unsigned int* const labeling) {
method update_labeling_and_its_inverse (line 703) | void update_labeling_and_its_inverse(unsigned int* const labeling, u...
method update_orbit_information (line 715) | void update_orbit_information(Orbit &o, const unsigned int *perm) {
method reset_permutation (line 726) | void reset_permutation(unsigned int* perm) {
method is_automorphism (line 732) | virtual bool is_automorphism(unsigned int* const perm) {
class CR_CEP (line 760) | class CR_CEP {
function fatal_error (line 25) | void fatal_error(const char* fmt, ...) {
class TreeNode (line 40) | class TreeNode {
class Stats (line 80) | class Stats {
method reset (line 100) | void reset() {
method Stats (line 111) | Stats() { reset(); }
method print (line 113) | size_t print(FILE* const fp) const {
method get_group_size_approx (line 127) | long double get_group_size_approx() const {return group_size_approx;}
method get_nof_nodes (line 129) | long unsigned int get_nof_nodes() const {return nof_nodes;}
method get_nof_leaf_nodes (line 131) | long unsigned int get_nof_leaf_nodes() const {return nof_leaf_nodes;}
method get_nof_bad_nodes (line 133) | long unsigned int get_nof_bad_nodes() const {return nof_bad_nodes;}
method get_nof_canupdates (line 135) | long unsigned int get_nof_canupdates() const {return nof_canupdates;}
method get_nof_generators (line 137) | long unsigned int get_nof_generators() const {return nof_generators;}
method get_max_level (line 139) | unsigned long int get_max_level() const {return max_level;}
class AbstractGraph (line 143) | class AbstractGraph {
method AbstractGraph (line 148) | AbstractGraph() {
method set_verbose_level (line 189) | void set_verbose_level(const unsigned int level) {
method set_verbose_file (line 198) | void set_verbose_file(FILE* const fp) {
method is_automorphism (line 225) | virtual bool is_automorphism(const std::vector<unsigned int>& perm) ...
method set_failure_recording (line 235) | void set_failure_recording(const bool active) {assert(!in_search); o...
method set_component_recursion (line 246) | void set_component_recursion(const bool active) {assert(!in_search);...
method find_automorphisms (line 279) | void find_automorphisms(Stats& stats, void (*hook)(void *user_param,...
method set_long_prune_activity (line 354) | void set_long_prune_activity(const bool active) {
method cert_add (line 405) | void cert_add(const unsigned int v1, const unsigned int v2, const un...
method cert_add_redundant (line 464) | void cert_add_redundant(const unsigned int v1, const unsigned int v2...
method long_prune_init (line 507) | void long_prune_init() {
method long_prune_deallocate (line 527) | void long_prune_deallocate() {
method long_prune_swap (line 538) | void long_prune_swap(const unsigned int i, const unsigned int j) {
method long_prune_add_automorphism (line 571) | void long_prune_add_automorphism(const unsigned int* aut) {
method refine_to_equitable (line 609) | void refine_to_equitable() {
method refine_to_equitable (line 616) | void refine_to_equitable(Partition::Cell* const unit_cell) {
method refine_to_equitable (line 621) | void refine_to_equitable(Partition::Cell* const unit_cell1, Partitio...
method do_refine_to_equitable (line 632) | bool do_refine_to_equitable() {
method update_labeling (line 692) | void update_labeling(unsigned int* const labeling) {
method update_labeling_and_its_inverse (line 703) | void update_labeling_and_its_inverse(unsigned int* const labeling, u...
method update_orbit_information (line 715) | void update_orbit_information(Orbit &o, const unsigned int *perm) {
method reset_permutation (line 726) | void reset_permutation(unsigned int* perm) {
method is_automorphism (line 732) | virtual bool is_automorphism(unsigned int* const perm) {
class CR_CEP (line 760) | class CR_CEP {
type bliss (line 23) | namespace bliss {
class AbstractGraph (line 12) | class AbstractGraph
method AbstractGraph (line 148) | AbstractGraph() {
method set_verbose_level (line 189) | void set_verbose_level(const unsigned int level) {
method set_verbose_file (line 198) | void set_verbose_file(FILE* const fp) {
method is_automorphism (line 225) | virtual bool is_automorphism(const std::vector<unsigned int>& perm) ...
method set_failure_recording (line 235) | void set_failure_recording(const bool active) {assert(!in_search); o...
method set_component_recursion (line 246) | void set_component_recursion(const bool active) {assert(!in_search);...
method find_automorphisms (line 279) | void find_automorphisms(Stats& stats, void (*hook)(void *user_param,...
method set_long_prune_activity (line 354) | void set_long_prune_activity(const bool active) {
method cert_add (line 405) | void cert_add(const unsigned int v1, const unsigned int v2, const un...
method cert_add_redundant (line 464) | void cert_add_redundant(const unsigned int v1, const unsigned int v2...
method long_prune_init (line 507) | void long_prune_init() {
method long_prune_deallocate (line 527) | void long_prune_deallocate() {
method long_prune_swap (line 538) | void long_prune_swap(const unsigned int i, const unsigned int j) {
method long_prune_add_automorphism (line 571) | void long_prune_add_automorphism(const unsigned int* aut) {
method refine_to_equitable (line 609) | void refine_to_equitable() {
method refine_to_equitable (line 616) | void refine_to_equitable(Partition::Cell* const unit_cell) {
method refine_to_equitable (line 621) | void refine_to_equitable(Partition::Cell* const unit_cell1, Partitio...
method do_refine_to_equitable (line 632) | bool do_refine_to_equitable() {
method update_labeling (line 692) | void update_labeling(unsigned int* const labeling) {
method update_labeling_and_its_inverse (line 703) | void update_labeling_and_its_inverse(unsigned int* const labeling, u...
method update_orbit_information (line 715) | void update_orbit_information(Orbit &o, const unsigned int *perm) {
method reset_permutation (line 726) | void reset_permutation(unsigned int* perm) {
method is_automorphism (line 732) | virtual bool is_automorphism(unsigned int* const perm) {
class CR_CEP (line 760) | class CR_CEP {
function fatal_error (line 25) | void fatal_error(const char* fmt, ...) {
class TreeNode (line 40) | class TreeNode {
class Stats (line 80) | class Stats {
method reset (line 100) | void reset() {
method Stats (line 111) | Stats() { reset(); }
method print (line 113) | size_t print(FILE* const fp) const {
method get_group_size_approx (line 127) | long double get_group_size_approx() const {return group_size_approx;}
method get_nof_nodes (line 129) | long unsigned int get_nof_nodes() const {return nof_nodes;}
method get_nof_leaf_nodes (line 131) | long unsigned int get_nof_leaf_nodes() const {return nof_leaf_nodes;}
method get_nof_bad_nodes (line 133) | long unsigned int get_nof_bad_nodes() const {return nof_bad_nodes;}
method get_nof_canupdates (line 135) | long unsigned int get_nof_canupdates() const {return nof_canupdates;}
method get_nof_generators (line 137) | long unsigned int get_nof_generators() const {return nof_generators;}
method get_max_level (line 139) | unsigned long int get_max_level() const {return max_level;}
class AbstractGraph (line 143) | class AbstractGraph {
method AbstractGraph (line 148) | AbstractGraph() {
method set_verbose_level (line 189) | void set_verbose_level(const unsigned int level) {
method set_verbose_file (line 198) | void set_verbose_file(FILE* const fp) {
method is_automorphism (line 225) | virtual bool is_automorphism(const std::vector<unsigned int>& perm) ...
method set_failure_recording (line 235) | void set_failure_recording(const bool active) {assert(!in_search); o...
method set_component_recursion (line 246) | void set_component_recursion(const bool active) {assert(!in_search);...
method find_automorphisms (line 279) | void find_automorphisms(Stats& stats, void (*hook)(void *user_param,...
method set_long_prune_activity (line 354) | void set_long_prune_activity(const bool active) {
method cert_add (line 405) | void cert_add(const unsigned int v1, const unsigned int v2, const un...
method cert_add_redundant (line 464) | void cert_add_redundant(const unsigned int v1, const unsigned int v2...
method long_prune_init (line 507) | void long_prune_init() {
method long_prune_deallocate (line 527) | void long_prune_deallocate() {
method long_prune_swap (line 538) | void long_prune_swap(const unsigned int i, const unsigned int j) {
method long_prune_add_automorphism (line 571) | void long_prune_add_automorphism(const unsigned int* aut) {
method refine_to_equitable (line 609) | void refine_to_equitable() {
method refine_to_equitable (line 616) | void refine_to_equitable(Partition::Cell* const unit_cell) {
method refine_to_equitable (line 621) | void refine_to_equitable(Partition::Cell* const unit_cell1, Partitio...
method do_refine_to_equitable (line 632) | bool do_refine_to_equitable() {
method update_labeling (line 692) | void update_labeling(unsigned int* const labeling) {
method update_labeling_and_its_inverse (line 703) | void update_labeling_and_its_inverse(unsigned int* const labeling, u...
method update_orbit_information (line 715) | void update_orbit_information(Orbit &o, const unsigned int *perm) {
method reset_permutation (line 726) | void reset_permutation(unsigned int* perm) {
method is_automorphism (line 732) | virtual bool is_automorphism(unsigned int* const perm) {
class CR_CEP (line 760) | class CR_CEP {
FILE: external/bliss/bliss/bignum.hh
type bliss (line 31) | namespace bliss {
class BigNum (line 44) | class BigNum
method BigNum (line 51) | BigNum() {mpz_init(v); }
method assign (line 61) | void assign(const int n) {mpz_set_si(v, n); }
method multiply (line 66) | void multiply(const int n) {mpz_mul_si(v, v, n); }
method print (line 71) | size_t print(FILE* const fp) const {return mpz_out_str(fp, 10, v); }
method BigNum (line 83) | BigNum(): v(0.0) {}
method assign (line 88) | void assign(const int n) {v = (long double)n; }
method multiply (line 93) | void multiply(const int n) {v *= (long double)n; }
method print (line 98) | size_t print(FILE* const fp) const {return fprintf(fp, "%Lg", v); }
class BigNum (line 76) | class BigNum
method BigNum (line 51) | BigNum() {mpz_init(v); }
method assign (line 61) | void assign(const int n) {mpz_set_si(v, n); }
method multiply (line 66) | void multiply(const int n) {mpz_mul_si(v, v, n); }
method print (line 71) | size_t print(FILE* const fp) const {return mpz_out_str(fp, 10, v); }
method BigNum (line 83) | BigNum(): v(0.0) {}
method assign (line 88) | void assign(const int n) {v = (long double)n; }
method multiply (line 93) | void multiply(const int n) {v *= (long double)n; }
method print (line 98) | size_t print(FILE* const fp) const {return fprintf(fp, "%Lg", v); }
FILE: external/bliss/bliss/defs.hh
type bliss (line 26) | namespace bliss {
FILE: external/bliss/bliss/graph.hh
function is_permutation (line 15) | static bool is_permutation(const unsigned int N, const unsigned int* per...
function is_permutation (line 26) | static bool is_permutation(const std::vector<unsigned int>& perm) {
class Graph (line 41) | class Graph : public AbstractGraph {
class Vertex (line 77) | class Vertex {
method Vertex (line 79) | Vertex() { color = 0;}
method add_edge (line 82) | void add_edge(const unsigned other_vertex, Index index) {
method sort_edges_rstream (line 130) | void sort_edges_rstream() { sort_edges(); }
method sort_edges (line 134) | void sort_edges() {
method remove_duplicate_edges (line 138) | void remove_duplicate_edges() {
method vertex_color_invariant (line 152) | static unsigned int vertex_color_invariant(const Graph* const g, con...
method degree_invariant (line 162) | static unsigned int degree_invariant(const Graph* const g, const uns...
method selfloop_invariant (line 172) | static unsigned selfloop_invariant(const Graph* const g, const unsig...
method refine_according_to_invariant (line 185) | bool refine_according_to_invariant(unsigned int (*inv)(const Graph* ...
method split_neighbourhood_of_cell (line 209) | bool split_neighbourhood_of_cell(Partition::Cell* const cell) {
method split_neighbourhood_of_unit_cell (line 304) | bool split_neighbourhood_of_unit_cell(Partition::Cell* const unit_ce...
method make_initial_equitable_partition (line 446) | void make_initial_equitable_partition() {
method is_equitable (line 463) | bool is_equitable() const {
method initialize_certificate (line 681) | void initialize_certificate() {
method is_automorphism (line 687) | bool is_automorphism(unsigned* const perm) {
method nucr_find_first_component (line 718) | bool nucr_find_first_component(const unsigned level) {
method nucr_find_first_component (line 780) | bool nucr_find_first_component(const unsigned int level, std::vector...
method Graph (line 916) | Graph(const unsigned nof_vertices = 0) {
method Graph (line 940) | static Graph* read_dimacs(FILE* const fp, FILE* const errstr = stder...
method write_dimacs (line 947) | void write_dimacs(FILE* const fp) {}
method write_dot (line 950) | void write_dot(FILE* const fp) {}
method write_dot (line 953) | void write_dot(const char* const file_name) {}
method is_automorphism (line 956) | bool is_automorphism(const std::vector<unsigned>& perm) const {
method get_hash (line 983) | virtual unsigned get_hash() {
method get_nof_vertices (line 1009) | unsigned int get_nof_vertices() const {return vertices.size(); }
method Graph (line 1012) | Graph* permute(const unsigned* perm) const {
method Graph (line 1035) | Graph* permute(const std::vector<unsigned>& perm) const {
method add_vertex (line 1057) | unsigned add_vertex(const unsigned color = 0) {
method add_edge (line 1069) | void add_edge(const unsigned vertex1, const unsigned vertex2, Index ...
method change_color (line 1080) | void change_color(const unsigned vertex, const unsigned color) {
method cmp (line 1089) | int cmp(Graph& other) {
method set_splitting_heuristic (line 1142) | void set_splitting_heuristic(const SplittingHeuristic shs) {sh = shs; }
FILE: external/bliss/bliss/heap.hh
type bliss (line 6) | namespace bliss {
class Heap (line 10) | class Heap {
method upheap (line 15) | void upheap(unsigned int index) {
method downheap (line 25) | void downheap(unsigned int index) {
method Heap (line 45) | Heap() {array = 0; n = 0; N = 0; }
method init (line 58) | void init(const unsigned int size) {
method is_empty (line 69) | bool is_empty() const { return (n==0); }
method clear (line 75) | void clear() { n = 0; }
method insert (line 83) | void insert(const unsigned int v) {
method remove (line 94) | unsigned int remove() {
method size (line 104) | unsigned int size() const {return n; }
FILE: external/bliss/bliss/kqueue.hh
type bliss (line 25) | namespace bliss {
class KQueue (line 32) | class KQueue
function Type (line 126) | Type KQueue<Type>::front() const
function Type (line 132) | Type KQueue<Type>::pop_front()
FILE: external/bliss/bliss/kstack.hh
type bliss (line 26) | namespace bliss {
class KStack (line 32) | class KStack {
method is_empty (line 55) | bool is_empty() const {return(cursor == entries); }
method Type (line 60) | Type top() const {BLISS_ASSERT(cursor > entries); return *cursor; }
method Type (line 65) | Type pop()
method push (line 73) | void push(Type e)
method clean (line 79) | void clean() {cursor = entries; }
method size (line 84) | unsigned int size() const {return(cursor - entries); }
method Type (line 91) | Type element_at(unsigned int i)
method capacity (line 98) | int capacity() {return kapacity; }
FILE: external/bliss/bliss/orbit.hh
type bliss (line 4) | namespace bliss {
class Orbit (line 5) | class Orbit {
class OrbitEntry (line 6) | class OrbitEntry {
method merge_orbits (line 16) | void merge_orbits(OrbitEntry *orbit1, OrbitEntry *orbit2) {
method Orbit (line 47) | Orbit() {
method init (line 68) | void init(const unsigned int n) {
method reset (line 80) | void reset() {
method merge_orbits (line 95) | void merge_orbits(unsigned int e1, unsigned int e2) {
method is_minimal_representative (line 101) | bool is_minimal_representative(unsigned element) const {
method get_minimal_representative (line 106) | unsigned get_minimal_representative(unsigned element) const {
method orbit_size (line 113) | unsigned orbit_size(unsigned element) const {
method nof_orbits (line 118) | unsigned int nof_orbits() const {return _nof_orbits; }
FILE: external/bliss/bliss/partition.hh
type bliss (line 23) | namespace bliss {
class Partition (line 24) | class Partition
class Cell (line 56) | class Cell
method is_unit (line 76) | bool is_unit() const {return(length == 1); }
method is_in_splitting_queue (line 78) | bool is_in_splitting_queue() const {return(in_splitting_queue); }
class RefInfo (line 88) | class RefInfo {
class BacktrackInfo (line 99) | class BacktrackInfo {
method BacktrackInfo (line 101) | BacktrackInfo() : refinement_stack_size(0), cr_backtrack_point(0) {}
method splitting_queue_add (line 121) | void splitting_queue_add(Cell* const cell) {
method splitting_queue_clear (line 130) | void splitting_queue_clear() {
method BacktrackPoint (line 142) | BacktrackPoint set_backtrack_point() {
method goto_backtrack_point (line 156) | void goto_backtrack_point(BacktrackPoint p) {
method Cell (line 232) | Cell* individualize(Cell * const cell, const unsigned int element) {
method is_unit (line 76) | bool is_unit() const {return(length == 1); }
method is_in_splitting_queue (line 78) | bool is_in_splitting_queue() const {return(in_splitting_queue); }
method Cell (line 245) | Cell* aux_split_in_two(Cell* const cell, const unsigned int first_ha...
method is_unit (line 76) | bool is_unit() const {return(length == 1); }
method is_in_splitting_queue (line 78) | bool is_in_splitting_queue() const {return(in_splitting_queue); }
method Cell (line 323) | Cell* get_cell(const unsigned int e) const {
method is_unit (line 76) | bool is_unit() const {return(length == 1); }
method is_in_splitting_queue (line 78) | bool is_in_splitting_queue() const {return(in_splitting_queue); }
method Partition (line 331) | Partition() {
method init (line 364) | void init(const unsigned int M) {
method is_discrete (line 447) | bool is_discrete() const {return(free_cells == 0); }
method nof_discrete_cells (line 449) | unsigned int nof_discrete_cells() const {return(discrete_cell_count); }
method print (line 455) | size_t print(FILE* const fp, const bool add_newline = true) const {
method print_signature (line 481) | size_t print_signature(FILE* const fp, const bool add_newline = true...
method Cell (line 510) | Cell* zplit_cell(Cell* const cell, const bool max_ival_info_ok) {
method is_unit (line 76) | bool is_unit() const {return(length == 1); }
method is_in_splitting_queue (line 78) | bool is_in_splitting_queue() const {return(in_splitting_queue); }
method cr_init (line 600) | void cr_init() {
method cr_free (line 625) | void cr_free() {
method cr_split_level (line 635) | unsigned int cr_split_level(const unsigned int level, const std::vec...
method clear_ivs (line 653) | void clear_ivs(Cell* const cell) {
class CRCell (line 667) | class CRCell {
method detach (line 672) | void detach() {
class CR_BTInfo (line 683) | class CR_BTInfo {
method cr_create_at_level (line 697) | void cr_create_at_level(const unsigned int cell_index, const unsigne...
method cr_create_at_level_trailed (line 714) | void cr_create_at_level_trailed(const unsigned int cell_index, const...
method cr_get_backtrack_point (line 720) | unsigned int cr_get_backtrack_point() {
method cr_goto_backtrack_point (line 730) | void cr_goto_backtrack_point(const unsigned int btpoint) {
method Cell (line 765) | Cell* sort_and_split_cell1(Cell* const cell) {
method is_unit (line 76) | bool is_unit() const {return(length == 1); }
method is_in_splitting_queue (line 78) | bool is_in_splitting_queue() const {return(in_splitting_queue); }
method shellsort_cell (line 969) | bool shellsort_cell(Cell* const cell) {
method Cell (line 1013) | Cell* sort_and_split_cell255(Cell* const cell, const unsigned int ma...
method is_unit (line 76) | bool is_unit() const {return(length == 1); }
method is_in_splitting_queue (line 78) | bool is_in_splitting_queue() const {return(in_splitting_queue); }
method dcs_cumulate_count (line 1108) | void dcs_cumulate_count(const unsigned int max) {
class Partition (line 50) | class Partition
class Cell (line 56) | class Cell
method is_unit (line 76) | bool is_unit() const {return(length == 1); }
method is_in_splitting_queue (line 78) | bool is_in_splitting_queue() const {return(in_splitting_queue); }
class RefInfo (line 88) | class RefInfo {
class BacktrackInfo (line 99) | class BacktrackInfo {
method BacktrackInfo (line 101) | BacktrackInfo() : refinement_stack_size(0), cr_backtrack_point(0) {}
method splitting_queue_add (line 121) | void splitting_queue_add(Cell* const cell) {
method splitting_queue_clear (line 130) | void splitting_queue_clear() {
method BacktrackPoint (line 142) | BacktrackPoint set_backtrack_point() {
method goto_backtrack_point (line 156) | void goto_backtrack_point(BacktrackPoint p) {
method Cell (line 232) | Cell* individualize(Cell * const cell, const unsigned int element) {
method is_unit (line 76) | bool is_unit() const {return(length == 1); }
method is_in_splitting_queue (line 78) | bool is_in_splitting_queue() const {return(in_splitting_queue); }
method Cell (line 245) | Cell* aux_split_in_two(Cell* const cell, const unsigned int first_ha...
method is_unit (line 76) | bool is_unit() const {return(length == 1); }
method is_in_splitting_queue (line 78) | bool is_in_splitting_queue() const {return(in_splitting_queue); }
method Cell (line 323) | Cell* get_cell(const unsigned int e) const {
method is_unit (line 76) | bool is_unit() const {return(length == 1); }
method is_in_splitting_queue (line 78) | bool is_in_splitting_queue() const {return(in_splitting_queue); }
method Partition (line 331) | Partition() {
method init (line 364) | void init(const unsigned int M) {
method is_discrete (line 447) | bool is_discrete() const {return(free_cells == 0); }
method nof_discrete_cells (line 449) | unsigned int nof_discrete_cells() const {return(discrete_cell_count); }
method print (line 455) | size_t print(FILE* const fp, const bool add_newline = true) const {
method print_signature (line 481) | size_t print_signature(FILE* const fp, const bool add_newline = true...
method Cell (line 510) | Cell* zplit_cell(Cell* const cell, const bool max_ival_info_ok) {
method is_unit (line 76) | bool is_unit() const {return(length == 1); }
method is_in_splitting_queue (line 78) | bool is_in_splitting_queue() const {return(in_splitting_queue); }
method cr_init (line 600) | void cr_init() {
method cr_free (line 625) | void cr_free() {
method cr_split_level (line 635) | unsigned int cr_split_level(const unsigned int level, const std::vec...
method clear_ivs (line 653) | void clear_ivs(Cell* const cell) {
class CRCell (line 667) | class CRCell {
method detach (line 672) | void detach() {
class CR_BTInfo (line 683) | class CR_BTInfo {
method cr_create_at_level (line 697) | void cr_create_at_level(const unsigned int cell_index, const unsigne...
method cr_create_at_level_trailed (line 714) | void cr_create_at_level_trailed(const unsigned int cell_index, const...
method cr_get_backtrack_point (line 720) | unsigned int cr_get_backtrack_point() {
method cr_goto_backtrack_point (line 730) | void cr_goto_backtrack_point(const unsigned int btpoint) {
method Cell (line 765) | Cell* sort_and_split_cell1(Cell* const cell) {
method is_unit (line 76) | bool is_unit() const {return(length == 1); }
method is_in_splitting_queue (line 78) | bool is_in_splitting_queue() const {return(in_splitting_queue); }
method shellsort_cell (line 969) | bool shellsort_cell(Cell* const cell) {
method Cell (line 1013) | Cell* sort_and_split_cell255(Cell* const cell, const unsigned int ma...
method is_unit (line 76) | bool is_unit() const {return(length == 1); }
method is_in_splitting_queue (line 78) | bool is_in_splitting_queue() const {return(in_splitting_queue); }
method dcs_cumulate_count (line 1108) | void dcs_cumulate_count(const unsigned int max) {
type bliss (line 38) | namespace bliss {
class Partition (line 24) | class Partition
class Cell (line 56) | class Cell
method is_unit (line 76) | bool is_unit() const {return(length == 1); }
method is_in_splitting_queue (line 78) | bool is_in_splitting_queue() const {return(in_splitting_queue); }
class RefInfo (line 88) | class RefInfo {
class BacktrackInfo (line 99) | class BacktrackInfo {
method BacktrackInfo (line 101) | BacktrackInfo() : refinement_stack_size(0), cr_backtrack_point(0) {}
method splitting_queue_add (line 121) | void splitting_queue_add(Cell* const cell) {
method splitting_queue_clear (line 130) | void splitting_queue_clear() {
method BacktrackPoint (line 142) | BacktrackPoint set_backtrack_point() {
method goto_backtrack_point (line 156) | void goto_backtrack_point(BacktrackPoint p) {
method Cell (line 232) | Cell* individualize(Cell * const cell, const unsigned int element) {
method is_unit (line 76) | bool is_unit() const {return(length == 1); }
method is_in_splitting_queue (line 78) | bool is_in_splitting_queue() const {return(in_splitting_queue); }
method Cell (line 245) | Cell* aux_split_in_two(Cell* const cell, const unsigned int first_ha...
method is_unit (line 76) | bool is_unit() const {return(length == 1); }
method is_in_splitting_queue (line 78) | bool is_in_splitting_queue() const {return(in_splitting_queue); }
method Cell (line 323) | Cell* get_cell(const unsigned int e) const {
method is_unit (line 76) | bool is_unit() const {return(length == 1); }
method is_in_splitting_queue (line 78) | bool is_in_splitting_queue() const {return(in_splitting_queue); }
method Partition (line 331) | Partition() {
method init (line 364) | void init(const unsigned int M) {
method is_discrete (line 447) | bool is_discrete() const {return(free_cells == 0); }
method nof_discrete_cells (line 449) | unsigned int nof_discrete_cells() const {return(discrete_cell_count); }
method print (line 455) | size_t print(FILE* const fp, const bool add_newline = true) const {
method print_signature (line 481) | size_t print_signature(FILE* const fp, const bool add_newline = true...
method Cell (line 510) | Cell* zplit_cell(Cell* const cell, const bool max_ival_info_ok) {
method is_unit (line 76) | bool is_unit() const {return(length == 1); }
method is_in_splitting_queue (line 78) | bool is_in_splitting_queue() const {return(in_splitting_queue); }
method cr_init (line 600) | void cr_init() {
method cr_free (line 625) | void cr_free() {
method cr_split_level (line 635) | unsigned int cr_split_level(const unsigned int level, const std::vec...
method clear_ivs (line 653) | void clear_ivs(Cell* const cell) {
class CRCell (line 667) | class CRCell {
method detach (line 672) | void detach() {
class CR_BTInfo (line 683) | class CR_BTInfo {
method cr_create_at_level (line 697) | void cr_create_at_level(const unsigned int cell_index, const unsigne...
method cr_create_at_level_trailed (line 714) | void cr_create_at_level_trailed(const unsigned int cell_index, const...
method cr_get_backtrack_point (line 720) | unsigned int cr_get_backtrack_point() {
method cr_goto_backtrack_point (line 730) | void cr_goto_backtrack_point(const unsigned int btpoint) {
method Cell (line 765) | Cell* sort_and_split_cell1(Cell* const cell) {
method is_unit (line 76) | bool is_unit() const {return(length == 1); }
method is_in_splitting_queue (line 78) | bool is_in_splitting_queue() const {return(in_splitting_queue); }
method shellsort_cell (line 969) | bool shellsort_cell(Cell* const cell) {
method Cell (line 1013) | Cell* sort_and_split_cell255(Cell* const cell, const unsigned int ma...
method is_unit (line 76) | bool is_unit() const {return(length == 1); }
method is_in_splitting_queue (line 78) | bool is_in_splitting_queue() const {return(in_splitting_queue); }
method dcs_cumulate_count (line 1108) | void dcs_cumulate_count(const unsigned int max) {
class Partition (line 50) | class Partition
class Cell (line 56) | class Cell
method is_unit (line 76) | bool is_unit() const {return(length == 1); }
method is_in_splitting_queue (line 78) | bool is_in_splitting_queue() const {return(in_splitting_queue); }
class RefInfo (line 88) | class RefInfo {
class BacktrackInfo (line 99) | class BacktrackInfo {
method BacktrackInfo (line 101) | BacktrackInfo() : refinement_stack_size(0), cr_backtrack_point(0) {}
method splitting_queue_add (line 121) | void splitting_queue_add(Cell* const cell) {
method splitting_queue_clear (line 130) | void splitting_queue_clear() {
method BacktrackPoint (line 142) | BacktrackPoint set_backtrack_point() {
method goto_backtrack_point (line 156) | void goto_backtrack_point(BacktrackPoint p) {
method Cell (line 232) | Cell* individualize(Cell * const cell, const unsigned int element) {
method is_unit (line 76) | bool is_unit() const {return(length == 1); }
method is_in_splitting_queue (line 78) | bool is_in_splitting_queue() const {return(in_splitting_queue); }
method Cell (line 245) | Cell* aux_split_in_two(Cell* const cell, const unsigned int first_ha...
method is_unit (line 76) | bool is_unit() const {return(length == 1); }
method is_in_splitting_queue (line 78) | bool is_in_splitting_queue() const {return(in_splitting_queue); }
method Cell (line 323) | Cell* get_cell(const unsigned int e) const {
method is_unit (line 76) | bool is_unit() const {return(length == 1); }
method is_in_splitting_queue (line 78) | bool is_in_splitting_queue() const {return(in_splitting_queue); }
method Partition (line 331) | Partition() {
method init (line 364) | void init(const unsigned int M) {
method is_discrete (line 447) | bool is_discrete() const {return(free_cells == 0); }
method nof_discrete_cells (line 449) | unsigned int nof_discrete_cells() const {return(discrete_cell_count); }
method print (line 455) | size_t print(FILE* const fp, const bool add_newline = true) const {
method print_signature (line 481) | size_t print_signature(FILE* const fp, const bool add_newline = true...
method Cell (line 510) | Cell* zplit_cell(Cell* const cell, const bool max_ival_info_ok) {
method is_unit (line 76) | bool is_unit() const {return(length == 1); }
method is_in_splitting_queue (line 78) | bool is_in_splitting_queue() const {return(in_splitting_queue); }
method cr_init (line 600) | void cr_init() {
method cr_free (line 625) | void cr_free() {
method cr_split_level (line 635) | unsigned int cr_split_level(const unsigned int level, const std::vec...
method clear_ivs (line 653) | void clear_ivs(Cell* const cell) {
class CRCell (line 667) | class CRCell {
method detach (line 672) | void detach() {
class CR_BTInfo (line 683) | class CR_BTInfo {
method cr_create_at_level (line 697) | void cr_create_at_level(const unsigned int cell_index, const unsigne...
method cr_create_at_level_trailed (line 714) | void cr_create_at_level_trailed(const unsigned int cell_index, const...
method cr_get_backtrack_point (line 720) | unsigned int cr_get_backtrack_point() {
method cr_goto_backtrack_point (line 730) | void cr_goto_backtrack_point(const unsigned int btpoint) {
method Cell (line 765) | Cell* sort_and_split_cell1(Cell* const cell) {
method is_unit (line 76) | bool is_unit() const {return(length == 1); }
method is_in_splitting_queue (line 78) | bool is_in_splitting_queue() const {return(in_splitting_queue); }
method shellsort_cell (line 969) | bool shellsort_cell(Cell* const cell) {
method Cell (line 1013) | Cell* sort_and_split_cell255(Cell* const cell, const unsigned int ma...
method is_unit (line 76) | bool is_unit() const {return(length == 1); }
method is_in_splitting_queue (line 78) | bool is_in_splitting_queue() const {return(in_splitting_queue); }
method dcs_cumulate_count (line 1108) | void dcs_cumulate_count(const unsigned int max) {
FILE: external/bliss/bliss/search.h
function search (line 2) | void search(const bool canonical, Stats& stats) {
FILE: external/bliss/bliss/uintseqhash.hh
type bliss (line 5) | namespace bliss {
class UintSeqHash (line 74) | class UintSeqHash {
method UintSeqHash (line 78) | UintSeqHash() {h = 0; }
method UintSeqHash (line 79) | UintSeqHash(const UintSeqHash &other) {h = other.h; }
method UintSeqHash (line 80) | UintSeqHash& operator=(const UintSeqHash &other) {h = other.h; retur...
method reset (line 82) | void reset() {h = 0; }
method update (line 84) | void update(unsigned int i) {
method get_value (line 94) | unsigned int get_value() const {return h; }
method cmp (line 98) | int cmp(const UintSeqHash &other) const {
method is_lt (line 102) | bool is_lt(const UintSeqHash &other) const {return(cmp(other) < 0); }
method is_le (line 104) | bool is_le(const UintSeqHash &other) const {return(cmp(other) <= 0); }
method is_equal (line 106) | bool is_equal(const UintSeqHash &other) const {return(cmp(other) == ...
FILE: external/bliss/bliss/utils.hh
type bliss (line 31) | namespace bliss {
FILE: libcusp/include/galois/graphs/BasePolicies.h
function namespace (line 30) | namespace galois {
function saveGID2HostInfo (line 236) | void saveGID2HostInfo(std::unordered_map<uint64_t, uint32_t>& gid2offsets,
function enterStage2 (line 271) | void enterStage2() { _status = 2; }
FILE: libcusp/include/galois/graphs/CuSPPartitioner.h
function namespace (line 34) | namespace galois {
FILE: libcusp/include/galois/graphs/DistributedGraph.h
function namespace (line 43) | namespace galois {
function virtual (line 535) | virtual bool isVertexCutImpl() const = 0;
function getHostID (line 544) | inline unsigned getHostID(uint64_t gid) const { return getHostIDImpl(gid...
function isOwned (line 547) | inline bool isOwned(uint64_t gid) const { return isOwnedImpl(gid); }
function isLocal (line 550) | inline bool isLocal(uint64_t gid) const { return isLocalImpl(gid); }
function isTransposed (line 563) | bool isTransposed() { return transposed; }
function getGID (line 571) | inline uint64_t getGID(const uint32_t nodeID) const { return L2G(nodeID); }
function getLID (line 579) | inline uint32_t getLID(const uint64_t nodeID) const { return G2L(nodeID); }
function GraphNode (line 615) | GraphNode getEdgeDst(edge_iterator ni) { return graph.getEdgeDst(ni); }
function edge_iterator (line 623) | inline edge_iterator edge_begin(GraphNode N) {
function edge_iterator (line 634) | inline edge_iterator edge_end(GraphNode N) {
function galois (line 644) | inline galois::runtime::iterable<galois::NoDerefIterator<edge_iterator>>
function NodeRangeType (line 699) | inline const NodeRangeType& allNodesRange() const {
function determineThreadRangesMaster (line 763) | inline void determineThreadRangesMaster() {
function determineThreadRangesWithEdges (line 789) | inline void determineThreadRangesWithEdges() {
function initializeSpecificRanges (line 812) | void initializeSpecificRanges() {
function edgesEqualMasters (line 846) | void edgesEqualMasters() { specificRanges[2] = specificRanges[1]; }
function read_local_graph_from_file (line 861) | void read_local_graph_from_file(std::string) {
function deallocate (line 868) | void deallocate() {
function sortEdgesByDestination (line 877) | void sortEdgesByDestination() {
FILE: libcusp/include/galois/graphs/GenericPartitioners.h
function class (line 10) | class NoCommunication : public galois::graphs::ReadMasterAssignment {
function class (line 30) | class MiningPolicyNaive : public galois::graphs::ReadMasterAssignment {
function class (line 41) | class MiningPolicyDegrees : public galois::graphs::ReadMasterAssignment {
function class (line 66) | class GenericCVC : public galois::graphs::ReadMasterAssignment {
function getEdgeOwner (line 113) | uint32_t getEdgeOwner(uint32_t, uint32_t dst, uint64_t) const {
function noCommunication (line 118) | bool noCommunication() { return false; }
function serializePartition (line 124) | void serializePartition(boost::archive::binary_oarchive& ar) {
function deserializePartition (line 128) | void deserializePartition(boost::archive::binary_iarchive& ar) {
function class (line 142) | class GenericCVCColumnFlip : public galois::graphs::ReadMasterAssignment {
function getEdgeOwner (line 188) | uint32_t getEdgeOwner(uint32_t, uint32_t dst, uint64_t) const {
function noCommunication (line 193) | bool noCommunication() { return false; }
function serializePartition (line 200) | void serializePartition(boost::archive::binary_oarchive& ar) {
function deserializePartition (line 205) | void deserializePartition(boost::archive::binary_iarchive& ar) {
function class (line 215) | class GenericHVC : public galois::graphs::ReadMasterAssignment {
function getEdgeOwner (line 226) | uint32_t getEdgeOwner(uint32_t src, uint32_t dst, uint64_t numEdges) con...
function noCommunication (line 234) | bool noCommunication() { return false; }
function serializePartition (line 237) | void serializePartition(boost::archive::binary_oarchive&) {}
function deserializePartition (line 238) | void deserializePartition(boost::archive::binary_iarchive&) {}
function class (line 246) | class GingerP : public galois::graphs::CustomMasterAssignment {
function getEdgeOwner (line 367) | uint32_t getEdgeOwner(uint32_t src, uint32_t dst, uint64_t numEdges) con...
function noCommunication (line 379) | bool noCommunication() { return false; }
function serializePartition (line 382) | void serializePartition(boost::archive::binary_oarchive&) {}
function deserializePartition (line 383) | void deserializePartition(boost::archive::binary_iarchive&) {}
function class (line 389) | class FennelP : public galois::graphs::CustomMasterAssignment {
function getEdgeOwner (line 511) | uint32_t getEdgeOwner(uint32_t src, uint32_t, uint64_t) const {
function noCommunication (line 515) | bool noCommunication() { return false; }
function serializePartition (line 518) | void serializePartition(boost::archive::binary_oarchive&) {}
function deserializePartition (line 519) | void deserializePartition(boost::archive::binary_iarchive&) {}
function class (line 525) | class SugarP : public galois::graphs::CustomMasterAssignment {
function getEdgeOwner (line 688) | uint32_t getEdgeOwner(uint32_t src, uint32_t dst, uint64_t) const {
function noCommunication (line 694) | bool noCommunication() { return false; }
function serializePartition (line 701) | void serializePartition(boost::archive::binary_oarchive& ar) {
function deserializePartition (line 706) | void deserializePartition(boost::archive::binary_iarchive& ar) {
function class (line 716) | class SugarColumnFlipP : public galois::graphs::CustomMasterAssignment {
function getEdgeOwner (line 882) | uint32_t getEdgeOwner(uint32_t src, uint32_t dst, uint64_t) const {
function noCommunication (line 888) | bool noCommunication() { return false; }
function serializePartition (line 894) | void serializePartition(boost::archive::binary_oarchive& ar) {
function deserializePartition (line 898) | void deserializePartition(boost::archive::binary_iarchive& ar) {
FILE: libcusp/include/galois/graphs/MiningPartitioner.h
function namespace (line 36) | namespace galois {
FILE: libcusp/include/galois/graphs/NewGeneric.h
function namespace (line 37) | namespace galois {
function asyncSendLoad (line 620) | void asyncSendLoad(galois::PODResizeableArray<uint64_t>& nodeAccum,
function asyncRecvLoad (line 657) | void asyncRecvLoad(std::vector<uint64_t>& nodeLoads,
function asyncSyncLoad (line 721) | void asyncSyncLoad(std::vector<uint64_t>& nodeLoads,
function printLoad (line 773) | void printLoad(std::vector<uint64_t>& loads,
function syncAssignmentSends (line 887) | void syncAssignmentSends(
function recvOffsetsAndMastersAsync (line 1028) | void recvOffsetsAndMastersAsync(
function syncAssignmentReceives (line 1087) | void
function syncAssignmentReceivesAsync (line 1113) | void syncAssignmentReceivesAsync(
function syncAssignment (line 1138) | void syncAssignment(
function syncAssignmentAsync (line 1153) | void syncAssignmentAsync(
function sendMastersToOwners (line 1178) | void sendMastersToOwners(
function recvMastersToOwners (line 1214) | void recvMastersToOwners() {
function phase0 (line 1249) | void phase0(galois::graphs::BufferedGraph<EdgeTy>& bufGraph, bool async,
function edgeInspection (line 1706) | void edgeInspection(galois::graphs::BufferedGraph<EdgeTy>& bufGraph,
function assignEdges (line 1761) | void assignEdges(galois::graphs::BufferedGraph<EdgeTy>& bufGraph,
function serializeOutgoingMasterMap (line 1847) | void
function inspectMasterNodes (line 2231) | void inspectMasterNodes(std::vector<std::vector<uint64_t>>& numOutgoingE...
function inspectOutgoingNodes (line 2341) | void
function createIntermediateMetadata (line 2442) | void
function inspectIncomingNodes (line 2464) | void inspectIncomingNodes(galois::DynamicBitSet& hasIncomingEdge,
function finalizeInspection (line 2538) | void finalizeInspection(galois::gstl::Vector<uint64_t>& prefixSumOfEdges) {
function fillMirrors (line 2562) | void fillMirrors() {
FILE: libdist/include/galois/DReducible.h
function namespace (line 36) | namespace galois {
function reduce_lwci (line 211) | inline void reduce_lwci() {
function reduce_mpi (line 219) | inline void reduce_mpi() {
function update (line 262) | void update(const Ty rhs) { mdata.update(rhs); }
function Ty (line 272) | Ty read_local() {
function Ty (line 284) | Ty read() { return global_mdata; }
function Ty (line 292) | Ty reset() {
function reduce_lwci (line 346) | inline void reduce_lwci() {
function reduce_mpi (line 354) | inline void reduce_mpi() {
function update (line 398) | void update(const Ty rhs) { mdata.update(rhs); }
function Ty (line 408) | Ty read_local() {
function Ty (line 420) | Ty read() { return global_mdata; }
function Ty (line 428) | Ty reset() {
FILE: libdist/include/galois/DTerminationDetector.h
function namespace (line 36) | namespace galois {
FILE: libdist/include/galois/DistGalois.h
function namespace (line 36) | namespace galois {
FILE: libdist/include/galois/runtime/BareMPI.h
type BareMPI (line 34) | enum BareMPI {
FILE: libdist/include/galois/runtime/DistStats.h
function namespace (line 49) | namespace galois {
FILE: libdist/include/galois/runtime/LWCI.h
function namespace (line 36) | namespace galois {
FILE: libdist/include/galois/runtime/MemUsage.h
function namespace (line 32) | namespace galois {
FILE: libdist/include/galois/runtime/Network.h
function namespace (line 40) | namespace galois::runtime {
FILE: libdist/include/galois/runtime/NetworkIO.h
function namespace (line 46) | namespace runtime {
FILE: libdist/include/galois/runtime/Serialize.h
function namespace (line 48) | namespace galois {
function gSerializeObj (line 656) | inline void gSerializeObj(SerializeBuffer& buf, const SerializeBuffer& d...
function gSerializeObj (line 666) | inline void gSerializeObj(SerializeBuffer& buf, const DeSerializeBuffer&...
function gSerializeObj (line 677) | inline void gSerializeObj(SerializeBuffer& buf,
function gSerialize (line 767) | static inline void gSerialize(SerializeBuffer&) {}
function namespace (line 773) | namespace internal {
type typename (line 950) | typedef typename Seq::value_type T;
function gDeserializeObj (line 1020) | inline void gDeserializeObj(DeSerializeBuffer& buf,
function gDeserialize (line 1042) | inline void gDeserialize(DeSerializeBuffer&) {}
FILE: libdist/src/Barrier.cpp
class HostFence (line 44) | class HostFence : public galois::substrate::Barrier {
method reinit (line 48) | virtual void reinit(unsigned) {}
method wait (line 52) | virtual void wait() {
class HostBarrier (line 91) | class HostBarrier : public galois::substrate::Barrier {
method reinit (line 95) | virtual void reinit(unsigned) {}
method wait (line 98) | virtual void wait() {
FILE: libdist/src/DistStats.cpp
function DistStatManager (line 31) | DistStatManager* internal::distSysStatManager(void) {
function DistStatManager (line 43) | inline static DistStatManager* dsm(void) {
class galois::runtime::StatRecvHelper (line 53) | class galois::runtime::StatRecvHelper {
method recvAtHost_0_hostTotalTy (line 56) | static void recvAtHost_0_hostTotalTy(galois::gstl::Str region,
method recvAtHost_0_int (line 63) | static void recvAtHost_0_int(uint32_t hostID, galois::gstl::Str region,
method recvAtHost_0_fp (line 71) | static void recvAtHost_0_fp(uint32_t hostID, galois::gstl::Str region,
method recvAtHost_0_str (line 79) | static void
FILE: libdist/src/Network.cpp
function bcastLandingPad (line 84) | static void bcastLandingPad(uint32_t src, RecvBuffer& buf) {
function NetworkInterface (line 131) | NetworkInterface& galois::runtime::getSystemNetworkInterface() {
FILE: libdist/src/NetworkBuffered.cpp
class NetworkInterfaceBuffered (line 54) | class NetworkInterfaceBuffered : public NetworkInterface {
class recvBuffer (line 73) | class recvBuffer {
method sizeAtLeast (line 80) | bool sizeAtLeast(size_t n, uint32_t tag) {
method copyOut (line 95) | void copyOut(IterTy it, size_t n) {
method popVec (line 117) | std::optional<vTy> popVec(uint32_t len,
method erase (line 135) | void erase(size_t n, std::atomic<size_t>& inflightRecvs) {
method getLenFromFront (line 149) | uint32_t getLenFromFront(uint32_t tag) {
method popMsg (line 163) | std::optional<RecvBuffer> popMsg(uint32_t tag,
method add (line 208) | void add(NetworkIO::message m) {
method hasData (line 231) | bool hasData(uint32_t tag) { return dataPresent == tag; }
method size (line 233) | size_t size() { return data.size(); }
method getPresentTag (line 235) | uint32_t getPresentTag() { return dataPresent; }
class sendBuffer (line 244) | class sendBuffer {
type msg (line 245) | struct msg {
method msg (line 248) | msg(uint32_t t, vTy& _data) : tag(t), data(std::move(_data)) {}
method size (line 263) | size_t size() { return messages.size(); }
method markUrgent (line 265) | void markUrgent() {
method ready (line 272) | bool ready() {
method assemble (line 302) | std::pair<uint32_t, vTy>
method add (line 358) | void add(uint32_t tag, vTy& b) {
method workerThread (line 374) | void workerThread() {
method NetworkInterfaceBuffered (line 436) | NetworkInterfaceBuffered() {
method sendTagged (line 457) | virtual void sendTagged(uint32_t dest, uint32_t tag, SendBuffer& buf,
method recieveTagged (line 469) | virtual std::optional<std::pair<uint32_t, RecvBuffer>>
method flush (line 502) | virtual void flush() {
method anyPendingSends (line 507) | virtual bool anyPendingSends() { return (inflightSends > 0); }
method anyPendingReceives (line 509) | virtual bool anyPendingReceives() {
method reportSendBytes (line 521) | virtual unsigned long reportSendBytes() const { return statSendBytes; }
method reportSendMsgs (line 522) | virtual unsigned long reportSendMsgs() const { return statSendNum; }
method reportRecvBytes (line 523) | virtual unsigned long reportRecvBytes() const { return statRecvBytes; }
method reportRecvMsgs (line 524) | virtual unsigned long reportRecvMsgs() const { return statRecvNum; }
method reportExtra (line 526) | virtual std::vector<unsigned long> reportExtra() const {
method reportExtraNamed (line 538) | virtual std::vector<std::pair<std::string, unsigned long>>
function NetworkInterface (line 563) | NetworkInterface& galois::runtime::makeNetworkBuffered() {
FILE: libdist/src/NetworkIOMPI.cpp
class NetworkIOMPI (line 34) | class NetworkIOMPI : public galois::runtime::NetworkIO {
method getID (line 41) | static int getID() {
method getNum (line 52) | static int getNum() {
method getIDAndHostNum (line 61) | std::pair<int, int> getIDAndHostNum() {
type mpiMessage (line 68) | struct mpiMessage {
method mpiMessage (line 75) | mpiMessage(uint32_t host, uint32_t tag, vTy&& data)
method mpiMessage (line 77) | mpiMessage(uint32_t host, uint32_t tag, size_t len)
type sendQueueTy (line 84) | struct sendQueueTy {
method sendQueueTy (line 91) | sendQueueTy(galois::runtime::MemUsageTracker& tracker,
method complete (line 95) | void complete() {
method send (line 111) | void send(message m) {
type recvQueueTy (line 130) | struct recvQueueTy {
method recvQueueTy (line 138) | recvQueueTy(galois::runtime::MemUsageTracker& tracker,
method probe (line 143) | void probe() {
method NetworkIOMPI (line 199) | NetworkIOMPI(galois::runtime::MemUsageTracker& tracker,
method enqueue (line 212) | virtual void enqueue(message m) {
method message (line 220) | virtual message dequeue() {
method progress (line 232) | virtual void progress() {
FILE: libdist/src/NetworkLCI.cpp
function crc32c (line 50) | inline uint32_t crc32c(char* buf, size_t len) {
type pendingReq (line 66) | struct pendingReq {
method pendingReq (line 73) | pendingReq(uint32_t _d, uint32_t _t, int _p, vTy& _buf,
function free_req (line 87) | static void free_req(void* ctx) {
class NetworkInterfaceLCI (line 101) | class NetworkInterfaceLCI : public NetworkInterface {
method workerThread (line 114) | void workerThread() {
method NetworkInterfaceLCI (line 145) | NetworkInterfaceLCI() {
method sendTagged (line 176) | virtual void sendTagged(uint32_t dest, uint32_t tag, SendBuffer& buf,
method pendingReq (line 202) | inline pendingReq* convertReq(lc_req* req_ptr, int phase) {
method recieveTagged (line 213) | virtual std::optional<std::pair<uint32_t, RecvBuffer>>
method flush (line 243) | virtual void flush() {}
method anyPendingSends (line 245) | virtual bool anyPendingSends() {
method anyPendingReceives (line 253) | virtual bool anyPendingReceives() {
method reportSendBytes (line 265) | virtual unsigned long reportSendBytes() const { return statSendBytes; }
method reportSendMsgs (line 266) | virtual unsigned long reportSendMsgs() const { return statSendNum; }
method reportRecvBytes (line 267) | virtual unsigned long reportRecvBytes() const { return statRecvBytes; }
method reportRecvMsgs (line 268) | virtual unsigned long reportRecvMsgs() const { return statRecvNum; }
method reportExtra (line 270) | virtual std::vector<unsigned long> reportExtra() const {
method reportExtraNamed (line 275) | virtual std::vector<std::pair<std::string, unsigned long>>
function NetworkInterface (line 295) | NetworkInterface& galois::runtime::makeNetworkLCI() {
FILE: libgalois/include/galois/ArrayWrapper.h
function namespace (line 34) | namespace galois {
FILE: libgalois/include/galois/AtomicHelpers.h
function namespace (line 27) | namespace galois {
FILE: libgalois/include/galois/AtomicWrapper.h
function namespace (line 32) | namespace galois {
FILE: libgalois/include/galois/Bag.h
function namespace (line 35) | namespace galois {
function pop (line 281) | void pop() {
FILE: libgalois/include/galois/CheckedObject.h
function namespace (line 26) | namespace galois {
FILE: libgalois/include/galois/CopyableTuple.h
function namespace (line 29) | namespace galois {
FILE: libgalois/include/galois/DynamicBitset.h
function namespace (line 43) | namespace galois {
function is_valid (line 413) | struct InvalidBitsetFnTy {
function galois (line 421) | static galois::DynamicBitSet& get() { return EmptyBitset; }
function reset_range (line 424) | static void reset_range(size_t, size_t) {}
FILE: libgalois/include/galois/Endian.h
function namespace (line 27) | namespace galois {
FILE: libgalois/include/galois/FixedSizeRing.h
function namespace (line 34) | namespace galois {
function reverse_iterator (line 185) | reverse_iterator rbegin() { return &datac[0]; }
function reverse_iterator (line 186) | reverse_iterator rend() { return &datac[count]; }
function iterator (line 190) | iterator begin() { return iterator(rend()); }
function iterator (line 191) | iterator end() { return iterator(rbegin()); }
function T (line 212) | T* at(unsigned i) { return &datac[i]; }
function T (line 213) | const T* at(unsigned i) const { return &datac[i]; }
function increment (line 234) | void increment() {
function decrement (line 240) | void decrement() {
function advance (line 246) | void advance(ptrdiff_t x) {
function distance_to (line 251) | ptrdiff_t distance_to(const Iterator& o) const {
type T (line 269) | typedef T* pointer;
type T (line 270) | typedef T& reference;
type T (line 271) | typedef const T& const_reference;
type Iterator (line 272) | typedef Iterator<T> iterator;
type Iterator (line 273) | typedef Iterator<const T> const_iterator;
type boost (line 274) | typedef boost::reverse_iterator<Iterator<T>> reverse_iterator;
type boost (line 275) | typedef boost::reverse_iterator<Iterator<const T>> const_reverse_iterator;
function size (line 292) | unsigned size() const {
function full (line 302) | bool full() const {
function const_reference (line 313) | const_reference getAt(unsigned x) const {
function clear (line 319) | void clear() {
function reference (line 378) | reference front() {
function const_reference (line 384) | const_reference front() const {
function pop_front (line 399) | void pop_front() {
function reference (line 407) | reference back() {
function const_reference (line 413) | const_reference back() const {
function pop_back (line 428) | void pop_back() {
function iterator (line 435) | iterator begin() { return iterator(at(0), start, count); }
function iterator (line 436) | iterator end() { return iterator(at(0), (start + count) % ChunkSize, 0); }
function reverse_iterator (line 442) | reverse_iterator rbegin() { return reverse_iterator(end()); }
function reverse_iterator (line 443) | reverse_iterator rend() { return reverse_iterator(begin()); }
FILE: libgalois/include/galois/FlatMap.h
function namespace (line 30) | namespace galois {
function namespace (line 370) | namespace std {
FILE: libgalois/include/galois/GaloisForwardDecl.h
function namespace (line 22) | namespace galois {
FILE: libgalois/include/galois/LargeArray.h
function namespace (line 40) | namespace galois {
function deallocate (line 271) | void deallocate() {
function destroy (line 277) | void destroy() {
function pointer (line 293) | pointer data() { return m_data; }
type raw_value_type (line 318) | typedef void raw_value_type;
type size_type (line 320) | typedef size_t size_type;
type difference_type (line 321) | typedef ptrdiff_t difference_type;
type value_type (line 322) | typedef value_type reference;
type value_type (line 323) | typedef value_type const_reference;
type value_type (line 324) | typedef value_type* pointer;
type value_type (line 325) | typedef value_type* const_pointer;
type pointer (line 326) | typedef pointer iterator;
type const_pointer (line 327) | typedef const_pointer const_iterator;
type size_of (line 329) | struct size_of {
function const_reference (line 333) | const_reference at(difference_type) const { return 0; }
function reference (line 334) | reference at(difference_type) { return 0; }
function const_reference (line 335) | const_reference operator[](size_type) const { return 0; }
function iterator (line 339) | iterator begin() { return 0; }
function iterator (line 341) | iterator end() { return 0; }
function allocateInterleaved (line 344) | void allocateInterleaved(size_type) {}
function allocateBlocked (line 345) | void allocateBlocked(size_type) {}
function allocateFloating (line 347) | void allocateFloating(size_type) {}
function pointer (line 363) | pointer data() { return 0; }
FILE: libgalois/include/galois/LazyArray.h
function namespace (line 33) | namespace galois {
FILE: libgalois/include/galois/LazyObject.h
function namespace (line 29) | namespace galois {
function void (line 118) | struct LazyObject<void> {
FILE: libgalois/include/galois/Loops.h
function namespace (line 32) | namespace galois {
type DoAll (line 173) | struct DoAll {
type StdForEach (line 186) | struct StdForEach {
type ForEach (line 195) | struct ForEach {
FILE: libgalois/include/galois/Mem.h
function namespace (line 26) | namespace galois {
FILE: libgalois/include/galois/MethodFlags.h
function namespace (line 25) | namespace galois {
FILE: libgalois/include/galois/NoDerefIterator.h
function namespace (line 27) | namespace galois {
FILE: libgalois/include/galois/PODResizeableArray.h
function namespace (line 32) | namespace galois {
function iterator (line 105) | iterator begin() { return iterator(&data_[0]); }
function iterator (line 107) | iterator end() { return iterator(&data_[size_]); }
function reverse_iterator (line 110) | reverse_iterator rbegin() { return reverse_iterator(end()); }
function reverse_iterator (line 114) | reverse_iterator rend() { return reverse_iterator(begin()); }
function reserve (line 129) | void reserve(size_t n) {
function resize (line 142) | void resize(size_t n) {
function clear (line 147) | void clear() { size_ = 0; }
function reference (line 150) | reference operator[](size_type __n) { return data_[__n]; }
function const_reference (line 151) | const_reference operator[](size_type __n) const { return data_[__n]; }
function reference (line 152) | reference at(size_type __n) {
function const_reference (line 157) | const_reference at(size_type __n) const {
function assign (line 163) | void assign(iterator first, iterator last) {
function reference (line 169) | reference front() { return data_[0]; }
function reference (line 171) | reference back() { return data_[size_ - 1]; }
function pointer (line 174) | pointer data() { return data_; }
function push_back (line 177) | void push_back(const _Tp& value) {
function swap (line 192) | void swap(PODResizeableArray& v) {
FILE: libgalois/include/galois/ParallelSTL.h
function namespace (line 33) | namespace galois {
type std (line 160) | typedef std::pair<RandomAccessIterator, RandomAccessIterator> RP;
type partition_helper_state (line 161) | struct partition_helper_state {
function RP (line 182) | RP takeLow() {
function update (line 190) | void update(RP low, RP high) {
function state (line 204) | state(s) {}
type partition_helper (line 229) | typedef partition_helper<RandomAccessIterator, Predicate> P;
type pair_dist (line 239) | struct pair_dist {
type galois (line 252) | typedef galois::worklists::PerSocketChunkFIFO<1> WL;
FILE: libgalois/include/galois/PerThreadContainer.h
function namespace (line 49) | namespace galois {
function clear_all_parallel (line 421) | void clear_all_parallel(void) {
type typename (line 456) | typedef typename gstl::template
function reserve_all (line 466) | void reserve_all(size_t sz) {
type PerThreadContainer (line 485) | typedef PerThreadContainer<container_type> Super_ty;
type PerThreadContainer (line 512) | typedef PerThreadContainer<container_type> Super_ty;
type typename (line 526) | typedef typename gstl::template
type typename (line 540) | typedef typename Super_ty::global_const_iterator global_const_iterator;
type typename (line 541) | typedef typename Super_ty::global_const_reverse_iterator
function global_const_iterator (line 545) | global_const_iterator begin_all() const { return Super_ty::cbegin_all(); }
function global_const_reverse_iterator (line 549) | global_const_reverse_iterator rbegin_all() const {
type PerThreadContainer (line 566) | typedef PerThreadContainer<container_type> Super_ty;
type typename (line 575) | typedef typename Super_ty::global_const_iterator global_const_iterator;
type typename (line 576) | typedef typename Super_ty::global_const_reverse_iterator
function global_const_iterator (line 580) | global_const_iterator begin_all() const { return Super_ty::cbegin_all(); }
function global_const_reverse_iterator (line 584) | global_const_reverse_iterator rbegin_all() const {
type typename (line 601) | typedef typename gstl::template
type PerThreadContainer (line 602) | typedef PerThreadContainer<container_type> Super_ty;
type typename (line 611) | typedef typename Super_ty::global_const_iterator global_const_iterator;
type typename (line 612) | typedef typename Super_ty::global_const_reverse_iterator
function global_const_iterator (line 616) | global_const_iterator begin_all() const { return Super_ty::cbegin_all(); }
function global_const_reverse_iterator (line 620) | global_const_reverse_iterator rbegin_all() const {
FILE: libgalois/include/galois/PriorityQueue.h
function namespace (line 32) | namespace galois {
type Cont (line 162) | typedef Cont container_type;
type typename (line 164) | typedef typename container_type::value_type value_type;
type typename (line 165) | typedef typename container_type::reference reference;
type typename (line 166) | typedef typename container_type::const_reference const_reference;
type typename (line 167) | typedef typename container_type::pointer pointer;
type typename (line 168) | typedef typename container_type::size_type size_type;
type typename (line 169) | typedef typename container_type::const_iterator iterator;
type typename (line 170) | typedef typename container_type::const_iterator const_iterator;
type typename (line 171) | typedef typename container_type::const_reverse_iterator reverse_iterator;
type typename (line 172) | typedef
type RevCmp (line 177) | struct RevCmp {
function value_type (line 195) | value_type pop_internal() {
function push_back (line 222) | inline void push_back(const value_type& x) { this->push(x); }
function insert (line 223) | inline void insert(const value_type& x) { this->push(x); }
function push (line 225) | void push(const value_type& x) {
function value_type (line 230) | value_type pop() {
function remove (line 239) | bool remove(const value_type& x) {
function find (line 259) | bool find(const value_type& x) const {
function clear (line 263) | void clear() { container.clear(); }
function reserve (line 268) | void reserve(size_type s) { container.reserve(s); }
type typename (line 279) | typedef typename container_type::value_type value_type;
type typename (line 280) | typedef typename container_type::reference reference;
type typename (line 281) | typedef typename container_type::const_reference const_reference;
type typename (line 282) | typedef typename container_type::pointer pointer;
type typename (line 283) | typedef typename container_type::size_type size_type;
type typename (line 284) | typedef typename container_type::const_iterator iterator;
type typename (line 285) | typedef typename container_type::const_iterator const_iterator;
type typename (line 286) | typedef typename container_type::const_reverse_iterator reverse_iterator;
type typename (line 287) | typedef
function push_back (line 330) | inline void push_back(const value_type& x) { this->push(x); }
function insert (line 331) | inline void insert(const value_type& x) { this->push(x); }
function push (line 333) | void push(const value_type& x) {
function value_type (line 339) | value_type pop() {
function remove (line 346) | bool remove(const value_type& x) {
function find (line 355) | bool find(const value_type& x) const {
function clear (line 363) | void clear() {
function reserve (line 373) | void reserve(size_type s) { heap.reserve(s); }
FILE: libgalois/include/galois/Reduction.h
function namespace (line 29) | namespace galois {
function T (line 132) | constexpr T operator()(const T& lhs, const T& rhs) const {
function T (line 140) | constexpr T operator()(const T& lhs, const T& rhs) const {
function T (line 155) | constexpr T operator()() const { return T{0}; }
FILE: libgalois/include/galois/SharedMemSys.h
function namespace (line 7) | namespace galois {
FILE: libgalois/include/galois/Threads.h
function namespace (line 25) | namespace galois {
FILE: libgalois/include/galois/Timer.h
type std (line 32) | typedef std::chrono::steady_clock clockTy;
function get (line 39) | uint64_t get() const;
FILE: libgalois/include/galois/Traits.h
function namespace (line 29) | namespace galois {
type T (line 49) | typedef T type;
function find_trait (line 78) | size_t find_trait(std::index_sequence<Int, Ints...> /*seq*/) {
function find_trait (line 88) | size_t find_trait() {
function has_trait (line 97) | bool has_trait(std::tuple<Ts...>* /*tpl*/) {
function has_trait (line 102) | bool has_trait() {
type std (line 181) | typedef std::tuple<> type;
type loopname_tag (line 196) | struct loopname_tag {}
type loopname (line 197) | struct loopname
type steal_tag (line 205) | struct steal_tag {}
type steal (line 206) | struct steal
type wl_tag (line 211) | struct wl_tag {}
type parallel_break_tag (line 228) | struct parallel_break_tag {}
type parallel_break (line 229) | struct parallel_break
type no_pushes_tag (line 234) | struct no_pushes_tag {}
type no_pushes (line 235) | struct no_pushes
type per_iter_alloc_tag (line 240) | struct per_iter_alloc_tag {}
type per_iter_alloc (line 241) | struct per_iter_alloc
type no_stats_tag (line 246) | struct no_stats_tag {}
type no_stats (line 247) | struct no_stats
type more_stats_tag (line 253) | struct more_stats_tag {}
type more_stats (line 254) | struct more_stats
type disable_conflict_detection_tag (line 259) | struct disable_conflict_detection_tag {}
type disable_conflict_detection (line 260) | struct disable_conflict_detection
type fixed_neighborhood_tag (line 270) | struct fixed_neighborhood_tag {}
type fixed_neighborhood (line 271) | struct fixed_neighborhood
type intent_to_read_tag (line 277) | struct intent_to_read_tag {}
type intent_to_read (line 278) | struct intent_to_read
type neighborhood_visitor_tag (line 284) | struct neighborhood_visitor_tag {}
type det_parallel_break_tag (line 302) | struct det_parallel_break_tag {}
type det_id_tag (line 318) | struct det_id_tag {}
type local_state_tag (line 330) | struct local_state_tag {}
type op_tag (line 336) | struct op_tag {}
type chunk_size_tag (line 338) | struct chunk_size_tag {
function trait_has_value (line 366) | chunk_size(unsigned cs = SZ) : trait_has_value(clamp(cs)) {}
type worklists (line 369) | typedef worklists::PerSocketChunkFIFO<chunk_size<>::value> defaultWL;
FILE: libgalois/include/galois/TwoLevelIterator.h
function namespace (line 34) | namespace galois {
function setInnerAtBegin (line 99) | inline void setInnerAtBegin(void) {
function setInnerAtEnd (line 105) | inline void setInnerAtEnd(void) {
function innerAtBegin (line 111) | inline bool innerAtBegin() const {
type TwoLevelIterBase (line 141) | typedef TwoLevelIterBase<Outer, Inner, InnerBegFn, InnerEndFn> Base;
function nextOuter (line 143) | void nextOuter() {
function seekValidBegin (line 154) | void seekValidBegin() {
function step_forward (line 160) | void step_forward() {
function is_equal (line 169) | bool is_equal(const TwoLevelFwdIter& that) const {
function step_backward (line 243) | void step_backward() {
type typename (line 293) | typedef typename BiDirBase::Traits::difference_type Diff_ty;
function jump_forward (line 295) | void jump_forward(const Diff_ty d) {
function jump_backward (line 326) | void jump_backward(const Diff_ty d) {
function Diff_ty (line 360) | Diff_ty compute_dist(const TwoLevelRandIter& that) const {
function typename (line 440) | typename BiDirBase::Traits::reference operator[](Diff_ty d) const {
function namespace (line 466) | namespace internal {
type typename (line 548) | typedef typename InnerBegFn::result_type Inner;
type typename (line 549) | typedef typename ChooseTwoLevelIterator<Outer, Inner, InnerBegFn,
type typename (line 564) | typedef typename InnerBegFn::result_type Inner;
type typename (line 565) | typedef typename ChooseTwoLevelIterator<Outer, Inner, InnerBegFn,
function namespace (line 571) | namespace internal {
type GetCbegin (line 686) | typedef GetCbegin<C> InnerBegFn;
type GetCend (line 687) | typedef GetCend<C> InnerEndFn;
type GetRbegin (line 694) | typedef GetRbegin<C> InnerBegFn;
type GetRend (line 695) | typedef GetRend<C> InnerEndFn;
type GetCRbegin (line 702) | typedef GetCRbegin<C> InnerBegFn;
type GetCRend (line 703) | typedef GetCRend<C> InnerEndFn;
type typename (line 709) | typedef typename std::iterator_traits<Outer>::value_type C;
type internal (line 712) | typedef internal::ChooseStlIter<C, Inner, KIND> CStl;
type typename (line 713) | typedef typename CStl::InnerBegFn InnerBegFn;
type typename (line 714) | typedef typename CStl::InnerEndFn InnerEndFn;
type typename (line 715) | typedef typename ChooseTwoLevelIterator<Outer, Inner, InnerBegFn,
function type (line 718) | static type make(Outer beg, Outer end, Outer outer_pos) {
type typename (line 752) | typedef typename internal::ChooseStlTwoLevelIterImpl<Outer, Inner>::type...
FILE: libgalois/include/galois/TwoLevelIteratorA.h
function namespace (line 33) | namespace galois {
function seek_backward (line 165) | void seek_backward() {
function increment (line 178) | void increment() {
function decrement (line 183) | void decrement() {
function advance (line 269) | void advance(difference_type n) {
type GetBegin (line 383) | struct GetBegin {
type GetEnd (line 391) | struct GetEnd {
FILE: libgalois/include/galois/UnionFind.h
function namespace (line 27) | namespace galois {
FILE: libgalois/include/galois/UserContext.h
function namespace (line 30) | namespace galois {
function abort (line 105) | void abort() { galois::runtime::signalConflict(); }
function isFirstPass (line 123) | bool isFirstPass(void) const { return firstPassFlag; }
function cautiousPoint (line 128) | void cautiousPoint() {
FILE: libgalois/include/galois/Version.h
function namespace (line 27) | namespace galois {
FILE: libgalois/include/galois/gIO.h
function namespace (line 32) | namespace galois {
FILE: libgalois/include/galois/gdeque.h
type Block (line 46) | struct Block
function increment (line 68) | void increment() { cur = cur->next; }
function decrement (line 69) | void decrement() {
type typename (line 92) | typedef typename Block::iterator inner_iterator;
type typename (line 93) | typedef typename Block::const_iterator const_inner_iterator;
function free_block (line 113) | void free_block(Block* b) {
function Block (line 124) | Block* extend_first() {
function Block (line 135) | Block* extend_last() {
function shrink (line 146) | void shrink(Block* b) {
type galois (line 194) | typedef galois::TwoLevelIteratorA<outer_iterator<Block>, inner_iterator,
type galois (line 198) | typedef galois::TwoLevelIteratorA<outer_iterator<const Block>,
function decrement (line 224) | void decrement() {
type Iterator (line 252) | typedef Iterator<T> iterator;
type Iterator (line 253) | typedef Iterator<const T> const_iterator;
type boost (line 256) | typedef boost::reverse_iterator<iterator> reverse_iterator;
type boost (line 257) | typedef boost::reverse_iterator<const_iterator> const_reverse_iterator;
type typename (line 258) | typedef typename iterator::value_type value_type;
type typename (line 259) | typedef typename iterator::pointer pointer;
type typename (line 260) | typedef typename iterator::reference reference;
type typename (line 261) | typedef typename const_iterator::reference const_reference;
type typename (line 262) | typedef typename iterator::difference_type difference_type;
type size_type (line 263) | typedef size_t size_type;
function reverse_iterator (line 338) | reverse_iterator rend() { return reverse_iterator{begin()}; }
FILE: libgalois/include/galois/graphs/BufferedGraph.h
function namespace (line 37) | namespace galois {
FILE: libgalois/include/galois/graphs/Details.h
function namespace (line 37) | namespace galois::graphs {
function namespace (line 46) | namespace galois::graphs::internal {
function namespace (line 52) | namespace galois::graphs {
function namespace (line 78) | namespace galois::graphs::internal {
function setId (line 243) | void setId(size_t n) { id = n; }
function setId (line 250) | void setId(size_t) {}
function class (line 254) | class NoLockable {}
type NodeTy (line 259) | typedef NodeTy& reference;
function typename (line 279) | typename NodeInfoBase::reference getData() { return data; }
function typename (line 287) | typename NodeInfoBase::reference getData() { return 0; }
type NodeInfoBase (line 292) | typedef NodeInfoBase<void, true> OutOfLineLock;
type size_of_out_of_line (line 296) | struct size_of_out_of_line {
function outOfLineAcquire (line 300) | void outOfLineAcquire(size_t n, MethodFlag mflag) {
function outOfLineAllocateLocal (line 303) | void outOfLineAllocateLocal(size_t numNodes) {
function outOfLineAllocateInterleaved (line 306) | void outOfLineAllocateInterleaved(size_t numNodes) {
function outOfLineAllocateBlocked (line 309) | void outOfLineAllocateBlocked(size_t numNodes) {
function outOfLineAllocateFloating (line 312) | void outOfLineAllocateFloating(size_t numNodes) {
function outOfLineConstructAt (line 321) | void outOfLineConstructAt(size_t n) { outOfLineLocks.constructAt(n); }
type size_of_out_of_line (line 327) | struct size_of_out_of_line {
function outOfLineAcquire (line 330) | void outOfLineAcquire(size_t, MethodFlag) {}
function outOfLineAllocateLocal (line 331) | void outOfLineAllocateLocal(size_t) {}
function outOfLineAllocateInterleaved (line 332) | void outOfLineAllocateInterleaved(size_t) {}
function outOfLineAllocateBlocked (line 333) | void outOfLineAllocateBlocked(size_t) {}
function outOfLineAllocateFloating (line 334) | void outOfLineAllocateFloating(size_t) {}
function outOfLineConstructAt (line 335) | void outOfLineConstructAt(size_t) {}
function iterator (line 364) | iterator end() { return make_no_deref_iterator(ee); }
function iterator (line 389) | iterator begin() { return make_no_deref_iterator(g.in_edge_begin(n, flag...
function iterator (line 390) | iterator end() { return make_no_deref_iterator(g.in_edge_end(n, flag)); }
function iterator (line 404) | iterator begin() { return make_no_deref_iterator(g.edge_begin(n)); }
function iterator (line 405) | iterator end() { return make_no_deref_iterator(g.edge_end(n)); }
FILE: libgalois/include/galois/graphs/FileGraph.h
function namespace (line 51) | namespace galois {
function finish (line 745) | void finish() { starts.reset(nullptr); }
type FileGraph (line 765) | typedef FileGraph::GraphNode GNode;
type FileGraph (line 840) | typedef FileGraph::GraphNode GNode;
FILE: libgalois/include/galois/graphs/GraphHelpers.h
function namespace (line 30) | namespace galois {
FILE: libgalois/include/galois/graphs/LC_CSR_CSC_Graph.h
function namespace (line 32) | namespace galois {
function getInDegree (line 302) | uint64_t getInDegree(GraphNode N) const {
function GraphNode (line 323) | GraphNode getInEdgeDst(edge_iterator ni) const { return inEdgeDst[*ni]; }
FILE: libgalois/include/galois/graphs/LC_CSR_Graph.h
function namespace (line 39) | namespace galois::graphs {
FILE: libgalois/include/galois/graphs/LC_CSR_Hypergraph.h
type LC_CSR_Hypergraph (line 75) | typedef LC_CSR_Hypergraph type;
type LC_CSR_Hypergraph (line 80) | typedef LC_CSR_Hypergraph<_node_data, EdgeTy, HasNoLockable, UseNumaAlloc,
type LC_CSR_Hypergraph (line 87) | typedef LC_CSR_Hypergraph<NodeTy, _edge_data, HasNoLockable, UseNumaAlloc,
type LC_CSR_Hypergraph (line 94) | typedef LC_CSR_Hypergraph<NodeTy, EdgeTy, HasNoLockable, UseNumaAlloc,
type LC_CSR_Hypergraph (line 102) | typedef LC_CSR_Hypergraph<NodeTy, EdgeTy, _has_no_lockable, UseNumaAlloc,
type LC_CSR_Hypergraph (line 114) | typedef LC_CSR_Hypergraph<NodeTy, EdgeTy, HasNoLockable, _use_numa_alloc,
type LC_CSR_Hypergraph (line 126) | typedef LC_CSR_Hypergraph<NodeTy, EdgeTy, HasNoLockable, UseNumaAlloc,
type read_default_graph_tag (line 131) | typedef read_default_graph_tag read_tag;
type LargeArray (line 135) | typedef LargeArray<uint32_t> EdgeDst;
type LargeArray (line 142) | typedef LargeArray<uint64_t> EdgeIndData;
type LargeArray (line 143) | typedef LargeArray<NodeInfo> NodeData;
type EdgeTy (line 147) | typedef EdgeTy edge_data_type;
type FileEdgeTy (line 148) | typedef FileEdgeTy file_edge_data_type;
type NodeTy (line 149) | typedef NodeTy node_data_type;
type typename (line 150) | typedef typename EdgeData::reference edge_data_reference;
type typename (line 151) | typedef typename NodeInfoTypes::reference node_data_reference;
type iterator (line 155) | typedef iterator const_iterator;
type iterator (line 156) | typedef iterator local_iterator;
type iterator (line 157) | typedef iterator const_local_iterator;
type internal (line 171) | typedef internal::EdgeSortIterator<
function edge_iterator (line 175) | edge_iterator raw_begin(GraphNode N) const {
function edge_iterator (line 179) | edge_iterator raw_end(GraphNode N) const {
function edge_sort_iterator (line 183) | edge_sort_iterator edge_sort_begin(GraphNode N) {
function edge_sort_iterator (line 187) | edge_sort_iterator edge_sort_end(GraphNode N) {
type LargeArray (line 212) | typedef LargeArray<FileEdgeTy> FED;
FILE: libgalois/include/galois/graphs/LC_InOut_Graph.h
function namespace (line 31) | namespace galois {
type EdgeSortValue (line 255) | typedef EdgeSortValue<GraphNode, edge_data_type> EdgeSortVal;
type EdgeSortValue (line 261) | typedef EdgeSortValue<typename
FILE: libgalois/include/galois/graphs/LC_InlineEdge_Graph.h
function namespace (line 31) | namespace graphs {
function edge_iterator (line 203) | edge_iterator raw_begin(GraphNode N) {
function edge_iterator (line 207) | edge_iterator raw_end(GraphNode N) { return nodeData[getId(N)].edgeEnd(); }
type LargeArray (line 214) | typedef LargeArray<FileEdgeTy> FED;
FILE: libgalois/include/galois/graphs/LC_Linear_Graph.h
type LC_Linear_Graph (line 57) | typedef LC_Linear_Graph<NodeTy, EdgeTy, HasNoLockable, UseNumaAlloc,
type LC_Linear_Graph (line 64) | typedef LC_Linear_Graph<_node_data, EdgeTy, HasNoLockable, UseNumaAlloc,
type LC_Linear_Graph (line 71) | typedef LC_Linear_Graph<NodeTy, _edge_data, HasNoLockable, UseNumaAlloc,
type LC_Linear_Graph (line 78) | typedef LC_Linear_Graph<NodeTy, EdgeTy, HasNoLockable, UseNumaAlloc,
type LC_Linear_Graph (line 85) | typedef LC_Linear_Graph<NodeTy, EdgeTy, _has_no_lockable, UseNumaAlloc,
type LC_Linear_Graph (line 92) | typedef LC_Linear_Graph<NodeTy, EdgeTy, HasNoLockable, _use_numa_alloc,
type LC_Linear_Graph (line 99) | typedef LC_Linear_Graph<NodeTy, EdgeTy, HasNoLockable, UseNumaAlloc,
type read_with_aux_graph_tag (line 105) | typedef read_with_aux_graph_tag read_tag;
type internal (line 109) | typedef internal::EdgeInfoBase<NodeInfo*, EdgeTy> EdgeInfo;
type LargeArray (line 110) | typedef LargeArray<NodeInfo*> Nodes;
function EdgeInfo (line 123) | EdgeInfo* edgeBegin() {
function EdgeInfo (line 129) | EdgeInfo* edgeEnd() {
function NodeInfo (line 135) | NodeInfo* next() {
type EdgeTy (line 146) | typedef EdgeTy edge_data_type;
type FileEdgeTy (line 147) | typedef FileEdgeTy file_edge_data_type;
type NodeTy (line 148) | typedef NodeTy node_data_type;
type typename (line 149) | typedef typename NodeInfoTypes::reference node_data_reference;
type typename (line 150) | typedef typename EdgeInfo::reference edge_data_reference;
type EdgeInfo (line 151) | typedef EdgeInfo* edge_iterator;
type NodeInfo (line 152) | typedef NodeInfo** iterator;
type NodeInfo (line 153) | typedef NodeInfo* const* const_iterator;
type iterator (line 154) | typedef iterator local_iterator;
type const_iterator (line 155) | typedef const_iterator const_local_iterator;
type ReadGraphAuxData (line 156) | typedef int ReadGraphAuxData;
function edge_iterator (line 180) | edge_iterator raw_begin(GraphNode N) { return N->edgeBegin(); }
function edge_iterator (line 182) | edge_iterator raw_end(GraphNode N) { return N->edgeEnd(); }
type LargeArray (line 189) | typedef LargeArray<FileEdgeTy> FED;
FILE: libgalois/include/galois/graphs/LC_Morph_Graph.h
function namespace (line 40) | namespace graphs {
FILE: libgalois/include/galois/graphs/MorphGraph.h
function namespace (line 55) | namespace galois {
function NTy (line 140) | inline NTy* first() { return (NTy*)((uintptr_t)N & ~1); }
function NTy (line 141) | inline const NTy* first() const { return (NTy*)((uintptr_t)N & ~1); }
function delEdge (line 163) | void delEdge(ETy*) {}
function N2 (line 318) | N2(n) {}
type first_not_valid (line 325) | struct first_not_valid {
function iterator (line 380) | iterator begin() { return edges.begin(); }
function iterator (line 382) | iterator end() { return edges.end(); }
function erase (line 386) | void erase(iterator ii) {
function resizeEdges (line 437) | void resizeEdges(size_t size) {
type is_node (line 512) | struct is_node {
type is_edge (line 515) | struct is_edge {
type is_in_edge (line 520) | struct is_in_edge {
type is_out_edge (line 525) | struct is_out_edge {
type makeGraphNode (line 530) | struct makeGraphNode {
type ReadGraphAuxData (line 564) | struct ReadGraphAuxData {
type AuxNode (line 574) | struct AuxNode {
type typename (line 690) | typedef typename LargeArray<FileEdgeTy>::value_type FEDV;
type LargeArray (line 691) | typedef LargeArray<EdgeTy> ED;
FILE: libgalois/include/galois/graphs/MorphHyperGraph.h
function namespace (line 54) | namespace galois {
function NTy (line 139) | inline NTy* first() { return (NTy*)((uintptr_t)N & ~1); }
function NTy (line 140) | inline NTy* first() const { return (NTy*)((uintptr_t)N & ~1); }
function delEdge (line 162) | void delEdge(ETy*) {}
function N2 (line 318) | N2(n) {}
type first_not_valid (line 325) | struct first_not_valid {
function iterator (line 380) | iterator begin() { return edges.begin(); }
function iterator (line 382) | iterator end() { return edges.end(); }
function erase (line 386) | void erase(iterator ii) {
function resizeEdges (line 437) | void resizeEdges(size_t size) {
type is_node (line 516) | struct is_node {
type is_edge (line 519) | struct is_edge {
type is_in_edge (line 524) | struct is_in_edge {
type is_out_edge (line 529) | struct is_out_edge {
type makeGraphNode (line 534) | struct makeGraphNode {
type ReadGraphAuxData (line 575) | struct ReadGraphAuxData {
type AuxNode (line 585) | struct AuxNode {
type typename (line 701) | typedef typename LargeArray<FileEdgeTy>::value_type FEDV;
type LargeArray (line 702) | typedef LargeArray<EdgeTy> ED;
FILE: libgalois/include/galois/graphs/Morph_SepInOut_Graph.h
function namespace (line 47) | namespace galois {
function NTy (line 133) | inline NTy* first() { return (NTy*)((uintptr_t)N & ~1); }
function NTy (line 134) | inline NTy const* first() const { return (NTy*)((uintptr_t)N & ~1); }
function delEdge (line 156) | void delEdge(ETy*) {}
type Morph_SepInOut_Graph (line 241) | typedef Morph_SepInOut_Graph<NodeTy, EdgeTy, Directional, InOut,
type Morph_SepInOut_Graph (line 248) | typedef Morph_SepInOut_Graph<_node_data, EdgeTy, Directional, InOut,
type Morph_SepInOut_Graph (line 255) | typedef Morph_SepInOut_Graph<NodeTy, _edge_data, Directional, InOut,
type Morph_SepInOut_Graph (line 262) | typedef Morph_SepInOut_Graph<NodeTy, EdgeTy, Directional, InOut,
type Morph_SepInOut_Graph (line 270) | typedef Morph_SepInOut_Graph<NodeTy, EdgeTy, _directional, InOut,
type Morph_SepInOut_Graph (line 277) | typedef Morph_SepInOut_Graph<NodeTy, EdgeTy, Directional, InOut,
type read_with_aux_first_graph_tag (line 282) | typedef read_with_aux_first_graph_tag read_tag;
function N2 (line 288) | N2(n) {}
type first_not_valid (line 295) | struct first_not_valid {
type internal (line 320) | typedef internal::UEdgeInfoBase<gNode, EdgeTy, Directional
type boost (line 326) | typedef boost::container::small_vector<
type typename (line 330) | typedef typename EdgesTy::iterator iterator;
type typename (line 339) | typedef typename gNode::iterator iterator;
type typename (line 340) | typedef typename gNode::EdgeInfo EdgeInfo;
function iterator (line 344) | iterator begin() { return edges.begin(); }
function iterator (line 345) | iterator end() { return edges.end(); }
function iterator (line 347) | iterator in_edge_begin() { return in_edges.begin(); }
function iterator (line 348) | iterator in_edge_end() { return in_edges.end(); }
type galois (line 453) | typedef galois::InsertBag<gNode> NodeListTy;
type is_node (line 459) | struct is_node {
type is_edge (line 462) | struct is_edge {
type is_in_edge (line 467) | struct is_in_edge {
type is_out_edge (line 472) | struct is_out_edge {
type makeGraphNode (line 477) | struct makeGraphNode {
type EdgeTy (line 485) | typedef EdgeTy edge_data_type;
type FileEdgeTy (line 487) | typedef FileEdgeTy file_edge_data_type;
type NodeTy (line 489) | typedef NodeTy node_data_type;
type typename (line 491) | typedef typename boost::filter_iterator<is_out_edge,
type typename (line 495) | typedef
type typename (line 499) | typedef typename gNodeTypes::EdgeInfo::reference edge_data_reference;
type typename (line 501) | typedef typename gNodeTypes::reference node_data_reference;
type boost (line 503) | typedef boost::transform_iterator<
type ReadGraphAuxData (line 508) | struct ReadGraphAuxData {
type AuxNode (line 515) | struct AuxNode {
type typename (line 622) | typedef typename LargeArray<FileEdgeTy>::value_type FEDV;
type LargeArray (line 623) | typedef LargeArray<EdgeTy> ED;
FILE: libgalois/include/galois/graphs/OCGraph.h
function namespace (line 36) | namespace galois {
function GraphNode (line 115) | GraphNode getInEdgeDst(in_edge_iterator ni) {
function idFromNode (line 134) | size_t idFromNode(GraphNode N) { return graph.idFromNode(N); }
function GraphNode (line 136) | GraphNode nodeFromId(size_t N) { return graph.nodeFromId(N); }
function class (line 140) | class OCFileGraph : private boost::noncopyable {
function GraphNode (line 232) | GraphNode getEdgeDst(const segment_type& s, edge_iterator it) {
function unload (line 237) | void unload(segment_type& s) {
type read_oc_immutable_edge_graph_tag (line 252) | struct read_oc_immutable_edge_graph_tag {}
FILE: libgalois/include/galois/graphs/OfflineGraph.h
function namespace (line 40) | namespace graphs {
function num_seeks (line 252) | uint64_t num_seeks() {
function num_bytes_read (line 258) | uint64_t num_bytes_read() {
function reset_seek_counters (line 264) | void reset_seek_counters() {
function iterator (line 275) | iterator begin() { return iterator(0); }
function iterator (line 276) | iterator end() { return iterator(numNodes); }
function edge_iterator (line 278) | edge_iterator edge_begin(GraphNode N) {
function edge_iterator (line 285) | edge_iterator edge_end(GraphNode N) { return edge_iterator(outIndexs(N)); }
function GraphNode (line 287) | GraphNode getEdgeDst(edge_iterator ni) { return outEdges(*ni); }
type std (line 307) | typedef std::pair<iterator, iterator> NodeRange;
type std (line 308) | typedef std::pair<edge_iterator, edge_iterator> EdgeRange;
type std (line 309) | typedef std::pair<NodeRange, EdgeRange> GraphRange;
function setEdge32 (line 351) | void setEdge32(uint64_t src, uint64_t offset, uint64_t dst, uint32_t val) {
function setEdge64 (line 360) | void setEdge64(uint64_t src, uint64_t offset, uint64_t dst, uint64_t val) {
function setEdge_sorted (line 369) | void setEdge_sorted(uint64_t dst) {
function setEdge_sortedBuffer (line 378) | void setEdge_sortedBuffer() {
function setCounts (line 411) | void setCounts(std::deque<uint64_t> edgeCounts) {
FILE: libgalois/include/galois/graphs/ReadGraph.h
function namespace (line 29) | namespace galois {
FILE: libgalois/include/galois/graphs/SpatialTree.h
function namespace (line 25) | namespace galois {
function closer (line 87) | bool closer(double x, double y, double testx, double testy, double oldx,
function T (line 111) | T* recfind(Node* n, double x, double y) {
function recinsert (line 123) | void recinsert(Node** pos, Box2d b, Node* node) {
function Node (line 136) | Node* mkNode(const T& v, double x, double y) {
function delNode (line 143) | void delNode(Node* n) {
function freeTree (line 149) | void freeTree(Node* n) {
function init (line 169) | void init(double xmin, double ymin, double xmax, double ymax) {
function T (line 177) | T* find(double x, double y) {
function insert (line 184) | void insert(double x, double y, const T& v) {
FILE: libgalois/include/galois/graphs/TypeTraits.h
function namespace (line 27) | namespace galois {
FILE: libgalois/include/galois/gslist.h
function namespace (line 32) | namespace galois {
type T (line 165) | typedef T value_type;
type galois (line 166) | typedef galois::TwoLevelIteratorA<outer_iterator<Block>,
type galois (line 170) | typedef galois::TwoLevelIteratorA<outer_iterator<const Block>,
function iterator (line 196) | iterator begin() {
function iterator (line 202) | iterator end() {
function const_iterator (line 208) | const_iterator begin() const {
function pop_front (line 262) | bool pop_front(promise_to_dealloc) {
function clear (line 271) | void clear(promise_to_dealloc) { _clear(promise_to_dealloc()); }
FILE: libgalois/include/galois/gstl.h
function namespace (line 38) | namespace galois {
function T (line 179) | T pop(void) {
function T (line 194) | T pop(void) {
function namespace (line 276) | namespace internal {
FILE: libgalois/include/galois/optional.h
function namespace (line 28) | namespace galois {
FILE: libgalois/include/galois/runtime/Context.h
function namespace (line 38) | namespace galois {
function shouldLock (line 189) | inline bool shouldLock(const galois::MethodFlag g) {
function doAcquire (line 210) | inline void doAcquire(Lockable* lockable, galois::MethodFlag m) {
function acquire (line 218) | inline void acquire(Lockable* lockable, galois::MethodFlag m) {
type AlwaysLockObj (line 223) | struct AlwaysLockObj {
type CheckedLockObj (line 229) | struct CheckedLockObj {
FILE: libgalois/include/galois/runtime/Executor_Deterministic.h
function namespace (line 57) | namespace galois {
function build (line 188) | void build() {
function propagate (line 196) | bool propagate() { return this->find()->isReady(); }
function virtual (line 198) | virtual void alwaysAcquire(Lockable*, galois::MethodFlag) {
function acquireRead (line 213) | void acquireRead(Lockable* lockable) {
function acquireWrite (line 242) | void acquireWrite(Lockable* lockable) {
function clear (line 269) | void clear() {}
function build (line 271) | void build() { readerCtx.build(); }
function propagate (line 273) | void propagate() {
function virtual (line 278) | virtual void alwaysAcquire(Lockable* lockable, galois::MethodFlag m) {
function initialize (line 292) | static void initialize() {}
type galois (line 299) | typedef galois::concurrent_gslist<DeterministicContextBase*, 8> ContextL...
type ContextPtrLessThan (line 305) | struct ContextPtrLessThan {
function addEdge (line 328) | void addEdge(DeterministicContextBase* o) {
function isReady (line 333) | bool isReady() { return false; }
function virtual (line 335) | virtual void alwaysAcquire(Lockable* lockable, galois::MethodFlag) {
function initialize (line 354) | static void initialize() {
type GetValue (line 395) | struct GetValue {
function push (line 445) | void push(const T& val) {
type T (line 457) | typedef T value_type;
type FunctionTy (line 458) | typedef FunctionTy function2_type;
type ArgsTy (line 459) | typedef ArgsTy args_type;
type FunctionTy (line 494) | typedef FunctionTy function1_type;
type typename (line 505) | typedef typename get_trait_type<neighborhood_visitor_tag, ArgsTy>::type:...
type DeterministicContext (line 521) | typedef DeterministicContext<OptionsTy> Context;
function pushDAGTask (line 525) | void pushDAGTask(Context*) {}
function buildDAG (line 526) | bool buildDAG() { return false; }
type worklists (line 536) | typedef worklists::PerSocketChunkFIFO<OptionsTy::ChunkSize
type worklists (line 537) | typedef worklists::PerThreadChunkLIFO<OptionsTy::ChunkSize
type ThreadLocalData (line 540) | struct ThreadLocalData
function destroyDAGManager (line 562) | void destroyDAGManager() { data.getLocal()->heap.clear(); }
function pushDAGTask (line 564) | void pushDAGTask(Context* ctx) { taskList.push(ctx); }
function buildDAG (line 566) | bool buildDAG() {
type typename (line 743) | typedef typename get_trait_type<det_parallel_break_tag,
function checkBreak (line 755) | bool checkBreak() {
type DeterministicContext (line 768) | typedef DeterministicContext<OptionsTy> Context;
function buildIntentToRead (line 772) | bool buildIntentToRead() { return false; }
type DeterministicContext (line 777) | typedef DeterministicContext<OptionsTy> Context;
type galois (line 778) | typedef galois::gdeque<Context*> WL;
function pushIntentToReadTask (line 785) | void pushIntentToReadTask(Context* ctx) {
function buildIntentToRead (line 791) | bool buildIntentToRead() {
function incrementIterations (line 910) | void incrementIterations() {}
function incrementCommitted (line 911) | void incrementCommitted() {}
function calculateWindow (line 926) | void calculateWindow(bool) {}
type typename (line 935) | typedef typename OptionsTy::value_type value_type;
function id (line 937) | uintptr_t id(const value_type&) { return 0; }
type typename (line 942) | typedef typename OptionsTy::value_type value_type;
type typename (line 943) | typedef
function id (line 951) | uintptr_t id(const value_type& x) { return idFn(x); }
type typename (line 959) | typedef typename OptionsTy::value_type value_type;
type DItem (line 960) | typedef DItem<OptionsTy> Item;
type DNewItem (line 961) | typedef DNewItem<value_type> NewItem;
type std (line 962) | typedef std::vector<NewItem, typename
type typename (line 964) | typedef typename NewItemsTy::iterator NewItemsIterator;
type worklists (line 966) | typedef worklists::PerSocketChunkFIFO<OptionsTy::ChunkSize, NewItem> New...
type GetNewItem (line 968) | struct GetNewItem {
type boost (line 976) | typedef boost::transform_iterator<GetNewItem, boost::counting_iterator<i...
type std (line 978) | typedef std::vector<NewItem, typename
type std (line 980) | typedef std::vector<value_type,
type ThreadLocalData (line 984) | struct ThreadLocalData {
function broadcastLimits (line 1191) | void broadcastLimits(ThreadLocalData& local) {
function receiveLimits (line 1200) | void receiveLimits(ThreadLocalData& local) {
function emptyReserve (line 1255) | bool emptyReserve() { return data.getLocal()->reserve.empty(); }
function clearNewWork (line 1269) | void clearNewWork() { data.getLocal()->heap.clear(); }
type DItem (line 1325) | typedef DItem<OptionsTy> Item;
type DeterministicContext (line 1326) | typedef DeterministicContext<OptionsTy> Context;
type worklists (line 1328) | typedef worklists::PerSocketChunkFIFO<OptionsTy::ChunkSize, Item> WL;
type worklists (line 1329) | typedef worklists::PerSocketChunkFIFO<OptionsTy::ChunkSize, Context>
type worklists (line 1331) | typedef worklists::ChunkFIFO<OptionsTy::ChunkSize, Context, false>
function LoopStat (line 1336) | struct ThreadLocalData : public LoopStat {
function drainPending (line 1368) | void drainPending(ThreadLocalData& tld) {
FILE: libgalois/include/galois/runtime/Executor_DoAll.h
function namespace (line 36) | namespace galois::runtime {
function assignWork (line 216) | void assignWork(const Iter& beg, const Iter& end, const Diff_ty sz) {
function initThread (line 382) | void initThread(void) {
function call (line 464) | void call(const R& range, F&& func, const ArgsT& argsTuple) {
type ChooseDoAllImpl (line 479) | struct ChooseDoAllImpl
function call (line 482) | void call(const R& range, F func, const ArgsT& argsTuple) {
FILE: libgalois/include/galois/runtime/Executor_ForEach.h
function namespace (line 47) | namespace galois {
function fastPushBack (line 293) | void fastPushBack(typename UserContextAccess<value_type>::PushBufferTy& ...
type T1 (line 363) | struct T1 {}
type T2 (line 364) | struct T2 {}
type WLTy (line 431) | typedef WLTy type;
type typename (line 437) | typedef typename WLTy::template
type typename (line 443) | typedef typename std::iterator_traits<typename
type typename (line 445) | typedef typename get_trait_type<wl_tag, ArgsTy>::type::type BaseWorkListTy;
type typename (line 446) | typedef typename reiterator<BaseWorkListTy, typename
type ForEachExecutor (line 451) | typedef ForEachExecutor<WorkListTy, FuncRefType, ArgsTy> WorkTy;
FILE: libgalois/include/galois/runtime/Executor_OnEach.h
function namespace (line 33) | namespace galois {
FILE: libgalois/include/galois/runtime/Executor_Ordered.h
function namespace (line 25) | namespace galois {
FILE: libgalois/include/galois/runtime/Executor_ParaMeter.h
function namespace (line 44) | namespace runtime {
function StepStatsBase (line 82) | struct UnorderedStepStats : public StepStatsBase {
function iterateCurr (line 130) | auto iterateCurr(void) { return galois::runtime::makeLocalRange(*curr); }
function pushNext (line 132) | void pushNext(const T& item) { next->get().push_back(item); }
function nextStep (line 134) | void nextStep(void) {
function empty (line 139) | bool empty(void) const { return next->empty_all(); }
type class (line 181) | enum class
type IterationContext (line 216) | struct IterationContext {
function IterationContext (line 244) | IterationContext* newIteration(const T& item) {
function abortIteration (line 254) | unsigned abortIteration(IterationContext* it) {
function namespace (line 425) | namespace worklists {
function namespace (line 448) | namespace runtime {
FILE: libgalois/include/galois/runtime/ExtraTraits.h
function namespace (line 41) | namespace galois {
FILE: libgalois/include/galois/runtime/Iterable.h
function namespace (line 25) | namespace galois {
FILE: libgalois/include/galois/runtime/LoopStatistics.h
function namespace (line 26) | namespace galois {
FILE: libgalois/include/galois/runtime/Mem.h
function namespace (line 42) | namespace galois {
function class (line 593) | class SizedHeapFactory : private boost::noncopyable {
function class (line 603) | class SizedHeapFactory : public StaticSingleInstance<SizedHeapFactory> {
type VariableSizeHeap (line 637) | struct VariableSizeHeap
function class (line 642) | class FixedSizeHeap {
function deallocate (line 664) | inline void deallocate(void* ptr) { heap->deallocate(ptr); }
function rhs (line 666) | inline bool operator!=(const FixedSizeHeap& rhs) const {
function rhs (line 670) | inline bool operator==(const FixedSizeHeap& rhs) const {
function class (line 675) | class SerialNumaHeap {
type difference_type (line 934) | typedef ptrdiff_t difference_type;
type value_type (line 937) | typedef void value_type;
type Pow_2_BlockAllocator (line 941) | typedef Pow_2_BlockAllocator<Other> other;
type difference_type (line 953) | typedef ptrdiff_t difference_type;
type value_type (line 956) | typedef void value_type;
type ExternalHeapAllocator (line 960) | typedef ExternalHeapAllocator<Other, HeapTy> other;
function destruct (line 966) | inline void destruct(char*) const {}
function destruct (line 967) | inline void destruct(wchar_t*) const {}
function destruct (line 969) | void destruct(T* t) const {
type size_type (line 976) | typedef size_t size_type;
type difference_type (line 977) | typedef ptrdiff_t difference_type;
type Ty (line 978) | typedef Ty* pointer;
type Ty (line 979) | typedef const Ty* const_pointer;
type Ty (line 980) | typedef Ty& reference;
type Ty (line 981) | typedef const Ty& const_reference;
type Ty (line 982) | typedef Ty value_type;
type ExternalHeapAllocator (line 986) | typedef ExternalHeapAllocator<Other, HeapTy> other;
function explicit (line 989) | explicit ExternalHeapAllocator(HeapTy* a) noexcept : heap(a) {}
function pointer (line 996) | inline pointer address(reference val) const { return &val; }
function const_pointer (line 998) | inline const_pointer address(const_reference val) const { return &val; }
function pointer (line 1000) | pointer allocate(size_type size) {
function deallocate (line 1006) | void deallocate(pointer ptr, size_type) { heap->deallocate(ptr); }
function construct (line 1008) | inline void construct(pointer ptr, const_reference val) const {
function destroy (line 1017) | void destroy(pointer ptr) const { destruct(ptr); }
function size_type (line 1019) | size_type max_size() const noexcept {
type SerialNumaAllocator (line 1043) | typedef SerialNumaAllocator<Other> other;
FILE: libgalois/include/galois/runtime/OperatorReferenceTypes.h
function namespace (line 25) | namespace galois {
FILE: libgalois/include/galois/runtime/PagePool.h
function namespace (line 38) | namespace galois {
FILE: libgalois/include/galois/runtime/Profile.h
function namespace (line 41) | namespace galois::runtime {
FILE: libgalois/include/galois/runtime/Range.h
function namespace (line 31) | namespace galois {
function m_list (line 267) | m_list(l) {}
FILE: libgalois/include/galois/runtime/SharedMem.h
function namespace (line 30) | namespace galois::runtime {
FILE: libgalois/include/galois/runtime/Statistics.h
function namespace (line 55) | namespace runtime {
function add (line 147) | void add(const T& val) { (..., Bases::add(val)); }
type StatTotal (line 155) | struct StatTotal {
function namespace (line 162) | namespace internal {
function addToStat (line 365) | void addToStat(const Str& region, const Str& category, const T& val,
function mergeStats (line 370) | void mergeStats(void) {
function const_iterator (line 390) | const_iterator cbegin(void) const { return result.cbegin(); }
function const_iterator (line 391) | const_iterator cend(void) const { return result.cend(); }
function Str (line 393) | const Str& region(const const_iterator& i) const {
function Str (line 397) | const Str& category(const const_iterator& i) const {
function Stat (line 401) | const Stat& stat(const const_iterator& i) const { return result.stat(i); }
function print (line 416) | void print(std::ostream& out) const {
FILE: libgalois/include/galois/runtime/Substrate.h
function namespace (line 25) | namespace galois {
FILE: libgalois/include/galois/runtime/ThreadTimer.h
function namespace (line 9) | namespace galois::runtime {
FILE: libgalois/include/galois/runtime/TiledExecutor.h
function namespace (line 28) | namespace galois {
FILE: libgalois/include/galois/runtime/Tracer.h
function traceImpl (line 43) | static inline void traceImpl(std::ostringstream& os) { os << "\n"; }
function traceImpl (line 49) | inline void traceImpl(std::ostringstream& os, T&&, Args&&... args) {
function traceFormatImpl (line 57) | static inline void traceFormatImpl(std::ostringstream& os, const char* f...
function traceFormatImpl (line 65) | inline void traceFormatImpl(std::ostringstream& os, const char* format,
FILE: libgalois/include/galois/runtime/UserContextAccess.h
function namespace (line 26) | namespace galois {
FILE: libgalois/include/galois/substrate/Barrier.h
function namespace (line 30) | namespace galois {
FILE: libgalois/include/galois/substrate/CacheLineStorage.h
function namespace (line 28) | namespace galois::substrate {
FILE: libgalois/include/galois/substrate/CompilerSpecific.h
function namespace (line 25) | namespace galois::substrate {
FILE: libgalois/include/galois/substrate/EnvCheck.h
function namespace (line 28) | namespace galois {
FILE: libgalois/include/galois/substrate/HWTopo.h
function namespace (line 28) | namespace galois::substrate {
FILE: libgalois/include/galois/substrate/NumaMem.h
function namespace (line 29) | namespace galois {
FILE: libgalois/include/galois/substrate/PaddedLock.h
function namespace (line 26) | namespace galois {
FILE: libgalois/include/galois/substrate/PageAlloc.h
function namespace (line 34) | namespace galois {
type off64_t (line 41) | typedef off64_t offset_t;
function namespace (line 43) | namespace galois {
type off_t (line 50) | typedef off_t offset_t;
function namespace (line 62) | namespace galois {
FILE: libgalois/include/galois/substrate/PerThreadStorage.h
function class (line 36) | class PerBackend {
FILE: libgalois/include/galois/substrate/PtrLock.h
function namespace (line 30) | namespace galois {
FILE: libgalois/include/galois/substrate/SharedMem.h
function namespace (line 30) | namespace galois::substrate {
FILE: libgalois/include/galois/substrate/SimpleLock.h
function namespace (line 30) | namespace galois {
function class (line 92) | class DummyLock {
FILE: libgalois/include/galois/substrate/StaticInstance.h
function namespace (line 26) | namespace galois {
FILE: libgalois/include/galois/substrate/Termination.h
function namespace (line 29) | namespace galois {
function virtual (line 225) | virtual void initializeThread() {
function virtual (line 249) | virtual void localTermination(bool workHappened) {
FILE: libgalois/include/galois/substrate/ThreadPool.h
function namespace (line 34) | namespace galois::substrate::internal {
function namespace (line 51) | namespace galois::substrate {
function ExecuteTuple (line 143) | struct ExecuteTuple {
function getLeaderForSocket (line 183) | unsigned getLeaderForSocket(unsigned pid) const {
function isLeader (line 190) | bool isLeader(unsigned tid) const {
function getSocket (line 193) | unsigned getSocket(unsigned tid) const { return signals[tid]->topo.socke...
function getLeader (line 194) | unsigned getLeader(unsigned tid) const {
function getCumulativeMaxSocket (line 197) | unsigned getCumulativeMaxSocket(unsigned tid) const {
function getNumaNode (line 200) | unsigned getNumaNode(unsigned tid) const {
function getTID (line 204) | static unsigned getTID() { return my_box.topo.tid; }
function isLeader (line 205) | static bool isLeader() { return my_box.topo.tid == my_box.topo.socketLea...
function getLeader (line 206) | static unsigned getLeader() { return my_box.topo.socketLeader; }
function getSocket (line 207) | static unsigned getSocket() { return my_box.topo.socket; }
function getCumulativeMaxSocket (line 208) | static unsigned getCumulativeMaxSocket() {
function getNumaNode (line 211) | static unsigned getNumaNode() { return my_box.topo.numaNode; }
function namespace (line 221) | namespace galois::substrate::internal {
FILE: libgalois/include/galois/substrate/ThreadRWlock.h
function namespace (line 27) | namespace galois {
FILE: libgalois/include/galois/worklists/AdaptiveObim.h
function namespace (line 39) | namespace galois {
type galois (line 262) | typedef galois::flat_map<deltaIndex, CTy*> LMapTy;
function isSlowPopFreq (line 264) | struct ThreadData {
type std (line 312) | typedef std::deque<std::pair<deltaIndex, CTy*>> MasterLog;
function updateLocal (line 324) | bool updateLocal(ThreadData& p) {
function GALOIS_ATTRIBUTE_NOINLINE (line 344) | GALOIS_ATTRIBUTE_NOINLINE
function CTy (line 480) | inline CTy* updateLocalOrCreate(ThreadData& p, deltaIndex i) {
function push (line 510) | void push(const value_type& val) {
FILE: libgalois/include/galois/worklists/BulkSynchronous.h
function namespace (line 30) | namespace galois {
FILE: libgalois/include/galois/worklists/Chunk.h
function namespace (line 30) | namespace galois {
FILE: libgalois/include/galois/worklists/ExternalReference.h
function namespace (line 25) | namespace galois {
FILE: libgalois/include/galois/worklists/LocalQueue.h
function namespace (line 30) | namespace galois {
function push (line 91) | void push(const value_type& val) { local.getLocal()->push(val); }
FILE: libgalois/include/galois/worklists/Obim.h
function namespace (line 34) | namespace galois {
type OrderedByIntegerMetric (line 172) | typedef OrderedByIntegerMetric<Indexer, Container, _period, BSP, T, Index,
type OrderedByIntegerMetric (line 180) | typedef OrderedByIntegerMetric<Indexer, _container, BlockPeriod, BSP, T,
type OrderedByIntegerMetric (line 188) | typedef OrderedByIntegerMetric<_indexer, Container, BlockPeriod, BSP, T,
type OrderedByIntegerMetric (line 196) | typedef OrderedByIntegerMetric<Indexer, Container, BlockPeriod, _bsp, T,
type OrderedByIntegerMetric (line 204) | typedef OrderedByIntegerMetric<Indexer, Container, BlockPeriod, BSP, T,
type OrderedByIntegerMetric (line 212) | typedef OrderedByIntegerMetric<Indexer, Container, BlockPeriod, BSP, T,
type OrderedByIntegerMetric (line 220) | typedef OrderedByIntegerMetric<Indexer, Container, BlockPeriod, BSP, T,
type T (line 226) | typedef T value_type;
type Index (line 227) | typedef Index index_type;
type internal (line 231) | typedef internal::OrderedByIntegerMetricComparator<Index, UseDescending>
type typename (line 233) | typedef typename Comparator::template with_local_map<CTy*>::type LMapTy;
type ThreadData (line 235) | struct ThreadData
type std (line 250) | typedef std::deque<std::pair<Index, CTy*>> MasterLog;
function updateLocal (line 261) | bool updateLocal(ThreadData& p) {
function GALOIS_ATTRIBUTE_NOINLINE (line 281) | GALOIS_ATTRIBUTE_NOINLINE
function CTy (line 341) | inline CTy* updateLocalOrCreate(ThreadData& p, Index i) {
function push (line 363) | void push(const value_type& val) {
FILE: libgalois/include/galois/worklists/OrderedList.h
function namespace (line 26) | namespace galois {
FILE: libgalois/include/galois/worklists/OwnerComputes.h
function namespace (line 26) | namespace galois {
FILE: libgalois/include/galois/worklists/PerThreadChunk.h
function namespace (line 31) | namespace galois {
FILE: libgalois/include/galois/worklists/Simple.h
function namespace (line 31) | namespace galois {
FILE: libgalois/include/galois/worklists/StableIterator.h
function namespace (line 27) | namespace galois {
function doSteal (line 99) | bool doSteal(state& dst, state& src, bool wait) {
function push (line 167) | void push(const value_type& val) { inner.push(val); }
FILE: libgalois/include/galois/worklists/WorkList.h
function namespace (line 36) | namespace galois {
FILE: libgalois/include/galois/worklists/WorkListHelpers.h
function namespace (line 29) | namespace galois {
FILE: libgalois/src/Barrier_Counting.cpp
class CountingBarrier (line 26) | class CountingBarrier : public galois::substrate::Barrier {
method _reinit (line 32) | void _reinit(unsigned val) {
method CountingBarrier (line 41) | CountingBarrier(unsigned int activeT) { _reinit(activeT); }
method reinit (line 45) | virtual void reinit(unsigned val) { _reinit(val); }
method wait (line 47) | virtual void wait() {
FILE: libgalois/src/Barrier_Dissemination.cpp
class DisseminationBarrier (line 33) | class DisseminationBarrier : public galois::substrate::Barrier {
type node (line 35) | struct node {
method node (line 38) | node() : partner(nullptr) {}
method node (line 39) | node(const node& rhs) : partner(rhs.partner) {
type LocalData (line 45) | struct LocalData {
method _reinit (line 55) | void _reinit(unsigned P) {
method DisseminationBarrier (line 75) | DisseminationBarrier(unsigned v) { _reinit(v); }
method reinit (line 77) | virtual void reinit(unsigned val) { _reinit(val); }
method wait (line 79) | virtual void wait() {
FILE: libgalois/src/Barrier_MCS.cpp
class MCSBarrier (line 28) | class MCSBarrier : public galois::substrate::Barrier {
type treenode (line 29) | struct treenode {
method treenode (line 38) | treenode() {}
method treenode (line 39) | treenode(const treenode& rhs)
method _reinit (line 53) | void _reinit(unsigned P) {
method MCSBarrier (line 72) | MCSBarrier(unsigned v) { _reinit(v); }
method reinit (line 74) | virtual void reinit(unsigned val) { _reinit(val); }
method wait (line 76) | virtual void wait() {
FILE: libgalois/src/Barrier_Pthread.cpp
class PthreadBarrier (line 36) | class PthreadBarrier : public galois::substrate::Barrier {
method PthreadBarrier (line 40) | PthreadBarrier() {
method PthreadBarrier (line 46) | PthreadBarrier(unsigned int v) {
method reinit (line 58) | virtual void reinit(unsigned val) {
method wait (line 66) | virtual void wait() {
FILE: libgalois/src/Barrier_Simple.cpp
class OneWayBarrier (line 28) | class OneWayBarrier : public galois::substrate::Barrier {
method OneWayBarrier (line 35) | OneWayBarrier(unsigned p) { reinit(p); }
method reinit (line 39) | virtual void reinit(unsigned val) {
method wait (line 44) | virtual void wait() {
class SimpleBarrier (line 54) | class SimpleBarrier : public galois::substrate::Barrier {
method SimpleBarrier (line 60) | SimpleBarrier(unsigned p) : barrier1(p), barrier2(p), total(p) {}
method reinit (line 64) | virtual void reinit(unsigned val) {
method wait (line 70) | virtual void wait() {
FILE: libgalois/src/Barrier_Topo.cpp
class TopoBarrier (line 28) | class TopoBarrier : public galois::substrate::Barrier {
type treenode (line 29) | struct treenode {
method _reinit (line 47) | void _reinit(unsigned P) {
method TopoBarrier (line 78) | TopoBarrier(unsigned v) { _reinit(v); }
method reinit (line 81) | virtual void reinit(unsigned val) { _reinit(val); }
method wait (line 83) | virtual void wait() {
FILE: libgalois/src/FileGraph.cpp
type galois (line 42) | namespace galois {
type graphs (line 43) | namespace graphs {
function FileGraph (line 64) | FileGraph& FileGraph::operator=(const FileGraph& other) {
function FileGraph (line 78) | FileGraph& FileGraph::operator=(FileGraph&& other) {
function rawBlockSize (line 154) | static size_t rawBlockSize(size_t numNodes, size_t numEdges,
type stat (line 279) | struct stat
function pageInterleaved (line 329) | static void pageInterleaved(void* ptr, uint64_t length, uint32_t hug...
function pageInReadOnly (line 539) | static void pageInReadOnly(void* buf, size_t len, size_t stride) {
FILE: libgalois/src/FileGraphParallel.cpp
type galois (line 27) | namespace galois {
type graphs (line 28) | namespace graphs {
FILE: libgalois/src/GraphHelpers.cpp
type galois (line 22) | namespace galois {
type graphs (line 23) | namespace graphs {
type internal (line 24) | namespace internal {
function determine_block_division (line 26) | uint32_t determine_block_division(uint32_t numDivisions,
function unitRangeCornerCaseHandle (line 53) | bool unitRangeCornerCaseHandle(uint32_t unitsToSplit, uint32_t beg...
function unitRangeSanity (line 94) | void unitRangeSanity(
FILE: libgalois/src/HWTopoDarwin.cpp
function getIntValue (line 38) | int getIntValue(const char* name) {
function HWTopoInfo (line 50) | HWTopoInfo makeHWTopo() {
function HWTopoInfo (line 130) | HWTopoInfo galois::substrate::getHWTopo() {
FILE: libgalois/src/HWTopoLinux.cpp
type cpuinfo (line 47) | struct cpuinfo {
function getNumaNode (line 69) | unsigned getNumaNode(cpuinfo& c) {
function parseCPUInfo (line 100) | std::vector<cpuinfo> parseCPUInfo() {
function countSockets (line 140) | unsigned countSockets(const std::vector<cpuinfo>& info) {
function countCores (line 147) | unsigned countCores(const std::vector<cpuinfo>& info) {
function countNumaNodes (line 154) | unsigned countNumaNodes(const std::vector<cpuinfo>& info) {
function markSMT (line 161) | void markSMT(std::vector<cpuinfo>& info) {
function parseCPUSet (line 170) | std::vector<int> parseCPUSet() {
function markValid (line 203) | void markValid(std::vector<cpuinfo>& info) {
function makeHWTopo (line 215) | galois::substrate::HWTopoInfo makeHWTopo() {
FILE: libgalois/src/NumaMem.cpp
function pageIn (line 31) | static void pageIn(void* _ptr, size_t len, size_t pageSize, unsigned num...
function pageInSpecified (line 76) | static void pageInSpecified(void* _ptr, size_t len, size_t pageSize,
function largeFree (line 133) | static void largeFree(void* ptr, size_t bytes) {
function roundup (line 142) | static size_t roundup(size_t data, size_t mult) {
function LAptr (line 150) | LAptr galois::substrate::largeMallocInterleaved(size_t bytes,
function LAptr (line 172) | LAptr galois::substrate::largeMallocLocal(size_t bytes) {
function LAptr (line 180) | LAptr galois::substrate::largeMallocFloating(size_t bytes) {
function LAptr (line 188) | LAptr galois::substrate::largeMallocBlocked(size_t bytes, unsigned numTh...
function LAptr (line 213) | LAptr galois::substrate::largeMallocSpecified(size_t bytes, uint32_t num...
FILE: libgalois/src/OCFileGraph.cpp
function readHeader (line 104) | static void readHeader(int fd, uint64_t& numNodes, uint64_t& numEdges) {
FILE: libgalois/src/ParaMeter.cpp
type StatsFileManager (line 26) | struct StatsFileManager {
method getTimeStampedName (line 39) | static void getTimeStampedName(std::string& statsFileName) {
method FILE (line 55) | FILE* get(void) {
method close (line 82) | void close(void) {
function StatsFileManager (line 91) | static StatsFileManager& getStatsFileManager(void) {
method getTimeStampedName (line 39) | static void getTimeStampedName(std::string& statsFileName) {
method FILE (line 55) | FILE* get(void) {
method close (line 82) | void close(void) {
function FILE (line 96) | FILE* galois::runtime::ParaMeter::getStatsFile(void) {
FILE: libgalois/src/Statistics.cpp
type rusage (line 49) | struct rusage
function StatManager (line 126) | StatManager* galois::runtime::internal::sysStatManager(void) { return SM; }
FILE: libgalois/src/ThreadPool.cpp
type galois::substrate (line 30) | namespace galois::substrate {
function atomic_append (line 92) | static void atomic_append(std::atomic<T*>& headptr, T* newnode) {
function findID (line 100) | static unsigned findID(std::atomic<T*>& headptr, T* node, unsigned off) {
function T (line 110) | static T* getNth(std::atomic<T*>& headptr, unsigned off) {
FILE: libgalois/src/Threads.cpp
type galois (line 24) | namespace galois {
type runtime (line 25) | namespace runtime {
FILE: libgalois/src/Timer.cpp
function TimeAccumulator (line 51) | TimeAccumulator& TimeAccumulator::operator+=(const TimeAccumulator& rhs) {
function TimeAccumulator (line 56) | TimeAccumulator& TimeAccumulator::operator+=(const Timer& rhs) {
FILE: libgalois/src/Tracer.cpp
type galois (line 44) | namespace galois {
type runtime (line 45) | namespace runtime {
FILE: libgalois/src/gIO.cpp
function printString (line 37) | static void printString(bool error, bool newline, const std::string& pre...
type tm (line 56) | struct tm
FILE: libgalois/test/acquire.cpp
function main (line 26) | int main(int argc, char** argv) {
FILE: libgalois/test/bandwidth.cpp
function random_access (line 28) | void random_access(Gen& gen, int* buf, size_t size, size_t accesses) {
type run_local_helper (line 36) | struct run_local_helper {
method run_local_helper (line 40) | run_local_helper(int* b, size_t s, size_t ss) : block(b), seed(s), siz...
method run_local_helper (line 41) | run_local_helper() {}
function run_local (line 51) | void run_local(size_t seed, size_t mega) {
type run_interleaved_helper (line 61) | struct run_interleaved_helper {
method run_interleaved_helper (line 65) | run_interleaved_helper(int* b, size_t s, size_t ss)
method run_interleaved_helper (line 67) | run_interleaved_helper() {}
function run_interleaved (line 77) | void run_interleaved(size_t seed, size_t mega, bool full) {
function time_run (line 90) | long time_run(Fn fn) {
type F1 (line 98) | struct F1 {
method F1 (line 101) | F1(size_t s, size_t m) : seed(s), mega(m) {}
type F2 (line 105) | struct F2 {
method F2 (line 109) | F2(size_t s, size_t m, bool f) : seed(s), mega(m), full(f) {}
function main (line 113) | int main(int argc, char** argv) {
FILE: libgalois/test/barriers.cpp
type emp (line 33) | struct emp {
method go (line 36) | void go() {
function test (line 53) | void test(std::unique_ptr<galois::substrate::Barrier> b) {
function main (line 76) | int main(int argc, char** argv) {
FILE: libgalois/test/empty-member-lcgraph.cpp
function main (line 22) | int main() {
FILE: libgalois/test/flatmap.cpp
type element (line 30) | struct element {
method element (line 32) | element() : val() {}
method element (line 33) | element(int x) : val(x) {}
type Fn1 (line 43) | struct Fn1 {
type Fn2 (line 49) | struct Fn2 {
function timeMapParallel (line 58) | void timeMapParallel(std::string c, const std::vector<int>& keys) {
function timeMap (line 71) | void timeMap(std::string c, const std::vector<int>& keys) {
function testMap (line 89) | void testMap() {
function timeTests (line 145) | void timeTests(std::string prefix, const std::vector<int>& keys) {
function main (line 152) | int main(int argc, char** argv) {
FILE: libgalois/test/floatingPointErrors.cpp
function multiplyTest (line 29) | void multiplyTest(const double mpcand, const double mplier, const double...
function multiplyTestRational (line 59) | void multiplyTestRational(const Rational& mpcand, const Rational& mplier,
function rationalConversionError (line 90) | void rationalConversionError(double fpVal) {
function main (line 103) | int main() {
FILE: libgalois/test/foreach.cpp
function function_pointer (line 25) | void function_pointer(int x, galois::UserContext<int>&) {
type function_object (line 29) | struct function_object {
function main (line 35) | int main() {
FILE: libgalois/test/forward-declare-graph.cpp
type Node1 (line 23) | struct Node1
type Node1 (line 25) | struct Node1 {
type Node2 (line 30) | struct Node2
type Node2 (line 32) | struct Node2 {
type Node3 (line 37) | struct Node3
type Node3 (line 39) | struct Node3 {
type Node4 (line 44) | struct Node4
type Node4 (line 46) | struct Node4 {
type Node5 (line 51) | struct Node5
type Node5 (line 53) | struct Node5 {
function main (line 58) | int main() {
FILE: libgalois/test/gcollections.cpp
function needs_heap (line 38) | auto constexpr needs_heap(int)
function needs_heap (line 44) | bool constexpr needs_heap(...) {
function addToCollection (line 49) | auto addToCollection(C& c, HeapTy& heap, V&& v) ->
function addToCollection (line 55) | auto addToCollection(C& c, HeapTy&, V&& v) ->
function removeFromCollection (line 61) | auto removeFromCollection(C& c) ->
function removeFromCollection (line 67) | auto removeFromCollection(C& c) ->
type Heap (line 73) | struct Heap {}
type Heap<C, true> (line 76) | struct Heap<C, true> {
method Heap (line 78) | Heap() : heap(sizeof(typename C::block_type)) {}
function testBasic (line 82) | void testBasic(std::string prefix, C&& collection, int N) {
function testNormal (line 106) | void testNormal(std::string prefix, C&& collection, int N) {
function testSort (line 140) | void testSort(std::string prefix, C&& collection, int N) {
function timeAccess (line 167) | void timeAccess(std::string prefix, C&& c, Iterator first, Iterator last) {
function timeAccesses (line 186) | void timeAccesses(std::string prefix, T&& x, int size) {
type element (line 192) | struct element {
method element (line 194) | element(int x) : val(x) {}
function main (line 197) | int main(int argc, char** argv) {
FILE: libgalois/test/graph-compile.cpp
type NoDefault (line 24) | struct NoDefault {
method NoDefault (line 26) | explicit NoDefault(int x) : x(x) {}
function check (line 33) | void check() {
function main (line 71) | int main() {
FILE: libgalois/test/graph.cpp
function useGraph (line 23) | int useGraph(std::string inputfile) {
function useGraphCxx11 (line 49) | int useGraphCxx11(std::string inputfile) {
function main (line 73) | int main(int argc, char** argv) {
FILE: libgalois/test/gslist.cpp
function main (line 26) | int main(int argc, char** argv) {
FILE: libgalois/test/hwtopo.cpp
function printMyTopo (line 25) | void printMyTopo() {
function test (line 40) | void test(const std::string& name, const std::vector<int>& found,
function main (line 60) | int main() {
FILE: libgalois/test/lc-adaptor.cpp
type CSRArrays (line 23) | struct CSRArrays {
class MyGraph (line 31) | class MyGraph
method MyGraph (line 37) | MyGraph(const CSRArrays& i) : m_instance(i) {}
method get_id (line 39) | size_t get_id(GraphNode n) const { return n; }
method node_data_reference (line 41) | node_data_reference get_data(GraphNode n) { return m_instance.nodeData...
method edge_data_reference (line 43) | edge_data_reference get_edge_data(edge_iterator) { return {}; }
method GraphNode (line 45) | GraphNode get_edge_dst(edge_iterator n) { return *n; }
method get_size (line 47) | int get_size() const { return m_instance.numNodes; }
method get_size_edges (line 48) | int get_size_edges() const { return m_instance.numEdges; }
method iterator (line 50) | iterator get_begin() const { return iterator(0); }
method iterator (line 51) | iterator get_end() const { return iterator(m_instance.numNodes); }
method edge_iterator (line 53) | edge_iterator get_edge_begin(GraphNode n) {
method edge_iterator (line 57) | edge_iterator get_edge_end(GraphNode n) {
function main (line 62) | int main() {
FILE: libgalois/test/lock.cpp
function main (line 26) | int main(int argc, char** argv) {
FILE: libgalois/test/lockmgr.cpp
type simple (line 26) | struct simple : public Lockable {
function translate (line 30) | char translate(int i) {
function main (line 45) | int main(int argc, char** argv) {
FILE: libgalois/test/loop-overhead.cpp
function RandomNumber (line 28) | int RandomNumber() { return (rand() % 1000000); }
type emp (line 31) | struct emp {
function t_inline (line 42) | unsigned t_inline(std::vector<unsigned>& V, unsigned num) {
function t_stl (line 53) | unsigned t_stl(std::vector<unsigned>& V, unsigned num) {
function t_omp (line 62) | unsigned t_omp(std::vector<unsigned>& V, unsigned num, unsigned th) {
function t_doall (line 77) | unsigned t_doall(bool burn, bool steal, std::vector<unsigned>& V, unsign...
function t_foreach (line 91) | unsigned t_foreach(bool burn, std::vector<unsigned>& V, unsigned num,
function test (line 107) | void test(
function main (line 125) | int main(int argc, char** argv) {
FILE: libgalois/test/mem.cpp
type element (line 27) | struct element {
method element (line 30) | element(int i) : val(i), next(0) {}
function main (line 33) | int main() {
FILE: libgalois/test/morphgraph-removal.cpp
function traverseOutGraph (line 24) | void traverseOutGraph(G& g) {
function traverseInGraph (line 35) | void traverseInGraph(G& g) {
function traverseInGraph (line 46) | void traverseInGraph(OutGraph&) {}
function constructGraph (line 50) | void constructGraph(G& g, std::vector<typename G::GraphNode>& v) {
function removeGraphOutEdge (line 73) | void removeGraphOutEdge(G& g, typename G::GraphNode n1,
function removeGraphInEdge (line 81) | void removeGraphInEdge(SymGraph& g, SymGraph::GraphNode n1,
function removeGraphInEdge (line 98) | void removeGraphInEdge(InOutGraph& g, InOutGraph::GraphNode n1,
function countUnmatchedEdge (line 114) | unsigned int countUnmatchedEdge(OutGraph& g,
function countUnmatchedEdge (line 147) | unsigned int countUnmatchedEdge(InOutGraph& g,
function countUnmatchedEdge (line 185) | unsigned int countUnmatchedEdge(SymGraph& g,
function testGraphOutEdgeRemoval (line 226) | unsigned int testGraphOutEdgeRemoval(G& g,
function testGraphInEdgeRemoval (line 248) | unsigned int testGraphInEdgeRemoval(G& g,
function main (line 269) | int main() {
FILE: libgalois/test/morphgraph.cpp
function initGraph (line 40) | void initGraph(Graph& g) {
function traverseGraph (line 48) | void traverseGraph(Graph& g) {
function run (line 67) | void run(Graph& g, galois::StatTimer& timer, std::string prompt) {
function main (line 95) | int main(int argc, char** argv) {
FILE: libgalois/test/move.cpp
type MoveOnly (line 28) | struct MoveOnly {
method MoveOnly (line 29) | MoveOnly() = default;
method MoveOnly (line 30) | MoveOnly(MoveOnly&&) = default;
method MoveOnly (line 31) | MoveOnly& operator=(MoveOnly&&) = default;
method MoveOnly (line 32) | MoveOnly(const MoveOnly&) = delete;
method MoveOnly (line 33) | MoveOnly& operator=(const MoveOnly&) = delete;
type MoveOnlyA (line 36) | struct MoveOnlyA {
method MoveOnlyA (line 38) | MoveOnlyA() {}
method MoveOnlyA (line 39) | MoveOnlyA(const MoveOnlyA&) = delete;
method MoveOnly (line 40) | MoveOnly& operator=(const MoveOnlyA&) = delete;
function test (line 45) | void test(T&& x) {
function testContainerA (line 53) | void testContainerA(T&& x, U&& y) {
function testContainerAA (line 61) | void testContainerAA(T&& x, U&& y) {
function testContainerB (line 72) | void testContainerB(T&& x, U&& y) {
function testContainerC (line 80) | void testContainerC(T&& x, U&& y) {
function main (line 87) | int main() {
FILE: libgalois/test/oneach.cpp
function main (line 24) | int main() {
FILE: libgalois/test/papi.cpp
function vecSumSerial (line 27) | size_t vecSumSerial(V& vec) {
function vecSumParallel (line 50) | size_t vecSumParallel(V& vec) {
function main (line 70) | int main(int argc, char* argv[]) {
FILE: libgalois/test/pc.cpp
type testL (line 32) | struct testL {
method testL (line 35) | testL(PerThreadStorage<T>& B) : b(B) {}
type testR (line 44) | struct testR {
method testR (line 47) | testR(PerThreadStorage<T>& B) : b(B) {}
function testf (line 56) | void testf(const char* str) {
function main (line 73) | int main(int argc, char** argv) {
FILE: libgalois/test/reduction.cpp
type Move (line 9) | struct Move {
method Move (line 10) | Move() = default;
method Move (line 12) | Move(const Move&) = delete;
method Move (line 13) | Move(Move&&) noexcept {}
method Move (line 14) | Move& operator=(const Move&) = delete;
method Move (line 15) | Move& operator =(Move&&) noexcept { return *this; }
function test_move (line 18) | void test_move() {
function test_map (line 33) | void test_map() {
function other (line 58) | void other() {}
function test_max (line 60) | void test_max() {
function test_accum (line 74) | void test_accum() {
function main (line 84) | int main() {
FILE: libgalois/test/sort.cpp
function RandomNumber (line 28) | int RandomNumber() { return (rand() % 1000000); }
function IsOdd (line 29) | bool IsOdd(int i) { return ((i % 2) == 1); }
type IsOddS (line 31) | struct IsOddS {
function do_sort (line 37) | int do_sort() {
function do_count_if (line 90) | int do_count_if() {
type mymax (line 124) | struct mymax {
method T (line 125) | T operator()(const T& x, const T& y) const { return std::max(x, y); }
function do_accumulate (line 128) | int do_accumulate() {
function main (line 163) | int main(int argc, char** argv) {
FILE: libgalois/test/static.cpp
function main (line 31) | int main() {
FILE: libgalois/test/traits.cpp
type A (line 6) | struct A {}
type B (line 8) | struct B : public A {
method B (line 10) | B(std::string name) : name_(std::move(name)) {}
method B (line 11) | B() : B("") {}
type Unrelated (line 14) | struct Unrelated {}
function print (line 17) | void print(std::index_sequence<Ints...>, Tuple tup) {
function print (line 22) | void print(Tuple tup) {
function main (line 26) | int main() {
FILE: libgalois/test/twoleveliteratora.cpp
type GetBegin (line 34) | struct GetBegin {
type GetEnd (line 44) | struct GetEnd {
function check_forward (line 54) | void check_forward() {
function check_backward (line 99) | void check_backward() {
function check_strided (line 155) | void check_strided() {
function check_random (line 222) | void check_random() {
function check_forward_iteration (line 271) | void check_forward_iteration() {
function check_backward_iteration (line 323) | void check_backward_iteration() {
function check_strided_iteration (line 361) | void check_strided_iteration() {
function check_random_iteration (line 399) | void check_random_iteration() {
function main (line 419) | int main(int argc, char** argv) {
FILE: libgalois/test/wakeup-overhead.cpp
function runDoAllBurn (line 46) | void runDoAllBurn(int num) {
function runDoAll (line 58) | void runDoAll(int num) {
function runExplicitThread (line 66) | void runExplicitThread(int num) {
function run (line 83) | void run(std::function<void(int)> fn, std::string name) {
function main (line 93) | int main(int argc, char* argv[]) {
FILE: libgalois/test/worklists-compile.cpp
type checker (line 28) | struct checker {
method checker (line 34) | checker() {
function main (line 63) | int main(int argc, char** argv) {
FILE: libgluon/include/galois/cuda/Context.h
type CUDA_Context_Shared (line 36) | struct CUDA_Context_Shared {
type CUDA_Context_Common (line 41) | struct CUDA_Context_Common {
function init_CUDA_context_common (line 62) | bool init_CUDA_context_common(struct CUDA_Context_Common* ctx, int devic...
type CUDA_Context_Common (line 82) | struct CUDA_Context_Common
FILE: libgluon/include/galois/cuda/DynamicBitset.h
function class (line 40) | class DynamicBitset {
function alloc (line 59) | void alloc(size_t nbits) {
function resize (line 69) | void resize(size_t nbits) {
function vec_size (line 76) | size_t vec_size() const {
function reset (line 85) | void reset() {
function __device__ (line 90) | __device__ bool test(const size_t id) const {
function __device__ (line 97) | __device__ void set(const size_t id) {
function __device__ (line 107) | __device__ void batch_reset(const size_t bit_index) {
function __device__ (line 113) | __device__ void batch_bitwise_and(const size_t bit_index,
function copy_to_cpu (line 118) | void copy_to_cpu(uint64_t* bit_vector_cpu_copy) {
function copy_to_gpu (line 125) | void copy_to_gpu(uint64_t* cpu_bit_vector) {
FILE: libgluon/include/galois/cuda/EdgeContext.h
type CUDA_Context_Shared_Edges (line 36) | struct CUDA_Context_Shared_Edges {
type CUDA_Context_Common_Edges (line 41) | struct CUDA_Context_Common_Edges {
function init_CUDA_context_common_edges (line 62) | bool init_CUDA_context_common_edges(struct CUDA_Context_Common_Edges* ctx,
type CUDA_Context_Common_Edges (line 83) | struct CUDA_Context_Common_Edges
FILE: libgluon/include/galois/cuda/EdgeHostDecls.h
type index_type (line 33) | typedef unsigned int index_type;
type node_data_type (line 34) | typedef unsigned int node_data_type;
type edge_data_type (line 35) | typedef unsigned edge_data_type;
type CUDA_Context (line 94) | struct CUDA_Context
type CUDA_Context (line 98) | struct CUDA_Context
type CUDA_Context (line 99) | struct CUDA_Context
type CUDA_Context (line 100) | struct CUDA_Context
type CUDA_Context (line 102) | struct CUDA_Context
FILE: libgluon/include/galois/cuda/HostDecls.h
type index_type (line 33) | typedef unsigned int index_type;
type node_data_type (line 34) | typedef unsigned int node_data_type;
type edge_data_type (line 35) | typedef unsigned int edge_data_type;
type CUDA_Context (line 94) | struct CUDA_Context
type CUDA_Context (line 98) | struct CUDA_Context
type CUDA_Context (line 99) | struct CUDA_Context
type CUDA_Context (line 100) | struct CUDA_Context
type CUDA_Context (line 102) | struct CUDA_Context
FILE: libgluon/include/galois/graphs/GluonEdgeSubstrate.h
function namespace (line 55) | namespace galois {
function extractBatchWrapper (line 1098) | bool extractBatchWrapper(unsigned x, galois::runtime::SendBuffer& b) {
function extractBatchWrapper (line 1125) | bool extractBatchWrapper(unsigned x, galois::runtime::SendBuffer& b,
function setWrapper (line 1150) | void setWrapper(size_t lid, typename FnTy::ValTy val,
function setBatchWrapper (line 1244) | bool setBatchWrapper(unsigned x, galois::runtime::RecvBuffer& b) {
function setBatchWrapper (line 1273) | bool setBatchWrapper(unsigned x, galois::runtime::RecvBuffer& b,
function sync_any_to_any (line 2256) | void sync_any_to_any(std::string loopName) {
function sync (line 2278) | void sync(std::string loopName) {
function set_num_round (line 2431) | inline void set_num_round(const uint32_t round) { num_round = round; }
function std (line 2457) | inline std::string get_run_identifier(std::string loop_name) const {
function std (line 2477) | inline std::string get_run_identifier(std::string loop_name,
FILE: libgluon/include/galois/graphs/GluonSubstrate.h
type WriteLocation (line 53) | enum WriteLocation {
type ReadLocation (line 62) | enum ReadLocation {
function namespace (line 71) | namespace galois {
function extractBatchWrapper (line 1327) | bool extractBatchWrapper(unsigned x, galois::runtime::SendBuffer& b) {
function extractBatchWrapper (line 1354) | bool extractBatchWrapper(unsigned x, galois::runtime::SendBuffer& b,
function setWrapper (line 1379) | void setWrapper(size_t lid, typename FnTy::ValTy val,
function setWrapper (line 1411) | void setWrapper(size_t lid, typename FnTy::ValTy val,
function setBatchWrapper (line 1581) | bool setBatchWrapper(unsigned x, galois::runtime::RecvBuffer& b) {
function setBatchWrapper (line 1610) | bool setBatchWrapper(unsigned x, galois::runtime::RecvBuffer& b,
type typename (line 2725) | typedef typename ReduceFnTy::ValTy T;
type typename (line 2726) | typedef
type typename (line 2776) | typedef typename BroadcastFnTy::ValTy T;
type typename (line 2777) | typedef
function sync_src_to_src (line 2848) | void sync_src_to_src(std::string loopName) {
function sync_src_to_dst (line 2866) | void sync_src_to_dst(std::string loopName) {
function sync_src_to_any (line 2896) | void sync_src_to_any(std::string loopName) {
function sync_dst_to_src (line 2914) | void sync_dst_to_src(std::string loopName) {
function sync_dst_to_dst (line 2944) | void sync_dst_to_dst(std::string loopName) {
function sync_dst_to_any (line 2964) | void sync_dst_to_any(std::string loopName) {
function sync_any_to_src (line 2982) | void sync_any_to_src(std::string loopName) {
function sync_any_to_dst (line 3000) | void sync_any_to_dst(std::string loopName) {
function sync_any_to_any (line 3020) | void sync_any_to_any(std::string loopName) {
function sync (line 3046) | void sync(std::string loopName) {
function call (line 3098) | void call() { GALOIS_DIE("invalid read location for sync on demand"); }
function call (line 3120) | static inline void call(GluonSubstrate* substrate,
function call (line 3154) | static inline void call(GluonSubstrate* substrate,
function call (line 3188) | static inline void call(GluonSubstrate* substrate,
function syncOnDemand (line 3415) | void syncOnDemand(galois::runtime::FieldFlags& fieldFlags,
function set_num_run (line 3440) | inline void set_num_run(const uint32_t runNum) { num_run = runNum; }
function set_num_round (line 3454) | inline void set_num_round(const uint32_t round) { num_round = round; }
function std (line 3480) | inline std::string get_run_identifier(std::string loop_name) const {
function std (line 3500) | inline std::string get_run_identifier(std::string loop_name,
FILE: libgluon/include/galois/runtime/DataCommMode.h
type DataCommMode (line 33) | enum DataCommMode {
FILE: libgluon/include/galois/runtime/GlobalObj.h
function namespace (line 34) | namespace galois {
FILE: libgluon/include/galois/runtime/SyncStructures.h
function namespace (line 39) | namespace galois {
FILE: libgluon/include/galois/runtime/cuda/DeviceEdgeSync.h
type SharedType (line 42) | enum SharedType { sharedMaster, sharedMirror }
type UpdateOp (line 43) | enum UpdateOp { setOp, addOp, minOp }
function kernel_sizing (line 45) | void kernel_sizing(dim3& blocks, dim3& threads) {
function __global__ (line 281) | __global__ void
function __global__ (line 298) | __global__ void bitset_reset_range(DynamicBitset* __restrict__ bitset,
function get_offsets_from_bitset (line 405) | void get_offsets_from_bitset(index_type bitset_size,
type CUDA_Context_Shared_Edges (line 438) | struct CUDA_Context_Shared_Edges
type CUDA_Context_Common_Edges (line 527) | struct CUDA_Context_Common_Edges
type CUDA_Context_Field_Edges (line 528) | struct CUDA_Context_Field_Edges
type CUDA_Context_Shared_Edges (line 652) | struct CUDA_Context_Shared_Edges
FILE: libgluon/include/galois/runtime/cuda/DeviceSync.h
type SharedType (line 44) | enum SharedType { sharedMaster, sharedMirror }
type UpdateOp (line 45) | enum UpdateOp { setOp, addOp, minOp }
function kernel_sizing (line 47) | void kernel_sizing(dim3& blocks, dim3& threads) {
function __global__ (line 283) | __global__ void
function __global__ (line 300) | __global__ void bitset_reset_range(DynamicBitset* __restrict__ bitset,
function get_offsets_from_bitset (line 407) | void get_offsets_from_bitset(index_type bitset_size,
type CUDA_Context_Shared (line 440) | struct CUDA_Context_Shared
type CUDA_Context_Common (line 528) | struct CUDA_Context_Common
type CUDA_Context_Field (line 529) | struct CUDA_Context_Field
type CUDA_Context_Shared (line 653) | struct CUDA_Context_Shared
FILE: libgluon/src/cuda_device.cpp
function get_gpu_device_id (line 33) | int get_gpu_device_id(std::string personality_set, int num_nodes) {
FILE: libgpu/include/Timer.h
function namespace (line 39) | namespace ggc {
function upgrade_timer (line 115) | __attribute__((constructor)) static void upgrade_timer(void) {
FILE: libgpu/include/abitset.h
function unsigned (line 18) | struct Base<unsigned int> {
function unsigned (line 26) | struct Base<unsigned char> {
function __device__ (line 82) | __device__ void set(int pos) {
function __device__ (line 89) | __device__ void unset(int pos) {
function __device__ (line 94) | __device__ int is_set(int pos) const {
function dump (line 107) | void dump() {
type ApproxBitsetInt (line 115) | typedef ApproxBitset<unsigned int> ApproxBitsetInt;
type ApproxBitsetByte (line 116) | typedef ApproxBitset<unsigned char> ApproxBitsetByte;
FILE: libgpu/include/aolist.h
function AppendOnlyList (line 19) | struct AppendOnlyList {
function sort (line 45) | void sort() {
function update_cpu (line 50) | void update_cpu() { list.cpu_rd_ptr(); }
function display_items (line 52) | void display_items() {
function reset (line 64) | void reset() {
function nitems (line 69) | int nitems() {
function __device__ (line 79) | __device__ int push(int item) {
function __device__ (line 87) | __device__ int pop_id(int id, int& item) {
function __device__ (line 108) | __device__ int setup_push_warp_one() {
function __device__ (line 123) | __device__ int setup_push_thread(int nitems) {
function __device__ (line 130) | __device__ int do_push(int start, int id, int item) {
function push_1item (line 137) | int push_1item(int nitem, int item,
function save (line 170) | void save(const char* f, const unsigned iteration) {
function load (line 193) | void load(const char* f, const unsigned iteration) {
FILE: libgpu/include/atomic_helpers.h
function __device__ (line 5) | __device__ static double atomicTestAdd(double* address, double val) {
function __device__ (line 22) | __device__ static float atomicMax(float* address, float val) {
function __device__ (line 34) | __device__ static float atomicMin(float* address, float val) {
function __device__ (line 46) | __device__ static int atomicTestAdd(int* address, int val) {
function __device__ (line 50) | __device__ static float atomicTestAdd(float* address, float val) {
function __device__ (line 54) | __device__ static float atomicTestMin(float* address, float val) {
function __device__ (line 58) | __device__ static float atomicTestMax(float* address, float val) {
function __device__ (line 62) | __device__ static uint32_t atomicTestAdd(uint32_t* address, uint32_t val) {
function __device__ (line 66) | __device__ static uint32_t atomicTestMin(uint32_t* address, uint32_t val) {
function __device__ (line 71) | __device__ static uint32_t atomicTestMax(uint32_t* address, uint32_t val) {
function __device__ (line 76) | __device__ static uint64_t atomicTestAdd(uint64_t* address, uint64_t val) {
function __device__ (line 81) | __device__ static uint64_t atomicTestMin(uint64_t* address, uint64_t val) {
function __device__ (line 88) | __device__ static uint64_t atomicTestMax(uint64_t* address, uint64_t val) {
FILE: libgpu/include/component.h
type ComponentSpace (line 14) | struct ComponentSpace {
function dump_to_file (line 42) | void ComponentSpace::dump_to_file(const char* F) {
function copy (line 66) | void ComponentSpace::copy(ComponentSpace& two) {
function __global__ (line 81) | __global__ void print1x1(ComponentSpace cs) { cs.print1x1(); }
function numberOfElements (line 83) | __device__ unsigned ComponentSpace::numberOfElements() { return nelement...
function numberOfComponents (line 84) | __device__ unsigned ComponentSpace::numberOfComponents() {
function numberOfComponentsHost (line 87) | unsigned ComponentSpace::numberOfComponentsHost() {
function allocate (line 93) | void ComponentSpace::allocate() {
function __global__ (line 98) | __global__ void dinitcs(unsigned nelements, unsigned* complen,
function init (line 107) | void ComponentSpace::init() {
function find (line 119) | __device__ unsigned ComponentSpace::find(unsigned lelement,
FILE: libgpu/include/counter.h
function __device__ (line 23) | static __device__ uint get_smid_reg(void) {
function class (line 29) | class GPUCounter {
function class (line 65) | class Counter {
function __host__ (line 172) | __host__ void zero_gpu() {
FILE: libgpu/include/csr_graph.h
type index_type (line 22) | typedef unsigned index_type;
type edge_data_type (line 23) | typedef int edge_data_type;
type node_data_type (line 24) | typedef int node_data_type;
type CSRGraph (line 27) | struct CSRGraph {
function __host__ (line 48) | __host__ bool valid_edge(index_type edge) {
function index_type (line 52) | index_type getOutDegree(unsigned src) {
function index_type (line 57) | index_type getDestination(unsigned src, unsigned edge) {
function index_type (line 67) | index_type getAbsDestination(unsigned abs_edge) {
function index_type (line 73) | index_type getFirstEdge(unsigned src) {
function edge_data_type (line 78) | edge_data_type getWeight(unsigned src, unsigned edge) {
function edge_data_type (line 88) | edge_data_type getAbsWeight(unsigned abs_edge) {
function init_from_mgraph (line 94) | void init_from_mgraph(int m, int nnz, index_type* h_row_offsets,
function index_type (line 118) | index_type getEdgeDst(unsigned edge) {
function node_data_type (line 122) | node_data_type getData(unsigned vid) {
function index_type (line 125) | index_type edge_begin(unsigned src) {
function index_type (line 129) | index_type edge_end(unsigned src) {
function CSRGraph (line 143) | struct CSRGraphTex : CSRGraph {
type CSRGraphTex (line 201) | typedef CSRGraphTex CSRGraphTy;
type CSRGraph (line 203) | typedef CSRGraph CSRGraphTy;
FILE: libgpu/include/cuda_launch_config.hpp
type __cuda_launch_config_detail (line 89) | namespace __cuda_launch_config_detail {
type util (line 93) | namespace util {
function __host__ (line 96) | inline __host__ __device__ T min_(const T& lhs, const T& rhs) {
type zero_function (line 101) | struct zero_function {
method T (line 102) | T operator()(T) { return 0; }
function __host__ (line 108) | inline __host__ __device__ L divide_ri(const L x, const R y) {
function __host__ (line 115) | inline __host__ __device__ L divide_rz(const L x, const R y) {
function __host__ (line 121) | inline __host__ __device__ L round_i(const L x, const R y) {
function __host__ (line 127) | inline __host__ __device__ L round_z(const L x, const R y) {
function __host__ (line 134) | inline __host__ __device__ size_t
function __host__ (line 149) | inline __host__ __device__ size_t reg_allocation_unit(
function __host__ (line 176) | inline __host__ __device__ size_t
function __host__ (line 182) | inline __host__ __device__ size_t
function __host__ (line 196) | inline __host__ __device__ size_t
function __host__ (line 201) | inline __host__ __device__ size_t max_active_blocks_per_multiprocessor(
function __host__ (line 274) | inline __host__ __device__ size_t default_block_size(
function __host__ (line 306) | inline __host__ __device__ std::size_t
function __host__ (line 314) | inline __host__ __device__ std::size_t
function __host__ (line 323) | inline __host__ std::size_t block_size_with_maximum_potential_occupancy(...
function __host__ (line 346) | inline __host__ std::size_t
function __host__ (line 355) | inline __host__ std::size_t maximum_residency(T t, size_t CTA_SIZE,
function __host__ (line 413) | inline __host__ std::size_t all_resident(T t, const dim3& grid,
FILE: libgpu/include/cutil_subset.h
function __device__ (line 34) | static __device__ uint get_smid(void) {
function __device__ (line 40) | static __device__ uint get_warpid(void) {
function warp_active_count (line 47) | void warp_active_count(int& first, int& offset,
function warp_active_count_zero_active (line 56) | void
FILE: libgpu/include/exclusive.h
function class (line 29) | class ExclusiveLocks {
FILE: libgpu/include/failfast.h
function ff_fprintf (line 18) | static void ff_fprintf(const char* file, const int line, FILE* stream,
FILE: libgpu/include/gg.h
function check_cuda_error (line 38) | static void check_cuda_error(const cudaError_t e, const char* file,
function check_retval (line 47) | void check_retval(const T retval, const T expected, const char* file,
function roundup (line 56) | int roundup(int a, int r) {
function GG_MIN (line 60) | int GG_MIN(int x, int y) {
FILE: libgpu/include/ggc_rt.h
type ggc_rt_dev_info (line 3) | struct ggc_rt_dev_info {
FILE: libgpu/include/instr.h
type trace_file (line 3) | struct trace_file
type instr_trace (line 4) | struct instr_trace
type instr_trace (line 48) | struct instr_trace
type instr_trace (line 50) | struct instr_trace
type instr_trace (line 52) | struct instr_trace
type instr_trace (line 54) | struct instr_trace
type instr_trace (line 55) | struct instr_trace
type instr_trace (line 56) | struct instr_trace
type instr_trace (line 57) | struct instr_trace
type instr_trace (line 58) | struct instr_trace
type instr_trace (line 59) | struct instr_trace
FILE: libgpu/include/internal.h
type cuda_size_t (line 15) | typedef int cuda_size_t;
function __device__ (line 32) | __device__ __host__ multiple_sum(const T e) {
type pair (line 58) | struct pair {
type tb_np (line 83) | struct tb_np {
type empty_np (line 97) | struct empty_np {}
type NPInspector1 (line 114) | struct NPInspector1 {
function valid (line 161) | bool valid(const cuda_size_t ltid) const {
function execute_round_done (line 165) | void execute_round_done(const cuda_size_t ITSIZE) {
FILE: libgpu/include/lockarray.h
function class (line 19) | class LockArraySimple {
function __device__ (line 32) | __device__ bool acquire(int ndx) {
function __device__ (line 40) | __device__ bool acquire_or_fail(int ndx) {
function __device__ (line 45) | __device__ bool is_locked(int ndx) {
function __device__ (line 51) | __device__ void release(int ndx) {
function class (line 58) | class LockArrayTicket : public LockArraySimple {
type LockArraySimple (line 92) | typedef LockArraySimple LockArray;
FILE: libgpu/include/pipe.h
type oi_save (line 18) | struct oi_save {
type oi_save (line 32) | struct oi_save
function swap (line 52) | void swap(int& x, int& y) {
function advance (line 58) | inline void advance() {
function advance2 (line 63) | inline void advance2() { swap(in, out); }
function retry (line 65) | inline void retry() {
function retry2 (line 70) | inline void retry2() { swap(re, in); }
function __host__ (line 72) | __host__ void prep() { check_cuda(cudaMalloc(&ois, sizeof(struct oi_save...
function __device__ (line 74) | __device__ void save() {
function __host__ (line 84) | __host__ void restore() {
function __host__ (line 100) | __host__ void free() {
function save (line 107) | struct PipeContextLight {
type PipeContextT (line 207) | typedef PipeContextT<Worklist2> PipeContext;
type PipeContextT (line 208) | typedef PipeContextT<WorklistT> PipeContextWT;
FILE: libgpu/include/rv.h
function __device__ (line 23) | __device__ void thread_entry() {}
function thread_exit (line 26) | void thread_exit(typename T::TempStorage& temp_storage) {}
function __device__ (line 28) | __device__ void reduce(Type value) {}
function __device__ (line 36) | __device__ void thread_entry() { local = 0; }
function thread_exit (line 39) | void thread_exit(typename T::TempStorage& temp_storage) {
function __device__ (line 47) | __device__ void reduce(Type value) {
type MaxOp (line 57) | struct MaxOp {
function __device__ (line 76) | __device__ void reduce(Type value) {
type MinOp (line 86) | struct MinOp {
function __device__ (line 107) | __device__ void reduce(Type value) {
FILE: libgpu/include/sharedptr.h
function alloc (line 46) | void alloc(size_t nmemb) {
function free (line 62) | void free() {
function find_owner (line 85) | bool find_owner(int& o) {
function T (line 96) | T* cpu_rd_ptr() {
function copy (line 179) | void copy(int src, int dst) {
function T (line 198) | T* ptr() {
function alloc (line 225) | void alloc(size_t nmemb) {
function free (line 231) | bool free() {
function T (line 241) | T* zero_gpu() {
function copy_to_gpu (line 246) | void copy_to_gpu(T* cpu_ptr) { copy_to_gpu(cpu_ptr, nmemb); }
function copy_to_gpu (line 248) | void copy_to_gpu(T* cpu_ptr, size_t nuseb) {
function copy_to_cpu (line 257) | void copy_to_cpu(T* cpu_ptr) { copy_to_cpu(cpu_ptr, nmemb); }
function copy_to_cpu (line 259) | void copy_to_cpu(T* cpu_ptr, size_t nuseb) {
function T (line 268) | T* device_ptr() {
FILE: libgpu/include/snfile.h
type snappy_file (line 7) | struct snappy_file
type snappy_file (line 9) | struct snappy_file
FILE: libgpu/include/thread_work.h
function compute_prefix_sum (line 9) | struct ThreadWork {
function reset_thread_work (line 47) | void reset_thread_work() {
function compute_src_and_offset (line 54) | __device__ unsigned compute_src_and_offset(unsigned first, unsigned last,
FILE: libgpu/include/worklist.h
function __global__ (line 30) | static __global__ void reset_wl(volatile int* dindex) { *dindex = 0; }
function __global__ (line 32) | static __global__ void init_wl(int size, int* dsize, volatile int* dinde...
function else (line 44) | struct Worklist {
function free (line 120) | void free() {
function will_write (line 137) | void will_write() { f_will_write = true; }
function sort (line 139) | void sort() { mergesort(dwl, nitems(), mgpu::less_t<int>(), *mgc); }
function sort_prio (line 141) | void sort_prio() {
function update_gpu (line 145) | void update_gpu(int nsize) {
function update_cpu (line 161) | void update_cpu() {
function display_items (line 167) | void display_items() {
function save (line 180) | void save(const char* f, const unsigned iteration) {
function load (line 201) | void load(const char* f, const unsigned iteration) {
function set_slot (line 231) | void set_slot(int slot) {
function swap_slots (line 236) | inline void swap_slots() {
function reset (line 242) | inline void reset() {
function nitems (line 253) | inline int nitems() {
function __device__ (line 269) | __device__ int push(int item) {
function __device__ (line 290) | __device__ int push_range(int nitems) const {
function __device__ (line 301) | __device__ int push(int item, int prio) {
function __device__ (line 324) | __device__ int push_id(int id, int item) {
function __device__ (line 330) | __device__ int setup_push_warp_one() {
function __device__ (line 351) | __device__ int setup_push_warp_one_za() {
function __device__ (line 392) | __device__ int do_push(int start, int id, int item) const {
function Worklist (line 410) | struct Worklist2 : public Worklist {
function Worklist2 (line 546) | struct WorklistT : public Worklist2 {
type Worklist2Light (line 597) | struct Worklist2Light {
function __host__ (line 612) | __host__ inline int nitems() {
function swap_slots (line 631) | inline void swap_slots() {
function set_slot (line 636) | inline void set_slot(int slot) {
function __device__ (line 652) | __device__ int do_push(int start, int id, int item) {
function __device__ (line 658) | __device__ int push_range(int nitems) const {
function __device__ (line 669) | __device__ int setup_push_warp_one() {
function __device__ (line 690) | __device__ int pop_id(int id, int& item) {
function get_atomic_count (line 702) | int get_atomic_count(Worklist wl) {
function print_atomic_density (line 715) | void print_atomic_density(const char* name,
FILE: libgpu/src/bmk2.c
function bmk2_log_collect (line 18) | int bmk2_log_collect(const char* component, const char* file) {
function init_bmk2 (line 28) | __attribute__((constructor)) void init_bmk2() {
FILE: libgpu/src/snappy.c
type snappy_file (line 12) | struct snappy_file {
function SNAPPY_FILE (line 20) | SNAPPY_FILE snopen(const char* name, const char* mode) {
function snwrite (line 48) | size_t snwrite(SNAPPY_FILE f, void* p, size_t sz) {
function snmin (line 76) | static size_t snmin(size_t a, size_t b) { return a > b ? b : a; }
function snread (line 78) | size_t snread(SNAPPY_FILE f, void* p, size_t sz) {
function sneof (line 154) | int sneof(SNAPPY_FILE f) {
function snclose (line 159) | void snclose(SNAPPY_FILE f) {
FILE: libgpu/src/snappy_test.c
function compress (line 6) | void compress(char* in, char* out) {
function decompress (line 35) | void decompress(char* in, char* out) {
function main (line 69) | int main(int argc, char* argv[]) {
FILE: libpangolin/gpu/pangolin/bitsets.h
function class (line 8) | class Bitsets {
function set_size (line 18) | void set_size(int n, int nbits) {
function alloc (line 23) | void alloc(int n, int nbits) {
function clear (line 39) | void clear() {
function clean (line 46) | void clean() {
function reset (line 55) | void reset(int i) {
function __device__ (line 59) | __device__ void set(int sid, int bid) {
function __device__ (line 72) | __device__ int count_num_ones(int sid, size_t bid) {
FILE: libpangolin/gpu/pangolin/checker.h
function check_cuda_error (line 6) | static void check_cuda_error(const cudaError_t e, const char* file,
FILE: libpangolin/gpu/pangolin/cutils.h
function get_smid (line 26) | static __device__ unsigned get_smid(void) {
function CudaTest (line 32) | inline unsigned CudaTest(const char* msg) {
FILE: libpangolin/gpu/pangolin/graph_gpu.h
type Edge (line 19) | struct Edge {
function class (line 27) | class CSRGraph {
function readFromGR (line 100) | void readFromGR(const char file[]) {
function reconstruct_from_csr (line 168) | void reconstruct_from_csr() {
function read_adj (line 179) | int read_adj(const char* filename) {
FILE: libpangolin/gpu/pangolin/timer.h
function class (line 17) | class Timer {
FILE: libpangolin/include/pangolin/BfsMining/edge_miner.h
type QuickPattern (line 13) | typedef QuickPattern<EmbeddingTy, ElementTy> QPattern;
type CanonicalGraph (line 14) | typedef CanonicalGraph<EmbeddingTy, ElementTy> CPattern;
type std (line 16) | typedef std::unordered_map<QPattern, Frequency> QpMapFreq;
type std (line 18) | typedef std::unordered_map<CPattern, Frequency> CgMapFreq;
type std (line 20) | typedef std::unordered_map<QPattern, DomainSupport*> QpMapDomain;
type std (line 22) | typedef std::unordered_map<CPattern, DomainSupport*> CgMapDomain;
type galois (line 24) | typedef galois::substrate::PerThreadStorage<QpMapFreq> LocalQpMapFreq;
type galois (line 26) | typedef galois::substrate::PerThreadStorage<CgMapFreq> LocalCgMapFreq;
type galois (line 27) | typedef galois::substrate::PerThreadStorage<QpMapDomain> LocalQpMapDomain;
type galois (line 28) | typedef galois::substrate::PerThreadStorage<CgMapDomain> LocalCgMapDomain;
function virtual (line 33) | virtual ~EdgeMiner() {}
function clean (line 34) | void clean() {
function init_emb_list (line 68) | void init_emb_list() {
function inc_total_num (line 72) | void inc_total_num(int value) { total_num += value; }
function solver (line 73) | void solver() {
function init_aggregator (line 175) | inline unsigned init_aggregator() {
function init_filter (line 388) | inline void init_filter() {
function filter (line 449) | inline void filter(unsigned level) {
function set_threshold (line 482) | void set_threshold(const unsigned minsup) { threshold = minsup; }
function printout_agg (line 483) | inline void printout_agg(const CgMapFreq& cg_map) {
function printout_agg (line 487) | inline void printout_agg() {
function support_count (line 500) | inline unsigned support_count() {
function construct_edgemap (line 513) | void construct_edgemap() {
FILE: libpangolin/include/pangolin/BfsMining/edge_miner_api.h
function toExtend (line 11) | static inline bool toExtend(unsigned, const EmbeddingTy&, unsigned) {
function toAdd (line 15) | static inline bool toAdd(unsigned n, const EmbeddingTy& emb, unsigned pos,
function getPattern (line 21) | static inline unsigned getPattern(unsigned GALOIS_USED_ONLY_IN_DEBUG(n),
function is_edge_automorphism (line 55) | static inline bool is_edge_automorphism(unsigned size, const EmbeddingTy...
function swap (line 87) | static inline void swap(std::pair<VertexId, VertexId>& pair) {
function compare (line 94) | static inline int compare(std::pair<VertexId, VertexId>& oneEdge,
FILE: libpangolin/include/pangolin/BfsMining/embedding_list.h
function VertexId (line 15) | VertexId get_vid(unsigned level, size_t id) const {
function IndexTy (line 18) | IndexTy get_idx(unsigned level, size_t id) const {
function BYTE (line 21) | BYTE get_his(unsigned level, size_t id) const { return his_lists[level][...
function get_pid (line 22) | unsigned get_pid(size_t id) const { return pid_list[id]; }
function set_vid (line 23) | void set_vid(unsigned level, size_t id, VertexId vid) {
function set_idx (line 26) | void set_idx(unsigned level, size_t id, IndexTy idx) {
function set_his (line 29) | void set_his(unsigned level, size_t id, BYTE lab) {
function set_pid (line 32) | void set_pid(size_t id, unsigned pid) { pid_list[id] = pid; }
function size (line 34) | size_t size(unsigned level) const { return vid_lists[level].size(); }
function VertexList (line 35) | VertexList get_vid_list(unsigned level) { return vid_lists[level]; }
function UintList (line 36) | UintList get_idx_list(unsigned level) { return idx_lists[level]; }
function ByteList (line 37) | ByteList get_his_list(unsigned level) { return his_lists[level]; }
function remove_tail (line 38) | void remove_tail(size_t idx) {
function add_level (line 45) | void add_level(Ulong size) {
function reset_level (line 56) | void reset_level() {
function clean (line 74) | void clean() {
function get_embedding (line 94) | void get_embedding(unsigned level, size_t pos, EmbeddingType& emb) {
FILE: libpangolin/include/pangolin/BfsMining/engine.h
function main (line 5) | int main(int argc, char** argv) {
FILE: libpangolin/include/pangolin/BfsMining/vertex_miner.h
function virtual (line 18) | virtual ~VertexMiner() {}
function init_emb_list (line 19) | void init_emb_list() {
function is_single_pattern (line 22) | bool is_single_pattern() { return npatterns == 1; }
function get_num_patterns (line 23) | int get_num_patterns() { return npatterns; }
function clean (line 33) | void clean() {
function initialize (line 44) | void initialize(std::string pattern_filename) {
function set_input_pattern (line 62) | void set_input_pattern(unsigned GALOIS_UNUSED(pid)) {
function virtual (line 65) | virtual void print_output() {}
function extend_ordered (line 312) | inline void extend_ordered(unsigned level, size_t chunk_begin,
FILE: libpangolin/include/pangolin/BfsMining/vertex_miner_api.h
function toExtend (line 10) | static inline bool toExtend(unsigned, const EmbeddingTy&, unsigned) {
function toAdd (line 15) | static inline bool toAdd(unsigned n, PangolinGraph& g, const EmbeddingTy...
function toAddOrdered (line 20) | static inline bool toAddOrdered(unsigned, PangolinGraph&, const Embeddin...
function getExtendableVertex (line 26) | static inline unsigned getExtendableVertex(unsigned n) { return n - 1; }
function getPattern (line 29) | static inline unsigned getPattern(unsigned, PangolinGraph&, unsigned,
function is_connected (line 72) | static inline bool is_connected(PangolinGraph& g, unsigned a, unsigned b) {
function is_connected_dag (line 85) | static inline int is_connected_dag(PangolinGraph& g, unsigned key,
function binary_search (line 93) | static inline bool binary_search(PangolinGraph& g, unsigned key,
FILE: libpangolin/include/pangolin/base_embedding.h
function class (line 6) | class BaseEmbedding : public Embedding<SimpleElement> {
function namespace (line 32) | namespace std {
FILE: libpangolin/include/pangolin/canonical_graph.h
type std (line 22) | typedef std::unordered_map<VertexId, BYTE> VertexMap;
type std (line 23) | typedef std::vector<bliss::Graph::Vertex> BlissVertexList;
function cmp (line 51) | int cmp(const CanonicalGraph& other_cg) const {
function other (line 76) | inline bool operator==(const CanonicalGraph& other) const {
function set_number_vertices (line 81) | inline void set_number_vertices(int num_vertices) {
function set_hash_value (line 84) | inline void set_hash_value(unsigned int hash) { hash_value = hash; }
function get_quick_pattern_index (line 85) | inline unsigned get_quick_pattern_index(unsigned i) { return qp_idx[i]; }
function clean (line 87) | inline void clean() { embedding.clean(); }
function construct_cg (line 95) | void construct_cg(bliss::AbstractGraph* ag) {
function transform_to_embedding (line 100) | void transform_to_embedding(bliss::AbstractGraph* ag) {
function VertexId (line 125) | VertexId init_heapAndset(BlissVertexList& vertices, EdgeHeap& min_heap,
FILE: libpangolin/include/pangolin/core.h
type keyvalue (line 3) | typedef struct {
function class (line 8) | class bheap {
FILE: libpangolin/include/pangolin/domain_support.h
function class (line 15) | class DomainSupport {
function set_threshold (line 30) | void set_threshold(unsigned minsup) {
function clean (line 35) | void clean() {
function resize (line 39) | void resize(unsigned n) {
function is_frequent (line 47) | bool is_frequent() { return enough_support; }
function set_frequent (line 48) | void set_frequent() {
function has_domain_reached_support (line 52) | bool has_domain_reached_support(int i) {
function set_domain_frequent (line 57) | void set_domain_frequent(int i) {
function add_vertex (line 61) | void add_vertex(int i, VertexId vid) {
function add_vertices (line 66) | bool add_vertices(int i, IntSet& vertices) {
function get_support (line 76) | inline bool get_support() {
type std (line 90) | typedef std::map<InitPattern, DomainSupport*> InitMap;
type galois (line 91) | typedef galois::substrate::PerThreadStorage<InitMap> InitMaps;
FILE: libpangolin/include/pangolin/edge_embedding.h
function n (line 18) | EdgeInducedEmbedding(size_t n) : Embedding<ElementTy>(n) {}
function set_qpid (line 20) | void set_qpid(unsigned i) { qp_id = i; }
type EdgeInducedEmbedding (line 41) | typedef EdgeInducedEmbedding<LabeledElement> EdgeEmbedding;
FILE: libpangolin/include/pangolin/edge_type.h
function else (line 4) | struct Edge {
type std (line 50) | typedef std::pair<VertexId, VertexId> OrderedEdge;
type std (line 51) | typedef std::priority_queue<Edge, std::vector<Edge>, EdgeComparator> Edg...
FILE: libpangolin/include/pangolin/element.h
function set_history_info (line 23) | struct LabeledElement {
function set_vertex_label (line 53) | inline void set_vertex_label(BYTE lab) { vertex_label = lab; }
function cmp (line 54) | inline int cmp(const LabeledElement& other) const {
function has_history (line 87) | bool has_history() { return true; }
function set_history_info (line 98) | struct StructuralElement {
function set_vertex_label (line 116) | inline void set_vertex_label(BYTE) {}
function cmp (line 117) | inline int cmp(const StructuralElement& other) const {
function has_history (line 134) | bool has_history() { return true; }
function set_history_info (line 143) | struct SimpleElement {
function set_vertex_label (line 157) | inline void set_vertex_label(BYTE) {}
function has_history (line 162) | bool has_history() { return false; }
function cmp (line 163) | inline int cmp(const SimpleElement& other) const {
FILE: libpangolin/include/pangolin/embedding.h
function VertexId (line 21) | VertexId get_vertex(unsigned i) const { return elements[i].get_vid(); }
function BYTE (line 22) | BYTE get_history(unsigned i) const { return elements[i].get_his(); }
function BYTE (line 23) | BYTE get_label(unsigned i) const { return elements[i].get_vlabel(); }
function BYTE (line 24) | BYTE get_key(unsigned i) const { return elements[i].get_key(); }
function iterator (line 26) | iterator begin() { return elements.begin(); }
function iterator (line 27) | iterator end() { return elements.end(); }
function iterator (line 28) | iterator insert(iterator pos, const ElementTy& value) {
function push_back (line 31) | void push_back(ElementTy ele) { elements.push_back(ele); }
function pop_back (line 32) | void pop_back() { elements.pop_back(); }
function resize (line 36) | void resize(size_t n) { elements.resize(n); }
function ElementTy (line 37) | ElementTy* data() { return elements.data(); }
function ElementTy (line 38) | const ElementTy* data() const { return elements.data(); }
function ElementTy (line 39) | ElementTy get_element(unsigned i) const { return elements[i]; }
function set_element (line 40) | void set_element(unsigned i, ElementTy& ele) { elements[i] = ele; }
function set_vertex (line 41) | void set_vertex(unsigned i, VertexId vid) { elements[i].set_vertex_id(vi...
function clean (line 44) | void clean() { elements.clear(); }
FILE: libpangolin/include/pangolin/equivalence.h
function class (line 14) | class VertexPositionEquivalences {
FILE: libpangolin/include/pangolin/gtypes.h
type galois (line 11) | typedef galois::gstl::Vector<BYTE> ByteList;
type galois (line 12) | typedef galois::gstl::Vector<unsigned> UintList;
type galois (line 13) | typedef galois::gstl::Vector<Ulong> UlongList;
type galois (line 14) | typedef galois::gstl::Vector<VertexId> VertexList;
type galois (line 17) | typedef galois::gstl::Set<VertexId> VertexSet;
type galois (line 18) | typedef galois::substrate::PerThreadStorage<UintList> Lists;
type galois (line 19) | typedef galois::substrate::PerThreadStorage<unsigned> Counts;
type galois (line 21) | typedef galois::GAccumulator<unsigned> UintAccu;
type galois (line 22) | typedef galois::GAccumulator<uint64_t> UlongAccu;
type galois (line 23) | typedef galois::substrate::PerThreadStorage<UintMap> LocalUintMap;
type galois (line 29) | typedef galois::gstl::Set<int> IntSet;
type galois (line 30) | typedef galois::gstl::Vector<IntSet> IntSets;
function degree_counting (line 39) | void degree_counting() {
function get_degree (line 48) | uint32_t get_degree(uint32_t n) { return degrees[n]; }
type PangolinGraph (line 51) | typedef PangolinGraph::GraphNode GNode;
FILE: libpangolin/include/pangolin/mgraph.h
type std (line 23) | typedef std::vector<MEdge> MEdgeList;
FILE: libpangolin/include/pangolin/miner.h
type EmbeddingQueue (line 11) | typedef EmbeddingQueue<EmbeddingTy> EmbeddingQueueTy;
function virtual (line 18) | virtual ~Miner() {}
function intersect (line 20) | inline unsigned intersect(unsigned a, unsigned b) {
function intersect_dag (line 23) | inline unsigned intersect_dag(unsigned a, unsigned b) {
function read_graph (line 27) | unsigned read_graph(std::string filetype, std::string filename) {
FILE: libpangolin/include/pangolin/ptypes.h
type QuickPattern (line 7) | typedef QuickPattern<EdgeInducedEmbedding<StructuralElement>, Structural...
type CanonicalGraph (line 9) | typedef CanonicalGraph<EdgeInducedEmbedding<StructuralElement>,
type std (line 12) | typedef std::unordered_map<StrQPattern, Frequency>
type std (line 14) | typedef std::unordered_map<StrCPattern, Frequency>
type galois (line 16) | typedef galois::substrate::PerThreadStorage<StrQpMapFreq> LocalStrQpMapF...
type galois (line 17) | typedef galois::substrate::PerThreadStorage<StrCgMapFreq> LocalStrCgMapF...
FILE: libpangolin/include/pangolin/quick_pattern.h
function get_equivalences (line 35) | void get_equivalences(VertexPositionEquivalences& equ) {
function set_hash (line 64) | inline void set_hash() {
function clean (line 81) | inline void clean() { delete[] elements; }
function set_cgid (line 84) | void set_cgid(unsigned i) { cg_id = i; }
function namespace (line 95) | namespace std {
FILE: libpangolin/include/pangolin/res_man.h
function class (line 17) | class ResourceManager {
FILE: libpangolin/include/pangolin/scan.h
function std (line 5) | inline std::vector<IndexT> PrefixSum(const std::vector<IndexT>& vec) {
FILE: libpangolin/include/pangolin/types.h
type Weight (line 24) | typedef float Weight;
type Ulong (line 25) | typedef uint64_t Ulong;
type ValueT (line 26) | typedef uint32_t ValueT;
type VertexId (line 27) | typedef uint32_t VertexId;
type EdgeId (line 28) | typedef uint64_t EdgeId;
type BYTE (line 29) | typedef uint8_t BYTE;
type IndexT (line 31) | typedef uint64_t IndexT;
type IndexTy (line 32) | typedef uint64_t IndexTy;
type IndexT (line 34) | typedef uint32_t IndexT;
type IndexTy (line 35) | typedef uint32_t IndexTy;
type std (line 38) | typedef std::set<uint32_t> UintSet;
type std (line 39) | typedef std::vector<UintSet> UintSets;
type std (line 41) | typedef std::vector<BYTE> ByteList;
type std (line 42) | typedef std::vector<uint32_t> UintList;
type std (line 43) | typedef std::vector<Ulong> UlongList;
type std (line 44) | typedef std::vector<VertexId> VertexList;
type std (line 45) | typedef std::vector<UintList> IndexLists;
type std (line 46) | typedef std::vector<ByteList> ByteLists;
type std (line 47) | typedef std::vector<VertexList> VertexLists;
type std (line 48) | typedef std::vector<bool> BoolVec;
type MatType (line 54) | typedef float MatType;
type Frequency (line 55) | typedef unsigned Frequency;
type std (line 56) | typedef std::vector<std::vector<MatType>> Matrix;
type std (line 57) | typedef std::unordered_map<unsigned, unsigned> UintMap;
type std (line 58) | typedef std::pair<unsigned, unsigned> InitPattern;
type std (line 59) | typedef std::unordered_map<unsigned, unsigned> FreqMap;
type std (line 60) | typedef std::unordered_map<unsigned, bool> DomainMap;
type std (line 61) | typedef std::map<unsigned, std::map<unsigned, unsigned>> Map2D;
FILE: libpangolin/include/pangolin/util.h
function orientation (line 79) | unsigned orientation(PangolinGraph& og, PangolinGraph& g) {
FILE: libpangolin/include/pangolin/vertex_embedding.h
function class (line 6) | class VertexInducedEmbedding : public Embedding<SimpleElement> {
function namespace (line 43) | namespace std {
type VertexInducedEmbedding (line 52) | typedef VertexInducedEmbedding VertexEmbedding;
FILE: libpangolin/src/BfsMining/embedding_list.cpp
class EmbeddingList<SimpleElement, BaseEmbedding> (line 78) | class EmbeddingList<SimpleElement, BaseEmbedding>
class EmbeddingList<SimpleElement, VertexEmbedding> (line 79) | class EmbeddingList<SimpleElement, VertexEmbedding>
class EmbeddingList<LabeledElement,
EdgeInducedEmbedding<LabeledElement>> (line 80) | class EmbeddingList<LabeledElement,
FILE: libpangolin/src/quick_pattern.cpp
class QuickPattern<VertexEmbedding, SimpleElement> (line 251) | class QuickPattern<VertexEmbedding, SimpleElement>
class QuickPattern<EdgeInducedEmbedding<StructuralElement>,
StructuralElement> (line 252) | class QuickPattern<EdgeInducedEmbedding<StructuralElement>,
class QuickPattern<EdgeInducedEmbedding<LabeledElement>,
LabeledElement> (line 254) | class QuickPattern<EdgeInducedEmbedding<LabeledElement>,
FILE: libpygalois/include/galois/Constants.h
function namespace (line 2) | namespace galois {
FILE: libsupport/include/galois/GetEnv.h
function namespace (line 6) | namespace galois {
FILE: libsupport/include/galois/Logging.h
function string_view (line 20) | struct fmt::formatter<std::error_code> : formatter<string_view> {
function LogLevel (line 31) | enum class LogLevel {
FILE: libsupport/src/GetEnv.cpp
function Convert (line 8) | bool Convert(const std::string& var_val, bool* ret) {
function Convert (line 23) | bool Convert(const std::string& var_val, int* ret) {
function Convert (line 34) | bool Convert(const std::string& var_val, double* ret) {
function Convert (line 45) | bool Convert(const std::string& var_val, std::string* ret) {
function GenericGetEnv (line 51) | bool GenericGetEnv(const std::string& var_name, T* ret) {
FILE: libsupport/src/Logging.cpp
function PrintString (line 10) | void PrintString(bool error, bool flush, const std::string& prefix,
FILE: libsupport/test/getenv.cpp
function main (line 4) | int main() {
FILE: libsupport/test/logging.cpp
function main (line 5) | int main() {
FILE: lonestar/analytics/cpu/betweennesscentrality/AsyncStructs.h
type ForwardPhaseWorkItem (line 18) | struct ForwardPhaseWorkItem {
type FPWorkItemIndexer (line 26) | struct FPWorkItemIndexer {
type BetweenessCentralityAsync (line 56) | struct BetweenessCentralityAsync {
function findLeaves (line 328) | void findLeaves(galois::InsertBag<uint32_t>& fringeWL, unsigned nnodes) {
function AsyncSanity (line 344) | void AsyncSanity(AsyncGraph& graph) {
FILE: lonestar/analytics/cpu/betweennesscentrality/BCEdge.h
type BCEdge (line 26) | struct BCEdge {
function reset (line 47) | inline void reset() {
function checkClear (line 53) | void checkClear(int j) {
FILE: lonestar/analytics/cpu/betweennesscentrality/BCNode.h
function predsContain (line 60) | bool predsContain(const BCNode* a) const {
function reset (line 113) | void reset() {
function initAsSource (line 137) | void initAsSource() {
FILE: lonestar/analytics/cpu/betweennesscentrality/BetweennessCentrality.cpp
type Algo (line 28) | enum Algo { Level = 0, Async, Outer, AutoAlgo }
function main (line 102) | int main(int argc, char** argv) {
FILE: lonestar/analytics/cpu/betweennesscentrality/LevelStructs.h
type LevelNodeData (line 20) | struct LevelNodeData {
function LevelInitializeGraph (line 42) | void LevelInitializeGraph(LevelGraph& graph) {
function LevelInitializeIteration (line 60) | void LevelInitializeIteration(LevelGraph& graph) {
function else (line 121) | else if (destData.currentDistance == nextLevel) {
function LevelSanity (line 196) | void LevelSanity(LevelGraph& graph) {
function doLevelBC (line 224) | void doLevelBC() {
FILE: lonestar/analytics/cpu/betweennesscentrality/OuterStructs.h
function class (line 18) | class BCOuter {
type HasOut (line 281) | struct HasOut {
function doOuterBC (line 292) | void doOuterBC() {
FILE: lonestar/analytics/cpu/bfs/bfs.cpp
type Exec (line 60) | enum Exec { SERIAL, PARALLEL }
type Algo (line 62) | enum Algo { AsyncTile = 0, Async, SyncTile, Sync }
type EdgeTile (line 99) | struct EdgeTile {
type EdgeTileMaker (line 104) | struct EdgeTileMaker {
method EdgeTile (line 105) | EdgeTile operator()(Graph::edge_iterator beg,
type NodePushWrap (line 111) | struct NodePushWrap {
type EdgeTilePushWrap (line 124) | struct EdgeTilePushWrap {
type OneTilePushWrap (line 138) | struct OneTilePushWrap {
function asyncAlgo (line 156) | void asyncAlgo(Graph& graph, GNode source, const P& pushWrap,
function syncAlgo (line 245) | void syncAlgo(Graph& graph, GNode source, const P& pushWrap,
function runAlgo (line 296) | void runAlgo(Graph& graph, const GNode& source) {
function main (line 320) | int main(int argc, char** argv) {
FILE: lonestar/analytics/cpu/bfs/bfsDirectionOpt.cpp
type Exec (line 90) | enum Exec { SERIAL, PARALLEL }
type Algo (line 92) | enum Algo { SyncDO = 0, Async, AutoAlgo }
type EdgeTile (line 125) | struct EdgeTile {
type EdgeTileMaker (line 130) | struct EdgeTileMaker {
method EdgeTile (line 131) | EdgeTile operator()(Graph::edge_iterator beg,
type NodePushWrap (line 137) | struct NodePushWrap {
type EdgeTilePushWrap (line 150) | struct EdgeTilePushWrap {
type OneTilePushWrap (line 164) | struct OneTilePushWrap {
function WlToBitset (line 182) | void WlToBitset(WL& wl, galois::DynamicBitSet& bitset) {
function BitsetToWl (line 190) | void BitsetToWl(const Graph& graph, const galois::DynamicBitSet& bitset,
function syncDOAlgo (line 205) | void syncDOAlgo(Graph& graph, GNode source, const P& pushWrap,
function asyncAlgo (line 345) | void asyncAlgo(Graph& graph, GNode source, const P& pushWrap,
function runAlgo (line 393) | void runAlgo(Graph& graph, const GNode& source, const uint32_t runID) {
function main (line 409) | int main(int argc, char** argv) {
FILE: lonestar/analytics/cpu/bipart/Coarsening.cpp
function hash (line 39) | int hash(unsigned val) {
function parallelRand (line 44) | void parallelRand(std::shared_ptr<MetisGraph> graph, int) {
function PLD_f (line 85) | void PLD_f(GNode node, GGraph* fineGGraph) {
function RAND_f (line 90) | void RAND_f(GNode node, GGraph* fineGGraph) {
function PP_f (line 95) | void PP_f(GNode node, GGraph* fineGGraph) {
function WD_f (line 100) | void WD_f(GNode node, GGraph* fineGGraph) {
function MWD_f (line 108) | void MWD_f(GNode node, GGraph* fineGGraph) {
function RI_f (line 116) | void RI_f(GNode node, GGraph* fineGGraph) {
function MRI_f (line 121) | void MRI_f(GNode node, GGraph* fineGGraph) {
function DEG_f (line 126) | void DEG_f(GNode node, GGraph* fineGGraph) {
function MDEG_f (line 137) | void MDEG_f(GNode node, GGraph* fineGGraph) {
function parallelPrioRand (line 150) | void parallelPrioRand(std::shared_ptr<MetisGraph> graph, int iter) {
function parallelHMatchAndCreateNodes (line 194) | void parallelHMatchAndCreateNodes(std::shared_ptr<MetisGraph> graph, int...
function moreCoarse (line 261) | void moreCoarse(std::shared_ptr<MetisGraph> graph,
function coarsePhaseII (line 331) | void coarsePhaseII(std::shared_ptr<MetisGraph> graph, std::vector<bool>&...
function findLoneNodes (line 388) | void findLoneNodes(GGraph& graph) {
function parallelCreateEdges (line 405) | void parallelCreateEdges(std::shared_ptr<MetisGraph> graph, GNodeBag& bag,
function findMatching (line 597) | void findMatching(std::shared_ptr<MetisGraph> coarseMetisGraph,
function coarsenOnce (line 654) | std::shared_ptr<MetisGraph>
function coarsen (line 665) | std::shared_ptr<MetisGraph> coarsen(std::shared_ptr<MetisGraph> fineMeti...
FILE: lonestar/analytics/cpu/bipart/Metric.cpp
type onlineStat (line 26) | struct onlineStat {
method onlineStat (line 33) | onlineStat()
method add (line 37) | void add(unsigned v) {
method mean (line 45) | double mean() { return (double)val / (double)num; }
method variance (line 47) | double variance() {
method count (line 53) | unsigned count() { return num; }
method total (line 54) | unsigned total() { return val; }
method min (line 55) | unsigned min() { return mmin; }
method max (line 56) | unsigned max() { return mmax; }
function graphStat (line 59) | unsigned graphStat(GGraph& graph) {
function edgeCut (line 71) | std::vector<unsigned> edgeCut(GGraph& g, unsigned nparts) {
function computeCut (line 87) | unsigned computeCut(GGraph& g) {
function printCuts (line 100) | void printCuts(const char* str, MetisGraph* g, unsigned numPartitions) {
FILE: lonestar/analytics/cpu/bipart/Partitioning.cpp
function cut (line 36) | __attribute__((unused)) int cut(GGraph& g) {
function initGain (line 61) | void initGain(GGraph& g) {
function partition (line 116) | void partition(std::shared_ptr<MetisGraph> mcg, unsigned K) {
FILE: lonestar/analytics/cpu/bipart/Refine.cpp
function projectPart (line 31) | void projectPart(std::shared_ptr<MetisGraph> Graph) {
function initGains (line 45) | void initGains(GGraph& g, int) {
function unlock (line 96) | void unlock(GGraph& g) {
function unlocked (line 102) | __attribute__((unused)) void unlocked(GGraph& g) {
function parallel_refine_KF (line 109) | void parallel_refine_KF(GGraph& g, float, unsigned refineTo) {
function parallel_make_balance (line 215) | void parallel_make_balance(GGraph& g, float tol, int p) {
function isPT (line 530) | bool isPT(int n) {
function refine (line 537) | void refine(std::shared_ptr<MetisGraph> coarseGraph, unsigned K,
FILE: lonestar/analytics/cpu/bipart/bipart.cpp
function Partition (line 106) | void Partition(std::shared_ptr<MetisGraph> metisGraph, unsigned coarsenTo,
function computingCut (line 133) | int computingCut(GGraph& g) {
function computingBalance (line 152) | int computingBalance(GGraph& g) {
type order_by_degree (line 170) | struct order_by_degree {
method order_by_degree (line 173) | order_by_degree(GGraph& g, Weights& w) : graph(g), weights(w) {}
function cellToNet (line 189) | std::map<uint64_t, uint64_t>
function hash (line 200) | int hash(unsigned val) {
function main (line 205) | int main(int argc, char** argv) {
FILE: lonestar/analytics/cpu/bipart/bipart.h
type EdgeTy (line 27) | typedef uint32_t EdgeTy;
type GGraph (line 29) | struct GGraph
type scheduleMode (line 42) | enum scheduleMode { PLD, WD, RI, PP, MRI, MWD, DEG, MDEG, HIS, RAND }
type coarseModeII (line 44) | enum coarseModeII { HMETISII, PAIRII }
type pairScheduleModeII (line 45) | enum pairScheduleModeII { FIRSTII, MAXWII, ECII }
function class (line 47) | class MetisNode {
function setWeight (line 126) | void setWeight(int weight) { _weight = weight; }
function setParent (line 128) | void setParent(GNode p) { data.cd.parent = p; }
function getGain (line 133) | int getGain() { return FS - (TE + counter); }
function setMatched (line 135) | void setMatched() { data.cd.matched = true; }
function notMatched (line 136) | void notMatched() { data.cd.matched = false; }
function setFailedMatch (line 139) | void setFailedMatch() { data.cd.failedmatch = true; }
function GNode (line 142) | GNode getChild(unsigned x) const { return children[x]; }
function setChild (line 143) | void setChild(GNode c) { children.push_back(c); }
function setPart (line 147) | void setPart(unsigned val) { data.rd.partition = val; }
function OldPartCpyNew (line 150) | void OldPartCpyNew() { data.rd.oldPartition = data.rd.partition; }
function setmaybeBoundary (line 153) | void setmaybeBoundary(bool val) { data.rd.maybeBoundary = val; }
function setLocked (line 155) | void setLocked(bool locked) { pd.locked = locked; }
function isLocked (line 156) | bool isLocked() { return pd.locked; }
function class (line 169) | class MetisGraph : public std::enable_shared_from_this<MetisGraph> {
FILE: lonestar/analytics/cpu/clustering/clustering.h
type galois (line 86) | typedef galois::LargeArray<uint64_t> largeArray;
type EdgeTy (line 87) | typedef float EdgeTy;
type galois (line 89) | typedef galois::LargeArray<EdgeTy> largeArrayEdgeTy;
function generateRandonNumber (line 684) | uint64_t generateRandonNumber(uint64_t min, uint64_t max) {
function generateRandonNumberDouble (line 692) | uint64_t generateRandonNumberDouble(double min, double max) {
FILE: lonestar/analytics/cpu/clustering/leidenClustering.cpp
type Algo (line 45) | enum Algo { foreach }
type Comm (line 56) | struct Comm {
type Node (line 66) | struct Node {
function algoLeidenWithLocking (line 80) | double algoLeidenWithLocking(Graph& graph, double lower, double threshold,
function runMultiPhaseLouvainAlgorithm (line 224) | void runMultiPhaseLouvainAlgorithm(Graph& graph, uint64_t min_graph_size,
function main (line 316) | int main(int argc, char** argv) {
FILE: lonestar/analytics/cpu/clustering/louvainClustering.cpp
type Algo (line 44) | enum Algo { coloring, foreach, delay, doall }
type Comm (line 62) | struct Comm {
type Node (line 71) | struct Node {
function algoLouvainWithLocking (line 82) | double algoLouvainWithLocking(Graph& graph, double lower, double threshold,
function algoLouvainWithoutLockingDoAll (line 212) | double algoLouvainWithoutLockingDoAll(Graph& graph, double lower,
function algoLouvainWithLockingDelayUpdate (line 344) | double algoLouvainWithLockingDelayUpdate(Graph& graph, double lower,
function coloringDistanceOne (line 484) | uint64_t coloringDistanceOne(Graph& graph) {
function algoLouvainWithColoring (line 566) | double algoLouvainWithColoring(Graph& graph, double lower, double thresh...
function runMultiPhaseLouvainAlgorithm (line 713) | void runMultiPhaseLouvainAlgorithm(Graph& graph, uint32_t min_graph_size,
function main (line 791) | int main(int argc, char** argv) {
FILE: lonestar/analytics/cpu/connected-components/ConnectedComponents.cpp
type Algo (line 48) | enum Algo {
type OutputEdgeType (line 92) | enum OutputEdgeType { void_, int32_, int64_ }
type Node (line 135) | struct Node : public galois::UnionFindNode<Node> {
method Node (line 138) | Node() : galois::UnionFindNode<Node>(const_cast<Node*>(this)) {}
method Node (line 139) | Node(const Node& o) : galois::UnionFindNode<Node>(o.m_component) {}
method Node (line 141) | Node& operator=(const Node& o) {
method component_type (line 147) | component_type component() { return this->get(); }
method isRepComp (line 148) | bool isRepComp(unsigned int) { return false; }
type SerialAlgo (line 156) | struct SerialAlgo {
method readGraph (line 162) | void readGraph(G& graph) {
type LabelPropAlgo (line 183) | struct LabelPropAlgo {
type LNode (line 185) | struct LNode {
method component_type (line 190) | component_type component() { return comp_current; }
method isRep (line 191) | bool isRep() { return false; }
method isRepComp (line 192) | bool isRepComp(unsigned int x) { return x == comp_current; }
method readGraph (line 201) | void readGraph(G& graph) {
type SynchronousAlgo (line 241) | struct SynchronousAlgo {
method readGraph (line 247) | void readGraph(G& graph) {
type Edge (line 251) | struct Edge {
method Edge (line 255) | Edge(GNode src, Node* ddata, int count)
type AsyncAlgo (line 341) | struct AsyncAlgo {
method readGraph (line 347) | void readGraph(G& graph) {
type EdgeAsyncAlgo (line 385) | struct EdgeAsyncAlgo {
method readGraph (line 392) | void readGraph(G& graph) {
type BlockedAsyncAlgo (line 444) | struct BlockedAsyncAlgo {
type WorkItem (line 449) | struct WorkItem {
method readGraph (line 455) | void readGraph(G& graph) {
method process (line 461) | static void process(Graph& graph, const GNode& src,
type EdgeTiledAsyncAlgo (line 523) | struct EdgeTiledAsyncAlgo {
method readGraph (line 529) | void readGraph(G& graph) {
type EdgeTile (line 533) | struct EdgeTile {
function component_type (line 616) | component_type approxLargestComponent(Graph& graph) {
type AfforestAlgo (line 654) | struct AfforestAlgo {
type NodeData (line 655) | struct NodeData : public galois::UnionFindNode<NodeData> {
method NodeData (line 658) | NodeData() : galois::UnionFindNode<NodeData>(const_cast<NodeData*>(t...
method NodeData (line 659) | NodeData(const NodeData& o)
method component_type (line 662) | component_type component() { return this->get(); }
method isRepComp (line 663) | bool isRepComp(unsigned int) { return false; }
method link (line 666) | void link(NodeData* b) {
method readGraph (line 690) | void readGraph(G& graph) {
type EdgeAfforestAlgo (line 764) | struct EdgeAfforestAlgo {
type NodeData (line 765) | struct NodeData : public galois::UnionFindNode<NodeData> {
method NodeData (line 768) | NodeData() : galois::UnionFindNode<NodeData>(const_cast<NodeData*>(t...
method NodeData (line 769) | NodeData(const NodeData& o)
method component_type (line 772) | component_type component() { return this->get(); }
method isRepComp (line 773) | bool isRepComp(unsigned int) { return false; }
method NodeData (line 776) | NodeData* hook_min(NodeData* b, NodeData* c = 0) {
method readGraph (line 808) | void readGraph(G& graph) {
type EdgeTiledAfforestAlgo (line 907) | struct EdgeTiledAfforestAlgo {
type NodeData (line 908) | struct NodeData : public galois::UnionFindNode<NodeData> {
method NodeData (line 911) | NodeData() : galois::UnionFindNode<NodeData>(const_cast<NodeData*>(t...
method NodeData (line 912) | NodeData(const NodeData& o)
method component_type (line 915) | component_type component() { return this->get(); }
method isRepComp (line 916) | bool isRepComp(unsigned int) { return false; }
method link (line 919) | void link(NodeData* b) {
type EdgeTile (line 942) | struct EdgeTile {
method readGraph (line 949) | void readGraph(G& graph) {
function verify (line 1039) | bool verify(
function verify (line 1047) | bool verify(Graph& graph,
function findLargest (line 1075) | typename Graph::node_data_type::component_type findLargest(Graph& graph) {
function initialize (line 1160) | void initialize(Graph&) {}
function run (line 1175) | void run() {
function main (line 1207) | int main(int argc, char** argv) {
FILE: lonestar/analytics/cpu/gmetis/Coarsening.cpp
function HEMmatch (line 33) | std::pair<GNode, int> HEMmatch(GNode node, GGraph* graph, bool) {
function GNode (line 50) | GNode H
Condensed preview — 1074 files, each showing path, character count, and a content snippet. Download the .json file or copy for the full structured content (9,006K chars).
[
{
"path": ".circleci/config.yml",
"chars": 15537,
"preview": "version: 2.1\n\ncommon_step: &cmake_build_test\n - run: |\n cmake --build /tmp/build --target input\n\n if [ -n \"$C"
},
{
"path": ".circleci/longest_common_path.sh",
"chars": 958,
"preview": "#!/bin/bash\n# For PR build only; find the longest common path prefix as the build and test subset\n\nlongest_common_prefix"
},
{
"path": ".clang-format",
"chars": 2046,
"preview": "---\nLanguage: Cpp\nBasedOnStyle: LLVM\nAccessModifierOffset: -2\nAlignAfterOpenBracket: true\nAlignConsecutiveAssign"
},
{
"path": ".clang-tidy",
"chars": 2748,
"preview": "---\n# Enable most checks then disable (-) problematics ones:\n#\n# Some checks are good in principle but cannot be applied"
},
{
"path": ".git-blame-ignore-revs",
"chars": 645,
"preview": "# Bulk-change revisions to ignore in git blame\n#\n# Requires git v2.23\n#\n# To use:\n#\n# git blame --ignore-revs-file .gi"
},
{
"path": ".gitignore",
"chars": 354,
"preview": "# no editor files\n*~\n*.backup\n/.dir-locals.el\n*.orig\n*.patch\n/.project\n.settings\n.*.swo\n*.swp\n.vscode\n\n# no tool generat"
},
{
"path": ".gitmodules",
"chars": 282,
"preview": "[submodule \"moderngpu\"]\n\tpath = external/moderngpu\n\turl = https://github.com/moderngpu/moderngpu.git\n[submodule \"cub\"]\n\t"
},
{
"path": ".travis.yml",
"chars": 8476,
"preview": "dist: bionic\n\nlanguage: c++\n\ngit:\n submodules: true\n\nmatrix:\n include:\n - os: osx\n osx_image: xcode11.3\n "
},
{
"path": "CMakeLists.txt",
"chars": 10374,
"preview": "cmake_minimum_required(VERSION 3.13)\n\nproject(Galois)\n\nlist(APPEND CMAKE_MODULE_PATH \"${CMAKE_CURRENT_SOURCE_DIR}/cmake/"
},
{
"path": "COPYRIGHT",
"chars": 1078,
"preview": "Galois, a framework to exploit amorphous data-parallelism in irregular\nprograms.\n\nCopyright (C) 2018, The University of "
},
{
"path": "LICENSE.txt",
"chars": 1504,
"preview": "The 3-Clause BSD License\n\nCopyright 2018 The University of Texas at Austin\n\nRedistribution and use in source and binary "
},
{
"path": "README.md",
"chars": 11599,
"preview": "Overview\n========\n\n[](https://circle"
},
{
"path": "cmake/GaloisConfig.cmake.in",
"chars": 939,
"preview": "# Config file for the Galois package\n#\n# It exports the following targets:\n# Galois::shmem\n# Galois::dist\n# ...\n# "
},
{
"path": "cmake/Modules/CheckArchFlags.cmake",
"chars": 1139,
"preview": "# Find architecture-specific flags\n#\n# Once done this will define\n# ARCH_FLAGS_FOUND\n# ARCH_CXX_FLAGS - Compiler flags"
},
{
"path": "cmake/Modules/CheckCilk.cmake",
"chars": 267,
"preview": "include(CheckCXXSourceCompiles)\nset(Cilk_CXX_TEST_SOURCE\n\"\n#include <cilk/cilk.h>\nint main(){ cilk_for(int i=0;i<1; ++i)"
},
{
"path": "cmake/Modules/CheckEndian.cmake",
"chars": 472,
"preview": "include(TestBigEndian)\nTEST_BIG_ENDIAN(HAVE_BIG_ENDIAN)\ninclude(CheckIncludeFiles)\nCHECK_INCLUDE_FILES(endian.h HAVE_END"
},
{
"path": "cmake/Modules/CheckHugePages.cmake",
"chars": 541,
"preview": "include(CheckCSourceRuns)\nset(HugePages_C_TEST_SOURCE\n\"\n#ifdef __linux__\n#include <linux/mman.h>\n#endif\n#include <sys/mm"
},
{
"path": "cmake/Modules/CheckMmap.cmake",
"chars": 507,
"preview": "include(CheckCSourceCompiles)\nset(Mmap64_C_TEST_SOURCE\n\"\n#ifdef __linux__\n#include <linux/mman.h>\n#endif\n#include <sys/m"
},
{
"path": "cmake/Modules/CheckSchedSetAffinity.cmake",
"chars": 405,
"preview": "include(CheckSymbolExists)\n\nif(SCHED_SETAFFINITY_FOUND)\n\nelse()\n set(CMAKE_REQUIRED_DEFINITIONS -D_GNU_SOURCE)\n CHECK_"
},
{
"path": "cmake/Modules/FindCBLAS.cmake",
"chars": 3061,
"preview": "# Copyright 2009-2011 The VOTCA Development Team (http://www.votca.org)\n#\n# Licensed under the Apache License, Version 2"
},
{
"path": "cmake/Modules/FindFortran.cmake",
"chars": 532,
"preview": "# Check if Fortran is possibly around before using enable_lanauge because\n# enable_language(... OPTIONAL) does not fail "
},
{
"path": "cmake/Modules/FindGASNET.cmake",
"chars": 739,
"preview": "# Find the GasNet librairy\n# GASNET_FOUND - system has GasNet lib\n# GASNET_INCLUDE_DIR - the GasNet include directory\n"
},
{
"path": "cmake/Modules/FindGMP.cmake",
"chars": 776,
"preview": "# Find the GMP librairies\n# GMP_FOUND - system has GMP lib\n# GMP_INCLUDE_DIR - the GMP include directory\n# GMP_LIBRAR"
},
{
"path": "cmake/Modules/FindGit.cmake",
"chars": 1465,
"preview": "# The module defines the following variables:\n# GIT_EXECUTABLE - path to git command line client\n# GIT_FOUND - true "
},
{
"path": "cmake/Modules/FindNUMA.cmake",
"chars": 696,
"preview": "# Find numa library\n# Once done this will define\n# NUMA_FOUND - libnuma found\n# NUMA_OLD - old libnuma API\nif(NOT NUMA"
},
{
"path": "cmake/Modules/FindOpenCL.cmake",
"chars": 3639,
"preview": "#\n# This file taken from FindOpenCL project @ http://gitorious.com/findopencl\n#\n# - Try to find OpenCL\n# This module tr"
},
{
"path": "cmake/Modules/FindPAPI.cmake",
"chars": 1052,
"preview": "# Find PAPI libraries\n# Once done this will define\n# PAPI_FOUND - System has PAPI\n# PAPI_INCLUDE_DIRS - The PAPI inclu"
},
{
"path": "cmake/Modules/FindQGLViewer.cmake",
"chars": 713,
"preview": "# Find QGLViewer libraries\n# Once done this will define\n# QGLViewer_FOUND - System has QGLViewer\n# QGLViewer_INCLUDE_D"
},
{
"path": "cmake/Modules/FindTBB.cmake",
"chars": 13281,
"preview": "# Locate Intel Threading Building Blocks include paths and libraries\r\n# FindTBB.cmake can be found at https://code.googl"
},
{
"path": "cmake/Modules/FindVTune.cmake",
"chars": 958,
"preview": "# Find VTune libraries\n# Once done this will define\n# VTune_FOUND - System has VTune\n# VTune_INCLUDE_DIRS - The VTune "
},
{
"path": "cmake/Modules/GetGitVersion-write.cmake",
"chars": 620,
"preview": "### Don't include directly, for use by GetSVNVersion.cmake\nfind_package(Git)\n# Extract svn info into MY_XXX variables\nif"
},
{
"path": "cmake/Modules/GetGitVersion.cmake",
"chars": 611,
"preview": "# DUMMY is a non-existent file to force regeneration of svn header every build\nadd_custom_target(revision ALL DEPENDS DU"
},
{
"path": "cmake/Modules/HandleSanitizer.cmake",
"chars": 3825,
"preview": "# Galois: taken from:\n# https://github.com/llvm/llvm-project/blob/master/llvm/cmake/modules/HandleLLVMOptions.cmake \n\n"
},
{
"path": "cmake/Modules/LibFindMacros.cmake",
"chars": 2967,
"preview": "# Copyright Raimar Sandner 2012–2014. Distributed under the Boost Software License, Version 1.0. (See accompanying file "
},
{
"path": "cmake/Modules/UseStdMacro.cmake",
"chars": 81,
"preview": "add_definitions(-D__STDC_LIMIT_MACROS)\nadd_definitions(-D__STDC_CONSTANT_MACROS)\n"
},
{
"path": "config/sanitizers/ubsan_blacklist.txt.in",
"chars": 54,
"preview": "[undefined]\nsrc:@PROJECT_SOURCE_DIR@/external/bliss/*\n"
},
{
"path": "config/version.txt",
"chars": 6,
"preview": "6.0.0\n"
},
{
"path": "external/bliss/bliss/COPYING",
"chars": 35147,
"preview": " GNU GENERAL PUBLIC LICENSE\n Version 3, 29 June 2007\n\n Copyright (C) 2007 Free "
},
{
"path": "external/bliss/bliss/COPYING.LESSER",
"chars": 7651,
"preview": " GNU LESSER GENERAL PUBLIC LICENSE\n Version 3, 29 June 2007\n\n Copyright (C) 2007"
},
{
"path": "external/bliss/bliss/abgraph.hh",
"chars": 30809,
"preview": "#ifndef BLISS_AB_GRAPH_HH\n#define BLISS_AB_GRAPH_HH\n#include <set>\n#include <list>\n#include <cstdio>\n#include <vector>\n#"
},
{
"path": "external/bliss/bliss/bignum.hh",
"chars": 2254,
"preview": "#ifndef BLISS_BIGNUM_HH\n#define BLISS_BIGNUM_HH\n\n/*\n Copyright (c) 2003-2015 Tommi Junttila\n Released under the GNU Le"
},
{
"path": "external/bliss/bliss/defs.hh",
"chars": 3407,
"preview": "#ifndef BLISS_DEFS_HH\n#define BLISS_DEFS_HH\n\n#include <cassert>\n#include <cstdarg>\n\n/*\n Copyright (c) 2003-2015 Tommi J"
},
{
"path": "external/bliss/bliss/graph.hh",
"chars": 39300,
"preview": "#ifndef BLISS_GRAPH_HH\n#define BLISS_GRAPH_HH\n\n#include \"abgraph.hh\"\n\nnamespace bliss {\n\n#ifdef USE_DOMAIN\ntypedef std::"
},
{
"path": "external/bliss/bliss/heap.hh",
"chars": 2294,
"preview": "#ifndef BLISS_HEAP_HH\n#define BLISS_HEAP_HH\n#include <stdlib.h>\n#include <stdio.h>\n#include <limits.h>\nnamespace bliss {"
},
{
"path": "external/bliss/bliss/kqueue.hh",
"chars": 3155,
"preview": "#ifndef BLISS_KQUEUE_HH\n#define BLISS_KQUEUE_HH\n\n/*\n Copyright (c) 2003-2015 Tommi Junttila\n Released under the GNU Le"
},
{
"path": "external/bliss/bliss/kstack.hh",
"chars": 2932,
"preview": "#ifndef BLISS_KSTACK_H\n#define BLISS_KSTACK_H\n\n/*\n Copyright (c) 2003-2015 Tommi Junttila\n Released under the GNU Less"
},
{
"path": "external/bliss/bliss/orbit.hh",
"chars": 3281,
"preview": "#ifndef BLISS_ORBIT_HH\n#define BLISS_ORBIT_HH\n\nnamespace bliss {\nclass Orbit {\n\tclass OrbitEntry {\n\t\tpublic:\n\t\t\tunsigned"
},
{
"path": "external/bliss/bliss/partition.hh",
"chars": 32457,
"preview": "#ifndef BLISS_PARTITION_HH\n#define BLISS_PARTITION_HH\n\n/*\n Copyright (c) 2003-2015 Tommi Junttila\n Released under the "
},
{
"path": "external/bliss/bliss/search.h",
"chars": 38775,
"preview": "\nvoid search(const bool canonical, Stats& stats) {\n const unsigned int N = get_nof_vertices();\n unsigned int al"
},
{
"path": "external/bliss/bliss/uintseqhash.hh",
"chars": 4523,
"preview": "#ifndef BLISS_UINTSEQHASH_HH\n#define BLISS_UINTSEQHASH_HH\n\n#include <cstdio>\nnamespace bliss {\nstatic unsigned int rtab["
},
{
"path": "external/bliss/bliss/utils.hh",
"chars": 2034,
"preview": "#ifndef BLISS_UTILS_HH\n#define BLISS_UTILS_HH\n\n/*\n Copyright (c) 2003-2015 Tommi Junttila\n Released under the GNU Less"
},
{
"path": "inputs/CMakeLists.txt",
"chars": 651,
"preview": "file(WRITE ${CMAKE_CURRENT_BINARY_DIR}/download.cmake \"file(DOWNLOAD http://iss.oden.utexas.edu/projects/galois/download"
},
{
"path": "inputs/cholesky/matrix1.txt",
"chars": 73,
"preview": "4\t0\t0\t2\t0\t1\n0\t7\t2\t0\t0\t3\n0\t2\t3\t0\t0\t0\n2\t0\t0\t6\t3\t0\n0\t0\t0\t3\t7\t3\n1\t3\t0\t0\t3\t11\n"
},
{
"path": "inputs/cholesky/matrix1.txt.choleskyedges",
"chars": 184,
"preview": "0 0 2.000000\n0 3 1.000000\n0 5 0.500000\n1 1 2.645751\n1 2 0.755929\n1 5 1.133893\n2 2 1.558387\n2 5 -0.550019\n3 3 2.236068\n3 "
},
{
"path": "inputs/cholesky/matrix1.txt.dep",
"chars": 12,
"preview": "0 1 2 3 4 5\n"
},
{
"path": "inputs/cholesky/matrix1.txt.filled",
"chars": 183,
"preview": "0 0 4.000000\n0 3 2.000000\n0 5 1.000000\n1 1 7.000000\n1 2 2.000000\n1 5 3.000000\n2 2 3.000000\n2 5 0.000000\n3 3 6.000000\n3 4"
},
{
"path": "inputs/cholesky/very-sparse.txt",
"chars": 431,
"preview": "576.0\t0.0\t0.0\t0.0\t0.0\t0.0\t0.0\t0.0\t0.0\t0.0\n0.0\t256.0\t0.0\t0.0\t0.0\t0.0\t0.0\t0.0\t0.0\t256.0\n0.0\t0.0\t1369.0\t0.0\t0.0\t0.0\t0.0\t0.0"
},
{
"path": "inputs/cholesky/very-sparse.txt.choleskyedges",
"chars": 166,
"preview": "0 0 24.000000\n1 1 16.000000\n1 9 16.000000\n2 2 37.000000\n3 3 12.000000\n4 4 12.000000\n5 5 48.000000\n5 7 25.000000\n6 6 18.0"
},
{
"path": "inputs/cholesky/very-sparse.txt.dep",
"chars": 20,
"preview": "0 1 2 3 4 5 6 7 8 9\n"
},
{
"path": "inputs/cholesky/very-sparse.txt.filled",
"chars": 182,
"preview": "0 0 576.000000\n1 1 256.000000\n1 9 256.000000\n2 2 1369.000000\n3 3 144.000000\n4 4 144.000000\n5 5 2304.000000\n5 7 1200.0000"
},
{
"path": "libcusp/CMakeLists.txt",
"chars": 753,
"preview": "add_library(galois_cusp INTERFACE)\nadd_library(Galois::cusp ALIAS galois_cusp)\nset_target_properties(galois_cusp PROPERT"
},
{
"path": "libcusp/include/galois/graphs/BasePolicies.h",
"chars": 11615,
"preview": "/*\n * This file belongs to the Galois project, a C++ library for exploiting\n * parallelism. The code is being released u"
},
{
"path": "libcusp/include/galois/graphs/CuSPPartitioner.h",
"chars": 5965,
"preview": "/*\n * This file belongs to the Galois project, a C++ library for exploiting\n * parallelism. The code is being released u"
},
{
"path": "libcusp/include/galois/graphs/DistributedGraph.h",
"chars": 30574,
"preview": "/*\n * This file belongs to the Galois project, a C++ library for exploiting\n * parallelism. The code is being released u"
},
{
"path": "libcusp/include/galois/graphs/GenericPartitioners.h",
"chars": 30042,
"preview": "#ifndef _GALOIS_DIST_GENERICPARTS_H\n#define _GALOIS_DIST_GENERICPARTS_H\n\n#include \"DistributedGraph.h\"\n#include \"BasePol"
},
{
"path": "libcusp/include/galois/graphs/MiningPartitioner.h",
"chars": 42040,
"preview": "/*\n * This file belongs to the Galois project, a C++ library for exploiting\n * parallelism. The code is being released u"
},
{
"path": "libcusp/include/galois/graphs/NewGeneric.h",
"chars": 113561,
"preview": "/*\n * This file belongs to the Galois project, a C++ library for exploiting\n * parallelism. The code is being released u"
},
{
"path": "libdist/CMakeLists.txt",
"chars": 2137,
"preview": "add_library(galois_dist_async STATIC)\nadd_library(Galois::dist_async ALIAS galois_dist_async)\nadd_dependencies(lib galoi"
},
{
"path": "libdist/include/galois/DReducible.h",
"chars": 13453,
"preview": "/*\n * This file belongs to the Galois project, a C++ library for exploiting\n * parallelism. The code is being released u"
},
{
"path": "libdist/include/galois/DTerminationDetector.h",
"chars": 6712,
"preview": "/*\n * This file belongs to the Galois project, a C++ library for exploiting\n * parallelism. The code is being released u"
},
{
"path": "libdist/include/galois/DistGalois.h",
"chars": 1930,
"preview": "/*\n * This file belongs to the Galois project, a C++ library for exploiting\n * parallelism. The code is being released u"
},
{
"path": "libdist/include/galois/runtime/BareMPI.h",
"chars": 1548,
"preview": "/*\n * This file belongs to the Galois project, a C++ library for exploiting\n * parallelism. The code is being released u"
},
{
"path": "libdist/include/galois/runtime/DistStats.h",
"chars": 11345,
"preview": "/*\n * This file belongs to the Galois project, a C++ library for exploiting\n * parallelism. The code is being released u"
},
{
"path": "libdist/include/galois/runtime/LWCI.h",
"chars": 2970,
"preview": "/*\n * This file belongs to the Galois project, a C++ library for exploiting\n * parallelism. The code is being released u"
},
{
"path": "libdist/include/galois/runtime/MemUsage.h",
"chars": 2532,
"preview": "/*\n * This file belongs to the Galois project, a C++ library for exploiting\n * parallelism. The code is being released u"
},
{
"path": "libdist/include/galois/runtime/Network.h",
"chars": 8336,
"preview": "/*\n * This file belongs to the Galois project, a C++ library for exploiting\n * parallelism. The code is being released u"
},
{
"path": "libdist/include/galois/runtime/NetworkIO.h",
"chars": 4973,
"preview": "/*\n * This file belongs to the Galois project, a C++ library for exploiting\n * parallelism. The code is being released u"
},
{
"path": "libdist/include/galois/runtime/Serialize.h",
"chars": 31992,
"preview": "/*\n * This file belongs to the Galois project, a C++ library for exploiting\n * parallelism. The code is being released u"
},
{
"path": "libdist/src/Barrier.cpp",
"chars": 3952,
"preview": "/*\n * This file belongs to the Galois project, a C++ library for exploiting\n * parallelism. The code is being released u"
},
{
"path": "libdist/src/DistGalois.cpp",
"chars": 1758,
"preview": "/*\n * This file belongs to the Galois project, a C++ library for exploiting\n * parallelism. The code is being released u"
},
{
"path": "libdist/src/DistStats.cpp",
"chars": 12576,
"preview": "/*\n * This file belongs to the Galois project, a C++ library for exploiting\n * parallelism. The code is being released u"
},
{
"path": "libdist/src/Network.cpp",
"chars": 4673,
"preview": "/*\n * This file belongs to the Galois project, a C++ library for exploiting\n * parallelism. The code is being released u"
},
{
"path": "libdist/src/NetworkBuffered.cpp",
"chars": 17590,
"preview": "/*\n * This file belongs to the Galois project, a C++ library for exploiting\n * parallelism. The code is being released u"
},
{
"path": "libdist/src/NetworkIOMPI.cpp",
"chars": 7580,
"preview": "/*\n * This file belongs to the Galois project, a C++ library for exploiting\n * parallelism. The code is being released u"
},
{
"path": "libdist/src/NetworkLCI.cpp",
"chars": 9062,
"preview": "/*\n * This file belongs to the Galois project, a C++ library for exploiting\n * parallelism. The code is being released u"
},
{
"path": "libgalois/CMakeLists.txt",
"chars": 3669,
"preview": "add_library(galois_shmem)\nadd_library(Galois::shmem ALIAS galois_shmem)\nset_target_properties(galois_shmem PROPERTIES EX"
},
{
"path": "libgalois/include/galois/ArrayWrapper.h",
"chars": 2089,
"preview": "/*\n * This file belongs to the Galois project, a C++ library for exploiting\n * parallelism. The code is being released u"
},
{
"path": "libgalois/include/galois/AtomicHelpers.h",
"chars": 5582,
"preview": "/*\n * This file belongs to the Galois project, a C++ library for exploiting\n * parallelism. The code is being released u"
},
{
"path": "libgalois/include/galois/AtomicWrapper.h",
"chars": 2133,
"preview": "/*\n * This file belongs to the Galois project, a C++ library for exploiting\n * parallelism. The code is being released u"
},
{
"path": "libgalois/include/galois/Bag.h",
"chars": 8345,
"preview": "/*\n * This file belongs to the Galois project, a C++ library for exploiting\n * parallelism. The code is being released u"
},
{
"path": "libgalois/include/galois/CheckedObject.h",
"chars": 2184,
"preview": "/*\n * This file belongs to the Galois project, a C++ library for exploiting\n * parallelism. The code is being released u"
},
{
"path": "libgalois/include/galois/CopyableTuple.h",
"chars": 2377,
"preview": "/*\n * This file belongs to the Galois project, a C++ library for exploiting\n * parallelism. The code is being released u"
},
{
"path": "libgalois/include/galois/DynamicBitset.h",
"chars": 12896,
"preview": "/*\n * This file belongs to the Galois project, a C++ library for exploiting\n * parallelism. The code is being released u"
},
{
"path": "libgalois/include/galois/Endian.h",
"chars": 3078,
"preview": "/*\n * This file belongs to the Galois project, a C++ library for exploiting\n * parallelism. The code is being released u"
},
{
"path": "libgalois/include/galois/FixedSizeRing.h",
"chars": 12649,
"preview": "/*\n * This file belongs to the Galois project, a C++ library for exploiting\n * parallelism. The code is being released u"
},
{
"path": "libgalois/include/galois/FlatMap.h",
"chars": 12531,
"preview": "/*\n * This file belongs to the Galois project, a C++ library for exploiting\n * parallelism. The code is being released u"
},
{
"path": "libgalois/include/galois/Galois.h",
"chars": 1310,
"preview": "/*\n * This file belongs to the Galois project, a C++ library for exploiting\n * parallelism. The code is being released u"
},
{
"path": "libgalois/include/galois/GaloisForwardDecl.h",
"chars": 1627,
"preview": "/*\n * This file belongs to the Galois project, a C++ library for exploiting\n * parallelism. The code is being released u"
},
{
"path": "libgalois/include/galois/LargeArray.h",
"chars": 11593,
"preview": "/*\n * This file belongs to the Galois project, a C++ library for exploiting\n * parallelism. The code is being released u"
},
{
"path": "libgalois/include/galois/LazyArray.h",
"chars": 4475,
"preview": "/*\n * This file belongs to the Galois project, a C++ library for exploiting\n * parallelism. The code is being released u"
},
{
"path": "libgalois/include/galois/LazyObject.h",
"chars": 4087,
"preview": "/*\n * This file belongs to the Galois project, a C++ library for exploiting\n * parallelism. The code is being released u"
},
{
"path": "libgalois/include/galois/Loops.h",
"chars": 8308,
"preview": "/*\n * This file belongs to the Galois project, a C++ library for exploiting\n * parallelism. The code is being released u"
},
{
"path": "libgalois/include/galois/Mem.h",
"chars": 2193,
"preview": "/*\n * This file belongs to the Galois project, a C++ library for exploiting\n * parallelism. The code is being released u"
},
{
"path": "libgalois/include/galois/MethodFlags.h",
"chars": 1995,
"preview": "/*\n * This file belongs to the Galois project, a C++ library for exploiting\n * parallelism. The code is being released u"
},
{
"path": "libgalois/include/galois/NoDerefIterator.h",
"chars": 2176,
"preview": "/*\n * This file belongs to the Galois project, a C++ library for exploiting\n * parallelism. The code is being released u"
},
{
"path": "libgalois/include/galois/PODResizeableArray.h",
"chars": 6155,
"preview": "/*\n * This file belongs to the Galois project, a C++ library for exploiting\n * parallelism. The code is being released u"
},
{
"path": "libgalois/include/galois/ParallelSTL.h",
"chars": 13181,
"preview": "/*\n * This file belongs to the Galois project, a C++ library for exploiting\n * parallelism. The code is being released u"
},
{
"path": "libgalois/include/galois/PerThreadContainer.h",
"chars": 18876,
"preview": "/*\n * This file belongs to the Galois project, a C++ library for exploiting\n * parallelism. The code is being released u"
},
{
"path": "libgalois/include/galois/PriorityQueue.h",
"chars": 10438,
"preview": "/*\n * This file belongs to the Galois project, a C++ library for exploiting\n * parallelism. The code is being released u"
},
{
"path": "libgalois/include/galois/Reduction.h",
"chars": 6906,
"preview": "/*\n * This file belongs to the Galois project, a C++ library for exploiting\n * parallelism. The code is being released u"
},
{
"path": "libgalois/include/galois/SharedMemSys.h",
"chars": 643,
"preview": "#ifndef GALOIS_SHAREDMEMSYS_H\n#define GALOIS_SHAREDMEMSYS_H\n\n#include \"galois/config.h\"\n#include \"galois/runtime/SharedM"
},
{
"path": "libgalois/include/galois/Threads.h",
"chars": 1711,
"preview": "/*\n * This file belongs to the Galois project, a C++ library for exploiting\n * parallelism. The code is being released u"
},
{
"path": "libgalois/include/galois/Timer.h",
"chars": 3257,
"preview": "/*\n * This file belongs to the Galois project, a C++ library for exploiting\n * parallelism. The code is being released u"
},
{
"path": "libgalois/include/galois/Traits.h",
"chars": 12428,
"preview": "/*\n * This file belongs to the Galois project, a C++ library for exploiting\n * parallelism. The code is being released u"
},
{
"path": "libgalois/include/galois/TwoLevelIterator.h",
"chars": 22501,
"preview": "/*\n * This file belongs to the Galois project, a C++ library for exploiting\n * parallelism. The code is being released u"
},
{
"path": "libgalois/include/galois/TwoLevelIteratorA.h",
"chars": 13781,
"preview": "/*\n * This file belongs to the Galois project, a C++ library for exploiting\n * parallelism. The code is being released u"
},
{
"path": "libgalois/include/galois/UnionFind.h",
"chars": 3868,
"preview": "/*\n * This file belongs to the Galois project, a C++ library for exploiting\n * parallelism. The code is being released u"
},
{
"path": "libgalois/include/galois/UserContext.h",
"chars": 4363,
"preview": "/*\n * This file belongs to the Galois project, a C++ library for exploiting\n * parallelism. The code is being released u"
},
{
"path": "libgalois/include/galois/Version.h",
"chars": 1434,
"preview": "/*\n * This file belongs to the Galois project, a C++ library for exploiting\n * parallelism. The code is being released u"
},
{
"path": "libgalois/include/galois/config.h.in",
"chars": 3343,
"preview": "#ifndef GALOIS_CONFIG_H\n#define GALOIS_CONFIG_H\n\n#if !(defined(GALOIS_USE_LONGJMP_ABORT) || defined(GALOIS_USE_EXCEPTION"
},
{
"path": "libgalois/include/galois/gIO.h",
"chars": 4452,
"preview": "/*\n * This file belongs to the Galois project, a C++ library for exploiting\n * parallelism. The code is being released u"
},
{
"path": "libgalois/include/galois/gdeque.h",
"chars": 13122,
"preview": "/*\n * This file belongs to the Galois project, a C++ library for exploiting\n * parallelism. The code is being released u"
},
{
"path": "libgalois/include/galois/graphs/BufferedGraph.h",
"chars": 16602,
"preview": "/*\n * This file belongs to the Galois project, a C++ library for exploiting\n * parallelism. The code is being released u"
},
{
"path": "libgalois/include/galois/graphs/Details.h",
"chars": 12861,
"preview": "/*\n * This file belongs to the Galois project, a C++ library for exploiting\n * parallelism. The code is being released u"
},
{
"path": "libgalois/include/galois/graphs/FileGraph.h",
"chars": 27648,
"preview": "/*\n * This file belongs to the Galois project, a C++ library for exploiting\n * parallelism. The code is being released u"
},
{
"path": "libgalois/include/galois/graphs/Graph.h",
"chars": 1341,
"preview": "/*\n * This file belongs to the Galois project, a C++ library for exploiting\n * parallelism. The code is being released u"
},
{
"path": "libgalois/include/galois/graphs/GraphHelpers.h",
"chars": 21714,
"preview": "/*\n * This file belongs to the Galois project, a C++ library for exploiting\n * parallelism. The code is being released u"
},
{
"path": "libgalois/include/galois/graphs/LCGraph.h",
"chars": 1530,
"preview": "/*\n * This file belongs to the Galois project, a C++ library for exploiting\n * parallelism. The code is being released u"
},
{
"path": "libgalois/include/galois/graphs/LC_Adaptor_Graph.h",
"chars": 4706,
"preview": "/*\n * This file belongs to the Galois project, a C++ library for exploiting\n * parallelism. The code is being released u"
},
{
"path": "libgalois/include/galois/graphs/LC_CSR_CSC_Graph.h",
"chars": 15597,
"preview": "/*\n * This file belongs to the Galois project, a C++ library for exploiting\n * parallelism. The code is being released u"
},
{
"path": "libgalois/include/galois/graphs/LC_CSR_Graph.h",
"chars": 33722,
"preview": "/*\n * This file belongs to the Galois project, a C++ library for exploiting\n * parallelism. The code is being released u"
},
{
"path": "libgalois/include/galois/graphs/LC_CSR_Hypergraph.h",
"chars": 27857,
"preview": "/*\n * This file belongs to the Galois project, a C++ library for exploiting\n * parallelism. The code is being released u"
},
{
"path": "libgalois/include/galois/graphs/LC_InOut_Graph.h",
"chars": 10044,
"preview": "/*\n * This file belongs to the Galois project, a C++ library for exploiting\n * parallelism. The code is being released u"
},
{
"path": "libgalois/include/galois/graphs/LC_InlineEdge_Graph.h",
"chars": 13206,
"preview": "/*\n * This file belongs to the Galois project, a C++ library for exploiting\n * parallelism. The code is being released u"
},
{
"path": "libgalois/include/galois/graphs/LC_Linear_Graph.h",
"chars": 13216,
"preview": "/*\n * This file belongs to the Galois project, a C++ library for exploiting\n * parallelism. The code is being released u"
},
{
"path": "libgalois/include/galois/graphs/LC_Morph_Graph.h",
"chars": 21431,
"preview": "/*\n * This file belongs to the Galois project, a C++ library for exploiting\n * parallelism. The code is being released u"
},
{
"path": "libgalois/include/galois/graphs/MorphGraph.h",
"chars": 48204,
"preview": "/*\n * This file belongs to the Galois project, a C++ library for exploiting\n * parallelism. The code is being released u"
},
{
"path": "libgalois/include/galois/graphs/MorphHyperGraph.h",
"chars": 50928,
"preview": "/*\n * This file belongs to the Galois project, a C++ library for exploiting\n * parallelism. The code is being released u"
},
{
"path": "libgalois/include/galois/graphs/Morph_SepInOut_Graph.h",
"chars": 40902,
"preview": "/*\n * This file belongs to the Galois project, a C++ library for exploiting\n * parallelism. The code is being released u"
},
{
"path": "libgalois/include/galois/graphs/OCGraph.h",
"chars": 18939,
"preview": "/*\n * This file belongs to the Galois project, a C++ library for exploiting\n * parallelism. The code is being released u"
},
{
"path": "libgalois/include/galois/graphs/OfflineGraph.h",
"chars": 16217,
"preview": "/*\n * This file belongs to the Galois project, a C++ library for exploiting\n * parallelism. The code is being released u"
},
{
"path": "libgalois/include/galois/graphs/ReadGraph.h",
"chars": 7780,
"preview": "/*\n * This file belongs to the Galois project, a C++ library for exploiting\n * parallelism. The code is being released u"
},
{
"path": "libgalois/include/galois/graphs/SpatialTree.h",
"chars": 5272,
"preview": "/*\n * This file belongs to the Galois project, a C++ library for exploiting\n * parallelism. The code is being released u"
},
{
"path": "libgalois/include/galois/graphs/TypeTraits.h",
"chars": 1482,
"preview": "/*\n * This file belongs to the Galois project, a C++ library for exploiting\n * parallelism. The code is being released u"
},
{
"path": "libgalois/include/galois/gslist.h",
"chars": 8440,
"preview": "/*\n * This file belongs to the Galois project, a C++ library for exploiting\n * parallelism. The code is being released u"
},
{
"path": "libgalois/include/galois/gstl.h",
"chars": 8213,
"preview": "/*\n * This file belongs to the Galois project, a C++ library for exploiting\n * parallelism. The code is being released u"
},
{
"path": "libgalois/include/galois/optional.h",
"chars": 3725,
"preview": "/*\n * This file belongs to the Galois project, a C++ library for exploiting\n * parallelism. The code is being released u"
},
{
"path": "libgalois/include/galois/runtime/Context.h",
"chars": 6795,
"preview": "/*\n * This file belongs to the Galois project, a C++ library for exploiting\n * parallelism. The code is being released u"
},
{
"path": "libgalois/include/galois/runtime/Executor_Deterministic.h",
"chars": 48869,
"preview": "/*\n * This file belongs to the Galois project, a C++ library for exploiting\n * parallelism. The code is being released u"
},
{
"path": "libgalois/include/galois/runtime/Executor_DoAll.h",
"chars": 14678,
"preview": "/*\n * This file belongs to the Galois project, a C++ library for exploiting\n * parallelism. The code is being released u"
},
{
"path": "libgalois/include/galois/runtime/Executor_ForEach.h",
"chars": 15358,
"preview": "/*\n * This file belongs to the Galois project, a C++ library for exploiting\n * parallelism. The code is being released u"
},
{
"path": "libgalois/include/galois/runtime/Executor_OnEach.h",
"chars": 2773,
"preview": "/*\n * This file belongs to the Galois project, a C++ library for exploiting\n * parallelism. The code is being released u"
},
{
"path": "libgalois/include/galois/runtime/Executor_Ordered.h",
"chars": 2398,
"preview": "/*\n * This file belongs to the Galois project, a C++ library for exploiting\n * parallelism. The code is being released u"
},
{
"path": "libgalois/include/galois/runtime/Executor_ParaMeter.h",
"chars": 13020,
"preview": "/*\n * This file belongs to the Galois project, a C++ library for exploiting\n * parallelism. The code is being released u"
},
{
"path": "libgalois/include/galois/runtime/ExtraTraits.h",
"chars": 2598,
"preview": "/*\n * This file belongs to the Galois project, a C++ library for exploiting\n * parallelism. The code is being released u"
},
{
"path": "libgalois/include/galois/runtime/Iterable.h",
"chars": 2073,
"preview": "/*\n * This file belongs to the Galois project, a C++ library for exploiting\n * parallelism. The code is being released u"
},
{
"path": "libgalois/include/galois/runtime/LoopStatistics.h",
"chars": 2627,
"preview": "/*\n * This file belongs to the Galois project, a C++ library for exploiting\n * parallelism. The code is being released u"
},
{
"path": "libgalois/include/galois/runtime/Mem.h",
"chars": 26657,
"preview": "/*\n * This file belongs to the Galois project, a C++ library for exploiting\n * parallelism. The code is being released u"
},
{
"path": "libgalois/include/galois/runtime/OperatorReferenceTypes.h",
"chars": 2692,
"preview": "/*\n * This file belongs to the Galois project, a C++ library for exploiting\n * parallelism. The code is being released u"
},
{
"path": "libgalois/include/galois/runtime/PagePool.h",
"chars": 3961,
"preview": "/*\n * This file belongs to the Galois project, a C++ library for exploiting\n * parallelism. The code is being released u"
},
{
"path": "libgalois/include/galois/runtime/Profile.h",
"chars": 6356,
"preview": "/*\n * This file belongs to the Galois project, a C++ library for exploiting\n * parallelism. The code is being released u"
},
{
"path": "libgalois/include/galois/runtime/Range.h",
"chars": 10663,
"preview": "/*\n * This file belongs to the Galois project, a C++ library for exploiting\n * parallelism. The code is being released u"
},
{
"path": "libgalois/include/galois/runtime/SharedMem.h",
"chars": 1997,
"preview": "/*\n * This file belongs to the Galois project, a C++ library for exploiting\n * parallelism. The code is being released u"
},
{
"path": "libgalois/include/galois/runtime/Statistics.h",
"chars": 17692,
"preview": "/*\n * This file belongs to the Galois project, a C++ library for exploiting\n * parallelism. The code is being released u"
},
{
"path": "libgalois/include/galois/runtime/Substrate.h",
"chars": 1902,
"preview": "/*\n * This file belongs to the Galois project, a C++ library for exploiting\n * parallelism. The code is being released u"
},
{
"path": "libgalois/include/galois/runtime/ThreadTimer.h",
"chars": 2012,
"preview": "#ifndef GALOIS_RUNTIME_THREADTIMER_H\n#define GALOIS_RUNTIME_THREADTIMER_H\n\n#include <ctime>\n\n#include \"galois/config.h\"\n"
},
{
"path": "libgalois/include/galois/runtime/TiledExecutor.h",
"chars": 25768,
"preview": "/*\n * This file belongs to the Galois project, a C++ library for exploiting\n * parallelism. The code is being released u"
},
{
"path": "libgalois/include/galois/runtime/Tracer.h",
"chars": 4414,
"preview": "/*\n * This file belongs to the Galois project, a C++ library for exploiting\n * parallelism. The code is being released u"
},
{
"path": "libgalois/include/galois/runtime/UserContextAccess.h",
"chars": 2299,
"preview": "/*\n * This file belongs to the Galois project, a C++ library for exploiting\n * parallelism. The code is being released u"
},
{
"path": "libgalois/include/galois/substrate/Barrier.h",
"chars": 3365,
"preview": "/*\n * This file belongs to the Galois project, a C++ library for exploiting\n * parallelism. The code is being released u"
},
{
"path": "libgalois/include/galois/substrate/CacheLineStorage.h",
"chars": 2013,
"preview": "/*\n * This file belongs to the Galois project, a C++ library for exploiting\n * parallelism. The code is being released u"
},
{
"path": "libgalois/include/galois/substrate/CompilerSpecific.h",
"chars": 1872,
"preview": "/*\n * This file belongs to the Galois project, a C++ library for exploiting\n * parallelism. The code is being released u"
},
{
"path": "libgalois/include/galois/substrate/EnvCheck.h",
"chars": 2777,
"preview": "/*\n * This file belongs to the Galois project, a C++ library for exploiting\n * parallelism. The code is being released u"
},
{
"path": "libgalois/include/galois/substrate/HWTopo.h",
"chars": 2519,
"preview": "/*\n * This file belongs to the Galois project, a C++ library for exploiting\n * parallelism. The code is being released u"
},
{
"path": "libgalois/include/galois/substrate/NumaMem.h",
"chars": 2156,
"preview": "/*\n * This file belongs to the Galois project, a C++ library for exploiting\n * parallelism. The code is being released u"
},
{
"path": "libgalois/include/galois/substrate/PaddedLock.h",
"chars": 1932,
"preview": "/*\n * This file belongs to the Galois project, a C++ library for exploiting\n * parallelism. The code is being released u"
},
{
"path": "libgalois/include/galois/substrate/PageAlloc.h",
"chars": 2377,
"preview": "/*\n * This file belongs to the Galois project, a C++ library for exploiting\n * parallelism. The code is being released u"
},
{
"path": "libgalois/include/galois/substrate/PerThreadStorage.h",
"chars": 7633,
"preview": "/*\n * This file belongs to the Galois project, a C++ library for exploiting\n * parallelism. The code is being released u"
},
{
"path": "libgalois/include/galois/substrate/PtrLock.h",
"chars": 4963,
"preview": "/*\n * This file belongs to the Galois project, a C++ library for exploiting\n * parallelism. The code is being released u"
},
{
"path": "libgalois/include/galois/substrate/SharedMem.h",
"chars": 1984,
"preview": "/*\n * This file belongs to the Galois project, a C++ library for exploiting\n * parallelism. The code is being released u"
},
{
"path": "libgalois/include/galois/substrate/SimpleLock.h",
"chars": 3463,
"preview": "/*\n * This file belongs to the Galois project, a C++ library for exploiting\n * parallelism. The code is being released u"
},
{
"path": "libgalois/include/galois/substrate/StaticInstance.h",
"chars": 2052,
"preview": "/*\n * This file belongs to the Galois project, a C++ library for exploiting\n * parallelism. The code is being released u"
},
{
"path": "libgalois/include/galois/substrate/Termination.h",
"chars": 7753,
"preview": "/*\n * This file belongs to the Galois project, a C++ library for exploiting\n * parallelism. The code is being released u"
},
{
"path": "libgalois/include/galois/substrate/ThreadPool.h",
"chars": 6714,
"preview": "/*\n * This file belongs to the Galois project, a C++ library for exploiting\n * parallelism. The code is being released u"
},
{
"path": "libgalois/include/galois/substrate/ThreadRWlock.h",
"chars": 2993,
"preview": "/*\n * This file belongs to the Galois project, a C++ library for exploiting\n * parallelism. The code is being released u"
},
{
"path": "libgalois/include/galois/worklists/AdaptiveObim.h",
"chars": 19138,
"preview": "/** Scalable priority worklist\n *\n * This file belongs to the Galois project, a C++ library for exploiting\n * parallelis"
},
{
"path": "libgalois/include/galois/worklists/BulkSynchronous.h",
"chars": 3622,
"preview": "/*\n * This file belongs to the Galois project, a C++ library for exploiting\n * parallelism. The code is being released u"
},
{
"path": "libgalois/include/galois/worklists/Chunk.h",
"chars": 9047,
"preview": "/*\n * This file belongs to the Galois project, a C++ library for exploiting\n * parallelism. The code is being released u"
},
{
"path": "libgalois/include/galois/worklists/ExternalReference.h",
"chars": 2264,
"preview": "/*\n * This file belongs to the Galois project, a C++ library for exploiting\n * parallelism. The code is being released u"
},
{
"path": "libgalois/include/galois/worklists/LocalQueue.h",
"chars": 3726,
"preview": "/*\n * This file belongs to the Galois project, a C++ library for exploiting\n * parallelism. The code is being released u"
},
{
"path": "libgalois/include/galois/worklists/Obim.h",
"chars": 15043,
"preview": "/*\n * This file belongs to the Galois project, a C++ library for exploiting\n * parallelism. The code is being released u"
},
{
"path": "libgalois/include/galois/worklists/OrderedList.h",
"chars": 2854,
"preview": "/*\n * This file belongs to the Galois project, a C++ library for exploiting\n * parallelism. The code is being released u"
},
{
"path": "libgalois/include/galois/worklists/OwnerComputes.h",
"chars": 3353,
"preview": "/*\n * This file belongs to the Galois project, a C++ library for exploiting\n * parallelism. The code is being released u"
},
{
"path": "libgalois/include/galois/worklists/PerThreadChunk.h",
"chars": 11245,
"preview": "/*\n * This file belongs to the Galois project, a C++ library for exploiting\n * parallelism. The code is being released u"
},
{
"path": "libgalois/include/galois/worklists/Simple.h",
"chars": 3059,
"preview": "/*\n * This file belongs to the Galois project, a C++ library for exploiting\n * parallelism. The code is being released u"
},
{
"path": "libgalois/include/galois/worklists/StableIterator.h",
"chars": 5614,
"preview": "/*\n * This file belongs to the Galois project, a C++ library for exploiting\n * parallelism. The code is being released u"
},
{
"path": "libgalois/include/galois/worklists/WLCompileCheck.h",
"chars": 1330,
"preview": "/*\n * This file belongs to the Galois project, a C++ library for exploiting\n * parallelism. The code is being released u"
},
{
"path": "libgalois/include/galois/worklists/WorkList.h",
"chars": 3704,
"preview": "/*\n * This file belongs to the Galois project, a C++ library for exploiting\n * parallelism. The code is being released u"
},
{
"path": "libgalois/include/galois/worklists/WorkListHelpers.h",
"chars": 4819,
"preview": "/*\n * This file belongs to the Galois project, a C++ library for exploiting\n * parallelism. The code is being released u"
},
{
"path": "libgalois/src/Barrier.cpp",
"chars": 1799,
"preview": "/*\n * This file belongs to the Galois project, a C++ library for exploiting\n * parallelism. The code is being released u"
}
]
// ... and 874 more files (download for full content)
About this extraction
This page contains the full source code of the IntelligentSoftwareSystems/Galois GitHub repository, extracted and formatted as plain text for AI agents and large language models (LLMs). The extraction includes 1074 files (8.2 MB), approximately 2.2M tokens, and a symbol index with 7139 extracted functions, classes, methods, constants, and types. Use this with OpenClaw, Claude, ChatGPT, Cursor, Windsurf, or any other AI tool that accepts text input. You can copy the full output to your clipboard or download it as a .txt file.
Extracted by GitExtract — free GitHub repo to text converter for AI. Built by Nikandr Surkov.