[ { "path": ".circleci/config.yml", "content": "version: 2.1\n\ncommon_step: &cmake_build_test\n - run: |\n cmake --build /tmp/build --target input\n\n if [ -n \"$CIRCLE_PULL_REQUEST\" ]; then \\\n subset=$(/bin/bash .circleci/longest_common_path.sh); \\\n echo \"Changes of ${CIRCLE_SHA1} are all under $subset\"; \\\n fi\n\n cmake --build /tmp/build/${subset:-.} --parallel 2\n # Run tests as non-root otherwise MPI will complain\n (cd /tmp/build/${subset:-.} \\\n && chown -R runner . \\\n && su runner -c \"ctest --output-on-failure --label-regex quick --parallel 2\")\n\n# TODO: These builds are currently configured to\n# install the needed dependencies in each container\n# at the start of each build. The dependencies aren't huge,\n# but that is slower and does waste some bandwidth.\n# We should eventually roll the set up for each\n# container into a separate dockerfile and push custom\n# build images to dockerhub so that setting up packages\n# during the actual CI testing is no longer necessary.\n\njobs:\n \"CheckFormat\":\n docker:\n - image: ubuntu:bionic\n steps:\n - checkout\n - run: |\n apt-get -q update -y\n apt-get -q install -y apt-transport-https ca-certificates git gnupg software-properties-common wget\n wget -O - https://apt.llvm.org/llvm-snapshot.gpg.key 2>/dev/null | apt-key add -\n apt-add-repository -y 'deb https://apt.llvm.org/bionic/ llvm-toolchain-bionic-10 main'\n apt-get -q update -y\n - run: git submodule sync\n - run: git submodule update --init\n - run: |\n apt-get -q install -y \\\n clang-format-10\n\n update-alternatives --install /usr/bin/clang-format clang-format /usr/bin/clang-format-10 50\n\n if [ -n \"$CIRCLE_PULL_REQUEST\" ]; then \\\n subset=$(/bin/bash .circleci/longest_common_path.sh); \\\n echo \"Changes of ${CIRCLE_SHA1} are all under $subset\"; \\\n fi\n scripts/check_format.sh ${subset:-.}\n \"Sanitize\":\n docker:\n - image: ubuntu:bionic\n steps:\n - checkout\n - run: |\n apt-get -q update -y\n apt-get -q install -y apt-transport-https ca-certificates git gnupg software-properties-common wget\n wget -O - https://apt.kitware.com/keys/kitware-archive-latest.asc 2>/dev/null | apt-key add -\n wget -O - https://apt.llvm.org/llvm-snapshot.gpg.key 2>/dev/null | apt-key add -\n apt-add-repository -y 'ppa:ubuntu-toolchain-r/test'\n apt-add-repository -y 'deb https://apt.llvm.org/bionic/ llvm-toolchain-bionic-10 main'\n apt-add-repository -y 'deb https://apt.kitware.com/ubuntu/ bionic main'\n apt-add-repository -y 'ppa:mhier/libboost-latest'\n apt-get -q update -y\n - run: git submodule sync\n - run: git submodule update --init\n - run: |\n apt-get -q install -y \\\n clang-10 \\\n cmake \\\n libboost1.70-dev \\\n libeigen3-dev \\\n openmpi-bin \\\n libopenmpi-dev \\\n llvm-7-dev \\\n libz-dev \\\n libfmt-dev\n\n update-alternatives --install /usr/bin/clang clang /usr/bin/clang-10 50\n update-alternatives --install /usr/bin/clang++ clang++ /usr/bin/clang++-10 50\n\n chmod 755 /root\n useradd runner\n mkdir -p /tmp/build\n\n cmake -S . -B /tmp/build \\\n -DCMAKE_C_COMPILER=clang \\\n -DCMAKE_CXX_COMPILER=clang++ \\\n -DGALOIS_USE_SANITIZER=\"Address;Undefined\"\n - <<: *cmake_build_test\n \"Debian\":\n docker:\n - image: debian:10\n steps:\n - checkout\n - run: |\n apt-get -q update -y\n apt-get -q install -y git\n - run: git submodule sync\n - run: git submodule update --init\n - run: |\n apt-get -q install -y \\\n cmake \\\n g++ \\\n gcc \\\n libboost-iostreams-dev \\\n libboost-serialization-dev \\\n libeigen3-dev \\\n libmpich-dev \\\n llvm-7-dev \\\n mpich \\\n zlib1g-dev \\\n libfmt-dev\n\n chmod 755 /root\n useradd runner\n mkdir -p /tmp/build\n\n cmake -S . -B /tmp/build \\\n -DGALOIS_ENABLE_DIST=ON\n - <<: *cmake_build_test\n \"Ubuntu-18_04\":\n docker:\n - image: ubuntu:18.04\n steps:\n - checkout\n - run: |\n apt-get -q update -y\n apt-get -q install -y apt-transport-https ca-certificates git gnupg software-properties-common wget\n wget -O - https://apt.kitware.com/keys/kitware-archive-latest.asc 2>/dev/null | apt-key add -\n apt-add-repository 'deb https://apt.kitware.com/ubuntu/ bionic main'\n apt-get -q update -y\n - run: git submodule sync\n - run: git submodule update --init\n - run: |\n apt-get -q install -y \\\n cmake \\\n g++ \\\n gcc \\\n libboost-all-dev \\\n libeigen3-dev \\\n libopenmpi-dev \\\n llvm-7-dev \\\n openmpi-bin \\\n ssh \\\n libfmt-dev\n\n chmod 755 /root\n useradd runner\n mkdir -p /tmp/build\n\n cmake -S . -B /tmp/build \\\n -DGALOIS_ENABLE_DIST=ON\n - <<: *cmake_build_test\n \"Ubuntu-18_04-cuda11_0_3-build-only\":\n docker:\n - image: nvidia/cuda:11.0.3-devel-ubuntu18.04\n steps:\n - checkout\n - run: |\n apt-get -q update -y\n apt-get -q install -y apt-transport-https ca-certificates git gnupg software-properties-common wget\n wget -O - https://apt.kitware.com/keys/kitware-archive-latest.asc 2>/dev/null | apt-key add -\n apt-add-repository 'deb https://apt.kitware.com/ubuntu/ bionic main'\n apt-get -q update -y\n - run: git submodule sync\n - run: git submodule update --init\n - run: |\n apt-get -q install -y \\\n cmake \\\n g++ \\\n gcc \\\n libboost-all-dev \\\n libeigen3-dev \\\n libopenmpi-dev \\\n llvm-7-dev \\\n openmpi-bin \\\n ssh \\\n libfmt-dev\n\n cmake -S . -B /tmp/build \\\n -DGALOIS_ENABLE_DIST=ON \\\n -DGALOIS_ENABLE_GPU=ON\n cmake --build /tmp/build --target input\n cmake --build /tmp/build --parallel 2\n \"Ubuntu-18_04-cuda11_1_1-build-only\":\n docker:\n - image: nvidia/cuda:11.1.1-devel-ubuntu18.04\n steps:\n - checkout\n - run: |\n apt-get -q update -y\n apt-get -q install -y apt-transport-https ca-certificates git gnupg software-properties-common wget\n wget -O - https://apt.kitware.com/keys/kitware-archive-latest.asc 2>/dev/null | apt-key add -\n apt-add-repository 'deb https://apt.kitware.com/ubuntu/ bionic main'\n apt-get -q update -y\n - run: git submodule sync\n - run: git submodule update --init\n - run: |\n apt-get -q install -y \\\n cmake \\\n g++ \\\n gcc \\\n libboost-all-dev \\\n libeigen3-dev \\\n libopenmpi-dev \\\n llvm-7-dev \\\n openmpi-bin \\\n ssh \\\n libfmt-dev\n\n cmake -S . -B /tmp/build \\\n -DGALOIS_ENABLE_DIST=ON \\\n -DGALOIS_ENABLE_GPU=ON\n cmake --build /tmp/build --target input\n cmake --build /tmp/build --parallel 2\n \"CentOS-8-gcc\":\n docker:\n - image: centos:8\n steps:\n - checkout\n - run: |\n # CentOS Linux 8 has reached End Of Life (EOL) on December 31st, 2021\n ls /etc/yum.repos.d/ > /dev/null 2>&1\n sed -i 's/mirrorlist/#mirrorlist/g' /etc/yum.repos.d/CentOS-*\n sed -i 's|#baseurl=http://mirror.centos.org|baseurl=http://vault.centos.org|g' /etc/yum.repos.d/CentOS-*\n - run: |\n # fmt-devel is in EPEL\n yum -y -q install https://dl.fedoraproject.org/pub/epel/epel-release-latest-8.noarch.rpm\n\n # eigen3-devel needs PowerTools packages\n yum -y -q install dnf-plugins-core\n yum -y -q config-manager --set-enabled powertools\n\n yum -y -q install git\n - run: git submodule sync\n - run: git submodule update --init\n - run: |\n yum -y -q install \\\n boost-devel \\\n cmake \\\n eigen3-devel \\\n gcc \\\n gcc-c++ \\\n llvm-devel \\\n llvm-static \\\n make \\\n mpich-devel \\\n ncurses-devel \\\n wget \\\n zlib-devel \\\n fmt-devel\n\n 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\n ln -s /usr/local/cmake-3.17.0-Linux-x86_64/bin/cmake /usr/local/bin/cmake\n ln -s /usr/local/cmake-3.17.0-Linux-x86_64/bin/ctest /usr/local/bin/ctest\n\n # Make the \"module\" command work in the subsequent shell sessions.\n cat /etc/profile.d/modules.sh >> $BASH_ENV\n echo \"module load mpi\" >> $BASH_ENV\n - run: |\n chmod 755 /root\n useradd runner\n mkdir -p /tmp/build\n\n cmake -S . -B /tmp/build \\\n -DGALOIS_ENABLE_DIST=ON\n - <<: *cmake_build_test\n \"CentOS-8-clang\":\n docker:\n - image: centos:8\n steps:\n - checkout\n - run: |\n # CentOS Linux 8 has reached End Of Life (EOL) on December 31st, 2021\n ls /etc/yum.repos.d/ > /dev/null 2>&1\n sed -i 's/mirrorlist/#mirrorlist/g' /etc/yum.repos.d/CentOS-*\n sed -i 's|#baseurl=http://mirror.centos.org|baseurl=http://vault.centos.org|g' /etc/yum.repos.d/CentOS-*\n - run: |\n # fmt-devel is in EPEL\n yum -y -q install https://dl.fedoraproject.org/pub/epel/epel-release-latest-8.noarch.rpm\n\n # eigen3-devel needs PowerTools packages\n yum -y -q install dnf-plugins-core\n yum -y -q config-manager --set-enabled powertools\n\n yum -y -q install git\n - run: git submodule sync\n - run: git submodule update --init\n - run: |\n yum -y -q install \\\n boost-devel \\\n eigen3-devel \\\n llvm-devel \\\n llvm-static \\\n llvm-toolset \\\n make \\\n openmpi-devel \\\n ncurses-devel \\\n wget \\\n zlib-devel \\\n fmt-devel\n\n 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\n ln -s /usr/local/cmake-3.17.0-Linux-x86_64/bin/cmake /usr/local/bin/cmake\n ln -s /usr/local/cmake-3.17.0-Linux-x86_64/bin/ctest /usr/local/bin/ctest\n\n # Make the \"module\" command work in the subsequent shell sessions.\n cat /etc/profile.d/modules.sh >> $BASH_ENV\n echo \"module load mpi\" >> $BASH_ENV\n - run: |\n chmod 755 /root\n useradd runner\n mkdir -p /tmp/build\n\n cmake -S . -B /tmp/build \\\n -DCMAKE_C_COMPILER=clang \\\n -DCMAKE_CXX_COMPILER=clang++ \\\n # -DGALOIS_ENABLE_DIST=ON\n - <<: *cmake_build_test\n \"Arch\":\n docker:\n - image: archlinux:base\n steps:\n - checkout\n - run: |\n pacman -Syu --noconfirm\n pacman -q -S --noconfirm git\n - run: git submodule sync\n - run: git submodule update --init\n - run: |\n # NB(ddn): make requires libffi but its package doesn't depend on it.\n pacman -q -S --noconfirm \\\n boost \\\n cmake \\\n eigen \\\n gcc \\\n libffi \\\n llvm \\\n make \\\n openmpi \\\n fmt\n\n chmod 755 /root\n useradd runner\n mkdir -p /tmp/build\n\n cmake -S . -B /tmp/build \\\n -DGALOIS_ENABLE_DIST=ON\n - <<: *cmake_build_test\n \"Alpine\":\n docker:\n - image: alpine:latest\n steps:\n - checkout\n - run: |\n apk add --no-cache --no-progress git bash\n - run: git submodule sync\n - run: git submodule update --init\n - run: |\n apk add --no-cache --no-progress \\\n boost-dev \\\n cmake \\\n eigen \\\n g++ \\\n gcc \\\n llvm14-dev \\\n llvm14-static \\\n make \\\n musl-dev \\\n openssh-client \\\n zlib-dev \\\n fmt-dev\n\n chmod 755 /root\n adduser -D runner\n mkdir -p /tmp/build\n\n cmake -S . -B /tmp/build\n - <<: *cmake_build_test\n \"Fedora-gcc\":\n docker:\n - image: fedora:latest\n steps:\n - checkout\n - run: |\n yum -y -q install git\n - run: git submodule sync\n - run: git submodule update --init\n - run: |\n yum -y -q install \\\n boost-devel \\\n cmake \\\n eigen3-devel \\\n gcc-c++ \\\n llvm-devel \\\n llvm-static \\\n make \\\n mpich-devel \\\n wget \\\n zlib-devel \\\n fmt-devel\n\n chmod 755 /root\n useradd runner\n mkdir -p /tmp/build\n\n # Get the \"module\" function set up before loading MPI.\n cat /etc/profile.d/modules.sh >> $BASH_ENV\n echo \"module load mpi\" >> $BASH_ENV\n - run: |\n cmake -S . -B /tmp/build \\\n -DGALOIS_ENABLE_DIST=ON\n - <<: *cmake_build_test\n \"Fedora-clang\":\n docker:\n - image: fedora:latest\n steps:\n - checkout\n - run: |\n yum -y -q install git\n - run: git submodule sync\n - run: git submodule update --init\n - run: |\n yum -y -q install \\\n boost-devel \\\n clang \\\n cmake \\\n eigen3-devel \\\n llvm-devel \\\n llvm-static \\\n make \\\n openmpi-devel \\\n wget \\\n zlib-devel \\\n fmt-devel\n\n chmod 755 /root\n useradd runner\n mkdir -p /tmp/build\n\n # Get the \"module\" function set up before loading MPI.\n cat /etc/profile.d/modules.sh >> $BASH_ENV\n echo \"module load mpi\" >> $BASH_ENV\n - run: |\n cmake -S . -B /tmp/build \\\n -DCMAKE_C_COMPILER=clang \\\n -DCMAKE_CXX_COMPILER=clang++ \\\n # -DGALOIS_ENABLE_DIST=ON\n - <<: *cmake_build_test\n\nworkflows:\n build:\n jobs:\n - \"CheckFormat\"\n - \"Sanitize\"\n - \"Alpine\":\n requires:\n - \"CheckFormat\"\n # - \"Sanitize\"\n - \"Arch\":\n requires:\n - \"CheckFormat\"\n # - \"Sanitize\"\n - \"CentOS-8-clang\":\n requires:\n - \"CheckFormat\"\n # - \"Sanitize\"\n - \"CentOS-8-gcc\":\n requires:\n - \"CheckFormat\"\n # - \"Sanitize\"\n - \"Debian\":\n requires:\n - \"CheckFormat\"\n # - \"Sanitize\"\n - \"Fedora-clang\":\n requires:\n - \"CheckFormat\"\n # - \"Sanitize\"\n - \"Fedora-gcc\":\n requires:\n - \"CheckFormat\"\n # - \"Sanitize\"\n - \"Ubuntu-18_04\":\n requires:\n - \"CheckFormat\"\n # - \"Sanitize\"\n - \"Ubuntu-18_04-cuda11_1_1-build-only\":\n requires:\n - \"CheckFormat\"\n # - \"Sanitize\"\n - \"Ubuntu-18_04-cuda11_0_3-build-only\":\n requires:\n - \"CheckFormat\"\n # - \"Sanitize\"\n" }, { "path": ".circleci/longest_common_path.sh", "content": "#!/bin/bash\n# For PR build only; find the longest common path prefix as the build and test subset\n\nlongest_common_prefix() {\n declare -a possible_prefix\n declare i=0\n\n path=\"${1%/}\"\n while [ \"$path\" != \".\" ]; do\n if [[ -d $path && -f \"$path/CMakeLists.txt\" ]]; then\n possible_prefix[$i]=\"$path\"\n fi\n i=$(($i + 1))\n path=$(dirname \"$path\");\n done\n\n lcp=\".\"\n for prefix in \"${possible_prefix[@]}\"; do\n for path in $@; do\n if [ \"${path#$prefix}\" = \"${path}\" ]; then\n continue 2\n fi\n done\n lcp=\"$prefix\"\n break\n done\n echo $lcp\n}\nbase=$( \\\n wget -q -O - \"https://api.github.com/repos/$(echo ${CIRCLE_PULL_REQUEST:19} | sed \"s/\\/pull\\//\\/pulls\\//\")\" \\\n | sed -n -e \"s/^.*IntelligentSoftwareSystems://p\" \\\n | sed -n -e \"s/\\\".*$//p\" \\\n)\nlongest_common_prefix $(git -c core.quotepath=false diff --name-only $base $CIRCLE_SHA1)" }, { "path": ".clang-format", "content": "---\nLanguage: Cpp\nBasedOnStyle: LLVM\nAccessModifierOffset: -2\nAlignAfterOpenBracket: true\nAlignConsecutiveAssignments: true\nAlignEscapedNewlinesLeft: false\nAlignOperands: true\nAlignTrailingComments: true\nAllowAllParametersOfDeclarationOnNextLine: true\nAllowShortBlocksOnASingleLine: false\nAllowShortCaseLabelsOnASingleLine: false\nAllowShortFunctionsOnASingleLine: All\nAllowShortIfStatementsOnASingleLine: false\nAllowShortLoopsOnASingleLine: false\nAlwaysBreakAfterDefinitionReturnType: None\nAlwaysBreakBeforeMultilineStrings: false\nAlwaysBreakTemplateDeclarations: true\nBinPackArguments: true\nBinPackParameters: true\nBreakBeforeBinaryOperators: None\nBreakBeforeBraces: Attach\nBreakBeforeTernaryOperators: true\nBreakConstructorInitializersBeforeComma: false\nColumnLimit: 80\nCommentPragmas: '^ IWYU pragma:'\nConstructorInitializerAllOnOneLineOrOnePerLine: false\nConstructorInitializerIndentWidth: 4\nContinuationIndentWidth: 4\nCpp11BracedListStyle: true\nDeriveLineEnding: false\nDerivePointerAlignment: false\nDisableFormat: false\nExperimentalAutoDetectBinPacking: false\nForEachMacros: [ foreach, Q_FOREACH, BOOST_FOREACH ]\nIndentCaseLabels: false\nIndentWidth: 2\nIndentWrappedFunctionNames: false\nKeepEmptyLinesAtTheStartOfBlocks: true\nMacroBlockBegin: ''\nMacroBlockEnd: ''\nMaxEmptyLinesToKeep: 1\nNamespaceIndentation: None\nObjCBlockIndentWidth: 2\nObjCSpaceAfterProperty: false\nObjCSpaceBeforeProtocolList: true\nPenaltyBreakBeforeFirstCallParameter: 19\nPenaltyBreakComment: 300\nPenaltyBreakFirstLessLess: 120\nPenaltyBreakString: 1000\nPenaltyExcessCharacter: 1000000\nPenaltyReturnTypeOnItsOwnLine: 60\nPointerAlignment: Left\nSortIncludes: false\nSpaceAfterCStyleCast: false\nSpaceBeforeAssignmentOperators: true\nSpaceBeforeParens: ControlStatements\nSpaceInEmptyParentheses: false\nSpacesBeforeTrailingComments: 1\nSpacesInAngles: false\nSpacesInContainerLiterals: true\nSpacesInCStyleCastParentheses: false\nSpacesInParentheses: false\nSpacesInSquareBrackets: false\nStandard: Cpp11\nTabWidth: 4\nUseTab: Never\n...\n\n" }, { "path": ".clang-tidy", "content": "---\n# Enable most checks then disable (-) problematics ones:\n#\n# Some checks are good in principle but cannot be applied automatically either\n# because they require taste or the autofix can generate wrong code:\n#\n# - cppcoreguidelines-pro-type-member-init: wrong code sometimes\n# - google-explicit-constructor: libllvm has implicit conversions\n# - modernize-use-no-discard\n# - modernize-use-transparent-functors\n# - modernize-use-using: autofix doesn't handle dependent type templates\n# - readability-static-accessed-through-instance: wrong code sometimes\n#\n# No consensus:\n#\n# - modernize-use-trailing-return-type: also huge code churn\n# - readability-convert-member-functions-to-static\n# - readability-implicit-bool-conversion\nChecks: |\n abseil-*,\n boost-*,\n bugprone-*,\n clang-analyzer-*,\n clang-diagnostic-*,\n cppcoreguidelines-*,\n -cppcoreguidelines-pro-type-member-init,\n google-*,\n -google-explicit-constructor,\n modernize-*,\n -modernize-use-nodiscard,\n -modernize-use-trailing-return-type,\n -modernize-use-transparent-functors,\n -modernize-use-using,\n mpi-*,\n openmp-*,\n performance-*,\n readability-*,\n -readability-convert-member-functions-to-static,\n -readability-static-accessed-through-instance,\n -readability-implicit-bool-conversion,\nWarningsAsErrors: ''\nHeaderFilterRegex: ''\nAnalyzeTemporaryDtors: false\nFormatStyle: file\nCheckOptions:\n - key: cert-dcl16-c.NewSuffixes\n value: 'L;LL;LU;LLU'\n - key: cert-oop54-cpp.WarnOnlyIfThisHasSuspiciousField\n value: '0'\n - key: cppcoreguidelines-explicit-virtual-functions.IgnoreDestructors\n value: '1'\n - key: cppcoreguidelines-non-private-member-variables-in-classes.IgnoreClassesWithAllMemberVariablesBeingPublic\n value: '1'\n - key: google-readability-braces-around-statements.ShortStatementLines\n value: '1'\n - key: google-readability-function-size.StatementThreshold\n value: '800'\n - key: google-readability-namespace-comments.ShortNamespaceLines\n value: '10'\n - key: google-readability-namespace-comments.SpacesBeforeComments\n value: '2'\n - key: modernize-loop-convert.MaxCopySize\n value: '16'\n - key: modernize-loop-convert.MinConfidence\n value: reasonable\n - key: modernize-loop-convert.NamingStyle\n value: CamelCase\n - key: modernize-pass-by-value.IncludeStyle\n value: llvm\n - key: modernize-replace-auto-ptr.IncludeStyle\n value: llvm\n - key: modernize-use-nullptr.NullMacros\n value: 'NULL'\n...\n" }, { "path": ".git-blame-ignore-revs", "content": "# 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 .git-blame-ignore-revs\n#\n# or more permanently:\n#\n# git config blame.ignoreRevsFile .git-blame-ignore-revs\n\n# Run clang-format.\n02ecf4f4ea6ed8618a3826f98c3ea192ee38ca2d\n\n# Re-run clang-format.\n47ddbe14de2e61b87749cd20bd368f07ef3c322f\n\n# Reorganize the lonestar directories.\n6ade1c5ac3cf0c261aff7bee863e46b2c124d174\n\n# Run clang-format.\n517fca343c75f842096b661e3ff883bb93f5c09e\n\n# Another round of clang-format\n2264b05ece3f9ec2b9bf397594cc14ef99f498de\n\n# Fix endlines for barneshut app\n558ccb83ab2e388c1202396f42d0881912e6393d\n" }, { "path": ".gitignore", "content": "# 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 generated files\n.clang-complete\n.clangd\ncompile_commands.json\ncscope.out\n/GPATH\n/GRTAGS\n/GTAGS\n.tags*\ntags\n.ycm_extra_conf.py\n\n# no build files\n/build*\n\n# no python build artifacts\n*.pyc\n/python/galois.egg-info\n/python/galois/*.so\n/_skbuild\n" }, { "path": ".gitmodules", "content": "[submodule \"moderngpu\"]\n\tpath = external/moderngpu\n\turl = https://github.com/moderngpu/moderngpu.git\n[submodule \"cub\"]\n\tpath = external/cub\n\turl = https://github.com/NVlabs/cub.git\n[submodule \"docs\"]\n\tpath = docs\n\turl = https://github.com/IntelligentSoftwareSystems/Galois-docs.git\n" }, { "path": ".travis.yml", "content": "dist: bionic\n\nlanguage: c++\n\ngit:\n submodules: true\n\nmatrix:\n include:\n - os: osx\n osx_image: xcode11.3\n before_script:\n - export CC=clang\n - export CXX=clang++\n - brew install openmpi llvm fmt\n - mkdir build\n - export PATH=$PATH:/usr/local/opt/llvm/bin\n - cmake -S . -B build -DCMAKE_BUILD_TYPE=Release -DGALOIS_ENABLE_DIST=ON || exit 1\n - env:\n - GCC_VER=7\n addons:\n apt:\n sources:\n - sourceline: 'ppa:ubuntu-toolchain-r/test'\n - sourceline: 'deb https://apt.kitware.com/ubuntu/ bionic main'\n key_url: 'https://apt.kitware.com/keys/kitware-archive-latest.asc'\n - sourceline: 'ppa:mhier/libboost-latest'\n packages:\n - gcc-7\n - g++-7\n - cmake\n - libboost1.70-dev\n - libeigen3-dev\n - openmpi-bin\n - libopenmpi-dev\n - llvm-7-dev\n - libz-dev\n - libfmt-dev\n - env:\n - GCC_VER=8\n addons:\n apt:\n sources:\n - sourceline: 'ppa:ubuntu-toolchain-r/test'\n - sourceline: 'deb https://apt.kitware.com/ubuntu/ bionic main'\n key_url: 'https://apt.kitware.com/keys/kitware-archive-latest.asc'\n - sourceline: 'ppa:mhier/libboost-latest'\n packages:\n - gcc-8\n - g++-8\n - cmake\n - libboost1.70-dev\n - libeigen3-dev\n - openmpi-bin\n - libopenmpi-dev\n - llvm-7-dev\n - libz-dev\n - libfmt-dev\n - env:\n - GCC_VER=9\n addons:\n apt:\n sources:\n - sourceline: 'ppa:ubuntu-toolchain-r/test'\n - sourceline: 'deb https://apt.kitware.com/ubuntu/ bionic main'\n key_url: 'https://apt.kitware.com/keys/kitware-archive-latest.asc'\n - sourceline: 'ppa:mhier/libboost-latest'\n packages:\n - gcc-9\n - g++-9\n - cmake\n - libboost1.70-dev\n - libeigen3-dev\n - openmpi-bin\n - libopenmpi-dev\n - llvm-7-dev\n - libz-dev\n - libfmt-dev\n - env:\n - GCC_VER=10\n addons:\n apt:\n sources:\n - sourceline: 'ppa:ubuntu-toolchain-r/test'\n - sourceline: 'deb https://apt.kitware.com/ubuntu/ bionic main'\n key_url: 'https://apt.kitware.com/keys/kitware-archive-latest.asc'\n - sourceline: 'ppa:mhier/libboost-latest'\n packages:\n - gcc-10\n - g++-10\n - cmake\n - libboost1.70-dev\n - libeigen3-dev\n - openmpi-bin\n - libopenmpi-dev\n - llvm-7-dev\n - libz-dev\n - libfmt-dev\n - env:\n - GCC_VER=10\n - BUILD_TYPE=Debug\n addons:\n apt:\n sources:\n - sourceline: 'ppa:ubuntu-toolchain-r/test'\n - sourceline: 'deb https://apt.kitware.com/ubuntu/ bionic main'\n key_url: 'https://apt.kitware.com/keys/kitware-archive-latest.asc'\n - sourceline: 'ppa:mhier/libboost-latest'\n packages:\n - gcc-10\n - g++-10\n - cmake\n - libboost1.70-dev\n - libeigen3-dev\n - openmpi-bin\n - libopenmpi-dev\n - llvm-7-dev\n - libz-dev\n - libfmt-dev\n - env:\n - CLANG_VER=7\n addons:\n apt:\n sources:\n - sourceline: 'ppa:ubuntu-toolchain-r/test'\n - sourceline: 'deb http://apt.llvm.org/bionic/ llvm-toolchain-bionic-7 main'\n key_url: 'https://apt.llvm.org/llvm-snapshot.gpg.key'\n - sourceline: 'deb https://apt.kitware.com/ubuntu/ bionic main'\n key_url: 'https://apt.kitware.com/keys/kitware-archive-latest.asc'\n - sourceline: 'ppa:mhier/libboost-latest'\n packages:\n - clang-7\n - cmake\n - libboost1.70-dev\n - libeigen3-dev\n - openmpi-bin\n - libopenmpi-dev\n - llvm-7-dev\n - libz-dev\n - libfmt-dev\n - env:\n - CLANG_VER=8\n addons:\n apt:\n sources:\n - sourceline: 'ppa:ubuntu-toolchain-r/test'\n - sourceline: 'deb http://apt.llvm.org/bionic/ llvm-toolchain-bionic-8 main'\n key_url: 'https://apt.llvm.org/llvm-snapshot.gpg.key'\n - sourceline: 'deb https://apt.kitware.com/ubuntu/ bionic main'\n key_url: 'https://apt.kitware.com/keys/kitware-archive-latest.asc'\n - sourceline: 'ppa:mhier/libboost-latest'\n packages:\n - clang-8\n - cmake\n - libboost1.70-dev\n - libeigen3-dev\n - openmpi-bin\n - libopenmpi-dev\n - llvm-7-dev\n - libz-dev\n - libfmt-dev\n - env:\n - CLANG_VER=9\n addons:\n apt:\n sources:\n - sourceline: 'ppa:ubuntu-toolchain-r/test'\n - sourceline: 'deb http://apt.llvm.org/bionic/ llvm-toolchain-bionic-9 main'\n key_url: 'https://apt.llvm.org/llvm-snapshot.gpg.key'\n - sourceline: 'deb https://apt.kitware.com/ubuntu/ bionic main'\n key_url: 'https://apt.kitware.com/keys/kitware-archive-latest.asc'\n - sourceline: 'ppa:mhier/libboost-latest'\n packages:\n - clang-9\n - cmake\n - libboost1.70-dev\n - libeigen3-dev\n - openmpi-bin\n - libopenmpi-dev\n - llvm-7-dev\n - libz-dev\n - libfmt-dev\n - env:\n - CLANG_VER=10\n addons:\n apt:\n sources:\n - sourceline: 'ppa:ubuntu-toolchain-r/test'\n - sourceline: 'deb http://apt.llvm.org/bionic/ llvm-toolchain-bionic-10 main'\n key_url: 'https://apt.llvm.org/llvm-snapshot.gpg.key'\n - sourceline: 'deb https://apt.kitware.com/ubuntu/ bionic main'\n key_url: 'https://apt.kitware.com/keys/kitware-archive-latest.asc'\n - sourceline: 'ppa:mhier/libboost-latest'\n packages:\n - clang-10\n - cmake\n - libboost1.70-dev\n - libeigen3-dev\n - openmpi-bin\n - libopenmpi-dev\n - llvm-7-dev\n - libz-dev\n - libfmt-dev\n - env:\n - CLANG_VER=10\n - BUILD_TYPE=Debug\n addons:\n apt:\n sources:\n - sourceline: 'ppa:ubuntu-toolchain-r/test'\n - sourceline: 'deb http://apt.llvm.org/bionic/ llvm-toolchain-bionic-10 main'\n key_url: 'https://apt.llvm.org/llvm-snapshot.gpg.key'\n - sourceline: 'deb https://apt.kitware.com/ubuntu/ bionic main'\n key_url: 'https://apt.kitware.com/keys/kitware-archive-latest.asc'\n - sourceline: 'ppa:mhier/libboost-latest'\n packages:\n - clang-10\n - cmake\n - libboost1.70-dev\n - libeigen3-dev\n - openmpi-bin\n - libopenmpi-dev\n - llvm-7-dev\n - libz-dev\n - libfmt-dev\n\nbefore_script:\n # Depending on whether GCC_VER or CLANG_VER is set and nonempty,\n # set CC and CXX accordingly.\n - |\n if [ -n \"$GCC_VER\" ]; then\n export CC=\"gcc-$GCC_VER\"\n export CXX=\"g++-$GCC_VER\"\n fi\n - |\n if [ -n \"$CLANG_VER\" ]; then\n export CC=\"clang-$CLANG_VER\"\n export CXX=\"clang++-$CLANG_VER\"\n fi\n - |\n # Check if BUILD_TYPE is set at all, not just whether it is empty or unset.\n # See https://stackoverflow.com/a/13864829/1935144.\n if [ -z ${BUILD_TYPE+x} ]; then\n export BUILD_TYPE=Release\n fi\n - mkdir build\n # Use apt-installed llvm-7-dev rather than travis-provided one which is\n # picked up through the local clang-7 install in /usr/local/clang-7.\n - export CMAKE_PREFIX_PATH=/usr/lib/llvm-7\n # Use apt-installed cmake rather than travis-provided one\n # (/usr/local/cmake-3.12.4/bin/cmake).\n - /usr/bin/cmake -S . -B build -DCMAKE_PREFIX_PATH=$CMAKE_PREFIX_PATH -DCMAKE_BUILD_TYPE=$BUILD_TYPE -DGALOIS_ENABLE_DIST=ON || exit 1\n\nscript:\n - make -C build input\n - cmake --build build --parallel 2 || exit 1\n - (cd build && ctest --output-on-failure --parallel 2 --label-regex quick) || exit 1\n\nnotifications:\n email: false\n" }, { "path": "CMakeLists.txt", "content": "cmake_minimum_required(VERSION 3.13)\n\nproject(Galois)\n\nlist(APPEND CMAKE_MODULE_PATH \"${CMAKE_CURRENT_SOURCE_DIR}/cmake/Modules\")\n\ninclude(GNUInstallDirs)\n\nfile(STRINGS config/version.txt GALOIS_VERSION)\nstring(REGEX REPLACE \"[ \\t\\n]\" \"\" GALOIS_VERSION ${GALOIS_VERSION})\nstring(REGEX REPLACE \"([0-9]+)\\\\.([0-9]+)\\\\.([0-9]+)\" \"\\\\1\" GALOIS_VERSION_MAJOR ${GALOIS_VERSION})\nstring(REGEX REPLACE \"([0-9]+)\\\\.([0-9]+)\\\\.([0-9]+)\" \"\\\\2\" GALOIS_VERSION_MINOR ${GALOIS_VERSION})\nstring(REGEX REPLACE \"([0-9]+)\\\\.([0-9]+)\\\\.([0-9]+)\" \"\\\\3\" GALOIS_VERSION_PATCH ${GALOIS_VERSION})\nset(GALOIS_COPYRIGHT_YEAR \"2018\") # Also in COPYRIGHT\n\nif(NOT CMAKE_BUILD_TYPE)\n message(STATUS \"No build type selected, default to Release\")\n # cmake default flags with relwithdebinfo is -O2 -g\n # cmake default flags with release is -O3 -DNDEBUG\n set(CMAKE_BUILD_TYPE \"Release\")\nendif()\n\n###### Options (alternatively pass as options to cmake -DName=Value) ######\n###### Distributed-heterogeneous features ######\nset(GALOIS_ENABLE_DIST OFF CACHE BOOL \"Enable distributed features\")\nset(GALOIS_CUDA_CAPABILITY \"\" CACHE STRING \"Semi-colon list of CUDA compute capability version numbers to enable GPU features\") # e.g., \"3.7;6.1\"\nset(GALOIS_COMM_STATS OFF CACHE BOOL \"Report more detailed statistics of communication\")\n###### General features ######\nset(GALOIS_ENABLE_PAPI OFF CACHE BOOL \"Use PAPI counters for profiling\")\nset(GALOIS_ENABLE_VTUNE OFF CACHE BOOL \"Use VTune for profiling\")\nset(GALOIS_STRICT_CONFIG OFF CACHE BOOL \"Instead of falling back gracefully, fail\")\nset(GALOIS_GRAPH_LOCATION \"\" CACHE PATH \"Location of inputs for tests if downloaded/stored separately.\")\nset(CXX_CLANG_TIDY \"\" CACHE STRING \"Semi-colon list specifying clang-tidy command and arguments\")\nset(CMAKE_CXX_COMPILER_LAUNCHER \"\" CACHE STRING \"Semi-colon list specifying command to wrap compiler invocations (e.g., ccache)\")\nset(USE_ARCH native CACHE STRING \"Optimize for a specific processor architecture ('none' to disable)\")\nset(GALOIS_USE_SANITIZER \"\" CACHE STRING \"Semi-colon list of sanitizers to use (Memory, MemoryWithOrigins, Address, Undefined, Thread)\")\n# This option is automatically handled by CMake.\n# It makes add_library build a shared lib unless STATIC is explicitly specified.\n# Putting this here is mostly just a placeholder so people know it's an option.\n# Currently this is really only intended to change anything for the libgalois_shmem target.\nset(BUILD_SHARED_LIBS OFF CACHE BOOL \"Build shared libraries\")\nset(BUILD_DOCS \"\" CACHE STRING \"Build documentation with make doc. Supported values: , external, internal. external docs hide '*-draft*' and '*-internal* documentation pages and directories when building documentation\")\n###### Developer features ######\nset(GALOIS_PER_ROUND_STATS OFF CACHE BOOL \"Report statistics of each round of execution\")\nset(GALOIS_NUM_TEST_GPUS \"0\" CACHE STRING \"Number of test GPUs to use (on a single machine) for running the tests.\")\nset(GALOIS_USE_LCI OFF CACHE BOOL \"Use LCI network runtime instead of MPI\")\nset(GALOIS_USE_BARE_MPI OFF CACHE BOOL \"Use MPI directly (no dedicated network-runtime thread)\")\nset(GALOIS_NUM_TEST_THREADS \"\" CACHE STRING \"Maximum number of threads to use when running tests (default: number of physical cores)\")\n\nif(NOT GALOIS_NUM_TEST_THREADS)\n cmake_host_system_information(RESULT GALOIS_NUM_TEST_THREADS QUERY NUMBER_OF_PHYSICAL_CORES)\nendif()\nif(GALOIS_NUM_TEST_THREADS LESS_EQUAL 0)\n set(GALOIS_NUM_TEST_THREADS 1)\nendif()\n\n###### Configure (users don't need to go beyond here) ######\n\ninclude(CTest)\n\n###### Configure compiler ######\n\n# generate compile_commands.json\nset(CMAKE_EXPORT_COMPILE_COMMANDS ON)\n\nset(CMAKE_CXX_STANDARD 17)\nset(CMAKE_CXX_STANDARD_REQUIRED ON)\nset(CMAKE_CXX_EXTENSIONS OFF) #...without compiler extensions like gnu++11\nset(CMAKE_POSITION_INDEPENDENT_CODE ON)\n\n# Always include debug info\nadd_compile_options(\"$<$:-g>\")\n\n# GCC\nif(CMAKE_CXX_COMPILER_ID STREQUAL \"GNU\")\n if(CMAKE_CXX_COMPILER_VERSION VERSION_LESS 7)\n message(FATAL_ERROR \"gcc must be version 7 or higher. Found ${CMAKE_CXX_COMPILER_VERSION}.\")\n endif()\n\n add_compile_options(\"$<$:-Wall;-Wextra>\")\n\n if(CMAKE_CXX_COMPILER_VERSION VERSION_LESS 11)\n add_compile_options(\"$<$:-Werror>\")\n endif()\nendif()\n\nif(CMAKE_CXX_COMPILER_ID STREQUAL \"Clang\")\n if(CMAKE_CXX_COMPILER_VERSION VERSION_LESS 7)\n message(FATAL_ERROR \"clang must be version 7 or higher. Found ${CMAKE_CXX_COMPILER_VERSION}.\")\n endif()\n\n add_compile_options(\"$<$:-Wall;-Wextra>\")\n\n if(CMAKE_CXX_COMPILER_VERSION VERSION_LESS 11)\n add_compile_options(\"$<$:-Werror>\")\n endif()\nendif()\n\nif(CMAKE_CXX_COMPILER_ID STREQUAL \"AppleClang\")\n add_compile_options(\"$<$:-Wall;-Wextra>\")\n\n if(CMAKE_CXX_COMPILER_VERSION VERSION_LESS 12)\n add_compile_options(\"$<$:-Werror>\")\n endif()\nendif()\n\nif(CMAKE_CXX_COMPILER_ID STREQUAL \"Intel\")\n if(CMAKE_CXX_COMPILER_VERSION VERSION_LESS 19.0.1)\n message(FATAL_ERROR \"icpc must be 19.0.1 or higher. Found ${CMAKE_CXX_COMPILER_VERSION}.\")\n endif()\n\n # Avoid warnings when using noinline for methods defined inside class defintion.\n add_compile_options(\"$<$:-wd2196>\")\nendif()\n\n# Enable architecture-specific optimizations\ninclude(CheckArchFlags)\nif(ARCH_FLAGS_FOUND)\n add_compile_options(\"$<$:${ARCH_CXX_FLAGS}>\")\n add_compile_options(\"$<$:${ARCH_C_FLAGS}>\")\n add_link_options(${ARCH_LINK_FLAGS})\nendif()\n\nif(CXX_CLANG_TIDY)\n set(CMAKE_CXX_CLANG_TIDY ${CXX_CLANG_TIDY} \"-header-filter=.*${PROJECT_SOURCE_DIR}.*\")\n # Ignore warning flags intended for the CXX program. This only works because\n # the two compilers we care about, clang and gcc, both understand\n # -Wno-unknown-warning-option.\n add_compile_options(\"$<$:-Wno-unknown-warning-option>\")\nendif()\n\n###### Configure features ######\n\nif(GALOIS_ENABLE_VTUNE)\n set(VTune_ROOT /opt/intel/vtune_amplifier)\n find_package(VTune REQUIRED)\n include_directories(${VTune_INCLUDE_DIRS})\n add_definitions(-DGALOIS_ENABLE_VTUNE)\nendif()\n\nif(GALOIS_ENABLE_PAPI)\n find_package(PAPI REQUIRED)\n include_directories(${PAPI_INCLUDE_DIRS})\n add_definitions(-DGALOIS_ENABLE_PAPI)\nendif()\n\nfind_package(Threads REQUIRED)\n\ninclude(CheckMmap)\n\ninclude(CheckHugePages)\nif(NOT HAVE_HUGEPAGES AND GALOIS_STRICT_CONFIG)\n message(FATAL_ERROR \"Need huge pages\")\nendif()\n\nfind_package(Boost 1.58.0 REQUIRED COMPONENTS serialization iostreams)\n\nfind_package(LLVM REQUIRED CONFIG)\nif(\"${LLVM_PACKAGE_VERSION}\" VERSION_LESS \"7\")\n message(FATAL_ERROR \"LLVM 7 or greater is required.\")\nendif()\nif(NOT DEFINED LLVM_ENABLE_RTTI)\n message(FATAL_ERROR \"Could not determine if LLVM has RTTI enabled.\")\nendif()\nif(NOT ${LLVM_ENABLE_RTTI})\n 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`\")\nendif()\ntarget_include_directories(LLVMSupport INTERFACE ${LLVM_INCLUDE_DIRS})\n\ninclude(HandleSanitizer)\n\ninclude(CheckEndian)\n\n###### Test Inputs ######\n\nif(GALOIS_GRAPH_LOCATION)\n set(BASEINPUT \"${GALOIS_GRAPH_LOCATION}\")\n set(BASEOUTPUT \"${GALOIS_GRAPH_LOCATION}\")\n message(STATUS \"Using graph input and output location ${GALOIS_GRAPH_LOCATION}\")\nelseif(EXISTS /net/ohm/export/iss)\n set(BASEINPUT /net/ohm/export/iss/inputs)\n MESSAGE(STATUS \"Using graph input location /net/ohm/export/iss/inputs\")\n set(BASEOUTPUT /net/ohm/export/iss/dist-outputs)\n MESSAGE(STATUS \"Using graph output location /net/ohm/export/iss/dist-outputs\")\nelse()\n set(BASEINPUT \"${PROJECT_BINARY_DIR}/inputs\")\n set(BASEOUTPUT \"${PROJECT_BINARY_DIR}/inputs\")\n message(STATUS \"Use 'make input' to download inputs and outputs in the build directory\")\nendif()\n\n###### Source finding ######\n\nadd_custom_target(lib)\nadd_custom_target(apps)\n\n# Core libraries (lib)\nadd_subdirectory(libsupport)\nadd_subdirectory(libgalois)\nadd_subdirectory(libpygalois)\nif (GALOIS_ENABLE_DIST)\n find_package(MPI REQUIRED)\n add_subdirectory(libdist)\n add_subdirectory(libcusp)\n add_subdirectory(libgluon)\nendif()\nstring(COMPARE NOTEQUAL \"${GALOIS_CUDA_CAPABILITY}\" \"\" GALOIS_ENABLE_GPU)\nif (GALOIS_ENABLE_GPU)\n enable_language(CUDA)\n foreach(GENCODE ${GALOIS_CUDA_CAPABILITY})\n string(REPLACE \".\" \"\" GENCODE ${GENCODE})\n add_compile_options(\"$<$:-gencode=arch=compute_${GENCODE},code=sm_${GENCODE}>\")\n endforeach()\n\n # This is necessary to allow building for CUDA 11.x (where CUB is bundled) and earlier versions (where CUB is not included)\n add_definitions(-DTHRUST_IGNORE_CUB_VERSION_CHECK)\n\n add_subdirectory(libgpu)\nendif()\nadd_subdirectory(libpangolin)\n\n# Applications (apps)\nadd_subdirectory(lonestar)\n\nadd_subdirectory(scripts)\nadd_subdirectory(inputs)\nadd_subdirectory(tools)\n\nif(USE_EXP)\n add_subdirectory(lonestar/experimental)\nendif(USE_EXP)\n\n###### Documentation ######\n\nif(BUILD_DOCS)\n set(GALOIS_ROOT ${CMAKE_CURRENT_SOURCE_DIR})\n add_subdirectory(docs)\nendif()\n\n###### Installation ######\n\ninclude(CMakePackageConfigHelpers)\nwrite_basic_package_version_file(\n ${CMAKE_CURRENT_BINARY_DIR}/GaloisConfigVersion.cmake\n VERSION ${GALOIS_VERSION}\n COMPATIBILITY SameMajorVersion\n)\nconfigure_package_config_file(\n cmake/GaloisConfig.cmake.in\n ${CMAKE_CURRENT_BINARY_DIR}/GaloisConfig.cmake\n INSTALL_DESTINATION \"${CMAKE_INSTALL_LIBDIR}/cmake/Galois\"\n PATH_VARS CMAKE_INSTALL_INCLUDEDIR CMAKE_INSTALL_LIBDIR CMAKE_INSTALL_BINDIR\n)\ninstall(\n FILES \"${CMAKE_CURRENT_BINARY_DIR}/GaloisConfigVersion.cmake\" \"${CMAKE_CURRENT_BINARY_DIR}/GaloisConfig.cmake\"\n DESTINATION \"${CMAKE_INSTALL_LIBDIR}/cmake/Galois\"\n COMPONENT dev\n)\ninstall(\n EXPORT GaloisTargets\n NAMESPACE Galois::\n DESTINATION \"${CMAKE_INSTALL_LIBDIR}/cmake/Galois\"\n COMPONENT dev\n)\n\n###### Distribution ######\n\nset(CPACK_GENERATOR \"TGZ\")\nset(CPACK_ARCHIVE_COMPONENT_INSTALL ON)\nset(CPACK_RESOURCE_FILE_LICENSE \"${CMAKE_CURRENT_SOURCE_DIR}/COPYRIGHT\")\nset(CPACK_RESOURCE_FILE_README \"${CMAKE_CURRENT_SOURCE_DIR}/README.md\")\nset(CPACK_PACKAGE_VERSION_MAJOR ${GALOIS_VERSION_MAJOR})\nset(CPACK_PACKAGE_VERSION_MINOR ${GALOIS_VERSION_MINOR})\nset(CPACK_PACKAGE_VERSION_PATCH ${GALOIS_VERSION_PATCH})\ninclude(CPack)\n" }, { "path": "COPYRIGHT", "content": "Galois, a framework to exploit amorphous data-parallelism in irregular\nprograms.\n\nCopyright (C) 2018, The University of Texas at Austin. All rights reserved.\nUNIVERSITY EXPRESSLY DISCLAIMS ANY AND ALL WARRANTIES CONCERNING THIS\nSOFTWARE AND DOCUMENTATION, INCLUDING ANY WARRANTIES OF MERCHANTABILITY,\nFITNESS FOR ANY PARTICULAR PURPOSE, NON-INFRINGEMENT AND WARRANTIES OF\nPERFORMANCE, AND ANY WARRANTY THAT MIGHT OTHERWISE ARISE FROM COURSE OF\nDEALING OR USAGE OF TRADE. NO WARRANTY IS EITHER EXPRESS OR IMPLIED WITH\nRESPECT TO THE USE OF THE SOFTWARE OR DOCUMENTATION. Under no circumstances\nshall University be liable for incidental, special, indirect, direct or\nconsequential damages or loss of profits, interruption of business, or\nrelated expenses which may arise from use of Software or Documentation,\nincluding but not limited to those resulting from defects in Software and/or\nDocumentation, or loss or inaccuracy of data of any kind.\n\nThis software is released under the terms of the 3-Clause BSD License (a\ncopy is located in LICENSE.txt at the top-level directory).\n" }, { "path": "LICENSE.txt", "content": "The 3-Clause BSD License\n\nCopyright 2018 The University of Texas at Austin\n\nRedistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:\n\n1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.\n\n2. 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.\n\n3. 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.\n\nTHIS 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.\n" }, { "path": "README.md", "content": "Overview\n========\n\n[![CircleCI](https://circleci.com/gh/IntelligentSoftwareSystems/Galois.svg?style=svg)](https://circleci.com/gh/IntelligentSoftwareSystems/Galois)\n[![Build Status](https://travis-ci.org/IntelligentSoftwareSystems/Galois.svg?branch=master)](https://travis-ci.org/IntelligentSoftwareSystems/Galois)\n\nGalois is a C++ library designed to ease parallel programming, especially for\napplications with irregular parallelism (e.g., irregular amount of work in parallel\nsections, irregular memory accesses and branching patterns). It implements\nan implicitly parallel programming model, where the programmer replaces serial loop\nconstructs (e.g. for and while) and serial data structures in their algorithms with parallel loop\nconstructs and concurrent data structures provided by Galois to express their algorithms.\nGalois is designed so that the programmer does not have to deal with low-level parallel programming constructs such as\nthreads, locks, barriers, condition variables, etc. \n\nHighlights include:\n- Parallel *for_each* loop that handles dependencies between iterations, as well as\n dynamic work creation, and a *do_all* loop for simple parallelism. Both provide load balancing and excellent\n scalability on multi-socket systems\n- A concurrent graph library designed for graph analytics algorithms as well as\n other domains such as irregular meshes. \n- Scalable concurrent containers such as bag, vector, list, etc. \n\nGalois is released under the BSD-3-Clause license. \n\n\nBuilding Galois\n===============\n\nYou can checkout the latest release by typing (in a terminal):\n\n```Shell\ngit clone -b release-5.0 https://github.com/IntelligentSoftwareSystems/Galois\n```\n\nThe master branch will be regularly updated, so you may try out the latest\ndevelopment code as well by checking out master branch:\n\n```Shell\ngit clone https://github.com/IntelligentSoftwareSystems/Galois\n```\n\nDependencies\n------------\n\nGalois builds, runs, and has been tested on GNU/Linux. Even though\nGalois may build on systems similar to Linux, we have not tested correctness or performance, so please\nbeware. \n\nAt the minimum, Galois depends on the following software:\n\n- A modern C++ compiler compliant with the C++-17 standard (gcc >= 7, Intel >= 19.0.1, clang >= 7.0)\n- CMake (>= 3.13)\n- Boost library (>= 1.58.0, we recommend building/installing the full library)\n- libllvm (>= 7.0 with RTTI support)\n- libfmt (>= 4.0)\n\nHere are the dependencies for the optional features: \n\n- 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\n 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:\n ```Shell\n cat /proc/meminfo | fgrep Huge\n AnonHugePages: 104448 kB\n HugePages_Total: 65536\n HugePages_Free: 65536\n HugePages_Rsvd: 0\n HugePages_Surp: 0\n Hugepagesize: 2048 kB\n ```\n\n- libnuma support. Performance may degrade without it. Please install\n libnuma-dev on Debian like systems, and numactl-dev on Red Hat like systems. \n- Doxygen (>= 1.8.5) for compiling documentation as webpages or latex files \n- PAPI (>= 5.2.0.0 ) for profiling sections of code\n- Vtune (>= 2017 ) for profiling sections of code\n- MPICH2 (>= 3.2) if you are interested in building and running distributed system\n applications in Galois\n- CUDA (>= 8.0 and < 11.0) if you want to build GPU or distributed heterogeneous applications.\n Note that versions >= 11.0 use an incompatible CUB module and will fail to execute.\n- Eigen (3.3.1 works for us) for some matrix-completion app variants\n\n\nCompiling and Testing Galois\n----------------------------\nWe use CMake to streamline building, testing and installing Galois. In the\nfollowing, we will highlight some common commands.\n\nLet's assume that `SRC_DIR` is the directory where the source code for Galois\nresides, and you wish to build Galois in some `BUILD_DIR`. Run the following\ncommands to set up a build directory:\n\n```Shell\nSRC_DIR=`pwd` # Or top-level Galois source dir\nBUILD_DIR=\n\nmkdir -p $BUILD_DIR\ncmake -S $SRC_DIR -B $BUILD_DIR -DCMAKE_BUILD_TYPE=Release\n```\n\nYou can also set up a `Debug` build by running the following instead of the last command above:\n\n```Shell\ncmake -S $SRC_DIR -B $BUILD_DIR -DCMAKE_BUILD_TYPE=Debug\n```\n\nGalois applications are in `lonestar` directory. In order to build a particular application:\n\n```Shell\nmake -C $BUILD_DIR/lonestar/ -j\n# or alternatively\nmake -C $BUILD_DIR -j\n# or\ncmake --build $BUILD_DIR --parallel\n```\n\nYou can also build everything by running `make -j` in the top-level of build directory, but that may\ntake a lot of time.\n\nSetting 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.\n\nThe tests for the core runtime will be built by default when you run `make`\nwith no target specified. They can be also built explicitly with:\n\n```Shell\nmake -C $BUILD_DIR/test\n```\n\nWe provide a few sample inputs that can be downloaded by running:\n\n```Shell\nmake -C $BUILD_DIR input\n```\n\n`make input` will download a tarball of inputs and extract it to\n`$BUILD_DIR/inputs/small_inputs` directory. The tarball is downloaded to\n`$BUILD_DIR/inputs`\n\nMost of the Galois apps have corresponding tests.\nThese tests depend on downloading the reference inputs and building the corresponding apps and test binaries.\nOnce the reference inputs have been downloaded and everything has been built,\nthe tests for the core library and all the apps can be run by running:\n\n```Shell\nmake test\n# or alternatively\nctest\n```\n\nin the build directory.\n\n\nRunning Galois Applications\n===========================\n\nGraph Format\n------------\n\nMany Galois/Lonestar applications work with graphs. We store graphs in a binary format\ncalled *galois graph file* \n(`.gr` file extension). Other formats such as edge-list or Matrix-Market can be\nconverted to `.gr` format with `graph-convert` tool provided in galois. \nYou can build graph-convert as follows:\n\n```Shell\ncd $BUILD_DIR\nmake graph-convert\n./tools/graph-convert/graph-convert --help\n```\n\nOther applications, such as Delaunay Mesh Refinement may read special file formats\nor some may even generate random inputs on the fly. \n\nRunning\n-------\n\nAll Lonestar applications take a `-t` command-line option to specify the number of\nthreads to use. All applications run a basic sanity check (often insufficient for\ncorrectness) on the program output, which can be turned off with the `-noverify` option. You \ncan specify `-help` command-line option to print all available options. \n\nUpon successful completion, each application will produce some stats regarding running\ntime of various sections, parallel loop iterations and memory usage, etc. These\nstats are in CSV format and can be redirected to a file using `-statFile` option.\nPlease refer to the manual for details on stats. \n\nRunning LonestarGPU applications\n--------------------------\n\nPlease refer to `lonestar/analytics/gpu/README.md` and `lonestar/scientific/gpu/README.md` for more details on\ncompiling and running LonestarGPU applications.\n\nRunning Distributed Galois\n--------------------------\n\nPlease refer to `lonestar/analytics/distributed/README.md` for more details on\nrunning distributed benchmarks.\n\nDocumentation\n=============\n\nGalois documentation is produced using doxygen, included in this repository, which includes a tutorial, a user's\nmanual and API documentation for the Galois library. \n\nUsers can build doxygen documentation in the build directory using:\n\n```Shell\ncd $BUILD_DIR\nmake doc\nyour-fav-browser html/index.html &\n```\n\nSee online documentation at:\n [http://iss.ices.utexas.edu/?p=projects/galois](http://iss.ices.utexas.edu/?p=projects/galois)\n\nSource-Tree Organization\n========================\n\n- `libgalois` contains the source code for the shared-memory Galois library, e.g., runtime, graphs, worklists, etc. \n- `lonestar` contains the Lonestar benchmark applications and tutorial examples for Galois\n- `libdist` contains the source code for the distributed-memory and heterogeneous Galois library\n- `lonestardist` contains the source code for the distributed-memory and heterogeneous\n benchmark applications. Please refer to `lonestardist/README.md` for instructions on\n building and running these apps. \n- `tools` contains various helper programs such as graph-converter to convert\n between graph file formats and graph-stats to print graph properties\n\nUsing Galois as a library\n=========================\n\nThere are two common ways to use Galois as a library. One way is to copy this\nrepository into your own CMake project, typically using a git submodule. Then\nyou can put the following in your CMakeLists.txt:\n\n```CMake\nadd_subdirectory(galois EXCLUDE_FROM_ALL)\nadd_executable(app ...)\ntarget_link_libraries(app Galois::shmem)\n```\n\nThe other common method is to install Galois outside your project and import it\nas a package.\n\nIf you want to install Galois, assuming that you wish to install it under\n`INSTALL_DIR`:\n\n```Shell\ncmake -DCMAKE_INSTALL_PREFIX=$INSTALL_DIR $SRC_DIR\nmake install\n```\n\nThen, you can put something like the following in CMakeLists.txt:\n\n```CMake\nlist(APPEND CMAKE_PREFIX_PATH ${INSTALL_DIR})\nfind_package(Galois REQUIRED)\nadd_executable(app ...)\ntarget_link_libraries(app Galois::shmem)\n```\n\nIf you are not using CMake, the corresponding basic commands (although the\nspecific commands vary by system) are:\n\n```Shell\nc++ -std=c++14 app.cpp -I$INSTALL_DIR/include -L$INSTALL_DIR/lib -lgalois_shmem\n```\nThird-Party Libraries and Licensing\n====================\n\nGalois includes some third party libraries that do not use the same license as\nGalois. This includes the bliss library (located in lonestar/include/Mining/bliss)\nand Modern GPU (located in libgpu/moderngpu). Please be aware of this when\nusing Galois.\n\nContact Us\n==========\nFor bugs, please raise an\n[issue](https://github.com/IntelligentSoftwareSystems/Galois/issues) on\nGiHub.\nQuestions and comments are also welcome at the Galois users mailing list:\n[galois-users@utlists.utexas.edu](galois-users@utlists.utexas.edu). You may\n[subscribe here](https://utlists.utexas.edu/sympa/subscribe/galois-users).\n\nIf you find a bug, it would help us if you sent (1) the command line and\nprogram inputs and outputs and (2) a core dump, preferably from an executable\nbuilt with the debug build.\n\nYou can enable core dumps by setting `ulimit -c unlimited` before running your\nprogram. The location where the core dumps will be stored can be determined with\n`cat /proc/sys/kernel/core_pattern`.\n\nTo create a debug build, assuming you will build Galois in `BUILD_DIR` and the\nsource is in `SRC_DIR`:\n\n```Shell\ncmake -S $SRC_DIR -B $BUILD_DIR -DCMAKE_BUILD_TYPE=Debug\nmake -C $BUILD_DIR\n```\n\nA simple way to capture relevant debugging details is to use the `script`\ncommand, which will record your terminal input and output. For example,\n\n```Shell\nscript debug-log.txt\nulimit -c unlimited\ncat /proc/sys/kernel/core_pattern\nmake -C $BUILD_DIR VERBOSE=1\nmy-app with-failing-input\nexit\n```\n\nThis will generate a file `debug-log.txt`, which you can send to the mailing\nlist:[galois-users@utlists.utexas.edu](galois-users@utlists.utexas.edu) for\nfurther debugging or supply when opening a GitHub issue.\n" }, { "path": "cmake/GaloisConfig.cmake.in", "content": "# Config file for the Galois package\n#\n# It exports the following targets:\n# Galois::shmem\n# Galois::dist\n# ...\n# (see GaloisTargets.cmake for all of them)\n#\n# It defines the following variables for legacy importing:\n# Galois_INCLUDE_DIRS\n# Galois_LIBRARIES\n# Galois_LIBRARY_DIRS\n# Galois_BIN_DIRS\ninclude(CMakeFindDependencyMacro)\n\n@PACKAGE_INIT@\n\nset_and_check(Galois_INCLUDE_DIRS \"@PACKAGE_CMAKE_INSTALL_INCLUDEDIR@\")\nset_and_check(Galois_LIBRARY_DIRS \"@PACKAGE_CMAKE_INSTALL_LIBDIR@\")\nset_and_check(Galois_BIN_DIRS \"@PACKAGE_CMAKE_INSTALL_BINDIR@\")\nset(Galois_LIBRARIES galois_shmem)\n\nfind_dependency(Threads REQUIRED)\nfind_dependency(Boost 1.58.0 REQUIRED COMPONENTS serialization iostreams)\nif (@GALOIS_ENABLE_DIST@)\n find_dependency(MPI REQUIRED)\nendif()\n\nget_filename_component(GALOIS_CMAKE_DIR \"${CMAKE_CURRENT_LIST_FILE}\" PATH)\n\nif(NOT Galois::shmem)\n include(\"${GALOIS_CMAKE_DIR}/GaloisTargets.cmake\")\nendif()\n" }, { "path": "cmake/Modules/CheckArchFlags.cmake", "content": "# Find architecture-specific flags\n#\n# Once done this will define\n# ARCH_FLAGS_FOUND\n# ARCH_CXX_FLAGS - Compiler flags to enable architecture-specific optimizations\n# ARCH_C_FLAGS - Compiler flags to enable architecture-specific optimizations\n# ARCH_LINK_FLAGS - Compiler flags to enable architecture-specific optimizations\ninclude(CheckCXXCompilerFlag)\n\nif(NOT USE_ARCH OR USE_ARCH STREQUAL \"none\" OR ARCH_FLAGS_FOUND)\n set(ARCH_CXX_FLAGS_CANDIDATES)\nelse()\n set(ARCH_CXX_FLAGS_CANDIDATES \"-march=${USE_ARCH}\")\nendif()\n\nif(USE_ARCH STREQUAL \"mic\")\n if(CMAKE_CXX_COMPILER_ID MATCHES \"Intel\")\n list(APPEND ARCH_CXX_FLAGS_CANDIDATES -mmic)\n endif()\n\n if(CMAKE_COMPILER_IS_GNUCC)\n list(APPEND ARCH_CXX_FLAGS_CANDIDATES -march=knc)\n endif()\nendif()\n\nforeach(FLAG ${ARCH_CXX_FLAGS_CANDIDATES})\n message(STATUS \"Try architecture flag = [${FLAG}]\")\n unset(ARCH_CXX_FLAGS_DETECTED)\n check_cxx_compiler_flag(\"${FLAG}\" ARCH_CXX_FLAGS_DETECTED)\n if(ARCH_CXX_FLAGS_DETECTED)\n set(ARCH_FLAGS_FOUND \"YES\")\n set(ARCH_CXX_FLAGS \"${FLAG}\")\n set(ARCH_C_FLAGS \"${FLAG}\")\n set(ARCH_LINK_FLAGS \"${FLAG}\")\n endif()\nendforeach()\n" }, { "path": "cmake/Modules/CheckCilk.cmake", "content": "include(CheckCXXSourceCompiles)\nset(Cilk_CXX_TEST_SOURCE\n\"\n#include \nint main(){ cilk_for(int i=0;i<1; ++i); }\n\")\nCHECK_CXX_SOURCE_COMPILES(\"${Cilk_CXX_TEST_SOURCE}\" HAVE_CILK)\nif(HAVE_CILK)\n message(STATUS \"A compiler with CILK support found\")\nendif()\n" }, { "path": "cmake/Modules/CheckEndian.cmake", "content": "include(TestBigEndian)\nTEST_BIG_ENDIAN(HAVE_BIG_ENDIAN)\ninclude(CheckIncludeFiles)\nCHECK_INCLUDE_FILES(endian.h HAVE_ENDIAN_H)\ninclude(CheckSymbolExists)\nCHECK_SYMBOL_EXISTS(le64toh \"endian.h\" HAVE_LE64TOH)\nCHECK_SYMBOL_EXISTS(le32toh \"endian.h\" HAVE_LE32TOH)\nCHECK_SYMBOL_EXISTS(htobe64 \"endian.h\" HAVE_HTOBE64)\nCHECK_SYMBOL_EXISTS(htobe32 \"endian.h\" HAVE_HTOBE32)\nCHECK_SYMBOL_EXISTS(htole64 \"endian.h\" HAVE_HTOLE64)\nCHECK_SYMBOL_EXISTS(htole32 \"endian.h\" HAVE_HTOLE32)\n" }, { "path": "cmake/Modules/CheckHugePages.cmake", "content": "include(CheckCSourceRuns)\nset(HugePages_C_TEST_SOURCE\n\"\n#ifdef __linux__\n#include \n#endif\n#include \n\nint main(int c, char** argv) {\n void *ptr = mmap(0, 2*1024*1024, PROT_READ|PROT_WRITE, MAP_HUGETLB, -1, 0);\n\n return ptr != MAP_FAILED;\n}\n\")\nif(HAVE_HUGEPAGES)\n\nelse()\n CHECK_C_SOURCE_RUNS(\"${HugePages_C_TEST_SOURCE}\" HAVE_HUGEPAGES_INTERNAL)\n if(HAVE_HUGEPAGES_INTERNAL)\n message(STATUS \"Huge pages found\")\n set(HAVE_HUGEPAGES \"${HAVE_HUGEPAGES_INTERNAL}\" CACHE BOOL \"Have hugepages\")\n endif()\nendif()\n" }, { "path": "cmake/Modules/CheckMmap.cmake", "content": "include(CheckCSourceCompiles)\nset(Mmap64_C_TEST_SOURCE\n\"\n#ifdef __linux__\n#include \n#endif\n#include \n\nint main(int c, char** argv) {\n void *ptr = mmap64(0, 2*1024*1024, PROT_READ|PROT_WRITE, MAP_PRIVATE, -1, 0);\n return 0;\n}\n\")\n\nif(HAVE_MMAP64)\n\nelse()\n CHECK_C_SOURCE_COMPILES(\"${Mmap64_C_TEST_SOURCE}\" HAVE_MMAP64_INTERNAL)\n if(HAVE_MMAP64_INTERNAL)\n message(STATUS \"mmap64 found\")\n set(HAVE_MMAP64 \"${HAVE_MMAP64_INTERNAL}\" CACHE BOOL \"Have mmap64\")\n endif()\nendif()\n" }, { "path": "cmake/Modules/CheckSchedSetAffinity.cmake", "content": "include(CheckSymbolExists)\n\nif(SCHED_SETAFFINITY_FOUND)\n\nelse()\n set(CMAKE_REQUIRED_DEFINITIONS -D_GNU_SOURCE)\n CHECK_SYMBOL_EXISTS(sched_setaffinity sched.h HAVE_SCHED_SETAFFINITY_INTERNAL)\n if(HAVE_SCHED_SETAFFINITY_INTERNAL)\n message(STATUS \"sched_setaffinity found\")\n set(SCHED_SETAFFINITY_FOUND \"${HAVE_SCHED_SETAFFINITY_INTERNAL}\")\n set(SCHED_SETAFFINITY_LIBRARIES rt)\n endif()\nendif()\n" }, { "path": "cmake/Modules/FindCBLAS.cmake", "content": "# Copyright 2009-2011 The VOTCA Development Team (http://www.votca.org)\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n#\n# http://www.apache.org/licenses/LICENSE-2.0\n#\n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS,\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.\n#\n\n#! \\file\n#! \\ingroup FindPackage\n#! \\brief Find CBLAS\n#!\n#! Find the native CBLAS headers and libraries.\n#!\n#! - `CBLAS_LIBRARIES` - List of libraries when using cblas.\n#! - `CBLAS_INCLUDE_DIRS` - List of include directories\n#! - `CBLAS_FOUND` - True if cblas found.\n#!\n#! Cblas can be provided by libblas (Ubuntu), cblas or gslcblas, it will be searched for in\n#! this order.\n\ninclude(LibFindMacros)\n\nif (UNIX)\n find_package(PkgConfig QUIET)\n pkg_check_modules(CBLAS_PKGCONF QUIET cblas)\nendif()\n\nif (NOT CBLAS_FOUND)\n\nif(CBLAS_PKGCONF_FOUND)\n\nforeach(NEW_CBLAS_LIB ${CBLAS_PKGCONF_LIBRARIES})\n find_library(LIB_${NEW_CBLAS_LIB} ${NEW_CBLAS_LIB} HINTS ${CBLAS_PKGCONF_LIBRARY_DIRS})\n if(NOT LIB_${NEW_CBLAS_LIB})\n message(FATAL_ERROR \"Could not find ${NEW_CBLAS_LIB} where pkgconfig said it is: ${CBLAS_PKGCONF_LIBRARY_DIRS}\")\n else(NOT LIB_${NEW_CBLAS_LIB})\n message(STATUS \"Found ${LIB_${NEW_CBLAS_LIB}}.\")\n endif(NOT LIB_${NEW_CBLAS_LIB})\n set(CBLAS_LIBRARY ${CBLAS_LIBRARY} ${LIB_${NEW_CBLAS_LIB}})\nendforeach(NEW_CBLAS_LIB)\n\nelse(CBLAS_PKGCONF_FOUND)\n\nset(CBLAS_HINT_PATH $ENV{CBLASDIR}/lib $ENV{CBLASDIR}/lib64 $ENV{UIBK_GSL_LIB})\n\n# Check if libblas provides cblas (Ubuntu)\nfind_library(BLAS_LIBRARY NAMES blas PATHS ${CBLAS_HINT_PATH})\nif(BLAS_LIBRARY)\n include(CheckSymbolExists)\n set(CMAKE_REQUIRED_LIBRARIES ${BLAS_LIBRARY})\n check_symbol_exists(cblas_scopy \"cblas.h\" BLAS_HAS_CBLAS)\nendif(BLAS_LIBRARY)\n\nset(CBLAS_CANDIDATES cblas gslcblas)\nif(BLAS_HAS_CBLAS)\n message(STATUS \"libblas provides cblas.\")\n set(CBLAS_CANDIDATES blas ${CBLAS_CANDIDATES})\nendif(BLAS_HAS_CBLAS)\n\nfind_library(CBLAS_LIBRARY\n NAMES ${CBLAS_CANDIDATES}\n PATHS ${CBLAS_HINT_PATH}\n)\nendif(CBLAS_PKGCONF_FOUND)\n\nif(\"${CBLAS_LIBRARY}\" MATCHES gslcblas)\n set(CBLAS_INCLUDE_CANDIDATE gsl/gsl_cblas.h)\nelse(\"${CBLAS_LIBRARY}\" MATCHES gslcblas)\n set(CBLAS_INCLUDE_CANDIDATE cblas.h)\nendif(\"${CBLAS_LIBRARY}\" MATCHES gslcblas)\n\nfind_path(CBLAS_INCLUDE_DIR ${CBLAS_INCLUDE_CANDIDATE} HINTS ${CBLAS_PKGCONF_INCLUDE_DIRS} $ENV{CBLASDIR}/include $ENV{UIBK_GSL_INC})\n\n# Set the include dir variables and the libraries and let libfind_process do the rest.\n# NOTE: Singular variables for this library, plural for libraries this this lib depends on.\nset(CBLAS_PROCESS_INCLUDES CBLAS_INCLUDE_DIR)\nset(CBLAS_PROCESS_LIBS CBLAS_LIBRARY)\nlibfind_process(CBLAS)\nmessage(STATUS \"Using '${CBLAS_LIBRARIES}' for cblas.\")\n\nendif(NOT CBLAS_FOUND)\n" }, { "path": "cmake/Modules/FindFortran.cmake", "content": "# Check if Fortran is possibly around before using enable_lanauge because\n# enable_language(... OPTIONAL) does not fail gracefully if language is not\n# found:\n# http://public.kitware.com/Bug/view.php?id=9220\nset(Fortran_EXECUTABLE)\nif(Fortran_EXECUTABLE)\n set(Fortran_FIND_QUIETLY TRUE)\nendif()\nfind_program(Fortran_EXECUTABLE NAMES gfortran ifort g77 f77 g90 f90)\ninclude(FindPackageHandleStandardArgs)\nfind_package_handle_standard_args(Fortran DEFAULT_MSG Fortran_EXECUTABLE)\nif(FORTRAN_FOUND)\n set(Fortran_FOUND TRUE)\nendif()\n" }, { "path": "cmake/Modules/FindGASNET.cmake", "content": "# Find the GasNet librairy\n# GASNET_FOUND - system has GasNet lib\n# GASNET_INCLUDE_DIR - the GasNet include directory\n# GASNET_LIBRARIES - Libraries needed to use GasNet\n\nif(GASNET_INCLUDE_DIRS AND GASNET_LIBRARIES)\n set(GASNET_FIND_QUIETLY TRUE)\nendif()\n\nfind_path(GASNET_INCLUDE_DIRS NAMES gasnet.h)\nfind_library(GASNET_LIBRARY_1 NAMES gasnet amudp HINTS ${GASNET_INCLUDE_DIRS}/../lib )\nfind_library(GASNET_LIBRARY_2 NAMES gasnet gasnet-udp-par HINTS ${GASNET_INCLUDE_DIRS}/../lib )\n\nset(GASNET_LIBRARIES ${GASNET_LIBRARY_2} ${GASNET_LIBRARY_1})\n\ninclude(FindPackageHandleStandardArgs)\nfind_package_handle_standard_args(GASNET DEFAULT_MSG GASNET_INCLUDE_DIRS GASNET_LIBRARIES)\n\nmark_as_advanced(GASNET_INCLUDE_DIRS GASNET_LIBRARIES)\n" }, { "path": "cmake/Modules/FindGMP.cmake", "content": "# Find the GMP librairies\n# GMP_FOUND - system has GMP lib\n# GMP_INCLUDE_DIR - the GMP include directory\n# GMP_LIBRARIES - Libraries needed to use GMP\n\n# Copyright (c) 2006, Laurent Montel, \n#\n# Redistribution and use is allowed according to the terms of the BSD license.\n# For details see the accompanying COPYING-CMAKE-SCRIPTS file.\n\nif(GMP_INCLUDE_DIRS AND GMP_LIBRARIES AND GMPXX_LIBRARIES)\n set(GMP_FIND_QUIETLY TRUE)\nendif()\n\nfind_path(GMP_INCLUDE_DIRS NAMES gmp.h)\nfind_library(GMP_LIBRARIES NAMES gmp libgmp)\nfind_library(GMPXX_LIBRARIES NAMES gmpxx libgmpxx)\n\ninclude(FindPackageHandleStandardArgs)\nfind_package_handle_standard_args(GMP DEFAULT_MSG GMP_INCLUDE_DIRS GMP_LIBRARIES)\n\nmark_as_advanced(GMP_INCLUDE_DIRS GMP_LIBRARIES GMPXX_LIBRARIES)\n" }, { "path": "cmake/Modules/FindGit.cmake", "content": "# The module defines the following variables:\n# GIT_EXECUTABLE - path to git command line client\n# GIT_FOUND - true if the command line client was found\n# Example usage:\n# find_package(Git)\n# if(GIT_FOUND)\n# message(\"git found: ${GIT_EXECUTABLE}\")\n# endif()\n\n#=============================================================================\n# Copyright 2010 Kitware, Inc.\n#\n# Distributed under the OSI-approved BSD License (the \"License\");\n# see accompanying file Copyright.txt for details.\n#\n# This software is distributed WITHOUT ANY WARRANTY; without even the\n# implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.\n# See the License for more information.\n#=============================================================================\n# (To distributed this file outside of CMake, substitute the full\n# License text for the above reference.)\n\n# Look for 'git' or 'eg' (easy git)\n#\nset(git_names git eg)\n\n# Prefer .cmd variants on Windows unless running in a Makefile\n# in the MSYS shell.\n#\nif(WIN32)\n if(NOT CMAKE_GENERATOR MATCHES \"MSYS\")\n set(git_names git.cmd git eg.cmd eg)\n endif()\nendif()\n\nfind_program(GIT_EXECUTABLE\n NAMES ${git_names}\n DOC \"git command line client\"\n )\nmark_as_advanced(GIT_EXECUTABLE)\n\n# Handle the QUIETLY and REQUIRED arguments and set GIT_FOUND to TRUE if\n# all listed variables are TRUE\n\ninclude(FindPackageHandleStandardArgs)\nfind_package_handle_standard_args(Git DEFAULT_MSG GIT_EXECUTABLE)\n" }, { "path": "cmake/Modules/FindNUMA.cmake", "content": "# Find numa library\n# Once done this will define\n# NUMA_FOUND - libnuma found\n# NUMA_OLD - old libnuma API\nif(NOT NUMA_FOUND)\n find_library(NUMA_LIBRARY NAMES numa PATH_SUFFIXES lib lib64)\n if(NUMA_LIBRARY)\n include(CheckLibraryExists)\n check_library_exists(${NUMA_LIBRARY} numa_available \"\" NUMA_FOUND_INTERNAL)\n if(NUMA_FOUND_INTERNAL)\n check_library_exists(${NUMA_LIBRARY} numa_allocate_nodemask \"\" NUMA_NEW_INTERNAL)\n if(NOT NUMA_NEW_INTERNAL)\n set(NUMA_OLD \"yes\" CACHE)\n endif()\n endif()\n\n include(FindPackageHandleStandardArgs)\n find_package_handle_standard_args(NUMA DEFAULT_MSG NUMA_LIBRARY)\n mark_as_advanced(NUMA_FOUND)\n endif()\nendif()\n\n" }, { "path": "cmake/Modules/FindOpenCL.cmake", "content": "#\n# This file taken from FindOpenCL project @ http://gitorious.com/findopencl\n#\n# - Try to find OpenCL\n# This module tries to find an OpenCL implementation on your system. It supports\n# AMD / ATI, Apple and NVIDIA implementations, but should work, too.\n#\n# Once done this will define\n# OPENCL_FOUND - system has OpenCL\n# OPENCL_INCLUDE_DIRS - the OpenCL include directory\n# OPENCL_LIBRARIES - link these to use OpenCL\n#\n# WIN32 should work, but is untested\n\nFIND_PACKAGE( PackageHandleStandardArgs )\n\nSET (OPENCL_VERSION_STRING \"0.1.0\")\nSET (OPENCL_VERSION_MAJOR 0)\nSET (OPENCL_VERSION_MINOR 1)\nSET (OPENCL_VERSION_PATCH 0)\n\nIF (APPLE)\n\n FIND_LIBRARY(OPENCL_LIBRARIES OpenCL DOC \"OpenCL lib for OSX\")\n FIND_PATH(OPENCL_INCLUDE_DIRS opencl/cl.h DOC \"Include for OpenCL on OSX\")\n FIND_PATH(_OPENCL_CPP_INCLUDE_DIRS opencl/cl.hpp DOC \"Include for OpenCL CPP bindings on OSX\")\n\nELSE (APPLE)\n\n\tIF (WIN32)\n\t\n\t FIND_PATH(OPENCL_INCLUDE_DIRS CL/cl.h)\n\t FIND_PATH(_OPENCL_CPP_INCLUDE_DIRS CL/cl.hpp)\n\t\n\t # The AMD SDK currently installs both x86 and x86_64 libraries\n\t # This is only a hack to find out architecture\n\t IF( ${CMAKE_SYSTEM_PROCESSOR} STREQUAL \"AMD64\" )\n\t \tSET(OPENCL_LIB_DIR \"$ENV{ATISTREAMSDKROOT}/lib/x86_64\")\n\t\t\tSET(OPENCL_LIB_DIR \"$ENV{ATIINTERNALSTREAMSDKROOT}/lib/x86_64\")\n\t ELSE (${CMAKE_SYSTEM_PROCESSOR} STREQUAL \"AMD64\")\n\t \tSET(OPENCL_LIB_DIR \"$ENV{ATISTREAMSDKROOT}/lib/x86\")\n\t \t\tSET(OPENCL_LIB_DIR \"$ENV{ATIINTERNALSTREAMSDKROOT}/lib/x86\")\n\t ENDIF( ${CMAKE_SYSTEM_PROCESSOR} STREQUAL \"AMD64\" )\n\n\t # find out if the user asked for a 64-bit build, and use the corresponding \n\t # 64 or 32 bit NVIDIA library paths to the search:\n\t STRING(REGEX MATCH \"Win64\" ISWIN64 ${CMAKE_GENERATOR})\n\t IF(\"${ISWIN64}\" STREQUAL \"Win64\") \n\t \tFIND_LIBRARY(OPENCL_LIBRARIES OpenCL.lib ${OPENCL_LIB_DIR} $ENV{CUDA_LIB_PATH} $ENV{CUDA_PATH}/lib/x64)\n\t ELSE(\"${ISWIN64}\" STREQUAL \"Win64\") \n\t \tFIND_LIBRARY(OPENCL_LIBRARIES OpenCL.lib ${OPENCL_LIB_DIR} $ENV{CUDA_LIB_PATH} $ENV{CUDA_PATH}/lib/Win32)\n\t ENDIF(\"${ISWIN64}\" STREQUAL \"Win64\") \n\n\t GET_FILENAME_COMPONENT(_OPENCL_INC_CAND ${OPENCL_LIB_DIR}/../../include ABSOLUTE)\n\t \n\t # On Win32 search relative to the library\n\t FIND_PATH(OPENCL_INCLUDE_DIRS CL/cl.h PATHS \"${_OPENCL_INC_CAND}\" $ENV{CUDA_INC_PATH} $ENV{CUDA_PATH}/include)\n\t FIND_PATH(_OPENCL_CPP_INCLUDE_DIRS CL/cl.hpp PATHS \"${_OPENCL_INC_CAND}\" $ENV{CUDA_INC_PATH} $ENV{CUDA_PATH}/include)\n\t\n\tELSE (WIN32)\n\n # Unix style platforms\n FIND_LIBRARY(OPENCL_LIBRARIES OpenCL\n ENV LD_LIBRARY_PATH\n )\n\n GET_FILENAME_COMPONENT(OPENCL_LIB_DIR ${OPENCL_LIBRARIES} PATH)\n GET_FILENAME_COMPONENT(_OPENCL_INC_CAND ${OPENCL_LIB_DIR}/../../include ABSOLUTE)\n\n # The AMD SDK currently does not place its headers\n # in /usr/include, therefore also search relative\n # to the library\n FIND_PATH(OPENCL_INCLUDE_DIRS CL/cl.h PATHS ${_OPENCL_INC_CAND} $ENV{OPENCL_INCLUDE_DIRS} \"/usr/local/cuda/include\")\n FIND_PATH(_OPENCL_CPP_INCLUDE_DIRS CL/cl.hpp PATHS ${_OPENCL_INC_CAND} $ENV{OPENCL_LIB_DIR} \"/usr/local/cuda/include\")\n\n\tENDIF (WIN32)\n\nENDIF (APPLE)\n\nFIND_PACKAGE_HANDLE_STANDARD_ARGS( OpenCL DEFAULT_MSG OPENCL_LIBRARIES OPENCL_INCLUDE_DIRS )\n\nIF( _OPENCL_CPP_INCLUDE_DIRS )\n\tSET( OPENCL_HAS_CPP_BINDINGS TRUE )\n\tLIST( APPEND OPENCL_INCLUDE_DIRS ${_OPENCL_CPP_INCLUDE_DIRS} )\n\t# This is often the same, so clean up\n\tLIST( REMOVE_DUPLICATES OPENCL_INCLUDE_DIRS )\nENDIF( _OPENCL_CPP_INCLUDE_DIRS )\n\nMARK_AS_ADVANCED(\n OPENCL_INCLUDE_DIRS\n)\n" }, { "path": "cmake/Modules/FindPAPI.cmake", "content": "# Find PAPI libraries\n# Once done this will define\n# PAPI_FOUND - System has PAPI\n# PAPI_INCLUDE_DIRS - The PAPI include directories\n# PAPI_LIBRARIES - The libraries needed to use PAPI\n\nif(PAPI_INCLUDE_DIRS AND PAPI_LIBRARIES)\n set(PAPI_FIND_QUIETLY TRUE)\nendif()\n\n# XXX(ddn): our system papi is broken so ignore for now\n# find_path(PAPI_INCLUDE_DIRS papi.h HINTS ${PAPI_ROOT} PATH_SUFFIXES include NO_DEFAULT_PATH )\nfind_path(PAPI_INCLUDE_DIRS papi.h HINTS ${PAPI_ROOT} ENV TACC_PAPI_DIR PATH_SUFFIXES include)\nmessage(STATUS \"PAPI_INCLUDE_DIRS: ${PAPI_INCLUDE_DIRS}\")\nfind_library(PAPI_LIBRARY NAMES papi HINTS ${PAPI_ROOT} ENV TACC_PAPI_DIR PATH_SUFFIXES lib lib64)\nmessage(STATUS \"PAPI_LIBRARY: ${PAPI_LIBRARY}\")\nfind_library(PAPI_LIBRARIES NAMES rt PATH_SUFFIXES lib lib64)\n\ninclude(FindPackageHandleStandardArgs)\nfind_package_handle_standard_args(PAPI DEFAULT_MSG PAPI_LIBRARY PAPI_LIBRARIES PAPI_INCLUDE_DIRS)\nif(PAPI_FOUND)\n set(PAPI_LIBRARIES ${PAPI_LIBRARY} ${PAPI_LIBRARIES})\nendif()\n\nmark_as_advanced(PAPI_INCLUDE_DIRS PAPI_LIBRARIES)\n" }, { "path": "cmake/Modules/FindQGLViewer.cmake", "content": "# Find QGLViewer libraries\n# Once done this will define\n# QGLViewer_FOUND - System has QGLViewer\n# QGLViewer_INCLUDE_DIRS - The QGLViewer include directories\n# QGLViewer_LIBRARIES - The libraries needed to use QGLViewer\n\nif(QGLViewer_INCLUDE_DIRS AND QGLVIEWER_LIBRARIES)\n set(QGLViewer_FIND_QUIETLY TRUE)\nendif()\n\nfind_path(QGLViewer_INCLUDE_DIRS NAMES QGLViewer/qglviewer.h)\nfind_library(QGLViewer_LIBRARIES NAMES QGLViewer PATH_SUFFIXES lib lib64)\n\ninclude(FindPackageHandleStandardArgs)\nfind_package_handle_standard_args(QGLViewer DEFAULT_MSG QGLViewer_INCLUDE_DIRS QGLViewer_LIBRARIES)\nif(QGLVIEWER_FOUND)\n set(QGLViewer_FOUND TRUE)\nendif()\n\nmark_as_advanced(QGLViewer_INCLUDE_DIRS QGLViewer_LIBRARIES)\n" }, { "path": "cmake/Modules/FindTBB.cmake", "content": "# Locate Intel Threading Building Blocks include paths and libraries\r\n# FindTBB.cmake can be found at https://code.google.com/p/findtbb/\r\n# Written by Hannes Hofmann \r\n# Improvements by Gino van den Bergen ,\r\n# Florian Uhlig ,\r\n# Jiri Marsik \r\n\r\n# The MIT License\r\n#\r\n# Copyright (c) 2011 Hannes Hofmann\r\n#\r\n# Permission is hereby granted, free of charge, to any person obtaining a copy\r\n# of this software and associated documentation files (the \"Software\"), to deal\r\n# in the Software without restriction, including without limitation the rights\r\n# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\r\n# copies of the Software, and to permit persons to whom the Software is\r\n# furnished to do so, subject to the following conditions:\r\n#\r\n# The above copyright notice and this permission notice shall be included in\r\n# all copies or substantial portions of the Software.\r\n#\r\n# THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\r\n# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\r\n# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\r\n# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\r\n# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\r\n# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\r\n# THE SOFTWARE.\r\n\r\n# GvdB: This module uses the environment variable TBB_ARCH_PLATFORM which defines architecture and compiler.\r\n# e.g. \"ia32/vc8\" or \"em64t/cc4.1.0_libc2.4_kernel2.6.16.21\"\r\n# TBB_ARCH_PLATFORM is set by the build script tbbvars[.bat|.sh|.csh], which can be found\r\n# in the TBB installation directory (TBB_INSTALL_DIR).\r\n#\r\n# GvdB: Mac OS X distribution places libraries directly in lib directory.\r\n#\r\n# For backwards compatibility, you may explicitely set the CMake variables TBB_ARCHITECTURE and TBB_COMPILER.\r\n# TBB_ARCHITECTURE [ ia32 | em64t | itanium ]\r\n# which architecture to use\r\n# TBB_COMPILER e.g. vc9 or cc3.2.3_libc2.3.2_kernel2.4.21 or cc4.0.1_os10.4.9\r\n# which compiler to use (detected automatically on Windows)\r\n\r\n# This module respects\r\n# TBB_INSTALL_DIR or $ENV{TBB21_INSTALL_DIR} or $ENV{TBB_INSTALL_DIR}\r\n\r\n# This module defines\r\n# TBB_INCLUDE_DIRS, where to find task_scheduler_init.h, etc.\r\n# TBB_LIBRARY_DIRS, where to find libtbb, libtbbmalloc\r\n# TBB_DEBUG_LIBRARY_DIRS, where to find libtbb_debug, libtbbmalloc_debug\r\n# TBB_INSTALL_DIR, the base TBB install directory\r\n# TBB_LIBRARIES, the libraries to link against to use TBB.\r\n# TBB_DEBUG_LIBRARIES, the libraries to link against to use TBB with debug symbols.\r\n# TBB_FOUND, If false, don't try to use TBB.\r\n# TBB_INTERFACE_VERSION, as defined in tbb/tbb_stddef.h\r\n\r\n\r\nif (WIN32)\r\n # has em64t/vc8 em64t/vc9\r\n # has ia32/vc7.1 ia32/vc8 ia32/vc9\r\n set(_TBB_DEFAULT_INSTALL_DIR \"C:/Program Files/Intel/TBB\" \"C:/Program Files (x86)/Intel/TBB\")\r\n set(_TBB_LIB_NAME \"tbb\")\r\n set(_TBB_LIB_MALLOC_NAME \"${_TBB_LIB_NAME}malloc\")\r\n set(_TBB_LIB_DEBUG_NAME \"${_TBB_LIB_NAME}_debug\")\r\n set(_TBB_LIB_MALLOC_DEBUG_NAME \"${_TBB_LIB_MALLOC_NAME}_debug\")\r\n if (MSVC71)\r\n set (_TBB_COMPILER \"vc7.1\")\r\n endif(MSVC71)\r\n if (MSVC80)\r\n set(_TBB_COMPILER \"vc8\")\r\n endif(MSVC80)\r\n if (MSVC90)\r\n set(_TBB_COMPILER \"vc9\")\r\n endif(MSVC90)\r\n if(MSVC10)\r\n set(_TBB_COMPILER \"vc10\")\r\n endif(MSVC10)\r\n # Todo: add other Windows compilers such as ICL.\r\n set(_TBB_ARCHITECTURE ${TBB_ARCHITECTURE})\r\nendif (WIN32)\r\n\r\nif (UNIX)\r\n if (APPLE)\r\n # MAC\r\n set(_TBB_DEFAULT_INSTALL_DIR \"/Library/Frameworks/Intel_TBB.framework/Versions\")\r\n # libs: libtbb.dylib, libtbbmalloc.dylib, *_debug\r\n set(_TBB_LIB_NAME \"tbb\")\r\n set(_TBB_LIB_MALLOC_NAME \"${_TBB_LIB_NAME}malloc\")\r\n set(_TBB_LIB_DEBUG_NAME \"${_TBB_LIB_NAME}_debug\")\r\n set(_TBB_LIB_MALLOC_DEBUG_NAME \"${_TBB_LIB_MALLOC_NAME}_debug\")\r\n # default flavor on apple: ia32/cc4.0.1_os10.4.9\r\n # Jiri: There is no reason to presume there is only one flavor and\r\n # that user's setting of variables should be ignored.\r\n if(NOT TBB_COMPILER)\r\n set(_TBB_COMPILER \"cc4.0.1_os10.4.9\")\r\n elseif (NOT TBB_COMPILER)\r\n set(_TBB_COMPILER ${TBB_COMPILER})\r\n endif(NOT TBB_COMPILER)\r\n if(NOT TBB_ARCHITECTURE)\r\n set(_TBB_ARCHITECTURE \"ia32\")\r\n elseif(NOT TBB_ARCHITECTURE)\r\n set(_TBB_ARCHITECTURE ${TBB_ARCHITECTURE})\r\n endif(NOT TBB_ARCHITECTURE)\r\n else (APPLE)\r\n # LINUX\r\n set(_TBB_DEFAULT_INSTALL_DIR \"/opt/intel/tbb\" \"/usr/local/include\" \"/usr/include\")\r\n set(_TBB_LIB_NAME \"tbb\")\r\n set(_TBB_LIB_MALLOC_NAME \"${_TBB_LIB_NAME}malloc\")\r\n set(_TBB_LIB_DEBUG_NAME \"${_TBB_LIB_NAME}_debug\")\r\n set(_TBB_LIB_MALLOC_DEBUG_NAME \"${_TBB_LIB_MALLOC_NAME}_debug\")\r\n # 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\r\n # has ia32/*\r\n # has itanium/*\r\n set(_TBB_COMPILER ${TBB_COMPILER})\r\n set(_TBB_ARCHITECTURE ${TBB_ARCHITECTURE})\r\n endif (APPLE)\r\nendif (UNIX)\r\n\r\nif (CMAKE_SYSTEM MATCHES \"SunOS.*\")\r\n# SUN\r\n# not yet supported\r\n# has em64t/cc3.4.3_kernel5.10\r\n# has ia32/*\r\nendif (CMAKE_SYSTEM MATCHES \"SunOS.*\")\r\n\r\n\r\n#-- Clear the public variables\r\nset (TBB_FOUND \"NO\")\r\n\r\n\r\n#-- Find TBB install dir and set ${_TBB_INSTALL_DIR} and cached ${TBB_INSTALL_DIR}\r\n# first: use CMake variable TBB_INSTALL_DIR\r\nif (TBB_INSTALL_DIR)\r\n set (_TBB_INSTALL_DIR ${TBB_INSTALL_DIR})\r\nendif (TBB_INSTALL_DIR)\r\n# second: use environment variable\r\nif (NOT _TBB_INSTALL_DIR)\r\n if (NOT \"$ENV{TBBROOT}\" STREQUAL \"\")\r\n set (_TBB_INSTALL_DIR $ENV{TBBROOT})\r\n endif()\r\n if (NOT \"$ENV{TBB_INSTALL_DIR}\" STREQUAL \"\")\r\n set (_TBB_INSTALL_DIR $ENV{TBB_INSTALL_DIR})\r\n endif (NOT \"$ENV{TBB_INSTALL_DIR}\" STREQUAL \"\")\r\n # Intel recommends setting TBB21_INSTALL_DIR\r\n if (NOT \"$ENV{TBB21_INSTALL_DIR}\" STREQUAL \"\")\r\n set (_TBB_INSTALL_DIR $ENV{TBB21_INSTALL_DIR})\r\n endif (NOT \"$ENV{TBB21_INSTALL_DIR}\" STREQUAL \"\")\r\n if (NOT \"$ENV{TBB22_INSTALL_DIR}\" STREQUAL \"\")\r\n set (_TBB_INSTALL_DIR $ENV{TBB22_INSTALL_DIR})\r\n endif (NOT \"$ENV{TBB22_INSTALL_DIR}\" STREQUAL \"\")\r\n if (NOT \"$ENV{TBB30_INSTALL_DIR}\" STREQUAL \"\")\r\n set (_TBB_INSTALL_DIR $ENV{TBB30_INSTALL_DIR})\r\n endif (NOT \"$ENV{TBB30_INSTALL_DIR}\" STREQUAL \"\")\r\nendif (NOT _TBB_INSTALL_DIR)\r\n# third: try to find path automatically\r\nif (NOT _TBB_INSTALL_DIR)\r\n if (_TBB_DEFAULT_INSTALL_DIR)\r\n set (_TBB_INSTALL_DIR ${_TBB_DEFAULT_INSTALL_DIR})\r\n endif (_TBB_DEFAULT_INSTALL_DIR)\r\nendif (NOT _TBB_INSTALL_DIR)\r\n# sanity check\r\nif (NOT _TBB_INSTALL_DIR)\r\n message (\"ERROR: Unable to find Intel TBB install directory. ${_TBB_INSTALL_DIR}\")\r\nelse (NOT _TBB_INSTALL_DIR)\r\n# finally: set the cached CMake variable TBB_INSTALL_DIR\r\nif (NOT TBB_INSTALL_DIR)\r\n set (TBB_INSTALL_DIR ${_TBB_INSTALL_DIR} CACHE PATH \"Intel TBB install directory\")\r\n mark_as_advanced(TBB_INSTALL_DIR)\r\nendif (NOT TBB_INSTALL_DIR)\r\n\r\n\r\n#-- A macro to rewrite the paths of the library. This is necessary, because\r\n# find_library() always found the em64t/vc9 version of the TBB libs\r\nmacro(TBB_CORRECT_LIB_DIR var_name)\r\n# if (NOT \"${_TBB_ARCHITECTURE}\" STREQUAL \"em64t\")\r\n string(REPLACE em64t \"${_TBB_ARCHITECTURE}\" ${var_name} ${${var_name}})\r\n# endif (NOT \"${_TBB_ARCHITECTURE}\" STREQUAL \"em64t\")\r\n string(REPLACE ia32 \"${_TBB_ARCHITECTURE}\" ${var_name} ${${var_name}})\r\n string(REPLACE vc7.1 \"${_TBB_COMPILER}\" ${var_name} ${${var_name}})\r\n string(REPLACE vc8 \"${_TBB_COMPILER}\" ${var_name} ${${var_name}})\r\n string(REPLACE vc9 \"${_TBB_COMPILER}\" ${var_name} ${${var_name}})\r\n string(REPLACE vc10 \"${_TBB_COMPILER}\" ${var_name} ${${var_name}})\r\nendmacro(TBB_CORRECT_LIB_DIR var_content)\r\n\r\n\r\n#-- Look for include directory and set ${TBB_INCLUDE_DIR}\r\nset (TBB_INC_SEARCH_DIR ${_TBB_INSTALL_DIR}/include)\r\n# Jiri: tbbvars now sets the CPATH environment variable to the directory\r\n# containing the headers.\r\nfind_path(TBB_INCLUDE_DIR\r\n tbb/task_scheduler_init.h\r\n PATHS ${TBB_INC_SEARCH_DIR} ENV CPATH\r\n)\r\nmark_as_advanced(TBB_INCLUDE_DIR)\r\n\r\n\r\n#-- Look for libraries\r\n# GvdB: $ENV{TBB_ARCH_PLATFORM} is set by the build script tbbvars[.bat|.sh|.csh]\r\nif (NOT $ENV{TBB_ARCH_PLATFORM} STREQUAL \"\")\r\n set (_TBB_LIBRARY_DIR \r\n ${_TBB_INSTALL_DIR}/lib/$ENV{TBB_ARCH_PLATFORM}\r\n ${_TBB_INSTALL_DIR}/$ENV{TBB_ARCH_PLATFORM}/lib\r\n )\r\nendif (NOT $ENV{TBB_ARCH_PLATFORM} STREQUAL \"\")\r\n# Jiri: This block isn't mutually exclusive with the previous one\r\n# (hence no else), instead I test if the user really specified\r\n# the variables in question.\r\nif ((NOT ${TBB_ARCHITECTURE} STREQUAL \"\") AND (NOT ${TBB_COMPILER} STREQUAL \"\"))\r\n # HH: deprecated\r\n 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]).\")\r\n # Jiri: It doesn't hurt to look in more places, so I store the hints from\r\n # ENV{TBB_ARCH_PLATFORM} and the TBB_ARCHITECTURE and TBB_COMPILER\r\n # variables and search them both.\r\n set (_TBB_LIBRARY_DIR \"${_TBB_INSTALL_DIR}/${_TBB_ARCHITECTURE}/${_TBB_COMPILER}/lib\" ${_TBB_LIBRARY_DIR})\r\nendif ((NOT ${TBB_ARCHITECTURE} STREQUAL \"\") AND (NOT ${TBB_COMPILER} STREQUAL \"\"))\r\n\r\n# GvdB: Mac OS X distribution places libraries directly in lib directory.\r\nlist(APPEND _TBB_LIBRARY_DIR ${_TBB_INSTALL_DIR}/lib)\r\n\r\n# Jiri: No reason not to check the default paths. From recent versions,\r\n# tbbvars has started exporting the LIBRARY_PATH and LD_LIBRARY_PATH\r\n# variables, which now point to the directories of the lib files.\r\n# It all makes more sense to use the ${_TBB_LIBRARY_DIR} as a HINTS\r\n# argument instead of the implicit PATHS as it isn't hard-coded\r\n# but computed by system introspection. Searching the LIBRARY_PATH\r\n# and LD_LIBRARY_PATH environment variables is now even more important\r\n# that tbbvars doesn't export TBB_ARCH_PLATFORM and it facilitates\r\n# the use of TBB built from sources.\r\nfind_library(TBB_LIBRARY ${_TBB_LIB_NAME} HINTS ${_TBB_LIBRARY_DIR}\r\n PATHS ENV LIBRARY_PATH ENV LD_LIBRARY_PATH)\r\nfind_library(TBB_MALLOC_LIBRARY ${_TBB_LIB_MALLOC_NAME} HINTS ${_TBB_LIBRARY_DIR}\r\n PATHS ENV LIBRARY_PATH ENV LD_LIBRARY_PATH)\r\n\r\n#Extract path from TBB_LIBRARY name\r\nget_filename_component(TBB_LIBRARY_DIR ${TBB_LIBRARY} PATH)\r\n\r\n#TBB_CORRECT_LIB_DIR(TBB_LIBRARY)\r\n#TBB_CORRECT_LIB_DIR(TBB_MALLOC_LIBRARY)\r\nmark_as_advanced(TBB_LIBRARY TBB_MALLOC_LIBRARY)\r\n\r\n#-- Look for debug libraries\r\n# Jiri: Changed the same way as for the release libraries.\r\nfind_library(TBB_LIBRARY_DEBUG ${_TBB_LIB_DEBUG_NAME} HINTS ${_TBB_LIBRARY_DIR}\r\n PATHS ENV LIBRARY_PATH ENV LD_LIBRARY_PATH)\r\nfind_library(TBB_MALLOC_LIBRARY_DEBUG ${_TBB_LIB_MALLOC_DEBUG_NAME} HINTS ${_TBB_LIBRARY_DIR}\r\n PATHS ENV LIBRARY_PATH ENV LD_LIBRARY_PATH)\r\n\r\n# Jiri: Self-built TBB stores the debug libraries in a separate directory.\r\n# Extract path from TBB_LIBRARY_DEBUG name\r\nget_filename_component(TBB_LIBRARY_DEBUG_DIR ${TBB_LIBRARY_DEBUG} PATH)\r\n\r\n#TBB_CORRECT_LIB_DIR(TBB_LIBRARY_DEBUG)\r\n#TBB_CORRECT_LIB_DIR(TBB_MALLOC_LIBRARY_DEBUG)\r\nmark_as_advanced(TBB_LIBRARY_DEBUG TBB_MALLOC_LIBRARY_DEBUG)\r\n\r\n\r\nif (TBB_INCLUDE_DIR)\r\n if (TBB_LIBRARY)\r\n set (TBB_FOUND \"YES\")\r\n set (TBB_LIBRARIES ${TBB_LIBRARY} ${TBB_MALLOC_LIBRARY} ${TBB_LIBRARIES})\r\n set (TBB_DEBUG_LIBRARIES ${TBB_LIBRARY_DEBUG} ${TBB_MALLOC_LIBRARY_DEBUG} ${TBB_DEBUG_LIBRARIES})\r\n set (TBB_INCLUDE_DIRS ${TBB_INCLUDE_DIR} CACHE PATH \"TBB include directory\" FORCE)\r\n set (TBB_LIBRARY_DIRS ${TBB_LIBRARY_DIR} CACHE PATH \"TBB library directory\" FORCE)\r\n # Jiri: Self-built TBB stores the debug libraries in a separate directory.\r\n set (TBB_DEBUG_LIBRARY_DIRS ${TBB_LIBRARY_DEBUG_DIR} CACHE PATH \"TBB debug library directory\" FORCE)\r\n mark_as_advanced(TBB_INCLUDE_DIRS TBB_LIBRARY_DIRS TBB_DEBUG_LIBRARY_DIRS TBB_LIBRARIES TBB_DEBUG_LIBRARIES)\r\n message(STATUS \"Found Intel TBB\")\r\n endif (TBB_LIBRARY)\r\nendif (TBB_INCLUDE_DIR)\r\n\r\nif (NOT TBB_FOUND)\r\n message(\"ERROR: Intel TBB NOT found!\")\r\n message(STATUS \"Looked for Threading Building Blocks in ${_TBB_INSTALL_DIR}\")\r\n # do only throw fatal, if this pkg is REQUIRED\r\n if (TBB_FIND_REQUIRED)\r\n message(FATAL_ERROR \"Could NOT find TBB library.\")\r\n endif (TBB_FIND_REQUIRED)\r\nendif (NOT TBB_FOUND)\r\n\r\nendif (NOT _TBB_INSTALL_DIR)\r\n\r\nif (TBB_FOUND)\r\n\tset(TBB_INTERFACE_VERSION 0)\r\n#\tFILE(READ \"${TBB_INCLUDE_DIRS}/tbb/tbb_stddef.h\" _TBB_VERSION_CONTENTS)\r\n\tSTRING(REGEX REPLACE \".*#define TBB_INTERFACE_VERSION ([0-9]+).*\" \"\\\\1\" TBB_INTERFACE_VERSION \"${_TBB_VERSION_CONTENTS}\")\r\n\tset(TBB_INTERFACE_VERSION \"${TBB_INTERFACE_VERSION}\")\r\nendif (TBB_FOUND)\r\n" }, { "path": "cmake/Modules/FindVTune.cmake", "content": "# Find VTune libraries\n# Once done this will define\n# VTune_FOUND - System has VTune\n# VTune_INCLUDE_DIRS - The VTune include directories\n# VTune_LIBRARIES - The libraries needed to use VTune\n\nmessage(STATUS \"${VTune_INCLUDE_DIRS}\")\n\nif(VTune_INCLUDE_DIRS AND VTune_LIBRARIES)\n set(VTune_FIND_QUIETLY TRUE)\nendif()\n\n\nset(VTune_LIBRARY_PATH_CANDIDATES lib lib64 lib32 bin64/k1om bin32/k1om)\nfind_path(VTune_INCLUDE_DIRS ittnotify.h PATHS ${VTune_ROOT} PATH_SUFFIXES include)\nfind_library(VTune_LIBRARY NAMES ittnotify PATHS ${VTune_ROOT} PATH_SUFFIXES ${VTune_LIBRARY_PATH_CANDIDATES})\nfind_library(VTune_LIBRARIES NAMES dl PATH_SUFFIXES lib lib64 lib32)\n\ninclude(FindPackageHandleStandardArgs)\nfind_package_handle_standard_args(VTune DEFAULT_MSG VTune_LIBRARY VTune_LIBRARIES VTune_INCLUDE_DIRS)\nif(VTUNE_FOUND)\n set(VTune_FOUND on)\n set(VTune_LIBRARIES ${VTune_LIBRARY} ${VTune_LIBRARIES})\nendif()\nmark_as_advanced(VTune_INCLUDE_DIRS VTune_LIBRARIES)\n" }, { "path": "cmake/Modules/GetGitVersion-write.cmake", "content": "### Don't include directly, for use by GetSVNVersion.cmake\nfind_package(Git)\n# Extract svn info into MY_XXX variables\nif(GIT_FOUND)\n execute_process(COMMAND ${GIT_EXECUTABLE} rev-parse --verify --short HEAD\n WORKING_DIRECTORY ${SOURCE_DIR}\n OUTPUT_VARIABLE GIT_REVISION\n OUTPUT_STRIP_TRAILING_WHITESPACE)\n file(WRITE include/galois/revision.h.txt \"#define GALOIS_REVISION \\\"${GIT_REVISION}\\\"\\n\")\nelse()\n file(WRITE include/galois/revision.h.txt \"#define GALOIS_REVISION \\\"0\\\"\\n\")\nendif()\n\nexecute_process(COMMAND ${CMAKE_COMMAND} -E copy_if_different include/galois/revision.h.txt include/galois/revision.h)\n" }, { "path": "cmake/Modules/GetGitVersion.cmake", "content": "# DUMMY is a non-existent file to force regeneration of svn header every build\nadd_custom_target(revision ALL DEPENDS DUMMY ${PROJECT_BINARY_DIR}/include/galois/revision.h)\n\nfind_file(_MODULE \"GetGitVersion-write.cmake\" PATHS ${CMAKE_MODULE_PATH})\n\nadd_custom_command(OUTPUT DUMMY ${PROJECT_BINARY_DIR}/include/galois/revision.h\n COMMAND ${CMAKE_COMMAND} -DSOURCE_DIR=${CMAKE_SOURCE_DIR}\n -DCMAKE_MODULE_PATH=\"${CMAKE_SOURCE_DIR}/cmake/Modules/\" -P ${_MODULE})\n\nset(_MODULE off)\n\nset_source_files_properties(${PROJECT_BINARY_DIR}/include/galois/revision.h\n PROPERTIES GENERATED TRUE\n HEADER_FILE_ONLY TRUE)\n" }, { "path": "cmake/Modules/HandleSanitizer.cmake", "content": "# Galois: taken from:\n# https://github.com/llvm/llvm-project/blob/master/llvm/cmake/modules/HandleLLVMOptions.cmake \n\ninclude(CheckCCompilerFlag)\ninclude(CheckCXXCompilerFlag)\n\nstring(TOUPPER \"${CMAKE_BUILD_TYPE}\" uppercase_CMAKE_BUILD_TYPE)\n\nif(NOT GALOIS_USE_SANITIZER)\n return()\nendif()\n\nfunction(append value)\n foreach(variable ${ARGN})\n set(${variable} \"${${variable}} ${value}\" PARENT_SCOPE)\n endforeach(variable)\nendfunction()\n\nfunction(append_if condition value)\n if (${condition})\n foreach(variable ${ARGN})\n set(${variable} \"${${variable}} ${value}\" PARENT_SCOPE)\n endforeach(variable)\n endif()\nendfunction()\n\nmacro(add_flag_if_supported flag name)\n check_c_compiler_flag(\"-Werror ${flag}\" \"C_SUPPORTS_${name}\")\n append_if(\"C_SUPPORTS_${name}\" \"${flag}\" CMAKE_C_FLAGS)\n check_cxx_compiler_flag(\"-Werror ${flag}\" \"CXX_SUPPORTS_${name}\")\n append_if(\"CXX_SUPPORTS_${name}\" \"${flag}\" CMAKE_CXX_FLAGS)\nendmacro()\n\nmacro(append_common_sanitizer_flags)\n # Append -fno-omit-frame-pointer and turn on debug info to get better\n # stack traces.\n add_flag_if_supported(\"-fno-omit-frame-pointer\" FNO_OMIT_FRAME_POINTER)\n if (NOT uppercase_CMAKE_BUILD_TYPE STREQUAL \"DEBUG\" AND\n NOT uppercase_CMAKE_BUILD_TYPE STREQUAL \"RELWITHDEBINFO\")\n add_flag_if_supported(\"-gline-tables-only\" GLINE_TABLES_ONLY)\n endif()\n # Use -O1 even in debug mode, otherwise sanitizers slowdown is too large.\n if (uppercase_CMAKE_BUILD_TYPE STREQUAL \"DEBUG\")\n add_flag_if_supported(\"-O1\" O1)\n endif()\nendmacro()\n\nif (GALOIS_USE_SANITIZER STREQUAL \"Address\")\n append_common_sanitizer_flags()\n append(\"-fsanitize=address\" CMAKE_C_FLAGS CMAKE_CXX_FLAGS)\nelseif (GALOIS_USE_SANITIZER STREQUAL \"HWAddress\")\n append_common_sanitizer_flags()\n append(\"-fsanitize=hwaddress\" CMAKE_C_FLAGS CMAKE_CXX_FLAGS)\nelseif (GALOIS_USE_SANITIZER MATCHES \"Memory(WithOrigins)?\")\n append_common_sanitizer_flags()\n append(\"-fsanitize=memory\" CMAKE_C_FLAGS CMAKE_CXX_FLAGS)\n if(GALOIS_USE_SANITIZER STREQUAL \"MemoryWithOrigins\")\n append(\"-fsanitize-memory-track-origins\" CMAKE_C_FLAGS CMAKE_CXX_FLAGS)\n endif()\nelseif (GALOIS_USE_SANITIZER STREQUAL \"Undefined\")\n append_common_sanitizer_flags()\n append(\"-fsanitize=undefined -fno-sanitize-recover=all\"\n CMAKE_C_FLAGS CMAKE_CXX_FLAGS)\nelseif (GALOIS_USE_SANITIZER STREQUAL \"Thread\")\n append_common_sanitizer_flags()\n append(\"-fsanitize=thread\" CMAKE_C_FLAGS CMAKE_CXX_FLAGS)\nelseif (GALOIS_USE_SANITIZER STREQUAL \"DataFlow\")\n append(\"-fsanitize=dataflow\" CMAKE_C_FLAGS CMAKE_CXX_FLAGS)\nelseif (GALOIS_USE_SANITIZER STREQUAL \"Address;Undefined\" OR\n GALOIS_USE_SANITIZER STREQUAL \"Undefined;Address\")\n append_common_sanitizer_flags()\n append(\"-fsanitize=address,undefined -fno-sanitize-recover=all\"\n CMAKE_C_FLAGS CMAKE_CXX_FLAGS)\nelseif (GALOIS_USE_SANITIZER STREQUAL \"Leaks\")\n append_common_sanitizer_flags()\n append(\"-fsanitize=leak\" CMAKE_C_FLAGS CMAKE_CXX_FLAGS)\nelse()\n message(FATAL_ERROR \"Unsupported value of GALOIS_USE_SANITIZER: ${GALOIS_USE_SANITIZER}\")\nendif()\n\nif (GALOIS_USE_SANITIZER MATCHES \"(Undefined;)?Address(;Undefined)?\")\n add_flag_if_supported(\"-fsanitize-address-use-after-scope\"\n FSANITIZE_USE_AFTER_SCOPE_FLAG)\nendif()\n\nif (GALOIS_USE_SANITIZE_COVERAGE)\n append(\"-fsanitize=fuzzer-no-link\" CMAKE_C_FLAGS CMAKE_CXX_FLAGS)\nendif()\n\nif (GALOIS_USE_SANITIZER MATCHES \".*Undefined.*\")\n set(BLACKLIST_CONFIGURE_FILE \"${PROJECT_SOURCE_DIR}/config/sanitizers/ubsan_blacklist.txt.in\")\n if (EXISTS \"${BLACKLIST_CONFIGURE_FILE}\")\n set(BLACKLIST_FILE \"${PROJECT_BINARY_DIR}/config/sanitizers/ubsan_blacklist.txt\")\n configure_file(\"${BLACKLIST_CONFIGURE_FILE}\" \"${BLACKLIST_FILE}\")\n append(\"-fsanitize-blacklist=${BLACKLIST_FILE}\"\n CMAKE_C_FLAGS CMAKE_CXX_FLAGS)\n endif()\nendif()\n" }, { "path": "cmake/Modules/LibFindMacros.cmake", "content": "# Copyright Raimar Sandner 2012–2014. Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.txt)\n\n#! \\file\n#! \\ingroup Helpers\n#! \\brief Improved versions of %CMake's `find_package`\n\n#! \\ingroup Helpers\n#! \\brief Works the same as `find_package`, but forwards the \"REQUIRED\" and \"QUIET\" arguments\n#! used for the current package.\n#!\n#! For this to work, the first parameter must be the prefix of the current package, then the\n#! prefix of the new package etc, which are passed to `find_package`.\nmacro (libfind_package PREFIX)\n set (LIBFIND_PACKAGE_ARGS ${ARGN})\n if (${PREFIX}_FIND_QUIETLY)\n set (LIBFIND_PACKAGE_ARGS ${LIBFIND_PACKAGE_ARGS} QUIET)\n endif (${PREFIX}_FIND_QUIETLY)\n if (${PREFIX}_FIND_REQUIRED)\n set (LIBFIND_PACKAGE_ARGS ${LIBFIND_PACKAGE_ARGS} REQUIRED)\n endif (${PREFIX}_FIND_REQUIRED)\n find_package(${LIBFIND_PACKAGE_ARGS})\nendmacro (libfind_package)\n\n\n#! \\ingroup Helpers\n#! \\brief Do the final processing once the paths have been detected.\n#!\n#! If include dirs are needed, `${PREFIX}_PROCESS_INCLUDES` should be set to contain\n#! all the variables, each of which contain one include directory.\n#! Ditto for `${PREFIX}_PROCESS_LIBS` and library files.\n#! Will set `${PREFIX}_FOUND`, `${PREFIX}_INCLUDE_DIRS` and `${PREFIX}_LIBRARIES`.\n#! Also handles errors in case library detection was required, etc.\nmacro (libfind_process PREFIX)\n # Skip processing if already processed during this run\n if (NOT ${PREFIX}_FOUND)\n # Start with the assumption that the library was found\n set (${PREFIX}_FOUND TRUE)\n\n # Process all includes and set _FOUND to false if any are missing\n foreach (i ${${PREFIX}_PROCESS_INCLUDES})\n if (${i})\n set (${PREFIX}_INCLUDE_DIRS ${${PREFIX}_INCLUDE_DIRS} ${${i}})\n mark_as_advanced(${i})\n else (${i})\n set (${PREFIX}_FOUND FALSE)\n endif (${i})\n endforeach (i)\n\n # Process all libraries and set _FOUND to false if any are missing\n foreach (i ${${PREFIX}_PROCESS_LIBS})\n if (${i})\n set (${PREFIX}_LIBRARIES ${${PREFIX}_LIBRARIES} ${${i}})\n mark_as_advanced(${i})\n else (${i})\n set (${PREFIX}_FOUND FALSE)\n endif (${i})\n endforeach (i)\n\n # Print message and/or exit on fatal error\n if (${PREFIX}_FOUND)\n if (NOT ${PREFIX}_FIND_QUIETLY)\n message (STATUS \"Found ${PREFIX} ${${PREFIX}_VERSION}\")\n endif (NOT ${PREFIX}_FIND_QUIETLY)\n else (${PREFIX}_FOUND)\n if (${PREFIX}_FIND_REQUIRED)\n foreach (i ${${PREFIX}_PROCESS_INCLUDES} ${${PREFIX}_PROCESS_LIBS})\n message(\"${i}=${${i}}\")\n endforeach (i)\n 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.\")\n endif (${PREFIX}_FIND_REQUIRED)\n endif (${PREFIX}_FOUND)\n endif (NOT ${PREFIX}_FOUND)\nendmacro (libfind_process)\n" }, { "path": "cmake/Modules/UseStdMacro.cmake", "content": "add_definitions(-D__STDC_LIMIT_MACROS)\nadd_definitions(-D__STDC_CONSTANT_MACROS)\n" }, { "path": "config/sanitizers/ubsan_blacklist.txt.in", "content": "[undefined]\nsrc:@PROJECT_SOURCE_DIR@/external/bliss/*\n" }, { "path": "config/version.txt", "content": "6.0.0\n" }, { "path": "external/bliss/bliss/COPYING", "content": " GNU GENERAL PUBLIC LICENSE\n Version 3, 29 June 2007\n\n Copyright (C) 2007 Free Software Foundation, Inc. \n Everyone is permitted to copy and distribute verbatim copies\n of this license document, but changing it is not allowed.\n\n Preamble\n\n The GNU General Public License is a free, copyleft license for\nsoftware and other kinds of works.\n\n The licenses for most software and other practical works are designed\nto take away your freedom to share and change the works. By contrast,\nthe GNU General Public License is intended to guarantee your freedom to\nshare and change all versions of a program--to make sure it remains free\nsoftware for all its users. We, the Free Software Foundation, use the\nGNU General Public License for most of our software; it applies also to\nany other work released this way by its authors. You can apply it to\nyour programs, too.\n\n When we speak of free software, we are referring to freedom, not\nprice. Our General Public Licenses are designed to make sure that you\nhave the freedom to distribute copies of free software (and charge for\nthem if you wish), that you receive source code or can get it if you\nwant it, that you can change the software or use pieces of it in new\nfree programs, and that you know you can do these things.\n\n To protect your rights, we need to prevent others from denying you\nthese rights or asking you to surrender the rights. Therefore, you have\ncertain responsibilities if you distribute copies of the software, or if\nyou modify it: responsibilities to respect the freedom of others.\n\n For example, if you distribute copies of such a program, whether\ngratis or for a fee, you must pass on to the recipients the same\nfreedoms that you received. You must make sure that they, too, receive\nor can get the source code. And you must show them these terms so they\nknow their rights.\n\n Developers that use the GNU GPL protect your rights with two steps:\n(1) assert copyright on the software, and (2) offer you this License\ngiving you legal permission to copy, distribute and/or modify it.\n\n For the developers' and authors' protection, the GPL clearly explains\nthat there is no warranty for this free software. For both users' and\nauthors' sake, the GPL requires that modified versions be marked as\nchanged, so that their problems will not be attributed erroneously to\nauthors of previous versions.\n\n Some devices are designed to deny users access to install or run\nmodified versions of the software inside them, although the manufacturer\ncan do so. This is fundamentally incompatible with the aim of\nprotecting users' freedom to change the software. The systematic\npattern of such abuse occurs in the area of products for individuals to\nuse, which is precisely where it is most unacceptable. Therefore, we\nhave designed this version of the GPL to prohibit the practice for those\nproducts. If such problems arise substantially in other domains, we\nstand ready to extend this provision to those domains in future versions\nof the GPL, as needed to protect the freedom of users.\n\n Finally, every program is threatened constantly by software patents.\nStates should not allow patents to restrict development and use of\nsoftware on general-purpose computers, but in those that do, we wish to\navoid the special danger that patents applied to a free program could\nmake it effectively proprietary. To prevent this, the GPL assures that\npatents cannot be used to render the program non-free.\n\n The precise terms and conditions for copying, distribution and\nmodification follow.\n\n TERMS AND CONDITIONS\n\n 0. Definitions.\n\n \"This License\" refers to version 3 of the GNU General Public License.\n\n \"Copyright\" also means copyright-like laws that apply to other kinds of\nworks, such as semiconductor masks.\n\n \"The Program\" refers to any copyrightable work licensed under this\nLicense. Each licensee is addressed as \"you\". \"Licensees\" and\n\"recipients\" may be individuals or organizations.\n\n To \"modify\" a work means to copy from or adapt all or part of the work\nin a fashion requiring copyright permission, other than the making of an\nexact copy. The resulting work is called a \"modified version\" of the\nearlier work or a work \"based on\" the earlier work.\n\n A \"covered work\" means either the unmodified Program or a work based\non the Program.\n\n To \"propagate\" a work means to do anything with it that, without\npermission, would make you directly or secondarily liable for\ninfringement under applicable copyright law, except executing it on a\ncomputer or modifying a private copy. Propagation includes copying,\ndistribution (with or without modification), making available to the\npublic, and in some countries other activities as well.\n\n To \"convey\" a work means any kind of propagation that enables other\nparties to make or receive copies. Mere interaction with a user through\na computer network, with no transfer of a copy, is not conveying.\n\n An interactive user interface displays \"Appropriate Legal Notices\"\nto the extent that it includes a convenient and prominently visible\nfeature that (1) displays an appropriate copyright notice, and (2)\ntells the user that there is no warranty for the work (except to the\nextent that warranties are provided), that licensees may convey the\nwork under this License, and how to view a copy of this License. If\nthe interface presents a list of user commands or options, such as a\nmenu, a prominent item in the list meets this criterion.\n\n 1. Source Code.\n\n The \"source code\" for a work means the preferred form of the work\nfor making modifications to it. \"Object code\" means any non-source\nform of a work.\n\n A \"Standard Interface\" means an interface that either is an official\nstandard defined by a recognized standards body, or, in the case of\ninterfaces specified for a particular programming language, one that\nis widely used among developers working in that language.\n\n The \"System Libraries\" of an executable work include anything, other\nthan the work as a whole, that (a) is included in the normal form of\npackaging a Major Component, but which is not part of that Major\nComponent, and (b) serves only to enable use of the work with that\nMajor Component, or to implement a Standard Interface for which an\nimplementation is available to the public in source code form. A\n\"Major Component\", in this context, means a major essential component\n(kernel, window system, and so on) of the specific operating system\n(if any) on which the executable work runs, or a compiler used to\nproduce the work, or an object code interpreter used to run it.\n\n The \"Corresponding Source\" for a work in object code form means all\nthe source code needed to generate, install, and (for an executable\nwork) run the object code and to modify the work, including scripts to\ncontrol those activities. However, it does not include the work's\nSystem Libraries, or general-purpose tools or generally available free\nprograms which are used unmodified in performing those activities but\nwhich are not part of the work. For example, Corresponding Source\nincludes interface definition files associated with source files for\nthe work, and the source code for shared libraries and dynamically\nlinked subprograms that the work is specifically designed to require,\nsuch as by intimate data communication or control flow between those\nsubprograms and other parts of the work.\n\n The Corresponding Source need not include anything that users\ncan regenerate automatically from other parts of the Corresponding\nSource.\n\n The Corresponding Source for a work in source code form is that\nsame work.\n\n 2. Basic Permissions.\n\n All rights granted under this License are granted for the term of\ncopyright on the Program, and are irrevocable provided the stated\nconditions are met. This License explicitly affirms your unlimited\npermission to run the unmodified Program. The output from running a\ncovered work is covered by this License only if the output, given its\ncontent, constitutes a covered work. This License acknowledges your\nrights of fair use or other equivalent, as provided by copyright law.\n\n You may make, run and propagate covered works that you do not\nconvey, without conditions so long as your license otherwise remains\nin force. You may convey covered works to others for the sole purpose\nof having them make modifications exclusively for you, or provide you\nwith facilities for running those works, provided that you comply with\nthe terms of this License in conveying all material for which you do\nnot control copyright. Those thus making or running the covered works\nfor you must do so exclusively on your behalf, under your direction\nand control, on terms that prohibit them from making any copies of\nyour copyrighted material outside their relationship with you.\n\n Conveying under any other circumstances is permitted solely under\nthe conditions stated below. Sublicensing is not allowed; section 10\nmakes it unnecessary.\n\n 3. Protecting Users' Legal Rights From Anti-Circumvention Law.\n\n No covered work shall be deemed part of an effective technological\nmeasure under any applicable law fulfilling obligations under article\n11 of the WIPO copyright treaty adopted on 20 December 1996, or\nsimilar laws prohibiting or restricting circumvention of such\nmeasures.\n\n When you convey a covered work, you waive any legal power to forbid\ncircumvention of technological measures to the extent such circumvention\nis effected by exercising rights under this License with respect to\nthe covered work, and you disclaim any intention to limit operation or\nmodification of the work as a means of enforcing, against the work's\nusers, your or third parties' legal rights to forbid circumvention of\ntechnological measures.\n\n 4. Conveying Verbatim Copies.\n\n You may convey verbatim copies of the Program's source code as you\nreceive it, in any medium, provided that you conspicuously and\nappropriately publish on each copy an appropriate copyright notice;\nkeep intact all notices stating that this License and any\nnon-permissive terms added in accord with section 7 apply to the code;\nkeep intact all notices of the absence of any warranty; and give all\nrecipients a copy of this License along with the Program.\n\n You may charge any price or no price for each copy that you convey,\nand you may offer support or warranty protection for a fee.\n\n 5. Conveying Modified Source Versions.\n\n You may convey a work based on the Program, or the modifications to\nproduce it from the Program, in the form of source code under the\nterms of section 4, provided that you also meet all of these conditions:\n\n a) The work must carry prominent notices stating that you modified\n it, and giving a relevant date.\n\n b) The work must carry prominent notices stating that it is\n released under this License and any conditions added under section\n 7. This requirement modifies the requirement in section 4 to\n \"keep intact all notices\".\n\n c) You must license the entire work, as a whole, under this\n License to anyone who comes into possession of a copy. This\n License will therefore apply, along with any applicable section 7\n additional terms, to the whole of the work, and all its parts,\n regardless of how they are packaged. This License gives no\n permission to license the work in any other way, but it does not\n invalidate such permission if you have separately received it.\n\n d) If the work has interactive user interfaces, each must display\n Appropriate Legal Notices; however, if the Program has interactive\n interfaces that do not display Appropriate Legal Notices, your\n work need not make them do so.\n\n A compilation of a covered work with other separate and independent\nworks, which are not by their nature extensions of the covered work,\nand which are not combined with it such as to form a larger program,\nin or on a volume of a storage or distribution medium, is called an\n\"aggregate\" if the compilation and its resulting copyright are not\nused to limit the access or legal rights of the compilation's users\nbeyond what the individual works permit. Inclusion of a covered work\nin an aggregate does not cause this License to apply to the other\nparts of the aggregate.\n\n 6. Conveying Non-Source Forms.\n\n You may convey a covered work in object code form under the terms\nof sections 4 and 5, provided that you also convey the\nmachine-readable Corresponding Source under the terms of this License,\nin one of these ways:\n\n a) Convey the object code in, or embodied in, a physical product\n (including a physical distribution medium), accompanied by the\n Corresponding Source fixed on a durable physical medium\n customarily used for software interchange.\n\n b) Convey the object code in, or embodied in, a physical product\n (including a physical distribution medium), accompanied by a\n written offer, valid for at least three years and valid for as\n long as you offer spare parts or customer support for that product\n model, to give anyone who possesses the object code either (1) a\n copy of the Corresponding Source for all the software in the\n product that is covered by this License, on a durable physical\n medium customarily used for software interchange, for a price no\n more than your reasonable cost of physically performing this\n conveying of source, or (2) access to copy the\n Corresponding Source from a network server at no charge.\n\n c) Convey individual copies of the object code with a copy of the\n written offer to provide the Corresponding Source. This\n alternative is allowed only occasionally and noncommercially, and\n only if you received the object code with such an offer, in accord\n with subsection 6b.\n\n d) Convey the object code by offering access from a designated\n place (gratis or for a charge), and offer equivalent access to the\n Corresponding Source in the same way through the same place at no\n further charge. You need not require recipients to copy the\n Corresponding Source along with the object code. If the place to\n copy the object code is a network server, the Corresponding Source\n may be on a different server (operated by you or a third party)\n that supports equivalent copying facilities, provided you maintain\n clear directions next to the object code saying where to find the\n Corresponding Source. Regardless of what server hosts the\n Corresponding Source, you remain obligated to ensure that it is\n available for as long as needed to satisfy these requirements.\n\n e) Convey the object code using peer-to-peer transmission, provided\n you inform other peers where the object code and Corresponding\n Source of the work are being offered to the general public at no\n charge under subsection 6d.\n\n A separable portion of the object code, whose source code is excluded\nfrom the Corresponding Source as a System Library, need not be\nincluded in conveying the object code work.\n\n A \"User Product\" is either (1) a \"consumer product\", which means any\ntangible personal property which is normally used for personal, family,\nor household purposes, or (2) anything designed or sold for incorporation\ninto a dwelling. In determining whether a product is a consumer product,\ndoubtful cases shall be resolved in favor of coverage. For a particular\nproduct received by a particular user, \"normally used\" refers to a\ntypical or common use of that class of product, regardless of the status\nof the particular user or of the way in which the particular user\nactually uses, or expects or is expected to use, the product. A product\nis a consumer product regardless of whether the product has substantial\ncommercial, industrial or non-consumer uses, unless such uses represent\nthe only significant mode of use of the product.\n\n \"Installation Information\" for a User Product means any methods,\nprocedures, authorization keys, or other information required to install\nand execute modified versions of a covered work in that User Product from\na modified version of its Corresponding Source. The information must\nsuffice to ensure that the continued functioning of the modified object\ncode is in no case prevented or interfered with solely because\nmodification has been made.\n\n If you convey an object code work under this section in, or with, or\nspecifically for use in, a User Product, and the conveying occurs as\npart of a transaction in which the right of possession and use of the\nUser Product is transferred to the recipient in perpetuity or for a\nfixed term (regardless of how the transaction is characterized), the\nCorresponding Source conveyed under this section must be accompanied\nby the Installation Information. But this requirement does not apply\nif neither you nor any third party retains the ability to install\nmodified object code on the User Product (for example, the work has\nbeen installed in ROM).\n\n The requirement to provide Installation Information does not include a\nrequirement to continue to provide support service, warranty, or updates\nfor a work that has been modified or installed by the recipient, or for\nthe User Product in which it has been modified or installed. Access to a\nnetwork may be denied when the modification itself materially and\nadversely affects the operation of the network or violates the rules and\nprotocols for communication across the network.\n\n Corresponding Source conveyed, and Installation Information provided,\nin accord with this section must be in a format that is publicly\ndocumented (and with an implementation available to the public in\nsource code form), and must require no special password or key for\nunpacking, reading or copying.\n\n 7. Additional Terms.\n\n \"Additional permissions\" are terms that supplement the terms of this\nLicense by making exceptions from one or more of its conditions.\nAdditional permissions that are applicable to the entire Program shall\nbe treated as though they were included in this License, to the extent\nthat they are valid under applicable law. If additional permissions\napply only to part of the Program, that part may be used separately\nunder those permissions, but the entire Program remains governed by\nthis License without regard to the additional permissions.\n\n When you convey a copy of a covered work, you may at your option\nremove any additional permissions from that copy, or from any part of\nit. (Additional permissions may be written to require their own\nremoval in certain cases when you modify the work.) You may place\nadditional permissions on material, added by you to a covered work,\nfor which you have or can give appropriate copyright permission.\n\n Notwithstanding any other provision of this License, for material you\nadd to a covered work, you may (if authorized by the copyright holders of\nthat material) supplement the terms of this License with terms:\n\n a) Disclaiming warranty or limiting liability differently from the\n terms of sections 15 and 16 of this License; or\n\n b) Requiring preservation of specified reasonable legal notices or\n author attributions in that material or in the Appropriate Legal\n Notices displayed by works containing it; or\n\n c) Prohibiting misrepresentation of the origin of that material, or\n requiring that modified versions of such material be marked in\n reasonable ways as different from the original version; or\n\n d) Limiting the use for publicity purposes of names of licensors or\n authors of the material; or\n\n e) Declining to grant rights under trademark law for use of some\n trade names, trademarks, or service marks; or\n\n f) Requiring indemnification of licensors and authors of that\n material by anyone who conveys the material (or modified versions of\n it) with contractual assumptions of liability to the recipient, for\n any liability that these contractual assumptions directly impose on\n those licensors and authors.\n\n All other non-permissive additional terms are considered \"further\nrestrictions\" within the meaning of section 10. If the Program as you\nreceived it, or any part of it, contains a notice stating that it is\ngoverned by this License along with a term that is a further\nrestriction, you may remove that term. If a license document contains\na further restriction but permits relicensing or conveying under this\nLicense, you may add to a covered work material governed by the terms\nof that license document, provided that the further restriction does\nnot survive such relicensing or conveying.\n\n If you add terms to a covered work in accord with this section, you\nmust place, in the relevant source files, a statement of the\nadditional terms that apply to those files, or a notice indicating\nwhere to find the applicable terms.\n\n Additional terms, permissive or non-permissive, may be stated in the\nform of a separately written license, or stated as exceptions;\nthe above requirements apply either way.\n\n 8. Termination.\n\n You may not propagate or modify a covered work except as expressly\nprovided under this License. Any attempt otherwise to propagate or\nmodify it is void, and will automatically terminate your rights under\nthis License (including any patent licenses granted under the third\nparagraph of section 11).\n\n However, if you cease all violation of this License, then your\nlicense from a particular copyright holder is reinstated (a)\nprovisionally, unless and until the copyright holder explicitly and\nfinally terminates your license, and (b) permanently, if the copyright\nholder fails to notify you of the violation by some reasonable means\nprior to 60 days after the cessation.\n\n Moreover, your license from a particular copyright holder is\nreinstated permanently if the copyright holder notifies you of the\nviolation by some reasonable means, this is the first time you have\nreceived notice of violation of this License (for any work) from that\ncopyright holder, and you cure the violation prior to 30 days after\nyour receipt of the notice.\n\n Termination of your rights under this section does not terminate the\nlicenses of parties who have received copies or rights from you under\nthis License. If your rights have been terminated and not permanently\nreinstated, you do not qualify to receive new licenses for the same\nmaterial under section 10.\n\n 9. Acceptance Not Required for Having Copies.\n\n You are not required to accept this License in order to receive or\nrun a copy of the Program. Ancillary propagation of a covered work\noccurring solely as a consequence of using peer-to-peer transmission\nto receive a copy likewise does not require acceptance. However,\nnothing other than this License grants you permission to propagate or\nmodify any covered work. These actions infringe copyright if you do\nnot accept this License. Therefore, by modifying or propagating a\ncovered work, you indicate your acceptance of this License to do so.\n\n 10. Automatic Licensing of Downstream Recipients.\n\n Each time you convey a covered work, the recipient automatically\nreceives a license from the original licensors, to run, modify and\npropagate that work, subject to this License. You are not responsible\nfor enforcing compliance by third parties with this License.\n\n An \"entity transaction\" is a transaction transferring control of an\norganization, or substantially all assets of one, or subdividing an\norganization, or merging organizations. If propagation of a covered\nwork results from an entity transaction, each party to that\ntransaction who receives a copy of the work also receives whatever\nlicenses to the work the party's predecessor in interest had or could\ngive under the previous paragraph, plus a right to possession of the\nCorresponding Source of the work from the predecessor in interest, if\nthe predecessor has it or can get it with reasonable efforts.\n\n You may not impose any further restrictions on the exercise of the\nrights granted or affirmed under this License. For example, you may\nnot impose a license fee, royalty, or other charge for exercise of\nrights granted under this License, and you may not initiate litigation\n(including a cross-claim or counterclaim in a lawsuit) alleging that\nany patent claim is infringed by making, using, selling, offering for\nsale, or importing the Program or any portion of it.\n\n 11. Patents.\n\n A \"contributor\" is a copyright holder who authorizes use under this\nLicense of the Program or a work on which the Program is based. The\nwork thus licensed is called the contributor's \"contributor version\".\n\n A contributor's \"essential patent claims\" are all patent claims\nowned or controlled by the contributor, whether already acquired or\nhereafter acquired, that would be infringed by some manner, permitted\nby this License, of making, using, or selling its contributor version,\nbut do not include claims that would be infringed only as a\nconsequence of further modification of the contributor version. For\npurposes of this definition, \"control\" includes the right to grant\npatent sublicenses in a manner consistent with the requirements of\nthis License.\n\n Each contributor grants you a non-exclusive, worldwide, royalty-free\npatent license under the contributor's essential patent claims, to\nmake, use, sell, offer for sale, import and otherwise run, modify and\npropagate the contents of its contributor version.\n\n In the following three paragraphs, a \"patent license\" is any express\nagreement or commitment, however denominated, not to enforce a patent\n(such as an express permission to practice a patent or covenant not to\nsue for patent infringement). To \"grant\" such a patent license to a\nparty means to make such an agreement or commitment not to enforce a\npatent against the party.\n\n If you convey a covered work, knowingly relying on a patent license,\nand the Corresponding Source of the work is not available for anyone\nto copy, free of charge and under the terms of this License, through a\npublicly available network server or other readily accessible means,\nthen you must either (1) cause the Corresponding Source to be so\navailable, or (2) arrange to deprive yourself of the benefit of the\npatent license for this particular work, or (3) arrange, in a manner\nconsistent with the requirements of this License, to extend the patent\nlicense to downstream recipients. \"Knowingly relying\" means you have\nactual knowledge that, but for the patent license, your conveying the\ncovered work in a country, or your recipient's use of the covered work\nin a country, would infringe one or more identifiable patents in that\ncountry that you have reason to believe are valid.\n\n If, pursuant to or in connection with a single transaction or\narrangement, you convey, or propagate by procuring conveyance of, a\ncovered work, and grant a patent license to some of the parties\nreceiving the covered work authorizing them to use, propagate, modify\nor convey a specific copy of the covered work, then the patent license\nyou grant is automatically extended to all recipients of the covered\nwork and works based on it.\n\n A patent license is \"discriminatory\" if it does not include within\nthe scope of its coverage, prohibits the exercise of, or is\nconditioned on the non-exercise of one or more of the rights that are\nspecifically granted under this License. You may not convey a covered\nwork if you are a party to an arrangement with a third party that is\nin the business of distributing software, under which you make payment\nto the third party based on the extent of your activity of conveying\nthe work, and under which the third party grants, to any of the\nparties who would receive the covered work from you, a discriminatory\npatent license (a) in connection with copies of the covered work\nconveyed by you (or copies made from those copies), or (b) primarily\nfor and in connection with specific products or compilations that\ncontain the covered work, unless you entered into that arrangement,\nor that patent license was granted, prior to 28 March 2007.\n\n Nothing in this License shall be construed as excluding or limiting\nany implied license or other defenses to infringement that may\notherwise be available to you under applicable patent law.\n\n 12. No Surrender of Others' Freedom.\n\n If conditions are imposed on you (whether by court order, agreement or\notherwise) that contradict the conditions of this License, they do not\nexcuse you from the conditions of this License. If you cannot convey a\ncovered work so as to satisfy simultaneously your obligations under this\nLicense and any other pertinent obligations, then as a consequence you may\nnot convey it at all. For example, if you agree to terms that obligate you\nto collect a royalty for further conveying from those to whom you convey\nthe Program, the only way you could satisfy both those terms and this\nLicense would be to refrain entirely from conveying the Program.\n\n 13. Use with the GNU Affero General Public License.\n\n Notwithstanding any other provision of this License, you have\npermission to link or combine any covered work with a work licensed\nunder version 3 of the GNU Affero General Public License into a single\ncombined work, and to convey the resulting work. The terms of this\nLicense will continue to apply to the part which is the covered work,\nbut the special requirements of the GNU Affero General Public License,\nsection 13, concerning interaction through a network will apply to the\ncombination as such.\n\n 14. Revised Versions of this License.\n\n The Free Software Foundation may publish revised and/or new versions of\nthe GNU General Public License from time to time. Such new versions will\nbe similar in spirit to the present version, but may differ in detail to\naddress new problems or concerns.\n\n Each version is given a distinguishing version number. If the\nProgram specifies that a certain numbered version of the GNU General\nPublic License \"or any later version\" applies to it, you have the\noption of following the terms and conditions either of that numbered\nversion or of any later version published by the Free Software\nFoundation. If the Program does not specify a version number of the\nGNU General Public License, you may choose any version ever published\nby the Free Software Foundation.\n\n If the Program specifies that a proxy can decide which future\nversions of the GNU General Public License can be used, that proxy's\npublic statement of acceptance of a version permanently authorizes you\nto choose that version for the Program.\n\n Later license versions may give you additional or different\npermissions. However, no additional obligations are imposed on any\nauthor or copyright holder as a result of your choosing to follow a\nlater version.\n\n 15. Disclaimer of Warranty.\n\n THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY\nAPPLICABLE LAW. EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT\nHOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM \"AS IS\" WITHOUT WARRANTY\nOF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO,\nTHE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR\nPURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM\nIS WITH YOU. SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF\nALL NECESSARY SERVICING, REPAIR OR CORRECTION.\n\n 16. Limitation of Liability.\n\n IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING\nWILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS\nTHE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY\nGENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE\nUSE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF\nDATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD\nPARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS),\nEVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF\nSUCH DAMAGES.\n\n 17. Interpretation of Sections 15 and 16.\n\n If the disclaimer of warranty and limitation of liability provided\nabove cannot be given local legal effect according to their terms,\nreviewing courts shall apply local law that most closely approximates\nan absolute waiver of all civil liability in connection with the\nProgram, unless a warranty or assumption of liability accompanies a\ncopy of the Program in return for a fee.\n\n END OF TERMS AND CONDITIONS\n\n How to Apply These Terms to Your New Programs\n\n If you develop a new program, and you want it to be of the greatest\npossible use to the public, the best way to achieve this is to make it\nfree software which everyone can redistribute and change under these terms.\n\n To do so, attach the following notices to the program. It is safest\nto attach them to the start of each source file to most effectively\nstate the exclusion of warranty; and each file should have at least\nthe \"copyright\" line and a pointer to where the full notice is found.\n\n \n Copyright (C) \n\n This program is free software: you can redistribute it and/or modify\n it under the terms of the GNU General Public License as published by\n the Free Software Foundation, either version 3 of the License, or\n (at your option) any later version.\n\n This program is distributed in the hope that it will be useful,\n but WITHOUT ANY WARRANTY; without even the implied warranty of\n MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n GNU General Public License for more details.\n\n You should have received a copy of the GNU General Public License\n along with this program. If not, see .\n\nAlso add information on how to contact you by electronic and paper mail.\n\n If the program does terminal interaction, make it output a short\nnotice like this when it starts in an interactive mode:\n\n Copyright (C) \n This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'.\n This is free software, and you are welcome to redistribute it\n under certain conditions; type `show c' for details.\n\nThe hypothetical commands `show w' and `show c' should show the appropriate\nparts of the General Public License. Of course, your program's commands\nmight be different; for a GUI interface, you would use an \"about box\".\n\n You should also get your employer (if you work as a programmer) or school,\nif any, to sign a \"copyright disclaimer\" for the program, if necessary.\nFor more information on this, and how to apply and follow the GNU GPL, see\n.\n\n The GNU General Public License does not permit incorporating your program\ninto proprietary programs. If your program is a subroutine library, you\nmay consider it more useful to permit linking proprietary applications with\nthe library. If this is what you want to do, use the GNU Lesser General\nPublic License instead of this License. But first, please read\n.\n" }, { "path": "external/bliss/bliss/COPYING.LESSER", "content": " GNU LESSER GENERAL PUBLIC LICENSE\n Version 3, 29 June 2007\n\n Copyright (C) 2007 Free Software Foundation, Inc. \n Everyone is permitted to copy and distribute verbatim copies\n of this license document, but changing it is not allowed.\n\n\n This version of the GNU Lesser General Public License incorporates\nthe terms and conditions of version 3 of the GNU General Public\nLicense, supplemented by the additional permissions listed below.\n\n 0. Additional Definitions.\n\n As used herein, \"this License\" refers to version 3 of the GNU Lesser\nGeneral Public License, and the \"GNU GPL\" refers to version 3 of the GNU\nGeneral Public License.\n\n \"The Library\" refers to a covered work governed by this License,\nother than an Application or a Combined Work as defined below.\n\n An \"Application\" is any work that makes use of an interface provided\nby the Library, but which is not otherwise based on the Library.\nDefining a subclass of a class defined by the Library is deemed a mode\nof using an interface provided by the Library.\n\n A \"Combined Work\" is a work produced by combining or linking an\nApplication with the Library. The particular version of the Library\nwith which the Combined Work was made is also called the \"Linked\nVersion\".\n\n The \"Minimal Corresponding Source\" for a Combined Work means the\nCorresponding Source for the Combined Work, excluding any source code\nfor portions of the Combined Work that, considered in isolation, are\nbased on the Application, and not on the Linked Version.\n\n The \"Corresponding Application Code\" for a Combined Work means the\nobject code and/or source code for the Application, including any data\nand utility programs needed for reproducing the Combined Work from the\nApplication, but excluding the System Libraries of the Combined Work.\n\n 1. Exception to Section 3 of the GNU GPL.\n\n You may convey a covered work under sections 3 and 4 of this License\nwithout being bound by section 3 of the GNU GPL.\n\n 2. Conveying Modified Versions.\n\n If you modify a copy of the Library, and, in your modifications, a\nfacility refers to a function or data to be supplied by an Application\nthat uses the facility (other than as an argument passed when the\nfacility is invoked), then you may convey a copy of the modified\nversion:\n\n a) under this License, provided that you make a good faith effort to\n ensure that, in the event an Application does not supply the\n function or data, the facility still operates, and performs\n whatever part of its purpose remains meaningful, or\n\n b) under the GNU GPL, with none of the additional permissions of\n this License applicable to that copy.\n\n 3. Object Code Incorporating Material from Library Header Files.\n\n The object code form of an Application may incorporate material from\na header file that is part of the Library. You may convey such object\ncode under terms of your choice, provided that, if the incorporated\nmaterial is not limited to numerical parameters, data structure\nlayouts and accessors, or small macros, inline functions and templates\n(ten or fewer lines in length), you do both of the following:\n\n a) Give prominent notice with each copy of the object code that the\n Library is used in it and that the Library and its use are\n covered by this License.\n\n b) Accompany the object code with a copy of the GNU GPL and this license\n document.\n\n 4. Combined Works.\n\n You may convey a Combined Work under terms of your choice that,\ntaken together, effectively do not restrict modification of the\nportions of the Library contained in the Combined Work and reverse\nengineering for debugging such modifications, if you also do each of\nthe following:\n\n a) Give prominent notice with each copy of the Combined Work that\n the Library is used in it and that the Library and its use are\n covered by this License.\n\n b) Accompany the Combined Work with a copy of the GNU GPL and this license\n document.\n\n c) For a Combined Work that displays copyright notices during\n execution, include the copyright notice for the Library among\n these notices, as well as a reference directing the user to the\n copies of the GNU GPL and this license document.\n\n d) Do one of the following:\n\n 0) Convey the Minimal Corresponding Source under the terms of this\n License, and the Corresponding Application Code in a form\n suitable for, and under terms that permit, the user to\n recombine or relink the Application with a modified version of\n the Linked Version to produce a modified Combined Work, in the\n manner specified by section 6 of the GNU GPL for conveying\n Corresponding Source.\n\n 1) Use a suitable shared library mechanism for linking with the\n Library. A suitable mechanism is one that (a) uses at run time\n a copy of the Library already present on the user's computer\n system, and (b) will operate properly with a modified version\n of the Library that is interface-compatible with the Linked\n Version.\n\n e) Provide Installation Information, but only if you would otherwise\n be required to provide such information under section 6 of the\n GNU GPL, and only to the extent that such information is\n necessary to install and execute a modified version of the\n Combined Work produced by recombining or relinking the\n Application with a modified version of the Linked Version. (If\n you use option 4d0, the Installation Information must accompany\n the Minimal Corresponding Source and Corresponding Application\n Code. If you use option 4d1, you must provide the Installation\n Information in the manner specified by section 6 of the GNU GPL\n for conveying Corresponding Source.)\n\n 5. Combined Libraries.\n\n You may place library facilities that are a work based on the\nLibrary side by side in a single library together with other library\nfacilities that are not Applications and are not covered by this\nLicense, and convey such a combined library under terms of your\nchoice, if you do both of the following:\n\n a) Accompany the combined library with a copy of the same work based\n on the Library, uncombined with any other library facilities,\n conveyed under the terms of this License.\n\n b) Give prominent notice with the combined library that part of it\n is a work based on the Library, and explaining where to find the\n accompanying uncombined form of the same work.\n\n 6. Revised Versions of the GNU Lesser General Public License.\n\n The Free Software Foundation may publish revised and/or new versions\nof the GNU Lesser General Public License from time to time. Such new\nversions will be similar in spirit to the present version, but may\ndiffer in detail to address new problems or concerns.\n\n Each version is given a distinguishing version number. If the\nLibrary as you received it specifies that a certain numbered version\nof the GNU Lesser General Public License \"or any later version\"\napplies to it, you have the option of following the terms and\nconditions either of that published version or of any later version\npublished by the Free Software Foundation. If the Library as you\nreceived it does not specify a version number of the GNU Lesser\nGeneral Public License, you may choose any version of the GNU Lesser\nGeneral Public License ever published by the Free Software Foundation.\n\n If the Library as you received it specifies that a proxy can decide\nwhether future versions of the GNU Lesser General Public License shall\napply, that proxy's public statement of acceptance of any version is\npermanent authorization for you to choose that version for the\nLibrary.\n" }, { "path": "external/bliss/bliss/abgraph.hh", "content": "#ifndef BLISS_AB_GRAPH_HH\n#define BLISS_AB_GRAPH_HH\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nnamespace bliss {\n\tclass AbstractGraph;\n}\n\n#include \"kstack.hh\"\n#include \"kqueue.hh\"\n#include \"heap.hh\"\n#include \"orbit.hh\"\n#include \"partition.hh\"\n#include \"bignum.hh\"\n#include \"uintseqhash.hh\"\n\nnamespace bliss {\n\nvoid fatal_error(const char* fmt, ...) {\n\tva_list ap;\n\tva_start(ap, fmt);\n\tfprintf(stderr,\"Bliss fatal error: \");\n\tvfprintf(stderr, fmt, ap);\n\tfprintf(stderr, \"\\nAborting!\\n\");\n\tva_end(ap);\n\texit(1);\n}\n\n#define _INTERNAL_ERROR() fatal_error(\"%s:%d: internal error\",__FILE__,__LINE__)\n#define _OUT_OF_MEMORY() fatal_error(\"%s:%d: out of memory\",__FILE__,__LINE__)\n\ntypedef std::pair Index;\n\nclass TreeNode {\n//friend class AbstractGraph;\npublic:\n\tunsigned int split_cell_first;\n\n\tint split_element;\n\tstatic const int SPLIT_START = -1;\n\tstatic const int SPLIT_END = -2;\n\tPartition::BacktrackPoint partition_bt_point;\n\tunsigned int certificate_index;\n\tstatic const char NO = -1;\n\tstatic const char MAYBE = 0;\n\tstatic const char YES = 1;\n\t/* First path stuff */\n\tbool fp_on;\n\tbool fp_cert_equal;\n\tchar fp_extendable;\n\t/* Best path stuff */\n\tbool in_best_path;\n\tint cmp_to_best_path;\n\tunsigned int failure_recording_ival;\n\t/* Component recursion related data */\n\tunsigned int cr_cep_stack_size;\n\tunsigned int cr_cep_index;\n\tunsigned int cr_level;\n\tbool needs_long_prune;\n\tunsigned int long_prune_begin;\n\tstd::set > long_prune_redundant;\n\tUintSeqHash eqref_hash;\n\tunsigned int subcertificate_length;\n};\n\ntypedef struct {\n\tunsigned int splitting_element;\n\tunsigned int certificate_index;\n\tunsigned int subcertificate_length;\n\tUintSeqHash eqref_hash;\n} PathInfo;\n\n// \\brief Statistics returned by the bliss search algorithm.\nclass Stats {\n\tfriend class AbstractGraph;\n\t/** \\internal The size of the automorphism group. */\n\tBigNum group_size;\n\t/** \\internal An approximation (due to possible overflows) of\n\t * the size of the automorphism group. */\n\tlong double group_size_approx;\n\t/** \\internal The number of nodes in the search tree. */\n\tlong unsigned int nof_nodes;\n\t/** \\internal The number of leaf nodes in the search tree. */\n\tlong unsigned int nof_leaf_nodes;\n\t/** \\internal The number of bad nodes in the search tree. */\n\tlong unsigned int nof_bad_nodes;\n\t/** \\internal The number of canonical representative updates. */\n\tlong unsigned int nof_canupdates;\n\t/** \\internal The number of generator permutations. */\n\tlong unsigned int nof_generators;\n\t/** \\internal The maximal depth of the search tree. */\n\tunsigned long int max_level;\n\t/** */\n\tvoid reset() {\n\t\tgroup_size.assign(1);\n\t\tgroup_size_approx = 1.0;\n\t\tnof_nodes = 0;\n\t\tnof_leaf_nodes = 0;\n\t\tnof_bad_nodes = 0;\n\t\tnof_canupdates = 0;\n\t\tnof_generators = 0;\n\t\tmax_level = 0;\n\t}\n\tpublic:\n\tStats() { reset(); }\n\t/** Print the statistics. */\n\tsize_t print(FILE* const fp) const {\n\t\tsize_t r = 0;\n\t\tr += fprintf(fp, \"Nodes: %lu\\n\", nof_nodes);\n\t\tr += fprintf(fp, \"Leaf nodes: %lu\\n\", nof_leaf_nodes);\n\t\tr += fprintf(fp, \"Bad nodes: %lu\\n\", nof_bad_nodes);\n\t\tr += fprintf(fp, \"Canrep updates: %lu\\n\", nof_canupdates);\n\t\tr += fprintf(fp, \"Generators: %lu\\n\", nof_generators);\n\t\tr += fprintf(fp, \"Max level: %lu\\n\", max_level);\n\t\tr += fprintf(fp, \"|Aut|: \")+group_size.print(fp)+fprintf(fp, \"\\n\");\n\t\tfflush(fp);\n\t\treturn r;\n\t}\n\t/** An approximation (due to possible overflows/rounding errors) of\n\t * the size of the automorphism group. */\n\tlong double get_group_size_approx() const {return group_size_approx;}\n\t/** The number of nodes in the search tree. */\n\tlong unsigned int get_nof_nodes() const {return nof_nodes;}\n\t/** The number of leaf nodes in the search tree. */\n\tlong unsigned int get_nof_leaf_nodes() const {return nof_leaf_nodes;}\n\t/** The number of bad nodes in the search tree. */\n\tlong unsigned int get_nof_bad_nodes() const {return nof_bad_nodes;}\n\t/** The number of canonical representative updates. */\n\tlong unsigned int get_nof_canupdates() const {return nof_canupdates;}\n\t/** The number of generator permutations. */\n\tlong unsigned int get_nof_generators() const {return nof_generators;}\n\t/** The maximal depth of the search tree. */\n\tunsigned long int get_max_level() const {return max_level;}\n};\n\n// \\brief An abstract base class for different types of graphs.\nclass AbstractGraph {\n\tfriend class Partition;\npublic:\n\t//AbstractGraph();\n\t// Constructor and destructor routines for the abstract graph class\n\tAbstractGraph() {\n\t// Initialize stuff\n\tfirst_path_labeling = 0;\n\tfirst_path_labeling_inv = 0;\n\tbest_path_labeling = 0;\n\tbest_path_labeling_inv = 0;\n\tfirst_path_automorphism = 0;\n\tbest_path_automorphism = 0;\n\tin_search = false;\n\t// Default value for using \"long prune\"\n\topt_use_long_prune = true;\n\t// Default value for using failure recording\n\topt_use_failure_recording = true;\n\t// Default value for using component recursion\n\topt_use_comprec = true;\n\tverbose_level = 0;\n\tverbstr = stdout;\n\treport_hook = 0;\n\treport_user_param = 0;\n\t}\n\t//virtual ~AbstractGraph();\n\tvirtual ~AbstractGraph() {\n\tif(first_path_labeling) {\n\t\tfree(first_path_labeling); first_path_labeling = 0; }\n\tif(first_path_labeling_inv) {\n\t\tfree(first_path_labeling_inv); first_path_labeling_inv = 0; }\n\tif(best_path_labeling) {\n\t\tfree(best_path_labeling); best_path_labeling = 0; }\n\tif(best_path_labeling_inv) {\n\t\tfree(best_path_labeling_inv); best_path_labeling_inv = 0; }\n\tif(first_path_automorphism) {\n\t\tfree(first_path_automorphism); first_path_automorphism = 0; }\n\tif(best_path_automorphism) {\n\t\tfree(best_path_automorphism); best_path_automorphism = 0; }\n\treport_hook = 0;\n\treport_user_param = 0;\n\t}\n\n\t//Set the verbose output level for the algorithms.\n\t// \\param level the level of verbose output, 0 means no verbose output\n\t//void set_verbose_level(const unsigned int level);\nvoid set_verbose_level(const unsigned int level) {\n\tverbose_level = level;\n}\n\n\t/**\n\t * Set the file stream for the verbose output.\n\t * \\param fp the file stream; if null, no verbose output is written\n\t */\n\t//void set_verbose_file(FILE * const fp);\nvoid set_verbose_file(FILE* const fp) {\n\tverbstr = fp;\n}\n\t/**\n\t * Add a new vertex with color \\a color in the graph and return its index.\n\t */\n\tvirtual unsigned int add_vertex(const unsigned int color = 0) = 0;\n\n\t/**\n\t * Add an edge between vertices \\a source and \\a target.\n\t * Duplicate edges between vertices are ignored but try to avoid introducing\n\t * them in the first place as they are not ignored immediately but will\n\t * consume memory and computation resources for a while.\n\t */\n\tvirtual void add_edge(const unsigned int source, const unsigned int target, Index index) = 0;\n\n\t/**\n\t * Change the color of the vertex \\a vertex to \\a color.\n\t */\n\tvirtual void change_color(const unsigned int vertex, const unsigned int color) = 0;\n\n\t/**\n\t * Check whether \\a perm is an automorphism of this graph.\n\t * Unoptimized, mainly for debugging purposes.\n\t */\n\t//virtual bool is_automorphism(const std::vector& perm) const;\n\nvirtual bool is_automorphism(const std::vector& perm) const {\n\t_INTERNAL_ERROR();\n\treturn false;\n}\n\n\t/** Activate/deactivate failure recording.\n\t * May not be called during the search, i.e. from an automorphism reporting\n\t * hook function.\n\t * \\param active if true, activate failure recording, deactivate otherwise\n\t */\n\tvoid set_failure_recording(const bool active) {assert(!in_search); opt_use_failure_recording = active;}\n\n\t/** Activate/deactivate component recursion.\n\t * The choice affects the computed canonical labelings;\n\t * therefore, if you want to compare whether two graphs are isomorphic by\n\t * computing and comparing (for equality) their canonical versions,\n\t * be sure to use the same choice for both graphs.\n\t * May not be called during the search, i.e. from an automorphism reporting\n\t * hook function.\n\t * \\param active if true, activate component recursion, deactivate otherwise\n\t */\n\tvoid set_component_recursion(const bool active) {assert(!in_search); opt_use_comprec = active;}\n\n\t/**\n\t * Return the number of vertices in the graph.\n\t */\n\tvirtual unsigned int get_nof_vertices() const = 0;\n\n\t/**\n\t * Return a new graph that is the result of applying the permutation \\a perm\n\t * to this graph. This graph is not modified.\n\t * \\a perm must contain N=this.get_nof_vertices() elements and be a bijection\n\t * on {0,1,...,N-1}, otherwise the result is undefined or a segfault.\n\t */\n\tvirtual AbstractGraph* permute(const unsigned* const perm) const = 0;\n\tvirtual AbstractGraph* permute(const std::vector& perm) const = 0;\n\n\t/**\n\t * Find a set of generators for the automorphism group of the graph.\n\t * The function \\a hook (if non-null) is called each time a new generator\n\t * for the automorphism group is found.\n\t * The first argument \\a user_param for the hook is the\n\t * \\a hook_user_param given below,\n\t * the second argument \\a n is the length of the automorphism (equal to\n\t * get_nof_vertices()) and\n\t * the third argument \\a aut is the automorphism\n\t * (a bijection on {0,...,get_nof_vertices()-1}).\n\t * The memory for the automorphism \\a aut will be invalidated immediately\n\t * after the return from the hook function;\n\t * if you want to use the automorphism later, you have to take a copy of it.\n\t * Do not call any member functions in the hook.\n\t * The search statistics are copied in \\a stats.\n\t */\n\t//void find_automorphisms(Stats& stats, void (*hook)(void* user_param, unsigned int n, const unsigned int* aut), void* hook_user_param);\nvoid find_automorphisms(Stats& stats, void (*hook)(void *user_param, unsigned int n, const unsigned int *aut), void *user_param) {\n\treport_hook = hook;\n\treport_user_param = user_param;\n\tsearch(false, stats);\n\tif(first_path_labeling) {\n\t\tfree(first_path_labeling);\n\t\tfirst_path_labeling = 0;\n\t}\n\tif(best_path_labeling) {\n\t\tfree(best_path_labeling);\n\t\tbest_path_labeling = 0;\n\t}\n}\n\t/**\n\t * Otherwise the same as find_automorphisms() except that\n\t * a canonical labeling of the graph (a bijection on\n\t * {0,...,get_nof_vertices()-1}) is returned.\n\t * The memory allocated for the returned canonical labeling will remain\n\t * valid only until the next call to a member function with the exception\n\t * that constant member functions (for example, bliss::Graph::permute()) can\n\t * be called without invalidating the labeling.\n\t * To compute the canonical version of an undirected graph, call this\n\t * function and then bliss::Graph::permute() with the returned canonical\n\t * labeling.\n\t * Note that the computed canonical version may depend on the applied version\n\t * of bliss as well as on some other options (for instance, the splitting\n\t * heuristic selected with bliss::Graph::set_splitting_heuristic()).\n\t */\n\t//const unsigned int* canonical_form(Stats& stats, void (*hook)(void* user_param, unsigned int n, const unsigned int* aut), void* hook_user_param);\nconst unsigned * canonical_form(Stats& stats, void (*hook)(void *user_param, unsigned int n, const unsigned int *aut), void *user_param) {\n\treport_hook = hook;\n\treport_user_param = user_param;\n\tsearch(true, stats);\n\treturn best_path_labeling;\n}\n\t/**\n\t * Write the graph to a file in a variant of the DIMACS format.\n\t * See the bliss website\n\t * for the definition of the file format.\n\t * Note that in the DIMACS file the vertices are numbered from 1 to N while\n\t * in this C++ API they are from 0 to N-1.\n\t * Thus the vertex n in the file corresponds to the vertex n-1 in the API.\n\t * \\param fp the file stream where the graph is written\n\t */\n\tvirtual void write_dimacs(FILE * const fp) = 0;\n\n\t/**\n\t * Write the graph to a file in the graphviz dotty format.\n\t * \\param fp the file stream where the graph is written\n\t */\n\tvirtual void write_dot(FILE * const fp) = 0;\n\n\t/**\n\t * Write the graph in a file in the graphviz dotty format.\n\t * Do nothing if the file cannot be written.\n\t * \\param file_name the name of the file to which the graph is written\n\t */\n\tvirtual void write_dot(const char * const file_name) = 0;\n\n\t/**\n\t * Get a hash value for the graph.\n\t * \\return the hash value\n\t */ \n\tvirtual unsigned int get_hash() = 0;\n\n\t/**\n\t * Disable/enable the \"long prune\" method.\n\t * The choice affects the computed canonical labelings;\n\t * therefore, if you want to compare whether two graphs are isomorphic by\n\t * computing and comparing (for equality) their canonical versions,\n\t * be sure to use the same choice for both graphs.\n\t * May not be called during the search, i.e. from an automorphism reporting\n\t * hook function.\n\t * \\param active if true, activate \"long prune\", deactivate otherwise\n\t */\n\tvoid set_long_prune_activity(const bool active) {\n\t\tassert(!in_search);\n\t\topt_use_long_prune = active;\n\t}\n\nprotected:\n\t/** \\internal\n\t * How much verbose output is produced (0 means none) */\n\tunsigned int verbose_level;\n\t/** \\internal\n\t * The output stream for verbose output. */\n\tFILE *verbstr;\n\nprotected:\n\t/** \\internal\n\t * The ordered partition used in the search algorithm. */\n\tPartition p;\n\n\t/** \\internal\n\t * Whether the search for automorphisms and a canonical labeling is\n\t * in progress.\n\t */\n\tbool in_search;\n\n\t/** \\internal\n\t * Is failure recording in use?\n\t */\n\tbool opt_use_failure_recording;\n\t/* The \"tree-specific\" invariant value for the point when current path\n\t * got different from the first path */\n\tunsigned int failure_recording_fp_deviation;\n\n\t/** \\internal\n\t * Is component recursion in use?\n\t */\n\tbool opt_use_comprec;\n\n\tunsigned int refine_current_path_certificate_index;\n\tbool refine_compare_certificate;\n\tbool refine_equal_to_first;\n\tunsigned int refine_first_path_subcertificate_end;\n\tint refine_cmp_to_best;\n\tunsigned int refine_best_path_subcertificate_end;\n\tstatic const unsigned int CERT_SPLIT = 0; //UINT_MAX;\n\tstatic const unsigned int CERT_EDGE = 1; //UINT_MAX-1;\n\t/** \\internal\n\t * Add a triple (v1,v2,v3) in the certificate.\n\t * May modify refine_equal_to_first and refine_cmp_to_best.\n\t * May also update eqref_hash and failure_recording_fp_deviation. */\n\t//void cert_add(const unsigned int v1, const unsigned int v2, const unsigned int v3);\n// Certificate building\nvoid cert_add(const unsigned int v1, const unsigned int v2, const unsigned int v3) {\n\tif(refine_compare_certificate) {\n\t\tif(refine_equal_to_first) {\n\t\t\t/* So far equivalent to the first path... */\n\t\t\tunsigned int index = certificate_current_path.size();\n\t\t\tif(index >= refine_first_path_subcertificate_end) {\n\t\t\t\trefine_equal_to_first = false;\n\t\t\t} else if(certificate_first_path[index] != v1) {\n\t\t\t\trefine_equal_to_first = false;\n\t\t\t} else if(certificate_first_path[++index] != v2) {\n\t\t\t\trefine_equal_to_first = false;\n\t\t\t} else if(certificate_first_path[++index] != v3) {\n\t\t\t\trefine_equal_to_first = false;\n\t\t\t} if(opt_use_failure_recording and !refine_equal_to_first) {\n\t\t\t\t/* We just became different from the first path,\n\t\t\t\t * remember the deviation point tree-specific invariant\n\t\t\t\t * for the use of failure recording */\n\t\t\t\tUintSeqHash h;\n\t\t\t\th.update(v1);\n\t\t\t\th.update(v2);\n\t\t\t\th.update(v3);\n\t\t\t\th.update(index);\n\t\t\t\th.update(eqref_hash.get_value());\n\t\t\t\tfailure_recording_fp_deviation = h.get_value();\n\t\t\t}\n\t\t}\n\t\tif(refine_cmp_to_best == 0) {\n\t\t\t/* So far equivalent to the current best path... */\n\t\t\tunsigned int index = certificate_current_path.size();\n\t\t\tif(index >= refine_best_path_subcertificate_end) {\n\t\t\t\trefine_cmp_to_best = 1;\n\t\t\t} else if(v1 > certificate_best_path[index]) {\n\t\t\t\trefine_cmp_to_best = 1;\n\t\t\t} else if(v1 < certificate_best_path[index]) {\n\t\t\t\trefine_cmp_to_best = -1;\n\t\t\t} else if(v2 > certificate_best_path[++index]) {\n\t\t\t\trefine_cmp_to_best = 1;\n\t\t\t} else if(v2 < certificate_best_path[index]) {\n\t\t\t\trefine_cmp_to_best = -1;\n\t\t\t} else if(v3 > certificate_best_path[++index]) {\n\t\t\t\trefine_cmp_to_best = 1;\n\t\t\t} else if(v3 < certificate_best_path[index]) {\n\t\t\t\trefine_cmp_to_best = -1;\n\t\t\t}\n\t\t}\n\t\tif((refine_equal_to_first == false) and (refine_cmp_to_best < 0))\n\t\t\treturn;\n\t}\n\t/* Update the current path certificate */\n\tcertificate_current_path.push_back(v1);\n\tcertificate_current_path.push_back(v2);\n\tcertificate_current_path.push_back(v3);\n}\n\t/** \\internal\n\t * Add a redundant triple (v1,v2,v3) in the certificate.\n\t * Can also just dicard the triple.\n\t * May modify refine_equal_to_first and refine_cmp_to_best.\n\t * May also update eqref_hash and failure_recording_fp_deviation. */\n\t//void cert_add_redundant(const unsigned int x, const unsigned int y, const unsigned int z);\nvoid cert_add_redundant(const unsigned int v1, const unsigned int v2, const unsigned int v3) {\n\treturn cert_add(v1, v2, v3);\n}\n\t/**\\internal\n\t * Is the long prune method in use?\n\t */\n\tbool opt_use_long_prune;\n\t/**\\internal\n\t * Maximum amount of memory (in megabytes) available for\n\t * the long prune method\n\t */\n\tstatic const unsigned int long_prune_options_max_mem = 50;\n\t/**\\internal\n\t * Maximum amount of automorphisms stored for the long prune method;\n\t * less than this is stored if the memory limit above is reached first\n\t */\n\tstatic const unsigned int long_prune_options_max_stored_auts = 100;\n\n\tunsigned int long_prune_max_stored_autss;\n\tstd::vector *> long_prune_fixed;\n\tstd::vector *> long_prune_mcrs;\n\tstd::vector long_prune_temp;\n\tunsigned int long_prune_begin;\n\tunsigned int long_prune_end;\n\t/** \\internal\n\t * Initialize the \"long prune\" data structures.\n\t */\n\t//void long_prune_init();\n\t/** \\internal\n\t * Release the memory allocated for \"long prune\" data structures.\n\t */\n\t//void long_prune_deallocate();\n\t//void long_prune_add_automorphism(const unsigned int *aut);\n\t//std::vector& long_prune_get_fixed(const unsigned int index);\n\t//std::vector& long_prune_allocget_fixed(const unsigned int index);\n\t//std::vector& long_prune_get_mcrs(const unsigned int index);\n\t//std::vector& long_prune_allocget_mcrs(const unsigned int index);\n\t/** \\internal\n\t * Swap the i:th and j:th stored automorphism information;\n\t * i and j must be \"in window, i.e. in [long_prune_begin,long_prune_end[\n\t */\n\t//void long_prune_swap(const unsigned int i, const unsigned int j);\n//Long prune code\nvoid long_prune_init() {\n\tconst unsigned int N = get_nof_vertices();\n\tlong_prune_temp.clear();\n\tlong_prune_temp.resize(N);\n\t/* Of how many automorphisms we can store information in\n\t the predefined, fixed amount of memory? */\n\tconst unsigned int nof_fitting_in_max_mem =\n\t\t(long_prune_options_max_mem * 1024 * 1024) / (((N * 2) / 8)+1);\n\tlong_prune_max_stored_autss = long_prune_options_max_stored_auts;\n\t/* Had some problems with g++ in using (a* tmp = long_prune_fixed[real_i];\n\tlong_prune_fixed[real_i] = long_prune_fixed[real_j];\n\tlong_prune_fixed[real_j] = tmp;\n\ttmp = long_prune_mcrs[real_i];\n\tlong_prune_mcrs[real_i] = long_prune_mcrs[real_j];\n\tlong_prune_mcrs[real_j] = tmp;\n}\n\nstd::vector& long_prune_allocget_fixed(const unsigned int index) {\n\tconst unsigned int i = index % long_prune_max_stored_autss;\n\tif(!long_prune_fixed[i])\n\t\tlong_prune_fixed[i] = new std::vector(get_nof_vertices());\n\treturn *long_prune_fixed[i];\n}\n\nstd::vector& long_prune_get_fixed(const unsigned int index) {\n\treturn *long_prune_fixed[index % long_prune_max_stored_autss];\n}\n\nstd::vector& long_prune_allocget_mcrs(const unsigned int index) {\n\tconst unsigned int i = index % long_prune_max_stored_autss;\n\tif(!long_prune_mcrs[i])\n\t\tlong_prune_mcrs[i] = new std::vector(get_nof_vertices());\n\treturn *long_prune_mcrs[i];\n}\n\nstd::vector& long_prune_get_mcrs(const unsigned int index) {\n\treturn *long_prune_mcrs[index % long_prune_max_stored_autss];\n}\n\nvoid long_prune_add_automorphism(const unsigned int* aut) {\n\tif(long_prune_max_stored_autss == 0) return;\n\tconst unsigned int N = get_nof_vertices();\n\t/* If the buffer of stored auts is full, remove the oldest aut */\n\tif(long_prune_end - long_prune_begin == long_prune_max_stored_autss) {\n\t\tlong_prune_begin++;\n\t}\n\tlong_prune_end++;\n\tstd::vector& fixed = long_prune_allocget_fixed(long_prune_end-1);\n\tstd::vector& mcrs = long_prune_allocget_mcrs(long_prune_end-1);\n\t/* Mark nodes that are (i) fixed or (ii) minimal orbit representatives\n\t * under the automorphism 'aut' */\n\tfor(unsigned int i = 0; i < N; i++) {\n\t\tfixed[i] = (aut[i] == i);\n\t\tif(long_prune_temp[i] == false) {\n\t\t\tmcrs[i] = true;\n\t\t\tunsigned int j = aut[i];\n\t\t\twhile(j != i) {\n\t\t\t\tlong_prune_temp[j] = true;\n\t\t\t\tj = aut[j];\n\t\t\t}\n\t\t} else {\n\t\t\tmcrs[i] = false;\n\t\t}\n\t\t/* Clear the temp array on-the-fly... */\n\t\tlong_prune_temp[i] = false;\n\t}\n}\n\n\t/*\n\t * Data structures and routines for refining the partition p into equitable\n\t */\n\tHeap neighbour_heap;\n\tvirtual bool split_neighbourhood_of_unit_cell(Partition::Cell *) = 0;\n\tvirtual bool split_neighbourhood_of_cell(Partition::Cell * const) = 0;\n\t//void refine_to_equitable();\n\t//void refine_to_equitable(Partition::Cell * const unit_cell);\n\t//void refine_to_equitable(Partition::Cell * const unit_cell1, Partition::Cell * const unit_cell2);\nvoid refine_to_equitable() {\n\t/* Start refinement from all cells -> push 'em all in the splitting queue */\n\tfor(Partition::Cell* cell = p.first_cell; cell; cell = cell->next)\n\t\tp.splitting_queue_add(cell);\n\tdo_refine_to_equitable();\n}\n\nvoid refine_to_equitable(Partition::Cell* const unit_cell) {\n\tp.splitting_queue_add(unit_cell);\n\tdo_refine_to_equitable();\n}\n\nvoid refine_to_equitable(Partition::Cell* const unit_cell1, Partition::Cell* const unit_cell2) {\n\tp.splitting_queue_add(unit_cell1);\n\tp.splitting_queue_add(unit_cell2);\n\tdo_refine_to_equitable();\n}\n\t/** \\internal\n\t * \\return false if it was detected that the current certificate\n\t * is different from the first and/or best (whether this is checked\n\t * depends on in_search and refine_compare_certificate flags.\n\t */\n\t//bool do_refine_to_equitable();\nbool do_refine_to_equitable() {\n\teqref_hash.reset();\n\twhile(!p.splitting_queue_is_empty()) {\n\t\tPartition::Cell* const cell = p.splitting_queue_pop();\n\t\tif(cell->is_unit()) {\n\t\t\tif(in_search) {\n\t\t\t\tconst unsigned int index = cell->first;\n\t\t\t\tif(first_path_automorphism) {\n\t\t\t\t\t/* Build the (potential) automorphism on-the-fly */\n\t\t\t\t\tfirst_path_automorphism[first_path_labeling_inv[index]] =\n\t\t\t\t\t\tp.elements[index];\n\t\t\t\t}\n\t\t\t\tif(best_path_automorphism) {\n\t\t\t\t\t/* Build the (potential) automorphism on-the-fly */\n\t\t\t\t\tbest_path_automorphism[best_path_labeling_inv[index]] =\n\t\t\t\t\t\tp.elements[index];\n\t\t\t\t}\n\t\t\t}\n\t\t\tconst bool worse = split_neighbourhood_of_unit_cell(cell);\n\t\t\tif(in_search and worse) goto worse_exit;\n\t\t}\n\t\telse {\n\t\t\tconst bool worse = split_neighbourhood_of_cell(cell);\n\t\t\tif(in_search and worse) goto worse_exit;\n\t\t}\n\t}\n\treturn true;\nworse_exit:\n\t/* Clear splitting_queue */\n\tp.splitting_queue_clear();\n\treturn false;\n}\n\tunsigned int eqref_max_certificate_index;\n\t/** \\internal\n\t * Whether eqref_hash is updated during equitable refinement process.\n\t */\n\tbool compute_eqref_hash;\n\tUintSeqHash eqref_hash;\n\t/** \\internal\n\t * Check whether the current partition p is equitable.\n\t * Performance: very slow, use only for debugging purposes.\n\t */\n\tvirtual bool is_equitable() const = 0;\n\n\tunsigned int *first_path_labeling;\n\tunsigned int *first_path_labeling_inv;\n\tOrbit first_path_orbits;\n\tunsigned int *first_path_automorphism;\n\tunsigned int *best_path_labeling;\n\tunsigned int *best_path_labeling_inv;\n\tOrbit best_path_orbits;\n\tunsigned int *best_path_automorphism;\n\n\t//void update_labeling(unsigned int * const lab);\n/** \\internal\n * Assign the labeling induced by the current partition 'this.p' to\n * \\a labeling.\n * That is, if the partition is [[2,0],[1]],\n * then \\a labeling will map 0 to 1, 1 to 2, and 2 to 0.\n */\nvoid update_labeling(unsigned int* const labeling) {\n\tconst unsigned int N = get_nof_vertices();\n\tunsigned int* ep = p.elements;\n\tfor(unsigned int i = 0; i < N; i++, ep++)\n\t\tlabeling[*ep] = i;\n}\n\t//void update_labeling_and_its_inverse(unsigned int * const lab, unsigned int * const lab_inv);\n/** \\internal\n * The same as update_labeling() except that the inverse of the labeling\n * is also produced and assigned to \\a labeling_inv.\n */\nvoid update_labeling_and_its_inverse(unsigned int* const labeling, unsigned int* const labeling_inv) {\n\tconst unsigned int N = get_nof_vertices();\n\tunsigned int* ep = p.elements;\n\tunsigned int* clip = labeling_inv;\n\tfor(unsigned int i = 0; i < N; ) {\n\t\tlabeling[*ep] = i;\n\t\ti++;\n\t\t*clip = *ep;\n\t\tep++;\n\t\tclip++;\n\t}\n}\n\tvoid update_orbit_information(Orbit &o, const unsigned int *perm) {\n\t\tconst unsigned int N = get_nof_vertices();\n\t\tfor(unsigned int i = 0; i < N; i++)\n\t\t\tif(perm[i] != i) o.merge_orbits(i, perm[i]);\n\t}\n\t//void reset_permutation(unsigned int *perm);\n\t/* Mainly for debugging purposes */\n\t//virtual bool is_automorphism(unsigned int* const perm);\n\n// \\internal\n// Reset the permutation \\a perm to the identity permutation.\nvoid reset_permutation(unsigned int* perm) {\n\tconst unsigned int N = get_nof_vertices();\n\tfor(unsigned int i = 0; i < N; i++, perm++)\n\t\t*perm = i;\n}\n\nvirtual bool is_automorphism(unsigned int* const perm) {\n\t_INTERNAL_ERROR();\n\treturn false;\n}\n\tstd::vector certificate_current_path;\n\tstd::vector certificate_first_path;\n\tstd::vector certificate_best_path;\n\tunsigned int certificate_index;\n\tvirtual void initialize_certificate() = 0;\n\tvirtual void remove_duplicate_edges() = 0;\n\tvirtual void make_initial_equitable_partition() = 0;\n\tvirtual Partition::Cell* find_next_cell_to_be_splitted(Partition::Cell *cell) = 0;\n\t//void search(const bool canonical, Stats &stats);\n#include \"search.h\"\n\tvoid (*report_hook)(void *user_param, unsigned int n, const unsigned int *aut);\n\tvoid *report_user_param;\n\t/*\n\t *\n\t * Nonuniform component recursion (NUCR)\n\t *\n\t */\n\n\t/** The currently traversed component */\n\tunsigned int cr_level;\n\n\t/** \\internal\n\t * The \"Component End Point\" data structure\n\t */\n\tclass CR_CEP {\n\t\tpublic:\n\t\t\t/** At which level in the search was this CEP created */\n\t\t\tunsigned int creation_level;\n\t\t\t/** The current component has been fully traversed when the partition has\n\t\t\t * this many discrete cells left */\n\t\t\tunsigned int discrete_cell_limit;\n\t\t\t/** The component to be traversed after the current one */\n\t\t\tunsigned int next_cr_level;\n\t\t\t/** The next component end point */\n\t\t\tunsigned int next_cep_index;\n\t\t\tbool first_checked;\n\t\t\tbool best_checked;\n\t};\n\t/** \\internal\n\t * A stack for storing Component End Points\n\t */\n\tstd::vector cr_cep_stack;\n\n\t/** \\internal\n\t * Find the first non-uniformity component at the component recursion\n\t * level \\a level.\n\t * The component is stored in \\a cr_component.\n\t * If no component is found, \\a cr_component is empty.\n\t * Returns false if all the cells in the component recursion level \\a level\n\t * were discrete.\n\t * Modifies the max_ival and max_ival_count fields of Partition:Cell\n\t * (assumes that they are 0 when called and\n\t * quarantees that they are 0 when returned).\n\t */\n\tvirtual bool nucr_find_first_component(const unsigned int level) = 0;\n\tvirtual bool nucr_find_first_component(const unsigned int level,\n\t\t\tstd::vector& component,\n\t\t\tunsigned int& component_elements,\n\t\t\tPartition::Cell*& sh_return) = 0;\n\t/** \\internal\n\t * The non-uniformity component found by nucr_find_first_component()\n\t * is stored here.\n\t */\n\tstd::vector cr_component;\n\t/** \\internal\n\t * The number of vertices in the component \\a cr_component\n\t */\n\tunsigned int cr_component_elements;\n};\n\n// Assumes that the elements in the cell are sorted according to their invariant values.\nPartition::Cell* Partition::split_cell(Partition::Cell* const original_cell) {\n Partition::Cell* cell = original_cell;\n const bool original_cell_was_in_splitting_queue =\n original_cell->in_splitting_queue;\n Partition::Cell* largest_new_cell = 0;\n\n while(true) {\n unsigned int* ep = elements + cell->first;\n const unsigned int* const lp = ep + cell->length;\n const unsigned int ival = invariant_values[*ep];\n invariant_values[*ep] = 0;\n element_to_cell_map[*ep] = cell;\n in_pos[*ep] = ep;\n ep++;\n while(ep < lp) {\n\t const unsigned int e = *ep;\n\t if(invariant_values[e] != ival)\n\t break;\n\t invariant_values[e] = 0;\n\t in_pos[e] = ep;\n\t ep++;\n\t element_to_cell_map[e] = cell;\n\t}\n if(ep == lp) break;\n Partition::Cell* const new_cell = aux_split_in_two(cell, (ep - elements) - cell->first);\n if(graph and graph->compute_eqref_hash) {\n\t graph->eqref_hash.update(new_cell->first);\n\t graph->eqref_hash.update(new_cell->length);\n\t graph->eqref_hash.update(ival);\n\t}\n /* Add cells in splitting_queue */\n assert(!new_cell->is_in_splitting_queue());\n if(original_cell_was_in_splitting_queue)\n\t{\n\t /* In this case, all new cells are inserted in splitting_queue */\n\t assert(cell->is_in_splitting_queue());\n\t splitting_queue_add(new_cell);\n\t}\n else\n\t{\n\t /* Otherwise, we can omit one new cell from splitting_queue */\n\t assert(!cell->is_in_splitting_queue());\n\t if(largest_new_cell == 0) {\n\t largest_new_cell = cell;\n\t } else {\n\t assert(!largest_new_cell->is_in_splitting_queue());\n\t if(cell->length > largest_new_cell->length) {\n\t splitting_queue_add(largest_new_cell);\n\t largest_new_cell = cell;\n\t } else {\n\t splitting_queue_add(cell);\n\t }\n\t }\n\t}\n /* Process the rest of the cell */\n cell = new_cell;\n }\n\n \n if(original_cell == cell) {\n /* All the elements in cell had the same invariant value */\n return cell;\n }\n\n /* Add cells in splitting_queue */\n if(!original_cell_was_in_splitting_queue) {\n /* Also consider the last new cell */\n assert(largest_new_cell);\n if(cell->length > largest_new_cell->length) {\n\t splitting_queue_add(largest_new_cell);\n\t largest_new_cell = cell;\n\t} else {\n\t splitting_queue_add(cell);\n\t}\n if(largest_new_cell->is_unit()) {\n\t /* Needed in certificate computation */\n\t splitting_queue_add(largest_new_cell);\n\t}\n }\n return cell;\n}\n\n}\n\n#endif\n" }, { "path": "external/bliss/bliss/bignum.hh", "content": "#ifndef BLISS_BIGNUM_HH\n#define BLISS_BIGNUM_HH\n\n/*\n Copyright (c) 2003-2015 Tommi Junttila\n Released under the GNU Lesser General Public License version 3.\n \n This file is part of bliss.\n \n bliss is free software: you can redistribute it and/or modify\n it under the terms of the GNU Lesser General Public License as published by\n the Free Software Foundation, version 3 of the License.\n\n bliss is distributed in the hope that it will be useful,\n but WITHOUT ANY WARRANTY; without even the implied warranty of\n MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n GNU Lesser General Public License for more details.\n\n You should have received a copy of the GNU Lesser General Public License\n along with bliss. If not, see .\n*/\n\n#if defined(BLISS_USE_GMP)\n#include \n#endif\n\n#include \n#include \n#include \"defs.hh\"\n\nnamespace bliss {\n\n/**\n * \\brief A very simple class for big integers (or approximation of them).\n *\n * If the compile time flag BLISS_USE_GMP is set,\n * then the GNU Multiple Precision Arithmetic library (GMP) is used to\n * obtain arbitrary precision, otherwise \"long double\" is used to\n * approximate big integers.\n */\n\n#if defined(BLISS_USE_GMP)\n\nclass BigNum\n{\n mpz_t v;\npublic:\n /**\n * Create a new big number and set it to zero.\n */\n BigNum() {mpz_init(v); }\n\n /**\n * Destroy the number.\n */\n ~BigNum() {mpz_clear(v); }\n\n /**\n * Set the number to \\a n.\n */\n void assign(const int n) {mpz_set_si(v, n); }\n\n /**\n * Multiply the number with \\a n.\n */\n void multiply(const int n) {mpz_mul_si(v, v, n); }\n\n /**\n * Print the number in the file stream \\a fp.\n */\n size_t print(FILE* const fp) const {return mpz_out_str(fp, 10, v); }\n};\n\n#else\n\nclass BigNum\n{\n long double v;\npublic:\n /**\n * Create a new big number and set it to zero.\n */\n BigNum(): v(0.0) {}\n\n /**\n * Set the number to \\a n.\n */\n void assign(const int n) {v = (long double)n; }\n\n /**\n * Multiply the number with \\a n.\n */\n void multiply(const int n) {v *= (long double)n; }\n\n /**\n * Print the number in the file stream \\a fp.\n */\n size_t print(FILE* const fp) const {return fprintf(fp, \"%Lg\", v); }\n};\n\n#endif\n\n} //namespace bliss\n\n#endif\n" }, { "path": "external/bliss/bliss/defs.hh", "content": "#ifndef BLISS_DEFS_HH\n#define BLISS_DEFS_HH\n\n#include \n#include \n\n/*\n Copyright (c) 2003-2015 Tommi Junttila\n Released under the GNU Lesser General Public License version 3.\n \n This file is part of bliss.\n \n bliss is free software: you can redistribute it and/or modify\n it under the terms of the GNU Lesser General Public License as published by\n the Free Software Foundation, version 3 of the License.\n\n bliss is distributed in the hope that it will be useful,\n but WITHOUT ANY WARRANTY; without even the implied warranty of\n MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n GNU Lesser General Public License for more details.\n\n You should have received a copy of the GNU Lesser General Public License\n along with bliss. If not, see .\n*/\n\nnamespace bliss {\n\n/**\n * The version number of bliss.\n */\nstatic const char * const version = \"0.73\";\n\n/*\n * If a fatal error (out of memory, internal error) is encountered,\n * this function is called.\n * There should not be a return from this function but exit or\n * a jump to code that deallocates the AbstractGraph instance that called this.\n */\nvoid fatal_error(const char* fmt, ...);\n\n\n#if defined(BLISS_DEBUG)\n#define BLISS_CONSISTENCY_CHECKS\n#define BLISS_EXPENSIVE_CONSISTENCY_CHECKS\n#endif\n\n\n#if defined(BLISS_CONSISTENCY_CHECKS)\n/* Force a check that the found automorphisms are valid */\n#define BLISS_VERIFY_AUTOMORPHISMS\n#endif\n\n\n#if defined(BLISS_CONSISTENCY_CHECKS)\n/* Force a check that the generated partitions are equitable */\n#define BLISS_VERIFY_EQUITABLEDNESS\n#endif\n\n} // namespace bliss\n\n\n\n/*! \\mainpage Bliss\n *\n * \\section intro_sec Introduction\n *\n * This is the source code documentation of bliss,\n * produced by running doxygen in\n * the source directory.\n * The algorithms and data structures used in bliss are documented in\n * the papers found at the\n * bliss web site.\n *\n *\n * \\section compile_sec Compiling\n *\n * Compiling bliss in Linux should be easy, just execute\n * \\code\n * make\n * \\endcode\n * in the bliss source directory.\n * This will produce the executable program \\c bliss as well as\n * the library file \\c libbliss.a that can be linked in other programs.\n * If you have the GNU Multiple Precision\n * Arithmetic Library (GMP) installed in your machine, you can also use\n * \\code\n * make gmp\n * \\endcode\n * to enable exact computation of automorphism group sizes.\n *\n * When linking the bliss library \\c libbliss.a in other programs,\n * remember to include the standard c++ library\n * (and the GMP library if you compiled bliss to include it).\n * For instance,\n * \\code gcc -o test test.c -lstdc++ -lgmp -lbliss\\endcode\n *\n * \\section cppapi_sec The C++ language API\n *\n * The C++ language API is the main API to bliss;\n * all other APIs are just more or less complete variants of it.\n * The C++ API consists basically of the public methods in\n * the classes bliss::AbstractGraph, bliss::Graph, and bliss::Digraph.\n * For an example of its use,\n * see the \\ref executable \"source of the bliss executable\".\n *\n *\n * \\section capi_sec The C language API\n *\n * The C language API is given in the file bliss_C.h.\n * It is currently more restricted than the C++ API so\n * consider using the C++ API whenever possible.\n */\n\n\n#endif\n" }, { "path": "external/bliss/bliss/graph.hh", "content": "#ifndef BLISS_GRAPH_HH\n#define BLISS_GRAPH_HH\n\n#include \"abgraph.hh\"\n\nnamespace bliss {\n\n#ifdef USE_DOMAIN\ntypedef std::pair IndexEdge;\n#else\ntypedef unsigned IndexEdge;\n#endif\n\n#if defined(BLISS_CONSISTENCY_CHECKS)\nstatic bool is_permutation(const unsigned int N, const unsigned int* perm) {\n\tif(N == 0) return true;\n\tstd::vector m(N, false);\n\tfor(unsigned int i = 0; i < N; i++) {\n\t\tif(perm[i] >= N) return false;\n\t\tif(m[perm[i]]) return false;\n\t\tm[perm[i]] = true;\n\t}\n\treturn true;\n}\n#endif\nstatic bool is_permutation(const std::vector& perm) {\n\tconst unsigned int N = perm.size();\n\tif(N == 0)\n\t\treturn true;\n\tstd::vector m(N, false);\n\tfor(unsigned int i = 0; i < N; i++) {\n\t\tif(perm[i] >= N) return false;\n\t\tif(m[perm[i]]) return false;\n\t\tm[perm[i]] = true;\n\t}\n\treturn true;\n}\n\n// \\brief The class for undirected, vertex colored graphs.\n// Multiple edges between vertices are not allowed (i.e., are ignored).\nclass Graph : public AbstractGraph {\npublic:\n\t/**\n\t * The possible splitting heuristics.\n\t * The selected splitting heuristics affects the computed canonical\n\t * labelings; therefore, if you want to compare whether two graphs\n\t * are isomorphic by computing and comparing (for equality) their\n\t * canonical versions, be sure to use the same splitting heuristics\n\t * for both graphs.\n\t */\n\ttypedef enum {\n\t\t/** First non-unit cell.\n\t\t * Very fast but may result in large search spaces on difficult graphs.\n\t\t * Use for large but easy graphs. */\n\t\tshs_f = 0,\n\t\t/** First smallest non-unit cell.\n\t\t * Fast, should usually produce smaller search spaces than shs_f. */\n\t\tshs_fs,\n\t\t/** First largest non-unit cell.\n\t\t * Fast, should usually produce smaller search spaces than shs_f. */\n\t\tshs_fl,\n\t\t/** First maximally non-trivially connected non-unit cell.\n\t\t * Not so fast, should usually produce smaller search spaces than shs_f,\n\t\t * shs_fs, and shs_fl. */\n\t\tshs_fm,\n\t\t/** First smallest maximally non-trivially connected non-unit cell.\n\t\t * Not so fast, should usually produce smaller search spaces than shs_f,\n\t\t * shs_fs, and shs_fl. */\n\t\tshs_fsm,\n\t\t/** First largest maximally non-trivially connected non-unit cell.\n\t\t * Not so fast, should usually produce smaller search spaces than shs_f,\n\t\t * shs_fs, and shs_fl. */\n\t\tshs_flm\n\t} SplittingHeuristic;\n\n\t//moved from protected scope by Zhiqiang\n\tclass Vertex {\n\t\tpublic:\n\t\t\tVertex() { color = 0;}\n\t\t\t~Vertex(){ ; }\n#ifdef USE_DOMAIN\n\t\t\tvoid add_edge(const unsigned other_vertex, Index index) {\n\t\t\t\tedges.push_back(std::make_pair(other_vertex, index));\n#else\n\t\t\tvoid add_edge(const unsigned other_vertex) {\n\t\t\t\tedges.push_back(other_vertex);\n#endif\n\t\t\t}\n\t\t\tvoid remove_duplicate_edges(std::vector& tmp) {\n#if defined(BLISS_CONSISTENCY_CHECKS)\n\t\t\t\t/* Pre-conditions */\n\t\t\t\tfor(unsigned int i = 0; i < tmp.size(); i++) assert(tmp[i] == false);\n#endif\n\t\t\t\tfor(std::vector::iterator iter = edges.begin(); iter != edges.end(); ) {\n#ifdef USE_DOMAIN\n\t\t\t\t\tconst unsigned int dest_vertex = iter->first; //cxh\n#else\n\t\t\t\t\tconst unsigned int dest_vertex = *iter;\n#endif\n\t\t\t\t\tif(tmp[dest_vertex] == true) {\n\t\t\t\t\t\t/* A duplicate edge found! */\n\t\t\t\t\t\titer = edges.erase(iter);\n\t\t\t\t\t} else {\n\t\t\t\t\t\t/* Not seen earlier, mark as seen */\n\t\t\t\t\t\ttmp[dest_vertex] = true;\n\t\t\t\t\t\titer++;\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t\t/* Clear tmp */\n\t\t\t\tfor(std::vector::iterator iter = edges.begin(); iter != edges.end(); iter++) {\n#ifdef USE_DOMAIN\n\t\t\t\t\ttmp[iter->first] = false;// cxh\n#else\n\t\t\t\t\ttmp[*iter] = false;\n#endif\n\t\t\t\t}\n#if defined(BLISS_CONSISTENCY_CHECKS)\n\t\t\t\t/* Post-conditions */\n\t\t\t\tfor(unsigned int i = 0; i < tmp.size(); i++) assert(tmp[i] == false);\n#endif\n\t\t\t}\n\t\t\tvoid sort_edges() { std::sort(edges.begin(), edges.end()); }\n\t\t\tunsigned color;\n\t\t\t//std::vector edges;\n\t\t\tstd::vector edges; // cxh: add the edge ids from the embedding\n\t\t\tunsigned nof_edges() const {return edges.size(); }\n\t\t\t};\n\t\t\t//added by Zhiqiang\n\t\t\tstd::vector & get_vertices_rstream() { return vertices; }\n\t\t\tvoid sort_edges_rstream() { sort_edges(); }\n\nprotected:\n\tstd::vector vertices;\n\tvoid sort_edges() {\n\t\tfor(unsigned int i = 0; i < get_nof_vertices(); i++)\n\t\t\tvertices[i].sort_edges();\n\t}\n\tvoid remove_duplicate_edges() {\n\t\tstd::vector tmp(vertices.size(), false);\n\t\tfor(std::vector::iterator vi = vertices.begin();\n\t\t\t\tvi != vertices.end();\n\t\t\t\tvi++)\n\t\t{\n#if defined(BLISS_EXPENSIVE_CONSISTENCY_CHECKS)\n\t\t\tfor(unsigned int i = 0; i < tmp.size(); i++) assert(tmp[i] == false);\n#endif\n\t\t\t(*vi).remove_duplicate_edges(tmp);\n\t\t}\n\t}\n\t// \\internal Partition independent invariant.\n\t// Return the color of the vertex. Time complexity: O(1)\n\tstatic unsigned int vertex_color_invariant(const Graph* const g, const unsigned int v) { \n\t\treturn g->vertices[v].color;\n\t}\n\t/** \\internal\n\t * Partition independent invariant.\n\t * Returns the degree of the vertex.\n\t * DUPLICATE EDGES MUST HAVE BEEN REMOVED BEFORE.\n\t * Time complexity: O(1).\n\t */\n\t// Return the degree of the vertex. Time complexity: O(1)\n\tstatic unsigned int degree_invariant(const Graph* const g, const unsigned int v) {\n\t\treturn g->vertices[v].nof_edges();\n\t}\n\t/** \\internal\n\t * Partition independent invariant.\n\t * Returns 1 if there is an edge from the vertex to itself, 0 if not.\n\t * Time complexity: O(k), where k is the number of edges leaving the vertex.\n\t */\n\t// Return 1 if the vertex v has a self-loop, 0 otherwise\n\t// Time complexity: O(E_v), where E_v is the number of edges leaving v\n\tstatic unsigned selfloop_invariant(const Graph* const g, const unsigned int v) {\n\t\tconst Vertex& vertex = g->vertices[v];\n\t\tfor(std::vector::const_iterator ei = vertex.edges.begin(); ei != vertex.edges.end(); ei++) {\n#ifdef USE_DOMAIN\n\t\t\tif(ei->first == v) return 1; // cxh\n#else\n\t\t\tif(*ei == v) return 1;\n#endif\n\t\t}\n\t\treturn 0;\n\t}\n\n\t// Refine the partition p according to a partition independent invariant\n\tbool refine_according_to_invariant(unsigned int (*inv)(const Graph* const g, const unsigned int v)) {\n\t\tbool refined = false;\n\t\tfor(Partition::Cell* cell = p.first_nonsingleton_cell; cell; ) {\n\t\t\tPartition::Cell* const next_cell = cell->next_nonsingleton;\n\t\t\tconst unsigned int* ep = p.elements + cell->first;\n\t\t\tfor(unsigned int i = cell->length; i > 0; i--, ep++) {\n\t\t\t\tconst unsigned int ival = inv(this, *ep);\n\t\t\t\tp.invariant_values[*ep] = ival;\n\t\t\t\tif(ival > cell->max_ival) {\n\t\t\t\t\tcell->max_ival = ival;\n\t\t\t\t\tcell->max_ival_count = 1;\n\t\t\t\t}\n\t\t\t\telse if(ival == cell->max_ival) {\n\t\t\t\t\tcell->max_ival_count++;\n\t\t\t\t}\n\t\t\t}\n\t\t\tPartition::Cell* const last_new_cell = p.zplit_cell(cell, true);\n\t\t\trefined |= (last_new_cell != cell);\n\t\t\tcell = next_cell;\n\t\t}\n\t\treturn refined;\n\t}\n\t// Routines needed when refining the partition p into equitable\n\t// Split the neighbourhood of a cell according to the equitable invariant\n\tbool split_neighbourhood_of_cell(Partition::Cell* const cell) {\n\t\tconst bool was_equal_to_first = refine_equal_to_first;\n\t\tif(compute_eqref_hash) {\n\t\t\teqref_hash.update(cell->first);\n\t\t\teqref_hash.update(cell->length);\n\t\t}\n\t\tconst unsigned int* ep = p.elements + cell->first;\n\t\tfor(unsigned int i = cell->length; i > 0; i--) {\n\t\t\tconst Vertex& v = vertices[*ep++]; \n\t\t\tstd::vector::const_iterator ei = v.edges.begin();\n\t\t\tfor(unsigned int j = v.nof_edges(); j != 0; j--) {\n#ifdef USE_DOMAIN\n\t\t\t\tconst unsigned int dest_vertex = (ei++)->first; // cxh\n#else\n\t\t\t\tconst unsigned int dest_vertex = *ei++;\n#endif\n\t\t\t\tPartition::Cell * const neighbour_cell = p.get_cell(dest_vertex);\n\t\t\t\tif(neighbour_cell->is_unit())\n\t\t\t\t\tcontinue;\n\t\t\t\tconst unsigned int ival = ++p.invariant_values[dest_vertex];\n\t\t\t\tif(ival > neighbour_cell->max_ival) {\n\t\t\t\t\tneighbour_cell->max_ival = ival;\n\t\t\t\t\tneighbour_cell->max_ival_count = 1;\n\t\t\t\t\tif(ival == 1) {\n\t\t\t\t\t\tneighbour_heap.insert(neighbour_cell->first);\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t\telse if(ival == neighbour_cell->max_ival) {\n\t\t\t\t\tneighbour_cell->max_ival_count++;\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t\twhile(!neighbour_heap.is_empty()) {\n\t\t\tconst unsigned int start = neighbour_heap.remove();\n\t\t\tPartition::Cell * const neighbour_cell = p.get_cell(p.elements[start]);\n\t\t\tif(compute_eqref_hash) {\n\t\t\t\teqref_hash.update(neighbour_cell->first);\n\t\t\t\teqref_hash.update(neighbour_cell->length);\n\t\t\t\teqref_hash.update(neighbour_cell->max_ival);\n\t\t\t\teqref_hash.update(neighbour_cell->max_ival_count);\n\t\t\t}\n\t\t\tPartition::Cell* const last_new_cell = p.zplit_cell(neighbour_cell, true);\n\t\t\t// Update certificate and hash if needed\n\t\t\tconst Partition::Cell* c = neighbour_cell;\n\t\t\twhile(1) {\n\t\t\t\tif(in_search) {\n\t\t\t\t\t// Build certificate\n\t\t\t\t\tcert_add_redundant(CERT_SPLIT, c->first, c->length);\n\t\t\t\t\t// No need to continue?\n\t\t\t\t\tif(refine_compare_certificate and\n\t\t\t\t\t\t\t(refine_equal_to_first == false) and\n\t\t\t\t\t\t\t(refine_cmp_to_best < 0))\n\t\t\t\t\t\tgoto worse_exit;\n\t\t\t\t}\n\t\t\t\tif(compute_eqref_hash) {\n\t\t\t\t\teqref_hash.update(c->first);\n\t\t\t\t\teqref_hash.update(c->length);\n\t\t\t\t}\n\t\t\t\tif(c == last_new_cell) break;\n\t\t\t\tc = c->next;\n\t\t\t}\n\t\t}\n\n\t\tif(refine_compare_certificate and (refine_equal_to_first == false) and (refine_cmp_to_best < 0))\n\t\t\treturn true;\n\t\treturn false;\nworse_exit:\n\t\t// Clear neighbour heap \n\t\tUintSeqHash rest;\n\t\twhile(!neighbour_heap.is_empty()) {\n\t\t\tconst unsigned int start = neighbour_heap.remove();\n\t\t\tPartition::Cell * const neighbour_cell = p.get_cell(p.elements[start]);\n\t\t\tif(opt_use_failure_recording and was_equal_to_first) {\n\t\t\t\trest.update(neighbour_cell->first);\n\t\t\t\trest.update(neighbour_cell->length);\n\t\t\t\trest.update(neighbour_cell->max_ival);\n\t\t\t\trest.update(neighbour_cell->max_ival_count);\n\t\t\t}\n\t\t\tneighbour_cell->max_ival = 0;\n\t\t\tneighbour_cell->max_ival_count = 0;\n\t\t\tp.clear_ivs(neighbour_cell);\n\t\t}\n\t\tif(opt_use_failure_recording and was_equal_to_first) {\n\t\t\tfor(unsigned int i = p.splitting_queue.size(); i > 0; i--) {\n\t\t\t\tPartition::Cell* const cell = p.splitting_queue.pop_front();\n\t\t\t\trest.update(cell->first);\n\t\t\t\trest.update(cell->length);\n\t\t\t\tp.splitting_queue.push_back(cell);\n\t\t\t}\n\t\t\trest.update(failure_recording_fp_deviation);\n\t\t\tfailure_recording_fp_deviation = rest.get_value();\n\t\t}\n\t\treturn true;\n\t}\n\n\tbool split_neighbourhood_of_unit_cell(Partition::Cell* const unit_cell) {\n\t\tconst bool was_equal_to_first = refine_equal_to_first;\n\t\tif(compute_eqref_hash) {\n\t\t\teqref_hash.update(0x87654321);\n\t\t\teqref_hash.update(unit_cell->first);\n\t\t\teqref_hash.update(1);\n\t\t}\n\t\tconst Vertex& v = vertices[p.elements[unit_cell->first]];\n\t\tstd::vector::const_iterator ei = v.edges.begin();\n\t\tfor(unsigned int j = v.nof_edges(); j > 0; j--) {\n#ifdef USE_DOMAIN\n\t\t\tconst unsigned int dest_vertex = (ei++)->first; // cxh\n#else\n\t\t\tconst unsigned int dest_vertex = *ei++;\n#endif\n\t\t\tPartition::Cell * const neighbour_cell = p.get_cell(dest_vertex);\n\n\t\t\tif(neighbour_cell->is_unit()) {\n\t\t\t\tif(in_search) {\n\t\t\t\t\t/* Remember neighbour in order to generate certificate */\n\t\t\t\t\tneighbour_heap.insert(neighbour_cell->first);\n\t\t\t\t}\n\t\t\t\tcontinue;\n\t\t\t}\n\t\t\tif(neighbour_cell->max_ival_count == 0) {\n\t\t\t\tneighbour_heap.insert(neighbour_cell->first);\n\t\t\t}\n\t\t\tneighbour_cell->max_ival_count++;\n\n\t\t\tunsigned int * const swap_position =\n\t\t\t\tp.elements + neighbour_cell->first + neighbour_cell->length -\n\t\t\t\tneighbour_cell->max_ival_count;\n\t\t\t*p.in_pos[dest_vertex] = *swap_position;\n\t\t\tp.in_pos[*swap_position] = p.in_pos[dest_vertex];\n\t\t\t*swap_position = dest_vertex;\n\t\t\tp.in_pos[dest_vertex] = swap_position;\n\t\t}\n\n\t\twhile(!neighbour_heap.is_empty()) {\n\t\t\tconst unsigned int start = neighbour_heap.remove();\n\t\t\tPartition::Cell* neighbour_cell =\tp.get_cell(p.elements[start]);\n#if defined(BLISS_CONSISTENCY_CHECKS)\n\t\t\tif(neighbour_cell->is_unit()) { } else { }\n#endif\n\t\t\tif(compute_eqref_hash) {\n\t\t\t\teqref_hash.update(neighbour_cell->first);\n\t\t\t\teqref_hash.update(neighbour_cell->length);\n\t\t\t\teqref_hash.update(neighbour_cell->max_ival_count);\n\t\t\t}\n\n\t\t\tif(neighbour_cell->length > 1 and neighbour_cell->max_ival_count != neighbour_cell->length) {\n\t\t\t\tPartition::Cell * const new_cell =\n\t\t\t\t\tp.aux_split_in_two(neighbour_cell, neighbour_cell->length - neighbour_cell->max_ival_count);\n\t\t\t\tunsigned int *ep = p.elements + new_cell->first;\n\t\t\t\tunsigned int * const lp = p.elements+new_cell->first+new_cell->length;\n\t\t\t\twhile(ep < lp) {\n\t\t\t\t\tp.element_to_cell_map[*ep] = new_cell;\n\t\t\t\t\tep++;\n\t\t\t\t}\n\t\t\t\tneighbour_cell->max_ival_count = 0;\n\n\n\t\t\t\tif(compute_eqref_hash) {\n\t\t\t\t\t/* Update hash */\n\t\t\t\t\teqref_hash.update(neighbour_cell->first);\n\t\t\t\t\teqref_hash.update(neighbour_cell->length);\n\t\t\t\t\teqref_hash.update(0);\n\t\t\t\t\teqref_hash.update(new_cell->first);\n\t\t\t\t\teqref_hash.update(new_cell->length);\n\t\t\t\t\teqref_hash.update(1);\n\t\t\t\t}\n\n\t\t\t\t/* Add cells in splitting_queue */\n\t\t\t\tif(neighbour_cell->is_in_splitting_queue()) {\n\t\t\t\t\t/* Both cells must be included in splitting_queue in order\n\t\t\t\t\t to ensure refinement into equitable partition */\n\t\t\t\t\tp.splitting_queue_add(new_cell);\n\t\t\t\t} else {\n\t\t\t\t\tPartition::Cell *min_cell, *max_cell;\n\t\t\t\t\tif(neighbour_cell->length <= new_cell->length) {\n\t\t\t\t\t\tmin_cell = neighbour_cell;\n\t\t\t\t\t\tmax_cell = new_cell;\n\t\t\t\t\t} else {\n\t\t\t\t\t\tmin_cell = new_cell;\n\t\t\t\t\t\tmax_cell = neighbour_cell;\n\t\t\t\t\t}\n\t\t\t\t\t/* Put the smaller cell in splitting_queue */\n\t\t\t\t\tp.splitting_queue_add(min_cell);\n\t\t\t\t\tif(max_cell->is_unit()) {\n\t\t\t\t\t\t/* Put the \"larger\" cell also in splitting_queue */\n\t\t\t\t\t\tp.splitting_queue_add(max_cell);\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t\t/* Update pointer for certificate generation */\n\t\t\t\tneighbour_cell = new_cell;\n\t\t\t} else {\n\t\t\t\t/* neighbour_cell->length == 1 ||\n\t\t\t\t neighbour_cell->max_ival_count == neighbour_cell->length */\n\t\t\t\tneighbour_cell->max_ival_count = 0;\n\t\t\t}\n\n\t\t\t/*\n\t\t\t * Build certificate if required\n\t\t\t */\n\t\t\tif(in_search) {\n\t\t\t\tfor(unsigned int i = neighbour_cell->first, j = neighbour_cell->length; j > 0; j--, i++) {\n\t\t\t\t\t/* Build certificate */\n\t\t\t\t\tcert_add(CERT_EDGE, unit_cell->first, i);\n\t\t\t\t\t/* No need to continue? */\n\t\t\t\t\tif(refine_compare_certificate and (refine_equal_to_first == false) and (refine_cmp_to_best < 0))\n\t\t\t\t\t\tgoto worse_exit;\n\t\t\t\t}\n\t\t\t} /* if(in_search) */\n\t\t} /* while(!neighbour_heap.is_empty()) */\n\n\t\tif(refine_compare_certificate and\n\t\t\t\t(refine_equal_to_first == false) and\n\t\t\t\t(refine_cmp_to_best < 0))\n\t\t\treturn true;\n\t\treturn false;\n\nworse_exit:\n\t\t/* Clear neighbour heap */\n\t\tUintSeqHash rest;\n\t\twhile(!neighbour_heap.is_empty()) {\n\t\t\tconst unsigned int start = neighbour_heap.remove();\n\t\t\tPartition::Cell * const neighbour_cell = p.get_cell(p.elements[start]);\n\t\t\tif(opt_use_failure_recording and was_equal_to_first) {\n\t\t\t\trest.update(neighbour_cell->first);\n\t\t\t\trest.update(neighbour_cell->length);\n\t\t\t\trest.update(neighbour_cell->max_ival_count);\n\t\t\t}\n\t\t\tneighbour_cell->max_ival_count = 0;\n\t\t}\n\t\tif(opt_use_failure_recording and was_equal_to_first) {\n\t\t\trest.update(failure_recording_fp_deviation);\n\t\t\tfailure_recording_fp_deviation = rest.get_value();\n\t\t}\n\t\treturn true;\n\t}\n\n\t// Build the initial equitable partition\n\tvoid make_initial_equitable_partition() {\n\t\trefine_according_to_invariant(&vertex_color_invariant);\n\t\tp.splitting_queue_clear();\n\t\t//p.print_signature(stderr); fprintf(stderr, \"\\n\");\n\t\trefine_according_to_invariant(&selfloop_invariant);\n\t\tp.splitting_queue_clear();\n\t\t//p.print_signature(stderr); fprintf(stderr, \"\\n\");\n\t\trefine_according_to_invariant(°ree_invariant);\n\t\tp.splitting_queue_clear();\n\t\t//p.print_signature(stderr); fprintf(stderr, \"\\n\");\n\t\trefine_to_equitable();\n\t\t//p.print_signature(stderr); fprintf(stderr, \"\\n\");\n\t}\n\t// \\internal\n\t// \\copydoc AbstractGraph::is_equitable() const\n\t//Check whether the current partition p is equitable.\n\t//Performance: very slow, use only for debugging purposes.\n\tbool is_equitable() const {\n\t\tconst unsigned int N = get_nof_vertices();\n\t\tif(N == 0) return true;\n\t\tstd::vector first_count = std::vector(N, 0);\n\t\tstd::vector other_count = std::vector(N, 0);\n\t\tfor(Partition::Cell *cell = p.first_cell; cell; cell = cell->next) {\n\t\t\tif(cell->is_unit()) continue;\n\t\t\tunsigned int *ep = p.elements + cell->first;\n\t\t\tconst Vertex &first_vertex = vertices[*ep++];\n\t\t\t/* Count how many edges lead from the first vertex to\n\t\t\t * the neighbouring cells */\n\t\t\tfor(std::vector::const_iterator ei = first_vertex.edges.begin(); ei != first_vertex.edges.end(); ei++) {\n#ifdef USE_DOMAIN\n\t\t\t\tfirst_count[p.get_cell(ei->first)->first]++; // cxh\n#else\n\t\t\t\tfirst_count[p.get_cell(*ei)->first]++;\n#endif\n\t\t\t}\n\t\t\t/* Count and compare to the edges of the other vertices */\n\t\t\tfor(unsigned int i = cell->length; i > 1; i--) {\n\t\t\t\tconst Vertex &vertex = vertices[*ep++];\n\t\t\t\tfor(std::vector::const_iterator ei = vertex.edges.begin(); ei != vertex.edges.end(); ei++) {\n#ifdef USE_DOMAIN\n\t\t\t\t\tother_count[p.get_cell(ei->first)->first]++; // cxh\n#else\n\t\t\t\t\tother_count[p.get_cell(*ei)->first]++;\n#endif\n\t\t\t\t}\n\t\t\t\tfor(Partition::Cell *cell2 = p.first_cell; cell2; cell2 = cell2->next) {\n\t\t\t\t\tif(first_count[cell2->first] != other_count[cell2->first]) {\n\t\t\t\t\t\t/* Not equitable */\n\t\t\t\t\t\treturn false;\n\t\t\t\t\t}\n\t\t\t\t\tother_count[cell2->first] = 0;\n\t\t\t\t}\n\t\t\t}\n\t\t\t/* Reset first_count */\n\t\t\tfor(unsigned int i = 0; i < N; i++) first_count[i] = 0;\n\t\t}\n\t\treturn true;\n\t}\n\t/* Splitting heuristics, documented in more detail in graph.cc */\n\tSplittingHeuristic sh;\n\n\t// Find the next cell to be splitted\n\tPartition::Cell* find_next_cell_to_be_splitted(Partition::Cell* cell) {\n\t\tswitch(sh) {\n\t\t\tcase shs_f: return sh_first();\n\t\t\tcase shs_fs: return sh_first_smallest();\n\t\t\tcase shs_fl: return sh_first_largest();\n\t\t\tcase shs_fm: return sh_first_max_neighbours();\n\t\t\tcase shs_fsm: return sh_first_smallest_max_neighbours();\n\t\t\tcase shs_flm: return sh_first_largest_max_neighbours();\n\t\t\tdefault: fatal_error(\"Internal error - unknown splitting heuristics\");\n\t\t\t\t\t\t return 0;\n\t\t}\n\t}\n\t// \\internal\n\t// A splitting heuristic.\n\t// Returns the first nonsingleton cell in the current partition.\n\tPartition::Cell* sh_first() {\n\t\tPartition::Cell* best_cell = 0;\n\t\tfor(Partition::Cell* cell = p.first_nonsingleton_cell; cell; cell = cell->next_nonsingleton) {\n\t\t\tif(opt_use_comprec and p.cr_get_level(cell->first) != cr_level)\n\t\t\t\tcontinue;\n\t\t\tbest_cell = cell;\n\t\t\tbreak;\n\t\t}\n\t\treturn best_cell;\n\t}\n\t// \\internal A splitting heuristic.\n\t// Returns the first smallest nonsingleton cell in the current partition.\n\tPartition::Cell* sh_first_smallest() {\n\t\tPartition::Cell* best_cell = 0;\n\t\tunsigned int best_size = UINT_MAX;\n\t\tfor(Partition::Cell* cell = p.first_nonsingleton_cell; cell; cell = cell->next_nonsingleton) {\n\t\t\tif(opt_use_comprec and p.cr_get_level(cell->first) != cr_level) continue;\n\t\t\tif(cell->length < best_size) {\n\t\t\t\tbest_size = cell->length;\n\t\t\t\tbest_cell = cell;\n\t\t\t}\n\t\t}\n\t\treturn best_cell;\n\t}\n\t// \\internal A splitting heuristic.\n\t// Returns the first largest nonsingleton cell in the current partition.\n\tPartition::Cell* sh_first_largest() {\n\t\tPartition::Cell* best_cell = 0;\n\t\tunsigned int best_size = 0;\n\t\tfor(Partition::Cell* cell = p.first_nonsingleton_cell; cell; cell = cell->next_nonsingleton) {\n\t\t\tif(opt_use_comprec and p.cr_get_level(cell->first) != cr_level)\n\t\t\t\tcontinue;\n\t\t\tif(cell->length > best_size) {\n\t\t\t\tbest_size = cell->length;\n\t\t\t\tbest_cell = cell;\n\t\t\t}\n\t\t}\n\t\treturn best_cell;\n\t}\n\t// \\internal\n\t// A splitting heuristic.\n\t// Returns the first nonsingleton cell with max number of neighbouring nonsingleton cells.\n\t// Assumes that the partition p is equitable.\n\t// Assumes that the max_ival fields of the cells are all 0.\n\tPartition::Cell* sh_first_max_neighbours() {\n\t\tPartition::Cell* best_cell = 0;\n\t\tint best_value = -1;\n\t\tKStack neighbour_cells_visited;\n\t\tneighbour_cells_visited.init(get_nof_vertices());\n\t\tfor(Partition::Cell* cell = p.first_nonsingleton_cell; cell; cell = cell->next_nonsingleton) {\n\t\t\tif(opt_use_comprec and p.cr_get_level(cell->first) != cr_level)\n\t\t\t\tcontinue;\n\t\t\tconst Vertex& v = vertices[p.elements[cell->first]];\n\t\t\tstd::vector::const_iterator ei = v.edges.begin();\n\t\t\tfor(unsigned int j = v.nof_edges(); j > 0; j--) {\n#ifdef USE_DOMAIN\n\t\t\t\tPartition::Cell * const neighbour_cell = p.get_cell((ei++)->first); // cxh\n#else\n\t\t\t\tPartition::Cell * const neighbour_cell = p.get_cell(*ei++);\n#endif\n\t\t\t\tif(neighbour_cell->is_unit()) continue;\n\t\t\t\tneighbour_cell->max_ival++;\n\t\t\t\tif(neighbour_cell->max_ival == 1)\n\t\t\t\t\tneighbour_cells_visited.push(neighbour_cell);\n\t\t\t}\n\t\t\tint value = 0;\n\t\t\twhile(!neighbour_cells_visited.is_empty()) {\n\t\t\t\tPartition::Cell* const neighbour_cell = neighbour_cells_visited.pop();\n\t\t\t\tif(neighbour_cell->max_ival != neighbour_cell->length)\n\t\t\t\t\tvalue++;\n\t\t\t\tneighbour_cell->max_ival = 0;\n\t\t\t}\n\t\t\tif(value > best_value) {\n\t\t\t\tbest_value = value;\n\t\t\t\tbest_cell = cell;\n\t\t\t}\n\t\t}\n\t\treturn best_cell;\n\t}\n\t// \\internal A splitting heuristic.\n\t// Returns the first smallest nonsingleton cell with max number of neighbouring nonsingleton cells.\n\t// Assumes that the partition p is equitable. Assumes that the max_ival fields of the cells are all 0.\n\tPartition::Cell* sh_first_smallest_max_neighbours() {\n\t\tPartition::Cell* best_cell = 0;\n\t\tint best_value = -1;\n\t\tunsigned int best_size = UINT_MAX;\n\t\tKStack neighbour_cells_visited;\n\t\tneighbour_cells_visited.init(get_nof_vertices());\n\t\tfor(Partition::Cell* cell = p.first_nonsingleton_cell; cell; cell = cell->next_nonsingleton) {\n\t\t\tif(opt_use_comprec and p.cr_get_level(cell->first) != cr_level)\n\t\t\t\tcontinue;\n\t\t\tconst Vertex& v = vertices[p.elements[cell->first]];\n\t\t\tstd::vector::const_iterator ei = v.edges.begin();\n\t\t\tfor(unsigned int j = v.nof_edges(); j > 0; j--) {\n#ifdef USE_DOMAIN\n\t\t\t\tPartition::Cell* const neighbour_cell = p.get_cell((ei++)->first); // cxh\n#else\n\t\t\t\tPartition::Cell* const neighbour_cell = p.get_cell(*ei++);\n#endif\n\t\t\t\tif(neighbour_cell->is_unit()) continue;\n\t\t\t\tneighbour_cell->max_ival++;\n\t\t\t\tif(neighbour_cell->max_ival == 1)\n\t\t\t\t\tneighbour_cells_visited.push(neighbour_cell);\n\t\t\t}\n\t\t\tint value = 0;\n\t\t\twhile(!neighbour_cells_visited.is_empty()) {\n\t\t\t\tPartition::Cell* const neighbour_cell = neighbour_cells_visited.pop();\n\t\t\t\tif(neighbour_cell->max_ival != neighbour_cell->length)\n\t\t\t\t\tvalue++;\n\t\t\t\tneighbour_cell->max_ival = 0;\n\t\t\t}\n\t\t\tif((value > best_value) or (value == best_value and cell->length < best_size)) {\n\t\t\t\tbest_value = value;\n\t\t\t\tbest_size = cell->length;\n\t\t\t\tbest_cell = cell;\n\t\t\t}\n\t\t}\n\t\treturn best_cell;\n\t}\n\t// \\internal A splitting heuristic.\n\t// Returns the first largest nonsingleton cell with max number of neighbouring nonsingleton cells.\n\t// Assumes that the partition p is equitable. Assumes that the max_ival fields of the cells are all 0.\n\tPartition::Cell* sh_first_largest_max_neighbours() {\n\t\tPartition::Cell* best_cell = 0;\n\t\tint best_value = -1;\n\t\tunsigned int best_size = 0;\n\t\tKStack neighbour_cells_visited;\n\t\tneighbour_cells_visited.init(get_nof_vertices());\n\t\tfor(Partition::Cell* cell = p.first_nonsingleton_cell; cell; cell = cell->next_nonsingleton) {\n\t\t\tif(opt_use_comprec and p.cr_get_level(cell->first) != cr_level) continue;\n\t\t\tconst Vertex& v = vertices[p.elements[cell->first]];\n\t\t\tstd::vector::const_iterator ei = v.edges.begin();\n\t\t\tfor(unsigned int j = v.nof_edges(); j > 0; j--) {\n#ifdef USE_DOMAIN\n\t\t\t\tPartition::Cell* const neighbour_cell = p.get_cell((ei++)->first); // cxh\n#else\n\t\t\t\tPartition::Cell* const neighbour_cell = p.get_cell(*ei++);\n#endif\n\t\t\t\tif(neighbour_cell->is_unit()) continue;\n\t\t\t\tneighbour_cell->max_ival++;\n\t\t\t\tif(neighbour_cell->max_ival == 1)\n\t\t\t\t\tneighbour_cells_visited.push(neighbour_cell);\n\t\t\t}\n\t\t\tint value = 0;\n\t\t\twhile(!neighbour_cells_visited.is_empty()) {\n\t\t\t\tPartition::Cell* const neighbour_cell = neighbour_cells_visited.pop();\n\t\t\t\tif(neighbour_cell->max_ival != neighbour_cell->length) value++;\n\t\t\t\tneighbour_cell->max_ival = 0;\n\t\t\t}\n\t\t\tif((value > best_value) or (value == best_value and cell->length > best_size)) {\n\t\t\t\tbest_value = value;\n\t\t\t\tbest_size = cell->length;\n\t\t\t\tbest_cell = cell;\n\t\t\t}\n\t\t}\n\t\treturn best_cell;\n\t}\n\t//Initialize the certificate size and memory\n\tvoid initialize_certificate() {\n\t\tcertificate_index = 0;\n\t\tcertificate_current_path.clear();\n\t\tcertificate_first_path.clear();\n\t\tcertificate_best_path.clear();\n\t}\n\tbool is_automorphism(unsigned* const perm) {\n\t\tstd::set > edges1;\n\t\tstd::set > edges2;\n\n#if defined(BLISS_CONSISTENCY_CHECKS)\n\t\tif(!is_permutation(get_nof_vertices(), perm))\n\t\t\t_INTERNAL_ERROR();\n#endif\n\n\t\tfor(unsigned int i = 0; i < get_nof_vertices(); i++) {\n\t\t\tVertex& v1 = vertices[i];\n\t\t\tedges1.clear();\n\t\t\tfor(std::vector::iterator ei = v1.edges.begin(); ei != v1.edges.end(); ei++)\n#ifdef USE_DOMAIN\n\t\t\t\tedges1.insert(perm[ei->first]); // cxh\n#else\n\t\t\tedges1.insert(perm[*ei]);\n#endif\n\t\t\tVertex& v2 = vertices[perm[i]];\n\t\t\tedges2.clear();\n\t\t\tfor(std::vector::iterator ei = v2.edges.begin(); ei != v2.edges.end(); ei++)\n#ifdef USE_DOMAIN\n\t\t\t\tedges2.insert(ei->first); // cxh\n#else\n\t\t\tedges2.insert(*ei);\n#endif\n\t\t\tif(!(edges1 == edges2)) return false;\n\t\t}\n\t\treturn true;\n\t}\n\n\tbool nucr_find_first_component(const unsigned level) {\n\t\tcr_component.clear();\n\t\tcr_component_elements = 0;\n\t\t/* Find first non-discrete cell in the component level */\n\t\tPartition::Cell* first_cell = p.first_nonsingleton_cell;\n\t\twhile(first_cell) {\n\t\t\tif(p.cr_get_level(first_cell->first) == level) break;\n\t\t\tfirst_cell = first_cell->next_nonsingleton;\n\t\t}\n\t\t/* The component is discrete, return false */\n\t\tif(!first_cell) return false;\n\t\tstd::vector component;\n\t\tfirst_cell->max_ival = 1;\n\t\tcomponent.push_back(first_cell);\n\t\tfor(unsigned int i = 0; i < component.size(); i++) {\n\t\t\tPartition::Cell* const cell = component[i];\n\t\t\tconst Vertex& v = vertices[p.elements[cell->first]];\n\t\t\tstd::vector::const_iterator ei = v.edges.begin();\n\t\t\tfor(unsigned int j = v.nof_edges(); j > 0; j--) {\n#ifdef USE_DOMAIN\n\t\t\t\tconst unsigned int neighbour = (ei++)->first; // cxh\n#else\n\t\t\t\tconst unsigned int neighbour = *ei++;\n#endif \n\t\t\t\tPartition::Cell* const neighbour_cell = p.get_cell(neighbour);\n\t\t\t\t/* Skip unit neighbours */\n\t\t\t\tif(neighbour_cell->is_unit()) continue;\n\t\t\t\t/* Already marked to be in the same component? */\n\t\t\t\tif(neighbour_cell->max_ival == 1) continue;\n\t\t\t\t/* Is the neighbour at the same component recursion level? */\n\t\t\t\tif(p.cr_get_level(neighbour_cell->first) != level) continue;\n\t\t\t\tif(neighbour_cell->max_ival_count == 0)\n\t\t\t\t\tneighbour_heap.insert(neighbour_cell->first);\n\t\t\t\tneighbour_cell->max_ival_count++;\n\t\t\t}\n\t\t\twhile(!neighbour_heap.is_empty()) {\n\t\t\t\tconst unsigned int start = neighbour_heap.remove();\n\t\t\t\tPartition::Cell* const neighbour_cell =\n\t\t\t\t\tp.get_cell(p.elements[start]);\n\t\t\t\t/* Skip saturated neighbour cells */\n\t\t\t\tif(neighbour_cell->max_ival_count == neighbour_cell->length) {\n\t\t\t\t\tneighbour_cell->max_ival_count = 0;\n\t\t\t\t\tcontinue;\n\t\t\t\t} \n\t\t\t\tneighbour_cell->max_ival_count = 0;\n\t\t\t\tneighbour_cell->max_ival = 1;\n\t\t\t\tcomponent.push_back(neighbour_cell);\n\t\t\t}\n\t\t}\n\t\tfor(unsigned int i = 0; i < component.size(); i++) {\n\t\t\tPartition::Cell* const cell = component[i];\n\t\t\tcell->max_ival = 0;\n\t\t\tcr_component.push_back(cell->first);\n\t\t\tcr_component_elements += cell->length;\n\t\t}\n\t\tif(verbstr and verbose_level > 2) {\n\t\t\tfprintf(verbstr, \"NU-component with %lu cells and %u vertices\\n\",\n\t\t\t\t\t(long unsigned)cr_component.size(), cr_component_elements);\n\t\t\tfflush(verbstr);\n\t\t}\n\t\treturn true;\n\t}\n\tbool nucr_find_first_component(const unsigned int level, std::vector& component, unsigned int& component_elements, Partition::Cell*& sh_return) {\n\t\tcomponent.clear();\n\t\tcomponent_elements = 0;\n\t\tsh_return = 0;\n\t\tunsigned int sh_first = 0;\n\t\tunsigned int sh_size = 0;\n\t\tunsigned int sh_nuconn = 0;\n\n\t\t/* Find first non-discrete cell in the component level */\n\t\tPartition::Cell* first_cell = p.first_nonsingleton_cell;\n\t\twhile(first_cell) {\n\t\t\tif(p.cr_get_level(first_cell->first) == level) break;\n\t\t\tfirst_cell = first_cell->next_nonsingleton;\n\t\t}\n\t\tif(!first_cell) {\n\t\t\t/* The component is discrete, return false */\n\t\t\treturn false;\n\t\t}\n\t\tstd::vector comp;\n\t\tKStack neighbours;\n\t\tneighbours.init(get_nof_vertices());\n\t\tfirst_cell->max_ival = 1;\n\t\tcomp.push_back(first_cell);\n\t\tfor(unsigned int i = 0; i < comp.size(); i++) {\n\t\t\tPartition::Cell* const cell = comp[i];\n\t\t\tconst Vertex& v = vertices[p.elements[cell->first]];\n\t\t\tstd::vector::const_iterator ei = v.edges.begin();\n\t\t\tfor(unsigned int j = v.nof_edges(); j > 0; j--) {\n#ifdef USE_DOMAIN\n\t\t\t\tconst unsigned int neighbour = (ei++)->first; // cxh\n#else\n\t\t\t\tconst unsigned int neighbour = *ei++;\n#endif\n\t\t\t\tPartition::Cell* const neighbour_cell = p.get_cell(neighbour);\n\t\t\t\t/* Skip unit neighbours */\n\t\t\t\tif(neighbour_cell->is_unit()) continue;\n\t\t\t\t/* Is the neighbour at the same component recursion level? */\n\t\t\t\t//if(p.cr_get_level(neighbour_cell->first) != level)\n\t\t\t\t// continue;\n\t\t\t\tif(neighbour_cell->max_ival_count == 0)\n\t\t\t\t\tneighbours.push(neighbour_cell);\n\t\t\t\tneighbour_cell->max_ival_count++;\n\t\t\t}\n\t\t\tunsigned int nuconn = 1;\n\t\t\twhile(!neighbours.is_empty()) {\n\t\t\t\tPartition::Cell* const neighbour_cell = neighbours.pop();\n\t\t\t\t//neighbours.pop_back();\n\t\t\t\t/* Skip saturated neighbour cells */\n\t\t\t\tif(neighbour_cell->max_ival_count == neighbour_cell->length) {\n\t\t\t\t\tneighbour_cell->max_ival_count = 0;\n\t\t\t\t\tcontinue;\n\t\t\t\t}\n\t\t\t\tnuconn++;\n\t\t\t\tneighbour_cell->max_ival_count = 0;\n\t\t\t\tif(neighbour_cell->max_ival == 0) {\n\t\t\t\t\tcomp.push_back(neighbour_cell);\n\t\t\t\t\tneighbour_cell->max_ival = 1;\n\t\t\t\t}\n\t\t\t}\n\t\t\tswitch(sh) {\n\t\t\t\tcase shs_f:\n\t\t\t\t\tif(sh_return == 0 or cell->first <= sh_first) {\n\t\t\t\t\t\tsh_return = cell;\n\t\t\t\t\t\tsh_first = cell->first;\n\t\t\t\t\t}\n\t\t\t\t\tbreak;\n\t\t\t\tcase shs_fs:\n\t\t\t\t\tif(sh_return == 0 or cell->length < sh_size or\n\t\t\t\t\t\t\t(cell->length == sh_size and cell->first <= sh_first)) {\n\t\t\t\t\t\tsh_return = cell;\n\t\t\t\t\t\tsh_first = cell->first;\n\t\t\t\t\t\tsh_size = cell->length;\n\t\t\t\t\t}\n\t\t\t\t\tbreak;\n\t\t\t\tcase shs_fl:\n\t\t\t\t\tif(sh_return == 0 or cell->length > sh_size or\n\t\t\t\t\t\t\t(cell->length == sh_size and cell->first <= sh_first)) {\n\t\t\t\t\t\tsh_return = cell;\n\t\t\t\t\t\tsh_first = cell->first;\n\t\t\t\t\t\tsh_size = cell->length;\n\t\t\t\t\t}\n\t\t\t\t\tbreak;\n\t\t\t\tcase shs_fm:\n\t\t\t\t\tif(sh_return == 0 or nuconn > sh_nuconn or\n\t\t\t\t\t\t\t(nuconn == sh_nuconn and cell->first <= sh_first)) {\n\t\t\t\t\t\tsh_return = cell;\n\t\t\t\t\t\tsh_first = cell->first;\n\t\t\t\t\t\tsh_nuconn = nuconn;\n\t\t\t\t\t}\n\t\t\t\t\tbreak;\n\t\t\t\tcase shs_fsm:\n\t\t\t\t\tif(sh_return == 0 or\n\t\t\t\t\t\t\tnuconn > sh_nuconn or\n\t\t\t\t\t\t\t(nuconn == sh_nuconn and\n\t\t\t\t\t\t\t (cell->length < sh_size or\n\t\t\t\t\t\t\t (cell->length == sh_size and cell->first <= sh_first)))) {\n\t\t\t\t\t\tsh_return = cell;\n\t\t\t\t\t\tsh_first = cell->first;\n\t\t\t\t\t\tsh_size = cell->length;\n\t\t\t\t\t\tsh_nuconn = nuconn;\n\t\t\t\t\t}\n\t\t\t\t\tbreak;\n\t\t\t\tcase shs_flm:\n\t\t\t\t\tif(sh_return == 0 or\n\t\t\t\t\t\t\tnuconn > sh_nuconn or\n\t\t\t\t\t\t\t(nuconn == sh_nuconn and\n\t\t\t\t\t\t\t (cell->length > sh_size or\n\t\t\t\t\t\t\t (cell->length == sh_size and cell->first <= sh_first)))) {\n\t\t\t\t\t\tsh_return = cell;\n\t\t\t\t\t\tsh_first = cell->first;\n\t\t\t\t\t\tsh_size = cell->length;\n\t\t\t\t\t\tsh_nuconn = nuconn;\n\t\t\t\t\t}\n\t\t\t\t\tbreak;\n\t\t\t\tdefault:\n\t\t\t\t\tfatal_error(\"Internal error - unknown splitting heuristics\");\n\t\t\t\t\treturn 0;\n\t\t\t}\n\t\t}\n\t\tassert(sh_return);\n\t\tfor(unsigned int i = 0; i < comp.size(); i++) {\n\t\t\tPartition::Cell* const cell = comp[i];\n\t\t\tcell->max_ival = 0;\n\t\t\tcomponent.push_back(cell->first);\n\t\t\tcomponent_elements += cell->length;\n\t\t}\n\t\tif(verbstr and verbose_level > 2) {\n\t\t\tfprintf(verbstr, \"NU-component with %lu cells and %u vertices\\n\",\n\t\t\t\t\t(long unsigned)component.size(), component_elements);\n\t\t\tfflush(verbstr);\n\t\t}\n\t\treturn true;\n\t}\n\npublic:\n\t// Create a new graph with \\a N vertices and no edges.\n\tGraph(const unsigned nof_vertices = 0) {\n\t\tvertices.resize(nof_vertices);\n\t\tsh = shs_flm;\n\t}\n\n\t/**\n\t * Destroy the graph.\n\t */\n\t~Graph() { ; }\n\n\t/**\n\t * Read the graph from the file \\a fp in a variant of the DIMACS format.\n\t * See the bliss website\n\t * for the definition of the file format.\n\t * Note that in the DIMACS file the vertices are numbered from 1 to N while\n\t * in this C++ API they are from 0 to N-1.\n\t * Thus the vertex n in the file corresponds to the vertex n-1 in the API.\n\t *\n\t * \\param fp the file stream for the graph file\n\t * \\param errstr if non-null, the possible error messages are printed\n\t * in this file stream\n\t * \\return a new Graph object or 0 if reading failed for some\n\t * reason\n\t */\n\tstatic Graph* read_dimacs(FILE* const fp, FILE* const errstr = stderr) { return NULL; }\n\n\t/**\n\t * Write the graph to a file in a variant of the DIMACS format.\n\t * See the bliss website\n\t * for the definition of the file format.\n\t */\n\tvoid write_dimacs(FILE* const fp) {}\n\n\t// \\copydoc AbstractGraph::write_dot(FILE * const fp)\n\tvoid write_dot(FILE* const fp) {}\n\n\t// \\copydoc AbstractGraph::write_dot(const char * const file_name)\n\tvoid write_dot(const char* const file_name) {}\n\n\t// \\copydoc AbstractGraph::is_automorphism(const std::vector& perm) const\n\tbool is_automorphism(const std::vector& perm) const {\n\t\tif(!(perm.size() == get_nof_vertices() and is_permutation(perm)))\n\t\t\treturn false;\n\t\tstd::set > edges1;\n\t\tstd::set > edges2;\n\t\tfor(unsigned i = 0; i < get_nof_vertices(); i++) {\n\t\t\tconst Vertex& v1 = vertices[i];\n\t\t\tedges1.clear();\n\t\t\tfor(std::vector::const_iterator ei = v1.edges.begin(); ei != v1.edges.end(); ei++)\n#ifdef USE_DOMAIN\n\t\t\t\tedges1.insert(perm[ei->first]); // cxh\n#else\n\t\t\tedges1.insert(perm[*ei]);\n#endif\n\t\t\tconst Vertex& v2 = vertices[perm[i]];\n\t\t\tedges2.clear();\n\t\t\tfor(std::vector::const_iterator ei = v2.edges.begin(); ei != v2.edges.end(); ei++)\n#ifdef USE_DOMAIN\n\t\t\t\tedges2.insert(ei->first); // cxh\n#else\n\t\t\tedges2.insert(*ei);\n#endif\n\t\t\tif(!(edges1 == edges2)) return false;\n\t\t}\n\t\treturn true;\n\t}\n\t// \\copydoc AbstractGraph::get_hash()\n\tvirtual unsigned get_hash() {\n\t\tremove_duplicate_edges();\n\t\tsort_edges();\n\t\tUintSeqHash h;\n\t\th.update(get_nof_vertices());\n\t\t/* Hash the color of each vertex */\n\t\tfor(unsigned int i = 0; i < get_nof_vertices(); i++) {\n\t\t\th.update(vertices[i].color);\n\t\t}\n\t\t/* Hash the edges */\n\t\tfor(unsigned int i = 0; i < get_nof_vertices(); i++) {\n\t\t\tVertex &v = vertices[i];\n\t\t\tfor(std::vector::const_iterator ei = v.edges.begin(); ei != v.edges.end(); ei++) {\n#ifdef USE_DOMAIN\n\t\t\t\tconst unsigned int dest_i = ei->first; // cxh\n#else\n\t\t\t\tconst unsigned int dest_i = *ei;\n#endif\n\t\t\t\tif(dest_i < i) continue;\n\t\t\t\th.update(i);\n\t\t\t\th.update(dest_i);\n\t\t\t}\n\t\t}\n\t\treturn h.get_value();\n\t}\n\t// Return the number of vertices in the graph.\n\tunsigned int get_nof_vertices() const {return vertices.size(); }\n\n\t// \\copydoc AbstractGraph::permute(const unsigned int* const perm) const\n\tGraph* permute(const unsigned* perm) const {\n#if defined(BLISS_CONSISTENCY_CHECKS)\n\t\tif(!is_permutation(get_nof_vertices(), perm))\n\t\t\t_INTERNAL_ERROR();\n#endif\n\t\tGraph* const g = new Graph(get_nof_vertices());\n\t\tfor(unsigned i = 0; i < get_nof_vertices(); i++) {\n\t\t\tconst Vertex& v = vertices[i];\n\t\t\tVertex& permuted_v = g->vertices[perm[i]];\n\t\t\tpermuted_v.color = v.color;\n\t\t\tfor(std::vector::const_iterator ei = v.edges.begin(); ei != v.edges.end(); ei++) {\n#ifdef USE_DOMAIN\n\t\t\t\tconst unsigned dest_v = ei->first; //cxh\n\t\t\t\tpermuted_v.add_edge(perm[dest_v], ei->second);\n#else\n\t\t\t\tconst unsigned dest_v = *ei;\n\t\t\t\tpermuted_v.add_edge(perm[dest_v]);\n#endif\n\t\t\t}\n\t\t\tpermuted_v.sort_edges();\n\t\t}\n\t\treturn g;\n\t}\n\tGraph* permute(const std::vector& perm) const {\n#if defined(BLISS_CONSISTENCY_CHECKS)\n#endif\n\t\tGraph* const g = new Graph(get_nof_vertices());\n\t\tfor(unsigned int i = 0; i < get_nof_vertices(); i++) {\n\t\t\tconst Vertex& v = vertices[i];\n\t\t\tVertex& permuted_v = g->vertices[perm[i]];\n\t\t\tpermuted_v.color = v.color;\n\t\t\tfor(std::vector::const_iterator ei = v.edges.begin(); ei != v.edges.end(); ei++) {\n#ifdef USE_DOMAIN\n\t\t\t\tconst unsigned dest_v = ei->first; // cxh\n\t\t\t\tpermuted_v.add_edge(perm[dest_v], ei->second);\n#else\n\t\t\t\tconst unsigned dest_v = *ei;\n\t\t\t\tpermuted_v.add_edge(perm[dest_v]);\n#endif\n\t\t\t}\n\t\t\tpermuted_v.sort_edges();\n\t\t}\n\t\treturn g;\n\t}\n\t// Add a new vertex with color \\a color in the graph and return its index.\n\tunsigned add_vertex(const unsigned color = 0) {\n\t\tconst unsigned int vertex_num = vertices.size();\n\t\tvertices.resize(vertex_num + 1);\n\t\tvertices.back().color = color;\n\t\treturn vertex_num;\n\t}\n\t/**\n\t * Add an edge between vertices \\a v1 and \\a v2.\n\t * Duplicate edges between vertices are ignored but try to avoid introducing\n\t * them in the first place as they are not ignored immediately but will\n\t * consume memory and computation resources for a while.\n\t */\n\tvoid add_edge(const unsigned vertex1, const unsigned vertex2, Index index) {\n\t\t//printf(\"Adding edge (%u -> %u)\\n\", vertex1, vertex2);\n#ifdef USE_DOMAIN\n\t\tvertices[vertex1].add_edge(vertex2, index);\n\t\tvertices[vertex2].add_edge(vertex1, std::make_pair(index.second, index.first));\n#else\n\t\tvertices[vertex1].add_edge(vertex2);\n\t\tvertices[vertex2].add_edge(vertex1);\n#endif\n\t}\n\t// Change the color of the vertex \\a vertex to \\a color.\n\tvoid change_color(const unsigned vertex, const unsigned color) {\n\t\tvertices[vertex].color = color;\n\t}\n\n\t/**\n\t * Compare this graph with the graph \\a other.\n\t * Returns 0 if the graphs are equal, and a negative (positive) integer\n\t * if this graph is \"smaller than\" (\"greater than\", resp.) than \\a other.\n\t */\n\tint cmp(Graph& other) {\n\t\t/* Compare the numbers of vertices */\n\t\tif(get_nof_vertices() < other.get_nof_vertices())\n\t\t\treturn -1;\n\t\tif(get_nof_vertices() > other.get_nof_vertices())\n\t\t\treturn 1;\n\t\t/* Compare vertex colors */\n\t\tfor(unsigned i = 0; i < get_nof_vertices(); i++) {\n\t\t\tif(vertices[i].color < other.vertices[i].color)\n\t\t\t\treturn -1;\n\t\t\tif(vertices[i].color > other.vertices[i].color)\n\t\t\t\treturn 1;\n\t\t}\n\t\t/* Compare vertex degrees */\n\t\tremove_duplicate_edges();\n\t\tother.remove_duplicate_edges();\n\t\tfor(unsigned i = 0; i < get_nof_vertices(); i++) {\n\t\t\tif(vertices[i].nof_edges() < other.vertices[i].nof_edges())\n\t\t\t\treturn -1;\n\t\t\tif(vertices[i].nof_edges() > other.vertices[i].nof_edges())\n\t\t\t\treturn 1;\n\t\t}\n\t\t/* Compare edges */\n\t\tfor(unsigned i = 0; i < get_nof_vertices(); i++) {\n\t\t\tVertex &v1 = vertices[i];\n\t\t\tVertex &v2 = other.vertices[i];\n\t\t\tv1.sort_edges();\n\t\t\tv2.sort_edges();\n\t\t\tstd::vector::const_iterator ei1 = v1.edges.begin();\n\t\t\tstd::vector::const_iterator ei2 = v2.edges.begin();\n\t\t\twhile(ei1 != v1.edges.end()) {\n#ifdef USE_DOMAIN\n\t\t\t\tif(ei1->first < ei2->first) return -1; // cxh\n\t\t\t\tif(ei1->first > ei2->first) return 1; // cxh\n#else\n\t\t\t\tif(*ei1 < *ei2) return -1;\n\t\t\t\tif(*ei1 > *ei2) return 1;\n#endif\n\t\t\t\tei1++;\n\t\t\t\tei2++;\n\t\t\t}\n\t\t}\n\t\treturn 0;\n\t}\n\t/**\n\t * Set the splitting heuristic used by the automorphism and canonical\n\t * labeling algorithm.\n\t * The selected splitting heuristics affects the computed canonical\n\t * labelings; therefore, if you want to compare whether two graphs\n\t * are isomorphic by computing and comparing (for equality) their\n\t * canonical versions, be sure to use the same splitting heuristics\n\t * for both graphs.\n\t */\n\tvoid set_splitting_heuristic(const SplittingHeuristic shs) {sh = shs; }\n};\n\n}\n\n#endif\n" }, { "path": "external/bliss/bliss/heap.hh", "content": "#ifndef BLISS_HEAP_HH\n#define BLISS_HEAP_HH\n#include \n#include \n#include \nnamespace bliss {\n/** \\internal\n * \\brief A capacity bounded heap data structure.\n */\nclass Heap {\n\tunsigned int N;\n\tunsigned int n;\n\tunsigned int *array;\n\t//void upheap(unsigned int k);\n\tvoid upheap(unsigned int index) {\n\t\tconst unsigned int v = array[index];\n\t\tarray[0] = 0;\n\t\twhile(array[index/2] > v) {\n\t\t\tarray[index] = array[index/2];\n\t\t\tindex = index/2;\n\t\t}\n\t\tarray[index] = v;\n\t}\n\t//void downheap(unsigned int k);\n\tvoid downheap(unsigned int index) {\n\t\tconst unsigned int v = array[index];\n\t\tconst unsigned int lim = n/2;\n\t\twhile(index <= lim) {\n\t\t\tunsigned int new_index = index + index;\n\t\t\tif((new_index < n) and (array[new_index] > array[new_index+1]))\n\t\t\t\tnew_index++;\n\t\t\tif(v <= array[new_index])\n\t\t\t\tbreak;\n\t\t\tarray[index] = array[new_index];\n\t\t\tindex = new_index;\n\t\t}\n\t\tarray[index] = v;\n\t}\n\npublic:\n\t/**\n\t * Create a new heap.\n\t * init() must be called after this.\n\t */\n\tHeap() {array = 0; n = 0; N = 0; }\n\t~Heap() {\n\t\tif(array) {\n\t\t\tfree(array);\n\t\t\tarray = 0;\n\t\t\tn = 0;\n\t\t\tN = 0;\n\t\t}\n\t}\n\t/**\n\t * Initialize the heap to have the capacity to hold \\e size elements.\n\t */\n\t//void init(const unsigned int size);\n\tvoid init(const unsigned int size) {\n\t\tif(size > N) {\n\t\t\tif(array) free(array);\n\t\t\tarray = (unsigned int*)malloc((size + 1) * sizeof(unsigned int));\n\t\t\tN = size;\n\t\t}\n\t}\n\t/**\n\t * Is the heap empty?\n\t * Time complexity is O(1).\n\t */\n\tbool is_empty() const { return (n==0); }\n\n\t/**\n\t * Remove all the elements in the heap.\n\t * Time complexity is O(1).\n\t */\n\tvoid clear() { n = 0; }\n\n\t/**\n\t * Insert the element \\a e in the heap.\n\t * Time complexity is O(log(N)), where N is the number of elements\n\t * currently in the heap.\n\t */\n\t//void insert(const unsigned int e);\n\tvoid insert(const unsigned int v) {\n\t\tarray[++n] = v;\n\t\tupheap(n);\n\t}\n\n\t/**\n\t * Remove and return the smallest element in the heap.\n\t * Time complexity is O(log(N)), where N is the number of elements\n\t * currently in the heap.\n\t */\n\t//unsigned int remove();\n\tunsigned int remove() {\n\t\tconst unsigned int v = array[1];\n\t\tarray[1] = array[n--];\n\t\tdownheap(1);\n\t\treturn v;\n\t}\n\n\t/**\n\t * Get the number of elements in the heap.\n\t */\n\tunsigned int size() const {return n; }\n\n};\n} // namespace bliss\n\n#endif\n" }, { "path": "external/bliss/bliss/kqueue.hh", "content": "#ifndef BLISS_KQUEUE_HH\n#define BLISS_KQUEUE_HH\n\n/*\n Copyright (c) 2003-2015 Tommi Junttila\n Released under the GNU Lesser General Public License version 3.\n \n This file is part of bliss.\n \n bliss is free software: you can redistribute it and/or modify\n it under the terms of the GNU Lesser General Public License as published by\n the Free Software Foundation, version 3 of the License.\n\n bliss is distributed in the hope that it will be useful,\n but WITHOUT ANY WARRANTY; without even the implied warranty of\n MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n GNU Lesser General Public License for more details.\n\n You should have received a copy of the GNU Lesser General Public License\n along with bliss. If not, see .\n*/\n\n#include \"defs.hh\"\n\nnamespace bliss {\n\n/** \\internal\n * \\brief A very simple implementation of queues with fixed capacity.\n */\n\ntemplate \nclass KQueue\n{\npublic:\n /**\n * Create a new queue with capacity zero.\n * The function init() should be called next.\n */\n KQueue();\n\n ~KQueue();\n\n /**\n * Initialize the queue to have the capacity to hold at most \\a N elements.\n */\n void init(const unsigned int N);\n \n /** Is the queue empty? */\n bool is_empty() const;\n\n /** Return the number of elements in the queue. */\n unsigned int size() const;\n\n /** Remove all the elements in the queue. */\n void clear();\n\n /** Return (but don't remove) the first element in the queue. */\n Type front() const;\n\n /** Remove and return the first element of the queue. */\n Type pop_front();\n\n /** Push the element \\a e in the front of the queue. */\n void push_front(Type e);\n\n /** Remove and return the last element of the queue. */\n Type pop_back();\n\n /** Push the element \\a e in the back of the queue. */\n void push_back(Type e);\nprivate:\n Type *entries, *end;\n Type *head, *tail;\n};\n\ntemplate \nKQueue::KQueue()\n{\n entries = 0;\n end = 0;\n head = 0;\n tail = 0;\n}\n\ntemplate \nKQueue::~KQueue()\n{\n if(entries)\n free(entries);\n}\n\ntemplate \nvoid KQueue::init(const unsigned int k)\n{\n assert(k > 0);\n if(entries)\n free(entries);\n entries = (Type*)malloc((k + 1) * sizeof(Type));\n end = entries + k + 1;\n head = entries;\n tail = head;\n}\n\ntemplate \nvoid KQueue::clear()\n{\n head = entries;\n tail = head;\n}\n\ntemplate \nbool KQueue::is_empty() const\n{\n return(head == tail);\n}\n\ntemplate \nunsigned int KQueue::size() const\n{\n if(tail >= head)\n return(tail - head);\n return((end - head) + (tail - entries));\n}\n\ntemplate \nType KQueue::front() const\n{\n return *head;\n}\n\ntemplate \nType KQueue::pop_front()\n{\n Type *old_head = head;\n head++;\n if(head == end)\n head = entries;\n return *old_head;\n}\n\ntemplate \nvoid KQueue::push_front(Type e)\n{\n if(head == entries)\n head = end - 1;\n else\n head--;\n *head = e;\n}\n\ntemplate \nvoid KQueue::push_back(Type e)\n{\n *tail = e;\n tail++;\n if(tail == end)\n tail = entries;\n}\n\n} // namespace bliss\n\n#endif\n" }, { "path": "external/bliss/bliss/kstack.hh", "content": "#ifndef BLISS_KSTACK_H\n#define BLISS_KSTACK_H\n\n/*\n Copyright (c) 2003-2015 Tommi Junttila\n Released under the GNU Lesser General Public License version 3.\n \n This file is part of bliss.\n \n bliss is free software: you can redistribute it and/or modify\n it under the terms of the GNU Lesser General Public License as published by\n the Free Software Foundation, version 3 of the License.\n\n bliss is distributed in the hope that it will be useful,\n but WITHOUT ANY WARRANTY; without even the implied warranty of\n MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n GNU Lesser General Public License for more details.\n\n You should have received a copy of the GNU Lesser General Public License\n along with bliss. If not, see .\n*/\n\n#include \n#include \"defs.hh\"\n\nnamespace bliss {\n\n/** \\internal\n * \\brief A very simple implementation of a stack with fixed capacity.\n */\ntemplate \nclass KStack {\npublic:\n /**\n * Create a new stack with zero capacity.\n * The function init() should be called next.\n */\n KStack();\n\n /**\n * Create a new stack with the capacity to hold at most \\a N elements.\n */\n KStack(int N);\n\n ~KStack();\n\n /**\n * Initialize the stack to have the capacity to hold at most \\a N elements.\n */\n void init(int N);\n\n /**\n * Is the stack empty?\n */\n bool is_empty() const {return(cursor == entries); }\n\n /**\n * Return (but don't remove) the top element of the stack.\n */\n Type top() const {BLISS_ASSERT(cursor > entries); return *cursor; }\n\n /**\n * Pop (remove) the top element of the stack.\n */\n Type pop()\n {\n return *cursor--;\n }\n\n /**\n * Push the element \\a e in the stack.\n */\n void push(Type e)\n {\n *(++cursor) = e;\n }\n\n /** Remove all the elements in the stack. */\n void clean() {cursor = entries; }\n\n /**\n * Get the number of elements in the stack.\n */\n unsigned int size() const {return(cursor - entries); }\n\n /**\n * Return the i:th element in the stack, where \\a i is in the range\n * 0,...,this.size()-1; the 0:th element is the bottom element\n * in the stack.\n */\n Type element_at(unsigned int i)\n {\n assert(i < size());\n return entries[i+1];\n }\n\n /** Return the capacity (NOT the number of elements) of the stack. */\n int capacity() {return kapacity; }\nprivate:\n int kapacity;\n Type *entries;\n Type *cursor;\n};\n\ntemplate \nKStack::KStack()\n{\n kapacity = 0;\n entries = 0;\n cursor = 0;\n}\n\ntemplate \nKStack::KStack(int k)\n{\n assert(k > 0);\n kapacity = k;\n entries = (Type*)malloc((k+1) * sizeof(Type));\n cursor = entries;\n}\n\ntemplate \nvoid KStack::init(int k)\n{\n assert(k > 0);\n if(entries)\n free(entries);\n kapacity = k;\n entries = (Type*)malloc((k+1) * sizeof(Type));\n cursor = entries;\n}\n\ntemplate \nKStack::~KStack()\n{\n free(entries);\n}\n\n} // namespace bliss\n\n#endif\n" }, { "path": "external/bliss/bliss/orbit.hh", "content": "#ifndef BLISS_ORBIT_HH\n#define BLISS_ORBIT_HH\n\nnamespace bliss {\nclass Orbit {\n\tclass OrbitEntry {\n\t\tpublic:\n\t\t\tunsigned int element;\n\t\t\tOrbitEntry *next;\n\t\t\tunsigned int size;\n\t};\n\tOrbitEntry *orbits;\n\tOrbitEntry **in_orbit;\n\tunsigned int nof_elements;\n\tunsigned int _nof_orbits;\n\tvoid merge_orbits(OrbitEntry *orbit1, OrbitEntry *orbit2) {\n\t\tif(orbit1 != orbit2) {\n\t\t\t_nof_orbits--;\n\t\t\t// Only update the elements in the smaller orbit\n\t\t\tif(orbit1->size > orbit2->size) {\n\t\t\t\tOrbitEntry * const temp = orbit2;\n\t\t\t\torbit2 = orbit1;\n\t\t\t\torbit1 = temp;\n\t\t\t}\n\t\t\t// Link the elements of orbit1 to the almost beginning of orbit2\n\t\t\tOrbitEntry *e = orbit1;\n\t\t\twhile(e->next) {\n\t\t\t\tin_orbit[e->element] = orbit2;\n\t\t\t\te = e->next;\n\t\t\t}\n\t\t\tin_orbit[e->element] = orbit2;\n\t\t\te->next = orbit2->next;\n\t\t\torbit2->next = orbit1;\n\t\t\t// Keep the minimal orbit representative in the beginning\n\t\t\tif(orbit1->element < orbit2->element) {\n\t\t\t\tconst unsigned int temp = orbit1->element;\n\t\t\t\torbit1->element = orbit2->element;\n\t\t\t\torbit2->element = temp;\n\t\t\t}\n\t\t\torbit2->size += orbit1->size;\n\t\t}\n\t}\n\n\tpublic:\n\t// Create a new orbit information object.\n\t// The init() function must be called next to actually initialize the object.\n\tOrbit() {\n\t\torbits = 0;\n\t\tin_orbit = 0;\n\t\tnof_elements = 0;\n\t}\n\t~Orbit() {\n\t\tif(orbits) {\n\t\t\tfree(orbits);\n\t\t\torbits = 0;\n\t\t}\n\t\tif(in_orbit) {\n\t\t\tfree(in_orbit);\n\t\t\tin_orbit = 0;\n\t\t}\n\t\tnof_elements = 0;\n\t}\n\n\t// Initialize the orbit information to consider sets of \\a N elements.\n\t// It is required that \\a N > 0.\n\t// The orbit information is reset so that each element forms an orbit of its own.\n\t// Time complexity is O(N). \\sa reset()\n\tvoid init(const unsigned int n) {\n\t\tassert(n > 0);\n\t\tif(orbits) free(orbits);\n\t\torbits = (OrbitEntry*)malloc(n * sizeof(OrbitEntry));\n\t\tif(in_orbit) free(in_orbit);\n\t\tin_orbit = (OrbitEntry**)malloc(n * sizeof(OrbitEntry*));\n\t\tnof_elements = n;\n\t\treset();\n\t}\n\n\t// Reset the orbits so that each element forms an orbit of its own.\n\t// Time complexity is O(N).\n\tvoid reset() {\n\t\tassert(orbits);\n\t\tassert(in_orbit);\n\t\tfor(unsigned int i = 0; i < nof_elements; i++) {\n\t\t\torbits[i].element = i;\n\t\t\torbits[i].next = 0;\n\t\t\torbits[i].size = 1;\n\t\t\tin_orbit[i] = &orbits[i];\n\t\t}\n\t\t_nof_orbits = nof_elements;\n\t}\n\n\t// Merge the orbits of the elements \\a e1 and \\a e2.\n\t// Time complexity is O(k), where k is the number of elements in\n\t// the smaller of the merged orbits.\n\tvoid merge_orbits(unsigned int e1, unsigned int e2) {\n\t\tmerge_orbits(in_orbit[e1], in_orbit[e2]);\n\t}\n\n\t// Is the element \\a e the smallest element in its orbit?\n\t// Time complexity is O(1).\n\tbool is_minimal_representative(unsigned element) const {\n\t\treturn(get_minimal_representative(element) == element);\n\t}\n\t/// Get the smallest element in the orbit of the element \\a e.\n\t// Time complexity is O(1).\n\tunsigned get_minimal_representative(unsigned element) const {\n\t\tOrbitEntry * const orbit = in_orbit[element];\n\t\treturn(orbit->element);\n\t}\n\t// Get the number of elements in the orbit of the element \\a e.\n\t// Time complexity is O(1).\n\n\tunsigned orbit_size(unsigned element) const {\n\t\treturn(in_orbit[element]->size);\n\t}\n\t// Get the number of orbits.\n\t// Time complexity is O(1).\n\tunsigned int nof_orbits() const {return _nof_orbits; }\n};\n\n} // namespace bliss\n\n#endif\n" }, { "path": "external/bliss/bliss/partition.hh", "content": "#ifndef BLISS_PARTITION_HH\n#define BLISS_PARTITION_HH\n\n/*\n Copyright (c) 2003-2015 Tommi Junttila\n Released under the GNU Lesser General Public License version 3.\n \n This file is part of bliss.\n \n bliss is free software: you can redistribute it and/or modify\n it under the terms of the GNU Lesser General Public License as published by\n the Free Software Foundation, version 3 of the License.\n\n bliss is distributed in the hope that it will be useful,\n but WITHOUT ANY WARRANTY; without even the implied warranty of\n MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n GNU Lesser General Public License for more details.\n\n You should have received a copy of the GNU Lesser General Public License\n along with bliss. If not, see .\n*/\n\nnamespace bliss {\n class Partition;\n}\n\n#include \n#include \n#include \n#include \n#include \"kstack.hh\"\n#include \"kqueue.hh\"\n#include \"heap.hh\"\n#include \"orbit.hh\"\n#include \"abgraph.hh\"\n#include \"graph.hh\"\n\nnamespace bliss {\n\n/** \\internal\n * \\brief A class for refinable, backtrackable ordered partitions.\n *\n * This is rather a data structure with some helper functions than\n * a proper self-contained class.\n * That is, for efficiency reasons the fields of this class are directly\n * manipulated from bliss::AbstractGraph and its subclasses.\n * Conversely, some methods of this class modify the fields of\n * bliss::AbstractGraph, too.\n */\nclass Partition\n{\npublic:\n /**\n * \\brief Data structure for holding information about a cell in a Partition.\n */\n class Cell\n {\n friend class Partition;\n public:\n unsigned int length;\n // Index of the first element of the cell in the Partition::elements array\n unsigned int first;\n unsigned int max_ival;\n unsigned int max_ival_count;\n private:\n bool in_splitting_queue;\n public:\n bool in_neighbour_heap;\n /* Pointer to the next cell, null if this is the last one. */\n Cell* next;\n Cell* prev;\n Cell* next_nonsingleton;\n Cell* prev_nonsingleton;\n unsigned int split_level;\n /** Is this a unit cell? */\n bool is_unit() const {return(length == 1); }\n /** Is this cell in splitting queue? */\n bool is_in_splitting_queue() const {return(in_splitting_queue); }\n };\n\n\nprivate:\n\n /** \\internal\n * Data structure for remembering information about splits in order to\n * perform efficient backtracking over the splits.\n */\n class RefInfo {\n public:\n unsigned int split_cell_first;\n int prev_nonsingleton_first;\n int next_nonsingleton_first;\n };\n /** \\internal\n * A stack for remembering the splits, used for backtracking.\n */\n KStack refinement_stack;\n\n class BacktrackInfo {\n public:\n BacktrackInfo() : refinement_stack_size(0), cr_backtrack_point(0) {}\n unsigned int refinement_stack_size;\n unsigned int cr_backtrack_point;\n };\n\n /** \\internal\n * The main stack for enabling backtracking.\n */\n std::vector bt_stack;\n\npublic:\n AbstractGraph* graph;\n\n /* Used during equitable partition refinement */\n KQueue splitting_queue;\n //void splitting_queue_add(Cell* const cell);\n Cell* splitting_queue_pop();\n bool splitting_queue_is_empty() const;\n //void splitting_queue_clear();\n\nvoid splitting_queue_add(Cell* const cell) {\n static const unsigned int smallish_cell_threshold = 1;\n cell->in_splitting_queue = true;\n if(cell->length <= smallish_cell_threshold)\n splitting_queue.push_front(cell);\n else\n splitting_queue.push_back(cell); \n}\n\nvoid splitting_queue_clear() {\n while(!splitting_queue_is_empty())\n splitting_queue_pop();\n}\n\n /** Type for backtracking points. */\n typedef unsigned int BacktrackPoint;\n\n /**\n * Get a new backtrack point for the current partition\n */\n //BacktrackPoint set_backtrack_point();\nBacktrackPoint set_backtrack_point() {\n BacktrackInfo info;\n info.refinement_stack_size = refinement_stack.size();\n if(cr_enabled)\n info.cr_backtrack_point = cr_get_backtrack_point();\n BacktrackPoint p = bt_stack.size();\n bt_stack.push_back(info);\n return p;\n}\n\n /**\n * Backtrack to the point \\a p and remove it.\n */\n //void goto_backtrack_point(BacktrackPoint p);\nvoid goto_backtrack_point(BacktrackPoint p) {\n BacktrackInfo info = bt_stack[p];\n bt_stack.resize(p);\n if(cr_enabled)\n cr_goto_backtrack_point(info.cr_backtrack_point);\n const unsigned int dest_refinement_stack_size = info.refinement_stack_size;\n assert(refinement_stack.size() >= dest_refinement_stack_size);\n while(refinement_stack.size() > dest_refinement_stack_size) {\n RefInfo i = refinement_stack.pop();\n const unsigned int first = i.split_cell_first;\n Cell* cell = get_cell(elements[first]);\n if(cell->first != first) {\n\t assert(cell->first < first);\n\t assert(cell->split_level <= dest_refinement_stack_size);\n\t goto done;\n\t}\n assert(cell->split_level > dest_refinement_stack_size);\n while(cell->split_level > dest_refinement_stack_size) {\n\t assert(cell->prev);\n\t cell = cell->prev;\n\t}\n while(cell->next and cell->next->split_level > dest_refinement_stack_size) {\n\t /* Merge next cell */\n\t Cell* const next_cell = cell->next;\n\t if(cell->length == 1)\n\t discrete_cell_count--;\n\t if(next_cell->length == 1)\n\t discrete_cell_count--;\n\t /* Update element_to_cell_map values of elements added in cell */\n\t unsigned int* ep = elements + next_cell->first;\n\t unsigned int* const lp = ep + next_cell->length;\n\t for( ; ep < lp; ep++)\n\t element_to_cell_map[*ep] = cell;\n\t /* Update cell parameters */\n\t cell->length += next_cell->length;\n\t if(next_cell->next)\n\t next_cell->next->prev = cell;\n\t cell->next = next_cell->next;\n\t /* (Pseudo)free next_cell */\n\t next_cell->first = 0;\n\t next_cell->length = 0;\n\t next_cell->prev = 0;\n\t next_cell->next = free_cells;\n\t free_cells = next_cell;\n\t}\n\n done:\n if(i.prev_nonsingleton_first >= 0) {\n\t Cell* const prev_cell = get_cell(elements[i.prev_nonsingleton_first]);\n\t cell->prev_nonsingleton = prev_cell;\n\t prev_cell->next_nonsingleton = cell;\n\t} else {\n\t //assert(cell->prev_nonsingleton == 0);\n\t cell->prev_nonsingleton = 0;\n\t first_nonsingleton_cell = cell;\n\t}\n\n if(i.next_nonsingleton_first >= 0) {\n\t Cell* const next_cell = get_cell(elements[i.next_nonsingleton_first]);\n\t cell->next_nonsingleton = next_cell;\n\t next_cell->prev_nonsingleton = cell;\n\t} else {\n\t //assert(cell->next_nonsingleton == 0);\n\t cell->next_nonsingleton = 0;\n\t}\n }\n}\n /**\n * Split the non-unit Cell \\a cell = {\\a element,e1,e2,...,en} containing\n * the element \\a element in two:\n * \\a cell = {e1,...,en} and \\a newcell = {\\a element}.\n * @param cell a non-unit Cell\n * @param element an element in \\a cell\n * @return the new unit Cell \\a newcell\n */\n //Cell* individualize(Cell* const cell, const unsigned int element);\nCell* individualize(Cell * const cell, const unsigned int element) {\n unsigned int * const pos = in_pos[element];\n const unsigned int last = cell->first + cell->length - 1;\n *pos = elements[last];\n in_pos[*pos] = pos;\n elements[last] = element;\n in_pos[element] = elements + last;\n Partition::Cell * const new_cell = aux_split_in_two(cell, cell->length-1);\n element_to_cell_map[element] = new_cell;\n return new_cell;\n}\n\n //Cell* aux_split_in_two(Cell* const cell, const unsigned int first_half_size);\nCell* aux_split_in_two(Cell* const cell, const unsigned int first_half_size) {\n RefInfo i;\n /* (Pseudo)allocate new cell */\n Cell * const new_cell = free_cells;\n free_cells = new_cell->next;\n /* Update new cell parameters */\n new_cell->first = cell->first + first_half_size;\n new_cell->length = cell->length - first_half_size;\n new_cell->next = cell->next;\n if(new_cell->next)\n new_cell->next->prev = new_cell;\n new_cell->prev = cell;\n new_cell->split_level = refinement_stack.size()+1;\n /* Update old, splitted cell parameters */\n cell->length = first_half_size;\n cell->next = new_cell;\n /* CR */\n if(cr_enabled)\n cr_create_at_level_trailed(new_cell->first, cr_get_level(cell->first));\n\n /* Add cell in refinement_stack for backtracking */\n i.split_cell_first = new_cell->first;\n if(cell->prev_nonsingleton)\n i.prev_nonsingleton_first = cell->prev_nonsingleton->first;\n else\n i.prev_nonsingleton_first = -1;\n if(cell->next_nonsingleton)\n i.next_nonsingleton_first = cell->next_nonsingleton->first;\n else\n i.next_nonsingleton_first = -1;\n refinement_stack.push(i);\n\n /* Modify nonsingleton cell list */\n if(new_cell->length > 1)\n {\n new_cell->prev_nonsingleton = cell;\n new_cell->next_nonsingleton = cell->next_nonsingleton;\n if(new_cell->next_nonsingleton)\n\tnew_cell->next_nonsingleton->prev_nonsingleton = new_cell;\n cell->next_nonsingleton = new_cell;\n }\n else\n {\n new_cell->next_nonsingleton = 0;\n new_cell->prev_nonsingleton = 0;\n discrete_cell_count++;\n }\n\n if(cell->is_unit())\n {\n if(cell->prev_nonsingleton)\n\tcell->prev_nonsingleton->next_nonsingleton = cell->next_nonsingleton;\n else\n\tfirst_nonsingleton_cell = cell->next_nonsingleton;\n if(cell->next_nonsingleton)\n\tcell->next_nonsingleton->prev_nonsingleton = cell->prev_nonsingleton;\n cell->next_nonsingleton = 0;\n cell->prev_nonsingleton = 0;\n discrete_cell_count++;\n }\n\n return new_cell;\n} \n\nprivate:\n unsigned int N;\n Cell* cells;\n Cell* free_cells;\n unsigned int discrete_cell_count;\npublic:\n Cell* first_cell;\n Cell* first_nonsingleton_cell;\n unsigned int *elements;\n /* invariant_values[e] gives the invariant value of the element e */\n unsigned int *invariant_values;\n /* element_to_cell_map[e] gives the cell of the element e */\n Cell **element_to_cell_map;\n /** Get the cell of the element \\a e */\n Cell* get_cell(const unsigned int e) const {\n return element_to_cell_map[e];\n }\n /* in_pos[e] points to the elements array s.t. *in_pos[e] = e */\n unsigned int **in_pos;\n\n //Partition();\n //~Partition();\nPartition() {\n N = 0;\n elements = 0;\n in_pos = 0;\n invariant_values = 0;\n cells = 0;\n free_cells = 0;\n element_to_cell_map = 0;\n graph = 0;\n discrete_cell_count = 0;\n /* Initialize a distribution count sorting array. */\n for(unsigned int i = 0; i < 256; i++)\n dcs_count[i] = 0;\n\n cr_enabled = false;\n cr_cells = 0;\n cr_levels = 0;\n}\n\n~Partition() {\n if(elements) {free(elements); elements = 0; }\n if(cells) {free(cells); cells = 0; }\n if(element_to_cell_map) {free(element_to_cell_map); element_to_cell_map = 0; }\n if(in_pos) {free(in_pos); in_pos = 0; }\n if(invariant_values) {free(invariant_values); invariant_values = 0; }\n N = 0;\n}\n\n /**\n * Initialize the partition to the unit partition (all elements in one cell)\n * over the \\a N > 0 elements {0,...,\\a N-1}.\n */\n //void init(const unsigned int N);\nvoid init(const unsigned int M) {\n assert(M > 0);\n N = M;\n\n if(elements)\n free(elements);\n elements = (unsigned int*)malloc(N * sizeof(unsigned int));\n for(unsigned int i = 0; i < N; i++)\n elements[i] = i;\n\n if(in_pos)\n free(in_pos);\n in_pos = (unsigned int**)malloc(N * sizeof(unsigned int*));\n for(unsigned int i = 0; i < N; i++)\n in_pos[i] = elements + i;\n\n if(invariant_values)\n free(invariant_values);\n invariant_values = (unsigned int*)malloc(N * sizeof(unsigned int));\n for(unsigned int i = 0; i < N; i++)\n invariant_values[i] = 0;\n\n if(cells)\n free(cells);\n cells = (Cell*)malloc(N * sizeof(Cell));\n\n cells[0].first = 0;\n cells[0].length = N;\n cells[0].max_ival = 0;\n cells[0].max_ival_count = 0;\n cells[0].in_splitting_queue = false;\n cells[0].in_neighbour_heap = false;\n cells[0].prev = 0;\n cells[0].next = 0;\n cells[0].next_nonsingleton = 0;\n cells[0].prev_nonsingleton = 0;\n cells[0].split_level = 0;\n first_cell = &cells[0];\n if(N == 1)\n {\n first_nonsingleton_cell = 0;\n discrete_cell_count = 1;\n }\n else\n {\n first_nonsingleton_cell = &cells[0];\n discrete_cell_count = 0;\n }\n\n for(unsigned int i = 1; i < N; i++)\n {\n cells[i].first = 0;\n cells[i].length = 0;\n cells[i].max_ival = 0;\n cells[i].max_ival_count = 0;\n cells[i].in_splitting_queue = false;\n cells[i].in_neighbour_heap = false;\n cells[i].prev = 0;\n cells[i].next = (i < N-1)?&cells[i+1]:0;\n cells[i].next_nonsingleton = 0;\n cells[i].prev_nonsingleton = 0;\n }\n if(N > 1)\n free_cells = &cells[1];\n else\n free_cells = 0;\n\n if(element_to_cell_map)\n free(element_to_cell_map);\n element_to_cell_map = (Cell **)malloc(N * sizeof(Cell *));\n for(unsigned int i = 0; i < N; i++)\n element_to_cell_map[i] = first_cell;\n\n splitting_queue.init(N);\n refinement_stack.init(N);\n\n /* Reset the main backtracking stack */\n bt_stack.clear();\n}\n /**\n * Returns true iff the partition is discrete, meaning that all\n * the elements are in their own cells.\n */\n bool is_discrete() const {return(free_cells == 0); }\n\n unsigned int nof_discrete_cells() const {return(discrete_cell_count); }\n\n /**\n * Print the partition into the file stream \\a fp.\n */\n //size_t print(FILE* const fp, const bool add_newline = true) const;\nsize_t print(FILE* const fp, const bool add_newline = true) const {\n size_t r = 0;\n const char* cell_sep = \"\";\n r += fprintf(fp, \"[\");\n for(Cell* cell = first_cell; cell; cell = cell->next)\n {\n /* Print cell */\n r += fprintf(fp, \"%s{\", cell_sep);\n cell_sep = \",\";\n const char* elem_sep = \"\";\n for(unsigned int i = 0; i < cell->length; i++)\n\t{\n\t r += fprintf(fp, \"%s%u\", elem_sep, elements[cell->first + i]);\n\t elem_sep = \",\";\n\t}\n r += fprintf(fp, \"}\");\n }\n r += fprintf(fp, \"]\");\n if(add_newline) r += fprintf(fp, \"\\n\");\n return r;\n}\n\n /**\n * Print the partition cell sizes into the file stream \\a fp.\n */\n //size_t print_signature(FILE* const fp, const bool add_newline = true) const;\nsize_t print_signature(FILE* const fp, const bool add_newline = true) const {\n size_t r = 0;\n const char* cell_sep = \"\";\n r += fprintf(fp, \"[\");\n for(Cell* cell = first_cell; cell; cell = cell->next)\n {\n if(cell->is_unit()) continue;\n //fprintf(fp, \"%s%u\", cell_sep, cr_cells[cell->first].level);\n r += fprintf(fp, \"%s%u\", cell_sep, cell->length);\n cell_sep = \",\";\n }\n r += fprintf(fp, \"]\");\n if(add_newline) r += fprintf(fp, \"\\n\");\n return r;\n}\n\n /*\n * Splits the Cell \\a cell into [cell_1,...,cell_n]\n * according to the invariant_values of the elements in \\a cell.\n * After splitting, cell_1 == \\a cell.\n * Returns the pointer to the Cell cell_n;\n * cell_n != cell iff the Cell \\a cell was actually splitted.\n * The flag \\a max_ival_info_ok indicates whether the max_ival and\n * max_ival_count fields of the Cell \\a cell have consistent values\n * when the method is called.\n * Clears the invariant values of elements in the Cell \\a cell as well as\n * the max_ival and max_ival_count fields of the Cell \\a cell.\n */\n //Cell *zplit_cell(Cell * const cell, const bool max_ival_info_ok);\nCell* zplit_cell(Cell* const cell, const bool max_ival_info_ok) {\n Cell* last_new_cell = cell;\n if(!max_ival_info_ok) {\n /* Compute max_ival info */\n assert(cell->max_ival == 0);\n assert(cell->max_ival_count == 0);\n unsigned int *ep = elements + cell->first;\n for(unsigned int i = cell->length; i > 0; i--, ep++) {\n\t const unsigned int ival = invariant_values[*ep];\n\t if(ival > cell->max_ival) {\n\t cell->max_ival = ival;\n\t cell->max_ival_count = 1;\n\t }\n\t else if(ival == cell->max_ival) {\n\t cell->max_ival_count++;\n\t }\n\t}\n }\n\n#ifdef BLISS_CONSISTENCY_CHECKS\n /* Verify max_ival info */\n {\n unsigned int nof_zeros = 0;\n unsigned int max_ival = 0;\n unsigned int max_ival_count = 0;\n unsigned int *ep = elements + cell->first;\n for(unsigned int i = cell->length; i > 0; i--, ep++)\n {\n\tconst unsigned int ival = invariant_values[*ep];\n\tif(ival == 0)\n\t nof_zeros++;\n\tif(ival > max_ival)\n\t {\n\t max_ival = ival;\n\t max_ival_count = 1;\n\t }\n\telse if(ival == max_ival)\n\t max_ival_count++;\n }\n assert(max_ival == cell->max_ival);\n assert(max_ival_count == cell->max_ival_count);\n }\n#endif\n\n /* max_ival info has been computed */\n\n if(cell->max_ival_count == cell->length)\n {\n /* All invariant values are the same, clear 'em */\n if(cell->max_ival > 0)\n\tclear_ivs(cell);\n }\n else\n {\n /* All invariant values are not the same */\n if(cell->max_ival == 1)\n\t{\n\t /* Specialized splitting for cells with binary invariant values */\n\t last_new_cell = sort_and_split_cell1(cell);\n\t}\n else if(cell->max_ival < 256)\n\t{\n\t /* Specialized splitting for cells with invariant values < 256 */\n\t last_new_cell = sort_and_split_cell255(cell, cell->max_ival);\n\t}\n else\n\t{\n\t /* Generic sorting and splitting */\n\t const bool sorted = shellsort_cell(cell);\n\t if (!sorted) printf(\"error sorting\\n\");\n\t assert(sorted);\n\t last_new_cell = split_cell(cell);\n\t}\n }\n cell->max_ival = 0;\n cell->max_ival_count = 0;\n return last_new_cell;\n}\n /*\n * Routines for component recursion\n */\n //void cr_init();\n //void cr_free();\n unsigned int cr_get_level(const unsigned int cell_index) const;\n //unsigned int cr_split_level(const unsigned int level, const std::vector& cells);\n/*\n *\n * Component recursion specific code\n *\n */\nvoid cr_init() {\n assert(bt_stack.empty());\n cr_enabled = true;\n if(cr_cells) free(cr_cells);\n cr_cells = (CRCell*)malloc(N * sizeof(CRCell));\n if(!cr_cells) {assert(false && \"Mem out\"); }\n\n if(cr_levels) free(cr_levels);\n cr_levels = (CRCell**)malloc(N * sizeof(CRCell*));\n if(!cr_levels) {assert(false && \"Mem out\"); }\n\n for(unsigned int i = 0; i < N; i++) {\n cr_levels[i] = 0;\n cr_cells[i].level = UINT_MAX;\n cr_cells[i].next = 0;\n cr_cells[i].prev_next_ptr = 0;\n }\n\n for(const Cell *cell = first_cell; cell; cell = cell->next)\n cr_create_at_level_trailed(cell->first, 0);\n\n cr_max_level = 0;\n}\n\n\nvoid cr_free() {\n if(cr_cells) {free(cr_cells); cr_cells = 0; }\n if(cr_levels) {free(cr_levels); cr_levels = 0; }\n cr_created_trail.clear();\n cr_splitted_level_trail.clear();\n cr_bt_info.clear();\n cr_max_level = 0;\n cr_enabled = false;\n}\n\nunsigned int cr_split_level(const unsigned int level, const std::vector& splitted_cells) {\n assert(cr_enabled);\n assert(level <= cr_max_level);\n cr_levels[++cr_max_level] = 0;\n cr_splitted_level_trail.push_back(level);\n for(unsigned int i = 0; i < splitted_cells.size(); i++) {\n const unsigned int cell_index = splitted_cells[i];\n assert(cell_index < N);\n CRCell& cr_cell = cr_cells[cell_index];\n assert(cr_cell.level == level);\n cr_cell.detach();\n cr_create_at_level(cell_index, cr_max_level);\n }\n return cr_max_level;\n}\n\n /** Clear the invariant_values of the elements in the Cell \\a cell. */\n //void clear_ivs(Cell* const cell);\nvoid clear_ivs(Cell* const cell) {\n unsigned int* ep = elements + cell->first;\n for(unsigned int i = cell->length; i > 0; i--, ep++)\n invariant_values[*ep] = 0;\n}\n\nprivate:\n /*\n * Component recursion data structures\n */\n\n /* Is component recursion support in use? */\n bool cr_enabled;\n\n class CRCell {\n public:\n unsigned int level;\n CRCell* next;\n CRCell** prev_next_ptr;\n void detach() {\n if(next)\n\tnext->prev_next_ptr = prev_next_ptr;\n *(prev_next_ptr) = next;\n level = UINT_MAX;\n next = 0;\n prev_next_ptr = 0;\n }\n };\n CRCell* cr_cells;\n CRCell** cr_levels;\n class CR_BTInfo {\n public:\n unsigned int created_trail_index;\n unsigned int splitted_level_trail_index;\n };\n std::vector cr_created_trail;\n std::vector cr_splitted_level_trail;\n std::vector cr_bt_info;\n unsigned int cr_max_level;\n //void cr_create_at_level(const unsigned int cell_index, unsigned int level);\n //void cr_create_at_level_trailed(const unsigned int cell_index, unsigned int level);\n //unsigned int cr_get_backtrack_point();\n //void cr_goto_backtrack_point(const unsigned int btpoint);\n\nvoid cr_create_at_level(const unsigned int cell_index, const unsigned int level) {\n assert(cr_enabled);\n assert(cell_index < N);\n assert(level < N);\n CRCell& cr_cell = cr_cells[cell_index];\n assert(cr_cell.level == UINT_MAX);\n assert(cr_cell.next == 0);\n assert(cr_cell.prev_next_ptr == 0);\n if(cr_levels[level])\n cr_levels[level]->prev_next_ptr = &(cr_cell.next);\n cr_cell.next = cr_levels[level];\n cr_levels[level] = &cr_cell;\n cr_cell.prev_next_ptr = &cr_levels[level];\n cr_cell.level = level;\n}\n\n\nvoid cr_create_at_level_trailed(const unsigned int cell_index, const unsigned int level) {\n assert(cr_enabled);\n cr_create_at_level(cell_index, level);\n cr_created_trail.push_back(cell_index);\n}\n\nunsigned int cr_get_backtrack_point() {\n assert(cr_enabled);\n CR_BTInfo info;\n info.created_trail_index = cr_created_trail.size();\n info.splitted_level_trail_index = cr_splitted_level_trail.size();\n cr_bt_info.push_back(info);\n return cr_bt_info.size()-1;\n}\n\n\nvoid cr_goto_backtrack_point(const unsigned int btpoint) {\n assert(cr_enabled);\n assert(btpoint < cr_bt_info.size());\n while(cr_created_trail.size() > cr_bt_info[btpoint].created_trail_index) {\n const unsigned int cell_index = cr_created_trail.back();\n cr_created_trail.pop_back();\n CRCell& cr_cell = cr_cells[cell_index];\n assert(cr_cell.level != UINT_MAX);\n assert(cr_cell.prev_next_ptr);\n cr_cell.detach();\n }\n\n while(cr_splitted_level_trail.size() >\n\tcr_bt_info[btpoint].splitted_level_trail_index)\n {\n const unsigned int dest_level = cr_splitted_level_trail.back();\n cr_splitted_level_trail.pop_back();\n assert(cr_max_level > 0);\n assert(dest_level < cr_max_level);\n while(cr_levels[cr_max_level]) {\n\tCRCell *cr_cell = cr_levels[cr_max_level];\n\tcr_cell->detach();\n\tcr_create_at_level(cr_cell - cr_cells, dest_level);\n }\n cr_max_level--;\n }\n cr_bt_info.resize(btpoint);\n}\n\n // Auxiliary routines for sorting and splitting cells\n //Cell* sort_and_split_cell1(Cell* cell);\n //Cell* sort_and_split_cell255(Cell* const cell, const unsigned int max_ival);\n //bool shellsort_cell(Cell* cell);\n\n// Assumes that the invariant values are NOT the same and that the cell contains more than one element\nCell* sort_and_split_cell1(Cell* const cell) {\n#if defined(BLISS_EXPENSIVE_CONSISTENCY_CHECKS)\n assert(cell->length > 1);\n assert(cell->first + cell->length <= N);\n unsigned int nof_0_found = 0;\n unsigned int nof_1_found = 0;\n for(unsigned int i = cell->first; i < cell->first + cell->length; i++)\n {\n const unsigned int ival = invariant_values[elements[i]];\n assert(ival == 0 or ival == 1);\n if(ival == 0) nof_0_found++;\n else nof_1_found++;\n }\n assert(nof_0_found > 0);\n assert(nof_1_found > 0);\n assert(nof_1_found == cell->max_ival_count);\n assert(nof_0_found + nof_1_found == cell->length);\n assert(cell->max_ival == 1);\n#endif\n\n\n /* (Pseudo)allocate new cell */\n Cell* const new_cell = free_cells;\n free_cells = new_cell->next;\n\n#define NEW_SORT1\n#ifdef NEW_SORT1\n unsigned int *ep0 = elements + cell->first;\n unsigned int *ep1 = ep0 + cell->length - cell->max_ival_count;\n if(cell->max_ival_count > cell->length / 2)\n\t{\n\t /* There are more ones than zeros, only move zeros */\n\t unsigned int * const end = ep0 + cell->length;\n\t while(ep1 < end)\n\t {\n\t while(invariant_values[*ep1] == 0)\n\t\t{\n\t\t const unsigned int tmp = *ep1;\n\t\t *ep1 = *ep0;\n\t\t *ep0 = tmp;\n\t\t in_pos[tmp] = ep0;\n\t\t in_pos[*ep1] = ep1;\n\t\t ep0++;\n\t\t}\n\t element_to_cell_map[*ep1] = new_cell;\n\t invariant_values[*ep1] = 0;\n\t ep1++;\n\t }\n\t}\n else\n\t{\n\t /* There are more zeros than ones, only move ones */\n\t unsigned int * const end = ep1;\n\t while(ep0 < end)\n\t {\n\t while(invariant_values[*ep0] != 0)\n\t\t{\n\t\t const unsigned int tmp = *ep0;\n\t\t *ep0 = *ep1;\n\t\t *ep1 = tmp;\n\t\t in_pos[tmp] = ep1;\n\t\t in_pos[*ep0] = ep0;\n\t\t ep1++;\n\t\t}\n\t ep0++;\n\t }\n\t ep1 = end;\n\t while(ep1 < elements + cell->first + cell->length)\n\t {\n\t element_to_cell_map[*ep1] = new_cell;\n\t invariant_values[*ep1] = 0;\n\t ep1++;\n\t }\n\t}\n /* Update new cell parameters */\n new_cell->first = cell->first + cell->length - cell->max_ival_count;\n new_cell->length = cell->length - (new_cell->first - cell->first);\n new_cell->next = cell->next;\n if(new_cell->next)\n new_cell->next->prev = new_cell;\n new_cell->prev = cell;\n new_cell->split_level = refinement_stack.size()+1;\n /* Update old, splitted cell parameters */\n cell->length = new_cell->first - cell->first;\n cell->next = new_cell;\n /* CR */\n if(cr_enabled)\n cr_create_at_level_trailed(new_cell->first, cr_get_level(cell->first));\n\n#else\n /* Sort vertices in the cell according to the invariant values */\n unsigned int *ep0 = elements + cell->first;\n unsigned int *ep1 = ep0 + cell->length;\n while(ep1 > ep0)\n {\n const unsigned int element = *ep0;\n const unsigned int ival = invariant_values[element];\n invariant_values[element] = 0;\n if(ival == 0)\n\t{\n\t ep0++;\n\t}\n else\n\t{\n\t ep1--;\n\t *ep0 = *ep1;\n\t *ep1 = element;\n\t element_to_cell_map[element] = new_cell;\n\t in_pos[element] = ep1;\n\t in_pos[*ep0] = ep0;\n\t}\n }\n\n\n /* Update new cell parameters */\n new_cell->first = ep1 - elements;\n new_cell->length = cell->length - (new_cell->first - cell->first);\n new_cell->next = cell->next;\n if(new_cell->next)\n new_cell->next->prev = new_cell;\n new_cell->prev = cell;\n new_cell->split_level = cell->split_level;\n /* Update old, splitted cell parameters */\n cell->length = new_cell->first - cell->first;\n cell->next = new_cell;\n cell->split_level = refinement_stack.size()+1;\n /* CR */\n if(cr_enabled)\n cr_create_at_level_trailed(new_cell->first, cr_get_level(cell->first));\n\n#endif /* ifdef NEW_SORT1*/\n\n /* Add cell in refinement stack for backtracking */\n {\n RefInfo i;\n i.split_cell_first = new_cell->first;\n if(cell->prev_nonsingleton)\n i.prev_nonsingleton_first = cell->prev_nonsingleton->first;\n else\n i.prev_nonsingleton_first = -1;\n if(cell->next_nonsingleton)\n i.next_nonsingleton_first = cell->next_nonsingleton->first;\n else\n i.next_nonsingleton_first = -1;\n /* Modify nonsingleton cell list */\n if(new_cell->length > 1)\n {\n\tnew_cell->prev_nonsingleton = cell;\n\tnew_cell->next_nonsingleton = cell->next_nonsingleton;\n\tif(new_cell->next_nonsingleton)\n\t new_cell->next_nonsingleton->prev_nonsingleton = new_cell;\n\tcell->next_nonsingleton = new_cell;\n }\n else\n {\n\tnew_cell->next_nonsingleton = 0;\n\tnew_cell->prev_nonsingleton = 0;\n\tdiscrete_cell_count++;\n }\n if(cell->is_unit())\n {\n\tif(cell->prev_nonsingleton)\n\t cell->prev_nonsingleton->next_nonsingleton = cell->next_nonsingleton;\n\telse\n\t first_nonsingleton_cell = cell->next_nonsingleton;\n\tif(cell->next_nonsingleton)\n\t cell->next_nonsingleton->prev_nonsingleton = cell->prev_nonsingleton;\n\tcell->next_nonsingleton = 0;\n\tcell->prev_nonsingleton = 0;\n\tdiscrete_cell_count++;\n }\n refinement_stack.push(i);\n }\n\n\n /* Add cells in splitting queue */\n if(cell->in_splitting_queue) {\n /* Both cells must be included in splitting_queue in order to have\n refinement to equitable partition */\n splitting_queue_add(new_cell);\n } else {\n Cell *min_cell, *max_cell;\n if(cell->length <= new_cell->length) {\n min_cell = cell;\n max_cell = new_cell;\n } else {\n min_cell = new_cell;\n max_cell = cell;\n }\n /* Put the smaller cell in splitting_queue */\n splitting_queue_add(min_cell);\n if(max_cell->is_unit()) {\n /* Put the \"larger\" cell also in splitting_queue */\n splitting_queue_add(max_cell);\n }\n }\n\n\n return new_cell;\n}\n\n// Sort the elements in a cell according to their invariant values.\n// The invariant values are not cleared.\n// Warning: the in_pos array is left in incorrect state.\nbool shellsort_cell(Cell* const cell) {\n unsigned int h;\n unsigned int* ep;\n if(cell->is_unit())\n return false;\n\n /* Check whether all the elements have the same invariant value */\n bool equal_invariant_values = true;\n {\n ep = elements + cell->first;\n const unsigned int ival = invariant_values[*ep];\n ep++;\n for(unsigned int i = cell->length - 1; i > 0; i--)\n {\n\tif(invariant_values[*ep] != ival) {\n\t equal_invariant_values = false;\n\t break;\n\t}\n\tep++;\n }\n }\n if(equal_invariant_values)\n return false;\n\n ep = elements + cell->first;\n\n for(h = 1; h <= cell->length/9; h = 3*h + 1)\n ;\n for( ; h > 0; h = h/3) {\n for(unsigned int i = h; i < cell->length; i++) {\n const unsigned int element = ep[i];\n const unsigned int ival = invariant_values[element];\n unsigned int j = i;\n while(j >= h and invariant_values[ep[j-h]] > ival) {\n ep[j] = ep[j-h];\n j -= h;\n }\n ep[j] = element;\n }\n }\n return true;\n}\n\n// Distribution count sorting of cells with invariant values less than 256.\nCell* sort_and_split_cell255(Cell* const cell, const unsigned int max_ival) {\n if(cell->is_unit()) {\n /* Reset invariant value */\n invariant_values[elements[cell->first]] = 0;\n return cell;\n }\n \n#ifdef BLISS_CONSISTENCY_CHECKS\n for(unsigned int i = 0; i < 256; i++)\n assert(dcs_count[i] == 0);\n#endif\n\n /*\n * Compute the distribution of invariant values to the count array\n */\n {\n const unsigned int *ep = elements + cell->first;\n const unsigned int ival = invariant_values[*ep];\n dcs_count[ival]++;\n ep++;\n#if defined(BLISS_CONSISTENCY_CHECKS)\n bool equal_invariant_values = true;\n#endif\n for(unsigned int i = cell->length - 1; i != 0; i--)\n {\n\tconst unsigned int ival2 = invariant_values[*ep];\n\tdcs_count[ival2]++;\n#if defined(BLISS_CONSISTENCY_CHECKS)\n\tif(ival2 != ival) {\n\t equal_invariant_values = false;\n\t}\n#endif\n\tep++;\n }\n#if defined(BLISS_CONSISTENCY_CHECKS)\n assert(!equal_invariant_values);\n if(equal_invariant_values) {\n assert(dcs_count[ival] == cell->length);\n dcs_count[ival] = 0;\n clear_ivs(cell);\n return cell;\n }\n#endif\n }\n\n /* Build start array */\n dcs_cumulate_count(max_ival);\n\n\n /* Do the sorting */\n for(unsigned int i = 0; i <= max_ival; i++)\n {\n unsigned int *ep = elements + cell->first + dcs_start[i];\n for(unsigned int j = dcs_count[i]; j > 0; j--)\n\t{\n\t while(true)\n\t {\n\t const unsigned int element = *ep;\n\t const unsigned int ival = invariant_values[element];\n\t if(ival == i)\n\t\tbreak;\n\t *ep = elements[cell->first + dcs_start[ival]];\n\t elements[cell->first + dcs_start[ival]] = element;\n\t dcs_start[ival]++;\n\t dcs_count[ival]--;\n\t }\n\t ep++;\n\t}\n dcs_count[i] = 0;\n }\n\n#if defined(BLISS_CONSISTENCY_CHECKS)\n for(unsigned int i = 0; i < 256; i++)\n assert(dcs_count[i] == 0);\n#endif\n\n /* split cell */\n Cell* const new_cell = split_cell(cell);\n return new_cell;\n}\n\n Cell* split_cell(Cell* const cell);\n\n /*\n * Some auxiliary stuff needed for distribution count sorting.\n * To make the code thread-safe (modulo the requirement that each graph is\n * only accessed in one thread at a time), the arrays are owned by\n * the partition instance, not statically defined.\n */\n unsigned int dcs_count[256];\n unsigned int dcs_start[256];\n //void dcs_cumulate_count(const unsigned int max);\n// An auxiliary function for distribution count sorting.\n// Build start array so that\n// dcs_start[0] = 0 and dcs_start[i+1] = dcs_start[i] + dcs_count[i].\nvoid dcs_cumulate_count(const unsigned int max) {\n unsigned int* count_p = dcs_count;\n unsigned int* start_p = dcs_start;\n unsigned int sum = 0;\n for(unsigned int i = max+1; i > 0; i--) {\n *start_p = sum;\n start_p++;\n sum += *count_p;\n count_p++;\n }\n}\n};\n\ninline Partition::Cell* Partition::splitting_queue_pop() {\n Cell* const cell = splitting_queue.pop_front();\n cell->in_splitting_queue = false;\n return cell;\n}\n\ninline bool Partition::splitting_queue_is_empty() const {\n return splitting_queue.is_empty();\n}\n\ninline unsigned int Partition::cr_get_level(const unsigned int cell_index) const {\n return(cr_cells[cell_index].level);\n}\n\n} // namespace bliss\n\n#endif\n" }, { "path": "external/bliss/bliss/search.h", "content": "\nvoid search(const bool canonical, Stats& stats) {\n const unsigned int N = get_nof_vertices();\n unsigned int all_same_level = UINT_MAX;\n p.graph = this;\n /*\n * Must be done!\n */\n remove_duplicate_edges();\n /*\n * Reset search statistics\n */\n stats.reset();\n stats.nof_nodes = 1;\n stats.nof_leaf_nodes = 1;\n\n /* Free old first path data structures */\n if (first_path_labeling) {\n free(first_path_labeling);\n first_path_labeling = 0;\n }\n if (first_path_labeling_inv) {\n free(first_path_labeling_inv);\n first_path_labeling_inv = 0;\n }\n if (first_path_automorphism) {\n free(first_path_automorphism);\n first_path_automorphism = 0;\n }\n\n /* Free old best path data structures */\n if (best_path_labeling) {\n free(best_path_labeling);\n best_path_labeling = 0;\n }\n if (best_path_labeling_inv) {\n free(best_path_labeling_inv);\n best_path_labeling_inv = 0;\n }\n if (best_path_automorphism) {\n free(best_path_automorphism);\n best_path_automorphism = 0;\n }\n\n if (N == 0) {\n /* Nothing to do, return... */\n return;\n }\n\n /* Initialize the partition ... */\n p.init(N);\n /* ... and the component recursion data structures in the partition */\n if (opt_use_comprec)\n p.cr_init();\n\n neighbour_heap.init(N);\n\n in_search = false;\n /* Do not compute certificate when building the initial partition */\n refine_compare_certificate = false;\n /* The 'eqref_hash' hash value is not computed when building\n * the initial partition as it is not used for anything at the moment.\n * This saves some cycles. */\n compute_eqref_hash = false;\n\n // Timer timer1;\n\n make_initial_equitable_partition();\n\n if (verbstr and verbose_level >= 2) {\n fprintf(verbstr, \"Initial partition computed in %.2f seconds\\n\", 0.0);\n // timer1.get_duration());\n fflush(verbstr);\n }\n\n /*\n * Allocate space for the \"first path\" and \"best path\" labelings\n */\n if (first_path_labeling)\n free(first_path_labeling);\n first_path_labeling = (unsigned int*)calloc(N, sizeof(unsigned int));\n if (!first_path_labeling)\n _OUT_OF_MEMORY();\n if (best_path_labeling)\n free(best_path_labeling);\n best_path_labeling = (unsigned int*)calloc(N, sizeof(unsigned int));\n if (!best_path_labeling)\n _OUT_OF_MEMORY();\n\n /*\n * Is the initial partition discrete?\n */\n if (p.is_discrete()) {\n /* Make the best path labeling i.e. the canonical labeling */\n update_labeling(best_path_labeling);\n /* Update statistics */\n stats.nof_leaf_nodes = 1;\n return;\n }\n\n /*\n * Allocate the inverses of the \"first path\" and \"best path\" labelings\n */\n if (first_path_labeling_inv)\n free(first_path_labeling_inv);\n first_path_labeling_inv = (unsigned int*)calloc(N, sizeof(unsigned int));\n if (!first_path_labeling_inv)\n _OUT_OF_MEMORY();\n if (best_path_labeling_inv)\n free(best_path_labeling_inv);\n best_path_labeling_inv = (unsigned int*)calloc(N, sizeof(unsigned int));\n if (!best_path_labeling_inv)\n _OUT_OF_MEMORY();\n\n /*\n * Allocate space for the automorphisms\n */\n if (first_path_automorphism)\n free(first_path_automorphism);\n first_path_automorphism = (unsigned int*)malloc(N * sizeof(unsigned int));\n if (!first_path_automorphism)\n _OUT_OF_MEMORY();\n if (best_path_automorphism)\n free(best_path_automorphism);\n best_path_automorphism = (unsigned int*)malloc(N * sizeof(unsigned int));\n if (!best_path_automorphism)\n _OUT_OF_MEMORY();\n\n /*\n * Initialize orbit information so that all vertices are in their own orbits\n */\n first_path_orbits.init(N);\n best_path_orbits.init(N);\n\n /*\n * Initialize certificate memory\n */\n initialize_certificate();\n\n std::vector search_stack;\n std::vector first_path_info;\n std::vector best_path_info;\n\n search_stack.clear();\n\n /* Initialize \"long prune\" data structures */\n if (opt_use_long_prune)\n long_prune_init();\n\n /*\n * Initialize failure recording data structures\n */\n typedef std::set> FailureRecordingSet;\n std::vector failure_recording_hashes;\n\n /*\n * Initialize component recursion data structures\n */\n cr_cep_stack.clear();\n unsigned int cr_cep_index = 0;\n {\n /* Inset a sentinel \"component end point\" */\n CR_CEP sentinel;\n sentinel.creation_level = 0;\n sentinel.discrete_cell_limit = get_nof_vertices();\n sentinel.next_cr_level = 0;\n sentinel.next_cep_index = 0;\n sentinel.first_checked = false;\n sentinel.best_checked = false;\n cr_cep_index = 0;\n cr_cep_stack.push_back(sentinel);\n }\n cr_level = 0;\n if (opt_use_comprec and nucr_find_first_component(cr_level) == true and\n p.nof_discrete_cells() + cr_component_elements <\n cr_cep_stack[cr_cep_index].discrete_cell_limit) {\n cr_level = p.cr_split_level(0, cr_component);\n CR_CEP cep;\n cep.creation_level = 0;\n cep.discrete_cell_limit = p.nof_discrete_cells() + cr_component_elements;\n cep.next_cr_level = 0;\n cep.next_cep_index = cr_cep_index;\n cep.first_checked = false;\n cep.best_checked = false;\n cr_cep_index = cr_cep_stack.size();\n cr_cep_stack.push_back(cep);\n }\n\n /*\n * Build the root node of the search tree\n */\n {\n TreeNode root;\n Partition::Cell* split_cell = find_next_cell_to_be_splitted(p.first_cell);\n root.split_cell_first = split_cell->first;\n root.split_element = TreeNode::SPLIT_START;\n root.partition_bt_point = p.set_backtrack_point();\n root.certificate_index = 0;\n root.fp_on = true;\n root.fp_cert_equal = true;\n root.fp_extendable = TreeNode::MAYBE;\n root.in_best_path = false;\n root.cmp_to_best_path = 0;\n root.long_prune_begin = 0;\n\n root.failure_recording_ival = 0;\n\n /* Save component recursion info for backtracking */\n root.cr_level = cr_level;\n root.cr_cep_stack_size = cr_cep_stack.size();\n root.cr_cep_index = cr_cep_index;\n search_stack.push_back(root);\n }\n\n /*\n * Set status and global flags for search related procedures\n */\n in_search = true;\n /* Do not compare certificates during refinement until the first path has been\n * traversed to the leaf */\n refine_compare_certificate = false;\n\n /*\n * The actual backtracking search\n */\n while (!search_stack.empty()) {\n TreeNode& current_node = search_stack.back();\n const unsigned int current_level = (unsigned int)search_stack.size() - 1;\n\n if (opt_use_comprec) {\n CR_CEP& cep = cr_cep_stack[current_node.cr_cep_index];\n if (cep.first_checked == true and\n current_node.fp_extendable == TreeNode::MAYBE and\n !search_stack[cep.creation_level].fp_on) {\n current_node.fp_extendable = TreeNode::NO;\n }\n }\n\n if (current_node.fp_on) {\n if (current_node.split_element == TreeNode::SPLIT_END) {\n search_stack.pop_back();\n continue;\n }\n } else {\n if (current_node.fp_extendable == TreeNode::YES) {\n search_stack.pop_back();\n continue;\n }\n if (current_node.split_element == TreeNode::SPLIT_END) {\n if (opt_use_failure_recording) {\n TreeNode& parent_node = search_stack[current_level - 1];\n if (parent_node.fp_on)\n failure_recording_hashes[current_level - 1].insert(\n current_node.failure_recording_ival);\n }\n search_stack.pop_back();\n continue;\n }\n if (current_node.fp_extendable == TreeNode::NO and\n (!canonical or current_node.cmp_to_best_path < 0)) {\n if (opt_use_failure_recording) {\n TreeNode& parent_node = search_stack[current_level - 1];\n if (parent_node.fp_on)\n failure_recording_hashes[current_level - 1].insert(\n current_node.failure_recording_ival);\n }\n search_stack.pop_back();\n continue;\n }\n }\n\n /* Restore partition ... */\n p.goto_backtrack_point(current_node.partition_bt_point);\n /* ... and re-remember backtracking point */\n current_node.partition_bt_point = p.set_backtrack_point();\n\n /* Restore current path certificate */\n certificate_index = current_node.certificate_index;\n refine_current_path_certificate_index = current_node.certificate_index;\n certificate_current_path.resize(certificate_index);\n\n /* Fetch split cell information */\n Partition::Cell* const cell =\n p.get_cell(p.elements[current_node.split_cell_first]);\n\n /* Restore component recursion information */\n cr_level = current_node.cr_level;\n cr_cep_stack.resize(current_node.cr_cep_stack_size);\n cr_cep_index = current_node.cr_cep_index;\n\n /*\n * Update long prune redundancy sets\n */\n if (opt_use_long_prune and current_level >= 1 and !current_node.fp_on) {\n unsigned int begin = (current_node.long_prune_begin > long_prune_begin)\n ? current_node.long_prune_begin\n : long_prune_begin;\n for (unsigned int i = begin; i < long_prune_end; i++) {\n const std::vector& fixed = long_prune_get_fixed(i);\n#if defined(BLISS_CONSISTENCY_CHECKS)\n for (unsigned int l = 0; l < search_stack.size() - 2; l++)\n assert(fixed[search_stack[l].split_element]);\n#endif\n if (fixed[search_stack[search_stack.size() - 1 - 1].split_element] ==\n false) {\n long_prune_swap(begin, i);\n begin++;\n current_node.long_prune_begin = begin;\n continue;\n }\n }\n\n if (current_node.split_element == TreeNode::SPLIT_START) {\n current_node.needs_long_prune = true;\n } else if (current_node.needs_long_prune) {\n current_node.needs_long_prune = false;\n unsigned int begin = (current_node.long_prune_begin > long_prune_begin)\n ? current_node.long_prune_begin\n : long_prune_begin;\n for (unsigned int i = begin; i < long_prune_end; i++) {\n const std::vector& fixed = long_prune_get_fixed(i);\n#if defined(BLISS_CONSISTENCY_CHECKS)\n for (unsigned int l = 0; l < search_stack.size() - 2; l++)\n assert(fixed[search_stack[l].split_element]);\n#endif\n assert(fixed[search_stack[current_level - 1].split_element] == true);\n if (fixed[search_stack[current_level - 1].split_element] == false) {\n long_prune_swap(begin, i);\n begin++;\n current_node.long_prune_begin = begin;\n continue;\n }\n const std::vector& mcrs = long_prune_get_mcrs(i);\n unsigned int* ep = p.elements + cell->first;\n for (unsigned int j = cell->length; j > 0; j--, ep++) {\n if (mcrs[*ep] == false)\n current_node.long_prune_redundant.insert(*ep);\n }\n }\n }\n }\n\n /*\n * Find the next smallest, non-isomorphic element in the cell and\n * store it in current_node.split_element\n */\n {\n unsigned int next_split_element = UINT_MAX;\n // unsigned int* next_split_element_pos = 0;\n unsigned int* ep = p.elements + cell->first;\n if (current_node.fp_on) {\n /* Find the next larger splitting element that is\n * a minimal orbit representative w.r.t. first_path_orbits */\n for (unsigned int i = cell->length; i > 0; i--, ep++) {\n if ((int)(*ep) > current_node.split_element and\n *ep < next_split_element and\n first_path_orbits.is_minimal_representative(*ep)) {\n next_split_element = *ep;\n // next_split_element_pos = ep;\n }\n }\n } else if (current_node.in_best_path) {\n /* Find the next larger splitting element that is\n * a minimal orbit representative w.r.t. best_path_orbits */\n for (unsigned int i = cell->length; i > 0; i--, ep++) {\n if ((int)(*ep) > current_node.split_element and\n *ep < next_split_element and\n best_path_orbits.is_minimal_representative(*ep) and\n (!opt_use_long_prune or\n current_node.long_prune_redundant.find(*ep) ==\n current_node.long_prune_redundant.end())) {\n next_split_element = *ep;\n // next_split_element_pos = ep;\n }\n }\n } else {\n /* Find the next larger splitting element */\n for (unsigned int i = cell->length; i > 0; i--, ep++) {\n if ((int)(*ep) > current_node.split_element and\n *ep < next_split_element and\n (!opt_use_long_prune or\n current_node.long_prune_redundant.find(*ep) ==\n current_node.long_prune_redundant.end())) {\n next_split_element = *ep;\n // next_split_element_pos = ep;\n }\n }\n }\n if (next_split_element == UINT_MAX) {\n /* No more (unexplored children) in the cell */\n current_node.split_element = TreeNode::SPLIT_END;\n if (current_node.fp_on) {\n /* Update group size */\n const unsigned int index = first_path_orbits.orbit_size(\n first_path_info[search_stack.size() - 1].splitting_element);\n stats.group_size.multiply(index);\n stats.group_size_approx *= (long double)index;\n /*\n * Update all_same_level\n */\n if (index == cell->length and all_same_level == current_level + 1)\n all_same_level = current_level;\n if (verbstr and verbose_level >= 2) {\n fprintf(verbstr,\n \"Level %u: orbits=%u, index=%u/%u, all_same_level=%u\\n\",\n current_level, first_path_orbits.nof_orbits(), index,\n cell->length, all_same_level);\n fflush(verbstr);\n }\n }\n continue;\n }\n\n /* Split on smallest */\n current_node.split_element = next_split_element;\n }\n\n const unsigned int child_level = current_level + 1;\n /* Update some statistics */\n stats.nof_nodes++;\n if (search_stack.size() > stats.max_level)\n stats.max_level = search_stack.size();\n\n /* Set flags and indices for the refiner certificate builder */\n refine_equal_to_first = current_node.fp_cert_equal;\n refine_cmp_to_best = current_node.cmp_to_best_path;\n if (!first_path_info.empty()) {\n if (refine_equal_to_first)\n refine_first_path_subcertificate_end =\n first_path_info[search_stack.size() - 1].certificate_index +\n first_path_info[search_stack.size() - 1].subcertificate_length;\n if (canonical) {\n if (refine_cmp_to_best == 0)\n refine_best_path_subcertificate_end =\n best_path_info[search_stack.size() - 1].certificate_index +\n best_path_info[search_stack.size() - 1].subcertificate_length;\n } else\n refine_cmp_to_best = -1;\n }\n\n const bool was_fp_cert_equal = current_node.fp_cert_equal;\n\n /* Individualize, i.e. split the cell in two, the latter new cell\n * will be a unit one containing info.split_element */\n Partition::Cell* const new_cell =\n p.individualize(cell, current_node.split_element);\n\n /*\n * Refine the new partition to equitable\n */\n if (cell->is_unit())\n refine_to_equitable(cell, new_cell);\n else\n refine_to_equitable(new_cell);\n\n /* Update statistics */\n if (p.is_discrete())\n stats.nof_leaf_nodes++;\n\n if (!first_path_info.empty()) {\n /* We are no longer on the first path */\n const unsigned int subcertificate_length =\n certificate_current_path.size() - certificate_index;\n if (refine_equal_to_first) {\n /* Was equal to the first path so far */\n PathInfo& first_pinfo = first_path_info[current_level];\n assert(first_pinfo.certificate_index == certificate_index);\n if (subcertificate_length != first_pinfo.subcertificate_length) {\n refine_equal_to_first = false;\n if (opt_use_failure_recording)\n failure_recording_fp_deviation = subcertificate_length;\n } else if (first_pinfo.eqref_hash.cmp(eqref_hash) != 0) {\n refine_equal_to_first = false;\n if (opt_use_failure_recording)\n failure_recording_fp_deviation = eqref_hash.get_value();\n }\n }\n if (canonical and (refine_cmp_to_best == 0)) {\n /* Was equal to the best path so far */\n PathInfo& bestp_info = best_path_info[current_level];\n assert(bestp_info.certificate_index == certificate_index);\n if (subcertificate_length < bestp_info.subcertificate_length) {\n refine_cmp_to_best = -1;\n } else if (subcertificate_length > bestp_info.subcertificate_length) {\n refine_cmp_to_best = 1;\n } else if (bestp_info.eqref_hash.cmp(eqref_hash) > 0) {\n refine_cmp_to_best = -1;\n } else if (bestp_info.eqref_hash.cmp(eqref_hash) < 0) {\n refine_cmp_to_best = 1;\n }\n }\n\n if (opt_use_failure_recording and was_fp_cert_equal and\n !refine_equal_to_first) {\n UintSeqHash k;\n k.update(failure_recording_fp_deviation);\n k.update(eqref_hash.get_value());\n failure_recording_fp_deviation = k.get_value();\n\n if (current_node.fp_on)\n failure_recording_hashes[current_level].insert(\n failure_recording_fp_deviation);\n else {\n for (unsigned int i = current_level; i > 0; i--) {\n if (search_stack[i].fp_on)\n break;\n const FailureRecordingSet& s = failure_recording_hashes[i];\n if (i == current_level and\n s.find(failure_recording_fp_deviation) != s.end())\n break;\n if (s.find(0) != s.end())\n break;\n search_stack[i].fp_extendable = TreeNode::NO;\n }\n }\n }\n\n /* Check if no longer equal to the first path and,\n * if canonical labeling is desired, also worse than the\n * current best path */\n if (refine_equal_to_first == false and\n (!canonical or (refine_cmp_to_best < 0))) {\n /* Yes, backtrack */\n stats.nof_bad_nodes++;\n if (current_node.fp_cert_equal == true and\n current_level + 1 > all_same_level) {\n assert(all_same_level >= 1);\n for (unsigned int i = all_same_level; i < search_stack.size(); i++) {\n search_stack[i].fp_extendable = TreeNode::NO;\n }\n }\n\n continue;\n }\n }\n\n#if defined(BLISS_VERIFY_EQUITABLEDNESS)\n /* The new partition should be equitable */\n if (!is_equitable())\n fatal_error(\"consistency check failed - partition after refinement is \"\n \"not equitable\");\n#endif\n\n /*\n * Next level search tree node info\n */\n TreeNode child_node;\n\n /* No more in the first path */\n child_node.fp_on = false;\n /* No more in the best path */\n child_node.in_best_path = false;\n\n child_node.fp_cert_equal = refine_equal_to_first;\n if (current_node.fp_extendable == TreeNode::NO or\n (current_node.fp_extendable == TreeNode::MAYBE and\n child_node.fp_cert_equal == false))\n child_node.fp_extendable = TreeNode::NO;\n else\n child_node.fp_extendable = TreeNode::MAYBE;\n child_node.cmp_to_best_path = refine_cmp_to_best;\n\n child_node.failure_recording_ival = 0;\n child_node.cr_cep_stack_size = current_node.cr_cep_stack_size;\n child_node.cr_cep_index = current_node.cr_cep_index;\n child_node.cr_level = current_node.cr_level;\n\n certificate_index = certificate_current_path.size();\n\n current_node.eqref_hash = eqref_hash;\n current_node.subcertificate_length =\n certificate_index - current_node.certificate_index;\n\n /*\n * The first encountered leaf node at the end of the \"first path\"?\n */\n if (p.is_discrete() and first_path_info.empty()) {\n // fprintf(stdout, \"Level %u: FIRST\\n\", child_level); fflush(stdout);\n stats.nof_canupdates++;\n /*\n * Update labelings and their inverses\n */\n update_labeling_and_its_inverse(first_path_labeling,\n first_path_labeling_inv);\n update_labeling_and_its_inverse(best_path_labeling,\n best_path_labeling_inv);\n /*\n * Reset automorphism array\n */\n reset_permutation(first_path_automorphism);\n reset_permutation(best_path_automorphism);\n /*\n * Reset orbit information\n */\n first_path_orbits.reset();\n best_path_orbits.reset();\n /*\n * Reset group size\n */\n stats.group_size.assign(1);\n stats.group_size_approx = 1.0;\n /*\n * Reset all_same_level\n */\n all_same_level = child_level;\n /*\n * Mark the current path to be the first and best one and save it\n */\n const unsigned int base_size = search_stack.size();\n best_path_info.clear();\n // fprintf(stdout, \" New base is: \");\n for (unsigned int i = 0; i < base_size; i++) {\n search_stack[i].fp_on = true;\n search_stack[i].fp_cert_equal = true;\n search_stack[i].fp_extendable = TreeNode::YES;\n search_stack[i].in_best_path = true;\n search_stack[i].cmp_to_best_path = 0;\n PathInfo path_info;\n path_info.splitting_element = search_stack[i].split_element;\n path_info.certificate_index = search_stack[i].certificate_index;\n path_info.eqref_hash = search_stack[i].eqref_hash;\n path_info.subcertificate_length = search_stack[i].subcertificate_length;\n first_path_info.push_back(path_info);\n best_path_info.push_back(path_info);\n // fprintf(stdout, \"%u \", search_stack[i].split_element);\n }\n // fprintf(stdout, \"\\n\"); fflush(stdout);\n /* Copy certificates */\n certificate_first_path = certificate_current_path;\n certificate_best_path = certificate_current_path;\n\n /* From now on, compare certificates when refining */\n refine_compare_certificate = true;\n\n if (opt_use_failure_recording)\n failure_recording_hashes.resize(base_size);\n\n /*\n for(unsigned int j = 0; j < search_stack.size(); j++)\n fprintf(stderr, \"%u \", search_stack[j].split_element);\n fprintf(stderr, \"\\n\");\n p.print(stderr); fprintf(stderr, \"\\n\");\n */\n\n /*\n * Backtrack to the previous level\n */\n continue;\n }\n\n if (p.is_discrete() and child_node.fp_cert_equal) {\n /*\n * A leaf node that is equal to the first one.\n * An automorphism found: aut[i] = elements[first_path_labeling[i]]\n */\n goto handle_first_path_automorphism;\n }\n\n if (!p.is_discrete()) {\n Partition::Cell* next_split_cell = 0;\n /*\n * An internal, non-leaf node\n */\n if (opt_use_comprec) {\n assert(p.nof_discrete_cells() <=\n cr_cep_stack[cr_cep_index].discrete_cell_limit);\n assert(cr_level == child_node.cr_level);\n\n if (p.nof_discrete_cells() ==\n cr_cep_stack[cr_cep_index].discrete_cell_limit) {\n /* We have reached the end of a component */\n assert(cr_cep_index != 0);\n CR_CEP& cep = cr_cep_stack[cr_cep_index];\n\n /* First, compare with respect to the first path */\n if (first_path_info.empty() or child_node.fp_cert_equal) {\n if (cep.first_checked == false) {\n /* First time, go to the next component */\n cep.first_checked = true;\n } else {\n assert(!first_path_info.empty());\n assert(cep.creation_level < search_stack.size());\n TreeNode& old_info = search_stack[cep.creation_level];\n /* If the component was found when on the first path,\n * handle the found automorphism as the other\n * first path automorphisms */\n if (old_info.fp_on)\n goto handle_first_path_automorphism;\n }\n }\n\n if (canonical and !first_path_info.empty() and\n child_node.cmp_to_best_path >= 0) {\n if (cep.best_checked == false) {\n /* First time, go to the next component */\n cep.best_checked = true;\n } else {\n assert(cep.creation_level < search_stack.size());\n TreeNode& old_info = search_stack[cep.creation_level];\n if (child_node.cmp_to_best_path == 0) {\n /* If the component was found when on the best path,\n * handle the found automorphism as the other\n * best path automorphisms */\n if (old_info.in_best_path)\n goto handle_best_path_automorphism;\n /* Otherwise, we do not remember the automorhism as\n * we didn't memorize the path that was invariant\n * equal to the best one and passed through the\n * component.\n * Thus we can only backtrack to the previous level */\n child_node.cmp_to_best_path = -1;\n if (!child_node.fp_cert_equal) {\n continue;\n }\n } else {\n assert(child_node.cmp_to_best_path > 0);\n if (old_info.in_best_path) {\n stats.nof_canupdates++;\n /*\n * Update canonical labeling and its inverse\n */\n for (unsigned int i = 0; i < N; i++) {\n if (p.get_cell(p.elements[i])->is_unit()) {\n best_path_labeling[p.elements[i]] = i;\n best_path_labeling_inv[i] = p.elements[i];\n }\n }\n // update_labeling_and_its_inverse(best_path_labeling,\n // best_path_labeling_inv);\n /* Reset best path automorphism */\n reset_permutation(best_path_automorphism);\n /* Reset best path orbit structure */\n best_path_orbits.reset();\n /* Mark to be the best one and save prefix */\n unsigned int postfix_start = cep.creation_level;\n assert(postfix_start < best_path_info.size());\n while (p.get_cell(\n best_path_info[postfix_start].splitting_element)\n ->is_unit()) {\n postfix_start++;\n assert(postfix_start < best_path_info.size());\n }\n unsigned int postfix_start_cert =\n best_path_info[postfix_start].certificate_index;\n std::vector best_path_temp = best_path_info;\n best_path_info.clear();\n for (unsigned int i = 0; i < search_stack.size(); i++) {\n TreeNode& ss_info = search_stack[i];\n PathInfo bp_info;\n ss_info.cmp_to_best_path = 0;\n ss_info.in_best_path = true;\n bp_info.splitting_element = ss_info.split_element;\n bp_info.certificate_index = ss_info.certificate_index;\n bp_info.subcertificate_length =\n ss_info.subcertificate_length;\n bp_info.eqref_hash = ss_info.eqref_hash;\n best_path_info.push_back(bp_info);\n }\n /* Copy the postfix of the previous best path */\n for (unsigned int i = postfix_start;\n i < best_path_temp.size(); i++) {\n best_path_info.push_back(best_path_temp[i]);\n best_path_info[best_path_info.size() - 1]\n .certificate_index =\n best_path_info[best_path_info.size() - 2]\n .certificate_index +\n best_path_info[best_path_info.size() - 2]\n .subcertificate_length;\n }\n std::vector certificate_best_path_old =\n certificate_best_path;\n certificate_best_path = certificate_current_path;\n for (unsigned int i = postfix_start_cert;\n i < certificate_best_path_old.size(); i++)\n certificate_best_path.push_back(\n certificate_best_path_old[i]);\n assert(certificate_best_path.size() ==\n best_path_info.back().certificate_index +\n best_path_info.back().subcertificate_length);\n /* Backtrack to the previous level */\n continue;\n }\n }\n }\n }\n\n /* No backtracking performed, go to next componenet */\n cr_level = cep.next_cr_level;\n cr_cep_index = cep.next_cep_index;\n }\n\n /* Check if the current component has been split into\n * new non-uniformity subcomponents */\n // if(nucr_find_first_component(cr_level) == true and\n // p.nof_discrete_cells() + cr_component_elements <\n // cr_cep_stack[cr_cep_index].discrete_cell_limit)\n if (nucr_find_first_component(cr_level, cr_component,\n cr_component_elements,\n next_split_cell) == true and\n p.nof_discrete_cells() + cr_component_elements <\n cr_cep_stack[cr_cep_index].discrete_cell_limit) {\n const unsigned int next_cr_level =\n p.cr_split_level(cr_level, cr_component);\n CR_CEP cep;\n cep.creation_level = search_stack.size();\n cep.discrete_cell_limit =\n p.nof_discrete_cells() + cr_component_elements;\n cep.next_cr_level = cr_level;\n cep.next_cep_index = cr_cep_index;\n cep.first_checked = false;\n cep.best_checked = false;\n cr_cep_index = cr_cep_stack.size();\n cr_cep_stack.push_back(cep);\n cr_level = next_cr_level;\n }\n }\n\n /*\n * Build the next node info\n */\n /* Find the next cell to be splitted */\n if (!next_split_cell)\n next_split_cell = find_next_cell_to_be_splitted(\n p.get_cell(p.elements[current_node.split_cell_first]));\n // Partition::Cell * const next_split_cell =\n // find_next_cell_to_be_splitted(p.get_cell(p.elements[current_node.split_cell_first]));\n child_node.split_cell_first = next_split_cell->first;\n child_node.split_element = TreeNode::SPLIT_START;\n child_node.certificate_index = certificate_index;\n child_node.partition_bt_point = p.set_backtrack_point();\n child_node.long_prune_redundant.clear();\n child_node.long_prune_begin = current_node.long_prune_begin;\n\n /* Save component recursion info for backtracking */\n child_node.cr_level = cr_level;\n child_node.cr_cep_stack_size = cr_cep_stack.size();\n child_node.cr_cep_index = cr_cep_index;\n\n search_stack.push_back(child_node);\n continue;\n }\n\n /*\n * A leaf node not in the first path or equivalent to the first path\n */\n\n if (child_node.cmp_to_best_path > 0) {\n /*\n * A new, better representative found\n */\n // fprintf(stdout, \"Level %u: NEW BEST\\n\", child_level); fflush(stdout);\n stats.nof_canupdates++;\n /*\n * Update canonical labeling and its inverse\n */\n update_labeling_and_its_inverse(best_path_labeling,\n best_path_labeling_inv);\n /* Reset best path automorphism */\n reset_permutation(best_path_automorphism);\n /* Reset best path orbit structure */\n best_path_orbits.reset();\n /*\n * Mark the current path to be the best one and save it\n */\n const unsigned int base_size = search_stack.size();\n assert(current_level + 1 == base_size);\n best_path_info.clear();\n for (unsigned int i = 0; i < base_size; i++) {\n search_stack[i].cmp_to_best_path = 0;\n search_stack[i].in_best_path = true;\n PathInfo path_info;\n path_info.splitting_element = search_stack[i].split_element;\n path_info.certificate_index = search_stack[i].certificate_index;\n path_info.subcertificate_length = search_stack[i].subcertificate_length;\n path_info.eqref_hash = search_stack[i].eqref_hash;\n best_path_info.push_back(path_info);\n }\n certificate_best_path = certificate_current_path;\n /*\n * Backtrack to the previous level\n */\n continue;\n }\n\n handle_best_path_automorphism:\n /*\n *\n * Best path automorphism handling\n *\n */\n {\n\n /*\n * Equal to the previous best path\n */\n if (p.is_discrete()) {\n#if defined(BLISS_CONSISTENCY_CHECKS)\n /* Verify that the automorphism is correctly built */\n for (unsigned int i = 0; i < N; i++)\n assert(best_path_automorphism[i] ==\n p.elements[best_path_labeling[i]]);\n#endif\n } else {\n /* An automorphism that was found before the partition was discrete.\n * Set the image of all elements in non-disrete cells accordingly */\n for (Partition::Cell* c = p.first_nonsingleton_cell; c;\n c = c->next_nonsingleton) {\n for (unsigned int i = c->first; i < c->first + c->length; i++)\n if (p.get_cell(p.elements[best_path_labeling[p.elements[i]]])\n ->is_unit())\n best_path_automorphism\n [p.elements[best_path_labeling[p.elements[i]]]] =\n p.elements[i];\n else\n best_path_automorphism[p.elements[i]] = p.elements[i];\n }\n }\n\n#if defined(BLISS_VERIFY_AUTOMORPHISMS)\n /* Verify that it really is an automorphism */\n if (!is_automorphism(best_path_automorphism))\n fatal_error(\"Best path automorhism validation check failed\");\n#endif\n\n unsigned int gca_level_with_first = 0;\n for (unsigned int i = search_stack.size(); i > 0; i--) {\n if ((int)first_path_info[gca_level_with_first].splitting_element !=\n search_stack[gca_level_with_first].split_element)\n break;\n gca_level_with_first++;\n }\n\n unsigned int gca_level_with_best = 0;\n for (unsigned int i = search_stack.size(); i > 0; i--) {\n if ((int)best_path_info[gca_level_with_best].splitting_element !=\n search_stack[gca_level_with_best].split_element)\n break;\n gca_level_with_best++;\n }\n\n if (opt_use_long_prune) {\n /* Record automorphism */\n long_prune_add_automorphism(best_path_automorphism);\n }\n\n /*\n * Update orbit information\n */\n update_orbit_information(best_path_orbits, best_path_automorphism);\n\n /*\n * Update orbit information\n */\n const unsigned int nof_old_orbits = first_path_orbits.nof_orbits();\n update_orbit_information(first_path_orbits, best_path_automorphism);\n if (nof_old_orbits != first_path_orbits.nof_orbits()) {\n /* Some orbits were merged */\n /* Report automorphism */\n if (report_hook)\n (*report_hook)(report_user_param, get_nof_vertices(),\n best_path_automorphism);\n /* Update statistics */\n stats.nof_generators++;\n }\n\n /*\n * Compute backjumping level\n */\n unsigned int backjumping_level = current_level + 1 - 1;\n if (!first_path_orbits.is_minimal_representative(\n search_stack[gca_level_with_first].split_element)) {\n backjumping_level = gca_level_with_first;\n } else {\n assert(!best_path_orbits.is_minimal_representative(\n search_stack[gca_level_with_best].split_element));\n backjumping_level = gca_level_with_best;\n }\n /* Backtrack */\n search_stack.resize(backjumping_level + 1);\n continue;\n }\n _INTERNAL_ERROR();\n\n handle_first_path_automorphism:\n /*\n *\n * A first-path automorphism: aut[i] = elements[first_path_labeling[i]]\n *\n */\n\n if (p.is_discrete()) {\n#if defined(BLISS_CONSISTENCY_CHECKS)\n /* Verify that the complete automorphism is correctly built */\n for (unsigned int i = 0; i < N; i++)\n assert(first_path_automorphism[i] ==\n p.elements[first_path_labeling[i]]);\n#endif\n } else {\n /* An automorphism that was found before the partition was discrete.\n * Set the image of all elements in non-disrete cells accordingly */\n for (Partition::Cell* c = p.first_nonsingleton_cell; c;\n c = c->next_nonsingleton) {\n for (unsigned int i = c->first; i < c->first + c->length; i++)\n if (p.get_cell(p.elements[first_path_labeling[p.elements[i]]])\n ->is_unit())\n first_path_automorphism\n [p.elements[first_path_labeling[p.elements[i]]]] =\n p.elements[i];\n else\n first_path_automorphism[p.elements[i]] = p.elements[i];\n }\n }\n\n#if defined(BLISS_VERIFY_AUTOMORPHISMS)\n /* Verify that it really is an automorphism */\n if (!is_automorphism(first_path_automorphism))\n fatal_error(\"First path automorphism validation check failed\");\n#endif\n\n if (opt_use_long_prune) {\n long_prune_add_automorphism(first_path_automorphism);\n }\n\n /*\n * Update orbit information\n */\n update_orbit_information(first_path_orbits, first_path_automorphism);\n\n /*\n * Compute backjumping level\n */\n for (unsigned int i = 0; i < search_stack.size(); i++) {\n TreeNode& n = search_stack[i];\n if (n.fp_on) {\n ;\n } else {\n n.fp_extendable = TreeNode::YES;\n }\n }\n\n /* Report automorphism by calling the user defined hook function */\n if (report_hook)\n (*report_hook)(report_user_param, get_nof_vertices(),\n first_path_automorphism);\n\n /* Update statistics */\n stats.nof_generators++;\n continue;\n\n } /* while(!search_stack.empty()) */\n\n /* Free \"long prune\" technique memory */\n if (opt_use_long_prune)\n long_prune_deallocate();\n\n /* Release component recursion data in partition */\n if (opt_use_comprec)\n p.cr_free();\n}\n" }, { "path": "external/bliss/bliss/uintseqhash.hh", "content": "#ifndef BLISS_UINTSEQHASH_HH\n#define BLISS_UINTSEQHASH_HH\n\n#include \nnamespace bliss {\nstatic unsigned int rtab[256] = {\n\t0xAEAA35B8, 0x65632E16, 0x155EDBA9, 0x01349B39,\n\t0x8EB8BD97, 0x8E4C5367, 0x8EA78B35, 0x2B1B4072,\n\t0xC1163893, 0x269A8642, 0xC79D7F6D, 0x6A32DEA0,\n\t0xD4D2DA56, 0xD96D4F47, 0x47B5F48A, 0x2587C6BF,\n\t0x642B71D8, 0x5DBBAF58, 0x5C178169, 0xA16D9279,\n\t0x75CDA063, 0x291BC48B, 0x01AC2F47, 0x5416DF7C,\n\t0x45307514, 0xB3E1317B, 0xE1C7A8DE, 0x3ACDAC96,\n\t0x11B96831, 0x32DE22DD, 0x6A1DA93B, 0x58B62381,\n\t0x283810E2, 0xBC30E6A6, 0x8EE51705, 0xB06E8DFB,\n\t0x729AB12A, 0xA9634922, 0x1A6E8525, 0x49DD4E19,\n\t0xE5DB3D44, 0x8C5B3A02, 0xEBDE2864, 0xA9146D9F,\n\t0x736D2CB4, 0xF5229F42, 0x712BA846, 0x20631593,\n\t0x89C02603, 0xD5A5BF6A, 0x823F4E18, 0x5BE5DEFF,\n\t0x1C4EBBFA, 0x5FAB8490, 0x6E559B0C, 0x1FE528D6,\n\t0xB3198066, 0x4A965EB5, 0xFE8BB3D5, 0x4D2F6234,\n\t0x5F125AA4, 0xBCC640FA, 0x4F8BC191, 0xA447E537,\n\t0xAC474D3C, 0x703BFA2C, 0x617DC0E7, 0xF26299D7,\n\t0xC90FD835, 0x33B71C7B, 0x6D83E138, 0xCBB1BB14,\n\t0x029CF5FF, 0x7CBD093D, 0x4C9825EF, 0x845C4D6D,\n\t0x124349A5, 0x53942D21, 0x800E60DA, 0x2BA6EB7F,\n\t0xCEBF30D3, 0xEB18D449, 0xE281F724, 0x58B1CB09,\n\t0xD469A13D, 0x9C7495C3, 0xE53A7810, 0xA866C08E,\n\t0x832A038B, 0xDDDCA484, 0xD5FE0DDE, 0x0756002B,\n\t0x2FF51342, 0x60FEC9C8, 0x061A53E3, 0x47B1884E,\n\t0xDC17E461, 0xA17A6A37, 0x3158E7E2, 0xA40D873B,\n\t0x45AE2140, 0xC8F36149, 0x63A4EE2D, 0xD7107447,\n\t0x6F90994F, 0x5006770F, 0xC1F3CA9A, 0x91B317B2,\n\t0xF61B4406, 0xA8C9EE8F, 0xC6939B75, 0xB28BBC3B,\n\t0x36BF4AEF, 0x3B12118D, 0x4D536ECF, 0x9CF4B46B,\n\t0xE8AB1E03, 0x8225A360, 0x7AE4A130, 0xC4EE8B50,\n\t0x50651797, 0x5BB4C59F, 0xD120EE47, 0x24F3A386,\n\t0xBE579B45, 0x3A378EFC, 0xC5AB007B, 0x3668942B,\n\t0x2DBDCC3A, 0x6F37F64C, 0xC24F862A, 0xB6F97FCF,\n\t0x9E4FA23D, 0x551AE769, 0x46A8A5A6, 0xDC1BCFDD,\n\t0x8F684CF9, 0x501D811B, 0x84279F80, 0x2614E0AC,\n\t0x86445276, 0xAEA0CE71, 0x0812250F, 0xB586D18A,\n\t0xC68D721B, 0x44514E1D, 0x37CDB99A, 0x24731F89,\n\t0xFA72E589, 0x81E6EBA2, 0x15452965, 0x55523D9D,\n\t0x2DC47E14, 0x2E7FA107, 0xA7790F23, 0x40EBFDBB,\n\t0x77E7906B, 0x6C1DB960, 0x1A8B9898, 0x65FA0D90,\n\t0xED28B4D8, 0x34C3ED75, 0x768FD2EC, 0xFAB60BCB,\n\t0x962C75F4, 0x304F0498, 0x0A41A36B, 0xF7DE2A4A,\n\t0xF4770FE2, 0x73C93BBB, 0xD21C82C5, 0x6C387447,\n\t0x8CDB4CB9, 0x2CC243E8, 0x41859E3D, 0xB667B9CB,\n\t0x89681E8A, 0x61A0526C, 0x883EDDDC, 0x539DE9A4,\n\t0xC29E1DEC, 0x97C71EC5, 0x4A560A66, 0xBD7ECACF,\n\t0x576AE998, 0x31CE5616, 0x97172A6C, 0x83D047C4,\n\t0x274EA9A8, 0xEB31A9DA, 0x327209B5, 0x14D1F2CB,\n\t0x00FE1D96, 0x817DBE08, 0xD3E55AED, 0xF2D30AFC,\n\t0xFB072660, 0x866687D6, 0x92552EB9, 0xEA8219CD,\n\t0xF7927269, 0xF1948483, 0x694C1DF5, 0xB7D8B7BF,\n\t0xFFBC5D2F, 0x2E88B849, 0x883FD32B, 0xA0331192,\n\t0x8CB244DF, 0x41FAF895, 0x16902220, 0x97FB512A,\n\t0x2BEA3CC4, 0xAF9CAE61, 0x41ACD0D5, 0xFD2F28FF,\n\t0xE780ADFA, 0xB3A3A76E, 0x7112AD87, 0x7C3D6058,\n\t0x69E64FFF, 0xE5F8617C, 0x8580727C, 0x41F54F04,\n\t0xD72BE498, 0x653D1795, 0x1275A327, 0x14B499D4,\n\t0x4E34D553, 0x4687AA39, 0x68B64292, 0x5C18ABC3,\n\t0x41EABFCC, 0x92A85616, 0x82684CF8, 0x5B9F8A4E,\n\t0x35382FFE, 0xFB936318, 0x52C08E15, 0x80918B2E,\n\t0x199EDEE0, 0xA9470163, 0xEC44ACDD, 0x612D6735,\n\t0x8F88EA7D, 0x759F5EA4, 0xE5CC7240, 0x68CFEB8B,\n\t0x04725601, 0x0C22C23E, 0x5BC97174, 0x89965841,\n\t0x5D939479, 0x690F338A, 0x3C2D4380, 0xDAE97F2B\n};\n\n// A hash for sequences of unsigned ints.\nclass UintSeqHash {\nprotected:\n\tunsigned int h;\npublic:\n\tUintSeqHash() {h = 0; }\n\tUintSeqHash(const UintSeqHash &other) {h = other.h; }\n\tUintSeqHash& operator=(const UintSeqHash &other) {h = other.h; return *this; }\n\t/** Reset the hash value. */\n\tvoid reset() {h = 0; }\n\t/** Add the unsigned int \\a n to the sequence. */\n\tvoid update(unsigned int i) {\n\t\ti++;\n\t\twhile(i > 0) {\n\t\t\th ^= rtab[i & 0xff];\n\t\t\tconst unsigned int b = (h & 0x80000000) >> 31;\n\t\t\ti = i >> 8;\n\t\t\th = (h << 1) | b;\n\t\t}\n\t}\n\t/** Get the hash value of the sequence seen so far. */\n\tunsigned int get_value() const {return h; }\n\t/** Compare the hash values of this and \\a other.\n\t * Return -1/0/1 if the value of this is smaller/equal/greater than\n\t * that of \\a other. */\n\tint cmp(const UintSeqHash &other) const {\n\t\treturn (h < other.h)?-1:((h == other.h)?0:1);\n\t}\n\t/** An abbreviation for cmp(other) < 0 */\n\tbool is_lt(const UintSeqHash &other) const {return(cmp(other) < 0); }\n\t/** An abbreviation for cmp(other) <= 0 */\n\tbool is_le(const UintSeqHash &other) const {return(cmp(other) <= 0); }\n\t/** An abbreviation for cmp(other) == 0 */\n\tbool is_equal(const UintSeqHash &other) const {return(cmp(other) == 0); }\n};\n} // namespace bliss\n#endif\n" }, { "path": "external/bliss/bliss/utils.hh", "content": "#ifndef BLISS_UTILS_HH\n#define BLISS_UTILS_HH\n\n/*\n Copyright (c) 2003-2015 Tommi Junttila\n Released under the GNU Lesser General Public License version 3.\n \n This file is part of bliss.\n \n bliss is free software: you can redistribute it and/or modify\n it under the terms of the GNU Lesser General Public License as published by\n the Free Software Foundation, version 3 of the License.\n\n bliss is distributed in the hope that it will be useful,\n but WITHOUT ANY WARRANTY; without even the implied warranty of\n MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n GNU Lesser General Public License for more details.\n\n You should have received a copy of the GNU Lesser General Public License\n along with bliss. If not, see .\n*/\n\n/**\n * \\file\n * \\brief Some small utilities.\n *\n */\n\n#include \n\nnamespace bliss {\n\n/**\n * Print the permutation \\a perm of {0,...,N-1} in the cycle format\n * in the file stream \\a fp.\n * The amount \\a offset is added to each element before printing,\n * e.g. the permutation (2 4) is printed as (3 5) when \\a offset is 1.\n */\nvoid print_permutation(FILE* fp,\n\t\t const unsigned int N,\n\t\t const unsigned int* perm,\n\t\t const unsigned int offset = 0);\n\n/**\n * Print the permutation \\a perm of {0,...,N-1} in the cycle format\n * in the file stream \\a fp.\n * The amount \\a offset is added to each element before printing,\n * e.g. the permutation (2 4) is printed as (3 5) when \\a offset is 1.\n */\nvoid print_permutation(FILE* fp,\n\t\t const std::vector& perm,\n\t\t const unsigned int offset = 0);\n\n/**\n * Check whether \\a perm is a valid permutation on {0,...,N-1}.\n * Slow, mainly for debugging and validation purposes.\n */\nbool is_permutation(const unsigned int N, const unsigned int* perm);\n\n/**\n * Check whether \\a perm is a valid permutation on {0,...,N-1}.\n * Slow, mainly for debugging and validation purposes.\n */\nbool is_permutation(const std::vector& perm);\n\n} // namespace bliss\n\n#endif\n" }, { "path": "inputs/CMakeLists.txt", "content": "file(WRITE ${CMAKE_CURRENT_BINARY_DIR}/download.cmake \"file(DOWNLOAD http://iss.oden.utexas.edu/projects/galois/downloads/small_inputs_for_lonestar_test.tar.gz ${CMAKE_CURRENT_BINARY_DIR}/lonestar-cpu-inputs.tar.gz SHOW_PROGRESS)\")\n\nadd_custom_command(\nOUTPUT lonestar-cpu-inputs.tar.gz\nCOMMAND ${CMAKE_COMMAND} -P ${CMAKE_CURRENT_BINARY_DIR}/download.cmake\n)\n\nadd_custom_command(\nOUTPUT small_inputs\nCOMMAND ${CMAKE_COMMAND} -E tar xJf lonestar-cpu-inputs.tar.gz\nDEPENDS lonestar-cpu-inputs.tar.gz\nWORKING_DIRECTORY ${PROJECT_BINARY_DIR}/inputs\nCOMMENT \"Unpacking lonestar-cpu-inputs.tar.gz\"\nVERBATIM\n)\n\nadd_custom_target(input DEPENDS small_inputs)\n" }, { "path": "inputs/cholesky/matrix1.txt", "content": "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", "content": "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 4 1.341641\n3 5 -0.223607\n4 4 2.280351\n4 5 1.447146\n5 5 2.649063\n" }, { "path": "inputs/cholesky/matrix1.txt.dep", "content": "0 1 2 3 4 5\n" }, { "path": "inputs/cholesky/matrix1.txt.filled", "content": "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 3.000000\n3 5 0.000000\n4 4 7.000000\n4 5 3.000000\n5 5 11.000000\n" }, { "path": "inputs/cholesky/very-sparse.txt", "content": "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\t0.0\t0.0\n0.0\t0.0\t0.0\t144.0\t0.0\t0.0\t0.0\t0.0\t0.0\t0.0\n0.0\t0.0\t0.0\t0.0\t144.0\t0.0\t0.0\t0.0\t0.0\t0.0\n0.0\t0.0\t0.0\t0.0\t0.0\t2304.0\t0.0\t1200.0\t0.0\t0.0\n0.0\t0.0\t0.0\t0.0\t0.0\t0.0\t324.0\t0.0\t0.0\t0.0\n0.0\t0.0\t0.0\t0.0\t0.0\t1200.0\t0.0\t641.0\t0.0\t0.0\n0.0\t0.0\t0.0\t0.0\t0.0\t0.0\t0.0\t0.0\t9.0\t0.0\n0.0\t256.0\t0.0\t0.0\t0.0\t0.0\t0.0\t0.0\t0.0\t1040.0\n" }, { "path": "inputs/cholesky/very-sparse.txt.choleskyedges", "content": "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.000000\n7 7 4.000000\n8 8 3.000000\n9 9 28.000000\n" }, { "path": "inputs/cholesky/very-sparse.txt.dep", "content": "0 1 2 3 4 5 6 7 8 9\n" }, { "path": "inputs/cholesky/very-sparse.txt.filled", "content": "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.000000\n6 6 324.000000\n7 7 641.000000\n8 8 9.000000\n9 9 1040.000000\n" }, { "path": "libcusp/CMakeLists.txt", "content": "add_library(galois_cusp INTERFACE)\nadd_library(Galois::cusp ALIAS galois_cusp)\nset_target_properties(galois_cusp PROPERTIES EXPORT_NAME cusp)\nadd_dependencies(lib galois_cusp)\n\ntarget_include_directories(galois_cusp INTERFACE\n $\n $\n)\n\ntarget_link_libraries(galois_cusp INTERFACE galois_dist_async)\n\ninstall(\n DIRECTORY include/\n DESTINATION \"${CMAKE_INSTALL_INCLUDEDIR}\"\n COMPONENT dev\n FILES_MATCHING PATTERN \"*.h\"\n)\n\ninstall(TARGETS galois_cusp\n EXPORT GaloisTargets\n LIBRARY\n DESTINATION \"${CMAKE_INSTALL_LIBDIR}\"\n COMPONENT shlib\n ARCHIVE\n DESTINATION \"${CMAKE_INSTALL_LIBDIR}\"\n COMPONENT lib\n INCLUDES DESTINATION \"${CMAKE_INSTALL_INCLUDEDIR}\"\n)\n" }, { "path": "libcusp/include/galois/graphs/BasePolicies.h", "content": "/*\n * This file belongs to the Galois project, a C++ library for exploiting\n * parallelism. The code is being released under the terms of the 3-Clause BSD\n * License (a copy is located in LICENSE.txt at the top-level directory).\n *\n * Copyright (C) 2019, The University of Texas at Austin. All rights reserved.\n * UNIVERSITY EXPRESSLY DISCLAIMS ANY AND ALL WARRANTIES CONCERNING THIS\n * SOFTWARE AND DOCUMENTATION, INCLUDING ANY WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR ANY PARTICULAR PURPOSE, NON-INFRINGEMENT AND WARRANTIES OF\n * PERFORMANCE, AND ANY WARRANTY THAT MIGHT OTHERWISE ARISE FROM COURSE OF\n * DEALING OR USAGE OF TRADE. NO WARRANTY IS EITHER EXPRESS OR IMPLIED WITH\n * RESPECT TO THE USE OF THE SOFTWARE OR DOCUMENTATION. Under no circumstances\n * shall University be liable for incidental, special, indirect, direct or\n * consequential damages or loss of profits, interruption of business, or\n * related expenses which may arise from use of Software or Documentation,\n * including but not limited to those resulting from defects in Software and/or\n * Documentation, or loss or inaccuracy of data of any kind.\n */\n\n/**\n * @file BasePolicies.h\n *\n * Header file that includes the base classes for defining CuSP partitioning\n * policies.\n */\n\n#ifndef _GALOIS_CUSP_PSCAFFOLD_H_\n#define _GALOIS_CUSP_PSCAFFOLD_H_\n\nnamespace galois {\nnamespace graphs {\n\n/**\n * Default fields and functions all CuSP partitioners use; this is a class to\n * inherit from.\n */\nclass PartitioningScaffold {\nprotected:\n uint32_t _hostID; //!< host ID of owner of this object\n uint32_t _numHosts; //!< total number of hosts\n uint64_t _numNodes; //!< number of nodes in graph\n uint64_t _numEdges; //!< number of edges in graph\n //! maps from host id to nodes that host as read from disk\n std::vector> _gid2host;\n\npublic:\n /**\n * Constructor for Scaffold.\n *\n * @param hostID Host ID of caller\n * @param numHosts Total num hosts in execution\n * @param numNodes Total number of nodes in graph\n * @param numEdges Total number of edges in graph\n */\n PartitioningScaffold(uint32_t hostID, uint32_t numHosts, uint64_t numNodes,\n uint64_t numEdges)\n : _hostID(hostID), _numHosts(numHosts), _numNodes(numNodes),\n _numEdges(numEdges) {}\n\n /**\n * Save a provided map from host to nodes a host has read into this object\n *\n * @param gid2host Map of hosts to read nodes to save\n */\n void saveGIDToHost(std::vector>& gid2host) {\n _gid2host = gid2host;\n }\n};\n\n/**\n * Policies that use the read assignment of nodes as the masters. Does not\n * need to go through a master assignment phase, saving overhead.\n */\nclass ReadMasterAssignment : public PartitioningScaffold {\npublic:\n /**\n * Constructor simply calls parent constructor.\n */\n ReadMasterAssignment(uint32_t hostID, uint32_t numHosts, uint64_t numNodes,\n uint64_t numEdges)\n : PartitioningScaffold(hostID, numHosts, numNodes, numEdges) {}\n\n /**\n * Returns the host ID of the host that read a particular node and its edges\n * from disk.\n *\n * @param gid GID of node to get master of\n * @returns Host ID of host that read the node specified by the GID.\n */\n uint32_t retrieveMaster(uint32_t gid) const {\n for (auto h = 0U; h < _numHosts; ++h) {\n uint64_t start, end;\n std::tie(start, end) = _gid2host[h];\n if (gid >= start && gid < end) {\n return h;\n }\n }\n assert(false);\n return _numHosts;\n }\n\n // below all unused if not assigning masters in default manner, but must be\n // defined or compiler complains\n\n /**\n * Returns false as this partitioning policy doesn't have a master assignment\n * phase.\n */\n bool masterAssignPhase() const { return false; }\n /**\n * Does nothing as this policy doesn't have a master assignment phase\n */\n void enterStage2() {}\n\n /**\n * Does nothing because this policy doesn't have a master assignment phase.\n * (uses read assignment)\n */\n template \n uint32_t getMaster(uint32_t, galois::graphs::BufferedGraph&,\n const std::vector&,\n std::unordered_map&,\n const std::vector&,\n std::vector>&,\n const std::vector&,\n std::vector>&) {\n return 0;\n }\n\n /**\n * No-op because no master assignment phase.\n */\n void saveGID2HostInfo(std::unordered_map&,\n std::vector&, uint64_t) {}\n /**\n * Technically doesn't nothing and should never be called because no master\n * assignment phase.\n */\n bool addMasterMapping(uint32_t, uint32_t) { return false; }\n};\n\n/**\n * Policies that use a custom assignment of masters (from the user).\n * Needs to go through a master assignment phase, which adds overhead\n * to partitioning, but may get better quality partitions.\n */\nclass CustomMasterAssignment : public PartitioningScaffold {\nprotected:\n char _status; //!< Specifies what phase of master assignment partitioner is on\n //! Metadata for determining where a node's master is\n std::vector _localNodeToMaster;\n //! Map GID to its master\n std::unordered_map _gid2masters;\n //! This host's node offset (each host reads a distinct contiguous portion\n //! of graph\n uint64_t _nodeOffset;\n\n /**\n * Return the reader of a particular node.\n * @param gid GID of node to get reader of\n * @return Host reader of node passed in as param\n */\n unsigned getHostReader(uint64_t gid) const {\n for (auto i = 0U; i < _numHosts; ++i) {\n uint64_t start, end;\n std::tie(start, end) = _gid2host[i];\n if (gid >= start && gid < end) {\n return i;\n }\n }\n return -1;\n }\n\npublic:\n //! Calls parent constructor to initialize common data\n CustomMasterAssignment(uint32_t hostID, uint32_t numHosts, uint64_t numNodes,\n uint64_t numEdges)\n : PartitioningScaffold(hostID, numHosts, numNodes, numEdges), _status(0) {\n }\n\n /**\n * Retrieves a saved master mapping: does not fail if a GID\n * mapping is not found but instead returns -1 if in stage 1, else\n * fails.\n *\n * @param gid GID to get master of\n * @returns Master of specified GID, -1, unsigned, if not found\n */\n uint32_t retrieveMaster(uint32_t gid) const {\n if (_status != 0) {\n // use map if not a locally read node, else use vector\n if (getHostReader(gid) != _hostID) {\n auto gidMasterIter = _gid2masters.find(gid);\n // found in map\n if (gidMasterIter != _gid2masters.end()) {\n uint32_t mappedMaster = gidMasterIter->second;\n // galois::gDebug(\"[\", _hostID, \"] \", gid, \" found with master \",\n // mappedMaster, \"!\");\n // make sure host is in bounds\n assert(mappedMaster < _numHosts);\n return mappedMaster;\n } else {\n // NOT FOUND (not necessarily a bad thing, and required for\n // some cases)\n galois::gDebug(\"[\", _hostID, \"] \", gid, \" not found!\");\n if (_status == 2) {\n // die if we expect all gids to be mapped already (stage 2)\n GALOIS_DIE(\"should not fail to find a GID after stage 2 \"\n \"of master assignment phase\");\n }\n return (uint32_t)-1;\n }\n } else {\n // determine offset\n uint32_t offsetIntoMap = gid - _nodeOffset;\n assert(offsetIntoMap != (uint32_t)-1);\n assert(offsetIntoMap < _localNodeToMaster.size());\n return _localNodeToMaster[offsetIntoMap];\n }\n } else {\n // stage 0 = this function shouldn't be called\n GALOIS_DIE(\"master setup incomplete\");\n return (uint32_t)-1;\n }\n }\n\n /**\n * Given gid to master mapping info, save it into a local map.\n *\n * @param gid2offsets Map a GID to an offset into a vector containing master\n * mapping information\n * @param localNodeToMaster Vector that represents the master mapping of\n * local nodes\n * @param nodeOffset First GID of nodes read by this host\n */\n void saveGID2HostInfo(std::unordered_map& gid2offsets,\n std::vector& localNodeToMaster,\n uint64_t nodeOffset) {\n#ifndef NDEBUG\n size_t originalSize = _gid2masters.size();\n#endif\n\n for (auto i = gid2offsets.begin(); i != gid2offsets.end(); i++) {\n assert(i->second < localNodeToMaster.size());\n galois::gDebug(\"Map \", i->first, \" to \", localNodeToMaster[i->second]);\n _gid2masters[i->first] = localNodeToMaster[i->second];\n }\n assert(_gid2masters.size() == (originalSize + gid2offsets.size()));\n // get memory back\n gid2offsets.clear();\n\n size_t myLocalNodes = _gid2host[_hostID].second - _gid2host[_hostID].first;\n assert((myLocalNodes + _gid2masters.size() - originalSize) ==\n localNodeToMaster.size());\n // copy over to this structure\n _localNodeToMaster = std::move(localNodeToMaster);\n assert(myLocalNodes <= _localNodeToMaster.size());\n\n // resize to fit only this host's read nodes\n _localNodeToMaster.resize(myLocalNodes);\n _nodeOffset = nodeOffset;\n\n // stage 1 setup complete\n _status = 1;\n }\n\n //! Returns true as policies that inherit from this should define master\n //! assignment function\n bool masterAssignPhase() const { return true; }\n //! Shifts master assignment phase to stage 2.\n void enterStage2() { _status = 2; }\n\n /**\n * CuSP's \"getMaster\" function.\n * This function should be defined by user in child class to assign a node to\n * a host.\n *\n * @todo Consolidate metadata into single struct to clean up function.\n * @returns Host id in which to assing a node\n */\n template \n uint32_t getMaster(uint32_t, galois::graphs::BufferedGraph&,\n const std::vector&,\n std::unordered_map&,\n const std::vector&,\n std::vector>&,\n const std::vector&,\n std::vector>&) {\n return (uint32_t)-1;\n }\n\n /**\n * Add a new master mapping to the local map: needs to be in stage 1\n *\n * @param gid GID to map; should not be a GID read by this host (won't\n * cause problems, but would just be a waste of compute resouces)\n * @param mappedMaster master to map a GID to\n * @returns true if new mapping added; false if already existed in map\n */\n bool addMasterMapping(uint32_t gid, uint32_t mappedMaster) {\n assert(mappedMaster < _numHosts);\n if (_status <= 1) {\n auto offsetIntoMapIter = _gid2masters.find(gid);\n if (offsetIntoMapIter == _gid2masters.end()) {\n // NOT FOUND\n galois::gDebug(\"[\", _hostID, \"] \", gid, \" not found; mapping!\");\n _gid2masters[gid] = mappedMaster;\n return true;\n } else {\n // already mapped\n galois::gDebug(\"[\", _hostID, \"] \", gid, \" already mapped with master \",\n offsetIntoMapIter->second, \"!\");\n assert(offsetIntoMapIter->second == mappedMaster);\n return false;\n }\n } else {\n GALOIS_DIE(\"unexpected status in add master mapping: \", _status);\n return false;\n }\n }\n};\n\n} // end namespace graphs\n} // end namespace galois\n\n#endif\n" }, { "path": "libcusp/include/galois/graphs/CuSPPartitioner.h", "content": "/*\n * This file belongs to the Galois project, a C++ library for exploiting\n * parallelism. The code is being released under the terms of the 3-Clause BSD\n * License (a copy is located in LICENSE.txt at the top-level directory).\n *\n * Copyright (C) 2019, The University of Texas at Austin. All rights reserved.\n * UNIVERSITY EXPRESSLY DISCLAIMS ANY AND ALL WARRANTIES CONCERNING THIS\n * SOFTWARE AND DOCUMENTATION, INCLUDING ANY WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR ANY PARTICULAR PURPOSE, NON-INFRINGEMENT AND WARRANTIES OF\n * PERFORMANCE, AND ANY WARRANTY THAT MIGHT OTHERWISE ARISE FROM COURSE OF\n * DEALING OR USAGE OF TRADE. NO WARRANTY IS EITHER EXPRESS OR IMPLIED WITH\n * RESPECT TO THE USE OF THE SOFTWARE OR DOCUMENTATION. Under no circumstances\n * shall University be liable for incidental, special, indirect, direct or\n * consequential damages or loss of profits, interruption of business, or\n * related expenses which may arise from use of Software or Documentation,\n * including but not limited to those resulting from defects in Software and/or\n * Documentation, or loss or inaccuracy of data of any kind.\n */\n\n/**\n * @file CuSPPartitioner.h\n *\n * Contains the main CuSP partitioning function.\n */\n\n#ifndef _GALOIS_CUSP_\n#define _GALOIS_CUSP_\n\n#include \"galois/DistGalois.h\"\n#include \"galois/graphs/DistributedGraph.h\"\n#include \"galois/graphs/NewGeneric.h\"\n#include \"galois/graphs/GenericPartitioners.h\"\n\nnamespace galois {\n//! Enum for the input/output format of the partitioner.\nenum CUSP_GRAPH_TYPE {\n CUSP_CSR, //!< Compressed sparse row graph format, i.e. outgoing edges\n CUSP_CSC //!< Compressed sparse column graph format, i.e. incoming edges\n};\n\ntemplate \nusing DistGraphPtr =\n std::unique_ptr>;\n\n/**\n * Main CuSP function: partitions a graph on disk, one partition per host.\n *\n * @param graphFile Graph file to read in the Galois binary CSR format\n * @param inputType Specifies which input format (CSR or CSC) should be given\n * to the partitioner\n * @param outputType Specifies the output format (CSR or CSC) that each\n * partition will be created in\n * @param symmetricGraph This should be \"true\" if the passed in graphFile\n * is a symmetric graph\n * @param transposeGraphFile Transpose graph of graphFile in Galois binary\n * CSC format (i.e. give it the transpose version of graphFile). Ignore\n * this argument if the graph is symmetric.\n * @param masterBlockFile\n * @param cuspAsync Toggles asynchronous master assignment phase during\n * partitioning\n * @param cuspStateRounds Toggles number of rounds used to synchronize\n * partitioning state during master assignment phase\n * @param readPolicy Determines how each host should divide the reading\n * load of the graph on disk\n * @param nodeWeight When using a read policy that involves nodes and edges,\n * this argument assigns a weight to give each node.\n * @param edgeWeight When using a read policy that involves nodes and edges,\n * this argument assigns a weight to give each edge.\n *\n * @tparam PartitionPolicy Partitioning policy object that specifies the\n * placement of nodes/edges during partitioning.\n * @tparam NodeData Data structure to be created for each node in the graph\n * @tparam EdgeData Type of data to be stored on each edge. Currently\n * only guarantee support for void or uint32_t; all other types may cause\n * undefined behavior.\n *\n * @returns A local partition of the passed in graph as a DistributedGraph\n *\n * @todo Look into making void node data work in LargeArray for D-Galois;\n * void specialization. For now, use char as default type\n */\ntemplate \nDistGraphPtr\ncuspPartitionGraph(std::string graphFile, CUSP_GRAPH_TYPE inputType,\n CUSP_GRAPH_TYPE outputType, bool symmetricGraph = false,\n std::string transposeGraphFile = \"\",\n std::string masterBlockFile = \"\", bool cuspAsync = true,\n uint32_t cuspStateRounds = 100,\n galois::graphs::MASTERS_DISTRIBUTION readPolicy =\n galois::graphs::BALANCED_EDGES_OF_MASTERS,\n uint32_t nodeWeight = 0, uint32_t edgeWeight = 0) {\n auto& net = galois::runtime::getSystemNetworkInterface();\n using DistGraphConstructor =\n galois::graphs::NewDistGraphGeneric;\n\n // TODO @todo bring back graph saving/reading functionality?\n\n if (!symmetricGraph) {\n // out edges or in edges\n std::string inputToUse;\n // depending on output type may need to transpose edges\n bool useTranspose;\n\n // see what input is specified\n if (inputType == CUSP_CSR) {\n inputToUse = graphFile;\n if (outputType == CUSP_CSR) {\n useTranspose = false;\n } else if (outputType == CUSP_CSC) {\n useTranspose = true;\n } else {\n GALOIS_DIE(\"CuSP output graph type is invalid\");\n }\n } else if (inputType == CUSP_CSC) {\n inputToUse = transposeGraphFile;\n if (outputType == CUSP_CSR) {\n useTranspose = true;\n } else if (outputType == CUSP_CSC) {\n useTranspose = false;\n } else {\n GALOIS_DIE(\"CuSP output graph type is invalid\");\n }\n } else {\n GALOIS_DIE(\"Invalid input graph type specified in CuSP partitioner\");\n }\n\n return std::make_unique(\n inputToUse, net.ID, net.Num, cuspAsync, cuspStateRounds, useTranspose,\n readPolicy, nodeWeight, edgeWeight, masterBlockFile);\n } else {\n // symmetric graph path: assume the passed in graphFile is a symmetric\n // graph; output is also symmetric\n return std::make_unique(\n graphFile, net.ID, net.Num, cuspAsync, cuspStateRounds, false,\n readPolicy, nodeWeight, edgeWeight, masterBlockFile);\n }\n}\n} // end namespace galois\n#endif\n" }, { "path": "libcusp/include/galois/graphs/DistributedGraph.h", "content": "/*\n * This file belongs to the Galois project, a C++ library for exploiting\n * parallelism. The code is being released under the terms of the 3-Clause BSD\n * License (a copy is located in LICENSE.txt at the top-level directory).\n *\n * Copyright (C) 2018, The University of Texas at Austin. All rights reserved.\n * UNIVERSITY EXPRESSLY DISCLAIMS ANY AND ALL WARRANTIES CONCERNING THIS\n * SOFTWARE AND DOCUMENTATION, INCLUDING ANY WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR ANY PARTICULAR PURPOSE, NON-INFRINGEMENT AND WARRANTIES OF\n * PERFORMANCE, AND ANY WARRANTY THAT MIGHT OTHERWISE ARISE FROM COURSE OF\n * DEALING OR USAGE OF TRADE. NO WARRANTY IS EITHER EXPRESS OR IMPLIED WITH\n * RESPECT TO THE USE OF THE SOFTWARE OR DOCUMENTATION. Under no circumstances\n * shall University be liable for incidental, special, indirect, direct or\n * consequential damages or loss of profits, interruption of business, or\n * related expenses which may arise from use of Software or Documentation,\n * including but not limited to those resulting from defects in Software and/or\n * Documentation, or loss or inaccuracy of data of any kind.\n */\n\n/**\n * @file DistributedGraph.h\n *\n * Contains the implementation for DistGraph. Command line argument definitions\n * are found in DistributedGraph.cpp.\n */\n\n#ifndef _GALOIS_DIST_HGRAPH_H_\n#define _GALOIS_DIST_HGRAPH_H_\n\n#include \n#include \n\n#include \"galois/graphs/LC_CSR_Graph.h\"\n#include \"galois/graphs/BufferedGraph.h\"\n#include \"galois/runtime/DistStats.h\"\n#include \"galois/graphs/OfflineGraph.h\"\n#include \"galois/DynamicBitset.h\"\n\n/*\n * Headers for boost serialization\n */\n\nnamespace galois {\nnamespace graphs {\n/**\n * Enums specifying how masters are to be distributed among hosts.\n */\nenum MASTERS_DISTRIBUTION {\n //! balance nodes\n BALANCED_MASTERS,\n //! balance edges\n BALANCED_EDGES_OF_MASTERS,\n //! balance nodes and edges\n BALANCED_MASTERS_AND_EDGES\n};\n\n/**\n * Base DistGraph class that all distributed graphs extend from.\n *\n * @tparam NodeTy type of node data for the graph\n * @tparam EdgeTy type of edge data for the graph\n */\ntemplate \nclass DistGraph {\nprivate:\n //! Graph name used for printing things\n constexpr static const char* const GRNAME = \"dGraph\";\n\n using GraphTy = galois::graphs::LC_CSR_Graph;\n\n // vector for determining range objects for master nodes + nodes\n // with edges (which includes masters)\n //! represents split of all nodes among threads to balance edges\n std::vector allNodesRanges;\n //! represents split of master nodes among threads to balance edges\n std::vector masterRanges;\n //! represents split of nodes with edges (includes masters) among threads to\n //! balance edges\n std::vector withEdgeRanges;\n //! represents split of all nodes among threads to balance in-edges\n std::vector allNodesRangesIn;\n //! represents split of master nodes among threads to balance in-edges\n std::vector masterRangesIn;\n\n using NodeRangeType =\n galois::runtime::SpecificRange>;\n\n //! Vector of ranges that stores the 3 different range objects that a user is\n //! able to access\n std::vector specificRanges;\n //! Like specificRanges, but for in edges\n std::vector specificRangesIn;\n\nprotected:\n //! The internal graph used by DistGraph to represent the graph\n GraphTy graph;\n\n //! Marks if the graph is transposed or not.\n bool transposed;\n\n // global graph variables\n uint64_t numGlobalNodes; //!< Total nodes in the global unpartitioned graph.\n uint64_t numGlobalEdges; //!< Total edges in the global unpartitioned graph.\n uint32_t numNodes; //!< Num nodes in this graph in total\n uint64_t numEdges; //!< Num edges in this graph in total\n\n const unsigned id; //!< ID of the machine.\n const uint32_t numHosts; //!< Total number of machines\n\n // local graph\n // size() = Number of nodes created on this host (masters + mirrors)\n uint32_t numOwned; //!< Number of nodes owned (masters) by this host.\n //!< size() - numOwned = mirrors on this host\n uint32_t beginMaster; //!< Local id of the beginning of master nodes.\n //!< beginMaster + numOwned = local id of the end of\n //!< master nodes\n uint32_t numNodesWithEdges; //!< Number of nodes (masters + mirrors) that have\n //!< outgoing edges\n\n //! Information that converts host to range of nodes that host reads\n std::vector> gid2host;\n //! Mirror nodes from different hosts. For reduce\n std::vector> mirrorNodes;\n\n //! GID = localToGlobalVector[LID]\n std::vector localToGlobalVector;\n //! LID = globalToLocalMap[GID]\n std::unordered_map globalToLocalMap;\n\n //! Increments evilPhase, a phase counter used by communication.\n void inline increment_evilPhase() {\n ++galois::runtime::evilPhase;\n if (galois::runtime::evilPhase >=\n static_cast(\n std::numeric_limits::max())) { // limit defined by MPI or\n // LCI\n galois::runtime::evilPhase = 1;\n }\n }\n\n //! Returns evilPhase + 1, handling loop around as necessary\n unsigned inline evilPhasePlus1() {\n unsigned result = galois::runtime::evilPhase + 1;\n\n // limit defined by MPI or LCI\n if (result >= uint32_t{std::numeric_limits::max()}) {\n return 1;\n }\n return result;\n }\n\n //! used to sort edges in the sort edges function\n template \n struct IdLess {\n bool\n operator()(const galois::graphs::EdgeSortValue& e1,\n const galois::graphs::EdgeSortValue& e2) const {\n return e1.dst < e2.dst;\n }\n };\n\nprivate:\n /**\n * Given an OfflineGraph, compute the masters for each node by\n * evenly (or unevenly as specified by scale factor)\n * blocking the nodes off to assign to each host. Considers\n * ONLY nodes and not edges.\n *\n * @param g The offline graph which has loaded the graph you want\n * to get the masters for\n * @param scalefactor A vector that specifies if a particular host\n * should have more or less than other hosts\n * @param DecomposeFactor Specifies how decomposed the blocking\n * of nodes should be. For example, a factor of 2 will make 2 blocks\n * out of 1 block had the decompose factor been set to 1.\n */\n void computeMastersBlockedNodes(galois::graphs::OfflineGraph& g,\n const std::vector& scalefactor,\n unsigned DecomposeFactor = 1) {\n uint64_t numNodes_to_divide = g.size();\n if (scalefactor.empty() || (numHosts * DecomposeFactor == 1)) {\n for (unsigned i = 0; i < numHosts * DecomposeFactor; ++i)\n gid2host.push_back(galois::block_range(uint64_t{0}, numNodes_to_divide,\n i, numHosts * DecomposeFactor));\n return;\n }\n\n // TODO: not compatible with DecomposeFactor.\n assert(scalefactor.size() == numHosts);\n\n unsigned numBlocks = 0;\n\n for (unsigned i = 0; i < numHosts; ++i) {\n numBlocks += scalefactor[i];\n }\n\n std::vector> blocks;\n for (unsigned i = 0; i < numBlocks; ++i) {\n blocks.push_back(\n galois::block_range(uint64_t{0}, numNodes_to_divide, i, numBlocks));\n }\n\n std::vector prefixSums;\n prefixSums.push_back(0);\n\n for (unsigned i = 1; i < numHosts; ++i) {\n prefixSums.push_back(prefixSums[i - 1] + scalefactor[i - 1]);\n }\n\n for (unsigned i = 0; i < numHosts; ++i) {\n unsigned firstBlock = prefixSums[i];\n unsigned lastBlock = prefixSums[i] + scalefactor[i] - 1;\n gid2host.push_back(\n std::make_pair(blocks[firstBlock].first, blocks[lastBlock].second));\n }\n }\n\n /**\n * Given an OfflineGraph, compute the masters for each node by\n * evenly (or unevenly as specified by scale factor)\n * blocking the nodes off to assign to each host while taking\n * into consideration the only edges of the node to get\n * even blocks.\n *\n * @param g The offline graph which has loaded the graph you want\n * to get the masters for\n * @param scalefactor A vector that specifies if a particular host\n * should have more or less than other hosts\n * @param DecomposeFactor Specifies how decomposed the blocking\n * of nodes should be. For example, a factor of 2 will make 2 blocks\n * out of 1 block had the decompose factor been set to 1.\n */\n void computeMastersBalancedEdges(galois::graphs::OfflineGraph& g,\n const std::vector& scalefactor,\n uint32_t edgeWeight,\n unsigned DecomposeFactor = 1) {\n if (edgeWeight == 0) {\n edgeWeight = 1;\n }\n\n auto& net = galois::runtime::getSystemNetworkInterface();\n\n gid2host.resize(numHosts * DecomposeFactor);\n for (unsigned d = 0; d < DecomposeFactor; ++d) {\n auto r = g.divideByNode(0, edgeWeight, (id + d * numHosts),\n numHosts * DecomposeFactor, scalefactor);\n gid2host[id + d * numHosts].first = *(r.first.first);\n gid2host[id + d * numHosts].second = *(r.first.second);\n }\n\n for (unsigned h = 0; h < numHosts; ++h) {\n if (h == id) {\n continue;\n }\n galois::runtime::SendBuffer b;\n for (unsigned d = 0; d < DecomposeFactor; ++d) {\n galois::runtime::gSerialize(b, gid2host[id + d * numHosts]);\n }\n net.sendTagged(h, galois::runtime::evilPhase, b);\n }\n net.flush();\n unsigned received = 1;\n while (received < numHosts) {\n decltype(net.recieveTagged(galois::runtime::evilPhase, nullptr)) p;\n do {\n p = net.recieveTagged(galois::runtime::evilPhase, nullptr);\n } while (!p);\n assert(p->first != id);\n auto& b = p->second;\n for (unsigned d = 0; d < DecomposeFactor; ++d) {\n galois::runtime::gDeserialize(b, gid2host[p->first + d * numHosts]);\n }\n ++received;\n }\n increment_evilPhase();\n\n#ifndef NDEBUG\n for (unsigned h = 0; h < numHosts; h++) {\n if (h == 0) {\n assert(gid2host[h].first == 0);\n } else if (h == numHosts - 1) {\n assert(gid2host[h].first == gid2host[h - 1].second);\n assert(gid2host[h].second == g.size());\n } else {\n assert(gid2host[h].first == gid2host[h - 1].second);\n assert(gid2host[h].second == gid2host[h + 1].first);\n }\n }\n#endif\n }\n\n /**\n * Given an OfflineGraph, compute the masters for each node by\n * evenly (or unevenly as specified by scale factor)\n * blocking the nodes off to assign to each host while taking\n * into consideration the edges of the node AND the node itself.\n *\n * @param g The offline graph which has loaded the graph you want\n * to get the masters for\n * @param scalefactor A vector that specifies if a particular host\n * should have more or less than other hosts\n * @param DecomposeFactor Specifies how decomposed the blocking\n * of nodes should be. For example, a factor of 2 will make 2 blocks\n * out of 1 block had the decompose factor been set to 1. Ignored\n * in this function currently.\n *\n * @todo make this function work with decompose factor\n */\n void computeMastersBalancedNodesAndEdges(\n galois::graphs::OfflineGraph& g, const std::vector& scalefactor,\n uint32_t nodeWeight, uint32_t edgeWeight, unsigned) {\n if (nodeWeight == 0) {\n nodeWeight = g.sizeEdges() / g.size(); // average degree\n }\n if (edgeWeight == 0) {\n edgeWeight = 1;\n }\n\n auto& net = galois::runtime::getSystemNetworkInterface();\n gid2host.resize(numHosts);\n auto r = g.divideByNode(nodeWeight, edgeWeight, id, numHosts, scalefactor);\n gid2host[id].first = *r.first.first;\n gid2host[id].second = *r.first.second;\n for (unsigned h = 0; h < numHosts; ++h) {\n if (h == id)\n continue;\n galois::runtime::SendBuffer b;\n galois::runtime::gSerialize(b, gid2host[id]);\n net.sendTagged(h, galois::runtime::evilPhase, b);\n }\n net.flush();\n unsigned received = 1;\n while (received < numHosts) {\n decltype(net.recieveTagged(galois::runtime::evilPhase, nullptr)) p;\n do {\n p = net.recieveTagged(galois::runtime::evilPhase, nullptr);\n } while (!p);\n assert(p->first != id);\n auto& b = p->second;\n galois::runtime::gDeserialize(b, gid2host[p->first]);\n ++received;\n }\n increment_evilPhase();\n }\n\nprotected:\n /**\n * Wrapper call that will call into more specific compute masters\n * functions that compute masters based on nodes, edges, or both.\n *\n * @param masters_distribution method of masters distribution to use\n * @param g The offline graph which has loaded the graph you want\n * to get the masters for\n * @param scalefactor A vector that specifies if a particular host\n * should have more or less than other hosts\n * @param nodeWeight weight to give nodes when computing balance\n * @param edgeWeight weight to give edges when computing balance\n * @param DecomposeFactor Specifies how decomposed the blocking\n * of nodes should be. For example, a factor of 2 will make 2 blocks\n * out of 1 block had the decompose factor been set to 1.\n */\n uint64_t computeMasters(MASTERS_DISTRIBUTION masters_distribution,\n galois::graphs::OfflineGraph& g,\n const std::vector& scalefactor,\n uint32_t nodeWeight = 0, uint32_t edgeWeight = 0,\n unsigned DecomposeFactor = 1) {\n galois::Timer timer;\n timer.start();\n g.reset_seek_counters();\n\n uint64_t numNodes_to_divide = g.size();\n\n // compute masters for all nodes\n switch (masters_distribution) {\n case BALANCED_MASTERS:\n computeMastersBlockedNodes(g, scalefactor, DecomposeFactor);\n break;\n case BALANCED_MASTERS_AND_EDGES:\n computeMastersBalancedNodesAndEdges(g, scalefactor, nodeWeight,\n edgeWeight, DecomposeFactor);\n break;\n case BALANCED_EDGES_OF_MASTERS:\n default:\n computeMastersBalancedEdges(g, scalefactor, edgeWeight, DecomposeFactor);\n break;\n }\n\n timer.stop();\n\n galois::runtime::reportStatCond_Tmax(\n GRNAME, \"MasterDistTime\", timer.get());\n\n galois::gPrint(\n \"[\", id, \"] Master distribution time : \", timer.get_usec() / 1000000.0f,\n \" seconds to read \", g.num_bytes_read(), \" bytes in \", g.num_seeks(),\n \" seeks (\", g.num_bytes_read() / (float)timer.get_usec(), \" MBPS)\\n\");\n return numNodes_to_divide;\n }\n\n //! reader assignment from a file\n //! corresponds to master assignment if using an edge cut\n void readersFromFile(galois::graphs::OfflineGraph& g, std::string filename) {\n // read file lines\n std::ifstream mappings(filename);\n std::string curLine;\n\n unsigned timesToRead = id + 1;\n\n for (unsigned i = 0; i < timesToRead; i++) {\n std::getline(mappings, curLine);\n }\n\n std::vector modifyLine(curLine.begin(), curLine.end());\n char* tokenizedString = modifyLine.data();\n char* token;\n token = strtok(tokenizedString, \" \");\n\n // loop 6 more times\n for (unsigned i = 0; i < 6; i++) {\n token = strtok(NULL, \" \");\n }\n std::string left(token);\n\n // 3 more times for right\n for (unsigned i = 0; i < 3; i++) {\n token = strtok(NULL, \" \");\n }\n std::string right(token);\n\n gid2host.resize(numHosts);\n gid2host[id].first = std::stoul(left);\n gid2host[id].second = std::stoul(right) + 1;\n galois::gPrint(\"[\", id, \"] Left: \", gid2host[id].first,\n \", Right: \", gid2host[id].second, \"\\n\");\n\n /////////////////////////\n // send/recv from other hosts\n /////////////////////////\n auto& net = galois::runtime::getSystemNetworkInterface();\n\n for (unsigned h = 0; h < numHosts; ++h) {\n if (h == id)\n continue;\n galois::runtime::SendBuffer b;\n galois::runtime::gSerialize(b, gid2host[id]);\n net.sendTagged(h, galois::runtime::evilPhase, b);\n }\n net.flush();\n unsigned received = 1;\n while (received < numHosts) {\n decltype(net.recieveTagged(galois::runtime::evilPhase, nullptr)) p;\n do {\n p = net.recieveTagged(galois::runtime::evilPhase, nullptr);\n } while (!p);\n assert(p->first != id);\n auto& b = p->second;\n galois::runtime::gDeserialize(b, gid2host[p->first]);\n ++received;\n }\n increment_evilPhase();\n\n // sanity checking assignment\n for (unsigned h = 0; h < numHosts; h++) {\n if (h == 0) {\n GALOIS_ASSERT(gid2host[h].first == 0);\n } else if (h == numHosts - 1) {\n GALOIS_ASSERT(gid2host[h].first == gid2host[h - 1].second,\n gid2host[h].first, \" \", gid2host[h - 1].second);\n GALOIS_ASSERT(gid2host[h].second == g.size(), gid2host[h].second, \" \",\n g.size());\n } else {\n GALOIS_ASSERT(gid2host[h].first == gid2host[h - 1].second,\n gid2host[h].first, \" \", gid2host[h - 1].second);\n GALOIS_ASSERT(gid2host[h].second == gid2host[h + 1].first,\n gid2host[h].second, \" \", gid2host[h + 1].first);\n }\n }\n }\n\n uint32_t G2L(uint64_t gid) const {\n assert(isLocal(gid));\n return globalToLocalMap.at(gid);\n }\n\n uint64_t L2G(uint32_t lid) const { return localToGlobalVector[lid]; }\n\npublic:\n //! Type representing a node in this graph\n using GraphNode = typename GraphTy::GraphNode;\n //! Expose EdgeTy to other classes\n using EdgeType = EdgeTy;\n //! iterator type over nodes\n using iterator = typename GraphTy::iterator;\n //! constant iterator type over nodes\n using const_iterator = typename GraphTy::const_iterator;\n //! iterator type over edges\n using edge_iterator = typename GraphTy::edge_iterator;\n\n /**\n * Constructor for DistGraph. Initializes metadata fields.\n *\n * @param host host number that this graph resides on\n * @param numHosts total number of hosts in the currently executing program\n */\n DistGraph(unsigned host, unsigned numHosts)\n : transposed(false), id(host), numHosts(numHosts) {\n mirrorNodes.resize(numHosts);\n numGlobalNodes = 0;\n numGlobalEdges = 0;\n }\n\n /**\n * Return a vector of pairs denoting mirror node ranges.\n *\n * Assumes all mirror nodes occur after the masters: this invariant should be\n * held by CuSP.\n */\n std::vector> getMirrorRanges() const {\n std::vector> mirrorRangesVector;\n // order of nodes locally is masters, outgoing mirrors, incoming mirrors,\n // so just get from numOwned to end\n if (numOwned != numNodes) {\n assert(numOwned < numNodes);\n mirrorRangesVector.push_back(std::make_pair(numOwned, numNodes));\n }\n return mirrorRangesVector;\n }\n\n std::vector>& getMirrorNodes() { return mirrorNodes; }\n\nprivate:\n virtual unsigned getHostIDImpl(uint64_t) const = 0;\n virtual bool isOwnedImpl(uint64_t) const = 0;\n virtual bool isLocalImpl(uint64_t) const = 0;\n virtual bool isVertexCutImpl() const = 0;\n virtual std::pair cartesianGridImpl() const {\n return std::make_pair(0u, 0u);\n }\n\npublic:\n virtual ~DistGraph() {}\n //! Determines which host has the master for a particular node\n //! @returns Host id of node in question\n inline unsigned getHostID(uint64_t gid) const { return getHostIDImpl(gid); }\n //! Determine if a node has a master on this host.\n //! @returns True if passed in global id has a master on this host\n inline bool isOwned(uint64_t gid) const { return isOwnedImpl(gid); }\n //! Determine if a node has a proxy on this host\n //! @returns True if passed in global id has a proxy on this host\n inline bool isLocal(uint64_t gid) const { return isLocalImpl(gid); }\n /**\n * Returns true if current partition is a vertex cut\n * @returns true if partition being stored in this graph is a vertex cut\n */\n inline bool is_vertex_cut() const { return isVertexCutImpl(); }\n /**\n * Returns Cartesian split (if it exists, else returns pair of 0s\n */\n inline std::pair cartesianGrid() const {\n return cartesianGridImpl();\n }\n\n bool isTransposed() { return transposed; }\n\n /**\n * Converts a local node id into a global node id\n *\n * @param nodeID local node id\n * @returns global node id corresponding to the local one\n */\n inline uint64_t getGID(const uint32_t nodeID) const { return L2G(nodeID); }\n\n /**\n * Converts a global node id into a local node id\n *\n * @param nodeID global node id\n * @returns local node id corresponding to the global one\n */\n inline uint32_t getLID(const uint64_t nodeID) const { return G2L(nodeID); }\n\n /**\n * Get data of a node.\n *\n * @param N node to get the data of\n * @param mflag access flag for node data\n * @returns A node data object\n */\n inline typename GraphTy::node_data_reference\n getData(GraphNode N,\n galois::MethodFlag mflag = galois::MethodFlag::UNPROTECTED) {\n auto& r = graph.getData(N, mflag);\n return r;\n }\n\n /**\n * Get the edge data for a particular edge in the graph.\n *\n * @param ni edge to get the data of\n * @param mflag access flag for edge data\n * @returns The edge data for the requested edge\n */\n inline typename GraphTy::edge_data_reference\n getEdgeData(edge_iterator ni,\n galois::MethodFlag mflag = galois::MethodFlag::UNPROTECTED) {\n auto& r = graph.getEdgeData(ni, mflag);\n return r;\n }\n\n /**\n * Gets edge destination of edge ni.\n *\n * @param ni edge id to get destination of\n * @returns Local ID of destination of edge ni\n */\n GraphNode getEdgeDst(edge_iterator ni) { return graph.getEdgeDst(ni); }\n\n /**\n * Gets the first edge of some node.\n *\n * @param N node to get the edge of\n * @returns iterator to first edge of N\n */\n inline edge_iterator edge_begin(GraphNode N) {\n return graph.edge_begin(N, galois::MethodFlag::UNPROTECTED);\n }\n\n /**\n * Gets the end edge boundary of some node.\n *\n * @param N node to get the edge of\n * @returns iterator to the end of the edges of node N, i.e. the first edge\n * of the next node (or an \"end\" iterator if there is no next node)\n */\n inline edge_iterator edge_end(GraphNode N) {\n return graph.edge_end(N, galois::MethodFlag::UNPROTECTED);\n }\n\n /**\n * Returns an iterable object over the edges of a particular node in the\n * graph.\n *\n * @param N node to get edges iterator over\n */\n inline galois::runtime::iterable>\n edges(GraphNode N) {\n return galois::graphs::internal::make_no_deref_range(edge_begin(N),\n edge_end(N));\n }\n\n /**\n * Gets number of nodes on this (local) graph.\n *\n * @returns number of nodes present in this (local) graph\n */\n inline size_t size() const { return graph.size(); }\n\n /**\n * Gets number of edges on this (local) graph.\n *\n * @returns number of edges present in this (local) graph\n */\n inline size_t sizeEdges() const { return graph.sizeEdges(); }\n\n /**\n * Gets number of nodes on this (local) graph.\n *\n * @returns number of nodes present in this (local) graph\n */\n inline size_t numMasters() const { return numOwned; }\n\n /**\n * Gets number of nodes with edges (may include nodes without edges)\n * on this (local) graph.\n *\n * @returns number of nodes with edges (may include nodes without edges\n * as it measures a contiguous range)\n */\n inline size_t getNumNodesWithEdges() const { return numNodesWithEdges; }\n\n /**\n * Gets number of nodes on the global unpartitioned graph.\n *\n * @returns number of nodes present in the global unpartitioned graph\n */\n inline size_t globalSize() const { return numGlobalNodes; }\n\n /**\n * Gets number of edges on the global unpartitioned graph.\n *\n * @returns number of edges present in the global unpartitioned graph\n */\n inline size_t globalSizeEdges() const { return numGlobalEdges; }\n\n /**\n * Returns a range object that encapsulates all nodes of the graph.\n *\n * @returns A range object that contains all the nodes in this graph\n */\n inline const NodeRangeType& allNodesRange() const {\n assert(specificRanges.size() == 3);\n return specificRanges[0];\n }\n\n /**\n * Returns a range object that encapsulates only master nodes in this\n * graph.\n *\n * @returns A range object that contains the master nodes in this graph\n */\n inline const NodeRangeType& masterNodesRange() const {\n assert(specificRanges.size() == 3);\n return specificRanges[1];\n }\n\n /**\n * Returns a range object that encapsulates master nodes and nodes\n * with edges in this graph.\n *\n * @returns A range object that contains the master nodes and the nodes\n * with outgoing edges in this graph\n */\n inline const NodeRangeType& allNodesWithEdgesRange() const {\n assert(specificRanges.size() == 3);\n return specificRanges[2];\n }\n\n /**\n * Returns a vector object that contains the global IDs (in order) of\n * the master nodes in this graph.\n *\n * @returns A vector object that contains the global IDs (in order) of\n * the master nodes in this graph\n */\n std::vector getMasterGlobalIDs() {\n std::vector IDs;\n\n IDs.reserve(numMasters());\n for (auto node : masterNodesRange()) {\n IDs.push_back(getGID(node));\n }\n\n return IDs;\n }\n\nprotected:\n /**\n * Uses a pre-computed prefix sum to determine division of nodes among\n * threads.\n *\n * The call uses binary search to determine the ranges.\n */\n inline void determineThreadRanges() {\n allNodesRanges = galois::graphs::determineUnitRangesFromPrefixSum(\n galois::runtime::activeThreads, graph.getEdgePrefixSum());\n }\n\n /**\n * Determines the thread ranges for master nodes only and saves them to\n * the object.\n *\n * Only call after graph is constructed + only call once\n */\n inline void determineThreadRangesMaster() {\n // make sure this hasn't been called before\n assert(masterRanges.size() == 0);\n\n // first check if we even need to do any work; if already calculated,\n // use already calculated vector\n if (beginMaster == 0 && (beginMaster + numOwned) == size()) {\n masterRanges = allNodesRanges;\n } else if (beginMaster == 0 &&\n (beginMaster + numOwned) == numNodesWithEdges &&\n withEdgeRanges.size() != 0) {\n masterRanges = withEdgeRanges;\n } else {\n galois::gDebug(\"Manually det. master thread ranges\");\n masterRanges = galois::graphs::determineUnitRangesFromGraph(\n graph, galois::runtime::activeThreads, beginMaster,\n beginMaster + numOwned, 0);\n }\n }\n\n /**\n * Determines the thread ranges for nodes with edges only and saves them to\n * the object.\n *\n * Only call after graph is constructed + only call once\n */\n inline void determineThreadRangesWithEdges() {\n // make sure not called before\n assert(withEdgeRanges.size() == 0);\n\n // first check if we even need to do any work; if already calculated,\n // use already calculated vector\n if (numNodesWithEdges == size()) {\n withEdgeRanges = allNodesRanges;\n } else if (beginMaster == 0 &&\n (beginMaster + numOwned) == numNodesWithEdges &&\n masterRanges.size() != 0) {\n withEdgeRanges = masterRanges;\n } else {\n galois::gDebug(\"Manually det. with edges thread ranges\");\n withEdgeRanges = galois::graphs::determineUnitRangesFromGraph(\n graph, galois::runtime::activeThreads, 0, numNodesWithEdges, 0);\n }\n }\n\n /**\n * Initializes the 3 range objects that a user can access to iterate\n * over the graph in different ways.\n */\n void initializeSpecificRanges() {\n assert(specificRanges.size() == 0);\n\n // TODO/FIXME assertion likely not safe if a host gets no nodes\n // make sure the thread ranges have already been calculated\n // for the 3 ranges\n assert(allNodesRanges.size() != 0);\n assert(masterRanges.size() != 0);\n assert(withEdgeRanges.size() != 0);\n\n // 0 is all nodes\n specificRanges.push_back(galois::runtime::makeSpecificRange(\n boost::counting_iterator(0),\n boost::counting_iterator(size()), allNodesRanges.data()));\n\n // 1 is master nodes\n specificRanges.push_back(galois::runtime::makeSpecificRange(\n boost::counting_iterator(beginMaster),\n boost::counting_iterator(beginMaster + numOwned),\n masterRanges.data()));\n\n // 2 is with edge nodes\n specificRanges.push_back(galois::runtime::makeSpecificRange(\n boost::counting_iterator(0),\n boost::counting_iterator(numNodesWithEdges),\n withEdgeRanges.data()));\n\n assert(specificRanges.size() == 3);\n }\n\n /**\n * Specific range editor: makes the range for edges equivalent to the range\n * for masters.\n */\n void edgesEqualMasters() { specificRanges[2] = specificRanges[1]; }\n\npublic:\n /**\n * Write the local LC_CSR graph to the file on a disk.\n *\n * @todo revive this\n */\n void save_local_graph_to_file(std::string) { GALOIS_DIE(\"not implemented\"); }\n\n /**\n * Read the local LC_CSR graph from the file on a disk.\n *\n * @todo revive this\n */\n void read_local_graph_from_file(std::string) {\n GALOIS_DIE(\"not implemented\");\n }\n\n /**\n * Deallocates underlying LC CSR Graph\n */\n void deallocate() {\n galois::gDebug(\"Deallocating CSR in DistGraph\");\n graph.deallocate();\n }\n\n /**\n * Sort the underlying LC_CSR_Graph by ID (destinations)\n * It sorts edges of the nodes by destination.\n */\n void sortEdgesByDestination() {\n using GN = typename GraphTy::GraphNode;\n galois::do_all(\n galois::iterate(graph),\n [&](GN n) { graph.sortEdges(n, IdLess()); },\n galois::no_stats(), galois::loopname(\"CSREdgeSort\"), galois::steal());\n }\n};\n\ntemplate \nconstexpr const char* const galois::graphs::DistGraph::GRNAME;\n} // end namespace graphs\n} // end namespace galois\n\n#endif //_GALOIS_DIST_HGRAPH_H\n" }, { "path": "libcusp/include/galois/graphs/GenericPartitioners.h", "content": "#ifndef _GALOIS_DIST_GENERICPARTS_H\n#define _GALOIS_DIST_GENERICPARTS_H\n\n#include \"DistributedGraph.h\"\n#include \"BasePolicies.h\"\n#include \n#include \n#include \n\nclass NoCommunication : public galois::graphs::ReadMasterAssignment {\npublic:\n NoCommunication(uint32_t, uint32_t numHosts, uint64_t, uint64_t)\n : galois::graphs::ReadMasterAssignment(0, numHosts, 0, 0) {}\n\n uint32_t getEdgeOwner(uint32_t src, uint32_t, uint64_t) const {\n return retrieveMaster(src);\n }\n\n bool noCommunication() { return true; }\n bool isVertexCut() const { return false; }\n void serializePartition(boost::archive::binary_oarchive&) {}\n void deserializePartition(boost::archive::binary_iarchive&) {}\n std::pair cartesianGrid() {\n return std::make_pair(0u, 0u);\n }\n};\n\n/**\n */\nclass MiningPolicyNaive : public galois::graphs::ReadMasterAssignment {\npublic:\n MiningPolicyNaive(uint32_t, uint32_t numHosts, uint64_t, uint64_t,\n std::vector&)\n : galois::graphs::ReadMasterAssignment(0, numHosts, 0, 0) {}\n\n static bool needNodeDegrees() { return false; }\n\n bool keepEdge(uint32_t src, uint32_t dst) const { return src < dst; }\n};\n\nclass MiningPolicyDegrees : public galois::graphs::ReadMasterAssignment {\n std::vector& ndegrees;\n\npublic:\n MiningPolicyDegrees(uint32_t, uint32_t numHosts, uint64_t, uint64_t,\n std::vector& _ndeg)\n : galois::graphs::ReadMasterAssignment(0, numHosts, 0, 0),\n ndegrees(_ndeg) {}\n\n static bool needNodeDegrees() { return true; }\n\n bool keepEdge(uint32_t src, uint32_t dst) const {\n uint64_t sourceDegree = ndegrees[src];\n uint64_t destDegree = ndegrees[dst];\n if ((destDegree > sourceDegree) ||\n ((destDegree == sourceDegree) && (src < dst))) {\n return true;\n } else {\n return false;\n }\n }\n};\n\n////////////////////////////////////////////////////////////////////////////////\n\nclass GenericCVC : public galois::graphs::ReadMasterAssignment {\n unsigned numRowHosts;\n unsigned numColumnHosts;\n unsigned _h_offset;\n\n void factorizeHosts() {\n numColumnHosts = sqrt(_numHosts);\n\n while ((_numHosts % numColumnHosts) != 0)\n numColumnHosts--;\n\n numRowHosts = _numHosts / numColumnHosts;\n assert(numRowHosts >= numColumnHosts);\n\n // if (moreColumnHosts) {\n // std::swap(numRowHosts, numColumnHosts);\n //}\n\n if (_hostID == 0) {\n galois::gPrint(\"Cartesian grid: \", numRowHosts, \" x \", numColumnHosts,\n \"\\n\");\n }\n }\n\n //! Returns the grid row ID of this host\n unsigned gridRowID() const { return (_hostID / numColumnHosts); }\n //! Returns the grid row ID of the specified host\n unsigned gridRowID(unsigned id) const { return (id / numColumnHosts); }\n //! Returns the grid column ID of this host\n unsigned gridColumnID() const { return (_hostID % numColumnHosts); }\n //! Returns the grid column ID of the specified host\n unsigned gridColumnID(unsigned id) const { return (id % numColumnHosts); }\n\n //! Find the column of a particular node\n unsigned getColumnOfNode(uint64_t gid) const {\n return gridColumnID(retrieveMaster(gid));\n }\n\npublic:\n GenericCVC(uint32_t hostID, uint32_t numHosts, uint64_t numNodes,\n uint64_t numEdges)\n : galois::graphs::ReadMasterAssignment(hostID, numHosts, numNodes,\n numEdges) {\n factorizeHosts();\n _h_offset = gridRowID() * numColumnHosts;\n }\n\n uint32_t getEdgeOwner(uint32_t, uint32_t dst, uint64_t) const {\n int i = getColumnOfNode(dst);\n return _h_offset + i;\n }\n\n bool noCommunication() { return false; }\n bool isVertexCut() const {\n if ((numRowHosts == 1) || (numColumnHosts == 1))\n return false;\n return true;\n }\n void serializePartition(boost::archive::binary_oarchive& ar) {\n ar << numRowHosts;\n ar << numColumnHosts;\n }\n void deserializePartition(boost::archive::binary_iarchive& ar) {\n ar >> numRowHosts;\n ar >> numColumnHosts;\n }\n\n std::pair cartesianGrid() {\n return std::make_pair(numRowHosts, numColumnHosts);\n }\n};\n\n////////////////////////////////////////////////////////////////////////////////\n\n// same as above, except columns are flipped (changes behavior of vertex cut\n// call as well)\nclass GenericCVCColumnFlip : public galois::graphs::ReadMasterAssignment {\n unsigned numRowHosts;\n unsigned numColumnHosts;\n unsigned _h_offset;\n\n void factorizeHosts() {\n numColumnHosts = sqrt(_numHosts);\n\n while ((_numHosts % numColumnHosts) != 0)\n numColumnHosts--;\n\n numRowHosts = _numHosts / numColumnHosts;\n assert(numRowHosts >= numColumnHosts);\n\n // column flip\n std::swap(numRowHosts, numColumnHosts);\n\n if (_hostID == 0) {\n galois::gPrint(\"Cartesian grid: \", numRowHosts, \" x \", numColumnHosts,\n \"\\n\");\n }\n }\n\n //! Returns the grid row ID of this host\n unsigned gridRowID() const { return (_hostID / numColumnHosts); }\n //! Returns the grid row ID of the specified host\n unsigned gridRowID(unsigned id) const { return (id / numColumnHosts); }\n //! Returns the grid column ID of this host\n unsigned gridColumnID() const { return (_hostID % numColumnHosts); }\n //! Returns the grid column ID of the specified host\n unsigned gridColumnID(unsigned id) const { return (id % numColumnHosts); }\n\n //! Find the column of a particular node\n unsigned getColumnOfNode(uint64_t gid) const {\n return gridColumnID(retrieveMaster(gid));\n }\n\npublic:\n GenericCVCColumnFlip(uint32_t hostID, uint32_t numHosts, uint64_t numNodes,\n uint64_t numEdges)\n : galois::graphs::ReadMasterAssignment(hostID, numHosts, numNodes,\n numEdges) {\n factorizeHosts();\n _h_offset = gridRowID() * numColumnHosts;\n }\n\n uint32_t getEdgeOwner(uint32_t, uint32_t dst, uint64_t) const {\n int i = getColumnOfNode(dst);\n return _h_offset + i;\n }\n\n bool noCommunication() { return false; }\n bool isVertexCut() const {\n if ((numRowHosts == 1) && (numColumnHosts == 1))\n return false;\n return true;\n }\n\n void serializePartition(boost::archive::binary_oarchive& ar) {\n ar << numRowHosts;\n ar << numColumnHosts;\n }\n\n void deserializePartition(boost::archive::binary_iarchive& ar) {\n ar >> numRowHosts;\n ar >> numColumnHosts;\n }\n\n std::pair cartesianGrid() {\n return std::make_pair(numRowHosts, numColumnHosts);\n }\n};\n////////////////////////////////////////////////////////////////////////////////\nclass GenericHVC : public galois::graphs::ReadMasterAssignment {\n uint32_t _vCutThreshold;\n\npublic:\n GenericHVC(uint32_t hostID, uint32_t numHosts, uint64_t numNodes,\n uint64_t numEdges)\n : galois::graphs::ReadMasterAssignment(hostID, numHosts, numNodes,\n numEdges) {\n _vCutThreshold = 1000; // can be changed, but default seems to be 1000\n }\n\n uint32_t getEdgeOwner(uint32_t src, uint32_t dst, uint64_t numEdges) const {\n if (numEdges > _vCutThreshold) {\n return retrieveMaster(dst);\n } else {\n return retrieveMaster(src);\n }\n }\n\n bool noCommunication() { return false; }\n // TODO I should be able to make this runtime detectable\n bool isVertexCut() const { return true; }\n void serializePartition(boost::archive::binary_oarchive&) {}\n void deserializePartition(boost::archive::binary_iarchive&) {}\n std::pair cartesianGrid() {\n return std::make_pair(0u, 0u);\n }\n};\n\n////////////////////////////////////////////////////////////////////////////////\n\nclass GingerP : public galois::graphs::CustomMasterAssignment {\n // used in hybrid cut\n uint32_t _vCutThreshold;\n // ginger scoring constants\n double _gamma;\n double _alpha;\n // ginger node/edge ratio\n double _neRatio;\n\n /**\n * Returns Ginger's composite balance parameter for a given host\n */\n double getCompositeBalanceParam(\n unsigned host, const std::vector& nodeLoads,\n const std::vector>& nodeAccum,\n const std::vector& edgeLoads,\n const std::vector>& edgeAccum) {\n // get node/edge loads\n uint64_t hostNodeLoad = nodeLoads[host] + nodeAccum[host].load();\n uint64_t hostEdgeLoad = edgeLoads[host] + edgeAccum[host].load();\n\n return (hostNodeLoad + (_neRatio * hostEdgeLoad)) / 2;\n }\n\n /**\n * Use FENNEL balance equation to get a score value for partition\n * scoring\n */\n double getFennelBalanceScore(double param) {\n return _alpha * _gamma * pow(param, _gamma - 1);\n }\n\npublic:\n GingerP(uint32_t hostID, uint32_t numHosts, uint64_t numNodes,\n uint64_t numEdges)\n : galois::graphs::CustomMasterAssignment(hostID, numHosts, numNodes,\n numEdges) {\n _vCutThreshold = 1000;\n _gamma = 1.5;\n _alpha = numEdges * pow(numHosts, _gamma - 1.0) / pow(numNodes, _gamma);\n _neRatio = (double)numNodes / (double)numEdges;\n }\n\n template \n uint32_t getMaster(uint32_t src,\n galois::graphs::BufferedGraph& bufGraph,\n const std::vector& localNodeToMaster,\n std::unordered_map& gid2offsets,\n const std::vector& nodeLoads,\n std::vector>& nodeAccum,\n const std::vector& edgeLoads,\n std::vector>& edgeAccum) {\n auto ii = bufGraph.edgeBegin(src);\n auto ee = bufGraph.edgeEnd(src);\n // number of edges\n uint64_t ne = std::distance(ii, ee);\n\n // high in-degree nodes masters stay the same\n if (ne > _vCutThreshold) {\n return _hostID;\n } else {\n // low in degree masters move based on augmented FENNEL scoring metric\n // initialize array to hold scores\n galois::PODResizeableArray scores;\n scores.resize(_numHosts);\n for (unsigned i = 0; i < _numHosts; i++) {\n scores[i] = 0.0;\n }\n\n for (; ii < ee; ++ii) {\n uint64_t dst = bufGraph.edgeDestination(*ii);\n size_t offsetIntoMap = (unsigned)-1;\n\n auto it = gid2offsets.find(dst);\n if (it != gid2offsets.end()) {\n offsetIntoMap = it->second;\n } else {\n // determine offset\n offsetIntoMap = dst - bufGraph.getNodeOffset();\n }\n\n assert(offsetIntoMap != (unsigned)-1);\n assert(offsetIntoMap < localNodeToMaster.size());\n\n unsigned currentAssignment = localNodeToMaster[offsetIntoMap];\n\n if (currentAssignment != (unsigned)-1) {\n scores[currentAssignment] += 1.0;\n } else {\n galois::gDebug(\"[\", _hostID, \"] \", dst, \" unassigned\");\n }\n }\n\n // subtraction of the composite balance term\n for (unsigned i = 0; i < _numHosts; i++) {\n scores[i] -= getFennelBalanceScore(getCompositeBalanceParam(\n i, nodeLoads, nodeAccum, edgeLoads, edgeAccum));\n }\n\n unsigned bestHost = -1;\n double bestScore = std::numeric_limits::lowest();\n // find max score\n for (unsigned i = 0; i < _numHosts; i++) {\n if (scores[i] >= bestScore) {\n // galois::gDebug(\"best score \", bestScore, \" beaten by \", scores[i]);\n bestScore = scores[i];\n bestHost = i;\n }\n }\n\n galois::gDebug(\"[\", _hostID, \"] \", src, \" assigned to \", bestHost,\n \" with num edge \", ne);\n\n // update metadata; TODO make this a nicer interface\n galois::atomicAdd(nodeAccum[bestHost], (uint64_t)1);\n galois::atomicAdd(edgeAccum[bestHost], ne);\n\n return bestHost;\n }\n }\n\n uint32_t getEdgeOwner(uint32_t src, uint32_t dst, uint64_t numEdges) const {\n // if high indegree, then move to source (which is dst), else stay on\n // dst (which is src)\n // note \"dst\" here is actually the source on the actual graph\n // since we're reading transpose\n if (numEdges > _vCutThreshold) {\n return retrieveMaster(dst);\n } else {\n return retrieveMaster(src);\n }\n }\n\n bool noCommunication() { return false; }\n // TODO I should be able to make this runtime detectable\n bool isVertexCut() const { return true; }\n void serializePartition(boost::archive::binary_oarchive&) {}\n void deserializePartition(boost::archive::binary_iarchive&) {}\n std::pair cartesianGrid() {\n return std::make_pair(0u, 0u);\n }\n};\n\nclass FennelP : public galois::graphs::CustomMasterAssignment {\n // used in hybrid cut\n uint32_t _vCutThreshold;\n // ginger scoring constants\n double _gamma;\n double _alpha;\n // ginger node/edge ratio\n double _neRatio;\n\n /**\n * Returns Ginger's composite balance parameter for a given host\n */\n double getCompositeBalanceParam(\n unsigned host, const std::vector& nodeLoads,\n const std::vector>& nodeAccum,\n const std::vector& edgeLoads,\n const std::vector>& edgeAccum) {\n // get node/edge loads\n uint64_t hostNodeLoad = nodeLoads[host] + nodeAccum[host].load();\n uint64_t hostEdgeLoad = edgeLoads[host] + edgeAccum[host].load();\n\n return (hostNodeLoad + (_neRatio * hostEdgeLoad)) / 2;\n }\n\n /**\n * Use FENNEL balance equation to get a score value for partition\n * scoring\n */\n double getFennelBalanceScore(double param) {\n return _alpha * _gamma * pow(param, _gamma - 1);\n }\n\npublic:\n FennelP(uint32_t hostID, uint32_t numHosts, uint64_t numNodes,\n uint64_t numEdges)\n : galois::graphs::CustomMasterAssignment(hostID, numHosts, numNodes,\n numEdges) {\n _vCutThreshold = 1000;\n _gamma = 1.5;\n _alpha = numEdges * pow(numHosts, _gamma - 1.0) / pow(numNodes, _gamma);\n _neRatio = (double)numNodes / (double)numEdges;\n }\n\n template \n uint32_t getMaster(uint32_t src,\n galois::graphs::BufferedGraph& bufGraph,\n const std::vector& localNodeToMaster,\n std::unordered_map& gid2offsets,\n const std::vector& nodeLoads,\n std::vector>& nodeAccum,\n const std::vector& edgeLoads,\n std::vector>& edgeAccum) {\n auto ii = bufGraph.edgeBegin(src);\n auto ee = bufGraph.edgeEnd(src);\n // number of edges\n uint64_t ne = std::distance(ii, ee);\n\n // high degree nodes masters stay the same\n if (ne > _vCutThreshold) {\n return _hostID;\n } else {\n // low degree masters move based on augmented FENNEL scoring metric\n // initialize array to hold scores\n galois::PODResizeableArray scores;\n scores.resize(_numHosts);\n for (unsigned i = 0; i < _numHosts; i++) {\n scores[i] = 0.0;\n }\n\n for (; ii < ee; ++ii) {\n uint64_t dst = bufGraph.edgeDestination(*ii);\n size_t offsetIntoMap = (unsigned)-1;\n\n auto it = gid2offsets.find(dst);\n if (it != gid2offsets.end()) {\n offsetIntoMap = it->second;\n } else {\n // determine offset\n offsetIntoMap = dst - bufGraph.getNodeOffset();\n }\n\n assert(offsetIntoMap != (unsigned)-1);\n assert(offsetIntoMap < localNodeToMaster.size());\n\n unsigned currentAssignment = localNodeToMaster[offsetIntoMap];\n\n if (currentAssignment != (unsigned)-1) {\n scores[currentAssignment] += 1.0;\n } else {\n galois::gDebug(\"[\", _hostID, \"] \", dst, \" unassigned\");\n }\n }\n\n // subtraction of the composite balance term\n for (unsigned i = 0; i < _numHosts; i++) {\n scores[i] -= getFennelBalanceScore(getCompositeBalanceParam(\n i, nodeLoads, nodeAccum, edgeLoads, edgeAccum));\n }\n\n unsigned bestHost = -1;\n double bestScore = std::numeric_limits::lowest();\n // find max score\n for (unsigned i = 0; i < _numHosts; i++) {\n if (scores[i] >= bestScore) {\n // galois::gDebug(\"best score \", bestScore, \" beaten by \", scores[i]);\n bestScore = scores[i];\n bestHost = i;\n }\n }\n\n galois::gDebug(\"[\", _hostID, \"] \", src, \" assigned to \", bestHost,\n \" with num edge \", ne);\n\n // update metadata; TODO make this a nicer interface\n galois::atomicAdd(nodeAccum[bestHost], (uint64_t)1);\n galois::atomicAdd(edgeAccum[bestHost], ne);\n\n return bestHost;\n }\n }\n\n // Fennel is an edge cut: all edges on source\n uint32_t getEdgeOwner(uint32_t src, uint32_t, uint64_t) const {\n return retrieveMaster(src);\n }\n\n bool noCommunication() { return false; }\n // TODO I should be able to make this runtime detectable\n bool isVertexCut() const { return false; }\n void serializePartition(boost::archive::binary_oarchive&) {}\n void deserializePartition(boost::archive::binary_iarchive&) {}\n std::pair cartesianGrid() {\n return std::make_pair(0u, 0u);\n }\n};\n\nclass SugarP : public galois::graphs::CustomMasterAssignment {\n // used in hybrid cut\n uint32_t _vCutThreshold;\n // ginger scoring constants\n double _gamma;\n double _alpha;\n // ginger node/edge ratio\n double _neRatio;\n\n unsigned numRowHosts;\n unsigned numColumnHosts;\n\n void factorizeHosts() {\n numColumnHosts = sqrt(_numHosts);\n\n while ((_numHosts % numColumnHosts) != 0)\n numColumnHosts--;\n\n numRowHosts = _numHosts / numColumnHosts;\n assert(numRowHosts >= numColumnHosts);\n\n if (_hostID == 0) {\n galois::gPrint(\"Cartesian grid: \", numRowHosts, \" x \", numColumnHosts,\n \"\\n\");\n }\n }\n\n //! Returns the grid row ID of this host\n unsigned gridRowID() const { return (_hostID / numColumnHosts); }\n //! Returns the grid row ID of the specified host\n unsigned gridRowID(unsigned id) const { return (id / numColumnHosts); }\n //! Returns the grid column ID of this host\n unsigned gridColumnID() const { return (_hostID % numColumnHosts); }\n //! Returns the grid column ID of the specified host\n unsigned gridColumnID(unsigned id) const { return (id % numColumnHosts); }\n\n //! Find the row of a particular node\n unsigned getRowOfNode(uint64_t gid) const {\n return gridRowID(retrieveMaster(gid));\n }\n\n //! Find the column of a particular node\n unsigned getColumnOfNode(uint64_t gid) const {\n return gridColumnID(retrieveMaster(gid));\n }\n\n /**\n * Returns Ginger's composite balance parameter for a given host\n */\n double getCompositeBalanceParam(\n unsigned host, const std::vector& nodeLoads,\n const std::vector>& nodeAccum,\n const std::vector& edgeLoads,\n const std::vector>& edgeAccum) {\n // get node/edge loads\n uint64_t hostNodeLoad = nodeLoads[host] + nodeAccum[host].load();\n uint64_t hostEdgeLoad = edgeLoads[host] + edgeAccum[host].load();\n\n return (hostNodeLoad + (_neRatio * hostEdgeLoad)) / 2;\n }\n\n /**\n * Use FENNEL balance equation to get a score value for partition\n * scoring\n */\n double getFennelBalanceScore(double param) {\n return _alpha * _gamma * pow(param, _gamma - 1);\n }\n\npublic:\n SugarP(uint32_t hostID, uint32_t numHosts, uint64_t numNodes,\n uint64_t numEdges)\n : galois::graphs::CustomMasterAssignment(hostID, numHosts, numNodes,\n numEdges) {\n _vCutThreshold = 1000;\n _gamma = 1.5;\n _alpha = numEdges * pow(numHosts, _gamma - 1.0) / pow(numNodes, _gamma);\n _neRatio = (double)numNodes / (double)numEdges;\n // CVC things\n factorizeHosts();\n }\n\n template \n uint32_t getMaster(uint32_t src,\n galois::graphs::BufferedGraph& bufGraph,\n const std::vector& localNodeToMaster,\n std::unordered_map& gid2offsets,\n const std::vector& nodeLoads,\n std::vector>& nodeAccum,\n const std::vector& edgeLoads,\n std::vector>& edgeAccum) {\n auto ii = bufGraph.edgeBegin(src);\n auto ee = bufGraph.edgeEnd(src);\n // number of edges\n uint64_t ne = std::distance(ii, ee);\n\n // high degree nodes masters stay the same\n if (ne > _vCutThreshold) {\n return _hostID;\n } else {\n // low degree masters move based on augmented FENNEL scoring metric\n // initialize array to hold scores\n galois::PODResizeableArray scores;\n scores.resize(_numHosts);\n for (unsigned i = 0; i < _numHosts; i++) {\n scores[i] = 0.0;\n }\n\n for (; ii < ee; ++ii) {\n uint64_t dst = bufGraph.edgeDestination(*ii);\n size_t offsetIntoMap = (unsigned)-1;\n\n auto it = gid2offsets.find(dst);\n if (it != gid2offsets.end()) {\n offsetIntoMap = it->second;\n } else {\n // determine offset\n offsetIntoMap = dst - bufGraph.getNodeOffset();\n }\n\n assert(offsetIntoMap != (unsigned)-1);\n assert(offsetIntoMap < localNodeToMaster.size());\n\n unsigned currentAssignment = localNodeToMaster[offsetIntoMap];\n\n if (currentAssignment != (unsigned)-1) {\n scores[currentAssignment] += 1.0;\n } else {\n // galois::gDebug(\"[\", _hostID, \"] \", dst, \" unassigned\");\n }\n }\n\n // subtraction of the composite balance term\n for (unsigned i = 0; i < _numHosts; i++) {\n scores[i] -= getFennelBalanceScore(getCompositeBalanceParam(\n i, nodeLoads, nodeAccum, edgeLoads, edgeAccum));\n }\n\n unsigned bestHost = -1;\n double bestScore = std::numeric_limits::lowest();\n // find max score\n for (unsigned i = 0; i < _numHosts; i++) {\n if (scores[i] >= bestScore) {\n // galois::gDebug(\"best score \", bestScore, \" beaten by \", scores[i]);\n bestScore = scores[i];\n bestHost = i;\n }\n }\n\n galois::gDebug(\"[\", _hostID, \"] \", src, \" assigned to \", bestHost,\n \" with num edge \", ne);\n\n // update metadata; TODO make this a nicer interface\n galois::atomicAdd(nodeAccum[bestHost], (uint64_t)1);\n galois::atomicAdd(edgeAccum[bestHost], ne);\n\n return bestHost;\n }\n }\n\n /**\n * return owner of edge using cartesian edge owner determination\n */\n uint32_t getEdgeOwner(uint32_t src, uint32_t dst, uint64_t) const {\n unsigned blockedRowOffset = getRowOfNode(src) * numColumnHosts;\n unsigned cyclicColumnOffset = getColumnOfNode(dst);\n return blockedRowOffset + cyclicColumnOffset;\n }\n\n bool noCommunication() { return false; }\n bool isVertexCut() const {\n if ((numRowHosts == 1) || (numColumnHosts == 1))\n return false;\n return true;\n }\n\n void serializePartition(boost::archive::binary_oarchive& ar) {\n ar << numRowHosts;\n ar << numColumnHosts;\n }\n\n void deserializePartition(boost::archive::binary_iarchive& ar) {\n ar >> numRowHosts;\n ar >> numColumnHosts;\n }\n\n std::pair cartesianGrid() {\n return std::make_pair(numRowHosts, numColumnHosts);\n }\n};\n\nclass SugarColumnFlipP : public galois::graphs::CustomMasterAssignment {\n // used in hybrid cut\n uint32_t _vCutThreshold;\n // ginger scoring constants\n double _gamma;\n double _alpha;\n // ginger node/edge ratio\n double _neRatio;\n\n unsigned numRowHosts;\n unsigned numColumnHosts;\n\n void factorizeHosts() {\n numColumnHosts = sqrt(_numHosts);\n\n while ((_numHosts % numColumnHosts) != 0)\n numColumnHosts--;\n\n numRowHosts = _numHosts / numColumnHosts;\n assert(numRowHosts >= numColumnHosts);\n\n // column flip\n std::swap(numRowHosts, numColumnHosts);\n\n if (_hostID == 0) {\n galois::gPrint(\"Cartesian grid: \", numRowHosts, \" x \", numColumnHosts,\n \"\\n\");\n }\n }\n\n //! Returns the grid row ID of this host\n unsigned gridRowID() const { return (_hostID / numColumnHosts); }\n //! Returns the grid row ID of the specified host\n unsigned gridRowID(unsigned id) const { return (id / numColumnHosts); }\n //! Returns the grid column ID of this host\n unsigned gridColumnID() const { return (_hostID % numColumnHosts); }\n //! Returns the grid column ID of the specified host\n unsigned gridColumnID(unsigned id) const { return (id % numColumnHosts); }\n\n //! Find the row of a particular node\n unsigned getRowOfNode(uint64_t gid) const {\n return gridRowID(retrieveMaster(gid));\n }\n\n //! Find the column of a particular node\n unsigned getColumnOfNode(uint64_t gid) const {\n return gridColumnID(retrieveMaster(gid));\n }\n\n /**\n * Returns Ginger's composite balance parameter for a given host\n */\n double getCompositeBalanceParam(\n unsigned host, const std::vector& nodeLoads,\n const std::vector>& nodeAccum,\n const std::vector& edgeLoads,\n const std::vector>& edgeAccum) {\n // get node/edge loads\n uint64_t hostNodeLoad = nodeLoads[host] + nodeAccum[host].load();\n uint64_t hostEdgeLoad = edgeLoads[host] + edgeAccum[host].load();\n\n return (hostNodeLoad + (_neRatio * hostEdgeLoad)) / 2;\n }\n\n /**\n * Use FENNEL balance equation to get a score value for partition\n * scoring\n */\n double getFennelBalanceScore(double param) {\n return _alpha * _gamma * pow(param, _gamma - 1);\n }\n\npublic:\n SugarColumnFlipP(uint32_t hostID, uint32_t numHosts, uint64_t numNodes,\n uint64_t numEdges)\n : galois::graphs::CustomMasterAssignment(hostID, numHosts, numNodes,\n numEdges) {\n _vCutThreshold = 1000;\n _gamma = 1.5;\n _alpha = numEdges * pow(numHosts, _gamma - 1.0) / pow(numNodes, _gamma);\n _neRatio = (double)numNodes / (double)numEdges;\n // CVC things\n factorizeHosts();\n }\n\n template \n uint32_t getMaster(uint32_t src,\n galois::graphs::BufferedGraph& bufGraph,\n const std::vector& localNodeToMaster,\n std::unordered_map& gid2offsets,\n const std::vector& nodeLoads,\n std::vector>& nodeAccum,\n const std::vector& edgeLoads,\n std::vector>& edgeAccum) {\n auto ii = bufGraph.edgeBegin(src);\n auto ee = bufGraph.edgeEnd(src);\n // number of edges\n uint64_t ne = std::distance(ii, ee);\n\n // high degree nodes masters stay the same\n if (ne > _vCutThreshold) {\n return _hostID;\n } else {\n // low degree masters move based on augmented FENNEL scoring metric\n // initialize array to hold scores\n galois::PODResizeableArray scores;\n scores.resize(_numHosts);\n for (unsigned i = 0; i < _numHosts; i++) {\n scores[i] = 0.0;\n }\n\n for (; ii < ee; ++ii) {\n uint64_t dst = bufGraph.edgeDestination(*ii);\n size_t offsetIntoMap = (unsigned)-1;\n\n auto it = gid2offsets.find(dst);\n if (it != gid2offsets.end()) {\n offsetIntoMap = it->second;\n } else {\n // determine offset\n offsetIntoMap = dst - bufGraph.getNodeOffset();\n }\n\n assert(offsetIntoMap != (unsigned)-1);\n assert(offsetIntoMap < localNodeToMaster.size());\n\n unsigned currentAssignment = localNodeToMaster[offsetIntoMap];\n\n if (currentAssignment != (unsigned)-1) {\n scores[currentAssignment] += 1.0;\n } else {\n galois::gDebug(\"[\", _hostID, \"] \", dst, \" unassigned\");\n }\n }\n\n // subtraction of the composite balance term\n for (unsigned i = 0; i < _numHosts; i++) {\n scores[i] -= getFennelBalanceScore(getCompositeBalanceParam(\n i, nodeLoads, nodeAccum, edgeLoads, edgeAccum));\n }\n\n unsigned bestHost = -1;\n double bestScore = std::numeric_limits::lowest();\n // find max score\n for (unsigned i = 0; i < _numHosts; i++) {\n if (scores[i] >= bestScore) {\n // galois::gDebug(\"best score \", bestScore, \" beaten by \", scores[i]);\n bestScore = scores[i];\n bestHost = i;\n }\n }\n\n galois::gDebug(\"[\", _hostID, \"] \", src, \" assigned to \", bestHost,\n \" with num edge \", ne);\n\n // update metadata; TODO make this a nicer interface\n galois::atomicAdd(nodeAccum[bestHost], (uint64_t)1);\n galois::atomicAdd(edgeAccum[bestHost], ne);\n\n return bestHost;\n }\n }\n\n /**\n * return owner of edge using cartesian edge owner determination\n */\n uint32_t getEdgeOwner(uint32_t src, uint32_t dst, uint64_t) const {\n unsigned blockedRowOffset = getRowOfNode(src) * numColumnHosts;\n unsigned cyclicColumnOffset = getColumnOfNode(dst);\n return blockedRowOffset + cyclicColumnOffset;\n }\n\n bool noCommunication() { return false; }\n bool isVertexCut() const {\n if ((numRowHosts == 1) && (numColumnHosts == 1))\n return false;\n return true;\n }\n void serializePartition(boost::archive::binary_oarchive& ar) {\n ar << numRowHosts;\n ar << numColumnHosts;\n }\n void deserializePartition(boost::archive::binary_iarchive& ar) {\n ar >> numRowHosts;\n ar >> numColumnHosts;\n }\n\n std::pair cartesianGrid() {\n return std::make_pair(numRowHosts, numColumnHosts);\n }\n};\n\n#endif\n" }, { "path": "libcusp/include/galois/graphs/MiningPartitioner.h", "content": "/*\n * This file belongs to the Galois project, a C++ library for exploiting\n * parallelism. The code is being released under the terms of the 3-Clause BSD\n * License (a copy is located in LICENSE.txt at the top-level directory).\n *\n * Copyright (C) 2019, The University of Texas at Austin. All rights reserved.\n * UNIVERSITY EXPRESSLY DISCLAIMS ANY AND ALL WARRANTIES CONCERNING THIS\n * SOFTWARE AND DOCUMENTATION, INCLUDING ANY WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR ANY PARTICULAR PURPOSE, NON-INFRINGEMENT AND WARRANTIES OF\n * PERFORMANCE, AND ANY WARRANTY THAT MIGHT OTHERWISE ARISE FROM COURSE OF\n * DEALING OR USAGE OF TRADE. NO WARRANTY IS EITHER EXPRESS OR IMPLIED WITH\n * RESPECT TO THE USE OF THE SOFTWARE OR DOCUMENTATION. Under no circumstances\n * shall University be liable for incidental, special, indirect, direct or\n * consequential damages or loss of profits, interruption of business, or\n * related expenses which may arise from use of Software or Documentation,\n * including but not limited to those resulting from defects in Software and/or\n * Documentation, or loss or inaccuracy of data of any kind.\n */\n\n/**\n * @file MiningPartitioner.h\n *\n * Graph mining partitioning that duplicates edges. Currently only supports an\n * outgoing edge cut.\n *\n * TODO lots of code dpulication here with regular cusp partitioner; need to\n * merge\n */\n\n#ifndef _GALOIS_DIST_MINING_H\n#define _GALOIS_DIST_MINING_H\n\n#include \"galois/graphs/DistributedGraph.h\"\n#include \"galois/DReducible.h\"\n\nnamespace galois {\nnamespace graphs {\n/**\n * @tparam NodeTy type of node data for the graph\n * @tparam EdgeTy type of edge data for the graph\n *\n * @todo fully document and clean up code\n * @warning not meant for public use + not fully documented yet\n */\ntemplate \nclass MiningGraph : public DistGraph {\n //! size used to buffer edge sends during partitioning\n constexpr static unsigned edgePartitionSendBufSize = 8388608;\n constexpr static const char* const GRNAME = \"dGraph_Mining\";\n std::unique_ptr graphPartitioner;\n\n uint32_t G2LEdgeCut(uint64_t gid, uint32_t globalOffset) const {\n assert(base_DistGraph::isLocal(gid));\n // optimized for edge cuts\n if (gid >= globalOffset && gid < globalOffset + base_DistGraph::numOwned)\n return gid - globalOffset;\n\n return base_DistGraph::globalToLocalMap.at(gid);\n }\n\n /**\n * Free memory of a vector by swapping an empty vector with it\n */\n template \n void freeVector(V& vectorToKill) {\n V dummyVector;\n vectorToKill.swap(dummyVector);\n }\n\n uint32_t nodesToReceive;\n\n uint64_t myKeptEdges;\n uint64_t myReadEdges;\n uint64_t globalKeptEdges;\n uint64_t totalEdgeProxies;\n\n std::vector> mirrorEdges;\n std::unordered_map localEdgeGIDToLID;\n\n std::vector getNodeDegrees(const std::string filename,\n uint32_t numNodes) {\n std::vector nodeDegrees;\n nodeDegrees.resize(numNodes);\n\n // read in prefix sum from GR on disk\n std::ifstream graphFile(filename.c_str());\n graphFile.seekg(sizeof(uint64_t) * 4);\n\n uint64_t* outIndexBuffer = (uint64_t*)malloc(sizeof(uint64_t) * numNodes);\n if (outIndexBuffer == nullptr) {\n GALOIS_DIE(\"out of memory\");\n }\n uint64_t numBytesToLoad = numNodes * sizeof(uint64_t);\n uint64_t bytesRead = 0;\n\n while (numBytesToLoad > 0) {\n graphFile.read(((char*)outIndexBuffer) + bytesRead, numBytesToLoad);\n size_t numRead = graphFile.gcount();\n numBytesToLoad -= numRead;\n bytesRead += numRead;\n }\n assert(numBytesToLoad == 0);\n\n galois::do_all(\n galois::iterate(0u, numNodes),\n [&](unsigned n) {\n if (n != 0) {\n nodeDegrees[n] = outIndexBuffer[n] - outIndexBuffer[n - 1];\n } else {\n nodeDegrees[n] = outIndexBuffer[0];\n }\n // galois::gDebug(n, \" degree \", nodeDegrees[n]);\n },\n galois::loopname(\"GetNodeDegrees\"), galois::no_stats());\n free(outIndexBuffer);\n\n#ifndef NDEBUG\n if (base_DistGraph::id == 0) {\n galois::gDebug(\"Sanity checking node degrees\");\n }\n\n galois::GAccumulator edgeCount;\n galois::do_all(\n galois::iterate(0u, numNodes),\n [&](unsigned n) { edgeCount += nodeDegrees[n]; },\n galois::loopname(\"SanityCheckDegrees\"), galois::no_stats());\n GALOIS_ASSERT(edgeCount.reduce() == base_DistGraph::numGlobalEdges);\n#endif\n\n return nodeDegrees;\n }\n\n virtual unsigned getHostIDImpl(uint64_t gid) const {\n assert(gid < base_DistGraph::numGlobalNodes);\n return graphPartitioner->retrieveMaster(gid);\n }\n\n virtual bool isOwnedImpl(uint64_t gid) const {\n assert(gid < base_DistGraph::numGlobalNodes);\n return (graphPartitioner->retrieveMaster(gid) == base_DistGraph::id);\n }\n\n virtual bool isLocalImpl(uint64_t gid) const {\n assert(gid < base_DistGraph::numGlobalNodes);\n return (base_DistGraph::globalToLocalMap.find(gid) !=\n base_DistGraph::globalToLocalMap.end());\n }\n\n virtual bool isVertexCutImpl() const { return false; }\n\npublic:\n //! typedef for base DistGraph class\n using base_DistGraph = DistGraph;\n\n /**\n * Returns edges owned by this graph (i.e. read).\n */\n uint64_t numOwnedEdges() const { return myKeptEdges; }\n\n /**\n * Returns # edges kept in all graphs.\n */\n uint64_t globalEdges() const { return globalKeptEdges; }\n\n std::vector>& getMirrorEdges() { return mirrorEdges; }\n\n /**\n * Return the reader of a particular node.\n * @param gid GID of node to get reader of\n * @return Host reader of node passed in as param\n */\n unsigned getHostReader(uint64_t gid) const {\n for (auto i = 0U; i < base_DistGraph::numHosts; ++i) {\n uint64_t start, end;\n std::tie(start, end) = base_DistGraph::gid2host[i];\n if (gid >= start && gid < end) {\n return i;\n }\n }\n return -1;\n }\n\n /**\n * Constructor\n */\n MiningGraph(\n const std::string& filename, unsigned host, unsigned _numHosts,\n bool setupGluon = true, bool doSort = false,\n galois::graphs::MASTERS_DISTRIBUTION md = BALANCED_EDGES_OF_MASTERS,\n uint32_t nodeWeight = 0, uint32_t edgeWeight = 0)\n : base_DistGraph(host, _numHosts) {\n galois::runtime::reportParam(GRNAME, \"MiningGraph\", \"0\");\n galois::CondStatTimer Tgraph_construct(\n \"GraphPartitioningTime\", GRNAME);\n Tgraph_construct.start();\n\n ////////////////////////////////////////////////////////////////////////////\n\n galois::graphs::OfflineGraph g(filename);\n base_DistGraph::numGlobalNodes = g.size();\n base_DistGraph::numGlobalEdges = g.sizeEdges();\n std::vector dummy;\n\n // not actually getting masters, but getting assigned readers for nodes\n base_DistGraph::computeMasters(md, g, dummy, nodeWeight, edgeWeight);\n\n std::vector ndegrees;\n\n if (Partitioner::needNodeDegrees()) {\n if (base_DistGraph::id == 0) {\n galois::gInfo(\"Calculating node degrees for partitioner\");\n }\n\n galois::runtime::reportParam(GRNAME, \"UsingDegreeOrdering\", \"1\");\n ndegrees = getNodeDegrees(filename, base_DistGraph::numGlobalNodes);\n }\n\n graphPartitioner = std::make_unique(\n host, _numHosts, base_DistGraph::numGlobalNodes,\n base_DistGraph::numGlobalEdges, ndegrees);\n graphPartitioner->saveGIDToHost(base_DistGraph::gid2host);\n\n ////////////////////////////////////////////////////////////////////////////\n\n uint64_t nodeBegin = base_DistGraph::gid2host[base_DistGraph::id].first;\n typename galois::graphs::OfflineGraph::edge_iterator edgeBegin =\n g.edge_begin(nodeBegin);\n uint64_t nodeEnd = base_DistGraph::gid2host[base_DistGraph::id].second;\n typename galois::graphs::OfflineGraph::edge_iterator edgeEnd =\n g.edge_begin(nodeEnd);\n\n galois::gPrint(\"[\", base_DistGraph::id, \"] Starting graph reading.\\n\");\n // never read edge data from disk\n galois::graphs::BufferedGraph bufGraph;\n bufGraph.resetReadCounters();\n galois::StatTimer graphReadTimer(\"GraphReading\", GRNAME);\n graphReadTimer.start();\n bufGraph.loadPartialGraph(filename, nodeBegin, nodeEnd, *edgeBegin,\n *edgeEnd, base_DistGraph::numGlobalNodes,\n base_DistGraph::numGlobalEdges);\n graphReadTimer.stop();\n galois::gPrint(\"[\", base_DistGraph::id, \"] Reading graph complete.\\n\");\n\n ////////////////////////////////////////////////////////////////////////////\n\n galois::StatTimer inspectionTimer(\"EdgeInspection\", GRNAME);\n inspectionTimer.start();\n bufGraph.resetReadCounters();\n galois::gstl::Vector prefixSumOfEdges;\n base_DistGraph::numOwned = nodeEnd - nodeBegin;\n prefixSumOfEdges.resize(base_DistGraph::numOwned);\n\n // initial pass; set up lid-gid mappings, determine which proxies exist on\n // this host; prefix sum of edges cna be set up up to the last master\n // node\n galois::DynamicBitSet presentProxies =\n edgeInspectionRound1(bufGraph, prefixSumOfEdges);\n // set my read nodes on present proxies\n // TODO parallel?\n for (uint64_t i = nodeBegin; i < nodeEnd; i++) {\n presentProxies.set(i);\n }\n\n // vector to store bitsets received from other hosts\n std::vector proxiesOnOtherHosts;\n proxiesOnOtherHosts.resize(_numHosts);\n\n // send off mirror proxies that exist on this host to other hosts\n communicateProxyInfo(presentProxies, proxiesOnOtherHosts);\n\n // signifies how many outgoing edges a particular host should expect from\n // this host\n std::vector> numOutgoingEdges;\n numOutgoingEdges.resize(base_DistGraph::numHosts);\n // edge inspection phase 2: determine how many edges to send to each host\n // don't actually send yet\n edgeInspectionRound2(bufGraph, numOutgoingEdges, proxiesOnOtherHosts);\n\n // prefix sum finalization\n finalizePrefixSum(numOutgoingEdges, prefixSumOfEdges);\n\n // doubly make sure the data is cleared\n freeVector(numOutgoingEdges); // should no longer use this variable\n inspectionTimer.stop();\n\n ////////////////////////////////////////////////////////////////////////////\n\n galois::StatTimer allocationTimer(\"GraphAllocation\", GRNAME);\n allocationTimer.start();\n\n // Graph construction related calls\n base_DistGraph::beginMaster = 0;\n // Allocate and construct the graph\n base_DistGraph::graph.allocateFrom(base_DistGraph::numNodes,\n base_DistGraph::numEdges);\n base_DistGraph::graph.constructNodes();\n\n // edge end fixing\n auto& base_graph = base_DistGraph::graph;\n galois::do_all(\n galois::iterate((uint32_t)0, base_DistGraph::numNodes),\n [&](uint64_t n) { base_graph.fixEndEdge(n, prefixSumOfEdges[n]); },\n#if MORE_DIST_STATS\n galois::loopname(\"FixEndEdgeLoop\"),\n#endif\n galois::no_stats());\n // get memory from prefix sum back\n prefixSumOfEdges.clear();\n freeVector(prefixSumOfEdges); // should no longer use this variable\n\n allocationTimer.stop();\n\n ////////////////////////////////////////////////////////////////////////////\n\n if (setupGluon) {\n galois::CondStatTimer TfillMirrors(\"FillMirrors\",\n GRNAME);\n\n TfillMirrors.start();\n fillMirrors();\n TfillMirrors.stop();\n }\n\n ////////////////////////////////////////////////////////////////////////////\n\n loadEdges(base_DistGraph::graph, bufGraph, proxiesOnOtherHosts);\n // TODO this might be useful to keep around\n proxiesOnOtherHosts.clear();\n ndegrees.clear();\n\n // SORT EDGES\n if (doSort) {\n base_DistGraph::sortEdgesByDestination();\n }\n\n if (setupGluon) {\n galois::CondStatTimer TfillMirrorsEdges(\n \"FillMirrorsEdges\", GRNAME);\n TfillMirrorsEdges.start();\n // edges\n mirrorEdges.resize(base_DistGraph::numHosts);\n galois::gPrint(\"[\", base_DistGraph::id,\n \"] Filling mirrors and creating \"\n \"mirror map\\n\");\n fillMirrorsEdgesAndCreateMirrorMap();\n TfillMirrorsEdges.stop();\n }\n\n ////////////////////////////////////////////////////////////////////////////\n\n galois::CondStatTimer Tthread_ranges(\"ThreadRangesTime\",\n GRNAME);\n\n galois::gPrint(\"[\", base_DistGraph::id, \"] Determining thread ranges\\n\");\n\n Tthread_ranges.start();\n base_DistGraph::determineThreadRanges();\n base_DistGraph::determineThreadRangesMaster();\n base_DistGraph::determineThreadRangesWithEdges();\n base_DistGraph::initializeSpecificRanges();\n Tthread_ranges.stop();\n\n Tgraph_construct.stop();\n galois::gPrint(\"[\", base_DistGraph::id, \"] Graph construction complete.\\n\");\n\n galois::DGAccumulator accumer;\n accumer.reset();\n accumer += base_DistGraph::sizeEdges();\n totalEdgeProxies = accumer.reduce();\n\n uint64_t totalNodeProxies;\n accumer.reset();\n accumer += base_DistGraph::size();\n totalNodeProxies = accumer.reduce();\n\n // report some statistics\n if (base_DistGraph::id == 0) {\n galois::runtime::reportStat_Single(\n GRNAME, std::string(\"TotalNodeProxies\"), totalNodeProxies);\n galois::runtime::reportStat_Single(\n GRNAME, std::string(\"TotalEdgeProxies\"), totalEdgeProxies);\n galois::runtime::reportStat_Single(GRNAME,\n std::string(\"OriginalNumberEdges\"),\n base_DistGraph::globalSizeEdges());\n galois::runtime::reportStat_Single(GRNAME, std::string(\"TotalKeptEdges\"),\n globalKeptEdges);\n GALOIS_ASSERT(globalKeptEdges * 2 == base_DistGraph::globalSizeEdges());\n galois::runtime::reportStat_Single(\n GRNAME, std::string(\"ReplicationFactorNodes\"),\n (totalNodeProxies) / (double)base_DistGraph::globalSize());\n galois::runtime::reportStat_Single(\n GRNAME, std::string(\"ReplicatonFactorEdges\"),\n (totalEdgeProxies) / (double)globalKeptEdges);\n }\n }\n\nprivate:\n galois::DynamicBitSet\n edgeInspectionRound1(galois::graphs::BufferedGraph& bufGraph,\n galois::gstl::Vector& prefixSumOfEdges) {\n galois::DynamicBitSet incomingMirrors;\n incomingMirrors.resize(base_DistGraph::numGlobalNodes);\n incomingMirrors.reset();\n\n uint32_t myID = base_DistGraph::id;\n uint64_t globalOffset = base_DistGraph::gid2host[base_DistGraph::id].first;\n\n // already set before this is called\n base_DistGraph::localToGlobalVector.resize(base_DistGraph::numOwned);\n\n galois::DGAccumulator keptEdges;\n keptEdges.reset();\n\n galois::GAccumulator allEdges;\n allEdges.reset();\n\n auto& ltgv = base_DistGraph::localToGlobalVector;\n galois::do_all(\n galois::iterate(base_DistGraph::gid2host[base_DistGraph::id].first,\n base_DistGraph::gid2host[base_DistGraph::id].second),\n [&](size_t n) {\n uint64_t edgeCount = 0;\n auto ii = bufGraph.edgeBegin(n);\n auto ee = bufGraph.edgeEnd(n);\n allEdges += std::distance(ii, ee);\n for (; ii < ee; ++ii) {\n uint32_t dst = bufGraph.edgeDestination(*ii);\n\n if (graphPartitioner->keepEdge(n, dst)) {\n edgeCount++;\n keptEdges += 1;\n // which mirrors do I have\n if (graphPartitioner->retrieveMaster(dst) != myID) {\n incomingMirrors.set(dst);\n }\n }\n }\n prefixSumOfEdges[n - globalOffset] = edgeCount;\n ltgv[n - globalOffset] = n;\n },\n#if MORE_DIST_STATS\n galois::loopname(\"EdgeInspectionLoop\"),\n#endif\n galois::steal(), galois::no_stats());\n\n myKeptEdges = keptEdges.read_local();\n myReadEdges = allEdges.reduce();\n globalKeptEdges = keptEdges.reduce();\n\n // get incoming mirrors ready for creation\n uint32_t additionalMirrorCount = incomingMirrors.count();\n base_DistGraph::localToGlobalVector.resize(\n base_DistGraph::localToGlobalVector.size() + additionalMirrorCount);\n\n // note prefix sum will get finalized in a later step\n if (base_DistGraph::numOwned > 0) {\n prefixSumOfEdges.resize(prefixSumOfEdges.size() + additionalMirrorCount,\n 0);\n } else {\n prefixSumOfEdges.resize(additionalMirrorCount, 0);\n }\n\n // map creation: lid to gid\n if (additionalMirrorCount > 0) {\n uint32_t totalNumNodes = base_DistGraph::numGlobalNodes;\n uint32_t activeThreads = galois::getActiveThreads();\n std::vector threadPrefixSums(activeThreads);\n galois::on_each([&](unsigned tid, unsigned nthreads) {\n size_t beginNode;\n size_t endNode;\n std::tie(beginNode, endNode) =\n galois::block_range(0u, totalNumNodes, tid, nthreads);\n uint64_t count = 0;\n for (size_t i = beginNode; i < endNode; i++) {\n if (incomingMirrors.test(i))\n ++count;\n }\n threadPrefixSums[tid] = count;\n });\n // get prefix sums\n for (unsigned int i = 1; i < threadPrefixSums.size(); i++) {\n threadPrefixSums[i] += threadPrefixSums[i - 1];\n }\n\n assert(threadPrefixSums.back() == additionalMirrorCount);\n\n uint32_t startingNodeIndex = base_DistGraph::numOwned;\n // do actual work, second on_each\n galois::on_each([&](unsigned tid, unsigned nthreads) {\n size_t beginNode;\n size_t endNode;\n std::tie(beginNode, endNode) =\n galois::block_range(0u, totalNumNodes, tid, nthreads);\n // start location to start adding things into prefix sums/vectors\n uint32_t threadStartLocation = 0;\n if (tid != 0) {\n threadStartLocation = threadPrefixSums[tid - 1];\n }\n uint32_t handledNodes = 0;\n for (size_t i = beginNode; i < endNode; i++) {\n if (incomingMirrors.test(i)) {\n base_DistGraph::localToGlobalVector[startingNodeIndex +\n threadStartLocation +\n handledNodes] = i;\n handledNodes++;\n }\n }\n });\n }\n\n base_DistGraph::numNodes = base_DistGraph::numOwned + additionalMirrorCount;\n base_DistGraph::numNodesWithEdges = base_DistGraph::numNodes;\n assert(base_DistGraph::localToGlobalVector.size() ==\n base_DistGraph::numNodes);\n\n // g2l mapping\n base_DistGraph::globalToLocalMap.reserve(base_DistGraph::numNodes);\n for (unsigned i = 0; i < base_DistGraph::numNodes; i++) {\n // global to local map construction\n base_DistGraph::globalToLocalMap[base_DistGraph::localToGlobalVector[i]] =\n i;\n }\n assert(base_DistGraph::globalToLocalMap.size() == base_DistGraph::numNodes);\n\n return incomingMirrors;\n }\n\n /**\n * Communicate to other hosts which proxies exist on this host.\n *\n * @param presentProxies Bitset marking which proxies are present on this host\n * @param proxiesOnOtherHosts Vector to deserialize received bitsets into\n */\n void communicateProxyInfo(\n galois::DynamicBitSet& presentProxies,\n std::vector& proxiesOnOtherHosts) {\n auto& net = galois::runtime::getSystemNetworkInterface();\n // Send proxies on this host to other hosts\n for (unsigned h = 0; h < base_DistGraph::numHosts; ++h) {\n if (h != base_DistGraph::id) {\n galois::runtime::SendBuffer bitsetBuffer;\n galois::runtime::gSerialize(bitsetBuffer, presentProxies);\n net.sendTagged(h, galois::runtime::evilPhase, bitsetBuffer);\n }\n }\n\n // receive loop\n for (unsigned h = 0; h < net.Num - 1; h++) {\n decltype(net.recieveTagged(galois::runtime::evilPhase, nullptr)) p;\n do {\n p = net.recieveTagged(galois::runtime::evilPhase, nullptr);\n } while (!p);\n uint32_t sendingHost = p->first;\n // deserialize proxiesOnOtherHosts\n galois::runtime::gDeserialize(p->second,\n proxiesOnOtherHosts[sendingHost]);\n }\n\n base_DistGraph::increment_evilPhase();\n }\n\n void edgeInspectionRound2(\n galois::graphs::BufferedGraph& bufGraph,\n std::vector>& numOutgoingEdges,\n std::vector& proxiesOnOtherHosts) {\n auto& net = galois::runtime::getSystemNetworkInterface();\n // allocate vectors for counting edges that must be sent\n // number of nodes that this host has read from disk\n uint32_t numRead = base_DistGraph::gid2host[base_DistGraph::id].second -\n base_DistGraph::gid2host[base_DistGraph::id].first;\n // allocate space for outgoing edges\n for (uint32_t i = 0; i < base_DistGraph::numHosts; ++i) {\n numOutgoingEdges[i].assign(numRead, 0);\n }\n uint64_t globalOffset = base_DistGraph::gid2host[base_DistGraph::id].first;\n\n galois::DynamicBitSet hostHasOutgoing;\n hostHasOutgoing.resize(base_DistGraph::numHosts);\n hostHasOutgoing.reset();\n\n // flip loop order, this can be optimized\n // for each host, loop over my local nodes\n galois::do_all(\n galois::iterate(base_DistGraph::gid2host[base_DistGraph::id].first,\n base_DistGraph::gid2host[base_DistGraph::id].second),\n [&](size_t n) {\n auto ii = bufGraph.edgeBegin(n);\n auto ee = bufGraph.edgeEnd(n);\n\n for (; ii < ee; ++ii) {\n uint32_t dst = bufGraph.edgeDestination(*ii);\n // make sure this edge is going to be kept and not dropped\n if (graphPartitioner->keepEdge(n, dst)) {\n for (unsigned h = 0; h < net.Num; h++) {\n if (h != net.ID) {\n if (proxiesOnOtherHosts[h].test(n)) {\n // if kept, make sure destination exists on that host\n if (proxiesOnOtherHosts[h].test(dst)) {\n // if it does, this edge must be duplicated on that host;\n // increment count\n numOutgoingEdges[h][n - globalOffset] += 1;\n hostHasOutgoing.set(h);\n }\n }\n }\n }\n }\n }\n },\n#if MORE_DIST_STATS\n galois::loopname(\"EdgeInspectionRound2Loop\"),\n#endif\n galois::steal(), galois::no_stats());\n\n // send data off, then receive it\n sendInspectionData(numOutgoingEdges, hostHasOutgoing);\n recvInspectionData(numOutgoingEdges);\n base_DistGraph::increment_evilPhase();\n }\n\n /**\n * Send data out from inspection to other hosts.\n *\n * @param[in,out] numOutgoingEdges specifies which nodes on a host will have\n * outgoing edges\n * @param[in] hostHasOutgoing bitset tracking which hosts have outgoing\n * edges from this host\n */\n void sendInspectionData(std::vector>& numOutgoingEdges,\n galois::DynamicBitSet& hostHasOutgoing) {\n auto& net = galois::runtime::getSystemNetworkInterface();\n\n galois::GAccumulator bytesSent;\n bytesSent.reset();\n\n for (unsigned h = 0; h < net.Num; h++) {\n if (h == net.ID) {\n continue;\n }\n\n // send outgoing edges data off to comm partner\n galois::runtime::SendBuffer b;\n\n // only send if non-zeros exist\n if (hostHasOutgoing.test(h)) {\n galois::runtime::gSerialize(b, 1); // token saying data exists\n galois::runtime::gSerialize(b, numOutgoingEdges[h]);\n } else {\n galois::runtime::gSerialize(b, 0); // token saying no data exists\n }\n numOutgoingEdges[h].clear();\n\n bytesSent.update(b.size());\n\n // send buffer and free memory\n net.sendTagged(h, galois::runtime::evilPhase, b);\n b.getVec().clear();\n }\n galois::runtime::reportStat_Tsum(\n GRNAME, std::string(\"EdgeInspectionBytesSent\"), bytesSent.reduce());\n\n galois::gPrint(\"[\", base_DistGraph::id, \"] Inspection sends complete.\\n\");\n }\n\n /**\n * Receive data from inspection from other hosts. Processes the incoming\n * edge bitsets/offsets.\n *\n * @param[in,out] numOutgoingEdges specifies which nodes on a host will have\n * outgoing edges\n */\n void\n recvInspectionData(std::vector>& numOutgoingEdges) {\n auto& net = galois::runtime::getSystemNetworkInterface();\n\n for (unsigned h = 0; h < net.Num - 1; h++) {\n // expect data from comm partner back\n decltype(net.recieveTagged(galois::runtime::evilPhase, nullptr)) p;\n do {\n p = net.recieveTagged(galois::runtime::evilPhase, nullptr);\n } while (!p);\n\n uint32_t sendingHost = p->first;\n\n // get outgoing edges; first get status var\n uint32_t outgoingExists = 2;\n galois::runtime::gDeserialize(p->second, outgoingExists);\n\n if (outgoingExists == 1) {\n // actual data sent\n galois::runtime::gDeserialize(p->second, numOutgoingEdges[sendingHost]);\n } else if (outgoingExists == 0) {\n // no data sent; just clear again\n numOutgoingEdges[sendingHost].clear();\n } else {\n GALOIS_DIE(\"unreachable: \", outgoingExists);\n }\n }\n\n galois::gPrint(\"[\", base_DistGraph::id,\n \"] Inspection receives complete.\\n\");\n }\n\n /**\n * Take inspection metadata and begin mapping nodes/creating prefix sums,\n * return the prefix sum.\n */\n galois::gstl::Vector\n finalizePrefixSum(std::vector>& numOutgoingEdges,\n galois::gstl::Vector& prefixSumOfEdges) {\n base_DistGraph::numEdges = 0;\n\n inspectOutgoingNodes(numOutgoingEdges, prefixSumOfEdges);\n finalizeInspection(prefixSumOfEdges);\n galois::gDebug(\"[\", base_DistGraph::id,\n \"] To receive this many nodes: \", nodesToReceive);\n galois::gPrint(\"[\", base_DistGraph::id,\n \"] Inspection allocation complete.\\n\");\n return prefixSumOfEdges;\n }\n\n /**\n * Outgoing inspection: loop over proxy nodes, determnine if need to receive\n * edges.\n */\n void\n inspectOutgoingNodes(std::vector>& numOutgoingEdges,\n galois::gstl::Vector& prefixSumOfEdges) {\n galois::GAccumulator toReceive;\n toReceive.reset();\n\n uint32_t proxyStart = base_DistGraph::numOwned;\n uint32_t proxyEnd = base_DistGraph::numNodes;\n assert(proxyEnd == prefixSumOfEdges.size());\n\n galois::GAccumulator edgesToReceive;\n edgesToReceive.reset();\n\n // loop over proxy nodes, see if edges need to be sent from another host\n // by looking at results of edge inspection\n galois::do_all(\n galois::iterate(proxyStart, proxyEnd),\n [&](uint32_t lid) {\n uint64_t gid = base_DistGraph::localToGlobalVector[lid];\n assert(gid < base_DistGraph::numGlobalNodes);\n unsigned hostReader = getHostReader(gid);\n assert(hostReader < base_DistGraph::numHosts);\n assert(hostReader != base_DistGraph::id); // self shouldn't be proxy\n\n uint64_t nodeOffset = base_DistGraph::gid2host[hostReader].first;\n if (numOutgoingEdges[hostReader].size()) {\n if (numOutgoingEdges[hostReader][gid - nodeOffset]) {\n // if this host is going to send me edges, note it for future use\n prefixSumOfEdges[lid] =\n numOutgoingEdges[hostReader][gid - nodeOffset];\n edgesToReceive += numOutgoingEdges[hostReader][gid - nodeOffset];\n toReceive += 1;\n }\n }\n },\n galois::loopname(\"OutgoingNodeInspection\"), galois::steal(),\n galois::no_stats());\n\n galois::gPrint(\"[\", base_DistGraph::id, \"] Need receive \",\n edgesToReceive.reduce(), \" edges; self is \", myKeptEdges,\n \"\\n\");\n // get memory back\n numOutgoingEdges.clear();\n nodesToReceive = toReceive.reduce();\n }\n\n /**\n * finalize metadata maps\n */\n void finalizeInspection(galois::gstl::Vector& prefixSumOfEdges) {\n for (unsigned i = 1; i < base_DistGraph::numNodes; i++) {\n // finalize prefix sum\n prefixSumOfEdges[i] += prefixSumOfEdges[i - 1];\n }\n if (prefixSumOfEdges.size() != 0) {\n base_DistGraph::numEdges = prefixSumOfEdges.back();\n } else {\n base_DistGraph::numEdges = 0;\n }\n }\n\n ////////////////////////////////////////////////////////////////////////////////\npublic:\n galois::GAccumulator lgMapAccesses;\n /**\n * Construct a map from local edge GIDs to LID\n */\n void constructLocalEdgeGIDMap() {\n lgMapAccesses.reset();\n galois::StatTimer mapConstructTimer(\"GID2LIDMapConstructTimer\", GRNAME);\n mapConstructTimer.start();\n\n localEdgeGIDToLID.reserve(base_DistGraph::sizeEdges());\n\n uint64_t count = 0;\n for (unsigned src = 0; src < base_DistGraph::size(); src++) {\n for (auto edge = base_DistGraph::edge_begin(src);\n edge != base_DistGraph::edge_end(src); edge++) {\n assert((*edge) == count);\n unsigned dst = base_DistGraph::getEdgeDst(edge);\n uint64_t localGID = getEdgeGIDFromSD(src, dst);\n // insert into map\n localEdgeGIDToLID.insert(std::make_pair(localGID, count));\n count++;\n }\n }\n\n GALOIS_ASSERT(localEdgeGIDToLID.size() == base_DistGraph::sizeEdges());\n GALOIS_ASSERT(count == base_DistGraph::sizeEdges());\n\n mapConstructTimer.stop();\n }\n\n void reportAccessBefore() {\n galois::runtime::reportStat_Single(GRNAME, std::string(\"MapAccessesBefore\"),\n lgMapAccesses.reduce());\n }\n\n void reportAccess() {\n galois::runtime::reportStat_Single(GRNAME, std::string(\"MapAccesses\"),\n lgMapAccesses.reduce());\n }\n\n /**\n * checks map constructed above to see which local id corresponds\n * to a node/edge (if it exists)\n *\n * assumes map is generated\n */\n std::pair getLIDFromMap(unsigned src, unsigned dst) {\n lgMapAccesses += 1;\n // try to find gid in map\n uint64_t localGID = getEdgeGIDFromSD(src, dst);\n auto findResult = localEdgeGIDToLID.find(localGID);\n\n // return if found, else return a false\n if (findResult != localEdgeGIDToLID.end()) {\n return std::make_pair(findResult->second, true);\n } else {\n // not found\n return std::make_pair((uint64_t)-1, false);\n }\n }\n\n uint64_t getEdgeLID(uint64_t gid) {\n uint64_t sourceNodeGID = edgeGIDToSource(gid);\n uint64_t sourceNodeLID = base_DistGraph::getLID(sourceNodeGID);\n uint64_t destNodeLID = base_DistGraph::getLID(edgeGIDToDest(gid));\n\n for (auto edge : base_DistGraph::edges(sourceNodeLID)) {\n uint64_t edgeDst = base_DistGraph::getEdgeDst(edge);\n if (edgeDst == destNodeLID) {\n return *edge;\n }\n }\n GALOIS_DIE(\"unreachable\");\n return (uint64_t)-1;\n }\n\n uint32_t findSourceFromEdge(uint64_t lid) {\n // TODO binary search\n // uint32_t left = 0;\n // uint32_t right = base_DistGraph::numNodes;\n // uint32_t mid = (left + right) / 2;\n\n for (uint32_t mid = 0; mid < base_DistGraph::numNodes; mid++) {\n uint64_t edge_left = *(base_DistGraph::edge_begin(mid));\n uint64_t edge_right = *(base_DistGraph::edge_begin(mid + 1));\n\n if (edge_left <= lid && lid < edge_right) {\n return mid;\n }\n }\n\n GALOIS_DIE(\"unreachable\");\n return (uint32_t)-1;\n }\n\n uint64_t getEdgeGID(uint64_t lid) {\n uint32_t src = base_DistGraph::getGID(findSourceFromEdge(lid));\n uint32_t dst = base_DistGraph::getGID(base_DistGraph::getEdgeDst(lid));\n return getEdgeGIDFromSD(src, dst);\n }\n\nprivate:\n // https://www.quora.com/\n // Is-there-a-mathematical-function-that-converts-two-numbers-into-one-so-\n // that-the-two-numbers-can-always-be-extracted-again\n // GLOBAL IDS ONLY\n uint64_t getEdgeGIDFromSD(uint32_t source, uint32_t dest) {\n return source + (dest % base_DistGraph::numGlobalNodes) *\n base_DistGraph::numGlobalNodes;\n }\n\n uint64_t edgeGIDToSource(uint64_t gid) {\n return gid % base_DistGraph::numGlobalNodes;\n }\n\n uint64_t edgeGIDToDest(uint64_t gid) {\n // assuming this floors\n return gid / base_DistGraph::numGlobalNodes;\n }\n\n /**\n * Fill up mirror arrays.\n * TODO make parallel?\n */\n void fillMirrors() {\n base_DistGraph::mirrorNodes.reserve(base_DistGraph::numNodes -\n base_DistGraph::numOwned);\n for (uint32_t i = base_DistGraph::numOwned; i < base_DistGraph::numNodes;\n i++) {\n uint32_t globalID = base_DistGraph::localToGlobalVector[i];\n base_DistGraph::mirrorNodes[graphPartitioner->retrieveMaster(globalID)]\n .push_back(globalID);\n }\n }\n\n void fillMirrorsEdgesAndCreateMirrorMap() {\n for (uint32_t src = base_DistGraph::numOwned;\n src < base_DistGraph::numNodes; src++) {\n auto ee = base_DistGraph::edge_begin(src);\n auto ee_end = base_DistGraph::edge_end(src);\n uint32_t globalSource = base_DistGraph::getGID(src);\n unsigned sourceOwner = graphPartitioner->retrieveMaster(globalSource);\n\n for (; ee != ee_end; ++ee) {\n // create mirror array\n uint64_t edgeGID = getEdgeGIDFromSD(\n globalSource,\n base_DistGraph::getGID(base_DistGraph::getEdgeDst(ee)));\n mirrorEdges[sourceOwner].push_back(edgeGID);\n }\n }\n }\n\n ////////////////////////////////////////////////////////////////////////////////\n\n template \n void loadEdges(GraphTy& graph, galois::graphs::BufferedGraph& bufGraph,\n std::vector& proxiesOnOtherHosts) {\n galois::StatTimer loadEdgeTimer(\"EdgeLoading\", GRNAME);\n loadEdgeTimer.start();\n\n bufGraph.resetReadCounters();\n std::atomic receivedNodes;\n receivedNodes.store(0);\n\n // sends data\n sendEdges(graph, bufGraph, receivedNodes, proxiesOnOtherHosts);\n // uint64_t bufBytesRead = bufGraph.getBytesRead();\n // get data from graph back (don't need it after sending things out)\n bufGraph.resetAndFree();\n\n // receives data\n galois::on_each(\n [&](unsigned GALOIS_UNUSED(tid), unsigned GALOIS_UNUSED(nthreads)) {\n receiveEdges(graph, receivedNodes);\n });\n base_DistGraph::increment_evilPhase();\n loadEdgeTimer.stop();\n\n galois::gPrint(\"[\", base_DistGraph::id, \"] Edge loading time: \",\n loadEdgeTimer.get_usec() / 1000000.0f, \" seconds\\n\");\n }\n\n // no edge data version\n template \n void sendEdges(GraphTy& graph, galois::graphs::BufferedGraph& bufGraph,\n std::atomic& receivedNodes,\n std::vector& proxiesOnOtherHosts) {\n using DstVecType = std::vector>;\n using SendBufferVecTy = std::vector;\n\n galois::substrate::PerThreadStorage gdst_vecs(\n base_DistGraph::numHosts);\n galois::substrate::PerThreadStorage sendBuffers(\n base_DistGraph::numHosts);\n\n auto& net = galois::runtime::getSystemNetworkInterface();\n const unsigned& id = this->base_DistGraph::id;\n const unsigned& numHosts = this->base_DistGraph::numHosts;\n\n galois::GAccumulator messagesSent;\n galois::GAccumulator bytesSent;\n galois::GReduceMax maxBytesSent;\n messagesSent.reset();\n bytesSent.reset();\n maxBytesSent.reset();\n\n // Go over assigned nodes and distribute edges.\n galois::do_all(\n galois::iterate(base_DistGraph::gid2host[base_DistGraph::id].first,\n base_DistGraph::gid2host[base_DistGraph::id].second),\n [&](uint64_t src) {\n uint32_t lsrc = 0;\n uint64_t curEdge = 0;\n if (base_DistGraph::isLocal(src)) {\n lsrc = this->G2L(src);\n curEdge = *graph.edge_begin(lsrc, galois::MethodFlag::UNPROTECTED);\n }\n\n auto ee = bufGraph.edgeBegin(src);\n auto ee_end = bufGraph.edgeEnd(src);\n auto& gdst_vec = *gdst_vecs.getLocal();\n\n for (unsigned i = 0; i < numHosts; ++i) {\n gdst_vec[i].clear();\n }\n\n for (; ee != ee_end; ++ee) {\n uint32_t gdst = bufGraph.edgeDestination(*ee);\n // make sure this edge is going to be kept and not dropped\n if (graphPartitioner->keepEdge(src, gdst)) {\n assert(base_DistGraph::isLocal(src));\n uint32_t ldst = this->G2L(gdst);\n graph.constructEdge(curEdge++, ldst);\n\n for (unsigned h = 0; h < net.Num; h++) {\n if (h != net.ID) {\n if (proxiesOnOtherHosts[h].test(src)) {\n // if kept, make sure destination exists on that host\n if (proxiesOnOtherHosts[h].test(gdst)) {\n // if it does, this edge must be duplicated on that host;\n // increment count\n gdst_vec[h].push_back(gdst);\n }\n }\n }\n }\n }\n }\n\n // make sure all edges accounted for if local\n if (base_DistGraph::isLocal(src)) {\n assert(curEdge == (*graph.edge_end(lsrc)));\n }\n\n // send\n for (uint32_t h = 0; h < numHosts; ++h) {\n if (h == id)\n continue;\n\n if (gdst_vec[h].size() > 0) {\n auto& b = (*sendBuffers.getLocal())[h];\n galois::runtime::gSerialize(b, src);\n galois::runtime::gSerialize(b, gdst_vec[h]);\n\n // send if over limit\n if (b.size() > edgePartitionSendBufSize) {\n messagesSent += 1;\n bytesSent.update(b.size());\n maxBytesSent.update(b.size());\n\n net.sendTagged(h, galois::runtime::evilPhase, b);\n b.getVec().clear();\n b.getVec().reserve(edgePartitionSendBufSize * 1.25);\n }\n }\n }\n\n // overlap receives\n auto buffer = net.recieveTagged(galois::runtime::evilPhase, nullptr);\n this->processReceivedEdgeBuffer(buffer, graph, receivedNodes);\n },\n#if MORE_DIST_STATS\n galois::loopname(\"EdgeLoading\"),\n#endif\n galois::steal(), galois::no_stats());\n\n // flush buffers\n for (unsigned threadNum = 0; threadNum < sendBuffers.size(); ++threadNum) {\n auto& sbr = *sendBuffers.getRemote(threadNum);\n for (unsigned h = 0; h < this->base_DistGraph::numHosts; ++h) {\n if (h == this->base_DistGraph::id)\n continue;\n auto& sendBuffer = sbr[h];\n if (sendBuffer.size() > 0) {\n messagesSent += 1;\n bytesSent.update(sendBuffer.size());\n maxBytesSent.update(sendBuffer.size());\n\n net.sendTagged(h, galois::runtime::evilPhase, sendBuffer);\n sendBuffer.getVec().clear();\n }\n }\n }\n\n net.flush();\n\n galois::runtime::reportStat_Tsum(\n GRNAME, std::string(\"EdgeLoadingMessagesSent\"), messagesSent.reduce());\n galois::runtime::reportStat_Tsum(\n GRNAME, std::string(\"EdgeLoadingBytesSent\"), bytesSent.reduce());\n galois::runtime::reportStat_Tmax(\n GRNAME, std::string(\"EdgeLoadingMaxBytesSent\"), maxBytesSent.reduce());\n }\n\n //! @copydoc DistGraphHybridCut::processReceivedEdgeBuffer\n template \n void processReceivedEdgeBuffer(\n std::optional>& buffer,\n GraphTy& graph, std::atomic& receivedNodes) {\n if (buffer) {\n auto& rb = buffer->second;\n while (rb.r_size() > 0) {\n uint64_t n;\n std::vector gdst_vec;\n galois::runtime::gDeserialize(rb, n);\n galois::runtime::gDeserialize(rb, gdst_vec);\n assert(base_DistGraph::isLocal(n));\n uint32_t lsrc = this->G2L(n);\n uint64_t cur = *graph.edge_begin(lsrc, galois::MethodFlag::UNPROTECTED);\n uint64_t cur_end = *graph.edge_end(lsrc);\n assert((cur_end - cur) == gdst_vec.size());\n deserializeEdges(graph, gdst_vec, cur, cur_end);\n ++receivedNodes;\n }\n }\n }\n\n /**\n * Receive the edge dest/data assigned to this host from other hosts\n * that were responsible for reading them.\n */\n template \n void receiveEdges(GraphTy& graph, std::atomic& receivedNodes) {\n auto& net = galois::runtime::getSystemNetworkInterface();\n\n // receive edges for all mirror nodes\n while (receivedNodes < nodesToReceive) {\n decltype(net.recieveTagged(galois::runtime::evilPhase, nullptr)) p;\n p = net.recieveTagged(galois::runtime::evilPhase, nullptr);\n processReceivedEdgeBuffer(p, graph, receivedNodes);\n }\n }\n\n template \n void deserializeEdges(GraphTy& graph, std::vector& gdst_vec,\n uint64_t& cur, uint64_t& cur_end) {\n uint64_t i = 0;\n while (cur < cur_end) {\n uint64_t gdst = gdst_vec[i++];\n uint32_t ldst = this->G2L(gdst);\n graph.constructEdge(cur++, ldst);\n }\n }\n};\n\n// make GRNAME visible to public\ntemplate \nconstexpr const char* const\n galois::graphs::MiningGraph::GRNAME;\n\n} // end namespace graphs\n} // end namespace galois\n#endif\n" }, { "path": "libcusp/include/galois/graphs/NewGeneric.h", "content": "/*\n * This file belongs to the Galois project, a C++ library for exploiting\n * parallelism. The code is being released under the terms of the 3-Clause BSD\n * License (a copy is located in LICENSE.txt at the top-level directory).\n *\n * Copyright (C) 2020, The University of Texas at Austin. All rights reserved.\n * UNIVERSITY EXPRESSLY DISCLAIMS ANY AND ALL WARRANTIES CONCERNING THIS\n * SOFTWARE AND DOCUMENTATION, INCLUDING ANY WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR ANY PARTICULAR PURPOSE, NON-INFRINGEMENT AND WARRANTIES OF\n * PERFORMANCE, AND ANY WARRANTY THAT MIGHT OTHERWISE ARISE FROM COURSE OF\n * DEALING OR USAGE OF TRADE. NO WARRANTY IS EITHER EXPRESS OR IMPLIED WITH\n * RESPECT TO THE USE OF THE SOFTWARE OR DOCUMENTATION. Under no circumstances\n * shall University be liable for incidental, special, indirect, direct or\n * consequential damages or loss of profits, interruption of business, or\n * related expenses which may arise from use of Software or Documentation,\n * including but not limited to those resulting from defects in Software and/or\n * Documentation, or loss or inaccuracy of data of any kind.\n */\n\n/**\n * @file NewGeneric.h\n *\n * Contains the main graph class as well as the partitioning logic that CuSP\n * uses.\n */\n\n#ifndef _GALOIS_DIST_NEWGENERIC_H\n#define _GALOIS_DIST_NEWGENERIC_H\n\n#include \"galois/graphs/DistributedGraph.h\"\n#include \"galois/DReducible.h\"\n#include \n#include \n\n#define CUSP_PT_TIMER 0\n\nnamespace galois {\nnamespace graphs {\n/**\n * @tparam NodeTy type of node data for the graph\n * @tparam EdgeTy type of edge data for the graph\n *\n * @todo fully document and clean up code\n * @warning not meant for public use + not fully documented yet\n */\ntemplate \nclass NewDistGraphGeneric : public DistGraph {\n //! size used to buffer edge sends during partitioning\n constexpr static unsigned edgePartitionSendBufSize = 8388608;\n constexpr static const char* const GRNAME = \"dGraph_Generic\";\n std::unique_ptr graphPartitioner;\n\n //! How many rounds to sync state during edge assignment phase\n uint32_t _edgeStateRounds;\n std::vector> hostLoads;\n std::vector old_hostLoads;\n\n uint32_t G2LEdgeCut(uint64_t gid, uint32_t globalOffset) const {\n assert(base_DistGraph::isLocal(gid));\n // optimized for edge cuts\n if (gid >= globalOffset && gid < globalOffset + base_DistGraph::numOwned)\n return gid - globalOffset;\n\n return base_DistGraph::globalToLocalMap.at(gid);\n }\n\n /**\n * Free memory of a vector by swapping an empty vector with it\n */\n template \n void freeVector(V& vectorToKill) {\n V dummyVector;\n vectorToKill.swap(dummyVector);\n }\n\n uint32_t nodesToReceive;\n\npublic:\n //! typedef for base DistGraph class\n using base_DistGraph = DistGraph;\n\nprivate:\n virtual unsigned getHostIDImpl(uint64_t gid) const {\n assert(gid < base_DistGraph::numGlobalNodes);\n return graphPartitioner->retrieveMaster(gid);\n }\n\n virtual bool isOwnedImpl(uint64_t gid) const {\n assert(gid < base_DistGraph::numGlobalNodes);\n return (graphPartitioner->retrieveMaster(gid) == base_DistGraph::id);\n }\n\n virtual bool isLocalImpl(uint64_t gid) const {\n assert(gid < base_DistGraph::numGlobalNodes);\n return (base_DistGraph::globalToLocalMap.find(gid) !=\n base_DistGraph::globalToLocalMap.end());\n }\n\n // TODO current uses graph partitioner\n // TODO make it so user doens't have to specify; can be done by tracking\n // if an outgoing mirror is marked as having an incoming edge on any\n // host\n virtual bool isVertexCutImpl() const {\n return graphPartitioner->isVertexCut();\n }\n virtual std::pair cartesianGridImpl() const {\n return graphPartitioner->cartesianGrid();\n }\n\npublic:\n /**\n * Reset load balance on host reducibles.\n */\n void resetEdgeLoad() {\n if (_edgeStateRounds > 1) {\n if (!graphPartitioner->noCommunication()) {\n for (unsigned i = 0; i < base_DistGraph::numHosts; i++) {\n hostLoads[i].reset();\n old_hostLoads[i] = 0;\n }\n }\n }\n }\n\n /**\n * Sync load balance on hosts using reducibles.\n */\n void syncEdgeLoad() {\n if (_edgeStateRounds > 1) {\n if (!graphPartitioner->noCommunication()) {\n for (unsigned i = 0; i < base_DistGraph::numHosts; i++) {\n old_hostLoads[i] += hostLoads[i].reduce();\n hostLoads[i].reset();\n }\n }\n }\n }\n\n /**\n * Debug function: prints host loads.\n */\n void printEdgeLoad() {\n if (_edgeStateRounds > 1) {\n if (!graphPartitioner->noCommunication()) {\n if (base_DistGraph::id == 0) {\n for (unsigned i = 0; i < base_DistGraph::numHosts; i++) {\n galois::gDebug(\"[\", base_DistGraph::id, \"] \", i, \" \",\n old_hostLoads[i], \"\\n\");\n }\n }\n }\n }\n }\n\n /**\n * Constructor\n */\n NewDistGraphGeneric(\n const std::string& filename, unsigned host, unsigned _numHosts,\n bool cuspAsync = true, uint32_t stateRounds = 100, bool transpose = false,\n galois::graphs::MASTERS_DISTRIBUTION md = BALANCED_EDGES_OF_MASTERS,\n uint32_t nodeWeight = 0, uint32_t edgeWeight = 0,\n std::string masterBlockFile = \"\", bool readFromFile = false,\n std::string localGraphFileName = \"local_graph\",\n uint32_t edgeStateRounds = 1)\n : base_DistGraph(host, _numHosts), _edgeStateRounds(edgeStateRounds) {\n galois::runtime::reportParam(\"dGraph\", \"GenericPartitioner\", \"0\");\n galois::CondStatTimer Tgraph_construct(\n \"GraphPartitioningTime\", GRNAME);\n Tgraph_construct.start();\n\n if (readFromFile) {\n galois::gPrint(\"[\", base_DistGraph::id,\n \"] Reading local graph from file \", localGraphFileName,\n \"\\n\");\n base_DistGraph::read_local_graph_from_file(localGraphFileName);\n Tgraph_construct.stop();\n return;\n }\n\n galois::graphs::OfflineGraph g(filename);\n base_DistGraph::numGlobalNodes = g.size();\n base_DistGraph::numGlobalEdges = g.sizeEdges();\n std::vector dummy;\n // not actually getting masters, but getting assigned readers for nodes\n if (masterBlockFile == \"\") {\n base_DistGraph::computeMasters(md, g, dummy, nodeWeight, edgeWeight);\n } else {\n galois::gInfo(\"Getting reader assignment from file\");\n base_DistGraph::readersFromFile(g, masterBlockFile);\n }\n\n graphPartitioner = std::make_unique(\n host, _numHosts, base_DistGraph::numGlobalNodes,\n base_DistGraph::numGlobalEdges);\n // TODO abstract this away somehow\n graphPartitioner->saveGIDToHost(base_DistGraph::gid2host);\n\n uint64_t nodeBegin = base_DistGraph::gid2host[base_DistGraph::id].first;\n typename galois::graphs::OfflineGraph::edge_iterator edgeBegin =\n g.edge_begin(nodeBegin);\n uint64_t nodeEnd = base_DistGraph::gid2host[base_DistGraph::id].second;\n typename galois::graphs::OfflineGraph::edge_iterator edgeEnd =\n g.edge_begin(nodeEnd);\n\n // signifies how many outgoing edges a particular host should expect from\n // this host\n std::vector> numOutgoingEdges;\n // signifies if a host should create a node because it has an incoming edge\n std::vector hasIncomingEdge;\n\n // only need to use for things that need communication\n if (!graphPartitioner->noCommunication()) {\n if (_edgeStateRounds > 1) {\n hostLoads.resize(base_DistGraph::numHosts);\n old_hostLoads.resize(base_DistGraph::numHosts);\n resetEdgeLoad();\n }\n numOutgoingEdges.resize(base_DistGraph::numHosts);\n hasIncomingEdge.resize(base_DistGraph::numHosts);\n }\n\n // phase 0\n\n galois::gPrint(\"[\", base_DistGraph::id, \"] Starting graph reading.\\n\");\n galois::graphs::BufferedGraph bufGraph;\n bufGraph.resetReadCounters();\n galois::StatTimer graphReadTimer(\"GraphReading\", GRNAME);\n graphReadTimer.start();\n bufGraph.loadPartialGraph(filename, nodeBegin, nodeEnd, *edgeBegin,\n *edgeEnd, base_DistGraph::numGlobalNodes,\n base_DistGraph::numGlobalEdges);\n graphReadTimer.stop();\n galois::gPrint(\"[\", base_DistGraph::id, \"] Reading graph complete.\\n\");\n\n if (graphPartitioner->masterAssignPhase()) {\n // loop over all nodes, determine where neighbors are, assign masters\n galois::StatTimer phase0Timer(\"Phase0\", GRNAME);\n galois::gPrint(\"[\", base_DistGraph::id,\n \"] Starting master assignment.\\n\");\n phase0Timer.start();\n phase0(bufGraph, cuspAsync, stateRounds);\n phase0Timer.stop();\n galois::gPrint(\"[\", base_DistGraph::id,\n \"] Master assignment complete.\\n\");\n }\n\n galois::StatTimer inspectionTimer(\"EdgeInspection\", GRNAME);\n inspectionTimer.start();\n bufGraph.resetReadCounters();\n galois::gstl::Vector prefixSumOfEdges;\n\n // assign edges to other nodes\n if (!graphPartitioner->noCommunication()) {\n edgeInspection(bufGraph, numOutgoingEdges, hasIncomingEdge,\n inspectionTimer);\n galois::DynamicBitSet& finalIncoming =\n hasIncomingEdge[base_DistGraph::id];\n\n galois::StatTimer mapTimer(\"NodeMapping\", GRNAME);\n mapTimer.start();\n nodeMapping(numOutgoingEdges, finalIncoming, prefixSumOfEdges);\n mapTimer.stop();\n\n finalIncoming.resize(0);\n } else {\n base_DistGraph::numOwned = nodeEnd - nodeBegin;\n uint64_t edgeOffset = *bufGraph.edgeBegin(nodeBegin);\n // edge prefix sum, no comm required\n edgeCutInspection(bufGraph, inspectionTimer, edgeOffset,\n prefixSumOfEdges);\n }\n // inspection timer is stopped in edgeInspection function\n\n // flip partitioners that have a master assignment phase to stage 2\n // (meaning all nodes and masters that will be on this host are present in\n // the partitioner's metadata)\n if (graphPartitioner->masterAssignPhase()) {\n graphPartitioner->enterStage2();\n }\n\n // get memory back from inspection metadata\n numOutgoingEdges.clear();\n hasIncomingEdge.clear();\n // doubly make sure the data is cleared\n freeVector(numOutgoingEdges); // should no longer use this variable\n freeVector(hasIncomingEdge); // should no longer use this variable\n\n // Graph construction related calls\n\n base_DistGraph::beginMaster = 0;\n // Allocate and construct the graph\n base_DistGraph::graph.allocateFrom(base_DistGraph::numNodes,\n base_DistGraph::numEdges);\n base_DistGraph::graph.constructNodes();\n\n // edge end fixing\n auto& base_graph = base_DistGraph::graph;\n galois::do_all(\n galois::iterate((uint32_t)0, base_DistGraph::numNodes),\n [&](uint64_t n) { base_graph.fixEndEdge(n, prefixSumOfEdges[n]); },\n#if MORE_DIST_STATS\n galois::loopname(\"FixEndEdgeLoop\"),\n#endif\n galois::no_stats());\n // get memory from prefix sum back\n prefixSumOfEdges.clear();\n freeVector(prefixSumOfEdges); // should no longer use this variable\n galois::CondStatTimer TfillMirrors(\"FillMirrors\", GRNAME);\n\n TfillMirrors.start();\n fillMirrors();\n TfillMirrors.stop();\n\n if (_edgeStateRounds > 1) {\n // reset edge load since we need exact same answers again\n resetEdgeLoad();\n }\n\n // Edge loading\n if (!graphPartitioner->noCommunication()) {\n loadEdges(base_DistGraph::graph, bufGraph);\n } else {\n // Edge cut construction\n edgeCutLoad(base_DistGraph::graph, bufGraph);\n bufGraph.resetAndFree();\n }\n\n // Finalization\n\n // TODO this is a hack; fix it somehow\n // if vertex cut but not a cart cut is the condition\n if (graphPartitioner->isVertexCut() &&\n graphPartitioner->cartesianGrid().first == 0) {\n base_DistGraph::numNodesWithEdges = base_DistGraph::numNodes;\n }\n\n if (transpose) {\n base_DistGraph::transposed = true;\n base_DistGraph::numNodesWithEdges = base_DistGraph::numNodes;\n if (base_DistGraph::numNodes > 0) {\n // consider all nodes to have outgoing edges (TODO better way to do\n // this?) for now it's fine I guess\n base_DistGraph::graph.transpose(GRNAME);\n }\n }\n\n galois::CondStatTimer Tthread_ranges(\"ThreadRangesTime\",\n GRNAME);\n\n Tthread_ranges.start();\n base_DistGraph::determineThreadRanges();\n Tthread_ranges.stop();\n\n base_DistGraph::determineThreadRangesMaster();\n base_DistGraph::determineThreadRangesWithEdges();\n base_DistGraph::initializeSpecificRanges();\n\n Tgraph_construct.stop();\n galois::gPrint(\"[\", base_DistGraph::id, \"] Graph construction complete.\\n\");\n\n // report state rounds\n if (base_DistGraph::id == 0) {\n galois::runtime::reportStat_Single(GRNAME, \"CuSPStateRounds\",\n (uint32_t)stateRounds);\n }\n }\n\nprivate:\n galois::runtime::SpecificRange>\n getSpecificThreadRange(galois::graphs::BufferedGraph& bufGraph,\n std::vector& assignedThreadRanges,\n uint64_t startNode, uint64_t endNode) {\n galois::StatTimer threadRangeTime(\"Phase0ThreadRangeTime\");\n threadRangeTime.start();\n uint64_t numLocalNodes = endNode - startNode;\n galois::PODResizeableArray edgePrefixSum;\n edgePrefixSum.resize(numLocalNodes);\n\n // get thread ranges with a prefix sum\n galois::do_all(\n galois::iterate(startNode, endNode),\n [&](unsigned n) {\n uint64_t offset = n - startNode;\n edgePrefixSum[offset] = bufGraph.edgeEnd(n) - bufGraph.edgeBegin(n);\n },\n galois::no_stats());\n\n for (unsigned i = 1; i < numLocalNodes; i++) {\n edgePrefixSum[i] += edgePrefixSum[i - 1];\n }\n\n assignedThreadRanges = galois::graphs::determineUnitRangesFromPrefixSum(\n galois::runtime::activeThreads, edgePrefixSum);\n\n for (unsigned i = 0; i < galois::runtime::activeThreads + 1; i++) {\n assignedThreadRanges[i] += startNode;\n }\n\n auto toReturn = galois::runtime::makeSpecificRange(\n boost::counting_iterator(startNode),\n boost::counting_iterator(startNode + numLocalNodes),\n assignedThreadRanges.data());\n\n threadRangeTime.stop();\n return toReturn;\n }\n\n /**\n * For each other host, determine which nodes that this host needs to get\n * info from\n *\n * @param bufGraph Buffered graph used to loop over edges\n * @param ghosts bitset; at end\n * of execution, marked bits signify neighbors on this host that that other\n * host has read (and therefore must sync with me)\n */\n // steps 1 and 2 of neighbor location setup: memory allocation, bitset setting\n void phase0BitsetSetup(galois::graphs::BufferedGraph& bufGraph,\n galois::DynamicBitSet& ghosts) {\n galois::StatTimer bitsetSetupTimer(\"Phase0BitsetSetup\", GRNAME);\n bitsetSetupTimer.start();\n\n ghosts.resize(bufGraph.size());\n ghosts.reset();\n\n std::vector rangeVector;\n auto start = base_DistGraph::gid2host[base_DistGraph::id].first;\n auto end = base_DistGraph::gid2host[base_DistGraph::id].second;\n\n galois::runtime::SpecificRange> work =\n getSpecificThreadRange(bufGraph, rangeVector, start, end);\n\n // Step 2: loop over all local nodes, determine neighbor locations\n galois::do_all(\n galois::iterate(work),\n // galois::iterate(base_DistGraph::gid2host[base_DistGraph::id].first,\n // base_DistGraph::gid2host[base_DistGraph::id].second),\n [&](unsigned n) {\n // ptt.start();\n // galois::gPrint(\"[\", base_DistGraph::id, \" \",\n // galois::substrate::getThreadPool().getTID(), \"] \", n, \"\\n\");\n auto ii = bufGraph.edgeBegin(n);\n auto ee = bufGraph.edgeEnd(n);\n for (; ii < ee; ++ii) {\n uint32_t dst = bufGraph.edgeDestination(*ii);\n if ((dst < start) || (dst >= end)) { // not owned by this host\n // set on bitset\n ghosts.set(dst);\n }\n }\n // ptt.stop();\n },\n galois::loopname(\"Phase0BitsetSetup_DetermineNeighborLocations\"),\n galois::steal(), galois::no_stats());\n\n bitsetSetupTimer.stop();\n }\n\n // sets up the gid to lid mapping for phase 0\n /**\n * Set up the GID to LID mapping for phase 0: In the mapping vector,\n * read nodes occupy the first chunk, and nodes read by other hosts follow.\n *\n * @param ghosts\n * @param gid2offsets mapping vector: element at an offset corresponds to a\n * particular GID (and its master)\n * @param syncNodes one vector of nodes for each host: at the end of\n * execution, will contain mirrors on this host whose master is on that host\n * @returns Number of set bits\n */\n uint64_t phase0MapSetup(\n galois::DynamicBitSet& ghosts,\n std::unordered_map& gid2offsets,\n galois::gstl::Vector>& syncNodes) {\n galois::StatTimer mapSetupTimer(\"Phase0MapSetup\", GRNAME);\n mapSetupTimer.start();\n\n uint32_t numLocal = base_DistGraph::gid2host[base_DistGraph::id].second -\n base_DistGraph::gid2host[base_DistGraph::id].first;\n uint32_t lid = numLocal;\n\n uint64_t numToReserve = ghosts.count();\n gid2offsets.reserve(numToReserve);\n\n // TODO: parallelize using prefix sum?\n for (unsigned h = 0; h < base_DistGraph::numHosts; ++h) {\n if (h == base_DistGraph::id)\n continue;\n auto start = base_DistGraph::gid2host[h].first;\n auto end = base_DistGraph::gid2host[h].second;\n for (uint64_t gid = start; gid < end; ++gid) {\n if (ghosts.test(gid)) {\n gid2offsets[gid] = lid;\n syncNodes[h].push_back(gid - start);\n lid++;\n }\n }\n galois::gDebug(\"[\", base_DistGraph::id, \" -> \", h, \"] bitset size \",\n (end - start) / 64, \" vs. vector size \",\n syncNodes[h].size() / 2);\n }\n lid -= numLocal;\n\n assert(lid == numToReserve);\n galois::gDebug(\"[\", base_DistGraph::id, \"] total bitset size \",\n (ghosts.size() - numLocal) / 64, \" vs. total vector size \",\n numToReserve / 2);\n\n // TODO: should not be used after this - refactor to make this clean\n ghosts.resize(0);\n\n mapSetupTimer.stop();\n\n return lid;\n }\n\n // steps 4 and 5 of neighbor location setup\n /**\n * Let other hosts know which nodes they need to send to me by giving them\n * the bitset marked with nodes I am interested in on the other host.\n *\n * @param syncNodes one vector of nodes for each host: at the begin of\n * execution, will contain mirrors on this host whose master is on that host;\n * at the end of execution, will contain masters on this host whose mirror\n * is on that host\n */\n void phase0SendRecv(\n galois::gstl::Vector>& syncNodes) {\n auto& net = galois::runtime::getSystemNetworkInterface();\n galois::StatTimer p0BitsetCommTimer(\"Phase0SendRecvBitsets\", GRNAME);\n p0BitsetCommTimer.start();\n uint64_t bytesSent = 0;\n\n // Step 4: send bitset to other hosts\n for (unsigned h = 0; h < base_DistGraph::numHosts; h++) {\n galois::runtime::SendBuffer bitsetBuffer;\n\n if (h != base_DistGraph::id) {\n galois::runtime::gSerialize(bitsetBuffer, syncNodes[h]);\n bytesSent += bitsetBuffer.size();\n net.sendTagged(h, galois::runtime::evilPhase, bitsetBuffer);\n }\n }\n\n // Step 5: recv bitset to other hosts; this indicates which local nodes each\n // other host needs to be informed of updates of\n for (unsigned h = 0; h < net.Num - 1; h++) {\n decltype(net.recieveTagged(galois::runtime::evilPhase, nullptr)) p;\n do {\n p = net.recieveTagged(galois::runtime::evilPhase, nullptr);\n } while (!p);\n uint32_t sendingHost = p->first;\n // deserialize into neighbor bitsets\n galois::runtime::gDeserialize(p->second, syncNodes[sendingHost]);\n }\n\n p0BitsetCommTimer.stop();\n\n galois::runtime::reportStat_Tsum(\n GRNAME, std::string(\"Phase0SendRecvBitsetsBytesSent\"), bytesSent);\n\n // comm phase complete\n base_DistGraph::increment_evilPhase();\n }\n\n /**\n * Given a set of loads in a vector and the accumulation to those loads,\n * synchronize them across hosts and do the accumulation into the vector\n * of loads.\n *\n * @param loads Vector of loads to accumulate to\n * @param accums Vector of accuulations to loads that occured since last\n * sync\n */\n void syncLoad(std::vector& loads,\n std::vector>& accums) {\n assert(loads.size() == accums.size());\n // use DG accumulator to force barrier on all hosts to sync this data\n galois::DGAccumulator syncer;\n // sync accum for each host one by one\n for (unsigned i = 0; i < loads.size(); i++) {\n syncer.reset();\n syncer += (accums[i].load());\n accums[i].store(0);\n uint64_t accumulation = syncer.reduce();\n loads[i] += accumulation;\n }\n }\n\n /**\n * Given a copyable atomic vector, get data from it, save to a\n * PODResizeableArray, and reset value in the atomic array.\n *\n * @param atomic Atomic vector to extract and reset\n * @param nonAtomic PODarray to extract data into\n */\n template \n void\n extractAtomicToPODArray(std::vector>& atomic,\n galois::PODResizeableArray& nonAtomic) {\n nonAtomic.resize(atomic.size());\n\n galois::do_all(\n galois::iterate((size_t)0, atomic.size()),\n [&](size_t i) {\n nonAtomic[i] = atomic[i].load();\n atomic[i].store(0);\n },\n galois::no_stats());\n }\n\n /**\n * Send newly accumulated node and edge loads to all other hosts and reset\n * the accumulated values. No DG accmulator used.\n *\n * @param nodeAccum new node accumulation for each host in system\n * @param edgeAccum new edge accumulation for each host in system\n */\n void asyncSendLoad(galois::PODResizeableArray& nodeAccum,\n galois::PODResizeableArray& edgeAccum) {\n auto& net = galois::runtime::getSystemNetworkInterface();\n\n unsigned bytesSent = 0;\n galois::StatTimer sendTimer(\"Phase0AsyncSendLoadTime\", GRNAME);\n\n sendTimer.start();\n for (unsigned h = 0; h < base_DistGraph::numHosts; h++) {\n if (h != base_DistGraph::id) {\n // serialize node and edge accumulations with tag 4 (to avoid\n // conflict with other tags being used) and send\n galois::runtime::SendBuffer b;\n\n galois::runtime::gSerialize(b, 4);\n galois::runtime::gSerialize(b, nodeAccum);\n galois::runtime::gSerialize(b, edgeAccum);\n bytesSent += b.size();\n\n // note the +1 on evil phase; load messages send using a different\n // phase to avoid conflicts\n net.sendTagged(h, base_DistGraph::evilPhasePlus1(), b);\n }\n }\n sendTimer.stop();\n\n galois::runtime::reportStat_Tsum(GRNAME, \"Phase0AsyncSendLoadBytesSent\",\n bytesSent);\n }\n\n /**\n * Receive (if it exists) new node/edge loads from other hosts and add it to\n * our own loads.\n *\n * @param nodeLoads current node load information for each host in system\n * @param edgeLoads current edge load information for each host in system\n */\n void asyncRecvLoad(std::vector& nodeLoads,\n std::vector& edgeLoads,\n galois::DynamicBitSet& loadsClear) {\n auto& net = galois::runtime::getSystemNetworkInterface();\n decltype(net.recieveTagged(base_DistGraph::evilPhasePlus1(), nullptr)) p;\n\n galois::StatTimer recvTimer(\"Phase0AsyncRecvLoadTime\", GRNAME);\n recvTimer.start();\n do {\n // note the +1\n p = net.recieveTagged(base_DistGraph::evilPhasePlus1(), nullptr);\n\n if (p) {\n unsigned messageType = (unsigned)-1;\n // deserialize message type\n galois::runtime::gDeserialize(p->second, messageType);\n\n if (messageType == 4) {\n galois::PODResizeableArray recvNodeAccum;\n galois::PODResizeableArray recvEdgeAccum;\n // loads to add\n galois::runtime::gDeserialize(p->second, recvNodeAccum);\n galois::runtime::gDeserialize(p->second, recvEdgeAccum);\n\n assert(recvNodeAccum.size() == recvEdgeAccum.size());\n assert(recvNodeAccum.size() == nodeLoads.size());\n assert(recvEdgeAccum.size() == edgeLoads.size());\n\n galois::do_all(\n galois::iterate((size_t)0, recvNodeAccum.size()),\n [&](size_t i) {\n nodeLoads[i] += recvNodeAccum[i];\n edgeLoads[i] += recvEdgeAccum[i];\n },\n galois::no_stats());\n } else if (messageType == 3) {\n // all clear message from host\n uint32_t sendingHost = p->first;\n assert(!loadsClear.test(sendingHost));\n loadsClear.set(sendingHost);\n } else {\n GALOIS_DIE(\"unexpected message type in async load synchronization: \",\n messageType);\n }\n }\n } while (p);\n\n recvTimer.stop();\n }\n\n /**\n * Send out accumulated loads from a round of node assignments to all other\n * hosts and also receive loads from other hosts if they exist\n * (non-blocking).\n *\n * @param nodeLoads current known node loads on this host\n * @param nodeAccum newly accumulated node loads from a prior round of node\n * assignments\n * @param edgeLoads current known edge loads on this host\n * @param edgeAccum newly accumulated edge loads from a prior round of node\n * assignments\n * @param loadsClear Bitset tracking if we have received all loads from\n * a particular host\n */\n void asyncSyncLoad(std::vector& nodeLoads,\n std::vector>& nodeAccum,\n std::vector& edgeLoads,\n std::vector>& edgeAccum,\n galois::DynamicBitSet& loadsClear) {\n assert(nodeLoads.size() == base_DistGraph::numHosts);\n assert(nodeAccum.size() == base_DistGraph::numHosts);\n assert(edgeLoads.size() == base_DistGraph::numHosts);\n assert(edgeAccum.size() == base_DistGraph::numHosts);\n\n galois::StatTimer syncTimer(\"Phase0AsyncSyncLoadTime\", GRNAME);\n syncTimer.start();\n\n // extract out data to send\n galois::PODResizeableArray nonAtomicNodeAccum;\n galois::PODResizeableArray nonAtomicEdgeAccum;\n extractAtomicToPODArray(nodeAccum, nonAtomicNodeAccum);\n extractAtomicToPODArray(edgeAccum, nonAtomicEdgeAccum);\n\n assert(nonAtomicNodeAccum.size() == base_DistGraph::numHosts);\n assert(nonAtomicEdgeAccum.size() == base_DistGraph::numHosts);\n\n // apply loads to self\n galois::do_all(\n galois::iterate((uint32_t)0, base_DistGraph::numHosts),\n [&](size_t i) {\n nodeLoads[i] += nonAtomicNodeAccum[i];\n edgeLoads[i] += nonAtomicEdgeAccum[i];\n },\n galois::no_stats());\n\n#ifndef NDEBUG\n for (unsigned i = 0; i < nodeAccum.size(); i++) {\n assert(nodeAccum[i].load() == 0);\n assert(edgeAccum[i].load() == 0);\n }\n#endif\n\n // send both nodes and edges accumulation at once\n asyncSendLoad(nonAtomicNodeAccum, nonAtomicEdgeAccum);\n asyncRecvLoad(nodeLoads, edgeLoads, loadsClear);\n\n syncTimer.stop();\n }\n\n /**\n * Debug function: simply prints loads and accumulations\n *\n * @param loads Vector of loads to accumulate to\n * @param accums Vector of accuulations to loads that occured since last\n * sync\n */\n void printLoad(std::vector& loads,\n std::vector>& accums) {\n assert(loads.size() == accums.size());\n for (unsigned i = 0; i < loads.size(); i++) {\n galois::gDebug(\"[\", base_DistGraph::id, \"] \", i, \" total \", loads[i],\n \" accum \", accums[i].load());\n }\n }\n\n /**\n * Given a vector of data and a bitset specifying which elements in the data\n * vector need to be extracted, extract the appropriate elements into\n * a vector.\n *\n * @param offsets Bitset specifying which elements in the data vector need\n * to be extracted.\n * @param dataVector Data vector to extract data from according to the bitset\n * @return Vector of extracted elements\n */\n template \n std::vector getDataFromOffsets(std::vector& offsetVector,\n const std::vector& dataVector) {\n std::vector toReturn;\n toReturn.resize(offsetVector.size());\n\n galois::do_all(\n galois::iterate((size_t)0, offsetVector.size()),\n [&](unsigned i) { toReturn[i] = dataVector[offsetVector[i]]; },\n galois::no_stats());\n\n return toReturn;\n }\n\n /**\n * Given a host, a bitset that marks offsets, and a vector,\n * send the data located at the offsets from the vector to the\n * specified host. If bitset is unmarked, send a no-op.\n *\n * @param targetHost Host to send data to\n * @param toSync Bitset that specifies which offsets in the data vector\n * to send\n * @param dataVector Data to be sent to the target host\n */\n void sendOffsets(unsigned targetHost, galois::DynamicBitSet& toSync,\n std::vector& dataVector,\n std::string timerName = std::string()) {\n auto& net = galois::runtime::getSystemNetworkInterface();\n std::string statString = std::string(\"Phase0SendOffsets_\") + timerName;\n uint64_t bytesSent = 0;\n\n galois::StatTimer sendOffsetsTimer(statString.c_str(), GRNAME);\n\n sendOffsetsTimer.start();\n\n // this means there are updates to send\n if (toSync.count()) {\n std::vector offsetVector = toSync.getOffsets();\n // get masters to send into a vector\n std::vector mastersToSend =\n getDataFromOffsets(offsetVector, dataVector);\n\n assert(mastersToSend.size());\n\n size_t num_selected = toSync.count();\n size_t num_total = toSync.size();\n // figure out how to send (most efficient method; either bitset\n // and data or offsets + data)\n size_t bitset_alloc_size =\n ((num_total + 63) / 64) * sizeof(uint64_t) + (2 * sizeof(size_t));\n size_t bitsetDataSize = (num_selected * sizeof(uint32_t)) +\n bitset_alloc_size + sizeof(num_selected);\n size_t offsetsDataSize = (num_selected * sizeof(uint32_t)) +\n (num_selected * sizeof(unsigned int)) +\n sizeof(uint32_t) + sizeof(num_selected);\n\n galois::runtime::SendBuffer b;\n // tag with send method and do send\n if (bitsetDataSize < offsetsDataSize) {\n // send bitset, tag 1\n galois::runtime::gSerialize(b, 1u);\n galois::runtime::gSerialize(b, toSync);\n galois::runtime::gSerialize(b, mastersToSend);\n } else {\n // send offsets, tag 2\n galois::runtime::gSerialize(b, 2u);\n galois::runtime::gSerialize(b, offsetVector);\n galois::runtime::gSerialize(b, mastersToSend);\n }\n bytesSent += b.size();\n net.sendTagged(targetHost, galois::runtime::evilPhase, b);\n } else {\n // send empty no-op message, tag 0\n galois::runtime::SendBuffer b;\n galois::runtime::gSerialize(b, 0u);\n bytesSent += b.size();\n net.sendTagged(targetHost, galois::runtime::evilPhase, b);\n }\n sendOffsetsTimer.stop();\n\n galois::runtime::reportStat_Tsum(GRNAME, statString + \"BytesSent\",\n bytesSent);\n }\n\n /**\n * Send new master assignment updates to other hosts based on syncNodes\n * for each host prepared in advance.\n *\n * @param begin to end: which nodes on this host have been updated\n * @param numLocalNodes: number of owned nodes\n * @param localNodeToMaster Vector map: an offset corresponds to a particular\n * GID; indicates masters of GIDs\n * @param syncNodes one vector of nodes for each host: contains mirrors on\n * this host whose master is on that host\n */\n void syncAssignmentSends(\n uint32_t begin, uint32_t end, uint32_t numLocalNodes,\n std::vector& localNodeToMaster,\n galois::gstl::Vector>& syncNodes) {\n galois::StatTimer p0assignSendTime(\"Phase0AssignmentSendTime\", GRNAME);\n p0assignSendTime.start();\n\n galois::DynamicBitSet toSync;\n toSync.resize(numLocalNodes);\n\n // send loop\n for (unsigned h = 0; h < base_DistGraph::numHosts; h++) {\n if (h != base_DistGraph::id) {\n toSync.reset();\n // send if in [start,end) and present in syncNodes[h]\n galois::do_all(\n galois::iterate(syncNodes[h]),\n [&](uint32_t lid) {\n if ((lid >= begin) && (lid < end)) {\n toSync.set(lid);\n }\n },\n galois::no_stats());\n // do actual send based on sync bitset\n sendOffsets(h, toSync, localNodeToMaster, \"NewAssignments\");\n }\n }\n\n p0assignSendTime.stop();\n }\n\n /**\n * Send message to all hosts saying we're done with assignments. Can\n * specify a phase to distinguish between all clears for assignments\n * and loads\n */\n void sendAllClears(unsigned phase = 0) {\n unsigned bytesSent = 0;\n auto& net = galois::runtime::getSystemNetworkInterface();\n galois::StatTimer allClearTimer(\"Phase0SendAllClearTime\", GRNAME);\n allClearTimer.start();\n\n // send loop\n for (unsigned h = 0; h < base_DistGraph::numHosts; h++) {\n if (h != base_DistGraph::id) {\n galois::runtime::SendBuffer b;\n galois::runtime::gSerialize(b, 3u);\n bytesSent += b.size();\n // assumes phase is 0 or 1\n if (phase == 1) {\n net.sendTagged(h, base_DistGraph::evilPhasePlus1(), b);\n } else if (phase == 0) {\n net.sendTagged(h, galois::runtime::evilPhase, b);\n } else {\n GALOIS_DIE(\"unexpected phase: \", phase);\n }\n }\n }\n allClearTimer.stop();\n\n galois::runtime::reportStat_Tsum(GRNAME, \"Phase0SendAllClearBytesSent\",\n bytesSent);\n }\n\n void saveReceivedMappings(std::vector& localNodeToMaster,\n std::unordered_map& gid2offsets,\n unsigned sendingHost,\n std::vector& receivedOffsets,\n std::vector& receivedMasters) {\n uint64_t hostOffset = base_DistGraph::gid2host[sendingHost].first;\n galois::gDebug(\"[\", base_DistGraph::id, \"] host \", sendingHost, \" offset \",\n hostOffset);\n\n // if execution gets here, messageType was 1 or 2\n assert(receivedMasters.size() == receivedOffsets.size());\n\n galois::do_all(\n galois::iterate((size_t)0, receivedMasters.size()),\n [&](size_t i) {\n uint64_t curGID = hostOffset + receivedOffsets[i];\n uint32_t indexIntoMap = gid2offsets[curGID];\n galois::gDebug(\"[\", base_DistGraph::id, \"] gid \", curGID, \" offset \",\n indexIntoMap);\n localNodeToMaster[indexIntoMap] = receivedMasters[i];\n },\n galois::no_stats());\n }\n\n /**\n * Receive offsets and masters into the provided vectors and return sending\n * host and the message type.\n *\n * @param receivedOffsets vector to receive offsets into\n * @param receivedMasters vector to receive masters mappings into\n * @returns sending host and message type of received data\n */\n std::pair\n recvOffsetsAndMasters(std::vector& receivedOffsets,\n std::vector& receivedMasters) {\n auto& net = galois::runtime::getSystemNetworkInterface();\n\n decltype(net.recieveTagged(galois::runtime::evilPhase, nullptr)) p;\n do {\n p = net.recieveTagged(galois::runtime::evilPhase, nullptr);\n } while (!p);\n\n uint32_t sendingHost = p->first;\n unsigned messageType = (unsigned)-1;\n\n // deserialize message type\n galois::runtime::gDeserialize(p->second, messageType);\n\n if (messageType == 1) {\n // bitset; deserialize, then get offsets\n galois::DynamicBitSet receivedSet;\n galois::runtime::gDeserialize(p->second, receivedSet);\n receivedOffsets = receivedSet.getOffsets();\n galois::runtime::gDeserialize(p->second, receivedMasters);\n } else if (messageType == 2) {\n // offsets\n galois::runtime::gDeserialize(p->second, receivedOffsets);\n galois::runtime::gDeserialize(p->second, receivedMasters);\n } else if (messageType != 0) {\n GALOIS_DIE(\"invalid message type for sync of master assignments: \",\n messageType);\n }\n\n galois::gDebug(\"[\", base_DistGraph::id, \"] host \", sendingHost,\n \" send message type \", messageType);\n\n return std::make_pair(sendingHost, messageType);\n }\n\n /**\n * Receive offsets and masters into the provided vectors and return sending\n * host and the message type, async (i.e. does not have to receive anything\n * to exit function.\n *\n * @param receivedOffsets vector to receive offsets into\n * @param receivedMasters vector to receive masters mappings into\n */\n void recvOffsetsAndMastersAsync(\n std::vector& localNodeToMaster,\n std::unordered_map& gid2offsets,\n galois::DynamicBitSet& hostFinished) {\n auto& net = galois::runtime::getSystemNetworkInterface();\n decltype(net.recieveTagged(galois::runtime::evilPhase, nullptr)) p;\n\n // repeat loop until no message\n do {\n p = net.recieveTagged(galois::runtime::evilPhase, nullptr);\n if (p) {\n uint32_t sendingHost = p->first;\n unsigned messageType = (unsigned)-1;\n\n std::vector receivedOffsets;\n std::vector receivedMasters;\n\n // deserialize message type\n galois::runtime::gDeserialize(p->second, messageType);\n\n if (messageType == 1) {\n // bitset; deserialize, then get offsets\n galois::DynamicBitSet receivedSet;\n galois::runtime::gDeserialize(p->second, receivedSet);\n receivedOffsets = receivedSet.getOffsets();\n galois::runtime::gDeserialize(p->second, receivedMasters);\n saveReceivedMappings(localNodeToMaster, gid2offsets, sendingHost,\n receivedOffsets, receivedMasters);\n } else if (messageType == 2) {\n // offsets\n galois::runtime::gDeserialize(p->second, receivedOffsets);\n galois::runtime::gDeserialize(p->second, receivedMasters);\n saveReceivedMappings(localNodeToMaster, gid2offsets, sendingHost,\n receivedOffsets, receivedMasters);\n } else if (messageType == 3) {\n // host indicating that it is done with all assignments from its\n // end; mark as such in bitset\n assert(!hostFinished.test(sendingHost));\n hostFinished.set(sendingHost);\n } else if (messageType != 0) {\n GALOIS_DIE(\"invalid message type for sync of master assignments: \",\n messageType);\n }\n\n galois::gDebug(\"[\", base_DistGraph::id, \"] host \", sendingHost,\n \" send message type \", messageType);\n }\n } while (p);\n }\n\n /**\n * Receive new master assignment updates from other hosts and update local\n * mappings.\n *\n * @param localNodeToMaster Vector map: an offset corresponds to a particular\n * GID; indicates masters of GIDs\n * @param gid2offsets Map of GIDs to the offset into the vector map that\n * corresponds to it\n */\n void\n syncAssignmentReceives(std::vector& localNodeToMaster,\n std::unordered_map& gid2offsets) {\n galois::StatTimer p0assignReceiveTime(\"Phase0AssignmentReceiveTime\",\n GRNAME);\n p0assignReceiveTime.start();\n\n // receive loop\n for (unsigned h = 0; h < base_DistGraph::numHosts - 1; h++) {\n unsigned sendingHost;\n unsigned messageType;\n std::vector receivedOffsets;\n std::vector receivedMasters;\n\n std::tie(sendingHost, messageType) =\n recvOffsetsAndMasters(receivedOffsets, receivedMasters);\n\n if (messageType == 1 || messageType == 2) {\n saveReceivedMappings(localNodeToMaster, gid2offsets, sendingHost,\n receivedOffsets, receivedMasters);\n }\n }\n\n p0assignReceiveTime.stop();\n }\n\n void syncAssignmentReceivesAsync(\n std::vector& localNodeToMaster,\n std::unordered_map& gid2offsets,\n galois::DynamicBitSet& hostFinished) {\n galois::StatTimer p0assignReceiveTime(\"Phase0AssignmentReceiveTimeAsync\",\n GRNAME);\n p0assignReceiveTime.start();\n\n recvOffsetsAndMastersAsync(localNodeToMaster, gid2offsets, hostFinished);\n\n p0assignReceiveTime.stop();\n }\n\n /**\n * Send/receive new master assignment updates to other hosts.\n *\n * @param begin to end: which nodes on this host have been updated\n * @param numLocalNodes: number of owned nodes\n * @param localNodeToMaster Vector map: an offset corresponds to a particular\n * GID; indicates masters of GIDs\n * @param syncNodes one vector of nodes for each host: contains mirrors on\n * this host whose master is on that host\n * @param gid2offsets Map of GIDs to the offset into the vector map that\n * corresponds to it\n */\n void syncAssignment(\n uint32_t begin, uint32_t end, uint32_t numLocalNodes,\n std::vector& localNodeToMaster,\n galois::gstl::Vector>& syncNodes,\n std::unordered_map& gid2offsets) {\n galois::StatTimer syncAssignmentTimer(\"Phase0SyncAssignmentTime\", GRNAME);\n syncAssignmentTimer.start();\n\n syncAssignmentSends(begin, end, numLocalNodes, localNodeToMaster,\n syncNodes);\n syncAssignmentReceives(localNodeToMaster, gid2offsets);\n\n syncAssignmentTimer.stop();\n }\n\n void syncAssignmentAsync(\n uint32_t begin, uint32_t end, uint32_t numLocalNodes,\n std::vector& localNodeToMaster,\n galois::gstl::Vector>& syncNodes,\n std::unordered_map& gid2offsets,\n galois::DynamicBitSet& hostFinished) {\n galois::StatTimer syncAssignmentTimer(\"Phase0SyncAssignmentAsyncTime\",\n GRNAME);\n syncAssignmentTimer.start();\n\n syncAssignmentSends(begin, end, numLocalNodes, localNodeToMaster,\n syncNodes);\n syncAssignmentReceivesAsync(localNodeToMaster, gid2offsets, hostFinished);\n\n syncAssignmentTimer.stop();\n }\n\n /**\n * Send masters mappings that were read on this host to their appropirate\n * owners\n *\n * @param localNodeToMaster local id to master mapping map\n * @param ghosts bitsets specifying which hosts have which neighbors\n * that this host has read\n */\n void sendMastersToOwners(\n std::vector& localNodeToMaster,\n galois::gstl::Vector>& syncNodes) {\n uint32_t begin = base_DistGraph::gid2host[base_DistGraph::id].first;\n uint32_t end = base_DistGraph::gid2host[base_DistGraph::id].second;\n // for each host, determine which master assignments still need to be sent\n // (if a host is a master of a node, but that node is not present as a\n // neighbor on the host, then this host needs to send the master assignment)\n galois::DynamicBitSet toSend;\n toSend.resize(end - begin);\n\n for (unsigned h = 0; h < base_DistGraph::numHosts; ++h) {\n if (h != base_DistGraph::id) {\n toSend.reset();\n // send if present in localNodeToMaster but not present in syncNodes\n galois::do_all(\n galois::iterate((uint32_t)0, end - begin),\n [&](uint32_t lid) {\n if (localNodeToMaster[lid] == h) {\n toSend.set(lid);\n }\n },\n galois::no_stats());\n galois::do_all(\n galois::iterate(syncNodes[h]),\n [&](uint32_t lid) { toSend.reset(lid); }, galois::no_stats());\n\n sendOffsets(h, toSend, localNodeToMaster, \"MastersToOwners\");\n }\n }\n }\n\n /**\n * Receive master mapping messages from hosts and add it to the graph\n * partitioner's map.\n */\n void recvMastersToOwners() {\n for (unsigned h = 0; h < base_DistGraph::numHosts - 1; h++) {\n unsigned sendingHost;\n unsigned messageType;\n std::vector receivedOffsets;\n std::vector receivedMasters;\n\n std::tie(sendingHost, messageType) =\n recvOffsetsAndMasters(receivedOffsets, receivedMasters);\n\n if (messageType == 1 || messageType == 2) {\n assert(receivedMasters.size() == receivedOffsets.size());\n uint64_t hostOffset = base_DistGraph::gid2host[sendingHost].first;\n\n // must be single threaded as map updating isn't thread-safe\n for (unsigned i = 0; i < receivedMasters.size(); i++) {\n uint64_t gidToMap = hostOffset + receivedOffsets[i];\n#ifndef NDEBUG\n bool newMapped =\n#endif\n graphPartitioner->addMasterMapping(gidToMap, receivedMasters[i]);\n assert(newMapped);\n }\n }\n }\n }\n\n /**\n * Phase responsible for initial master assignment.\n *\n * @param bufGraph Locally read graph on this host\n * @param async Specifies whether or not do synchronization of node\n * assignments BSP style or asynchronous style. Note regardless of which\n * is chosen there is a barrier at the end of master assignment.\n */\n void phase0(galois::graphs::BufferedGraph& bufGraph, bool async,\n const uint32_t stateRounds) {\n galois::DynamicBitSet ghosts;\n galois::gstl::Vector>\n syncNodes; // masterNodes\n syncNodes.resize(base_DistGraph::numHosts);\n\n // determine on which hosts that this host's read nodes havs neighbors on\n phase0BitsetSetup(bufGraph, ghosts);\n // gid to vector offset setup\n std::unordered_map gid2offsets;\n uint64_t neighborCount = phase0MapSetup(ghosts, gid2offsets, syncNodes);\n galois::gDebug(\"[\", base_DistGraph::id, \"] num neighbors found is \",\n neighborCount);\n // send off neighbor metadata\n phase0SendRecv(syncNodes);\n\n galois::StatTimer p0allocTimer(\"Phase0AllocationTime\", GRNAME);\n\n p0allocTimer.start();\n\n // setup other partitioning metadata: nodes on each host, edges on each\n // host (as determined by edge cut)\n std::vector nodeLoads;\n std::vector edgeLoads;\n std::vector> nodeAccum;\n std::vector> edgeAccum;\n nodeLoads.assign(base_DistGraph::numHosts, 0);\n edgeLoads.assign(base_DistGraph::numHosts, 0);\n nodeAccum.assign(base_DistGraph::numHosts, 0);\n edgeAccum.assign(base_DistGraph::numHosts, 0);\n\n uint32_t numLocalNodes =\n base_DistGraph::gid2host[base_DistGraph::id].second -\n base_DistGraph::gid2host[base_DistGraph::id].first;\n\n std::vector localNodeToMaster;\n localNodeToMaster.assign(numLocalNodes + neighborCount, (uint32_t)-1);\n\n // bitsets tracking termination of assignments and partitioning loads\n galois::DynamicBitSet hostFinished;\n galois::DynamicBitSet loadsClear;\n\n if (async) {\n if (base_DistGraph::id == 0) {\n galois::gPrint(\"Using asynchronous master determination sends.\\n\");\n }\n\n hostFinished.resize(base_DistGraph::numHosts);\n loadsClear.resize(base_DistGraph::numHosts);\n }\n\n p0allocTimer.stop();\n\n uint64_t globalOffset = base_DistGraph::gid2host[base_DistGraph::id].first;\n\n#ifndef NDEBUG\n for (uint32_t i : localNodeToMaster) {\n assert(i == (uint32_t)-1);\n }\n#endif\n\n if (base_DistGraph::id == 0) {\n galois::gPrint(\"Number of BSP sync rounds in master assignment: \",\n stateRounds, \"\\n\");\n }\n\n // galois::PerThreadTimer ptt(\n // GRNAME, \"Phase0DetermineMaster_\" + std::string(base_DistGraph::id)\n //);\n for (unsigned syncRound = 0; syncRound < stateRounds; syncRound++) {\n uint32_t beginNode;\n uint32_t endNode;\n std::tie(beginNode, endNode) = galois::block_range(\n globalOffset, base_DistGraph::gid2host[base_DistGraph::id].second,\n syncRound, stateRounds);\n\n // create specific range for this block\n std::vector rangeVec;\n auto work =\n getSpecificThreadRange(bufGraph, rangeVec, beginNode, endNode);\n\n // debug print\n // galois::on_each([&] (unsigned i, unsigned j) {\n // galois::gDebug(\"[\", base_DistGraph::id, \" \", i, \"] sync round \",\n // syncRound, \" local range \",\n // *work.local_begin(), \" \", *work.local_end());\n //});\n\n galois::do_all(\n // iterate over my read nodes\n galois::iterate(work),\n // galois::iterate(beginNode, endNode),\n [&](uint32_t node) {\n // ptt.start();\n // determine master function takes source node, iterator of\n // neighbors\n uint32_t assignedHost = graphPartitioner->getMaster(\n node, bufGraph, localNodeToMaster, gid2offsets, nodeLoads,\n nodeAccum, edgeLoads, edgeAccum);\n // != -1 means it was assigned a host\n assert(assignedHost != (uint32_t)-1);\n // update mapping; this is a local node, so can get position\n // on map with subtraction\n localNodeToMaster[node - globalOffset] = assignedHost;\n\n // galois::gDebug(\"[\", base_DistGraph::id, \"] state round \",\n // syncRound,\n // \" set \", node, \" \", node - globalOffset);\n\n // ptt.stop();\n },\n galois::loopname(\"Phase0DetermineMasters\"), galois::steal(),\n galois::no_stats());\n\n // do synchronization of master assignment of neighbors\n if (!async) {\n syncAssignment(beginNode - globalOffset, endNode - globalOffset,\n numLocalNodes, localNodeToMaster, syncNodes,\n gid2offsets);\n } else {\n // don't need to send anything if there is nothing to send unlike sync\n if (beginNode != endNode) {\n syncAssignmentAsync(beginNode - globalOffset, endNode - globalOffset,\n numLocalNodes, localNodeToMaster, syncNodes,\n gid2offsets, hostFinished);\n }\n }\n\n // sync node/edge loads\n galois::StatTimer loadSyncTimer(\"Phase0LoadSyncTime\", GRNAME);\n\n loadSyncTimer.start();\n if (!async) {\n syncLoad(nodeLoads, nodeAccum);\n syncLoad(edgeLoads, edgeAccum);\n } else {\n asyncSyncLoad(nodeLoads, nodeAccum, edgeLoads, edgeAccum, loadsClear);\n }\n loadSyncTimer.stop();\n\n#ifndef NDEBUG\n if (async) {\n galois::gDebug(\"[\", base_DistGraph::id, \"] host count \",\n hostFinished.count());\n }\n#endif\n }\n\n // if asynchronous, don't move on until everything is done\n if (async) {\n galois::StatTimer waitTime(\"Phase0AsyncWaitTime\", GRNAME);\n // assignment clears\n sendAllClears();\n // load clears\n sendAllClears(1);\n\n hostFinished.set(base_DistGraph::id);\n loadsClear.set(base_DistGraph::id);\n\n waitTime.start();\n while (hostFinished.count() != base_DistGraph::numHosts ||\n loadsClear.count() != base_DistGraph::numHosts) {\n //#ifndef NDEBUG\n // galois::gDebug(\"[\", base_DistGraph::id, \"] waiting for all hosts to\n // finish, \",\n // hostFinished.count());\n // galois::gDebug(\"[\", base_DistGraph::id, \"] waiting for all hosts\n // loads \"\n // \"syncs to finish, \", loadsClear.count());\n //#endif\n // make sure all assignments are done and all loads are done\n syncAssignmentReceivesAsync(localNodeToMaster, gid2offsets,\n hostFinished);\n asyncRecvLoad(nodeLoads, edgeLoads, loadsClear);\n }\n waitTime.stop();\n }\n\n#ifndef NDEBUG\n printLoad(nodeLoads, nodeAccum);\n printLoad(edgeLoads, edgeAccum);\n#endif\n\n // sanity check for correctness (all should be assigned)\n for (uint32_t i = 0; i < localNodeToMaster.size(); i++) {\n if (localNodeToMaster[i] == (uint32_t)-1) {\n // galois::gDebug(\"[\", base_DistGraph::id, \"] bad index \", i);\n assert(localNodeToMaster[i] != (uint32_t)-1);\n }\n }\n\n base_DistGraph::increment_evilPhase();\n // increment twice if async is used as async uses 2 phases\n if (async) {\n base_DistGraph::increment_evilPhase();\n }\n\n galois::gPrint(\"[\", base_DistGraph::id,\n \"] Local master assignment \"\n \"complete.\\n\");\n\n // one more step: let masters know of nodes they own (if they don't\n // have the node locally then this is the only way they will learn about\n // it)\n galois::StatTimer p0master2ownerTimer(\"Phase0MastersToOwners\", GRNAME);\n\n p0master2ownerTimer.start();\n sendMastersToOwners(localNodeToMaster, syncNodes);\n recvMastersToOwners();\n p0master2ownerTimer.stop();\n\n galois::gPrint(\"[\", base_DistGraph::id, \"] Received my master mappings.\\n\");\n\n base_DistGraph::increment_evilPhase();\n\n graphPartitioner->saveGID2HostInfo(gid2offsets, localNodeToMaster,\n bufGraph.getNodeOffset());\n }\n\n void edgeCutInspection(galois::graphs::BufferedGraph& bufGraph,\n galois::StatTimer& inspectionTimer,\n uint64_t edgeOffset,\n galois::gstl::Vector& prefixSumOfEdges) {\n galois::DynamicBitSet incomingMirrors;\n incomingMirrors.resize(base_DistGraph::numGlobalNodes);\n incomingMirrors.reset();\n uint32_t myID = base_DistGraph::id;\n uint64_t globalOffset = base_DistGraph::gid2host[base_DistGraph::id].first;\n\n // already set before this is called\n base_DistGraph::localToGlobalVector.resize(base_DistGraph::numOwned);\n prefixSumOfEdges.resize(base_DistGraph::numOwned);\n\n auto& ltgv = base_DistGraph::localToGlobalVector;\n galois::do_all(\n galois::iterate(base_DistGraph::gid2host[base_DistGraph::id].first,\n base_DistGraph::gid2host[base_DistGraph::id].second),\n [&](size_t n) {\n auto ii = bufGraph.edgeBegin(n);\n auto ee = bufGraph.edgeEnd(n);\n for (; ii < ee; ++ii) {\n uint32_t dst = bufGraph.edgeDestination(*ii);\n if (graphPartitioner->retrieveMaster(dst) != myID) {\n incomingMirrors.set(dst);\n }\n }\n prefixSumOfEdges[n - globalOffset] = (*ee) - edgeOffset;\n ltgv[n - globalOffset] = n;\n },\n#if MORE_DIST_STATS\n galois::loopname(\"EdgeInspectionLoop\"),\n#endif\n galois::steal(), galois::no_stats());\n inspectionTimer.stop();\n\n uint64_t allBytesRead = bufGraph.getBytesRead();\n galois::gPrint(\n \"[\", base_DistGraph::id,\n \"] Edge inspection time: \", inspectionTimer.get_usec() / 1000000.0f,\n \" seconds to read \", allBytesRead, \" bytes (\",\n allBytesRead / (float)inspectionTimer.get_usec(), \" MBPS)\\n\");\n\n // get incoming mirrors ready for creation\n uint32_t additionalMirrorCount = incomingMirrors.count();\n base_DistGraph::localToGlobalVector.resize(\n base_DistGraph::localToGlobalVector.size() + additionalMirrorCount);\n if (base_DistGraph::numOwned > 0) {\n // fill prefix sum with last number (incomings have no edges)\n prefixSumOfEdges.resize(prefixSumOfEdges.size() + additionalMirrorCount,\n prefixSumOfEdges.back());\n } else {\n prefixSumOfEdges.resize(additionalMirrorCount);\n }\n\n if (additionalMirrorCount > 0) {\n // TODO move this part below into separate function\n uint32_t totalNumNodes = base_DistGraph::numGlobalNodes;\n uint32_t activeThreads = galois::getActiveThreads();\n std::vector threadPrefixSums(activeThreads);\n galois::on_each([&](unsigned tid, unsigned nthreads) {\n size_t beginNode;\n size_t endNode;\n std::tie(beginNode, endNode) =\n galois::block_range(0u, totalNumNodes, tid, nthreads);\n uint64_t count = 0;\n for (size_t i = beginNode; i < endNode; i++) {\n if (incomingMirrors.test(i))\n ++count;\n }\n threadPrefixSums[tid] = count;\n });\n // get prefix sums\n for (unsigned int i = 1; i < threadPrefixSums.size(); i++) {\n threadPrefixSums[i] += threadPrefixSums[i - 1];\n }\n\n assert(threadPrefixSums.back() == additionalMirrorCount);\n\n uint32_t startingNodeIndex = base_DistGraph::numOwned;\n // do actual work, second on_each\n galois::on_each([&](unsigned tid, unsigned nthreads) {\n size_t beginNode;\n size_t endNode;\n std::tie(beginNode, endNode) =\n galois::block_range(0u, totalNumNodes, tid, nthreads);\n // start location to start adding things into prefix sums/vectors\n uint32_t threadStartLocation = 0;\n if (tid != 0) {\n threadStartLocation = threadPrefixSums[tid - 1];\n }\n uint32_t handledNodes = 0;\n for (size_t i = beginNode; i < endNode; i++) {\n if (incomingMirrors.test(i)) {\n base_DistGraph::localToGlobalVector[startingNodeIndex +\n threadStartLocation +\n handledNodes] = i;\n handledNodes++;\n }\n }\n });\n }\n\n base_DistGraph::numNodes = base_DistGraph::numOwned + additionalMirrorCount;\n if (prefixSumOfEdges.size() != 0) {\n base_DistGraph::numEdges = prefixSumOfEdges.back();\n } else {\n base_DistGraph::numEdges = 0;\n }\n assert(base_DistGraph::localToGlobalVector.size() ==\n base_DistGraph::numNodes);\n assert(prefixSumOfEdges.size() == base_DistGraph::numNodes);\n\n // g2l mapping\n base_DistGraph::globalToLocalMap.reserve(base_DistGraph::numNodes);\n for (unsigned i = 0; i < base_DistGraph::numNodes; i++) {\n // global to local map construction\n base_DistGraph::globalToLocalMap[base_DistGraph::localToGlobalVector[i]] =\n i;\n }\n assert(base_DistGraph::globalToLocalMap.size() == base_DistGraph::numNodes);\n\n base_DistGraph::numNodesWithEdges = base_DistGraph::numOwned;\n }\n\n /**\n * Given a loaded graph, construct the edges in the DistGraph graph.\n * Variant that constructs edge data as well.\n *\n * @tparam GraphTy type of graph to construct\n *\n * @param [in,out] graph Graph to construct edges in\n * @param bGraph Buffered graph that has edges to write into graph in memory\n */\n template ::value>::type* = nullptr>\n void edgeCutLoad(GraphTy& graph,\n galois::graphs::BufferedGraph& bGraph) {\n if (base_DistGraph::id == 0) {\n galois::gPrint(\"Loading edge-data while creating edges\\n\");\n }\n\n uint64_t globalOffset = base_DistGraph::gid2host[base_DistGraph::id].first;\n bGraph.resetReadCounters();\n galois::StatTimer timer(\"EdgeLoading\", GRNAME);\n timer.start();\n\n galois::do_all(\n galois::iterate(base_DistGraph::gid2host[base_DistGraph::id].first,\n base_DistGraph::gid2host[base_DistGraph::id].second),\n [&](size_t n) {\n auto ii = bGraph.edgeBegin(n);\n auto ee = bGraph.edgeEnd(n);\n uint32_t lsrc = this->G2LEdgeCut(n, globalOffset);\n uint64_t cur =\n *graph.edge_begin(lsrc, galois::MethodFlag::UNPROTECTED);\n for (; ii < ee; ++ii) {\n auto gdst = bGraph.edgeDestination(*ii);\n decltype(gdst) ldst = this->G2LEdgeCut(gdst, globalOffset);\n auto gdata = bGraph.edgeData(*ii);\n graph.constructEdge(cur++, ldst, gdata);\n }\n assert(cur == (*graph.edge_end(lsrc)));\n },\n#if MORE_DIST_STATS\n galois::loopname(\"EdgeLoadingLoop\"),\n#endif\n galois::steal(), galois::no_stats());\n\n timer.stop();\n galois::gPrint(\"[\", base_DistGraph::id,\n \"] Edge loading time: \", timer.get_usec() / 1000000.0f,\n \" seconds to read \", bGraph.getBytesRead(), \" bytes (\",\n bGraph.getBytesRead() / (float)timer.get_usec(), \" MBPS)\\n\");\n }\n\n /**\n * Given a loaded graph, construct the edges in the DistGraph graph.\n * No edge data.\n *\n * @tparam GraphTy type of graph to construct\n *\n * @param [in,out] graph Graph to construct edges in\n * @param bGraph Buffered graph that has edges to write into graph in memory\n */\n template ::value>::type* = nullptr>\n void edgeCutLoad(GraphTy& graph,\n galois::graphs::BufferedGraph& bGraph) {\n if (base_DistGraph::id == 0) {\n galois::gPrint(\"Loading edge-data while creating edges\\n\");\n }\n\n uint64_t globalOffset = base_DistGraph::gid2host[base_DistGraph::id].first;\n bGraph.resetReadCounters();\n galois::StatTimer timer(\"EdgeLoading\", GRNAME);\n timer.start();\n\n galois::do_all(\n galois::iterate(base_DistGraph::gid2host[base_DistGraph::id].first,\n base_DistGraph::gid2host[base_DistGraph::id].second),\n [&](size_t n) {\n auto ii = bGraph.edgeBegin(n);\n auto ee = bGraph.edgeEnd(n);\n uint32_t lsrc = this->G2LEdgeCut(n, globalOffset);\n uint64_t cur =\n *graph.edge_begin(lsrc, galois::MethodFlag::UNPROTECTED);\n for (; ii < ee; ++ii) {\n auto gdst = bGraph.edgeDestination(*ii);\n decltype(gdst) ldst = this->G2LEdgeCut(gdst, globalOffset);\n graph.constructEdge(cur++, ldst);\n }\n assert(cur == (*graph.edge_end(lsrc)));\n },\n#if MORE_DIST_STATS\n galois::loopname(\"EdgeLoadingLoop\"),\n#endif\n galois::steal(), galois::no_stats());\n\n timer.stop();\n galois::gPrint(\"[\", base_DistGraph::id,\n \"] Edge loading time: \", timer.get_usec() / 1000000.0f,\n \" seconds to read \", bGraph.getBytesRead(), \" bytes (\",\n bGraph.getBytesRead() / (float)timer.get_usec(), \" MBPS)\\n\");\n }\n\n /**\n * Assign edges to hosts (but don't actually send), and send this information\n * out to all hosts\n * @param[in] bufGraph local graph to read\n * @param[in,out] numOutgoingEdges specifies which nodes on a host will have\n * outgoing edges\n * @param[in,out] hasIncomingEdge indicates which nodes (that need to be\n * created)on a host have incoming edges\n */\n void edgeInspection(galois::graphs::BufferedGraph& bufGraph,\n std::vector>& numOutgoingEdges,\n std::vector& hasIncomingEdge,\n galois::StatTimer& inspectionTimer) {\n // number of nodes that this host has read from disk\n uint32_t numRead = base_DistGraph::gid2host[base_DistGraph::id].second -\n base_DistGraph::gid2host[base_DistGraph::id].first;\n\n // allocate space for outgoing edges\n for (uint32_t i = 0; i < base_DistGraph::numHosts; ++i) {\n numOutgoingEdges[i].assign(numRead, 0);\n }\n\n galois::DynamicBitSet hostHasOutgoing;\n hostHasOutgoing.resize(base_DistGraph::numHosts);\n hostHasOutgoing.reset();\n assignEdges(bufGraph, numOutgoingEdges, hasIncomingEdge, hostHasOutgoing);\n\n inspectionTimer.stop();\n // report edge inspection time\n uint64_t allBytesRead = bufGraph.getBytesRead();\n galois::gPrint(\n \"[\", base_DistGraph::id,\n \"] Edge inspection time: \", inspectionTimer.get_usec() / 1000000.0f,\n \" seconds to read \", allBytesRead, \" bytes (\",\n allBytesRead / (float)inspectionTimer.get_usec(), \" MBPS)\\n\");\n\n // old inspection barrier\n // galois::runtime::getHostBarrier().wait();\n\n sendInspectionData(numOutgoingEdges, hasIncomingEdge, hostHasOutgoing);\n\n // setup a single hasIncomingEdge bitvector\n\n uint32_t myHostID = base_DistGraph::id;\n if (hasIncomingEdge[myHostID].size() == 0) {\n hasIncomingEdge[myHostID].resize(base_DistGraph::numGlobalNodes);\n hasIncomingEdge[myHostID].reset();\n }\n recvInspectionData(numOutgoingEdges, hasIncomingEdge[myHostID]);\n base_DistGraph::increment_evilPhase();\n }\n\n /**\n * Inspect read edges and determine where to send them. Mark metadata as\n * necessary.\n *\n * @param[in] bufGraph local graph to read\n * @param[in,out] numOutgoingEdges specifies which nodes on a host will have\n * outgoing edges\n * @param[in,out] hasIncomingEdge indicates which nodes (that need to be\n * created)on a host have incoming edges\n * @param[in,out] hostHasOutgoing bitset tracking which hosts have outgoing\n * edges from this host\n */\n void assignEdges(galois::graphs::BufferedGraph& bufGraph,\n std::vector>& numOutgoingEdges,\n std::vector& hasIncomingEdge,\n galois::DynamicBitSet& hostHasOutgoing) {\n std::vector> indicatorVars(\n base_DistGraph::numHosts);\n // initialize indicators of initialized bitsets to 0\n for (unsigned i = 0; i < base_DistGraph::numHosts; i++) {\n indicatorVars[i] = 0;\n }\n\n // global offset into my read nodes\n uint64_t globalOffset = base_DistGraph::gid2host[base_DistGraph::id].first;\n uint32_t globalNodes = base_DistGraph::numGlobalNodes;\n\n for (unsigned syncRound = 0; syncRound < _edgeStateRounds; syncRound++) {\n uint32_t beginNode;\n uint32_t endNode;\n std::tie(beginNode, endNode) = galois::block_range(\n globalOffset, base_DistGraph::gid2host[base_DistGraph::id].second,\n syncRound, _edgeStateRounds);\n // TODO maybe edge range this?\n\n galois::do_all(\n // iterate over my read nodes\n galois::iterate(beginNode, endNode),\n [&](size_t src) {\n auto ee = bufGraph.edgeBegin(src);\n auto ee_end = bufGraph.edgeEnd(src);\n uint64_t numEdgesL = std::distance(ee, ee_end);\n\n for (; ee != ee_end; ee++) {\n uint32_t dst = bufGraph.edgeDestination(*ee);\n uint32_t hostBelongs = -1;\n hostBelongs = graphPartitioner->getEdgeOwner(src, dst, numEdgesL);\n if (_edgeStateRounds > 1) {\n hostLoads[hostBelongs] += 1;\n }\n\n numOutgoingEdges[hostBelongs][src - globalOffset] += 1;\n hostHasOutgoing.set(hostBelongs);\n bool hostIsMasterOfDest =\n (hostBelongs == graphPartitioner->retrieveMaster(dst));\n\n // this means a mirror must be created for destination node on\n // that host since it will not be created otherwise\n if (!hostIsMasterOfDest) {\n auto& bitsetStatus = indicatorVars[hostBelongs];\n\n // initialize the bitset if necessary\n if (bitsetStatus == 0) {\n char expected = 0;\n bool result =\n bitsetStatus.compare_exchange_strong(expected, 1);\n // i swapped successfully, therefore do allocation\n if (result) {\n hasIncomingEdge[hostBelongs].resize(globalNodes);\n hasIncomingEdge[hostBelongs].reset();\n bitsetStatus = 2;\n }\n }\n // until initialized, loop\n while (indicatorVars[hostBelongs] != 2)\n ;\n hasIncomingEdge[hostBelongs].set(dst);\n }\n }\n },\n#if MORE_DIST_STATS\n galois::loopname(\"AssignEdges\"),\n#endif\n galois::steal(), galois::no_stats());\n syncEdgeLoad();\n }\n }\n\n /**\n * Given a vector specifying which nodes have edges for an unspecified\n * receiver host, save the masters of those nodes (which are known on this\n * host but not necessarily other hosts) into a vector and serialize it for\n * the receiver to update their master node mapping.\n *\n * @param b Send buffer\n * @param hostOutgoingEdges Number of edges that the receiver of this\n * vector should expect for each node on this host\n */\n void\n serializeOutgoingMasterMap(galois::runtime::SendBuffer& b,\n const std::vector& hostOutgoingEdges) {\n // 2 phase: one phase determines amount of work each thread does,\n // second has threads actually do copies\n uint32_t activeThreads = galois::getActiveThreads();\n std::vector threadPrefixSums(activeThreads);\n size_t hostSize = base_DistGraph::gid2host[base_DistGraph::id].second -\n base_DistGraph::gid2host[base_DistGraph::id].first;\n assert(hostSize == hostOutgoingEdges.size());\n\n // for each thread, figure out how many items it will work with\n // (non-zero outgoing edges)\n galois::on_each([&](unsigned tid, unsigned nthreads) {\n size_t beginNode;\n size_t endNode;\n std::tie(beginNode, endNode) =\n galois::block_range((size_t)0, hostSize, tid, nthreads);\n uint64_t count = 0;\n for (size_t i = beginNode; i < endNode; i++) {\n if (hostOutgoingEdges[i] > 0) {\n count++;\n }\n }\n threadPrefixSums[tid] = count;\n });\n\n // get prefix sums\n for (unsigned int i = 1; i < threadPrefixSums.size(); i++) {\n threadPrefixSums[i] += threadPrefixSums[i - 1];\n }\n\n uint32_t numNonZero = threadPrefixSums[activeThreads - 1];\n std::vector masterLocation;\n masterLocation.resize(numNonZero, (uint32_t)-1);\n // should only be in here if there's something to send in first place\n assert(numNonZero > 0);\n\n uint64_t startNode = base_DistGraph::gid2host[base_DistGraph::id].first;\n\n // do actual work, second on_each; find non-zeros again, get master\n // corresponding to that non-zero and send to other end\n galois::on_each([&](unsigned tid, unsigned nthreads) {\n size_t beginNode;\n size_t endNode;\n std::tie(beginNode, endNode) =\n galois::block_range((size_t)0, hostSize, tid, nthreads);\n // start location to start adding things into prefix sums/vectors\n uint32_t threadStartLocation = 0;\n if (tid != 0) {\n threadStartLocation = threadPrefixSums[tid - 1];\n }\n\n uint32_t handledNodes = 0;\n for (size_t i = beginNode; i < endNode; i++) {\n if (hostOutgoingEdges[i] > 0) {\n // get master of i\n masterLocation[threadStartLocation + handledNodes] =\n graphPartitioner->retrieveMaster(i + startNode);\n handledNodes++;\n }\n }\n });\n\n#ifndef NDEBUG\n for (uint32_t i : masterLocation) {\n assert(i != (uint32_t)-1);\n }\n#endif\n\n // serialize into buffer; since this is sent along with vector receiver end\n // will know how to deal with it\n galois::runtime::gSerialize(b, masterLocation);\n }\n\n void\n serializeIncomingMasterMap(galois::runtime::SendBuffer& b,\n const galois::DynamicBitSet& hostIncomingEdges) {\n size_t numOfNodes = hostIncomingEdges.count();\n std::vector masterMap;\n masterMap.resize(numOfNodes, (uint32_t)-1);\n\n std::vector bitsetOffsets = hostIncomingEdges.getOffsets();\n\n // size_t firstBound = base_DistGraph::gid2host[h].first;\n // size_t secondBound = base_DistGraph::gid2host[h].second;\n\n // galois::do_all(\n // galois::iterate((size_t)0, firstBound),\n // [&] (size_t offset) {\n // masterMap[offset] =\n // graphPartitioner->retrieveMaster(bitsetOffsets[offset]);\n // },\n // galois::no_stats()\n //);\n\n galois::do_all(\n // galois::iterate((size_t)secondBound, numOfNodes),\n galois::iterate((size_t)0, numOfNodes),\n [&](size_t offset) {\n masterMap[offset] =\n graphPartitioner->retrieveMaster(bitsetOffsets[offset]);\n },\n galois::no_stats());\n\n#ifndef NDEBUG\n for (uint32_t i : masterMap) {\n assert(i != (uint32_t)-1);\n assert(i < base_DistGraph::numHosts);\n }\n#endif\n\n // serialize into buffer; since this is sent along with vector receiver end\n // will know how to deal with it\n galois::runtime::gSerialize(b, masterMap);\n }\n\n void deserializeOutgoingMasterMap(\n uint32_t senderHost, const std::vector& hostOutgoingEdges,\n const std::vector& recvMasterLocations) {\n uint64_t hostOffset = base_DistGraph::gid2host[senderHost].first;\n size_t hostSize = base_DistGraph::gid2host[senderHost].second -\n base_DistGraph::gid2host[senderHost].first;\n assert(hostSize == hostOutgoingEdges.size());\n galois::DynamicBitSet offsetsToConsider;\n offsetsToConsider.resize(hostSize);\n offsetsToConsider.reset();\n\n // step 1: figure out offsets that need to be handled (i.e. non-zero): only\n // handle if not already in map\n galois::do_all(\n galois::iterate((size_t)0, hostOutgoingEdges.size()),\n [&](size_t offset) {\n if (hostOutgoingEdges[offset] > 0) {\n offsetsToConsider.set(offset);\n }\n },\n galois::no_stats(), galois::steal());\n assert(offsetsToConsider.count() == recvMasterLocations.size());\n\n // step 2: using bitset that tells which offsets are set, add\n // to already master map in partitioner (this is single threaded\n // since map is not a concurrent data structure)\n size_t curCount = 0;\n // size_t actuallySet = 0;\n for (uint32_t offset : offsetsToConsider.getOffsets()) {\n // galois::gDebug(\"[\", base_DistGraph::id, \"] \", \" setting \",\n // offset + hostOffset, \" from host \", senderHost,\n // \" to \", recvMasterLocations[curCount]);\n graphPartitioner->addMasterMapping(offset + hostOffset,\n recvMasterLocations[curCount]);\n // bool set = graphPartitioner->addMasterMapping(offset + hostOffset,\n // recvMasterLocations[curCount]);\n // if (set) { actuallySet++; }\n curCount++;\n }\n\n // galois::gDebug(\"[\", base_DistGraph::id, \"] host \", senderHost, \": set \",\n // actuallySet, \" out of \", recvMasterLocations.size());\n }\n\n /**\n * Map GIDs to masters from incoming master map sent from hosts.\n *\n * @param senderHost host that sent the data\n * @param gids GIDs corresponding to the received master locations\n * @param recvMasterLocations masters of GIDs in the gids vector\n */\n void deserializeIncomingMasterMap(\n const std::vector& gids,\n const std::vector& recvMasterLocations) {\n assert(gids.size() == recvMasterLocations.size());\n size_t curCount = 0;\n for (uint64_t gid : gids) {\n assert(gid < base_DistGraph::numGlobalNodes);\n // galois::gDebug(\"[\", base_DistGraph::id, \"] \", \" in-setting \", gid, \" to\n // \",\n // recvMasterLocations[curCount]);\n graphPartitioner->addMasterMapping(gid, recvMasterLocations[curCount]);\n curCount++;\n }\n }\n\n /**\n * Send data out from inspection to other hosts.\n *\n * @param[in,out] numOutgoingEdges specifies which nodes on a host will have\n * outgoing edges\n * @param[in,out] hasIncomingEdge indicates which nodes (that need to be\n * created)on a host have incoming edges\n * @param[in] hostHasOutgoing bitset tracking which hosts have outgoing\n * edges from this host\n */\n void sendInspectionData(std::vector>& numOutgoingEdges,\n std::vector& hasIncomingEdge,\n galois::DynamicBitSet& hostHasOutgoing) {\n auto& net = galois::runtime::getSystemNetworkInterface();\n\n galois::GAccumulator bytesSent;\n bytesSent.reset();\n\n for (unsigned h = 0; h < net.Num; h++) {\n if (h == net.ID) {\n // i have no outgoing edges i will keep; go ahead and clear\n if (!hostHasOutgoing.test(h)) {\n numOutgoingEdges[h].clear();\n }\n continue;\n }\n // send outgoing edges data off to comm partner\n galois::runtime::SendBuffer b;\n\n // only send if non-zeros exist\n if (hostHasOutgoing.test(h)) {\n galois::runtime::gSerialize(b, 1); // token saying data exists\n galois::runtime::gSerialize(b, numOutgoingEdges[h]);\n if (graphPartitioner->masterAssignPhase()) {\n serializeOutgoingMasterMap(b, numOutgoingEdges[h]);\n }\n } else {\n galois::runtime::gSerialize(b, 0); // token saying no data exists\n }\n numOutgoingEdges[h].clear();\n\n // determine form to send bitset in\n galois::DynamicBitSet& curBitset = hasIncomingEdge[h];\n uint64_t bitsetSize = curBitset.size(); // num bits\n uint64_t onlyOffsetsSize = curBitset.count() * 32;\n if (bitsetSize == 0) {\n // there was nothing there to send in first place\n galois::runtime::gSerialize(b, 0);\n } else if (onlyOffsetsSize <= bitsetSize) {\n // send only offsets\n std::vector offsets = curBitset.getOffsets();\n galois::runtime::gSerialize(b, 2); // 2 = only offsets\n galois::runtime::gSerialize(b, offsets);\n\n if (graphPartitioner->masterAssignPhase()) {\n // galois::gDebug(\"incoming master map serialization\");\n // serializeIncomingMasterMap(b, curBitset, h);\n serializeIncomingMasterMap(b, curBitset);\n }\n } else {\n // send entire bitset\n galois::runtime::gSerialize(b, 1);\n galois::runtime::gSerialize(b, curBitset);\n if (graphPartitioner->masterAssignPhase()) {\n // galois::gDebug(\"incoming master map serialization\");\n // serializeIncomingMasterMap(b, curBitset, h);\n serializeIncomingMasterMap(b, curBitset);\n }\n }\n // get memory from bitset back\n curBitset.resize(0);\n\n bytesSent.update(b.size());\n\n // send buffer and free memory\n net.sendTagged(h, galois::runtime::evilPhase, b);\n b.getVec().clear();\n }\n\n galois::runtime::reportStat_Tsum(\n GRNAME, std::string(\"EdgeInspectionBytesSent\"), bytesSent.reduce());\n\n galois::gPrint(\"[\", base_DistGraph::id, \"] Inspection sends complete.\\n\");\n }\n\n /**\n * Receive data from inspection from other hosts. Processes the incoming\n * edge bitsets/offsets.\n *\n * @param[in,out] numOutgoingEdges specifies which nodes on a host will have\n * outgoing edges\n * @param[in,out] hasIncomingEdge indicates which nodes (that need to be\n * created) on this host have incoming edges\n */\n void recvInspectionData(std::vector>& numOutgoingEdges,\n galois::DynamicBitSet& hasIncomingEdge) {\n auto& net = galois::runtime::getSystemNetworkInterface();\n\n for (unsigned h = 0; h < net.Num - 1; h++) {\n // expect data from comm partner back\n decltype(net.recieveTagged(galois::runtime::evilPhase, nullptr)) p;\n do {\n p = net.recieveTagged(galois::runtime::evilPhase, nullptr);\n } while (!p);\n\n uint32_t sendingHost = p->first;\n\n // get outgoing edges; first get status var\n uint32_t outgoingExists = 2;\n galois::runtime::gDeserialize(p->second, outgoingExists);\n\n if (outgoingExists == 1) {\n // actual data sent\n galois::runtime::gDeserialize(p->second, numOutgoingEdges[sendingHost]);\n\n if (graphPartitioner->masterAssignPhase()) {\n std::vector recvMasterLocations;\n galois::runtime::gDeserialize(p->second, recvMasterLocations);\n deserializeOutgoingMasterMap(\n sendingHost, numOutgoingEdges[sendingHost], recvMasterLocations);\n }\n } else if (outgoingExists == 0) {\n // no data sent; just clear again\n numOutgoingEdges[sendingHost].clear();\n } else {\n GALOIS_DIE(\"invalid recv inspection data metadata mode, outgoing\");\n }\n\n uint32_t bitsetMetaMode = 3; // initialize to invalid mode\n galois::runtime::gDeserialize(p->second, bitsetMetaMode);\n if (bitsetMetaMode == 1) {\n // sent as bitset; deserialize then or with main bitset\n galois::DynamicBitSet recvSet;\n galois::runtime::gDeserialize(p->second, recvSet);\n hasIncomingEdge.bitwise_or(recvSet);\n\n if (graphPartitioner->masterAssignPhase()) {\n std::vector recvMasterLocations;\n galois::runtime::gDeserialize(p->second, recvMasterLocations);\n deserializeIncomingMasterMap(recvSet.getOffsets(),\n recvMasterLocations);\n }\n } else if (bitsetMetaMode == 2) {\n // sent as vector of offsets\n std::vector recvOffsets;\n galois::runtime::gDeserialize(p->second, recvOffsets);\n for (uint32_t offset : recvOffsets) {\n hasIncomingEdge.set(offset);\n }\n\n if (graphPartitioner->masterAssignPhase()) {\n std::vector recvMasterLocations;\n galois::runtime::gDeserialize(p->second, recvMasterLocations);\n deserializeIncomingMasterMap(recvOffsets, recvMasterLocations);\n }\n } else if (bitsetMetaMode == 0) {\n // do nothing; there was nothing to receive\n } else {\n GALOIS_DIE(\"invalid recv inspection data metadata mode\");\n }\n }\n\n galois::gPrint(\"[\", base_DistGraph::id,\n \"] Inspection receives complete.\\n\");\n }\n\n /**\n * Take inspection metadata and being mapping nodes/creating prefix sums,\n * return the prefix sum.\n */\n galois::gstl::Vector\n nodeMapping(std::vector>& numOutgoingEdges,\n galois::DynamicBitSet& hasIncomingEdge,\n galois::gstl::Vector& prefixSumOfEdges) {\n base_DistGraph::numNodes = 0;\n base_DistGraph::numEdges = 0;\n nodesToReceive = 0;\n\n // reserve overestimation of nodes\n prefixSumOfEdges.reserve(base_DistGraph::numGlobalNodes /\n base_DistGraph::numHosts * 1.15);\n base_DistGraph::localToGlobalVector.reserve(\n base_DistGraph::numGlobalNodes / base_DistGraph::numHosts * 1.15);\n\n inspectMasterNodes(numOutgoingEdges, prefixSumOfEdges);\n inspectOutgoingNodes(numOutgoingEdges, prefixSumOfEdges);\n createIntermediateMetadata(prefixSumOfEdges, hasIncomingEdge.count());\n inspectIncomingNodes(hasIncomingEdge, prefixSumOfEdges);\n finalizeInspection(prefixSumOfEdges);\n\n galois::gDebug(\"[\", base_DistGraph::id,\n \"] To receive this many nodes: \", nodesToReceive);\n\n galois::gPrint(\"[\", base_DistGraph::id, \"] Inspection mapping complete.\\n\");\n return prefixSumOfEdges;\n }\n\n /**\n * Inspect master nodes; loop over all nodes, determine if master; if is,\n * create mapping + get num edges\n */\n void inspectMasterNodes(std::vector>& numOutgoingEdges,\n galois::gstl::Vector& prefixSumOfEdges) {\n uint32_t myHID = base_DistGraph::id;\n\n galois::GAccumulator toReceive;\n toReceive.reset();\n\n for (unsigned h = 0; h < base_DistGraph::numHosts; ++h) {\n uint32_t activeThreads = galois::getActiveThreads();\n std::vector threadPrefixSums(activeThreads);\n uint64_t startNode = base_DistGraph::gid2host[h].first;\n uint64_t lastNode = base_DistGraph::gid2host[h].second;\n size_t hostSize = lastNode - startNode;\n\n if (numOutgoingEdges[h].size() != 0) {\n assert(hostSize == numOutgoingEdges[h].size());\n }\n\n // for each thread, figure out how many items it will work with (only\n // owned nodes)\n galois::on_each([&](unsigned tid, unsigned nthreads) {\n size_t beginNode;\n size_t endNode;\n // loop over all nodes that host h has read\n std::tie(beginNode, endNode) =\n galois::block_range((size_t)0, hostSize, tid, nthreads);\n uint64_t count = 0;\n for (size_t i = beginNode; i < endNode; i++) {\n // galois::gDebug(\"[\", base_DistGraph::id, \"] \", i + startNode,\n // \" mapped to \",\n // graphPartitioner->retrieveMaster(i+startNode));\n if (graphPartitioner->retrieveMaster(i + startNode) == myHID) {\n count++;\n }\n }\n threadPrefixSums[tid] = count;\n });\n\n // get prefix sums\n for (unsigned int i = 1; i < threadPrefixSums.size(); i++) {\n threadPrefixSums[i] += threadPrefixSums[i - 1];\n }\n\n assert(prefixSumOfEdges.size() == base_DistGraph::numNodes);\n assert(base_DistGraph::localToGlobalVector.size() ==\n base_DistGraph::numNodes);\n\n uint32_t newMasterNodes = threadPrefixSums[activeThreads - 1];\n galois::gDebug(\"[\", base_DistGraph::id, \"] This many masters from host \",\n h, \": \", newMasterNodes);\n uint32_t startingNodeIndex = base_DistGraph::numNodes;\n // increase size of prefix sum + mapping vector\n prefixSumOfEdges.resize(base_DistGraph::numNodes + newMasterNodes);\n base_DistGraph::localToGlobalVector.resize(base_DistGraph::numNodes +\n newMasterNodes);\n\n if (newMasterNodes > 0) {\n // do actual work, second on_each\n galois::on_each([&](unsigned tid, unsigned nthreads) {\n size_t beginNode;\n size_t endNode;\n std::tie(beginNode, endNode) =\n galois::block_range((size_t)0, hostSize, tid, nthreads);\n\n // start location to start adding things into prefix sums/vectors\n uint32_t threadStartLocation = 0;\n if (tid != 0) {\n threadStartLocation = threadPrefixSums[tid - 1];\n }\n\n uint32_t handledNodes = 0;\n for (size_t i = beginNode; i < endNode; i++) {\n uint32_t globalID = startNode + i;\n // if this node is master, get outgoing edges + save mapping\n if (graphPartitioner->retrieveMaster(globalID) == myHID) {\n // check size\n if (numOutgoingEdges[h].size() > 0) {\n uint64_t myEdges = numOutgoingEdges[h][i];\n numOutgoingEdges[h][i] = 0; // set to 0; does not need to be\n // handled later\n prefixSumOfEdges[startingNodeIndex + threadStartLocation +\n handledNodes] = myEdges;\n if (myEdges > 0 && h != myHID) {\n toReceive += 1;\n }\n } else {\n prefixSumOfEdges[startingNodeIndex + threadStartLocation +\n handledNodes] = 0;\n }\n\n base_DistGraph::localToGlobalVector[startingNodeIndex +\n threadStartLocation +\n handledNodes] = globalID;\n handledNodes++;\n }\n }\n });\n base_DistGraph::numNodes += newMasterNodes;\n }\n }\n\n nodesToReceive += toReceive.reduce();\n // masters have been handled\n base_DistGraph::numOwned = base_DistGraph::numNodes;\n }\n\n /**\n * Outgoing inspection: loop over all nodes, determnine if outgoing exists;\n * if does, create mapping, get edges\n */\n void\n inspectOutgoingNodes(std::vector>& numOutgoingEdges,\n galois::gstl::Vector& prefixSumOfEdges) {\n uint32_t myHID = base_DistGraph::id;\n\n galois::GAccumulator toReceive;\n toReceive.reset();\n\n for (unsigned h = 0; h < base_DistGraph::numHosts; ++h) {\n size_t hostSize = numOutgoingEdges[h].size();\n // if i got no outgoing info from this host, safely continue to next one\n if (hostSize == 0) {\n continue;\n }\n\n uint32_t activeThreads = galois::getActiveThreads();\n std::vector threadPrefixSums(activeThreads);\n\n // for each thread, figure out how many items it will work with (only\n // owned nodes)\n galois::on_each([&](unsigned tid, unsigned nthreads) {\n size_t beginNode;\n size_t endNode;\n std::tie(beginNode, endNode) =\n galois::block_range((size_t)0, hostSize, tid, nthreads);\n uint64_t count = 0;\n for (size_t i = beginNode; i < endNode; i++) {\n if (numOutgoingEdges[h][i] > 0) {\n count++;\n }\n }\n threadPrefixSums[tid] = count;\n });\n\n // get prefix sums\n for (unsigned int i = 1; i < threadPrefixSums.size(); i++) {\n threadPrefixSums[i] += threadPrefixSums[i - 1];\n }\n\n assert(prefixSumOfEdges.size() == base_DistGraph::numNodes);\n assert(base_DistGraph::localToGlobalVector.size() ==\n base_DistGraph::numNodes);\n\n uint32_t newOutgoingNodes = threadPrefixSums[activeThreads - 1];\n // increase size of prefix sum + mapping vector\n prefixSumOfEdges.resize(base_DistGraph::numNodes + newOutgoingNodes);\n base_DistGraph::localToGlobalVector.resize(base_DistGraph::numNodes +\n newOutgoingNodes);\n\n uint64_t startNode = base_DistGraph::gid2host[h].first;\n uint32_t startingNodeIndex = base_DistGraph::numNodes;\n\n if (newOutgoingNodes > 0) {\n // do actual work, second on_each\n galois::on_each([&](unsigned tid, unsigned nthreads) {\n size_t beginNode;\n size_t endNode;\n std::tie(beginNode, endNode) =\n galois::block_range((size_t)0, hostSize, tid, nthreads);\n\n // start location to start adding things into prefix sums/vectors\n uint32_t threadStartLocation = 0;\n if (tid != 0) {\n threadStartLocation = threadPrefixSums[tid - 1];\n }\n\n uint32_t handledNodes = 0;\n\n for (size_t i = beginNode; i < endNode; i++) {\n uint64_t myEdges = numOutgoingEdges[h][i];\n if (myEdges > 0) {\n prefixSumOfEdges[startingNodeIndex + threadStartLocation +\n handledNodes] = myEdges;\n base_DistGraph::localToGlobalVector[startingNodeIndex +\n threadStartLocation +\n handledNodes] = startNode + i;\n handledNodes++;\n\n if (myEdges > 0 && h != myHID) {\n toReceive += 1;\n }\n }\n }\n });\n base_DistGraph::numNodes += newOutgoingNodes;\n }\n // don't need anymore after this point; get memory back\n numOutgoingEdges[h].clear();\n }\n\n nodesToReceive += toReceive.reduce();\n base_DistGraph::numNodesWithEdges = base_DistGraph::numNodes;\n }\n\n /**\n * Create a part of the global to local map (it's missing the incoming\n * mirrors with no edges) + part of prefix sum\n *\n * @param[in, out] prefixSumOfEdges edge prefix sum to build\n * @param[in] incomingEstimate estimate of number of incoming nodes to build\n */\n void\n createIntermediateMetadata(galois::gstl::Vector& prefixSumOfEdges,\n const uint64_t incomingEstimate) {\n if (base_DistGraph::numNodes == 0) {\n return;\n }\n base_DistGraph::globalToLocalMap.reserve(base_DistGraph::numNodesWithEdges +\n incomingEstimate);\n base_DistGraph::globalToLocalMap[base_DistGraph::localToGlobalVector[0]] =\n 0;\n // global to local map construction using num nodes with edges\n for (unsigned i = 1; i < base_DistGraph::numNodesWithEdges; i++) {\n prefixSumOfEdges[i] += prefixSumOfEdges[i - 1];\n base_DistGraph::globalToLocalMap[base_DistGraph::localToGlobalVector[i]] =\n i;\n }\n }\n\n /**\n * incoming node creation if is doesn't already exist + if actually amrked\n * as having incoming node\n */\n void inspectIncomingNodes(galois::DynamicBitSet& hasIncomingEdge,\n galois::gstl::Vector& prefixSumOfEdges) {\n uint32_t totalNumNodes = base_DistGraph::numGlobalNodes;\n\n uint32_t activeThreads = galois::getActiveThreads();\n std::vector threadPrefixSums(activeThreads);\n\n galois::on_each([&](unsigned tid, unsigned nthreads) {\n size_t beginNode;\n size_t endNode;\n std::tie(beginNode, endNode) =\n galois::block_range(0u, totalNumNodes, tid, nthreads);\n uint64_t count = 0;\n for (size_t i = beginNode; i < endNode; i++) {\n // only count if doesn't exist in global/local map + is incoming\n // edge\n if (hasIncomingEdge.test(i) &&\n !base_DistGraph::globalToLocalMap.count(i))\n ++count;\n }\n threadPrefixSums[tid] = count;\n });\n // get prefix sums\n for (unsigned int i = 1; i < threadPrefixSums.size(); i++) {\n threadPrefixSums[i] += threadPrefixSums[i - 1];\n }\n\n assert(prefixSumOfEdges.size() == base_DistGraph::numNodes);\n assert(base_DistGraph::localToGlobalVector.size() ==\n base_DistGraph::numNodes);\n\n uint32_t newIncomingNodes = threadPrefixSums[activeThreads - 1];\n // increase size of prefix sum + mapping vector\n prefixSumOfEdges.resize(base_DistGraph::numNodes + newIncomingNodes);\n base_DistGraph::localToGlobalVector.resize(base_DistGraph::numNodes +\n newIncomingNodes);\n\n uint32_t startingNodeIndex = base_DistGraph::numNodes;\n\n if (newIncomingNodes > 0) {\n // do actual work, second on_each\n galois::on_each([&](unsigned tid, unsigned nthreads) {\n size_t beginNode;\n size_t endNode;\n std::tie(beginNode, endNode) =\n galois::block_range(0u, totalNumNodes, tid, nthreads);\n\n // start location to start adding things into prefix sums/vectors\n uint32_t threadStartLocation = 0;\n if (tid != 0) {\n threadStartLocation = threadPrefixSums[tid - 1];\n }\n\n uint32_t handledNodes = 0;\n\n for (size_t i = beginNode; i < endNode; i++) {\n if (hasIncomingEdge.test(i) &&\n !base_DistGraph::globalToLocalMap.count(i)) {\n prefixSumOfEdges[startingNodeIndex + threadStartLocation +\n handledNodes] = 0;\n base_DistGraph::localToGlobalVector[startingNodeIndex +\n threadStartLocation +\n handledNodes] = i;\n handledNodes++;\n }\n }\n });\n base_DistGraph::numNodes += newIncomingNodes;\n }\n }\n\n /**\n * finalize metadata maps\n */\n void finalizeInspection(galois::gstl::Vector& prefixSumOfEdges) {\n // reserve rest of memory needed\n base_DistGraph::globalToLocalMap.reserve(base_DistGraph::numNodes);\n for (unsigned i = base_DistGraph::numNodesWithEdges;\n i < base_DistGraph::numNodes; i++) {\n // finalize prefix sum\n prefixSumOfEdges[i] += prefixSumOfEdges[i - 1];\n // global to local map construction\n base_DistGraph::globalToLocalMap[base_DistGraph::localToGlobalVector[i]] =\n i;\n }\n if (prefixSumOfEdges.size() != 0) {\n base_DistGraph::numEdges = prefixSumOfEdges.back();\n } else {\n base_DistGraph::numEdges = 0;\n }\n }\n\n ////////////////////////////////////////////////////////////////////////////////\n\n /**\n * Fill up mirror arrays.\n * TODO make parallel?\n */\n void fillMirrors() {\n base_DistGraph::mirrorNodes.reserve(base_DistGraph::numNodes -\n base_DistGraph::numOwned);\n for (uint32_t i = base_DistGraph::numOwned; i < base_DistGraph::numNodes;\n i++) {\n uint32_t globalID = base_DistGraph::localToGlobalVector[i];\n base_DistGraph::mirrorNodes[graphPartitioner->retrieveMaster(globalID)]\n .push_back(globalID);\n }\n }\n\n ////////////////////////////////////////////////////////////////////////////////\n\n template \n void loadEdges(GraphTy& graph,\n galois::graphs::BufferedGraph& bufGraph) {\n if (base_DistGraph::id == 0) {\n if (std::is_void::value) {\n fprintf(stderr, \"Loading void edge-data while creating edges.\\n\");\n } else {\n fprintf(stderr, \"Loading edge-data while creating edges.\\n\");\n }\n }\n\n bufGraph.resetReadCounters();\n\n std::atomic receivedNodes;\n receivedNodes.store(0);\n\n galois::StatTimer loadEdgeTimer(\"EdgeLoading\", GRNAME);\n loadEdgeTimer.start();\n\n // sends data\n sendEdges(graph, bufGraph, receivedNodes);\n uint64_t bufBytesRead = bufGraph.getBytesRead();\n // get data from graph back (don't need it after sending things out)\n bufGraph.resetAndFree();\n\n // receives data\n galois::on_each(\n [&](unsigned, unsigned) { receiveEdges(graph, receivedNodes); });\n base_DistGraph::increment_evilPhase();\n\n loadEdgeTimer.stop();\n\n galois::gPrint(\"[\", base_DistGraph::id, \"] Edge loading time: \",\n loadEdgeTimer.get_usec() / 1000000.0f, \" seconds to read \",\n bufBytesRead, \" bytes (\",\n bufBytesRead / (float)loadEdgeTimer.get_usec(), \" MBPS)\\n\");\n }\n\n // Edge type is not void. (i.e. edge data exists)\n template ::value>::type* = nullptr>\n void sendEdges(GraphTy& graph,\n galois::graphs::BufferedGraph& bufGraph,\n std::atomic& receivedNodes) {\n using DstVecType = std::vector>;\n using DataVecType =\n std::vector>;\n using SendBufferVecTy = std::vector;\n\n galois::substrate::PerThreadStorage gdst_vecs(\n base_DistGraph::numHosts);\n galois::substrate::PerThreadStorage gdata_vecs(\n base_DistGraph::numHosts);\n galois::substrate::PerThreadStorage sendBuffers(\n base_DistGraph::numHosts);\n\n auto& net = galois::runtime::getSystemNetworkInterface();\n const unsigned& id = this->base_DistGraph::id;\n const unsigned& numHosts = this->base_DistGraph::numHosts;\n\n galois::GAccumulator messagesSent;\n galois::GAccumulator bytesSent;\n galois::GReduceMax maxBytesSent;\n messagesSent.reset();\n bytesSent.reset();\n maxBytesSent.reset();\n\n for (unsigned syncRound = 0; syncRound < _edgeStateRounds; syncRound++) {\n uint32_t beginNode;\n uint32_t endNode;\n std::tie(beginNode, endNode) = galois::block_range(\n base_DistGraph::gid2host[base_DistGraph::id].first,\n base_DistGraph::gid2host[base_DistGraph::id].second, syncRound,\n _edgeStateRounds);\n\n // Go over assigned nodes and distribute edges.\n galois::do_all(\n galois::iterate(beginNode, endNode),\n [&](uint64_t src) {\n uint32_t lsrc = 0;\n uint64_t curEdge = 0;\n if (base_DistGraph::isLocal(src)) {\n lsrc = this->G2L(src);\n curEdge =\n *graph.edge_begin(lsrc, galois::MethodFlag::UNPROTECTED);\n }\n\n auto ee = bufGraph.edgeBegin(src);\n auto ee_end = bufGraph.edgeEnd(src);\n uint64_t numEdgesL = std::distance(ee, ee_end);\n auto& gdst_vec = *gdst_vecs.getLocal();\n auto& gdata_vec = *gdata_vecs.getLocal();\n\n for (unsigned i = 0; i < numHosts; ++i) {\n gdst_vec[i].clear();\n gdata_vec[i].clear();\n gdst_vec[i].reserve(numEdgesL);\n // gdata_vec[i].reserve(numEdgesL);\n }\n\n for (; ee != ee_end; ++ee) {\n uint32_t gdst = bufGraph.edgeDestination(*ee);\n auto gdata = bufGraph.edgeData(*ee);\n\n uint32_t hostBelongs =\n graphPartitioner->getEdgeOwner(src, gdst, numEdgesL);\n if (_edgeStateRounds > 1) {\n hostLoads[hostBelongs] += 1;\n }\n\n if (hostBelongs == id) {\n // edge belongs here, construct on self\n assert(base_DistGraph::isLocal(src));\n uint32_t ldst = this->G2L(gdst);\n graph.constructEdge(curEdge++, ldst, gdata);\n // TODO\n // if ldst is an outgoing mirror, this is vertex cut\n } else {\n // add to host vector to send out later\n gdst_vec[hostBelongs].push_back(gdst);\n gdata_vec[hostBelongs].push_back(gdata);\n }\n }\n\n // make sure all edges accounted for if local\n if (base_DistGraph::isLocal(src)) {\n assert(curEdge == (*graph.edge_end(lsrc)));\n }\n\n // send\n for (uint32_t h = 0; h < numHosts; ++h) {\n if (h == id)\n continue;\n\n if (gdst_vec[h].size() > 0) {\n auto& b = (*sendBuffers.getLocal())[h];\n galois::runtime::gSerialize(b, src);\n galois::runtime::gSerialize(b, gdst_vec[h]);\n galois::runtime::gSerialize(b, gdata_vec[h]);\n\n // send if over limit\n if (b.size() > edgePartitionSendBufSize) {\n messagesSent += 1;\n bytesSent.update(b.size());\n maxBytesSent.update(b.size());\n\n net.sendTagged(h, galois::runtime::evilPhase, b);\n b.getVec().clear();\n b.getVec().reserve(edgePartitionSendBufSize * 1.25);\n }\n }\n }\n\n // overlap receives\n auto buffer =\n net.recieveTagged(galois::runtime::evilPhase, nullptr);\n this->processReceivedEdgeBuffer(buffer, graph, receivedNodes);\n },\n#if MORE_DIST_STATS\n galois::loopname(\"EdgeLoadingLoop\"),\n#endif\n galois::steal(), galois::no_stats());\n syncEdgeLoad();\n // printEdgeLoad();\n }\n\n // flush buffers\n for (unsigned threadNum = 0; threadNum < sendBuffers.size(); ++threadNum) {\n auto& sbr = *sendBuffers.getRemote(threadNum);\n for (unsigned h = 0; h < this->base_DistGraph::numHosts; ++h) {\n if (h == this->base_DistGraph::id)\n continue;\n auto& sendBuffer = sbr[h];\n if (sendBuffer.size() > 0) {\n messagesSent += 1;\n bytesSent.update(sendBuffer.size());\n maxBytesSent.update(sendBuffer.size());\n\n net.sendTagged(h, galois::runtime::evilPhase, sendBuffer);\n sendBuffer.getVec().clear();\n }\n }\n }\n\n net.flush();\n\n galois::runtime::reportStat_Tsum(\n GRNAME, std::string(\"EdgeLoadingMessagesSent\"), messagesSent.reduce());\n galois::runtime::reportStat_Tsum(\n GRNAME, std::string(\"EdgeLoadingBytesSent\"), bytesSent.reduce());\n galois::runtime::reportStat_Tmax(\n GRNAME, std::string(\"EdgeLoadingMaxBytesSent\"), maxBytesSent.reduce());\n }\n\n // no edge data version\n template ::value>::type* = nullptr>\n void sendEdges(GraphTy& graph,\n galois::graphs::BufferedGraph& bufGraph,\n std::atomic& receivedNodes) {\n using DstVecType = std::vector>;\n using SendBufferVecTy = std::vector;\n\n galois::substrate::PerThreadStorage gdst_vecs(\n base_DistGraph::numHosts);\n galois::substrate::PerThreadStorage sendBuffers(\n base_DistGraph::numHosts);\n\n auto& net = galois::runtime::getSystemNetworkInterface();\n const unsigned& id = this->base_DistGraph::id;\n const unsigned& numHosts = this->base_DistGraph::numHosts;\n\n galois::GAccumulator messagesSent;\n galois::GAccumulator bytesSent;\n galois::GReduceMax maxBytesSent;\n messagesSent.reset();\n bytesSent.reset();\n maxBytesSent.reset();\n\n for (unsigned syncRound = 0; syncRound < _edgeStateRounds; syncRound++) {\n uint64_t beginNode;\n uint64_t endNode;\n std::tie(beginNode, endNode) = galois::block_range(\n base_DistGraph::gid2host[base_DistGraph::id].first,\n base_DistGraph::gid2host[base_DistGraph::id].second, syncRound,\n _edgeStateRounds);\n\n // Go over assigned nodes and distribute edges.\n galois::do_all(\n galois::iterate(beginNode, endNode),\n [&](uint64_t src) {\n uint32_t lsrc = 0;\n uint64_t curEdge = 0;\n if (base_DistGraph::isLocal(src)) {\n lsrc = this->G2L(src);\n curEdge =\n *graph.edge_begin(lsrc, galois::MethodFlag::UNPROTECTED);\n }\n\n auto ee = bufGraph.edgeBegin(src);\n auto ee_end = bufGraph.edgeEnd(src);\n uint64_t numEdgesL = std::distance(ee, ee_end);\n auto& gdst_vec = *gdst_vecs.getLocal();\n\n for (unsigned i = 0; i < numHosts; ++i) {\n gdst_vec[i].clear();\n // gdst_vec[i].reserve(numEdgesL);\n }\n\n for (; ee != ee_end; ++ee) {\n uint32_t gdst = bufGraph.edgeDestination(*ee);\n uint32_t hostBelongs =\n graphPartitioner->getEdgeOwner(src, gdst, numEdgesL);\n if (_edgeStateRounds > 1) {\n hostLoads[hostBelongs] += 1;\n }\n\n if (hostBelongs == id) {\n // edge belongs here, construct on self\n assert(base_DistGraph::isLocal(src));\n uint32_t ldst = this->G2L(gdst);\n graph.constructEdge(curEdge++, ldst);\n // TODO\n // if ldst is an outgoing mirror, this is vertex cut\n } else {\n // add to host vector to send out later\n gdst_vec[hostBelongs].push_back(gdst);\n }\n }\n\n // make sure all edges accounted for if local\n if (base_DistGraph::isLocal(src)) {\n assert(curEdge == (*graph.edge_end(lsrc)));\n }\n\n // send\n for (uint32_t h = 0; h < numHosts; ++h) {\n if (h == id)\n continue;\n\n if (gdst_vec[h].size() > 0) {\n auto& b = (*sendBuffers.getLocal())[h];\n galois::runtime::gSerialize(b, src);\n galois::runtime::gSerialize(b, gdst_vec[h]);\n\n // send if over limit\n if (b.size() > edgePartitionSendBufSize) {\n messagesSent += 1;\n bytesSent.update(b.size());\n maxBytesSent.update(b.size());\n\n net.sendTagged(h, galois::runtime::evilPhase, b);\n b.getVec().clear();\n b.getVec().reserve(edgePartitionSendBufSize * 1.25);\n }\n }\n }\n\n // overlap receives\n auto buffer =\n net.recieveTagged(galois::runtime::evilPhase, nullptr);\n this->processReceivedEdgeBuffer(buffer, graph, receivedNodes);\n },\n#if MORE_DIST_STATS\n galois::loopname(\"EdgeLoading\"),\n#endif\n galois::steal(), galois::no_stats());\n syncEdgeLoad();\n // printEdgeLoad();\n }\n\n // flush buffers\n for (unsigned threadNum = 0; threadNum < sendBuffers.size(); ++threadNum) {\n auto& sbr = *sendBuffers.getRemote(threadNum);\n for (unsigned h = 0; h < this->base_DistGraph::numHosts; ++h) {\n if (h == this->base_DistGraph::id)\n continue;\n auto& sendBuffer = sbr[h];\n if (sendBuffer.size() > 0) {\n messagesSent += 1;\n bytesSent.update(sendBuffer.size());\n maxBytesSent.update(sendBuffer.size());\n\n net.sendTagged(h, galois::runtime::evilPhase, sendBuffer);\n sendBuffer.getVec().clear();\n }\n }\n }\n\n net.flush();\n\n galois::runtime::reportStat_Tsum(\n GRNAME, std::string(\"EdgeLoadingMessagesSent\"), messagesSent.reduce());\n galois::runtime::reportStat_Tsum(\n GRNAME, std::string(\"EdgeLoadingBytesSent\"), bytesSent.reduce());\n galois::runtime::reportStat_Tmax(\n GRNAME, std::string(\"EdgeLoadingMaxBytesSent\"), maxBytesSent.reduce());\n }\n\n //! @copydoc DistGraphHybridCut::processReceivedEdgeBuffer\n template \n void processReceivedEdgeBuffer(\n std::optional>& buffer,\n GraphTy& graph, std::atomic& receivedNodes) {\n if (buffer) {\n auto& rb = buffer->second;\n while (rb.r_size() > 0) {\n uint64_t n;\n std::vector gdst_vec;\n galois::runtime::gDeserialize(rb, n);\n galois::runtime::gDeserialize(rb, gdst_vec);\n assert(base_DistGraph::isLocal(n));\n uint32_t lsrc = this->G2L(n);\n uint64_t cur = *graph.edge_begin(lsrc, galois::MethodFlag::UNPROTECTED);\n uint64_t cur_end = *graph.edge_end(lsrc);\n assert((cur_end - cur) == gdst_vec.size());\n deserializeEdges(graph, rb, gdst_vec, cur, cur_end);\n ++receivedNodes;\n }\n }\n }\n\n /**\n * Receive the edge dest/data assigned to this host from other hosts\n * that were responsible for reading them.\n */\n template \n void receiveEdges(GraphTy& graph, std::atomic& receivedNodes) {\n auto& net = galois::runtime::getSystemNetworkInterface();\n\n // receive edges for all mirror nodes\n while (receivedNodes < nodesToReceive) {\n decltype(net.recieveTagged(galois::runtime::evilPhase, nullptr)) p;\n p = net.recieveTagged(galois::runtime::evilPhase, nullptr);\n processReceivedEdgeBuffer(p, graph, receivedNodes);\n }\n }\n\n template ::value>::type* = nullptr>\n void deserializeEdges(GraphTy& graph, galois::runtime::RecvBuffer& b,\n std::vector& gdst_vec, uint64_t& cur,\n uint64_t& cur_end) {\n std::vector gdata_vec;\n galois::runtime::gDeserialize(b, gdata_vec);\n uint64_t i = 0;\n while (cur < cur_end) {\n auto gdata = gdata_vec[i];\n uint64_t gdst = gdst_vec[i++];\n uint32_t ldst = this->G2L(gdst);\n graph.constructEdge(cur++, ldst, gdata);\n // TODO if ldst is an outgoing mirror, this is vertex cut\n }\n }\n\n template ::value>::type* = nullptr>\n void deserializeEdges(GraphTy& graph, galois::runtime::RecvBuffer&,\n std::vector& gdst_vec, uint64_t& cur,\n uint64_t& cur_end) {\n uint64_t i = 0;\n while (cur < cur_end) {\n uint64_t gdst = gdst_vec[i++];\n uint32_t ldst = this->G2L(gdst);\n graph.constructEdge(cur++, ldst);\n // TODO if ldst is an outgoing mirror, this is vertex cut\n }\n }\n};\n\n// make GRNAME visible to public\ntemplate \nconstexpr const char* const\n galois::graphs::NewDistGraphGeneric::GRNAME;\n\n} // end namespace graphs\n} // end namespace galois\n#endif\n" }, { "path": "libdist/CMakeLists.txt", "content": "add_library(galois_dist_async STATIC)\nadd_library(Galois::dist_async ALIAS galois_dist_async)\nadd_dependencies(lib galois_dist_async)\nset_target_properties(galois_dist_async PROPERTIES EXPORT_NAME dist_async)\n\ntarget_sources(galois_dist_async PRIVATE\n src/Barrier.cpp\n src/DistGalois.cpp\n src/DistStats.cpp\n src/Network.cpp\n src/NetworkBuffered.cpp\n src/NetworkIOMPI.cpp\n src/NetworkLCI.cpp\n)\n\ntarget_include_directories(galois_dist_async PUBLIC\n $\n $\n)\n\ntarget_link_libraries(galois_dist_async PUBLIC MPI::MPI_CXX)\ntarget_link_libraries(galois_dist_async PUBLIC galois_shmem)\n\ntarget_compile_definitions(galois_dist_async PRIVATE GALOIS_SUPPORT_ASYNC=1)\n\nif (GALOIS_USE_BARE_MPI)\n target_compile_definitions(galois_dist_async PRIVATE GALOIS_USE_BARE_MPI=1)\nendif()\n\nif (GALOIS_USE_LCI)\n add_definitions(-DGALOIS_USE_LCI)\n set(LCI_ROOT \"${CMAKE_BINARY_DIR}/libdist/external/src/lci\")\n set(LCI_INCLUDE \"${LCI_ROOT}/include\")\n set(LCI_LIBRARY \"${LCI_ROOT}/liblci.a\")\n\n include(ExternalProject)\n # do not clone submodules for external projects\n cmake_policy(SET CMP0097 NEW)\n\n ExternalProject_Add(lci\n PREFIX external\n BUILD_IN_SOURCE 1\n CONFIGURE_COMMAND \"\"\n INSTALL_COMMAND \"\"\n LOG_OUTPUT_ON_FAILURE 1\n GIT_REPOSITORY \"https://github.com/uiuc-hpc/LC.git\"\n GIT_SUBMODULES \"\"\n GIT_TAG \"9bf912829339879e1132614c6d24cd032c32366b\")\n\n add_dependencies(galois_dist_async lci)\n target_link_libraries(galois_dist_async PRIVATE ${LCI_LIBRARY} -lpsm2)\n target_include_directories(galois_dist_async PUBLIC \n $\n $\n )\nendif(GALOIS_USE_LCI)\n\ninstall(\n DIRECTORY include/\n DESTINATION \"${CMAKE_INSTALL_INCLUDEDIR}\"\n COMPONENT dev\n FILES_MATCHING PATTERN \"*.h\"\n)\n\ninstall(TARGETS galois_dist_async\n EXPORT GaloisTargets\n LIBRARY\n DESTINATION \"${CMAKE_INSTALL_LIBDIR}\"\n COMPONENT shlib\n ARCHIVE\n DESTINATION \"${CMAKE_INSTALL_LIBDIR}\"\n COMPONENT lib\n INCLUDES DESTINATION \"${CMAKE_INSTALL_INCLUDEDIR}\"\n)\n" }, { "path": "libdist/include/galois/DReducible.h", "content": "/*\n * This file belongs to the Galois project, a C++ library for exploiting\n * parallelism. The code is being released under the terms of the 3-Clause BSD\n * License (a copy is located in LICENSE.txt at the top-level directory).\n *\n * Copyright (C) 2018, The University of Texas at Austin. All rights reserved.\n * UNIVERSITY EXPRESSLY DISCLAIMS ANY AND ALL WARRANTIES CONCERNING THIS\n * SOFTWARE AND DOCUMENTATION, INCLUDING ANY WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR ANY PARTICULAR PURPOSE, NON-INFRINGEMENT AND WARRANTIES OF\n * PERFORMANCE, AND ANY WARRANTY THAT MIGHT OTHERWISE ARISE FROM COURSE OF\n * DEALING OR USAGE OF TRADE. NO WARRANTY IS EITHER EXPRESS OR IMPLIED WITH\n * RESPECT TO THE USE OF THE SOFTWARE OR DOCUMENTATION. Under no circumstances\n * shall University be liable for incidental, special, indirect, direct or\n * consequential damages or loss of profits, interruption of business, or\n * related expenses which may arise from use of Software or Documentation,\n * including but not limited to those resulting from defects in Software and/or\n * Documentation, or loss or inaccuracy of data of any kind.\n */\n\n/**\n * @file DReducible.h\n *\n * Implements distributed reducible objects for easy reduction of values\n * across a distributed system.\n */\n#ifndef GALOIS_DISTACCUMULATOR_H\n#define GALOIS_DISTACCUMULATOR_H\n\n#include \n#include \"galois/Galois.h\"\n#include \"galois/Reduction.h\"\n#include \"galois/AtomicHelpers.h\"\n#include \"galois/runtime/LWCI.h\"\n#include \"galois/runtime/DistStats.h\"\n\nnamespace galois {\n\n/**\n * Distributed sum-reducer for getting the sum of some value across multiple\n * hosts.\n *\n * @tparam Ty type of value to max-reduce\n */\ntemplate \nclass DGAccumulator {\n galois::runtime::NetworkInterface& net =\n galois::runtime::getSystemNetworkInterface();\n\n galois::GAccumulator mdata;\n Ty local_mdata, global_mdata;\n\n#ifdef GALOIS_USE_LCI\n /**\n * Sum reduction using LWCI\n */\n inline void reduce_lwci() {\n lc_alreduce(&local_mdata, &global_mdata, sizeof(Ty),\n &galois::runtime::internal::ompi_op_sum, lc_col_ep);\n }\n#else\n /**\n * Sum reduction using MPI\n */\n inline void reduce_mpi() {\n if (typeid(Ty) == typeid(int32_t)) {\n MPI_Allreduce(&local_mdata, &global_mdata, 1, MPI_INT, MPI_SUM,\n MPI_COMM_WORLD);\n } else if (typeid(Ty) == typeid(int64_t)) {\n MPI_Allreduce(&local_mdata, &global_mdata, 1, MPI_LONG, MPI_SUM,\n MPI_COMM_WORLD);\n } else if (typeid(Ty) == typeid(uint32_t)) {\n MPI_Allreduce(&local_mdata, &global_mdata, 1, MPI_UNSIGNED, MPI_SUM,\n MPI_COMM_WORLD);\n } else if (typeid(Ty) == typeid(uint64_t)) {\n MPI_Allreduce(&local_mdata, &global_mdata, 1, MPI_UNSIGNED_LONG, MPI_SUM,\n MPI_COMM_WORLD);\n } else if (typeid(Ty) == typeid(float)) {\n MPI_Allreduce(&local_mdata, &global_mdata, 1, MPI_FLOAT, MPI_SUM,\n MPI_COMM_WORLD);\n } else if (typeid(Ty) == typeid(double)) {\n MPI_Allreduce(&local_mdata, &global_mdata, 1, MPI_DOUBLE, MPI_SUM,\n MPI_COMM_WORLD);\n } else if (typeid(Ty) == typeid(long double)) {\n MPI_Allreduce(&local_mdata, &global_mdata, 1, MPI_LONG_DOUBLE, MPI_SUM,\n MPI_COMM_WORLD);\n } else {\n static_assert(true,\n \"Type of DGAccumulator not supported for MPI reduction\");\n }\n }\n#endif\n\npublic:\n //! Default constructor\n DGAccumulator() {}\n\n /**\n * Adds to accumulated value\n *\n * @param rhs Value to add\n * @returns reference to this object\n */\n DGAccumulator& operator+=(const Ty& rhs) {\n mdata += rhs;\n return *this;\n }\n\n /**\n * Sets current value stored in accumulator.\n *\n * @param rhs Value to set\n */\n void operator=(const Ty rhs) {\n mdata.reset();\n mdata += rhs;\n }\n\n /**\n * Sets current value stored in accumulator.\n *\n * @param rhs Value to set\n */\n void set(const Ty rhs) {\n mdata.reset();\n mdata += rhs;\n }\n\n /**\n * Read local accumulated value.\n *\n * @returns locally accumulated value\n */\n Ty read_local() {\n if (local_mdata == 0)\n local_mdata = mdata.reduce();\n return local_mdata;\n }\n\n /**\n * Read the value returned by the last reduce call.\n * Should call reduce before calling this function if an up to date\n * value is required\n *\n * @returns the value of the last reduce call\n */\n Ty read() { return global_mdata; }\n\n /**\n * Reset the entire accumulator.\n *\n * @returns the value of the last reduce call\n */\n Ty reset() {\n Ty retval = global_mdata;\n mdata.reset();\n local_mdata = global_mdata = 0;\n return retval;\n }\n\n /**\n * Reduce data across all hosts, saves the value, and returns the\n * reduced value\n *\n * @param runID optional argument used to create a statistics timer\n * for later reporting\n *\n * @returns The reduced value\n */\n Ty reduce(std::string runID = std::string()) {\n std::string timer_str(\"ReduceDGAccum_\" + runID);\n\n galois::CondStatTimer reduceTimer(timer_str.c_str(),\n \"DGReducible\");\n reduceTimer.start();\n\n if (local_mdata == 0)\n local_mdata = mdata.reduce();\n\n#ifdef GALOIS_USE_LCI\n reduce_lwci();\n#else\n reduce_mpi();\n#endif\n\n reduceTimer.stop();\n\n return global_mdata;\n }\n};\n\n////////////////////////////////////////////////////////////////////////////////\n\n/**\n * Distributed max-reducer for getting the max of some value across multiple\n * hosts.\n *\n * @tparam Ty type of value to max-reduce\n */\ntemplate \nclass DGReduceMax {\n galois::runtime::NetworkInterface& net =\n galois::runtime::getSystemNetworkInterface();\n\n galois::GReduceMax mdata; // local max reducer\n Ty local_mdata, global_mdata;\n\n#ifdef GALOIS_USE_LCI\n /**\n * Use LWCI to reduce max across hosts\n */\n inline void reduce_lwci() {\n lc_alreduce(&local_mdata, &global_mdata, sizeof(Ty),\n &galois::runtime::internal::ompi_op_max, lc_col_ep);\n }\n#else\n /**\n * Use MPI to reduce max across hosts\n */\n inline void reduce_mpi() {\n if (typeid(Ty) == typeid(int32_t)) {\n MPI_Allreduce(&local_mdata, &global_mdata, 1, MPI_INT, MPI_MAX,\n MPI_COMM_WORLD);\n } else if (typeid(Ty) == typeid(int64_t)) {\n MPI_Allreduce(&local_mdata, &global_mdata, 1, MPI_LONG, MPI_MAX,\n MPI_COMM_WORLD);\n } else if (typeid(Ty) == typeid(uint32_t)) {\n MPI_Allreduce(&local_mdata, &global_mdata, 1, MPI_UNSIGNED, MPI_MAX,\n MPI_COMM_WORLD);\n } else if (typeid(Ty) == typeid(uint64_t)) {\n MPI_Allreduce(&local_mdata, &global_mdata, 1, MPI_UNSIGNED_LONG, MPI_MAX,\n MPI_COMM_WORLD);\n } else if (typeid(Ty) == typeid(float)) {\n MPI_Allreduce(&local_mdata, &global_mdata, 1, MPI_FLOAT, MPI_MAX,\n MPI_COMM_WORLD);\n } else if (typeid(Ty) == typeid(double)) {\n MPI_Allreduce(&local_mdata, &global_mdata, 1, MPI_DOUBLE, MPI_MAX,\n MPI_COMM_WORLD);\n } else if (typeid(Ty) == typeid(long double)) {\n MPI_Allreduce(&local_mdata, &global_mdata, 1, MPI_LONG_DOUBLE, MPI_MAX,\n MPI_COMM_WORLD);\n } else {\n static_assert(true, \"Type of DGReduceMax not supported for MPI \"\n \"reduction\");\n }\n }\n#endif\n\npublic:\n /**\n * Default constructor; initializes everything to 0.\n */\n DGReduceMax() {\n local_mdata = 0;\n global_mdata = 0;\n }\n\n /**\n * Update the local max-reduced value.\n *\n * @param rhs Value to max-reduce locally with\n */\n void update(const Ty rhs) { mdata.update(rhs); }\n\n /**\n * Read the local reduced max value; if it has never been reduced, it will\n * attempt get the global value through a reduce (i.e. all other hosts\n * should call reduce as well).\n *\n * @returns the local value stored in the accumulator or a global value if\n * reduce has never been called\n */\n Ty read_local() {\n if (local_mdata == 0)\n local_mdata = mdata.reduce();\n return local_mdata;\n }\n\n /**\n * Read the global reduced max value. For accurate results, you should\n * call reduce before calling this.\n *\n * @returns the global value stored in the accumulator\n */\n Ty read() { return global_mdata; }\n\n /**\n * Reset this accumulator.\n *\n * @returns the previous global value stored in this accumulator (note if\n * never reduced, it will be 0\n */\n Ty reset() {\n Ty retval = global_mdata;\n mdata.reset();\n local_mdata = global_mdata = 0;\n return retval;\n }\n\n /**\n * Do a max reduction across all hosts by sending data to all other hosts\n * and reducing received data.\n *\n * @returns the max-reduced value after reducing from all hosts.\n */\n Ty reduce(std::string runID = std::string()) {\n std::string timer_str(\"ReduceDGReduceMax_\" + runID);\n\n galois::CondStatTimer reduceTimer(timer_str.c_str(),\n \"DGReduceMax\");\n\n reduceTimer.start();\n if (local_mdata == 0)\n local_mdata = mdata.reduce();\n\n#ifdef GALOIS_USE_LCI\n reduce_lwci();\n#else\n reduce_mpi();\n#endif\n reduceTimer.stop();\n\n return global_mdata;\n }\n};\n\n////////////////////////////////////////////////////////////////////////////////\n\n/**\n * Distributed min-reducer for getting the min of some value across multiple\n * hosts.\n *\n * @tparam Ty type of value to min-reduce\n */\ntemplate \nclass DGReduceMin {\n galois::runtime::NetworkInterface& net =\n galois::runtime::getSystemNetworkInterface();\n\n galois::GReduceMin mdata; // local min reducer\n Ty local_mdata, global_mdata;\n\n#ifdef GALOIS_USE_LCI\n /**\n * Use LWCI to reduce min across hosts\n */\n inline void reduce_lwci() {\n lc_alreduce(&local_mdata, &global_mdata, sizeof(Ty),\n &galois::runtime::internal::ompi_op_min, lc_col_ep);\n }\n#else\n /**\n * Use MPI to reduce min across hosts\n */\n inline void reduce_mpi() {\n if (typeid(Ty) == typeid(int32_t)) {\n MPI_Allreduce(&local_mdata, &global_mdata, 1, MPI_INT, MPI_MIN,\n MPI_COMM_WORLD);\n } else if (typeid(Ty) == typeid(int64_t)) {\n MPI_Allreduce(&local_mdata, &global_mdata, 1, MPI_LONG, MPI_MIN,\n MPI_COMM_WORLD);\n } else if (typeid(Ty) == typeid(uint32_t)) {\n MPI_Allreduce(&local_mdata, &global_mdata, 1, MPI_UNSIGNED, MPI_MIN,\n MPI_COMM_WORLD);\n } else if (typeid(Ty) == typeid(uint64_t)) {\n MPI_Allreduce(&local_mdata, &global_mdata, 1, MPI_UNSIGNED_LONG, MPI_MIN,\n MPI_COMM_WORLD);\n } else if (typeid(Ty) == typeid(float)) {\n MPI_Allreduce(&local_mdata, &global_mdata, 1, MPI_FLOAT, MPI_MIN,\n MPI_COMM_WORLD);\n } else if (typeid(Ty) == typeid(double)) {\n MPI_Allreduce(&local_mdata, &global_mdata, 1, MPI_DOUBLE, MPI_MIN,\n MPI_COMM_WORLD);\n } else if (typeid(Ty) == typeid(long double)) {\n MPI_Allreduce(&local_mdata, &global_mdata, 1, MPI_LONG_DOUBLE, MPI_MIN,\n MPI_COMM_WORLD);\n } else {\n static_assert(true, \"Type of DGReduceMin not supported for MPI \"\n \"reduction\");\n }\n }\n#endif\n\npublic:\n /**\n * Default constructor; initializes everything to the max value of the type.\n */\n DGReduceMin() {\n local_mdata = std::numeric_limits::max();\n global_mdata = std::numeric_limits::max();\n ;\n }\n\n /**\n * Update the local min-reduced value.\n *\n * @param rhs Value to min-reduce locally with\n */\n void update(const Ty rhs) { mdata.update(rhs); }\n\n /**\n * Read the local reduced min value; if it has never been reduced, it will\n * attempt get the global value through a reduce (i.e. all other hosts\n * should call reduce as well).\n *\n * @returns the local value stored in the accumulator or a global value if\n * reduce has never been called\n */\n Ty read_local() {\n if (local_mdata == std::numeric_limits::max())\n local_mdata = mdata.reduce();\n return local_mdata;\n }\n\n /**\n * Read the global reduced min value. For accurate results, you should\n * call reduce before calling this.\n *\n * @returns the global value stored in the accumulator\n */\n Ty read() { return global_mdata; }\n\n /**\n * Reset this accumulator.\n *\n * @returns the previous global value stored in this accumulator (note if\n * never reduced, it will be 0\n */\n Ty reset() {\n Ty retval = global_mdata;\n mdata.reset();\n local_mdata = global_mdata = std::numeric_limits::max();\n return retval;\n }\n\n /**\n * Do a min reduction across all hosts by sending data to all other hosts\n * and reducing received data.\n *\n * @returns the min-reduced value after reducing from all hosts.\n */\n Ty reduce(std::string runID = std::string()) {\n std::string timer_str(\"ReduceDGReduceMin_\" + runID);\n\n galois::CondStatTimer reduceTimer(timer_str.c_str(),\n \"DGReduceMin\");\n\n reduceTimer.start();\n if (local_mdata == std::numeric_limits::max())\n local_mdata = mdata.reduce();\n\n#ifdef GALOIS_USE_LCI\n reduce_lwci();\n#else\n reduce_mpi();\n#endif\n reduceTimer.stop();\n\n return global_mdata;\n }\n};\n\n} // namespace galois\n#endif\n" }, { "path": "libdist/include/galois/DTerminationDetector.h", "content": "/*\n * This file belongs to the Galois project, a C++ library for exploiting\n * parallelism. The code is being released under the terms of the 3-Clause BSD\n * License (a copy is located in LICENSE.txt at the top-level directory).\n *\n * Copyright (C) 2018, The University of Texas at Austin. All rights reserved.\n * UNIVERSITY EXPRESSLY DISCLAIMS ANY AND ALL WARRANTIES CONCERNING THIS\n * SOFTWARE AND DOCUMENTATION, INCLUDING ANY WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR ANY PARTICULAR PURPOSE, NON-INFRINGEMENT AND WARRANTIES OF\n * PERFORMANCE, AND ANY WARRANTY THAT MIGHT OTHERWISE ARISE FROM COURSE OF\n * DEALING OR USAGE OF TRADE. NO WARRANTY IS EITHER EXPRESS OR IMPLIED WITH\n * RESPECT TO THE USE OF THE SOFTWARE OR DOCUMENTATION. Under no circumstances\n * shall University be liable for incidental, special, indirect, direct or\n * consequential damages or loss of profits, interruption of business, or\n * related expenses which may arise from use of Software or Documentation,\n * including but not limited to those resulting from defects in Software and/or\n * Documentation, or loss or inaccuracy of data of any kind.\n */\n\n/**\n * @file DReducible.h\n *\n * Implements distributed reducible objects for easy reduction of values\n * across a distributed system.\n */\n#ifndef GALOIS_DISTTERMINATOR_H\n#define GALOIS_DISTTERMINATOR_H\n\n#include \n#include \"galois/Galois.h\"\n#include \"galois/Reduction.h\"\n#include \"galois/AtomicHelpers.h\"\n#include \"galois/runtime/LWCI.h\"\n#include \"galois/runtime/DistStats.h\"\n\nnamespace galois {\n\n/**\n * Distributed sum-reducer for getting the sum of some value across multiple\n * hosts.\n *\n * @tparam Ty type of value to max-reduce\n */\ntemplate \nclass DGTerminator {\n galois::runtime::NetworkInterface& net =\n galois::runtime::getSystemNetworkInterface();\n\n galois::GAccumulator mdata;\n Ty local_mdata, global_mdata;\n\n uint64_t prev_snapshot;\n uint64_t snapshot;\n uint64_t global_snapshot;\n bool work_done;\n#ifndef GALOIS_USE_LCI\n MPI_Request snapshot_request;\n#else\n lc_colreq snapshot_request;\n#endif\n\npublic:\n //! Default constructor\n DGTerminator() {\n reinitialize();\n initiate_snapshot();\n reset();\n }\n\n void reinitialize() {\n prev_snapshot = 0;\n snapshot = 1;\n global_snapshot = 1;\n work_done = false;\n }\n\n /**\n * Adds to accumulated value\n *\n * @param rhs Value to add\n * @returns reference to this object\n */\n DGTerminator& operator+=(const Ty& rhs) {\n mdata += rhs;\n return *this;\n }\n\n /**\n * Sets current value stored in accumulator.\n *\n * @param rhs Value to set\n */\n void operator=(const Ty rhs) {\n mdata.reset();\n mdata += rhs;\n }\n\n /**\n * Sets current value stored in accumulator.\n *\n * @param rhs Value to set\n */\n void set(const Ty rhs) {\n mdata.reset();\n mdata += rhs;\n }\n\n /**\n * Read local accumulated value.\n *\n * @returns locally accumulated value\n */\n Ty read_local() {\n if (local_mdata == 0)\n local_mdata = mdata.reduce();\n return local_mdata;\n }\n\n /**\n * Read the value returned by the last reduce call.\n * Should call reduce before calling this function if an up to date\n * value is required\n *\n * @returns the value of the last reduce call\n */\n Ty read() { return global_mdata; }\n\n /**\n * Reset the entire accumulator.\n *\n * @returns the value of the last reduce call\n */\n Ty reset() {\n Ty retval = global_mdata;\n mdata.reset();\n local_mdata = global_mdata = 0;\n return retval;\n }\n\n void initiate_snapshot() {\n#ifdef GALOIS_USE_LCI\n lc_ialreduce(&snapshot, &global_snapshot, sizeof(Ty),\n &galois::runtime::internal::ompi_op_max, lc_col_ep,\n &snapshot_request);\n#else\n MPI_Iallreduce(&snapshot, &global_snapshot, 1, MPI_UNSIGNED_LONG, MPI_MAX,\n MPI_COMM_WORLD, &snapshot_request);\n#endif\n }\n\n bool terminate() {\n bool active = (local_mdata != 0);\n if (!active) {\n active = net.anyPendingSends();\n }\n int snapshot_ended = 0;\n if (!active) {\n#ifndef GALOIS_USE_LCI\n MPI_Test(&snapshot_request, &snapshot_ended, MPI_STATUS_IGNORE);\n#else\n lc_col_progress(&snapshot_request);\n snapshot_ended = snapshot_request.flag;\n#endif\n }\n if (!active) { // check pending receives after checking snapshot\n active = net.anyPendingReceives();\n if (active)\n galois::gDebug(\"[\", net.ID, \"] pending receive\");\n }\n if (active) {\n work_done = true;\n } else {\n if (snapshot_ended != 0) {\n snapshot = global_snapshot;\n if (work_done) {\n work_done = false;\n prev_snapshot = snapshot;\n ++snapshot;\n galois::gDebug(\"[\", net.ID, \"] work done, taking snapshot \",\n snapshot);\n initiate_snapshot();\n } else if (prev_snapshot != snapshot) {\n prev_snapshot = snapshot;\n galois::gDebug(\"[\", net.ID, \"] no work done, taking snapshot \",\n snapshot);\n initiate_snapshot();\n } else {\n galois::gDebug(\"[\", net.ID, \"] terminating \", snapshot);\n // an explicit barrier may be required here\n // so that the next async phase begins on all hosts at the same time\n // however, this may add overheads when it is not required\n // (depending on when the next async phase actually begins), so\n // ASSUME: caller will call getHostBarrier().wait() if required\n reinitialize(); // for next async phase\n return true;\n }\n }\n }\n return false;\n }\n\n /**\n * Reduce data across all hosts, saves the value, and returns the\n * reduced value\n *\n * @param runID optional argument used to create a statistics timer\n * for later reporting\n *\n * @returns The reduced value\n */\n Ty reduce(std::string runID = std::string()) {\n std::string timer_str(\"ReduceDGAccum_\" + runID);\n\n galois::CondStatTimer reduceTimer(timer_str.c_str(),\n \"DGReducible\");\n reduceTimer.start();\n\n if (local_mdata == 0)\n local_mdata = mdata.reduce();\n\n bool halt = terminate();\n global_mdata = !halt;\n if (halt) {\n galois::runtime::evilPhase += 2; // one for reduce and one for broadcast\n if (galois::runtime::evilPhase >=\n static_cast(\n std::numeric_limits::max())) { // limit defined by MPI or\n // LCI\n galois::runtime::evilPhase = 1;\n }\n }\n\n reduceTimer.stop();\n\n return global_mdata;\n }\n};\n\n} // namespace galois\n#endif\n" }, { "path": "libdist/include/galois/DistGalois.h", "content": "/*\n * This file belongs to the Galois project, a C++ library for exploiting\n * parallelism. The code is being released under the terms of the 3-Clause BSD\n * License (a copy is located in LICENSE.txt at the top-level directory).\n *\n * Copyright (C) 2018, The University of Texas at Austin. All rights reserved.\n * UNIVERSITY EXPRESSLY DISCLAIMS ANY AND ALL WARRANTIES CONCERNING THIS\n * SOFTWARE AND DOCUMENTATION, INCLUDING ANY WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR ANY PARTICULAR PURPOSE, NON-INFRINGEMENT AND WARRANTIES OF\n * PERFORMANCE, AND ANY WARRANTY THAT MIGHT OTHERWISE ARISE FROM COURSE OF\n * DEALING OR USAGE OF TRADE. NO WARRANTY IS EITHER EXPRESS OR IMPLIED WITH\n * RESPECT TO THE USE OF THE SOFTWARE OR DOCUMENTATION. Under no circumstances\n * shall University be liable for incidental, special, indirect, direct or\n * consequential damages or loss of profits, interruption of business, or\n * related expenses which may arise from use of Software or Documentation,\n * including but not limited to those resulting from defects in Software and/or\n * Documentation, or loss or inaccuracy of data of any kind.\n */\n\n/**\n * @file DistGalois.h\n *\n * Contains the declaration of DistMemSys, a way to explicitly initiate the\n * Galois runtime.\n */\n#ifndef GALOIS_DIST_GALOIS_H\n#define GALOIS_DIST_GALOIS_H\n\n#include \"galois/runtime/SharedMem.h\"\n#include \"galois/runtime/DistStats.h\"\n\n#include \n#include \n#include \n\nnamespace galois {\n/**\n * Explicit class to initialize the Galois Runtime.\n * The runtime is destroyed when this object is destroyed\n */\nclass DistMemSys : public runtime::SharedMem {\npublic:\n explicit DistMemSys();\n\n ~DistMemSys();\n\n DistMemSys(const DistMemSys&) = delete;\n DistMemSys& operator=(const DistMemSys&) = delete;\n\n DistMemSys(DistMemSys&&) = delete;\n DistMemSys& operator=(DistMemSys&&) = delete;\n};\n\n} // namespace galois\n#endif\n" }, { "path": "libdist/include/galois/runtime/BareMPI.h", "content": "/*\n * This file belongs to the Galois project, a C++ library for exploiting\n * parallelism. The code is being released under the terms of the 3-Clause BSD\n * License (a copy is located in LICENSE.txt at the top-level directory).\n *\n * Copyright (C) 2018, The University of Texas at Austin. All rights reserved.\n * UNIVERSITY EXPRESSLY DISCLAIMS ANY AND ALL WARRANTIES CONCERNING THIS\n * SOFTWARE AND DOCUMENTATION, INCLUDING ANY WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR ANY PARTICULAR PURPOSE, NON-INFRINGEMENT AND WARRANTIES OF\n * PERFORMANCE, AND ANY WARRANTY THAT MIGHT OTHERWISE ARISE FROM COURSE OF\n * DEALING OR USAGE OF TRADE. NO WARRANTY IS EITHER EXPRESS OR IMPLIED WITH\n * RESPECT TO THE USE OF THE SOFTWARE OR DOCUMENTATION. Under no circumstances\n * shall University be liable for incidental, special, indirect, direct or\n * consequential damages or loss of profits, interruption of business, or\n * related expenses which may arise from use of Software or Documentation,\n * including but not limited to those resulting from defects in Software and/or\n * Documentation, or loss or inaccuracy of data of any kind.\n */\n\n/*\n */\n\n/**\n * @file BareMPI.h\n *\n * Contains the BareMPI enum and the command line option that controls bare\n * MPI usage.\n */\n#pragma once\n#ifdef GALOIS_USE_BARE_MPI\n#include \"mpi.h\"\n\n//! Defines types of bare MPI to use\nenum BareMPI {\n noBareMPI, //!< do not use bare MPI; use our network layer\n nonBlockingBareMPI, //!< non blocking bare MPI\n oneSidedBareMPI //!< one sided bare MPI\n};\n#endif\n" }, { "path": "libdist/include/galois/runtime/DistStats.h", "content": "/*\n * This file belongs to the Galois project, a C++ library for exploiting\n * parallelism. The code is being released under the terms of the 3-Clause BSD\n * License (a copy is located in LICENSE.txt at the top-level directory).\n *\n * Copyright (C) 2018, The University of Texas at Austin. All rights reserved.\n * UNIVERSITY EXPRESSLY DISCLAIMS ANY AND ALL WARRANTIES CONCERNING THIS\n * SOFTWARE AND DOCUMENTATION, INCLUDING ANY WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR ANY PARTICULAR PURPOSE, NON-INFRINGEMENT AND WARRANTIES OF\n * PERFORMANCE, AND ANY WARRANTY THAT MIGHT OTHERWISE ARISE FROM COURSE OF\n * DEALING OR USAGE OF TRADE. NO WARRANTY IS EITHER EXPRESS OR IMPLIED WITH\n * RESPECT TO THE USE OF THE SOFTWARE OR DOCUMENTATION. Under no circumstances\n * shall University be liable for incidental, special, indirect, direct or\n * consequential damages or loss of profits, interruption of business, or\n * related expenses which may arise from use of Software or Documentation,\n * including but not limited to those resulting from defects in Software and/or\n * Documentation, or loss or inaccuracy of data of any kind.\n */\n\n/**\n * @file DistStats.h\n *\n * Contains declaration of DistStatManager, which reports runtime statistics of\n * a distributed application in Galois.\n */\n\n#ifndef GALOIS_RUNTIME_DIST_STATS_H\n#define GALOIS_RUNTIME_DIST_STATS_H\n\n//! Turn on if you want more distributed stats to be printed\n#ifndef MORE_DIST_STATS\n#define MORE_DIST_STATS 0\n#endif\n//! Turn on if you want more communication statistics to be printed\n#ifndef GALOIS_COMM_STATS\n#define GALOIS_COMM_STATS 0\n#endif\n//! Turn on if you want per-bulk-synchronous parallel timers to be printed\n//! (otherwise all rounds are under 1 timer)\n#ifndef GALOIS_PER_ROUND_STATS\n#define GALOIS_PER_ROUND_STATS 0\n#endif\n\n#include \"galois/runtime/Statistics.h\"\n#include \"galois/runtime/Network.h\"\n\n#include \n\nnamespace galois {\nnamespace runtime {\n\n/**\n * Helper class for the DistStatManager that aids in receiving statistics\n */\nclass StatRecvHelper;\n\n/**\n * Class responsible for tracking all statistics of a running distributed\n * Galois program and reporting them at the end of program execution.\n */\nclass DistStatManager : public galois::runtime::StatManager {\n //! Friend class that helps with receiving stats\n friend class galois::runtime::StatRecvHelper;\n using Base = galois::runtime::StatManager;\n using Str = galois::gstl::Str;\n using Base::SEP;\n\n static constexpr const char* const HSTAT_SEP = Base::TSTAT_SEP;\n static constexpr const char* const HSTAT_NAME = \"HostValues\";\n static constexpr const char* const HSTAT_ENV_VAR = \"PRINT_PER_HOST_STATS\";\n\n static bool printingHostVals(void);\n\n template \n struct HostTotalTypesImpl {\n struct DummyStat {\n StatTotal::Type m_totalTy;\n\n explicit DummyStat(StatTotal::Type total) : m_totalTy(total) {}\n\n template \n void add(const _U&) const {}\n\n const StatTotal::Type& totalTy(void) const { return m_totalTy; }\n };\n\n using TMap = internal::BasicStatMap;\n\n bool merged = false;\n substrate::PerThreadStorage perThrdMap;\n\n void addToStat(const Str& region, const Str& category,\n const StatTotal::Type& hTotalTy) {\n perThrdMap.getLocal()->addToStat(region, category, 0, hTotalTy);\n }\n\n void mergeStats(void) {\n if (merged) {\n return;\n }\n GALOIS_ASSERT(perThrdMap.getLocal() == perThrdMap.getRemote(0),\n \"Must call from Thread 0\");\n\n auto* t0Map = perThrdMap.getRemote(0);\n\n for (unsigned t = 1; t < perThrdMap.size(); ++t) {\n const auto* manager = perThrdMap.getRemote(t);\n\n for (auto i = manager->cbegin(), end_i = manager->cend(); i != end_i;\n ++i) {\n t0Map->addToStat(manager->region(i), manager->category(i), 0,\n manager->stat(i).totalTy());\n }\n }\n\n merged = true;\n }\n\n const TMap& mergedMap(void) const {\n assert(merged && \"Must merge first\");\n return *perThrdMap.getRemote(0);\n }\n };\n\n using HostTotalTypes = HostTotalTypesImpl<>;\n\n template \n using ThrdVals = galois::gstl::Vector;\n\n template \n using HostStatVal =\n std::tuple&>;\n\n template \n struct HostStat : public internal::VecStat {\n using Base = internal::VecStat;\n using ThrdStats = internal::VecStat;\n using PerHostThrdStats = galois::gstl::Map;\n\n PerHostThrdStats perHostThrdStats;\n\n explicit HostStat(const StatTotal::Type& hTotalTy) : Base(hTotalTy) {}\n\n void add(const HostStatVal& val) {\n const auto& hostID = std::get<0>(val);\n const auto& thrdTotal = std::get<1>(val);\n const auto& thrdTotalTy = std::get<2>(val);\n const auto& thrdVals = std::get<3>(val);\n\n Base::add(thrdTotal);\n\n auto p = perHostThrdStats.emplace(hostID, ThrdStats(thrdTotalTy));\n auto& tstat = p.first->second;\n\n for (const auto& i : thrdVals) {\n tstat.add(i);\n }\n }\n\n void printHostVals(std::ostream& out, const Str& region,\n const Str& category) const {\n out << StatManager::statKind() << SEP << galois::runtime::getHostID()\n << SEP;\n out << region << SEP << category << SEP;\n out << HSTAT_NAME << SEP;\n\n const char* sep = \"\";\n\n for (const auto& v : Base::values()) {\n out << sep << v;\n sep = HSTAT_SEP;\n }\n\n out << std::endl;\n }\n\n void printThreadVals(std::ostream& out, const Str& region,\n const Str& category) const {\n for (const auto& p : perHostThrdStats) {\n out << StatManager::statKind() << SEP << p.first << SEP;\n out << region << SEP << category << SEP;\n out << StatTotal::str(p.second.totalTy()) << SEP << p.second.total();\n out << std::endl;\n\n out << StatManager::statKind() << SEP << p.first << SEP;\n out << region << SEP << category << SEP;\n out << StatManager::TSTAT_NAME << SEP;\n\n const char* sep = \"\";\n for (const auto& v : p.second.values()) {\n out << sep << v;\n sep = StatManager::TSTAT_SEP;\n }\n\n out << std::endl;\n }\n }\n };\n\n template \n struct DistStatCombiner : public internal::BasicStatMap> {\n using Base = internal::BasicStatMap>;\n\n#if __GNUC__ < 5\n static const char* htotalName(const StatTotal::Type& type){\n#else\n static constexpr const char* htotalName(const StatTotal::Type& type) {\n#endif\n switch (type) {\n case StatTotal::SINGLE : return \"HOST_0\";\n case StatTotal::TSUM:\n return \"HSUM\";\n case StatTotal::TAVG:\n return \"HAVG\";\n case StatTotal::TMIN:\n return \"HMIN\";\n case StatTotal::TMAX:\n return \"HMAX\";\n default:\n std::abort();\n return nullptr;\n }\n}\n\n void print(std::ostream& out) const {\n for (auto i = Base::cbegin(), end_i = Base::cend(); i != end_i; ++i) {\n out << StatManager::statKind() << SEP << galois::runtime::getHostID()\n << SEP;\n out << Base::region(i) << SEP << Base::category(i) << SEP;\n\n const HostStat& hs = Base::stat(i);\n\n out << htotalName(hs.totalTy()) << SEP << hs.total();\n out << std::endl;\n\n if (DistStatManager::printingHostVals()) {\n hs.printHostVals(out, Base::region(i), Base::category(i));\n }\n\n if (StatManager::printingThreadVals()) {\n hs.printThreadVals(out, Base::region(i), Base::category(i));\n }\n }\n}\n}; // namespace runtime\n\nDistStatCombiner intDistStats;\nDistStatCombiner fpDistStats;\nDistStatCombiner strDistStats;\nHostTotalTypes hostTotalTypes;\n\nprotected:\n/**\n * Merge all stats from each individual thread as well as each individual\n * host as prescribed the the reduction (Total) type specified for each\n * statistic.\n */\nvoid mergeStats(void);\n\n/**\n * Print the header of the stats file output.\n *\n * @param out File to print header out to\n */\nvoid printHeader(std::ostream& out) const;\n\n/**\n * Merge all stats. Host 0 will then print out all collected stats.\n */\nvirtual void printStats(std::ostream& out);\n\npublic:\n//! Dist stat manager constructor\nDistStatManager(const std::string& outfile = \"\");\n~DistStatManager();\n\n/**\n * Adds a statistic to the statistics manager.\n *\n * @param region Region name to give statistic\n * @param category Category of statistic\n * @param val Value of the statistic\n * @param thrdTotalTy The type of reduction used to combine thread statistics\n * of the same kind\n * @param hTotalTy The type of reduction used to combine host statistics\n * of the same kind\n */\ntemplate \nvoid addToStat(const Str& region, const Str& category, const T& val,\n const StatTotal::Type& thrdTotalTy,\n const StatTotal::Type& hTotalTy) {\n Base::addToStat(region, category, val, thrdTotalTy);\n hostTotalTypes.addToStat(region, category, hTotalTy);\n}\n\nprivate:\nvoid combineAtHost_0_helper(void);\nvoid combineAtHost_0_helper2(void);\nvoid receiveAtHost_0_helper(void);\nvoid receiveAtHost_0_helper2(void);\nvoid combineAtHost_0(void);\nStatTotal::Type findHostTotalTy(const Str& region, const Str& category,\n const StatTotal::Type& thrdTotalTy) const;\nvoid addRecvdHostTotalTy(const Str& region, const Str& category,\n const StatTotal::Type& totalTy);\nvoid addRecvdStat(unsigned hostID, const Str& region, const Str& category,\n int64_t thrdTotal, const StatTotal::Type& thrdTotalTy,\n const ThrdVals& thrdVals);\nvoid addRecvdStat(unsigned hostID, const Str& region, const Str& category,\n double thrdTotal, const StatTotal::Type& thrdTotalTy,\n const ThrdVals& thrdVals);\nvoid addRecvdParam(unsigned hostID, const Str& region, const Str& category,\n const Str& thrdTotal, const StatTotal::Type& thrdTotalTy,\n const ThrdVals& thrdVals);\n}; // namespace galois\n\nnamespace internal {\n/**\n * Gets a pointer to the distributed stat manager.\n *\n * @returns Pointer to distributed statistics manager\n */\nDistStatManager* distSysStatManager(void);\n} // namespace internal\n\n/**\n * Adds a statistic to the statistics manager. Calls addToStat in\n * DistStatManager.\n *\n * @param region Region name to give statistic\n * @param category Category of statistic\n * @param value Value of the statistic\n * @param thrdTotalTy The type of reduction used to combine thread statistics\n * of the same kind\n * @param hTotalTy The type of reduction used to combine host statistics\n * of the same kind\n */\ntemplate \ninline void reportDistStat(const S1& region, const S2& category, const T& value,\n const StatTotal::Type& thrdTotalTy,\n const StatTotal::Type& hTotalTy) {\n internal::distSysStatManager()->addToStat(gstl::makeStr(region),\n gstl::makeStr(category), value,\n thrdTotalTy, hTotalTy);\n}\n\n} // end namespace runtime\n} // end namespace galois\n\n#endif // GALOIS_RUNTIME_DIST_STATS_H\n" }, { "path": "libdist/include/galois/runtime/LWCI.h", "content": "/*\n * This file belongs to the Galois project, a C++ library for exploiting\n * parallelism. The code is being released under the terms of the 3-Clause BSD\n * License (a copy is located in LICENSE.txt at the top-level directory).\n *\n * Copyright (C) 2018, The University of Texas at Austin. All rights reserved.\n * UNIVERSITY EXPRESSLY DISCLAIMS ANY AND ALL WARRANTIES CONCERNING THIS\n * SOFTWARE AND DOCUMENTATION, INCLUDING ANY WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR ANY PARTICULAR PURPOSE, NON-INFRINGEMENT AND WARRANTIES OF\n * PERFORMANCE, AND ANY WARRANTY THAT MIGHT OTHERWISE ARISE FROM COURSE OF\n * DEALING OR USAGE OF TRADE. NO WARRANTY IS EITHER EXPRESS OR IMPLIED WITH\n * RESPECT TO THE USE OF THE SOFTWARE OR DOCUMENTATION. Under no circumstances\n * shall University be liable for incidental, special, indirect, direct or\n * consequential damages or loss of profits, interruption of business, or\n * related expenses which may arise from use of Software or Documentation,\n * including but not limited to those resulting from defects in Software and/or\n * Documentation, or loss or inaccuracy of data of any kind.\n */\n\n/**\n * @file LWCI.h\n *\n * LWCI header that includes lc.h (LCI library) and internal helper functions\n * on arrays.\n */\n\n#pragma once\n#ifdef GALOIS_USE_LCI\nGALOIS_IGNORE_UNUSED_PARAMETERS\n#include \"lc.h\"\nGALOIS_END_IGNORE_UNUSED_PARAMETERS\n\nextern lc_ep lc_col_ep;\nextern lc_ep lc_p2p_ep[3];\n\nnamespace galois {\nnamespace runtime {\nnamespace internal {\n\n/**\n * Element-wise sum of 2 arrays.\n *\n * @tparam Ty type of elements contained in the arrays\n *\n * @param dst destination array to write to\n * @param src source array to read from\n * @param count Size of array in bytes\n */\ntemplate \nvoid ompi_op_sum(void* dst, void* src, size_t count) {\n Ty* dst_ty = (Ty*)dst;\n Ty* src_ty = (Ty*)src;\n for (size_t i = 0; i < (count / sizeof(Ty)); ++i) {\n dst_ty[i] += src_ty[i];\n }\n}\n\n/**\n * Element-wise max of 2 arrays.\n *\n * @tparam Ty type of elements contained in the arrays\n *\n * @param dst destination array to write to\n * @param src source array to read from\n * @param count Size of array in bytes\n */\ntemplate \nvoid ompi_op_max(void* dst, void* src, size_t count) {\n Ty* dst_ty = (Ty*)dst;\n Ty* src_ty = (Ty*)src;\n for (size_t i = 0; i < (count / sizeof(Ty)); ++i) {\n if (dst_ty[i] < src_ty[i]) {\n dst_ty[i] = src_ty[i];\n }\n }\n}\n\n/**\n * Element-wise min of 2 arrays.\n *\n * @tparam Ty type of elements contained in the arrays\n *\n * @param dst destination array to write to\n * @param src source array to read from\n * @param count Size of array in bytes\n */\ntemplate \nvoid ompi_op_min(void* dst, void* src, size_t count) {\n Ty* dst_ty = (Ty*)dst;\n Ty* src_ty = (Ty*)src;\n for (size_t i = 0; i < (count / sizeof(Ty)); ++i) {\n if (dst_ty[i] > src_ty[i]) {\n dst_ty[i] = src_ty[i];\n }\n }\n}\n\n} // namespace internal\n} // namespace runtime\n} // namespace galois\n#endif\n" }, { "path": "libdist/include/galois/runtime/MemUsage.h", "content": "/*\n * This file belongs to the Galois project, a C++ library for exploiting\n * parallelism. The code is being released under the terms of the 3-Clause BSD\n * License (a copy is located in LICENSE.txt at the top-level directory).\n *\n * Copyright (C) 2018, The University of Texas at Austin. All rights reserved.\n * UNIVERSITY EXPRESSLY DISCLAIMS ANY AND ALL WARRANTIES CONCERNING THIS\n * SOFTWARE AND DOCUMENTATION, INCLUDING ANY WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR ANY PARTICULAR PURPOSE, NON-INFRINGEMENT AND WARRANTIES OF\n * PERFORMANCE, AND ANY WARRANTY THAT MIGHT OTHERWISE ARISE FROM COURSE OF\n * DEALING OR USAGE OF TRADE. NO WARRANTY IS EITHER EXPRESS OR IMPLIED WITH\n * RESPECT TO THE USE OF THE SOFTWARE OR DOCUMENTATION. Under no circumstances\n * shall University be liable for incidental, special, indirect, direct or\n * consequential damages or loss of profits, interruption of business, or\n * related expenses which may arise from use of Software or Documentation,\n * including but not limited to those resulting from defects in Software and/or\n * Documentation, or loss or inaccuracy of data of any kind.\n */\n\n/*\n */\n\n/**\n * @file MemUsage.h\n *\n * Contains MemUsageTracker, a class that tracks memory usage throughout\n * runtime of a program of send/receive buffers.\n */\n\n#pragma once\n#include \nnamespace galois {\nnamespace runtime {\n\n/**\n * Class that tracks memory usage (mainly of send and receive buffers).\n */\nclass MemUsageTracker {\n std::atomic\n currentMemUsage; //!< mem usage of send and receive buffers\n int64_t maxMemUsage; //!< max mem usage of send and receive buffers\n\npublic:\n //! Default constructor initializes everything to 0.\n MemUsageTracker() : currentMemUsage(0), maxMemUsage(0) {}\n\n /**\n * Increment memory usage.\n *\n * @param size amount to increment mem usage by\n */\n inline void incrementMemUsage(uint64_t size) {\n currentMemUsage += size;\n if (currentMemUsage > maxMemUsage)\n maxMemUsage = currentMemUsage;\n }\n\n /**\n * Decrement memory usage.\n *\n * @param size amount to decrement mem usage by\n */\n inline void decrementMemUsage(uint64_t size) { currentMemUsage -= size; }\n\n /**\n * Reset mem usage and max mem usage to 0.\n */\n inline void resetMemUsage() {\n currentMemUsage = 0;\n maxMemUsage = 0;\n }\n\n /**\n * Get max mem usage.\n *\n * @returns maximum memory usage tracked so far\n */\n inline int64_t getMaxMemUsage() const { return maxMemUsage; }\n};\n\n} // namespace runtime\n} // namespace galois\n" }, { "path": "libdist/include/galois/runtime/Network.h", "content": "/*\n * This file belongs to the Galois project, a C++ library for exploiting\n * parallelism. The code is being released under the terms of the 3-Clause BSD\n * License (a copy is located in LICENSE.txt at the top-level directory).\n *\n * Copyright (C) 2018, The University of Texas at Austin. All rights reserved.\n * UNIVERSITY EXPRESSLY DISCLAIMS ANY AND ALL WARRANTIES CONCERNING THIS\n * SOFTWARE AND DOCUMENTATION, INCLUDING ANY WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR ANY PARTICULAR PURPOSE, NON-INFRINGEMENT AND WARRANTIES OF\n * PERFORMANCE, AND ANY WARRANTY THAT MIGHT OTHERWISE ARISE FROM COURSE OF\n * DEALING OR USAGE OF TRADE. NO WARRANTY IS EITHER EXPRESS OR IMPLIED WITH\n * RESPECT TO THE USE OF THE SOFTWARE OR DOCUMENTATION. Under no circumstances\n * shall University be liable for incidental, special, indirect, direct or\n * consequential damages or loss of profits, interruption of business, or\n * related expenses which may arise from use of Software or Documentation,\n * including but not limited to those resulting from defects in Software and/or\n * Documentation, or loss or inaccuracy of data of any kind.\n */\n\n/**\n * @file Network.h\n *\n * Contains the network interface class which is the base class for all\n * network layer implementations.\n */\n\n#ifndef GALOIS_RUNTIME_NETWORK_H\n#define GALOIS_RUNTIME_NETWORK_H\n\n#include \"galois/runtime/Serialize.h\"\n#include \"galois/runtime/MemUsage.h\"\n#include \"galois/substrate/Barrier.h\"\n\n#include \n\n#include \n#include \n#include \n\nnamespace galois::runtime {\n\n//! typedef for buffer that stores data to be sent out\nusing SendBuffer = SerializeBuffer;\n//! typedef for buffer that received data is saved into\nusing RecvBuffer = DeSerializeBuffer;\n\n/**\n * A class that defines functions that a network interface in Galois should\n * have. How the sends/recvs/stat-collecting happens as well\n * as the network layer itself is up to the implemention of the class.\n */\nclass NetworkInterface {\nprotected:\n //! Initialize the MPI system. Should only be called once per process.\n void initializeMPI();\n\n //! Finalize the MPI system. Should only be called once per process.\n void finalizeMPI();\n\n //! Memory usage tracker\n MemUsageTracker memUsageTracker;\n\n //! Number of inflight sends and receives\n std::atomic inflightSends;\n std::atomic inflightRecvs;\n\n#ifdef GALOIS_USE_BARE_MPI\npublic:\n //! Wrapper that calls into increment mem usage on the memory usage tracker\n inline void incrementMemUsage(uint64_t size) {\n memUsageTracker.incrementMemUsage(size);\n }\n //! Wrapper that calls into decrement mem usage on the memory usage tracker\n inline void decrementMemUsage(uint64_t size) {\n memUsageTracker.decrementMemUsage(size);\n }\n#endif\n\npublic:\n //! This machine's host ID\n static uint32_t ID;\n //! The total number of machines in the current program\n static uint32_t Num;\n\n /**\n * Constructor for interface.\n */\n NetworkInterface();\n\n /**\n * Destructor destroys MPI (if it exists).\n */\n virtual ~NetworkInterface();\n\n //! Send a message to a given (dest) host. A message is simply a\n //! landing pad (recv, funciton pointer) and some data (buf)\n //! on the receiver, recv(buf) will be called durring handleReceives()\n //! buf is invalidated by this operation\n void sendMsg(uint32_t dest, void (*recv)(uint32_t, RecvBuffer&),\n SendBuffer& buf);\n\n //! Send a message letting the network handle the serialization and\n //! deserialization slightly slower\n template \n void sendSimple(uint32_t dest, void (*recv)(uint32_t, Args...),\n Args... param);\n\n //! Send a message to a given (dest) host. A message is simply a\n //! tag (tag) and some data (buf)\n //! on the receiver, buf will be returned on a receiveTagged(tag)\n //! buf is invalidated by this operation\n virtual void sendTagged(uint32_t dest, uint32_t tag, SendBuffer& buf,\n int type = 0) = 0;\n\n //! Send a message to all hosts. A message is simply a\n //! landing pad (recv) and some data (buf)\n //! buf is invalidated by this operation\n void broadcast(void (*recv)(uint32_t, RecvBuffer&), SendBuffer& buf,\n bool self = false);\n\n //! Broadcast a message allowing the network to handle serialization and\n //! deserialization\n template \n void broadcastSimple(void (*recv)(uint32_t, Args...), Args... param);\n\n //! Receive and dispatch messages\n void handleReceives();\n\n //! Wrapper to reset the mem usage tracker's stats\n inline void resetMemUsage() { memUsageTracker.resetMemUsage(); }\n\n //! Reports the memory usage tracker's statistics to the stat manager\n void reportMemUsage() const;\n\n //! Receive a tagged message\n virtual std::optional>\n recieveTagged(uint32_t tag, std::unique_lock* rlg,\n int type = 0) = 0;\n\n //! move send buffers out to network\n virtual void flush() = 0;\n\n //! @returns true if any send is in progress or is pending to be enqueued\n virtual bool anyPendingSends() = 0;\n\n //! @returns true if any receive is in progress or is pending to be dequeued\n virtual bool anyPendingReceives() = 0;\n\n //! Get how many bytes were sent\n //! @returns num bytes sent\n virtual unsigned long reportSendBytes() const = 0;\n //! Get how many messages were sent\n //! @returns num messages sent\n virtual unsigned long reportSendMsgs() const = 0;\n //! Get how many bytes were received\n //! @returns num bytes received\n virtual unsigned long reportRecvBytes() const = 0;\n //! Get how many messages were received\n //! @returns num messages received\n virtual unsigned long reportRecvMsgs() const = 0;\n //! Get any other extra statistics that might need to be reported; varies\n //! depending on implementation\n //! @returns vector of extra things to be reported\n virtual std::vector reportExtra() const = 0;\n //! Get the names of the extra things that are returned by reportExtra\n //! @returns vector of the names of the reported extra things\n virtual std::vector>\n reportExtraNamed() const = 0;\n};\n\n//! Variable that keeps track of which network send/recv phase a program is\n//! currently on. Can be seen as a count of send/recv rounds that have occured.\nextern uint32_t evilPhase;\n\n//! Get the network interface\n//! @returns network interface\nNetworkInterface& getSystemNetworkInterface();\n\nnamespace internal {\n//! Deletes the system network interface (if it exists).\nvoid destroySystemNetworkInterface();\n} // namespace internal\n\n//! Gets this host's ID\n//! @returns ID of this host\nuint32_t getHostID();\n\n//! Returns a BufferedNetwork interface\nNetworkInterface& makeNetworkBuffered();\n\n//! Returns a LCINetwork interface\nNetworkInterface& makeNetworkLCI();\n\n//! Returns a host barrier, which is a regular MPI-Like Barrier for all hosts.\n//! @warning Should not be called within a parallel region; assumes only one\n//! thread is calling it\nsubstrate::Barrier& getHostBarrier();\n//! Returns a fence that ensures all pending messages are delivered, acting\n//! like a memory-barrier\nsubstrate::Barrier& getHostFence();\n\n////////////////////////////////////////////////////////////////////////////////\n// Implementations\n////////////////////////////////////////////////////////////////////////////////\nnamespace { // anon\ntemplate \nstatic void genericLandingPad(uint32_t src, RecvBuffer& buf) {\n void (*fp)(uint32_t, Args...);\n std::tuple args;\n gDeserialize(buf, fp, args);\n std::apply([fp, src](Args... params) { fp(src, params...); }, args);\n}\n\n} // namespace\n\ntemplate \nvoid NetworkInterface::sendSimple(uint32_t dest,\n void (*recv)(uint32_t, Args...),\n Args... param) {\n SendBuffer buf;\n gSerialize(buf, (uintptr_t)recv, param...,\n (uintptr_t)genericLandingPad);\n sendTagged(dest, 0, buf);\n}\n\ntemplate \nvoid NetworkInterface::broadcastSimple(void (*recv)(uint32_t, Args...),\n Args... param) {\n SendBuffer buf;\n gSerialize(buf, (uintptr_t)recv, param...);\n broadcast(genericLandingPad, buf, false);\n}\n\n} // namespace galois::runtime\n#endif\n" }, { "path": "libdist/include/galois/runtime/NetworkIO.h", "content": "/*\n * This file belongs to the Galois project, a C++ library for exploiting\n * parallelism. The code is being released under the terms of the 3-Clause BSD\n * License (a copy is located in LICENSE.txt at the top-level directory).\n *\n * Copyright (C) 2018, The University of Texas at Austin. All rights reserved.\n * UNIVERSITY EXPRESSLY DISCLAIMS ANY AND ALL WARRANTIES CONCERNING THIS\n * SOFTWARE AND DOCUMENTATION, INCLUDING ANY WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR ANY PARTICULAR PURPOSE, NON-INFRINGEMENT AND WARRANTIES OF\n * PERFORMANCE, AND ANY WARRANTY THAT MIGHT OTHERWISE ARISE FROM COURSE OF\n * DEALING OR USAGE OF TRADE. NO WARRANTY IS EITHER EXPRESS OR IMPLIED WITH\n * RESPECT TO THE USE OF THE SOFTWARE OR DOCUMENTATION. Under no circumstances\n * shall University be liable for incidental, special, indirect, direct or\n * consequential damages or loss of profits, interruption of business, or\n * related expenses which may arise from use of Software or Documentation,\n * including but not limited to those resulting from defects in Software and/or\n * Documentation, or loss or inaccuracy of data of any kind.\n */\n\n/**\n * @file NetworkIO.h\n *\n * Contains NetworkIO, a base class that is inherited by classes that want to\n * implement the communication layer of Galois. (e.g. NetworkIOMPI and\n * NetworkIOLWCI)\n */\n\n#ifndef GALOIS_RUNTIME_NETWORKTHREAD_H\n#define GALOIS_RUNTIME_NETWORKTHREAD_H\n\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \"galois/runtime/MemUsage.h\"\n#include \"galois/PODResizeableArray.h\"\n\nnamespace galois {\nnamespace runtime {\n\n/**\n * Class for the network IO layer which is responsible for doing sends/receives\n * of data. Used by the network interface to do the actual communication.\n */\nclass NetworkIO {\nprotected:\n /**\n * Wrapper for dealing with MPI error codes. Program dies if the error code\n * isn't MPI_SUCCESS.\n *\n * @param rc Error code to check for success\n */\n static void handleError(int rc) {\n if (rc != MPI_SUCCESS) {\n MPI_Abort(MPI_COMM_WORLD, rc);\n }\n }\n\n //! memory usage tracker\n MemUsageTracker& memUsageTracker;\n\n //! Number of inflight sends and receives\n std::atomic& inflightSends;\n std::atomic& inflightRecvs;\n\n // using vTy = std::vector;\n using vTy = galois::PODResizeableArray;\n\npublic:\n /**\n * Message structure for sending data across the network.\n */\n struct message {\n uint32_t host; //!< destination of this message\n uint32_t tag; //!< tag on message indicating distinct communication phases\n vTy data; //!< data portion of message\n\n //! Default constructor initializes host and tag to large numbers.\n message() : host(~0), tag(~0) {}\n //! @param h Host to send message to\n //! @param t Tag to associate with message\n //! @param d Data to save in message\n message(uint32_t h, uint32_t t, vTy&& d)\n : host(h), tag(t), data(std::move(d)) {}\n\n //! A message is valid if there is data to be sent\n //! @returns true if data is non-empty\n bool valid() const { return !data.empty(); }\n };\n\n //! The default constructor takes a memory usage tracker and saves it\n //! @param tracker reference to a memory usage tracker used by the system\n //! @param sends\n //! @param recvs\n NetworkIO(MemUsageTracker& tracker, std::atomic& sends,\n std::atomic& recvs)\n : memUsageTracker(tracker), inflightSends(sends), inflightRecvs(recvs) {}\n\n //! Default destructor does nothing.\n virtual ~NetworkIO();\n //! Queues a message for sending out. Takes ownership of data buffer.\n virtual void enqueue(message m) = 0;\n //! Checks to see if a message is here for this host to receive. If so, take\n //! and return it\n //! @returns an empty message if no message\n virtual message dequeue() = 0;\n //! Make progress. Other functions don't have to make progress.\n virtual void progress() = 0;\n};\n\n/**\n * Creates/returns a network IO layer that uses MPI to do communication.\n *\n * @returns tuple with pointer to the MPI IO layer, this host's ID, and the\n * total number of hosts in the system\n */\nstd::tuple, uint32_t, uint32_t>\nmakeNetworkIOMPI(galois::runtime::MemUsageTracker& tracker,\n std::atomic& sends, std::atomic& recvs);\n// #ifdef GALOIS_USE_LCI\n// /**\n// * Creates/returns a network IO layer that uses LWCI to do communication.\n// *\n// * @returns tuple with pointer to the LWCI IO layer, this host's ID, and the\n// * total number of hosts in the system\n// */\n// std::tuple, uint32_t, uint32_t>\n// makeNetworkIOLWCI(galois::runtime::MemUsageTracker& tracker,\n// std::atomic& sends, std::atomic& recvs);\n// #endif\n\n} // namespace runtime\n} // namespace galois\n\n#endif\n" }, { "path": "libdist/include/galois/runtime/Serialize.h", "content": "/*\n * This file belongs to the Galois project, a C++ library for exploiting\n * parallelism. The code is being released under the terms of the 3-Clause BSD\n * License (a copy is located in LICENSE.txt at the top-level directory).\n *\n * Copyright (C) 2018, The University of Texas at Austin. All rights reserved.\n * UNIVERSITY EXPRESSLY DISCLAIMS ANY AND ALL WARRANTIES CONCERNING THIS\n * SOFTWARE AND DOCUMENTATION, INCLUDING ANY WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR ANY PARTICULAR PURPOSE, NON-INFRINGEMENT AND WARRANTIES OF\n * PERFORMANCE, AND ANY WARRANTY THAT MIGHT OTHERWISE ARISE FROM COURSE OF\n * DEALING OR USAGE OF TRADE. NO WARRANTY IS EITHER EXPRESS OR IMPLIED WITH\n * RESPECT TO THE USE OF THE SOFTWARE OR DOCUMENTATION. Under no circumstances\n * shall University be liable for incidental, special, indirect, direct or\n * consequential damages or loss of profits, interruption of business, or\n * related expenses which may arise from use of Software or Documentation,\n * including but not limited to those resulting from defects in Software and/or\n * Documentation, or loss or inaccuracy of data of any kind.\n */\n\n/**\n * @file Serialize.h\n *\n * Contains functions that serialize/deserialize data, mainly for sending\n * out serialized data over the network and deserializing it on the other end.\n */\n\n#ifndef GALOIS_RUNTIME_SERIALIZE_H\n#define GALOIS_RUNTIME_SERIALIZE_H\n\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\n#include \n#include \"galois/runtime/ExtraTraits.h\"\n\n#include \n#include \n#include \n#include \n#include \"galois/CopyableTuple.h\"\n#include \"galois/Bag.h\"\n\nnamespace galois {\nnamespace runtime {\n\nclass DeSerializeBuffer; // forward declaration for friend declaration\n\n/**\n * Buffer for serialization of data. Mainly used during network communication.\n */\nclass SerializeBuffer {\n //! Access to a deserialize buffer\n friend DeSerializeBuffer;\n\n //! type of data buffer\n // using vTy = std::vector;\n using vTy = galois::PODResizeableArray;\n //! the actual data stored in this buffer\n vTy bufdata;\n\npublic:\n //! default constructor\n SerializeBuffer() = default;\n //! disabled copy constructor\n SerializeBuffer(SerializeBuffer&& rhs) = default;\n //! Creates a buffer from another buffer\n //! @param d buffer to create from\n //! @param len amount of copy from buffer d\n SerializeBuffer(const char* d, unsigned len) : bufdata(d, d + len) {}\n\n //! Push a character onto the serialize buffer\n inline void push(const char c) { bufdata.push_back(c); }\n\n //! Insert characters from a buffer into the serialize buffer\n void insert(const uint8_t* c, size_t bytes) {\n bufdata.insert(bufdata.end(), c, c + bytes);\n }\n\n //! Insert characters from a buffer into the serialize buffer at a particular\n //! offset\n void insertAt(const uint8_t* c, size_t bytes, size_t offset) {\n std::copy_n(c, bytes, bufdata.begin() + offset);\n }\n\n /**\n * Reserve space at the end for inserting new data into the serialize\n * buffer\n *\n * @param bytes number of bytes to reserve at the end\n * @returns offset to the end of the buffer before new space was reserved\n */\n size_t encomber(size_t bytes) {\n size_t retval = bufdata.size();\n bufdata.resize(retval + bytes);\n return retval;\n }\n\n void resize(size_t bytes) { bufdata.resize(bytes); }\n\n /**\n * Reserve more space in the serialize buffer.\n *\n * @param s extra space to reserve\n */\n void reserve(size_t s) { bufdata.reserve(bufdata.size() + s); }\n\n //! Returns a pointer to the data stored in this serialize buffer\n const uint8_t* linearData() const { return bufdata.data(); }\n //! Returns vector of data stored in this serialize buffer\n vTy& getVec() { return bufdata; }\n\n //! Returns an iterator to the beginning of the data in this serialize buffer\n vTy::const_iterator begin() const { return bufdata.cbegin(); }\n //! Returns an iterator to the end of the data in this serialize buffer\n vTy::const_iterator end() const { return bufdata.cend(); }\n\n using size_type = vTy::size_type;\n\n //! Returns the size of the serialize buffer\n size_type size() const { return bufdata.size(); }\n\n //! Utility print function for the serialize buffer\n //! @param o stream to print to\n void print(std::ostream& o) const {\n o << \"<{\" << std::hex;\n for (auto& i : bufdata)\n o << (unsigned int)i << \" \";\n o << std::dec << \"}>\";\n }\n\n //! Operator that calls the print function of the serialize buffer\n friend std::ostream& operator<<(std::ostream& os, const SerializeBuffer& b) {\n b.print(os);\n return os;\n }\n};\n\n/**\n * Buffer for deserialization of data. Mainly used during network\n * communication.\n */\nclass DeSerializeBuffer {\n //! Access to serialize buffer\n friend SerializeBuffer;\n //! type of data buffer\n // using vTy = std::vector;\n using vTy = galois::PODResizeableArray;\n //! the actual data stored in this buffer\n vTy bufdata;\n int offset;\n\npublic:\n //! Constructor initializes offset into buffer to 0\n DeSerializeBuffer() : offset(0) {}\n //! Disable copy constructor\n DeSerializeBuffer(DeSerializeBuffer&&) = default;\n //! Move constructor\n //! @param v vector to act as deserialize buffer\n //! @param start offset to start saving data into\n DeSerializeBuffer(vTy&& v, uint32_t start = 0)\n : bufdata(std::move(v)), offset(start) {}\n\n //! Constructor that takes an existing vector to use as the deserialize\n //! buffer\n explicit DeSerializeBuffer(vTy& data) {\n bufdata.swap(data);\n offset = 0;\n }\n\n /**\n * Initializes the deserialize buffer with a certain size\n * @param [in] count size to initialize buffer to\n */\n explicit DeSerializeBuffer(int count) : bufdata(count), offset(0) {}\n\n /**\n * Initializes the deserialize buffer using vector initialization from\n * 2 iterators.\n */\n template \n DeSerializeBuffer(Iter b, Iter e) : bufdata(b, e), offset{0} {}\n\n /**\n * Initialize a deserialize buffer from a serialize buffer\n */\n explicit DeSerializeBuffer(SerializeBuffer&& buf) : offset(0) {\n bufdata.swap(buf.bufdata);\n }\n\n /**\n * Disable copy constructor\n */\n DeSerializeBuffer& operator=(DeSerializeBuffer&& buf) = default;\n\n /**\n * Reset deserialize buffer\n * @param count new size of buffer\n */\n void reset(int count) {\n offset = 0;\n bufdata.resize(count);\n }\n\n //! Gets the current offset into the deserialize buffer\n unsigned getOffset() const { return offset; }\n //! Sets the offset into the deserialize buffer\n void setOffset(unsigned off) {\n assert(off <= size());\n offset = off;\n }\n\n //! Gets the size of the deserialize buffer\n unsigned size() const { return bufdata.size(); }\n\n //! Returns true if the deserialize buffer is empty\n //! @returns true if the deserialize buffer is empty\n bool empty() const { return bufdata.empty(); }\n\n //! Get the next character in the deserialize buffer\n unsigned char pop() { return bufdata.at(offset++); }\n\n //! Clears the last x bytes of the deserialize buffer, resizing it as well\n //! @param x How many bytes from the end to clear\n void pop_back(unsigned x) { bufdata.resize(bufdata.size() - x); }\n\n /**\n * Extracts a certain amount of data from the deserialize buffer\n *\n * @param dst buffer to copy data from deserialize buffer into\n * @param num Amount of data to get from deserialize buffer\n */\n void extract(uint8_t* dst, size_t num) {\n if (num > 0) {\n memcpy(dst, &bufdata[offset], num);\n offset += num;\n }\n }\n\n //! Get the underlying vector storing the data of the deserialize\n //! buffer\n vTy& getVec() { return bufdata; }\n\n //! Get a pointer to the underlying data of the deserialize buffer\n void* linearData() { return &bufdata[0]; }\n\n //! Get a pointer to the remaining data of the deserialize buffer\n //! (as determined by offset)\n const uint8_t* r_linearData() const { return &bufdata[offset]; }\n //! Get the remaining size of the deserialize buffer (as determined\n //! by offset)\n size_t r_size() const { return bufdata.size() - offset; }\n\n //! Checks if the current location in the deserialize buffer is aligned\n //! to some size a\n bool atAlignment(size_t a) { return (uintptr_t)r_linearData() % a == 0; }\n\n //! Utility print of deserialize buffer\n //! @param o stream to print to\n void print(std::ostream& o) const {\n o << \"<{(\" << offset << \") \" << std::hex;\n for (auto ii = bufdata.begin(), ee = bufdata.end(); ii != ee; ++ii)\n o << (unsigned int)*ii << \" \";\n o << std::dec << \"}>\";\n }\n\n //! Operator for printing deserialize buffer\n friend std::ostream& operator<<(std::ostream& os,\n const DeSerializeBuffer& buf) {\n buf.print(os);\n return os;\n }\n};\n\nnamespace internal {\n\n/**\n * Returns the size necessary for an object in a buffer.\n * This version runs if the data is memory copyable; uses sizeof.\n *\n * @tparam T type of datato get size of\n */\ntemplate \n__attribute__((always_inline)) constexpr size_t\ngSizedObj(const T&,\n typename std::enable_if::value>::type* = 0) {\n return sizeof(T);\n}\n\n/**\n * Returns the size necessary for an object in a buffer.\n * This version runs if the data is not memory copyable but is serializable.\n * It returns the size of a uintptr_t.\n *\n * @tparam T type of datato get size of\n * @returns size of uintptr_t\n */\ntemplate \n__attribute__((always_inline)) constexpr size_t\ngSizedObj(const T&,\n typename std::enable_if::value>::type* = 0,\n typename std::enable_if::value>::type* = 0) {\n return sizeof(uintptr_t);\n}\n\n/**\n * Returns the size necessary for storing 2 elements of a pair into a\n * serialize buffer.\n *\n * @param data pair of 2 elements\n */\ntemplate \ninline size_t gSizedObj(const std::pair& data) {\n return gSizedObj(data.first) + gSizedObj(data.second);\n}\n\n/**\n * Returns the size necessary to store a sequence in a serialize buffer.\n * This depends on if the sequence is memory copyable.\n */\ntemplate \nsize_t gSizedSeq(const Seq& seq) {\n typename Seq::size_type size = seq.size();\n typedef typename Seq::value_type T;\n size_t tsize = std::conditional<\n is_memory_copyable::value, std::integral_constant,\n std::integral_constant>::type::value;\n return sizeof(size) + tsize * size;\n}\n\n/**\n * Returns the size needed to store the elements a vector in a serialize\n * buffer.\n *\n * @returns size needed to store a vector into a serialize buffer\n */\ntemplate \ninline size_t gSizedObj(const std::vector& data) {\n return gSizedSeq(data);\n}\n\n/**\n * Returns the size needed to store the elements a PODResizeableArray in a\n * serialize buffer.\n *\n * @returns size needed to store a PODResizeableArray into a serialize buffer\n */\ntemplate \ninline size_t gSizedObj(const galois::PODResizeableArray& data) {\n return gSizedSeq(data);\n}\n\n/**\n * Returns the size needed to store the elements a deque into a serialize\n * buffer.\n *\n * @returns size needed to store a deque into a serialize buffer\n */\ntemplate \ninline size_t gSerializeObj(const std::deque& data) {\n return gSizedSeq(data);\n}\n\n/**\n * Returns the size needed to store the elements a Galois deque into a serialize\n * buffer.\n *\n * @returns size needed to store a Galois deque into a serialize buffer\n */\ntemplate \ninline size_t gSizedObj(const galois::gdeque& data) {\n return gSizedSeq(data);\n}\n\n/**\n * Returns the size needed to store a string into a serialize\n * buffer.\n *\n * @returns size needed to store a string into a serialize buffer\n */\ntemplate \ninline size_t\ngSizedObj(const std::basic_string, A>& data) {\n return data.length() + 1;\n}\n\n/**\n * Returns the size of the passed in serialize buffer\n *\n * @returns size of the serialize buffer passed into it\n */\ninline size_t gSizedObj(const SerializeBuffer& data) { return data.size(); }\n\n/**\n * Returns the size of the passed in deserialize buffer\n *\n * @returns size of the deserialize buffer passed into it\n */\ninline size_t gSizedObj(const DeSerializeBuffer& rbuf) { return rbuf.r_size(); }\n\n/**\n * Returns the size of the passed in insert bag.\n *\n * @returns size of the insert bag passed into it\n */\ntemplate \ninline size_t gSizedObj(const galois::InsertBag& bag) {\n return bag.size();\n}\n\n/**\n * Returns 0.\n * @returns 0\n */\ninline size_t adder() { return 0; }\n/**\n * Returns the passed in argument.\n * @param a a number\n * @returns a\n */\ninline size_t adder(size_t a) { return a; }\n/**\n * Returns the sum of all passed in arguments.\n * @returns sum of all arguments\n */\ntemplate \ninline size_t adder(size_t a, size_t b, Args&&... args) {\n return a + b + adder(args...);\n}\n\n} // namespace internal\n\n/**\n * Gets the total size necessary for storing all of the passed in arguments into\n * a serialize buffer.\n *\n * @returns size necessary for storing all arguments into a serialize buffer\n */\ntemplate \nstatic inline size_t gSized(Args&&... args) {\n return internal::adder(internal::gSizedObj(args)...);\n}\n\n////////////////////////////////////////////////////////////////////////////////\n// Serialize support\n////////////////////////////////////////////////////////////////////////////////\n\nnamespace internal {\n\n/**\n * Serialize a memory copyable object into a serialize buffer.\n *\n * @param [in,out] buf Serialize buffer to serialize into\n * @param [in] data Data to serialize\n */\ntemplate \ninline void gSerializeObj(\n SerializeBuffer& buf, const T& data,\n typename std::enable_if::value>::type* = 0) {\n uint8_t* pdata = (uint8_t*)&data;\n buf.insert(pdata, sizeof(T));\n}\n\n/**\n * Serialize a non-memory copyable but serializable object into a serialize\n * buffer.\n *\n * @param [in,out] buf Serialize buffer to serialize into\n * @param [in] data Data to serialize\n */\ntemplate \ninline void\ngSerializeObj(SerializeBuffer& buf, const T& data,\n typename std::enable_if::value>::type* = 0,\n typename std::enable_if::value>::type* = 0) {\n data.serialize(buf);\n}\n\n/**\n * Serialize a pair into a serialize buffer.\n *\n * @param [in,out] buf Serialize buffer to serialize into\n * @param [in] data Pair to serialize\n */\ntemplate \ninline void gSerializeObj(SerializeBuffer& buf, const std::pair& data) {\n gSerialize(buf, data.first, data.second);\n}\n\n/**\n * Serialize a pair. Either memcpys entire struct or serializes\n * each element individually.\n *\n * @param [in,out] buf Serialize buffer to serialize into\n * @param [in] data Pair to serialize\n */\ntemplate \ninline void gSerializeObj(SerializeBuffer& buf,\n const galois::Pair& data) {\n if (is_memory_copyable::value && is_memory_copyable::value) {\n // do memcpy\n buf.insert((uint8_t*)&data, sizeof(data));\n } else {\n // serialize each individually\n gSerialize(buf, data.first, data.second);\n }\n}\n\n/**\n * Serialize a tuple of 3. Either memcpys entire struct or serializes\n * each element individually.\n *\n * @param [in,out] buf Serialize buffer to serialize into\n * @param [in] data Tuple of 3 to serialize\n * @todo This specialization isn't being used as expected. Figure out why.\n */\ntemplate \ninline void gSerializeObj(SerializeBuffer& buf,\n const galois::TupleOfThree& data) {\n if (is_memory_copyable::value && is_memory_copyable::value &&\n is_memory_copyable::value) {\n // do memcpy\n buf.insert((uint8_t*)&data, sizeof(data));\n } else {\n // serialize each individually\n gSerialize(buf, data.first, data.second, data.third);\n }\n}\n\n/**\n * Serialize a copyable atomic: load atomic data as a plain old\n * datatype (POD) and mem copy it to the buffer.\n *\n * @param [in,out] buf Serialize buffer to serialize into\n * @param [in] data copyable atomic to serialize\n */\ntemplate \ninline void gSerializeObj(SerializeBuffer& buf,\n const galois::CopyableAtomic& data) {\n T temp = data.load();\n buf.insert((uint8_t*)(&temp), sizeof(T));\n}\n\n/**\n * Serialize a string into a buffer.\n *\n * @param [in,out] buf Serialize buffer to serialize into\n * @param [in] data String\n */\ntemplate \ninline void\ngSerializeObj(SerializeBuffer& buf,\n const std::basic_string, A>& data) {\n buf.insert((uint8_t*)data.data(), data.length() + 1);\n}\n\n// Forward declaration of vector serialize\ntemplate \ninline void gSerializeObj(SerializeBuffer& buf,\n const std::vector& data);\n\n/**\n * Serialize a sequence type into a buffer.\n *\n * @param [in,out] buf Serialize buffer to serialize into\n * @param [in] seq sequence to serialize\n * @todo specialize for Sequences with consecutive PODS\n */\ntemplate \nvoid gSerializeSeq(SerializeBuffer& buf, const Seq& seq) {\n typename Seq::size_type size = seq.size();\n gSerializeObj(buf, size);\n for (auto& o : seq)\n gSerializeObj(buf, o);\n}\n\n/**\n * Serialize a linear sequence type (i.e. memcopyable) into a buffer.\n *\n * @param [in,out] buf Serialize buffer to serialize into\n * @param [in] seq sequence to serialize\n */\ntemplate \nvoid gSerializeLinearSeq(SerializeBuffer& buf, const Seq& seq) {\n typename Seq::size_type size = seq.size();\n typedef typename Seq::value_type T;\n size_t tsize = sizeof(T);\n // buf.reserve(size * tsize + sizeof(size));\n gSerializeObj(buf, size);\n buf.insert((uint8_t*)seq.data(), size * tsize);\n}\n\n/**\n * Serialize a vector into a buffer, choosing to do a memcopy or\n * to serialize each element individually depending on data.\n *\n * @param [in,out] buf Serialize buffer to serialize into\n * @param [in] data vector to serialize\n */\ntemplate \ninline void gSerializeObj(SerializeBuffer& buf,\n const std::vector& data) {\n if (is_memory_copyable::value)\n gSerializeLinearSeq(buf, data);\n else\n gSerializeSeq(buf, data);\n}\n\n/**\n * Serialize a PODResizeableArray into a buffer, choosing to do a memcopy or\n * to serialize each element individually depending on data.\n *\n * @param [in,out] buf Serialize buffer to serialize into\n * @param [in] data PODResizeableArray to serialize\n */\ntemplate \ninline void gSerializeObj(SerializeBuffer& buf,\n const galois::PODResizeableArray& data) {\n gSerializeLinearSeq(buf, data);\n}\n\n/**\n * Serialize a deque into a buffer.\n *\n * @param [in,out] buf Serialize buffer to serialize into\n * @param [in] data deque to serialize\n */\ntemplate \ninline void gSerializeObj(SerializeBuffer& buf,\n const std::deque& data) {\n gSerializeSeq(buf, data);\n}\n\n/**\n * Serialize a Galois deque into a buffer.\n *\n * @param [in,out] buf Serialize buffer to serialize into\n * @param [in] data deque to serialize\n */\ntemplate \ninline void gSerializeObj(SerializeBuffer& buf,\n const galois::gdeque& data) {\n gSerializeSeq(buf, data);\n}\n\n/**\n * Serialize data in another serialize buffer into a buffer.\n *\n * @param [in,out] buf Serialize buffer to serialize into\n * @param [in] data serialize buffer to get data from\n */\ninline void gSerializeObj(SerializeBuffer& buf, const SerializeBuffer& data) {\n buf.insert(data.linearData(), data.size());\n}\n\n/**\n * Serialize data in a deserialize buffer into a buffer.\n *\n * @param [in,out] buf Serialize buffer to serialize into\n * @param [in] rbuf deserialize buffer to get data from\n */\ninline void gSerializeObj(SerializeBuffer& buf, const DeSerializeBuffer& rbuf) {\n // buf.reserve(rbuf.r_size());\n buf.insert(rbuf.r_linearData(), rbuf.r_size());\n}\n\n/**\n * Serialize a dynamic bitset into a buffer.\n *\n * @param [in,out] buf Serialize buffer to serialize into\n * @param [in] data dynamic bitset to serialize\n */\ninline void gSerializeObj(SerializeBuffer& buf,\n const galois::DynamicBitSet& data) {\n gSerializeObj(buf, data.size());\n gSerializeObj(buf, data.get_vec());\n}\n\n// we removed the functions in Bag.h that this function requires, so this\n// won't work\n#if 0\n/**\n * For serializing insertBag.\n * Insert contigous memory chunks for each thread\n * and clear it.\n * Can not be const.\n * Implemention below makes sure that it can be deserialized\n * into a linear sequence like vector or deque.\n */\ntemplate\ninline void gSerializeObj(SerializeBuffer& buf, galois::InsertBag& bag){\n gSerializeObj(buf, bag.size());\n auto headerVec = bag.getHeads();\n size_t totalSize = 0;\n for(auto h : headerVec){\n size_t localSize = (h->dend - h->dbegin);\n buf.insert((uint8_t*)h->dbegin, localSize*sizeof(T));\n totalSize += (h->dend - h->dbegin);\n }\n\n assert(totalSize == bag.size());\n bag.clear();\n}\n#endif\n} // namespace internal\n\n/**\n * LazyRef structure; used to store both a type and an offset to begin\n * saving data into\n */\ntemplate \nstruct LazyRef {\n size_t off;\n};\n\n/**\n * Lazy serialize: doesn't actually serialize the data itself, but only\n * reserves space for it in the serialize buffer + serializes the\n * passed in num.\n */\ntemplate \nstatic inline LazyRef\ngSerializeLazySeq(SerializeBuffer& buf, unsigned num, Seq*) {\n static_assert(is_memory_copyable::value,\n \"Not POD Sequence\");\n typename Seq::size_type size = num;\n internal::gSerializeObj(buf, size);\n size_t tsize = sizeof(typename Seq::value_type);\n return LazyRef{buf.encomber(tsize * num)};\n}\n\n/**\n * Lazy serialize: given an offset and type through a LazyRef object,\n * serializes a certain amount from the passed in data array.\n *\n * @param buf Buffer to serialize into\n * @param r struct with info on where to start saving data and the type\n * of the data that needs to be saved\n * @param item Number of items that need to be serialized\n * @param data Data array containing data that needs to be serialized\n */\ntemplate \nstatic inline void gSerializeLazy(SerializeBuffer& buf, LazyRef r,\n unsigned item, Ty&& data) {\n size_t off = r.off + sizeof(Ty) * item;\n uint8_t* pdata = (uint8_t*)&data;\n buf.insertAt(pdata, sizeof(Ty), off);\n}\n\n/**\n * Serialize an entire series of datatypes into a provided serialize buffer\n */\ntemplate \nstatic inline void gSerialize(SerializeBuffer& buf, T1&& t1, Args&&... args) {\n buf.reserve(gSized(t1, args...));\n internal::gSerializeObj(buf, std::forward(t1));\n gSerialize(buf, std::forward(args)...);\n}\n\n/**\n * No-op function. \"Base case\" for recursive gSerialize function.\n */\nstatic inline void gSerialize(SerializeBuffer&) {}\n\n////////////////////////////////////////////////////////////////////////////////\n// Deserialize support\n////////////////////////////////////////////////////////////////////////////////\n\nnamespace internal {\n\n/**\n * Deserialize a memcopyable object from a buffer.\n *\n * @param buf [in,out] Buffer to deserialize from\n * @param data [in,out] Data to deserialize into\n */\ntemplate \nvoid gDeserializeObj(\n DeSerializeBuffer& buf, T& data,\n typename std::enable_if::value>::type* = 0) {\n uint8_t* pdata = (uint8_t*)&data;\n buf.extract(pdata, sizeof(T));\n}\n\n/**\n * Deserialize a non-memcopyable but seralizable object from a buffer.\n *\n * @param buf [in,out] Buffer to deserialize from\n * @param data [in,out] Data to deserialize into\n */\ntemplate \nvoid gDeserializeObj(\n DeSerializeBuffer& buf, T& data,\n typename std::enable_if::value>::type* = 0,\n typename std::enable_if::value>::type* = 0) {\n data.deserialize(buf);\n}\n\n/**\n * Deserialize a pair from a buffer.\n *\n * @param buf [in,out] Buffer to deserialize from\n * @param data [in,out] pair to deserialize into\n */\ntemplate \nvoid gDeserializeObj(DeSerializeBuffer& buf, std::pair& data) {\n gDeserialize(buf, data.first, data.second);\n}\n\n/**\n * Deserialize into a pair. Either memcpys from buffer or deserializes\n * each element individually.\n *\n * @param [in,out] buf Buffer to deserialize from\n * @param [in] data Pair to deserialize into\n */\ntemplate \ninline void gDeserializeObj(DeSerializeBuffer& buf,\n galois::Pair& data) {\n if (is_memory_copyable::value && is_memory_copyable::value) {\n // do memcpy\n buf.extract((uint8_t*)&data, sizeof(data));\n } else {\n // deserialize each individually\n gDeserialize(buf, data.first, data.second);\n }\n}\n\n/**\n * Deserialize into a tuple of 3. Either memcpys from buffer or deserializes\n * each element individually.\n *\n * @param buf [in,out] Buffer to deserialize from\n * @param data [in,out] triple to deserialize into\n * @todo This specialization isn't being used as expected. Figure out why.\n */\ntemplate \ninline void gDeserializeObj(DeSerializeBuffer& buf,\n galois::TupleOfThree& data) {\n if (is_memory_copyable::value && is_memory_copyable::value &&\n is_memory_copyable::value) {\n // do memcpy straight to data\n buf.extract((uint8_t*)&data, sizeof(data));\n } else {\n // deserialize each individually\n gDeserialize(buf, data.first, data.second, data.third);\n }\n}\n\n/**\n * Deserialize into a CopyableAtomic. Loads the POD from the DeserializeBuffer\n * then stores it into the atomic.\n *\n * @param buf [in,out] Buffer to deserialize from\n * @param data [in,out] copyable atomic to deserialize into\n */\ntemplate \nvoid gDeserializeObj(DeSerializeBuffer& buf, galois::CopyableAtomic& data) {\n T tempData;\n uint8_t* pointerToTemp = (uint8_t*)&tempData;\n buf.extract(pointerToTemp, sizeof(T));\n data.store(tempData);\n}\n\nnamespace {\ntemplate \nstruct seq {};\ntemplate \nstruct gens : gens {};\ntemplate \nstruct gens<0, S...> {\n typedef seq type;\n};\n} // namespace\n\n/**\n * Deserialize into a tuple.\n *\n * @param buf [in,out] Buffer to deserialize from\n * @param data [in,out] tuple to serialize into\n */\ntemplate \nvoid gDeserializeTuple(DeSerializeBuffer& buf, std::tuple& data,\n seq) {\n gDeserialize(buf, std::get(data)...);\n}\n\n/**\n * Wrapper for deserialization into a tuple.\n *\n * @param buf [in,out] Buffer to deserialize from\n * @param data [in,out] tuple to serialize into\n */\ntemplate \nvoid gDeserializeObj(DeSerializeBuffer& buf, std::tuple& data) {\n return gDeserializeTuple(buf, data, typename gens::type());\n}\n\n/**\n * Deserialize into a string.\n *\n * @param buf [in,out] Buffer to deserialize from\n * @param data [in,out] string to serialize into\n */\ntemplate \ninline void\ngDeserializeObj(DeSerializeBuffer& buf,\n std::basic_string, A>& data) {\n char c = buf.pop();\n while (c != '\\0') {\n data.push_back(c);\n c = buf.pop();\n };\n}\n\n// Forward declaration of vector deserialize\ntemplate \nvoid gDeserializeObj(DeSerializeBuffer& buf, std::vector& data);\n\n/**\n * Deserialize into a sequence object\n *\n * @param buf [in,out] Buffer to deserialize from\n * @param seq [in,out] sequence to deserialize into\n */\ntemplate \nvoid gDeserializeSeq(DeSerializeBuffer& buf, Seq& seq) {\n seq.clear();\n typename Seq::size_type size;\n gDeserializeObj(buf, size);\n while (size--) {\n typename Seq::value_type v;\n gDeserializeObj(buf, v);\n seq.push_back(v);\n }\n}\n\n/**\n * Deserialize into a linear sequence object (i.e. one that is mem-copyable)\n *\n * @param buf [in,out] Buffer to deserialize from\n * @param seq [in,out] sequence to deserialize into\n */\ntemplate \nvoid gDeserializeLinearSeq(DeSerializeBuffer& buf, Seq& seq) {\n typedef typename Seq::value_type T;\n // seq.clear();\n typename Seq::size_type size;\n gDeserializeObj(buf, size);\n // If the alignment is right, cast to a T array and insert\n if (buf.atAlignment(alignof(T))) {\n T* src = (T*)buf.r_linearData();\n seq.assign(src, &src[size]);\n buf.setOffset(buf.getOffset() + size * sizeof(T));\n } else {\n seq.resize(size);\n buf.extract((uint8_t*)seq.data(), size * sizeof(T));\n }\n}\n\n/**\n * Deserialize into a deque\n *\n * @param buf [in,out] Buffer to deserialize from\n * @param data [in,out] deque to deserialize into\n */\ntemplate \nvoid gDeserializeObj(DeSerializeBuffer& buf, std::deque& data) {\n gDeserializeSeq(buf, data);\n}\n\n/**\n * Deserialize into a vector; implementation depends on whether or not data in\n * vector is mem-copyable\n *\n * @param buf [in,out] Buffer to deserialize from\n * @param data [in,out] vector to deserialize into\n */\ntemplate \nvoid gDeserializeObj(DeSerializeBuffer& buf, std::vector& data) {\n if (is_memory_copyable::value)\n gDeserializeLinearSeq(buf, data);\n else\n gDeserializeSeq(buf, data);\n}\n\n/**\n * Deserialize into a PODResizeableArray\n *\n * @param buf [in,out] Buffer to deserialize from\n * @param data [in,out] PODResizeableArray to deserialize into\n */\ntemplate \nvoid gDeserializeObj(DeSerializeBuffer& buf,\n galois::PODResizeableArray& data) {\n gDeserializeLinearSeq(buf, data);\n}\n\n/**\n * Deserialize into a galois deque\n *\n * @param buf [in,out] Buffer to deserialize from\n * @param data [in,out] galois deque to deserialize into\n */\ntemplate \nvoid gDeserializeObj(DeSerializeBuffer& buf, galois::gdeque& data) {\n gDeserializeSeq(buf, data);\n}\n\n/**\n * Deserialize into a dynamic bitset\n *\n * @param buf [in,out] Buffer to deserialize from\n * @param data [in,out] bitset to deserialize into\n */\ninline void gDeserializeObj(DeSerializeBuffer& buf,\n galois::DynamicBitSet& data) {\n size_t size = 0;\n gDeserializeObj(buf, size);\n data.resize(size);\n gDeserializeObj(buf, data.get_vec());\n}\n\n} // namespace internal\n\n/**\n * Deserialize data in a buffer into a series of objects\n */\ntemplate \nvoid gDeserialize(DeSerializeBuffer& buf, T1&& t1, Args&&... args) {\n internal::gDeserializeObj(buf, std::forward(t1));\n gDeserialize(buf, std::forward(args)...);\n}\n\n/**\n * Base case for regular gDeserialize recursive call.\n */\ninline void gDeserialize(DeSerializeBuffer&) {}\n\n/**\n * \"Deserialize\" data in an iterator type into a data object.\n *\n * @tparam Iter iterator type that has objects of type T\n * @tparam T type of data to deserialize into\n * @param iter Iterator containing data that we want to save into the passed in\n * data reference\n * @param data Object to save data in the iterator type into\n */\ntemplate \nauto gDeserializeRaw(Iter iter, T& data) -> decltype(\n std::declval::value>::type>(),\n Iter()) {\n unsigned char* pdata = (unsigned char*)&data;\n for (size_t i = 0; i < sizeof(T); ++i)\n pdata[i] = *iter++;\n return iter;\n}\n\n} // namespace runtime\n} // namespace galois\n\n#endif // SERIALIZE DEF end\n" }, { "path": "libdist/src/Barrier.cpp", "content": "/*\n * This file belongs to the Galois project, a C++ library for exploiting\n * parallelism. The code is being released under the terms of the 3-Clause BSD\n * License (a copy is located in LICENSE.txt at the top-level directory).\n *\n * Copyright (C) 2018, The University of Texas at Austin. All rights reserved.\n * UNIVERSITY EXPRESSLY DISCLAIMS ANY AND ALL WARRANTIES CONCERNING THIS\n * SOFTWARE AND DOCUMENTATION, INCLUDING ANY WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR ANY PARTICULAR PURPOSE, NON-INFRINGEMENT AND WARRANTIES OF\n * PERFORMANCE, AND ANY WARRANTY THAT MIGHT OTHERWISE ARISE FROM COURSE OF\n * DEALING OR USAGE OF TRADE. NO WARRANTY IS EITHER EXPRESS OR IMPLIED WITH\n * RESPECT TO THE USE OF THE SOFTWARE OR DOCUMENTATION. Under no circumstances\n * shall University be liable for incidental, special, indirect, direct or\n * consequential damages or loss of profits, interruption of business, or\n * related expenses which may arise from use of Software or Documentation,\n * including but not limited to those resulting from defects in Software and/or\n * Documentation, or loss or inaccuracy of data of any kind.\n */\n\n/**\n * @file libdist/src/Barrier.cpp\n *\n * Contains implementation of HostFence and HostBarrier as well as functions\n * that get static singletons of the 2.\n *\n * A fence flushes out and receives all messages in the network while a barrier\n * simply acts as a barrier in the code for all hosts.\n */\n\n#include \"galois/substrate/PerThreadStorage.h\"\n#include \"galois/runtime/Substrate.h\"\n#include \"galois/substrate/CompilerSpecific.h\"\n#include \"galois/runtime/Network.h\"\n#include \"galois/runtime/LWCI.h\"\n\n#include \n#include \n#include \n\n#include \n#include \"galois/runtime/BareMPI.h\"\n\nnamespace {\nclass HostFence : public galois::substrate::Barrier {\npublic:\n virtual const char* name() const { return \"HostFence\"; }\n\n virtual void reinit(unsigned) {}\n\n //! control-flow barrier across distributed hosts\n //! acts as a distributed-memory fence as well (flushes send and receives)\n virtual void wait() {\n auto& net = galois::runtime::getSystemNetworkInterface();\n\n if (galois::runtime::evilPhase == 0) {\n galois::gWarn(\"evilPhase is 0, implying loop-around or no use: fence \"\n \"may not work correctly!\");\n }\n\n for (unsigned h = 0; h < net.Num; ++h) {\n if (h == net.ID)\n continue;\n galois::runtime::SendBuffer b;\n galois::runtime::gSerialize(b, net.ID + 1); // non-zero message\n net.sendTagged(h, galois::runtime::evilPhase, b);\n }\n net.flush(); // flush all sends\n\n unsigned received = 1; // self\n while (received < net.Num) {\n decltype(net.recieveTagged(galois::runtime::evilPhase, nullptr)) p;\n do {\n net.handleReceives(); // flush all receives from net.sendMsg() or\n // net.sendSimple()\n p = net.recieveTagged(galois::runtime::evilPhase, nullptr);\n } while (!p);\n assert(p->first != net.ID);\n // ignore received data\n ++received;\n }\n ++galois::runtime::evilPhase;\n if (galois::runtime::evilPhase >=\n static_cast(\n std::numeric_limits::max())) { // limit defined by MPI or\n // LCI\n galois::runtime::evilPhase = 1;\n }\n }\n};\n\nclass HostBarrier : public galois::substrate::Barrier {\npublic:\n virtual const char* name() const { return \"HostBarrier\"; }\n\n virtual void reinit(unsigned) {}\n\n //! Control-flow barrier across distributed hosts\n virtual void wait() {\n#ifdef GALOIS_USE_LCI\n lc_barrier(lc_col_ep);\n#else\n MPI_Barrier(MPI_COMM_WORLD); // assumes MPI_THREAD_MULTIPLE\n#endif\n }\n};\n\n} // end anonymous namespace\n\ngalois::substrate::Barrier& galois::runtime::getHostBarrier() {\n static HostBarrier b;\n return b;\n}\n\ngalois::substrate::Barrier& galois::runtime::getHostFence() {\n static HostFence b;\n return b;\n}\n" }, { "path": "libdist/src/DistGalois.cpp", "content": "/*\n * This file belongs to the Galois project, a C++ library for exploiting\n * parallelism. The code is being released under the terms of the 3-Clause BSD\n * License (a copy is located in LICENSE.txt at the top-level directory).\n *\n * Copyright (C) 2018, The University of Texas at Austin. All rights reserved.\n * UNIVERSITY EXPRESSLY DISCLAIMS ANY AND ALL WARRANTIES CONCERNING THIS\n * SOFTWARE AND DOCUMENTATION, INCLUDING ANY WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR ANY PARTICULAR PURPOSE, NON-INFRINGEMENT AND WARRANTIES OF\n * PERFORMANCE, AND ANY WARRANTY THAT MIGHT OTHERWISE ARISE FROM COURSE OF\n * DEALING OR USAGE OF TRADE. NO WARRANTY IS EITHER EXPRESS OR IMPLIED WITH\n * RESPECT TO THE USE OF THE SOFTWARE OR DOCUMENTATION. Under no circumstances\n * shall University be liable for incidental, special, indirect, direct or\n * consequential damages or loss of profits, interruption of business, or\n * related expenses which may arise from use of Software or Documentation,\n * including but not limited to those resulting from defects in Software and/or\n * Documentation, or loss or inaccuracy of data of any kind.\n */\n\n/**\n * @file DistGalois.cpp\n *\n * Includes the definitions for DistMemSys's constructor and destructor\n */\n\n#include \"galois/DistGalois.h\"\n#include \"galois/runtime/Network.h\"\n\n//! DistMemSys constructor which calls the shared memory runtime constructor\n//! with the distributed stats manager\ngalois::DistMemSys::DistMemSys()\n : galois::runtime::SharedMem() {}\n\n//! DistMemSys destructor which reports memory usage from the network\ngalois::DistMemSys::~DistMemSys() {\n if (MORE_DIST_STATS) {\n auto& net = galois::runtime::getSystemNetworkInterface();\n net.reportMemUsage();\n }\n}\n" }, { "path": "libdist/src/DistStats.cpp", "content": "/*\n * This file belongs to the Galois project, a C++ library for exploiting\n * parallelism. The code is being released under the terms of the 3-Clause BSD\n * License (a copy is located in LICENSE.txt at the top-level directory).\n *\n * Copyright (C) 2018, The University of Texas at Austin. All rights reserved.\n * UNIVERSITY EXPRESSLY DISCLAIMS ANY AND ALL WARRANTIES CONCERNING THIS\n * SOFTWARE AND DOCUMENTATION, INCLUDING ANY WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR ANY PARTICULAR PURPOSE, NON-INFRINGEMENT AND WARRANTIES OF\n * PERFORMANCE, AND ANY WARRANTY THAT MIGHT OTHERWISE ARISE FROM COURSE OF\n * DEALING OR USAGE OF TRADE. NO WARRANTY IS EITHER EXPRESS OR IMPLIED WITH\n * RESPECT TO THE USE OF THE SOFTWARE OR DOCUMENTATION. Under no circumstances\n * shall University be liable for incidental, special, indirect, direct or\n * consequential damages or loss of profits, interruption of business, or\n * related expenses which may arise from use of Software or Documentation,\n * including but not limited to those resulting from defects in Software and/or\n * Documentation, or loss or inaccuracy of data of any kind.\n */\n\n/**\n * @file DistStats.cpp\n *\n * Contains implementations for DistStats.h.\n */\n#include \"galois/runtime/DistStats.h\"\n#include \"galois/runtime/Serialize.h\"\n#include \"galois/DTerminationDetector.h\"\n\nusing namespace galois::runtime;\n\nDistStatManager* internal::distSysStatManager(void) {\n galois::runtime::StatManager* sm = internal::sysStatManager();\n\n assert(sm && \"StatManager not initialized\");\n\n DistStatManager* d = dynamic_cast(sm);\n\n assert(d && \"dynamic_cast failed\");\n\n return d;\n}\n\ninline static DistStatManager* dsm(void) {\n return internal::distSysStatManager();\n}\n\nDistStatManager::DistStatManager(const std::string& outfile)\n : StatManager(outfile) {}\nDistStatManager::~DistStatManager() {\n galois::runtime::internal::destroySystemNetworkInterface();\n}\n\nclass galois::runtime::StatRecvHelper {\n\npublic:\n static void recvAtHost_0_hostTotalTy(galois::gstl::Str region,\n galois::gstl::Str category,\n StatTotal::Type totalTy) {\n\n dsm()->addRecvdHostTotalTy(region, category, totalTy);\n }\n\n static void recvAtHost_0_int(uint32_t hostID, galois::gstl::Str region,\n galois::gstl::Str category, int64_t thrdTotal,\n StatTotal::Type totalTy,\n const galois::gstl::Vector thrdVals) {\n\n dsm()->addRecvdStat(hostID, region, category, thrdTotal, totalTy, thrdVals);\n }\n\n static void recvAtHost_0_fp(uint32_t hostID, galois::gstl::Str region,\n galois::gstl::Str category, double thrdTotal,\n StatTotal::Type totalTy,\n const galois::gstl::Vector thrdVals) {\n\n dsm()->addRecvdStat(hostID, region, category, thrdTotal, totalTy, thrdVals);\n }\n\n static void\n recvAtHost_0_str(uint32_t hostID, galois::gstl::Str region,\n galois::gstl::Str category, galois::gstl::Str thrdTotal,\n StatTotal::Type totalTy,\n const galois::gstl::Vector thrdVals) {\n\n dsm()->addRecvdParam(hostID, region, category, thrdTotal, totalTy,\n thrdVals);\n }\n};\n\nvoid DistStatManager::mergeStats(void) {\n Base::mergeStats();\n hostTotalTypes.mergeStats();\n combineAtHost_0();\n}\n\nvoid DistStatManager::combineAtHost_0_helper(void) {\n const bool IS_HOST0 = getHostID() == 0;\n\n const auto& hTotalMap = hostTotalTypes.mergedMap();\n\n size_t syncTypePhase = 0;\n if (!IS_HOST0) {\n for (auto i = hTotalMap.cbegin(), end_i = hTotalMap.cend(); i != end_i;\n ++i) {\n SendBuffer b;\n gSerialize(b, hTotalMap.region(i), hTotalMap.category(i),\n hTotalMap.stat(i).totalTy());\n getSystemNetworkInterface().sendTagged(0, galois::runtime::evilPhase, b,\n syncTypePhase);\n }\n }\n\n ++syncTypePhase;\n for (auto i = Base::intBegin(), end_i = Base::intEnd(); i != end_i; ++i) {\n Str ln;\n Str cat;\n int64_t thrdTotal;\n StatTotal::Type totalTy;\n galois::gstl::Vector thrdVals;\n\n Base::readIntStat(i, ln, cat, thrdTotal, totalTy, thrdVals);\n\n if (IS_HOST0) {\n addRecvdStat(0, ln, cat, thrdTotal, totalTy, thrdVals);\n\n } else {\n SendBuffer b;\n gSerialize(b, ln, cat, thrdTotal, totalTy, thrdVals);\n getSystemNetworkInterface().sendTagged(0, galois::runtime::evilPhase, b,\n syncTypePhase);\n }\n }\n}\n\nvoid DistStatManager::combineAtHost_0_helper2(void) {\n const bool IS_HOST0 = getHostID() == 0;\n\n size_t syncTypePhase = 0;\n for (auto i = Base::fpBegin(), end_i = Base::fpEnd(); i != end_i; ++i) {\n Str ln;\n Str cat;\n double thrdTotal;\n StatTotal::Type totalTy;\n galois::gstl::Vector thrdVals;\n\n Base::readFPstat(i, ln, cat, thrdTotal, totalTy, thrdVals);\n\n if (IS_HOST0) {\n addRecvdStat(0, ln, cat, thrdTotal, totalTy, thrdVals);\n\n } else {\n SendBuffer b;\n gSerialize(b, ln, cat, thrdTotal, totalTy, thrdVals);\n getSystemNetworkInterface().sendTagged(0, galois::runtime::evilPhase, b,\n syncTypePhase);\n }\n }\n\n ++syncTypePhase;\n for (auto i = Base::paramBegin(), end_i = Base::paramEnd(); i != end_i; ++i) {\n Str ln;\n Str cat;\n Str thrdTotal;\n StatTotal::Type totalTy;\n galois::gstl::Vector thrdVals;\n\n Base::readParam(i, ln, cat, thrdTotal, totalTy, thrdVals);\n\n if (IS_HOST0) {\n addRecvdParam(0, ln, cat, thrdTotal, totalTy, thrdVals);\n\n } else {\n SendBuffer b;\n gSerialize(b, ln, cat, thrdTotal, totalTy, thrdVals);\n getSystemNetworkInterface().sendTagged(0, galois::runtime::evilPhase, b,\n syncTypePhase);\n }\n }\n}\n\nvoid DistStatManager::receiveAtHost_0_helper(void) {\n size_t syncTypePhase = 0;\n {\n decltype(getSystemNetworkInterface().recieveTagged(\n galois::runtime::evilPhase, nullptr, syncTypePhase)) p;\n do {\n p = getSystemNetworkInterface().recieveTagged(galois::runtime::evilPhase,\n nullptr, syncTypePhase);\n\n if (p) {\n RecvBuffer& b = p->second;\n\n galois::gstl::Str region;\n galois::gstl::Str category;\n StatTotal::Type totalTy;\n gDeserialize(b, region, category, totalTy);\n\n StatRecvHelper::recvAtHost_0_hostTotalTy(region, category, totalTy);\n }\n } while (p);\n }\n\n ++syncTypePhase;\n {\n decltype(getSystemNetworkInterface().recieveTagged(\n galois::runtime::evilPhase, nullptr, syncTypePhase)) p;\n do {\n p = getSystemNetworkInterface().recieveTagged(galois::runtime::evilPhase,\n nullptr, syncTypePhase);\n\n if (p) {\n uint32_t hostID = p->first;\n RecvBuffer& b = p->second;\n\n Str ln;\n Str cat;\n int64_t thrdTotal;\n StatTotal::Type totalTy;\n galois::gstl::Vector thrdVals;\n gDeserialize(b, ln, cat, thrdTotal, totalTy, thrdVals);\n\n StatRecvHelper::recvAtHost_0_int(hostID, ln, cat, thrdTotal, totalTy,\n thrdVals);\n }\n } while (p);\n }\n}\n\nvoid DistStatManager::receiveAtHost_0_helper2(void) {\n size_t syncTypePhase = 0;\n {\n decltype(getSystemNetworkInterface().recieveTagged(\n galois::runtime::evilPhase, nullptr, syncTypePhase)) p;\n do {\n p = getSystemNetworkInterface().recieveTagged(galois::runtime::evilPhase,\n nullptr, syncTypePhase);\n\n if (p) {\n uint32_t hostID = p->first;\n RecvBuffer& b = p->second;\n\n Str ln;\n Str cat;\n double thrdTotal;\n StatTotal::Type totalTy;\n galois::gstl::Vector thrdVals;\n gDeserialize(b, ln, cat, thrdTotal, totalTy, thrdVals);\n\n StatRecvHelper::recvAtHost_0_fp(hostID, ln, cat, thrdTotal, totalTy,\n thrdVals);\n }\n } while (p);\n }\n\n ++syncTypePhase;\n {\n decltype(getSystemNetworkInterface().recieveTagged(\n galois::runtime::evilPhase, nullptr, syncTypePhase)) p;\n do {\n p = getSystemNetworkInterface().recieveTagged(galois::runtime::evilPhase,\n nullptr, syncTypePhase);\n\n if (p) {\n uint32_t hostID = p->first;\n RecvBuffer& b = p->second;\n\n Str ln;\n Str cat;\n Str thrdTotal;\n StatTotal::Type totalTy;\n galois::gstl::Vector thrdVals;\n gDeserialize(b, ln, cat, thrdTotal, totalTy, thrdVals);\n\n StatRecvHelper::recvAtHost_0_str(hostID, ln, cat, thrdTotal, totalTy,\n thrdVals);\n }\n } while (p);\n }\n}\n\nvoid DistStatManager::combineAtHost_0(void) {\n galois::DGTerminator td;\n\n // host 0 reads stats from Base class\n // other hosts send stats to host 0\n combineAtHost_0_helper();\n getSystemNetworkInterface().flush();\n\n // work done before check\n td += 1;\n\n // barrier\n while (td.reduce()) {\n td.reset();\n if (getHostID() == 0) {\n // receive from other hosts\n receiveAtHost_0_helper();\n }\n }\n\n // explicit barrier after logical barrier is required\n // as next async phase begins immediately\n getHostBarrier().wait();\n\n // host 0 reads stats from Base class\n // other hosts send stats to host 0\n combineAtHost_0_helper2();\n getSystemNetworkInterface().flush();\n\n td += 1;\n\n // barrier\n while (td.reduce()) {\n td.reset();\n\n if (getHostID() == 0) {\n // receive from other hosts\n receiveAtHost_0_helper2();\n }\n }\n\n // explicit barrier after logical barrier is required\n // as next async phase begins immediately\n getHostBarrier().wait();\n}\n\nbool DistStatManager::printingHostVals(void) {\n return galois::substrate::EnvCheck(DistStatManager::HSTAT_ENV_VAR);\n}\n\nStatTotal::Type\nDistStatManager::findHostTotalTy(const Str& region, const Str& category,\n const StatTotal::Type& thrdTotalTy) const {\n\n StatTotal::Type hostTotalTy = thrdTotalTy;\n\n auto& mrgMap = hostTotalTypes.mergedMap();\n\n auto i = mrgMap.findStat(region, category);\n if (i != mrgMap.cend()) {\n hostTotalTy = mrgMap.stat(i).totalTy();\n }\n\n return hostTotalTy;\n}\n\nvoid DistStatManager::addRecvdHostTotalTy(const Str& region,\n const Str& category,\n const StatTotal::Type& totalTy) {\n hostTotalTypes.addToStat(region, category, totalTy);\n}\n\nvoid DistStatManager::addRecvdStat(\n unsigned hostID, const Str& region, const Str& category, int64_t thrdTotal,\n const StatTotal::Type& thrdTotalTy,\n const DistStatManager::ThrdVals& thrdVals) {\n\n intDistStats.addToStat(\n region, category,\n std::make_tuple(hostID, thrdTotal, thrdTotalTy, thrdVals),\n findHostTotalTy(region, category, thrdTotalTy));\n}\n\nvoid DistStatManager::addRecvdStat(\n unsigned hostID, const Str& region, const Str& category, double thrdTotal,\n const StatTotal::Type& thrdTotalTy,\n const DistStatManager::ThrdVals& thrdVals) {\n\n fpDistStats.addToStat(\n region, category,\n std::make_tuple(hostID, thrdTotal, thrdTotalTy, thrdVals),\n findHostTotalTy(region, category, thrdTotalTy));\n}\n\nvoid DistStatManager::addRecvdParam(\n unsigned hostID, const Str& region, const Str& category,\n const Str& thrdTotal, const StatTotal::Type& thrdTotalTy,\n const DistStatManager::ThrdVals& thrdVals) {\n\n strDistStats.addToStat(\n region, category,\n std::make_tuple(hostID, thrdTotal, thrdTotalTy, thrdVals),\n findHostTotalTy(region, category, thrdTotalTy));\n}\n\nvoid DistStatManager::printHeader(std::ostream& out) const {\n out << \"STAT_TYPE\" << SEP;\n out << \"HOST_ID\" << SEP;\n out << \"REGION\" << SEP << \"CATEGORY\" << SEP;\n out << \"TOTAL_TYPE\" << SEP << \"TOTAL\";\n\n out << std::endl;\n}\n\nvoid DistStatManager::printStats(std::ostream& out) {\n mergeStats();\n\n galois::DGTerminator td;\n if (getHostID() == 0) {\n printHeader(out);\n\n intDistStats.print(out);\n fpDistStats.print(out);\n strDistStats.print(out);\n }\n // all hosts must wait for host 0 to finish printing stats\n while (td.reduce()) {\n };\n}\n" }, { "path": "libdist/src/Network.cpp", "content": "/*\n * This file belongs to the Galois project, a C++ library for exploiting\n * parallelism. The code is being released under the terms of the 3-Clause BSD\n * License (a copy is located in LICENSE.txt at the top-level directory).\n *\n * Copyright (C) 2018, The University of Texas at Austin. All rights reserved.\n * UNIVERSITY EXPRESSLY DISCLAIMS ANY AND ALL WARRANTIES CONCERNING THIS\n * SOFTWARE AND DOCUMENTATION, INCLUDING ANY WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR ANY PARTICULAR PURPOSE, NON-INFRINGEMENT AND WARRANTIES OF\n * PERFORMANCE, AND ANY WARRANTY THAT MIGHT OTHERWISE ARISE FROM COURSE OF\n * DEALING OR USAGE OF TRADE. NO WARRANTY IS EITHER EXPRESS OR IMPLIED WITH\n * RESPECT TO THE USE OF THE SOFTWARE OR DOCUMENTATION. Under no circumstances\n * shall University be liable for incidental, special, indirect, direct or\n * consequential damages or loss of profits, interruption of business, or\n * related expenses which may arise from use of Software or Documentation,\n * including but not limited to those resulting from defects in Software and/or\n * Documentation, or loss or inaccuracy of data of any kind.\n */\n\n/**\n * @file Network.cpp\n *\n * Contains implementations for basic NetworkInterface functions and\n * initializations of some NetworkInterface variables.\n */\n\n#include \"galois/runtime/Tracer.h\"\n#include \"galois/runtime/Network.h\"\n#include \"galois/runtime/NetworkIO.h\"\n\n#include \n#include \n\nusing namespace galois::runtime;\n\nuint32_t galois::runtime::evilPhase = 1;\n\nuint32_t galois::runtime::NetworkInterface::ID = 0;\nuint32_t galois::runtime::NetworkInterface::Num = 1;\n\nuint32_t galois::runtime::getHostID() { return NetworkInterface::ID; }\n\ngalois::runtime::NetworkIO::~NetworkIO() {}\n\nvoid NetworkInterface::initializeMPI() {\n int supportProvided;\n int initSuccess =\n MPI_Init_thread(NULL, NULL, MPI_THREAD_MULTIPLE, &supportProvided);\n if (initSuccess != MPI_SUCCESS) {\n MPI_Abort(MPI_COMM_WORLD, initSuccess);\n }\n\n if (supportProvided != MPI_THREAD_MULTIPLE) {\n GALOIS_DIE(\"MPI_THREAD_MULTIPLE not supported.\");\n }\n}\n\nvoid NetworkInterface::finalizeMPI() {\n int finalizeSuccess = MPI_Finalize();\n\n if (finalizeSuccess != MPI_SUCCESS) {\n MPI_Abort(MPI_COMM_WORLD, finalizeSuccess);\n }\n\n galois::gDebug(\"[\", NetworkInterface::ID, \"] MPI finalized\");\n}\n\nNetworkInterface::NetworkInterface() {}\n\nNetworkInterface::~NetworkInterface() {}\n\nvoid NetworkInterface::reportMemUsage() const {\n std::string str(\"CommunicationMemUsage\");\n galois::runtime::reportStat_Tmin(\"dGraph\", str + \"Min\",\n memUsageTracker.getMaxMemUsage());\n galois::runtime::reportStat_Tmax(\"dGraph\", str + \"Max\",\n memUsageTracker.getMaxMemUsage());\n}\n\n// forward decl\n//! Receive broadcasted messages over the network\nstatic void bcastLandingPad(uint32_t src, ::RecvBuffer& buf);\n\nstatic void bcastLandingPad(uint32_t src, RecvBuffer& buf) {\n uintptr_t fp;\n gDeserialize(buf, fp);\n auto recv = (void (*)(uint32_t, RecvBuffer&))fp;\n trace(\"NetworkInterface::bcastLandingPad\", (void*)recv);\n recv(src, buf);\n}\n\nvoid NetworkInterface::sendMsg(uint32_t dest,\n void (*recv)(uint32_t, RecvBuffer&),\n SendBuffer& buf) {\n gSerialize(buf, recv);\n sendTagged(dest, 0, buf);\n}\n\nvoid NetworkInterface::broadcast(void (*recv)(uint32_t, RecvBuffer&),\n SendBuffer& buf, bool self) {\n trace(\"NetworkInterface::broadcast\", (void*)recv);\n auto fp = (uintptr_t)recv;\n for (unsigned x = 0; x < Num; ++x) {\n if (x != ID) {\n SendBuffer b;\n gSerialize(b, fp, buf, (uintptr_t)&bcastLandingPad);\n sendTagged(x, 0, b);\n } else if (self) {\n RecvBuffer rb(buf.begin(), buf.end());\n recv(ID, rb);\n }\n }\n}\n\nvoid NetworkInterface::handleReceives() {\n std::unique_lock lg;\n auto opt = recieveTagged(0, &lg);\n while (opt) {\n uint32_t src = std::get<0>(*opt);\n RecvBuffer& buf = std::get<1>(*opt);\n uintptr_t fp = 0;\n gDeserializeRaw(buf.r_linearData() + buf.r_size() - sizeof(uintptr_t), fp);\n buf.pop_back(sizeof(uintptr_t));\n assert(fp);\n auto f = (void (*)(uint32_t, RecvBuffer&))fp;\n f(src, buf);\n opt = recieveTagged(0, &lg);\n }\n}\n\nNetworkInterface& galois::runtime::getSystemNetworkInterface() {\n#ifndef GALOIS_USE_LCI\n return makeNetworkBuffered();\n#else\n return makeNetworkLCI();\n#endif\n}\n\nvoid galois::runtime::internal::destroySystemNetworkInterface() {\n // get net interface, then delete it\n NetworkInterface& netInterface = getSystemNetworkInterface();\n delete &netInterface;\n}\n" }, { "path": "libdist/src/NetworkBuffered.cpp", "content": "/*\n * This file belongs to the Galois project, a C++ library for exploiting\n * parallelism. The code is being released under the terms of the 3-Clause BSD\n * License (a copy is located in LICENSE.txt at the top-level directory).\n *\n * Copyright (C) 2018, The University of Texas at Austin. All rights reserved.\n * UNIVERSITY EXPRESSLY DISCLAIMS ANY AND ALL WARRANTIES CONCERNING THIS\n * SOFTWARE AND DOCUMENTATION, INCLUDING ANY WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR ANY PARTICULAR PURPOSE, NON-INFRINGEMENT AND WARRANTIES OF\n * PERFORMANCE, AND ANY WARRANTY THAT MIGHT OTHERWISE ARISE FROM COURSE OF\n * DEALING OR USAGE OF TRADE. NO WARRANTY IS EITHER EXPRESS OR IMPLIED WITH\n * RESPECT TO THE USE OF THE SOFTWARE OR DOCUMENTATION. Under no circumstances\n * shall University be liable for incidental, special, indirect, direct or\n * consequential damages or loss of profits, interruption of business, or\n * related expenses which may arise from use of Software or Documentation,\n * including but not limited to those resulting from defects in Software and/or\n * Documentation, or loss or inaccuracy of data of any kind.\n */\n\n/**\n * @file NetworkBuffered.cpp\n *\n * Contains NetworkInterfaceBuffered, an implementation of a network interface\n * that buffers messages before sending them out.\n *\n * @todo document this file more\n */\n\n#include \"galois/runtime/Network.h\"\n#include \"galois/runtime/NetworkIO.h\"\n#include \"galois/runtime/Tracer.h\"\n\n#ifdef GALOIS_USE_LCI\n#define NO_AGG\n#endif\n\n#include \n#include \n#include \n#include \n\nusing namespace galois::runtime;\nusing namespace galois::substrate;\n\nnamespace {\n\n/**\n * @class NetworkInterfaceBuffered\n *\n * Buffered network interface: messages are buffered before they are sent out.\n * A single worker thread is initialized to send/receive messages from/to\n * buffers.\n */\nclass NetworkInterfaceBuffered : public NetworkInterface {\n static const int COMM_MIN =\n 1400; //! bytes (sligtly smaller than an ethernet packet)\n static const int COMM_DELAY = 100; //! microseconds delay\n\n unsigned long statSendNum;\n unsigned long statSendBytes;\n unsigned long statSendEnqueued;\n unsigned long statRecvNum;\n unsigned long statRecvBytes;\n unsigned long statRecvDequeued;\n bool anyReceivedMessages;\n\n // using vTy = std::vector;\n using vTy = galois::PODResizeableArray;\n\n /**\n * Receive buffers for the buffered network interface\n */\n class recvBuffer {\n std::deque data;\n size_t frontOffset;\n SimpleLock qlock;\n // tag of head of queue\n std::atomic dataPresent;\n\n bool sizeAtLeast(size_t n, uint32_t tag) {\n size_t tot = -frontOffset;\n for (auto& v : data) {\n if (v.tag == tag) {\n tot += v.data.size();\n if (tot >= n)\n return true;\n } else {\n return false;\n }\n }\n return false;\n }\n\n template \n void copyOut(IterTy it, size_t n) {\n // assert(sizeAtLeast(n));\n // fast path is first buffer\n { // limit scope\n auto& f0data = data[0].data;\n for (int k = frontOffset, ke = f0data.size(); k < ke && n; ++k, --n)\n *it++ = f0data[k];\n }\n if (n) { // more data (slow path)\n for (int j = 1, je = data.size(); j < je && n; ++j) {\n auto& vdata = data[j].data;\n for (int k = 0, ke = vdata.size(); k < ke && n; ++k, --n) {\n *it++ = vdata[k];\n }\n }\n }\n }\n\n /**\n * Return a (moved) vector if the len bytes requested are the last len\n * bytes of the front of the buffer queue\n */\n std::optional popVec(uint32_t len,\n std::atomic& inflightRecvs) {\n if (data[0].data.size() == frontOffset + len) {\n vTy retval(std::move(data[0].data));\n data.pop_front();\n --inflightRecvs;\n frontOffset = 0;\n if (data.size()) {\n dataPresent = data.front().tag;\n } else {\n dataPresent = ~0;\n }\n return std::optional(std::move(retval));\n } else {\n return std::optional();\n }\n }\n\n void erase(size_t n, std::atomic& inflightRecvs) {\n frontOffset += n;\n while (frontOffset && frontOffset >= data.front().data.size()) {\n frontOffset -= data.front().data.size();\n data.pop_front();\n --inflightRecvs;\n }\n if (data.size()) {\n dataPresent = data.front().tag;\n } else {\n dataPresent = ~0;\n }\n }\n\n uint32_t getLenFromFront(uint32_t tag) {\n if (sizeAtLeast(sizeof(uint32_t), tag)) {\n union {\n uint8_t a[sizeof(uint32_t)];\n uint32_t b;\n } c;\n copyOut(&c.a[0], sizeof(uint32_t));\n return c.b;\n } else {\n return ~0;\n }\n }\n\n public:\n std::optional popMsg(uint32_t tag,\n std::atomic& inflightRecvs) {\n std::lock_guard lg(qlock);\n#ifndef NO_AGG\n uint32_t len = getLenFromFront(tag);\n // assert(len);\n if (len == ~0U || len == 0)\n return std::optional();\n if (!sizeAtLeast(sizeof(uint32_t) + len, tag))\n return std::optional();\n erase(4, inflightRecvs);\n\n // Try just using the buffer\n if (auto r = popVec(len, inflightRecvs)) {\n auto start = r->size() - len;\n // std::cerr << \"FP \" << r->size() << \" \" << len << \" \" << start\n // << \"\\n\";\n return std::optional(RecvBuffer(std::move(*r), start));\n }\n\n RecvBuffer buf(len);\n // FIXME: This is slows things down 25%\n copyOut((char*)buf.linearData(), len);\n erase(len, inflightRecvs);\n // std::cerr << \"p \" << tag << \" \" << len << \"\\n\";\n return std::optional(std::move(buf));\n#else\n if (data.empty() || data.front().tag != tag)\n return std::optional();\n\n vTy vec(std::move(data.front().data));\n\n data.pop_front();\n --inflightRecvs;\n if (!data.empty()) {\n dataPresent = data.front().tag;\n } else {\n dataPresent = ~0;\n }\n\n return std::optional(RecvBuffer(std::move(vec), 0));\n#endif\n }\n\n // Worker thread interface\n void add(NetworkIO::message m) {\n std::lock_guard lg(qlock);\n if (data.empty()) {\n galois::runtime::trace(\"ADD LATEST \", m.tag);\n dataPresent = m.tag;\n }\n\n // std::cerr << m.data.size() << \" \" <<\n // std::count(m.data.begin(), m.data.end(), 0) << \"\\n\";\n // for (auto x : m.data) {\n // std::cerr << (int) x << \" \";\n // }\n // std::cerr << \"\\n\";\n // std::cerr << \"A \" << m.host << \" \" << m.tag << \" \" << m.data.size() <<\n // \"\\n\";\n\n data.push_back(std::move(m));\n\n assert(data.back().data.size() !=\n (unsigned int)std::count(data.back().data.begin(),\n data.back().data.end(), 0));\n }\n\n bool hasData(uint32_t tag) { return dataPresent == tag; }\n\n size_t size() { return data.size(); }\n\n uint32_t getPresentTag() { return dataPresent; }\n }; // end recv buffer class\n\n std::vector recvData;\n std::vector recvLock;\n\n /**\n * Send buffers for the buffered network interface\n */\n class sendBuffer {\n struct msg {\n uint32_t tag;\n vTy data;\n msg(uint32_t t, vTy& _data) : tag(t), data(std::move(_data)) {}\n };\n\n std::deque messages;\n std::atomic numBytes;\n std::atomic urgent;\n //! @todo FIXME track time since some epoch in an atomic.\n std::chrono::high_resolution_clock::time_point time;\n SimpleLock lock, timelock;\n\n public:\n unsigned long statSendTimeout;\n unsigned long statSendOverflow;\n unsigned long statSendUrgent;\n\n size_t size() { return messages.size(); }\n\n void markUrgent() {\n if (numBytes) {\n std::lock_guard lg(lock);\n urgent = messages.size();\n }\n }\n\n bool ready() {\n#ifndef NO_AGG\n if (numBytes == 0)\n return false;\n if (urgent) {\n ++statSendUrgent;\n return true;\n }\n if (numBytes > COMM_MIN) {\n ++statSendOverflow;\n return true;\n }\n auto n = std::chrono::high_resolution_clock::now();\n decltype(n) mytime;\n {\n std::lock_guard lg(timelock);\n mytime = time;\n }\n auto elapsed =\n std::chrono::duration_cast(n - mytime);\n if (elapsed.count() > COMM_DELAY) {\n ++statSendTimeout;\n return true;\n }\n return false;\n#else\n return messages.size() > 0;\n#endif\n }\n\n std::pair\n assemble(std::atomic& GALOIS_UNUSED(inflightSends)) {\n std::unique_lock lg(lock);\n if (messages.empty())\n return std::make_pair(~0, vTy());\n#ifndef NO_AGG\n // compute message size\n uint32_t len = 0;\n int num = 0;\n uint32_t tag = messages.front().tag;\n for (auto& m : messages) {\n if (m.tag != tag) {\n break;\n } else {\n // do not let it go over the integer limit because MPI_Isend cannot\n // deal with it\n if ((m.data.size() + sizeof(uint32_t) + len + num) >\n static_cast(std::numeric_limits::max())) {\n break;\n }\n len += m.data.size();\n num += sizeof(uint32_t);\n }\n }\n lg.unlock();\n // construct message\n vTy vec;\n vec.reserve(len + num);\n // go out of our way to avoid locking out senders when making messages\n lg.lock();\n do {\n auto& m = messages.front();\n lg.unlock();\n union {\n uint32_t a;\n uint8_t b[sizeof(uint32_t)];\n } foo;\n foo.a = m.data.size();\n vec.insert(vec.end(), &foo.b[0], &foo.b[sizeof(uint32_t)]);\n vec.insert(vec.end(), m.data.begin(), m.data.end());\n if (urgent)\n --urgent;\n lg.lock();\n messages.pop_front();\n --inflightSends;\n } while (vec.size() < len + num);\n ++inflightSends;\n numBytes -= len;\n#else\n uint32_t tag = messages.front().tag;\n vTy vec(std::move(messages.front().data));\n messages.pop_front();\n#endif\n return std::make_pair(tag, std::move(vec));\n }\n\n void add(uint32_t tag, vTy& b) {\n std::lock_guard lg(lock);\n if (messages.empty()) {\n std::lock_guard lg(timelock);\n time = std::chrono::high_resolution_clock::now();\n }\n unsigned oldNumBytes = numBytes;\n numBytes += b.size();\n galois::runtime::trace(\"BufferedAdd\", oldNumBytes, numBytes, tag,\n galois::runtime::printVec(b));\n messages.emplace_back(tag, b);\n }\n }; // end send buffer class\n\n std::vector sendData;\n\n void workerThread() {\n initializeMPI();\n int rank;\n int hostSize;\n\n int rankSuccess = MPI_Comm_rank(MPI_COMM_WORLD, &rank);\n if (rankSuccess != MPI_SUCCESS) {\n MPI_Abort(MPI_COMM_WORLD, rankSuccess);\n }\n\n int sizeSuccess = MPI_Comm_size(MPI_COMM_WORLD, &hostSize);\n if (sizeSuccess != MPI_SUCCESS) {\n MPI_Abort(MPI_COMM_WORLD, sizeSuccess);\n }\n\n galois::gDebug(\"[\", NetworkInterface::ID, \"] MPI initialized\");\n std::tie(netio, ID, Num) =\n makeNetworkIOMPI(memUsageTracker, inflightSends, inflightRecvs);\n\n assert(ID == (unsigned)rank);\n assert(Num == (unsigned)hostSize);\n\n ready = 1;\n while (ready < 2) { /*fprintf(stderr, \"[WaitOnReady-2]\");*/\n };\n while (ready != 3) {\n for (unsigned i = 0; i < sendData.size(); ++i) {\n netio->progress();\n // handle send queue i\n auto& sd = sendData[i];\n if (sd.ready()) {\n NetworkIO::message msg;\n msg.host = i;\n std::tie(msg.tag, msg.data) = sd.assemble(inflightSends);\n galois::runtime::trace(\"BufferedSending\", msg.host, msg.tag,\n galois::runtime::printVec(msg.data));\n ++statSendEnqueued;\n netio->enqueue(std::move(msg));\n }\n // handle receive\n NetworkIO::message rdata = netio->dequeue();\n if (rdata.data.size()) {\n ++statRecvDequeued;\n assert(rdata.data.size() !=\n (unsigned int)std::count(rdata.data.begin(), rdata.data.end(),\n 0));\n galois::runtime::trace(\"BufferedRecieving\", rdata.host, rdata.tag,\n galois::runtime::printVec(rdata.data));\n recvData[rdata.host].add(std::move(rdata));\n }\n }\n }\n finalizeMPI();\n }\n\n std::thread worker;\n std::atomic ready;\n\npublic:\n using NetworkInterface::ID;\n using NetworkInterface::Num;\n\n NetworkInterfaceBuffered() {\n inflightSends = 0;\n inflightRecvs = 0;\n ready = 0;\n anyReceivedMessages = false;\n worker = std::thread(&NetworkInterfaceBuffered::workerThread, this);\n while (ready != 1) {\n };\n recvData = decltype(recvData)(Num);\n recvLock.resize(Num);\n sendData = decltype(sendData)(Num);\n ready = 2;\n }\n\n virtual ~NetworkInterfaceBuffered() {\n ready = 3;\n worker.join();\n }\n\n std::unique_ptr netio;\n\n virtual void sendTagged(uint32_t dest, uint32_t tag, SendBuffer& buf,\n int phase) {\n ++inflightSends;\n tag += phase;\n statSendNum += 1;\n statSendBytes += buf.size();\n galois::runtime::trace(\"sendTagged\", dest, tag,\n galois::runtime::printVec(buf.getVec()));\n auto& sd = sendData[dest];\n sd.add(tag, buf.getVec());\n }\n\n virtual std::optional>\n recieveTagged(uint32_t tag,\n std::unique_lock* rlg,\n int phase) {\n tag += phase;\n for (unsigned h = 0; h < recvData.size(); ++h) {\n auto& rq = recvData[h];\n if (rq.hasData(tag)) {\n if (recvLock[h].try_lock()) {\n std::unique_lock lg(recvLock[h],\n std::adopt_lock);\n auto buf = rq.popMsg(tag, inflightRecvs);\n if (buf) {\n ++statRecvNum;\n statRecvBytes += buf->size();\n memUsageTracker.decrementMemUsage(buf->size());\n if (rlg)\n *rlg = std::move(lg);\n galois::runtime::trace(\"recvTagged\", h, tag,\n galois::runtime::printVec(buf->getVec()));\n anyReceivedMessages = true;\n return std::optional>(\n std::make_pair(h, std::move(*buf)));\n }\n }\n }\n galois::runtime::trace(\"recvTagged BLOCKED this by that\", tag,\n rq.getPresentTag());\n }\n\n return std::optional>();\n }\n\n virtual void flush() {\n for (auto& sd : sendData)\n sd.markUrgent();\n }\n\n virtual bool anyPendingSends() { return (inflightSends > 0); }\n\n virtual bool anyPendingReceives() {\n if (anyReceivedMessages) { // might not be acted on by the computation yet\n anyReceivedMessages = false;\n // galois::gDebug(\"[\", ID, \"] receive out of buffer \\n\");\n return true;\n }\n // if (inflightRecvs > 0) {\n // galois::gDebug(\"[\", ID, \"] inflight receive: \", inflightRecvs, \" \\n\");\n // }\n return (inflightRecvs > 0);\n }\n\n virtual unsigned long reportSendBytes() const { return statSendBytes; }\n virtual unsigned long reportSendMsgs() const { return statSendNum; }\n virtual unsigned long reportRecvBytes() const { return statRecvBytes; }\n virtual unsigned long reportRecvMsgs() const { return statRecvNum; }\n\n virtual std::vector reportExtra() const {\n std::vector retval(5);\n for (auto& sd : sendData) {\n retval[0] += sd.statSendTimeout;\n retval[1] += sd.statSendOverflow;\n retval[2] += sd.statSendUrgent;\n }\n retval[3] = statSendEnqueued;\n retval[4] = statRecvDequeued;\n return retval;\n }\n\n virtual std::vector>\n reportExtraNamed() const {\n std::vector> retval(5);\n retval[0].first = \"SendTimeout\";\n retval[1].first = \"SendOverflow\";\n retval[2].first = \"SendUrgent\";\n retval[3].first = \"SendEnqueued\";\n retval[4].first = \"RecvDequeued\";\n for (auto& sd : sendData) {\n retval[0].second += sd.statSendTimeout;\n retval[1].second += sd.statSendOverflow;\n retval[2].second += sd.statSendUrgent;\n }\n retval[3].second = statSendEnqueued;\n retval[4].second = statRecvDequeued;\n return retval;\n }\n};\n\n} // namespace\n\n/**\n * Create a buffered network interface, or return one if already\n * created.\n */\nNetworkInterface& galois::runtime::makeNetworkBuffered() {\n static std::atomic net;\n static substrate::SimpleLock m_mutex;\n\n // create the interface if it doesn't yet exist in the static variable\n auto* tmp = net.load();\n if (tmp == nullptr) {\n std::lock_guard lock(m_mutex);\n tmp = net.load();\n if (tmp == nullptr) {\n tmp = new NetworkInterfaceBuffered();\n net.store(tmp);\n }\n }\n\n return *tmp;\n}\n" }, { "path": "libdist/src/NetworkIOMPI.cpp", "content": "/*\n * This file belongs to the Galois project, a C++ library for exploiting\n * parallelism. The code is being released under the terms of the 3-Clause BSD\n * License (a copy is located in LICENSE.txt at the top-level directory).\n *\n * Copyright (C) 2018, The University of Texas at Austin. All rights reserved.\n * UNIVERSITY EXPRESSLY DISCLAIMS ANY AND ALL WARRANTIES CONCERNING THIS\n * SOFTWARE AND DOCUMENTATION, INCLUDING ANY WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR ANY PARTICULAR PURPOSE, NON-INFRINGEMENT AND WARRANTIES OF\n * PERFORMANCE, AND ANY WARRANTY THAT MIGHT OTHERWISE ARISE FROM COURSE OF\n * DEALING OR USAGE OF TRADE. NO WARRANTY IS EITHER EXPRESS OR IMPLIED WITH\n * RESPECT TO THE USE OF THE SOFTWARE OR DOCUMENTATION. Under no circumstances\n * shall University be liable for incidental, special, indirect, direct or\n * consequential damages or loss of profits, interruption of business, or\n * related expenses which may arise from use of Software or Documentation,\n * including but not limited to those resulting from defects in Software and/or\n * Documentation, or loss or inaccuracy of data of any kind.\n */\n\n/**\n * @file NetworkIOMPI.cpp\n *\n * Contains an implementation of network IO that uses MPI.\n */\n\n#include \"galois/runtime/NetworkIO.h\"\n#include \"galois/runtime/Tracer.h\"\n#include \"galois/substrate/SimpleLock.h\"\n\n/**\n * MPI implementation of network IO. ASSUMES THAT MPI IS INITIALIZED\n * UPON CREATION OF THIS OBJECT.\n */\nclass NetworkIOMPI : public galois::runtime::NetworkIO {\nprivate:\n /**\n * Get the host id of the caller.\n *\n * @returns host id of the caller with regard to the MPI setup\n */\n static int getID() {\n int taskRank;\n handleError(MPI_Comm_rank(MPI_COMM_WORLD, &taskRank));\n return taskRank;\n }\n\n /**\n * Get the total number of hosts in the system.\n *\n * @returns number of hosts with regard to the MPI setup\n */\n static int getNum() {\n int numTasks;\n handleError(MPI_Comm_size(MPI_COMM_WORLD, &numTasks));\n return numTasks;\n }\n\n /**\n * Get both the ID of the caller + number of hosts.\n */\n std::pair getIDAndHostNum() {\n return std::make_pair(getID(), getNum());\n }\n\n /**\n * Message type to send/recv in this network IO layer.\n */\n struct mpiMessage {\n uint32_t host;\n uint32_t tag;\n vTy data;\n MPI_Request req;\n // mpiMessage(message&& _m, MPI_Request _req) : m(std::move(_m)), req(_req)\n // {}\n mpiMessage(uint32_t host, uint32_t tag, vTy&& data)\n : host(host), tag(tag), data(std::move(data)) {}\n mpiMessage(uint32_t host, uint32_t tag, size_t len)\n : host(host), tag(tag), data(len) {}\n };\n\n /**\n * Send queue structure.\n */\n struct sendQueueTy {\n std::deque inflight;\n\n galois::runtime::MemUsageTracker& memUsageTracker;\n\n std::atomic& inflightSends;\n\n sendQueueTy(galois::runtime::MemUsageTracker& tracker,\n std::atomic& sends)\n : memUsageTracker(tracker), inflightSends(sends) {}\n\n void complete() {\n while (!inflight.empty()) {\n int flag = 0;\n MPI_Status status;\n auto& f = inflight.front();\n int rv = MPI_Test(&f.req, &flag, &status);\n handleError(rv);\n if (flag) {\n memUsageTracker.decrementMemUsage(f.data.size());\n inflight.pop_front();\n --inflightSends;\n } else\n break;\n }\n }\n\n void send(message m) {\n inflight.emplace_back(m.host, m.tag, std::move(m.data));\n auto& f = inflight.back();\n galois::runtime::trace(\"MPI SEND\", f.host, f.tag, f.data.size(),\n galois::runtime::printVec(f.data));\n#ifdef GALOIS_SUPPORT_ASYNC\n int rv = MPI_Issend(f.data.data(), f.data.size(), MPI_BYTE, f.host, f.tag,\n MPI_COMM_WORLD, &f.req);\n#else\n int rv = MPI_Isend(f.data.data(), f.data.size(), MPI_BYTE, f.host, f.tag,\n MPI_COMM_WORLD, &f.req);\n#endif\n handleError(rv);\n }\n };\n\n /**\n * Receive queue structure\n */\n struct recvQueueTy {\n std::deque done;\n std::deque inflight;\n\n galois::runtime::MemUsageTracker& memUsageTracker;\n\n std::atomic& inflightRecvs;\n\n recvQueueTy(galois::runtime::MemUsageTracker& tracker,\n std::atomic& recvs)\n : memUsageTracker(tracker), inflightRecvs(recvs) {}\n\n // FIXME: Does synchronous recieves overly halt forward progress?\n void probe() {\n int flag = 0;\n MPI_Status status;\n // check for new messages\n int rv = MPI_Iprobe(MPI_ANY_SOURCE, MPI_ANY_TAG, MPI_COMM_WORLD, &flag,\n &status);\n handleError(rv);\n if (flag) {\n#ifdef GALOIS_USE_BARE_MPI\n assert(status.MPI_TAG <= 32767);\n if (status.MPI_TAG != 32767) {\n#endif\n ++inflightRecvs;\n int nbytes;\n rv = MPI_Get_count(&status, MPI_BYTE, &nbytes);\n handleError(rv);\n inflight.emplace_back(status.MPI_SOURCE, status.MPI_TAG, nbytes);\n auto& m = inflight.back();\n memUsageTracker.incrementMemUsage(m.data.size());\n rv = MPI_Irecv(m.data.data(), nbytes, MPI_BYTE, status.MPI_SOURCE,\n status.MPI_TAG, MPI_COMM_WORLD, &m.req);\n handleError(rv);\n galois::runtime::trace(\"MPI IRECV\", status.MPI_SOURCE, status.MPI_TAG,\n m.data.size());\n#ifdef GALOIS_USE_BARE_MPI\n }\n#endif\n }\n\n // complete messages\n if (!inflight.empty()) {\n auto& m = inflight.front();\n int flag = 0;\n rv = MPI_Test(&m.req, &flag, MPI_STATUS_IGNORE);\n handleError(rv);\n if (flag) {\n done.emplace_back(m.host, m.tag, std::move(m.data));\n inflight.pop_front();\n }\n }\n }\n };\n\n sendQueueTy sendQueue;\n recvQueueTy recvQueue;\n\npublic:\n /**\n * Constructor.\n *\n * @param tracker memory usage tracker\n * @param sends\n * @param recvs\n * @param [out] ID this machine's host id\n * @param [out] NUM total number of hosts in the system\n */\n NetworkIOMPI(galois::runtime::MemUsageTracker& tracker,\n std::atomic& sends, std::atomic& recvs,\n uint32_t& ID, uint32_t& NUM)\n : NetworkIO(tracker, sends, recvs), sendQueue(tracker, inflightSends),\n recvQueue(tracker, inflightRecvs) {\n auto p = getIDAndHostNum();\n ID = p.first;\n NUM = p.second;\n }\n\n /**\n * Adds a message to the send queue\n */\n virtual void enqueue(message m) {\n memUsageTracker.incrementMemUsage(m.data.size());\n sendQueue.send(std::move(m));\n }\n\n /**\n * Attempts to get a message from the recv queue.\n */\n virtual message dequeue() {\n if (!recvQueue.done.empty()) {\n auto msg = std::move(recvQueue.done.front());\n recvQueue.done.pop_front();\n return msg;\n }\n return message{~0U, 0, vTy()};\n }\n\n /**\n * Push progress forward in the system.\n */\n virtual void progress() {\n sendQueue.complete();\n recvQueue.probe();\n }\n}; // end NetworkIOMPI class\n\nstd::tuple, uint32_t, uint32_t>\ngalois::runtime::makeNetworkIOMPI(galois::runtime::MemUsageTracker& tracker,\n std::atomic& sends,\n std::atomic& recvs) {\n uint32_t ID, NUM;\n std::unique_ptr n{\n new NetworkIOMPI(tracker, sends, recvs, ID, NUM)};\n return std::make_tuple(std::move(n), ID, NUM);\n}\n" }, { "path": "libdist/src/NetworkLCI.cpp", "content": "/*\n * This file belongs to the Galois project, a C++ library for exploiting\n * parallelism. The code is being released under the terms of the 3-Clause BSD\n * License (a copy is located in LICENSE.txt at the top-level directory).\n *\n * Copyright (C) 2018, The University of Texas at Austin. All rights reserved.\n * UNIVERSITY EXPRESSLY DISCLAIMS ANY AND ALL WARRANTIES CONCERNING THIS\n * SOFTWARE AND DOCUMENTATION, INCLUDING ANY WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR ANY PARTICULAR PURPOSE, NON-INFRINGEMENT AND WARRANTIES OF\n * PERFORMANCE, AND ANY WARRANTY THAT MIGHT OTHERWISE ARISE FROM COURSE OF\n * DEALING OR USAGE OF TRADE. NO WARRANTY IS EITHER EXPRESS OR IMPLIED WITH\n * RESPECT TO THE USE OF THE SOFTWARE OR DOCUMENTATION. Under no circumstances\n * shall University be liable for incidental, special, indirect, direct or\n * consequential damages or loss of profits, interruption of business, or\n * related expenses which may arise from use of Software or Documentation,\n * including but not limited to those resulting from defects in Software and/or\n * Documentation, or loss or inaccuracy of data of any kind.\n */\n\n/**\n * @file NetworkBuffered.cpp\n *\n * Contains NetworkInterfaceLCI, an implementation of a network interface\n * that buffers messages before sending them out.\n *\n * @todo document this file more\n */\n\n#ifdef GALOIS_USE_LCI\n#include \"galois/runtime/Network.h\"\n#include \"galois/runtime/NetworkIO.h\"\n#include \"galois/runtime/Tracer.h\"\n#include \"galois/runtime/LWCI.h\"\n\nusing vTy = galois::PODResizeableArray;\n\n#include \n#include \n#include \n#include \n#include \n\n#include \n\nusing namespace galois::runtime;\nusing namespace galois::substrate;\n\n/* CRC-32C (iSCSI) polynomial in reversed bit order. */\n#define POLY 0x82f63b78\ninline uint32_t crc32c(char* buf, size_t len) {\n uint32_t crc = 0;\n int k;\n\n crc = ~crc;\n while (len--) {\n crc ^= *buf++;\n for (k = 0; k < 8; k++)\n crc = crc & 1 ? (crc >> 1) ^ POLY : crc >> 1;\n }\n return ~crc;\n}\n\nlc_ep lc_p2p_ep[3];\nlc_ep lc_col_ep;\n\nstruct pendingReq {\n uint32_t dest;\n uint32_t tag;\n int phase;\n vTy buf;\n lc_req req;\n std::atomic& inflight;\n pendingReq(uint32_t _d, uint32_t _t, int _p, vTy& _buf,\n std::atomic& s)\n : dest(_d), tag(_t), phase(_p), buf(std::move(_buf)), inflight(s) {\n s++;\n }\n ~pendingReq() { inflight--; }\n};\n\nstatic void* alloc_req(size_t size, void** ctx) {\n vTy** vector = (vTy**)ctx;\n *vector = new vTy(size);\n return (*vector)->data();\n}\n\nstatic void free_req(void* ctx) {\n pendingReq* req = (pendingReq*)ctx;\n delete req;\n}\n\nnamespace {\n\n/**\n * @class NetworkInterfaceLCI\n *\n * Buffered network interface: messages are buffered before they are sent out.\n * A single worker thread is initialized to send/receive messages from/to\n * buffers.\n */\nclass NetworkInterfaceLCI : public NetworkInterface {\n unsigned long statSendNum;\n unsigned long statSendBytes;\n unsigned long statSendEnqueued;\n unsigned long statRecvNum;\n unsigned long statRecvBytes;\n unsigned long statRecvDequeued;\n bool anyReceivedMessages;\n\n // using vTy = std::vector;\n using vTy = galois::PODResizeableArray;\n\npublic:\n void workerThread() {\n // Initialize LWCI\n // makeNetworkIOLWCI(memUsageTracker, inflightSends, inflightRecvs);\n if (ID == 0)\n fprintf(stderr, \"**Using LWCI Communication layer**\\n\");\n\n ready = 1;\n while (ready < 2) { /*fprintf(stderr, \"[WaitOnReady-2]\");*/\n };\n while (ready != 3) {\n lc_progress(0);\n\n lc_req* req_ptr;\n for (int phase = 0; phase < 3; phase++) {\n if (lc_cq_pop(lc_p2p_ep[phase], &req_ptr) == LC_OK) {\n int bin = ((req_ptr->meta % 3) * 3) + phase;\n bufferedRecv[bin].push(convertReq(req_ptr, phase));\n }\n }\n\n sched_yield();\n }\n }\n\n std::thread worker;\n std::atomic ready;\n\npublic:\n using NetworkInterface::ID;\n using NetworkInterface::Num;\n\n NetworkInterfaceLCI() {\n lc_init(1, &lc_col_ep);\n lc_opt opt;\n opt.dev = 0;\n opt.desc = LC_DYN_CQ;\n opt.alloc = alloc_req;\n lc_ep_dup(&opt, lc_col_ep, &lc_p2p_ep[0]);\n lc_ep_dup(&opt, lc_col_ep, &lc_p2p_ep[1]);\n lc_ep_dup(&opt, lc_col_ep, &lc_p2p_ep[2]);\n\n lc_get_proc_num((int*)&ID);\n lc_get_num_proc((int*)&Num);\n\n inflightSends = 0;\n inflightRecvs = 0;\n ready = 0;\n anyReceivedMessages = false;\n worker = std::thread(&NetworkInterfaceLCI::workerThread, this);\n while (ready != 1) {\n };\n ready = 2;\n }\n\n virtual ~NetworkInterfaceLCI() {\n ready = 3;\n worker.join();\n }\n\n boost::lockfree::queue\n bufferedRecv[9]; // [0, 1, 2] [0, 1, 2] 0: normal, 1: reduce, 2: AM\n\n virtual void sendTagged(uint32_t dest, uint32_t tag, SendBuffer& buf,\n int phase) {\n if (tag == 0)\n phase = 2;\n\n statSendNum += 1;\n statSendBytes += buf.size();\n // int count = 0;\n#ifndef GALOIS_SUPPORT_ASYNC\n if (buf.getVec().size() < 8192) {\n while (lc_sendm(buf.getVec().data(), buf.getVec().size(), dest, tag,\n lc_p2p_ep[phase]) != LC_OK) {\n sched_yield();\n }\n } else\n#endif\n {\n pendingReq* msg =\n new pendingReq(dest, tag, phase, buf.getVec(), inflightSends);\n while (lc_sendl(msg->buf.data(), msg->buf.size(), dest, tag,\n lc_p2p_ep[phase], free_req, msg) != LC_OK) {\n sched_yield();\n }\n }\n }\n\n inline pendingReq* convertReq(lc_req* req_ptr, int phase) {\n // Need to drain LCI queue to allow more injection.\n // Convert internal LCI request to a Galois pending request.\n vTy buf = std::move(*((vTy*)(req_ptr->ctx)));\n int rank = req_ptr->rank;\n int meta = req_ptr->meta;\n delete (vTy*)req_ptr->ctx;\n lc_cq_reqfree(lc_p2p_ep[phase], req_ptr);\n return new pendingReq(rank, meta, phase, buf, inflightRecvs);\n }\n\n virtual std::optional>\n recieveTagged(uint32_t tag,\n std::unique_lock* /*rlg*/,\n int phase) {\n if (tag == 0)\n phase = 2;\n // static int count = 0;\n\n pendingReq* req;\n int bin = ((tag % 3) * 3) + phase;\n if (!bufferedRecv[bin].pop(req)) {\n // if (count ++ == 10000) {\n // printf(\"[%d] WARNING possible lock out on RECV %d\\n\", ID, tag);\n // }\n return std::optional>();\n }\n\n if (req->tag == tag) {\n vTy buf = std::move(req->buf);\n int dest = req->dest;\n delete req;\n return std::optional>(\n std::make_pair(dest, std::move(buf)));\n } else {\n printf(\"[%d] WARNING possible lock out, wrong tag %d/%d.\\n\", ID, req->tag,\n tag);\n return std::optional>();\n }\n }\n\n virtual void flush() {}\n\n virtual bool anyPendingSends() {\n // static int count = 0;\n // if (count++ == 10000)\n // printf(\"[%d] WARNING possible lock out terminate %d %d\\n\", ID,\n // inflightSends.load(), inflightRecvs.load());\n return (inflightSends > 0);\n }\n\n virtual bool anyPendingReceives() {\n if (anyReceivedMessages) { // might not be acted on by the computation yet\n anyReceivedMessages = false;\n // galois::gDebug(\"[\", ID, \"] receive out of buffer \\n\");\n return true;\n }\n // if (inflightRecvs > 0) {\n // galois::gDebug(\"[\", ID, \"] inflight receive: \", inflightRecvs, \" \\n\");\n // }\n return (inflightRecvs > 0);\n }\n\n virtual unsigned long reportSendBytes() const { return statSendBytes; }\n virtual unsigned long reportSendMsgs() const { return statSendNum; }\n virtual unsigned long reportRecvBytes() const { return statRecvBytes; }\n virtual unsigned long reportRecvMsgs() const { return statRecvNum; }\n\n virtual std::vector reportExtra() const {\n std::vector retval(5);\n return retval;\n }\n\n virtual std::vector>\n reportExtraNamed() const {\n std::vector> retval(5);\n retval[0].first = \"SendTimeout\";\n retval[1].first = \"SendOverflow\";\n retval[2].first = \"SendUrgent\";\n retval[3].first = \"SendEnqueued\";\n retval[4].first = \"RecvDequeued\";\n retval[3].second = statSendEnqueued;\n retval[4].second = statRecvDequeued;\n return retval;\n }\n};\n\n} // namespace\n\n/**\n * Create a buffered network interface, or return one if already\n * created.\n */\nNetworkInterface& galois::runtime::makeNetworkLCI() {\n static std::atomic net;\n static substrate::SimpleLock m_mutex;\n\n // create the interface if it doesn't yet exist in the static variable\n auto* tmp = net.load();\n if (tmp == nullptr) {\n std::lock_guard lock(m_mutex);\n tmp = net.load();\n if (tmp == nullptr) {\n tmp = new NetworkInterfaceLCI();\n net.store(tmp);\n }\n }\n\n return *tmp;\n}\n#endif\n" }, { "path": "libgalois/CMakeLists.txt", "content": "add_library(galois_shmem)\nadd_library(Galois::shmem ALIAS galois_shmem)\nset_target_properties(galois_shmem PROPERTIES EXPORT_NAME shmem)\nadd_dependencies(lib galois_shmem)\n\nconfigure_file(src/Version.cpp.in Version.cpp @ONLY)\nconfigure_file(include/galois/config.h.in include/galois/config.h)\n\nset(sources\n \"${CMAKE_CURRENT_BINARY_DIR}/Version.cpp\"\n src/Barrier_Counting.cpp\n src/Barrier.cpp\n src/Barrier_Dissemination.cpp \n src/Barrier_MCS.cpp\n src/Barrier_Pthread.cpp\n src/Barrier_Simple.cpp\n src/Barrier_Topo.cpp\n src/Context.cpp\n src/Deterministic.cpp\n src/DynamicBitset.cpp\n src/EnvCheck.cpp\n src/FileGraph.cpp\n src/FileGraphParallel.cpp\n src/gIO.cpp\n src/GraphHelpers.cpp\n src/HWTopo.cpp\n src/Mem.cpp\n src/NumaMem.cpp\n src/OCFileGraph.cpp\n src/PageAlloc.cpp\n src/PagePool.cpp\n src/PagePool.cpp\n src/ParaMeter.cpp\n src/PerThreadStorage.cpp\n src/PreAlloc.cpp\n src/Profile.cpp\n src/PtrLock.cpp\n src/SharedMem.cpp\n src/SharedMemSys.cpp\n src/SimpleLock.cpp\n src/Statistics.cpp\n src/Substrate.cpp\n src/Support.cpp\n src/Termination.cpp\n src/ThreadPool.cpp\n src/Threads.cpp\n src/ThreadTimer.cpp\n src/Timer.cpp\n src/Tracer.cpp\n)\n\nif (${CMAKE_SYSTEM_NAME} MATCHES \"Darwin\")\n list(APPEND sources src/HWTopoDarwin.cpp)\nelse()\n include(CheckSchedSetAffinity)\n if (NOT SCHED_SETAFFINITY_FOUND)\n if (GALOIS_STRICT_CONFIG)\n message(FATAL_ERROR \"Need sched_setaffinity\")\n endif()\n endif()\n list(APPEND sources src/HWTopoLinux.cpp)\nendif()\n\ntarget_sources(galois_shmem PRIVATE ${sources})\n\ntarget_include_directories(galois_shmem PUBLIC\n $\n $\n $\n)\n\nif (TARGET Boost::Boost)\n # Autogenerated conan module doesn't provide header-only target. Extract one\n # manually.\n get_target_property(include_dirs Boost::Boost INTERFACE_INCLUDE_DIRECTORIES)\n target_include_directories(galois_shmem PUBLIC ${include_dirs})\nelse()\n # Standard CMake Boost module\n target_link_libraries(galois_shmem PUBLIC Boost::boost)\nendif()\n\nif (SCHED_SETAFFINITY_FOUND)\n target_compile_definitions(galois_shmem PRIVATE GALOIS_USE_SCHED_SETAFFINITY)\n target_link_libraries(galois_shmem PRIVATE ${SCHED_SETAFFINITY_LIBRARIES})\nendif()\n\ntarget_link_libraries(galois_shmem INTERFACE pygalois)\ntarget_link_libraries(galois_shmem PRIVATE Threads::Threads)\n\nif (CMAKE_HAVE_PTHREAD_H)\n target_compile_definitions(galois_shmem PRIVATE GALOIS_HAVE_PTHREAD)\nendif()\n\nfind_package(NUMA)\nif (NUMA_FOUND)\n target_compile_definitions(galois_shmem PRIVATE GALOIS_USE_NUMA)\n target_link_libraries(galois_shmem PRIVATE ${NUMA_LIBRARY})\nelse()\n message(WARNING \"No NUMA Support. Likely poor performance for multi-socket systems.\")\nendif()\n\nif (VTune_FOUND)\n target_link_libraries(galois_shmem PRIVATE ${VTune_LIBRARIES})\nendif()\n\n\nadd_subdirectory(test)\n\ninstall(\n DIRECTORY include/\n DESTINATION \"${CMAKE_INSTALL_INCLUDEDIR}\"\n COMPONENT dev\n FILES_MATCHING PATTERN \"*.h\"\n)\n\ninstall(\n DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/include/\n DESTINATION \"${CMAKE_INSTALL_INCLUDEDIR}\"\n COMPONENT dev\n FILES_MATCHING PATTERN \"*.h\"\n)\n\ninstall(\n TARGETS galois_shmem\n EXPORT GaloisTargets\n LIBRARY\n DESTINATION \"${CMAKE_INSTALL_LIBDIR}\"\n COMPONENT shlib\n ARCHIVE\n DESTINATION \"${CMAKE_INSTALL_LIBDIR}\"\n COMPONENT lib\n INCLUDES DESTINATION \"${CMAKE_INSTALL_INCLUDEDIR}\"\n)\n" }, { "path": "libgalois/include/galois/ArrayWrapper.h", "content": "/*\n * This file belongs to the Galois project, a C++ library for exploiting\n * parallelism. The code is being released under the terms of the 3-Clause BSD\n * License (a copy is located in LICENSE.txt at the top-level directory).\n *\n * Copyright (C) 2018, The University of Texas at Austin. All rights reserved.\n * UNIVERSITY EXPRESSLY DISCLAIMS ANY AND ALL WARRANTIES CONCERNING THIS\n * SOFTWARE AND DOCUMENTATION, INCLUDING ANY WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR ANY PARTICULAR PURPOSE, NON-INFRINGEMENT AND WARRANTIES OF\n * PERFORMANCE, AND ANY WARRANTY THAT MIGHT OTHERWISE ARISE FROM COURSE OF\n * DEALING OR USAGE OF TRADE. NO WARRANTY IS EITHER EXPRESS OR IMPLIED WITH\n * RESPECT TO THE USE OF THE SOFTWARE OR DOCUMENTATION. Under no circumstances\n * shall University be liable for incidental, special, indirect, direct or\n * consequential damages or loss of profits, interruption of business, or\n * related expenses which may arise from use of Software or Documentation,\n * including but not limited to those resulting from defects in Software and/or\n * Documentation, or loss or inaccuracy of data of any kind.\n */\n\n/**\n * @file ArrayWrapper.h\n *\n * Defines the CopyableArray subclass used to make arrays trivially copyable if\n * possible.\n */\n\n#ifndef _ARRAY_WRAPPER_H_\n#define _ARRAY_WRAPPER_H_\n\n#include \n#include \"galois/config.h\"\n#include \"galois/runtime/ExtraTraits.h\"\n\nnamespace galois {\n/**\n * A subclass of std::array that is marked trivially copyable if the type is\n * also memory copyable. Useful when you need a trivially copyable type for\n * serialization.\n *\n * @tparam T type of the items to be stored in the array\n * @tparam N total number of items in the array\n */\ntemplate \nclass CopyableArray : public std::array {\npublic:\n //! Only typedef tt_is_copyable if T is trivially copyable.\n //! Allows the use of memcopy in serialize/deserialize.\n using tt_is_copyable =\n typename std::enable_if::value,\n int>::type;\n};\n} // namespace galois\n#endif\n" }, { "path": "libgalois/include/galois/AtomicHelpers.h", "content": "/*\n * This file belongs to the Galois project, a C++ library for exploiting\n * parallelism. The code is being released under the terms of the 3-Clause BSD\n * License (a copy is located in LICENSE.txt at the top-level directory).\n *\n * Copyright (C) 2018, The University of Texas at Austin. All rights reserved.\n * UNIVERSITY EXPRESSLY DISCLAIMS ANY AND ALL WARRANTIES CONCERNING THIS\n * SOFTWARE AND DOCUMENTATION, INCLUDING ANY WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR ANY PARTICULAR PURPOSE, NON-INFRINGEMENT AND WARRANTIES OF\n * PERFORMANCE, AND ANY WARRANTY THAT MIGHT OTHERWISE ARISE FROM COURSE OF\n * DEALING OR USAGE OF TRADE. NO WARRANTY IS EITHER EXPRESS OR IMPLIED WITH\n * RESPECT TO THE USE OF THE SOFTWARE OR DOCUMENTATION. Under no circumstances\n * shall University be liable for incidental, special, indirect, direct or\n * consequential damages or loss of profits, interruption of business, or\n * related expenses which may arise from use of Software or Documentation,\n * including but not limited to those resulting from defects in Software and/or\n * Documentation, or loss or inaccuracy of data of any kind.\n */\n\n#pragma once\n#include \n#include \n#include \n\n#include \"galois/config.h\"\n\nnamespace galois {\n/** galois::atomicMax + non-atomic max calls **/\ntemplate \nconst Ty atomicMax(std::atomic& a, const Ty b) {\n Ty old_a = a.load(std::memory_order_relaxed);\n // if old value is less than new value, atomically exchange\n while (old_a < b &&\n !a.compare_exchange_weak(old_a, b, std::memory_order_relaxed))\n ;\n return old_a;\n}\n\ntemplate \nconst Ty max(std::atomic& a, const Ty& b) {\n Ty old_a = a.load(std::memory_order_relaxed);\n\n if (a < b) {\n a.store(b, std::memory_order_relaxed);\n }\n return old_a;\n}\n\ntemplate \nconst Ty max(Ty& a, const Ty& b) {\n Ty old_a = a;\n\n if (a < b) {\n a = b;\n }\n return old_a;\n}\n\n/** galois::atomicMin **/\ntemplate \nconst Ty atomicMin(std::atomic& a, const Ty b) {\n Ty old_a = a.load(std::memory_order_relaxed);\n while (old_a > b &&\n !a.compare_exchange_weak(old_a, b, std::memory_order_relaxed))\n ;\n return old_a;\n}\n\ntemplate \nconst Ty min(std::atomic& a, const Ty& b) {\n Ty old_a = a.load(std::memory_order_relaxed);\n if (a > b) {\n a.store(b, std::memory_order_relaxed);\n }\n return old_a;\n}\n\ntemplate \nconst Ty min(Ty& a, const Ty& b) {\n Ty old_a = a;\n if (a > b) {\n a = b;\n }\n return old_a;\n}\n\n/** galois::atomicAdd **/\ntemplate \nconst Ty atomicAdd(std::atomic& val, Ty delta) {\n Ty old_val = val.load(std::memory_order_relaxed);\n while (!val.compare_exchange_weak(old_val, old_val + delta,\n std::memory_order_relaxed))\n ;\n return old_val;\n}\n\ntemplate \nconst Ty add(std::atomic& a, const Ty& b) {\n Ty old_a = a.load(std::memory_order_relaxed);\n a.store(a + b, std::memory_order_relaxed);\n return old_a;\n}\n\ntemplate \nconst Ty add(Ty& a, std::atomic& b) {\n Ty old_a = a;\n a = a + b.load(std::memory_order_relaxed);\n return old_a;\n}\n\ntemplate \nconst Ty add(Ty& a, const Ty& b) {\n Ty old_a = a;\n a += b;\n return old_a;\n}\n\n/**\n * atomic subtraction of delta (because atomicAdd with negative numbers implies\n * a signed integer cast)\n */\ntemplate \nconst Ty atomicSubtract(std::atomic& val, Ty delta) {\n Ty old_val = val.load(std::memory_order_relaxed);\n while (!val.compare_exchange_weak(old_val, old_val - delta,\n std::memory_order_relaxed))\n ;\n return old_val;\n}\n\ntemplate \nconst Ty set(Ty& a, const Ty& b) {\n a = b;\n return a;\n}\n\ntemplate \nconst Ty set(std::atomic& a, const Ty& b) {\n a.store(b, std::memory_order_relaxed);\n return a;\n}\n\n/** Pair Wise Average function **/\ntemplate \nconst Ty pairWiseAvg(Ty a, Ty b) {\n return (a + b) / 2.0;\n}\n\ntemplate \nvoid pairWiseAvg_vec(std::vector& a_vec, std::vector& b_vec) {\n for (unsigned i = 0; i < a_vec.size(); ++i) {\n a_vec[i] = (a_vec[i] + b_vec[i]) / 2.0;\n }\n}\n\ntemplate \nvoid resetVec(Ty& a_arr) {\n // std::for_each(a_arr.begin(), a_arr.end(),[](Ty &ele){ele = 0;} );\n std::fill(a_arr.begin(), a_arr.end(), 0);\n}\n\ntemplate \nvoid pairWiseAvg_vec(Ty& a_arr, Ty& b_arr) {\n for (unsigned i = 0; i < a_arr.size(); ++i) {\n a_arr[i] = (a_arr[i] + b_arr[i]) / 2.0;\n }\n}\n\ntemplate \nvoid addArray(Ty& a_arr, Ty& b_arr) {\n for (unsigned i = 0; i < a_arr.size(); ++i) {\n a_arr[i] = (a_arr[i] + b_arr[i]);\n }\n}\n\ntemplate \nvoid resetVec(std::vector& a_vec) {\n std::for_each(a_vec.begin(), a_vec.end(), [](Ty& ele) { ele = 0; });\n}\n\n// like std::inner_product\ntemplate \nTy innerProduct(ItrTy a_begin, ItrTy a_end, ItrTy b_begin, Ty init_value) {\n auto jj = b_begin;\n for (auto ii = a_begin; ii != a_end; ++ii, ++jj) {\n init_value += (*ii) * (*jj);\n }\n return init_value;\n}\n\n// like std::inner_product\ntemplate \nTy innerProduct(ItrTy& a_arr, ItrTy& b_arr, Ty init_value) {\n auto jj = b_arr.begin();\n for (auto ii = a_arr.begin(); ii != a_arr.end(); ++ii, ++jj) {\n init_value += (*ii) * (*jj);\n }\n return init_value;\n}\n\ntemplate \nvoid reset(Ty& var, Ty val) {\n var = val;\n}\n\ntemplate \nvoid reset(std::atomic& var, Ty val) {\n var.store(val, std::memory_order_relaxed);\n}\n} // end namespace galois\n" }, { "path": "libgalois/include/galois/AtomicWrapper.h", "content": "/*\n * This file belongs to the Galois project, a C++ library for exploiting\n * parallelism. The code is being released under the terms of the 3-Clause BSD\n * License (a copy is located in LICENSE.txt at the top-level directory).\n *\n * Copyright (C) 2018, The University of Texas at Austin. All rights reserved.\n * UNIVERSITY EXPRESSLY DISCLAIMS ANY AND ALL WARRANTIES CONCERNING THIS\n * SOFTWARE AND DOCUMENTATION, INCLUDING ANY WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR ANY PARTICULAR PURPOSE, NON-INFRINGEMENT AND WARRANTIES OF\n * PERFORMANCE, AND ANY WARRANTY THAT MIGHT OTHERWISE ARISE FROM COURSE OF\n * DEALING OR USAGE OF TRADE. NO WARRANTY IS EITHER EXPRESS OR IMPLIED WITH\n * RESPECT TO THE USE OF THE SOFTWARE OR DOCUMENTATION. Under no circumstances\n * shall University be liable for incidental, special, indirect, direct or\n * consequential damages or loss of profits, interruption of business, or\n * related expenses which may arise from use of Software or Documentation,\n * including but not limited to those resulting from defects in Software and/or\n * Documentation, or loss or inaccuracy of data of any kind.\n */\n\n/**\n * @file AtomicWrapper.h\n *\n * Contains a copyable atomics class.\n */\n#ifndef _ATOMIC_WRAPPER_H_\n#define _ATOMIC_WRAPPER_H_\n\n#include \n\n#include \"galois/config.h\"\n\nnamespace galois {\n/**\n * Class that inherits from std::atomic to make it copyable by defining a copy\n * constructor.\n *\n * @tparam T type of the atomic\n */\ntemplate \nclass CopyableAtomic : public std::atomic {\npublic:\n //! Default constructor\n CopyableAtomic() : std::atomic(T{}) {}\n\n //! Constructor initializing atomic to passed in data\n constexpr CopyableAtomic(T desired) : std::atomic(desired) {}\n\n //! Copy constructor\n constexpr CopyableAtomic(const CopyableAtomic& other)\n : CopyableAtomic(other.load(std::memory_order_relaxed)) {}\n\n //! Copy constructor operator\n CopyableAtomic& operator=(const CopyableAtomic& other) {\n this->store(other.load(std::memory_order_relaxed),\n std::memory_order_relaxed);\n return *this;\n }\n};\n\n} // namespace galois\n#endif\n" }, { "path": "libgalois/include/galois/Bag.h", "content": "/*\n * This file belongs to the Galois project, a C++ library for exploiting\n * parallelism. The code is being released under the terms of the 3-Clause BSD\n * License (a copy is located in LICENSE.txt at the top-level directory).\n *\n * Copyright (C) 2018, The University of Texas at Austin. All rights reserved.\n * UNIVERSITY EXPRESSLY DISCLAIMS ANY AND ALL WARRANTIES CONCERNING THIS\n * SOFTWARE AND DOCUMENTATION, INCLUDING ANY WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR ANY PARTICULAR PURPOSE, NON-INFRINGEMENT AND WARRANTIES OF\n * PERFORMANCE, AND ANY WARRANTY THAT MIGHT OTHERWISE ARISE FROM COURSE OF\n * DEALING OR USAGE OF TRADE. NO WARRANTY IS EITHER EXPRESS OR IMPLIED WITH\n * RESPECT TO THE USE OF THE SOFTWARE OR DOCUMENTATION. Under no circumstances\n * shall University be liable for incidental, special, indirect, direct or\n * consequential damages or loss of profits, interruption of business, or\n * related expenses which may arise from use of Software or Documentation,\n * including but not limited to those resulting from defects in Software and/or\n * Documentation, or loss or inaccuracy of data of any kind.\n */\n\n#ifndef GALOIS_BAG_H\n#define GALOIS_BAG_H\n\n#include \n#include \n\n#include \n\n#include \"galois/config.h\"\n#include \"galois/gstl.h\"\n#include \"galois/runtime/Executor_OnEach.h\"\n#include \"galois/substrate/PerThreadStorage.h\"\n#include \"galois/gIO.h\"\n#include \"galois/runtime/Mem.h\"\n\nnamespace galois {\n\n/**\n * Unordered collection of elements. This data structure supports scalable\n * concurrent pushes but reading the bag can only be done serially.\n */\ntemplate \nclass InsertBag {\n\n struct header {\n header* next;\n T* dbegin; // start of interesting data\n T* dend; // end of valid data\n T* dlast; // end of storage\n };\n\n typedef std::pair PerThread;\n\npublic:\n template \n class Iterator : public boost::iterator_facade, U,\n boost::forward_traversal_tag> {\n friend class boost::iterator_core_access;\n\n galois::substrate::PerThreadStorage>* hd;\n unsigned int thr;\n header* p;\n U* v;\n\n bool init_thread() {\n p = thr < hd->size() ? hd->getRemote(thr)->first : 0;\n v = p ? p->dbegin : 0;\n return p;\n }\n\n bool advance_local() {\n if (p) {\n ++v;\n return v != p->dend;\n }\n return false;\n }\n\n bool advance_chunk() {\n if (p) {\n p = p->next;\n v = p ? p->dbegin : 0;\n }\n return p;\n }\n\n void advance_thread() {\n while (thr < hd->size()) {\n ++thr;\n if (init_thread())\n return;\n }\n }\n\n void increment() {\n if (advance_local())\n return;\n if (advance_chunk())\n return;\n advance_thread();\n }\n\n template \n bool equal(const Iterator& o) const {\n return hd == o.hd && thr == o.thr && p == o.p && v == o.v;\n }\n\n U& dereference() const { return *v; }\n\n public:\n Iterator() : hd(0), thr(0), p(0), v(0) {}\n\n template \n Iterator(const Iterator& o)\n : hd(o.hd), thr(o.thr), p(o.p), v(o.v) {}\n\n Iterator(\n galois::substrate::PerThreadStorage>* h,\n unsigned t)\n : hd(h), thr(t), p(0), v(0) {\n // find first valid item\n if (!init_thread())\n advance_thread();\n }\n };\n\nprivate:\n galois::runtime::FixedSizeHeap heap;\n galois::substrate::PerThreadStorage heads;\n\n void insHeader(header* h) {\n PerThread& hpair = *heads.getLocal();\n if (hpair.second) {\n hpair.second->next = h;\n hpair.second = h;\n } else {\n hpair.first = hpair.second = h;\n }\n }\n\n header* newHeaderFromHeap(void* m, unsigned size) {\n header* H = new (m) header();\n int offset = 1;\n if (sizeof(T) < sizeof(header))\n offset += sizeof(header) / sizeof(T);\n T* a = reinterpret_cast(m);\n H->dbegin = &a[offset];\n H->dend = H->dbegin;\n H->dlast = &a[(size / sizeof(T))];\n H->next = 0;\n return H;\n }\n\n header* newHeader() {\n if (BlockSize) {\n return newHeaderFromHeap(heap.allocate(BlockSize), BlockSize);\n } else {\n return newHeaderFromHeap(galois::runtime::pagePoolAlloc(),\n galois::runtime::pagePoolSize());\n }\n }\n\n void destruct_serial() {\n for (unsigned x = 0; x < heads.size(); ++x) {\n PerThread& hpair = *heads.getRemote(x);\n header*& h = hpair.first;\n while (h) {\n uninitialized_destroy(h->dbegin, h->dend);\n header* h2 = h;\n h = h->next;\n if (BlockSize)\n heap.deallocate(h2);\n else\n galois::runtime::pagePoolFree(h2);\n }\n hpair.second = 0;\n }\n }\n\n void destruct_parallel(void) {\n galois::runtime::on_each_gen(\n [this](const unsigned int tid, const unsigned int) {\n PerThread& hpair = *heads.getLocal(tid);\n header*& h = hpair.first;\n while (h) {\n uninitialized_destroy(h->dbegin, h->dend);\n header* h2 = h;\n h = h->next;\n if (BlockSize)\n heap.deallocate(h2);\n else\n galois::runtime::pagePoolFree(h2);\n }\n hpair.second = 0;\n },\n std::make_tuple(galois::no_stats()));\n }\n\npublic:\n // static_assert(BlockSize == 0 || BlockSize >= (2 * sizeof(T) +\n // sizeof(header)),\n // \"BlockSize should larger than sizeof(T) + O(1)\");\n\n InsertBag() : heap(BlockSize) {}\n InsertBag(InsertBag&& o) : heap(BlockSize) {\n std::swap(heap, o.heap);\n std::swap(heads, o.heads);\n }\n\n InsertBag& operator=(InsertBag&& o) {\n std::swap(heap, o.heap);\n std::swap(heads, o.heads);\n return *this;\n }\n\n InsertBag(const InsertBag&) = delete;\n InsertBag& operator=(const InsertBag&) = delete;\n\n ~InsertBag() { destruct_parallel(); }\n\n void clear() { destruct_parallel(); }\n\n void clear_serial() { destruct_serial(); }\n\n void swap(InsertBag& o) {\n std::swap(heap, o.heap);\n std::swap(heads, o.heads);\n }\n\n typedef T value_type;\n typedef T* pointer;\n typedef const T* const_pointer;\n typedef const T& const_reference;\n typedef T& reference;\n typedef Iterator iterator;\n typedef Iterator const_iterator;\n typedef iterator local_iterator;\n\n iterator begin() { return iterator(&heads, 0); }\n iterator end() { return iterator(&heads, heads.size()); }\n const_iterator begin() const { return const_iterator(&heads, 0); }\n const_iterator end() const { return const_iterator(&heads, heads.size()); }\n\n local_iterator local_begin() {\n return local_iterator(&heads, galois::substrate::ThreadPool::getTID());\n }\n local_iterator local_end() {\n return local_iterator(&heads, galois::substrate::ThreadPool::getTID() + 1);\n }\n\n bool empty() const {\n for (unsigned x = 0; x < heads.size(); ++x) {\n header* h = heads.getRemote(x)->first;\n if (h)\n return false;\n }\n return true;\n }\n //! Thread safe bag insertion\n template \n reference emplace(Args&&... args) {\n header* H = heads.getLocal()->second;\n T* rv;\n if (!H || H->dend == H->dlast) {\n H = newHeader();\n insHeader(H);\n }\n rv = new (H->dend) T(std::forward(args)...);\n ++H->dend;\n return *rv;\n }\n\n template \n reference emplace_back(Args&&... args) {\n return emplace(std::forward(args)...);\n }\n\n /**\n * Pop the last element pushed by this thread. The number of consecutive\n * pops supported without intevening pushes is implementation dependent.\n */\n void pop() {\n header* H = heads.getLocal()->second;\n if (H->dbegin == H->dend) {\n throw std::out_of_range(\"InsertBag::pop\");\n }\n uninitialized_destroy(H->dend - 1, H->dend);\n --H->dend;\n }\n\n //! Thread safe bag insertion\n template \n reference push(ItemTy&& val) {\n return emplace(std::forward(val));\n }\n\n //! Thread safe bag insertion\n template \n reference push_back(ItemTy&& val) {\n return emplace(std::forward(val));\n }\n};\n\n} // namespace galois\n\n#endif\n" }, { "path": "libgalois/include/galois/CheckedObject.h", "content": "/*\n * This file belongs to the Galois project, a C++ library for exploiting\n * parallelism. The code is being released under the terms of the 3-Clause BSD\n * License (a copy is located in LICENSE.txt at the top-level directory).\n *\n * Copyright (C) 2018, The University of Texas at Austin. All rights reserved.\n * UNIVERSITY EXPRESSLY DISCLAIMS ANY AND ALL WARRANTIES CONCERNING THIS\n * SOFTWARE AND DOCUMENTATION, INCLUDING ANY WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR ANY PARTICULAR PURPOSE, NON-INFRINGEMENT AND WARRANTIES OF\n * PERFORMANCE, AND ANY WARRANTY THAT MIGHT OTHERWISE ARISE FROM COURSE OF\n * DEALING OR USAGE OF TRADE. NO WARRANTY IS EITHER EXPRESS OR IMPLIED WITH\n * RESPECT TO THE USE OF THE SOFTWARE OR DOCUMENTATION. Under no circumstances\n * shall University be liable for incidental, special, indirect, direct or\n * consequential damages or loss of profits, interruption of business, or\n * related expenses which may arise from use of Software or Documentation,\n * including but not limited to those resulting from defects in Software and/or\n * Documentation, or loss or inaccuracy of data of any kind.\n */\n\n#ifndef GALOIS_CHECKEDOBJECT_H\n#define GALOIS_CHECKEDOBJECT_H\n\n#include \"galois/config.h\"\n#include \"galois/runtime/Context.h\"\n\nnamespace galois {\n\n/**\n * Conflict-checking wrapper for any type. Performs global conflict detection\n * on the enclosed object. This enables arbitrary types to be managed by the\n * Galois runtime.\n */\ntemplate \nclass GChecked : public galois::runtime::Lockable {\n T val;\n\npublic:\n template \n GChecked(Args&&... args) : val(std::forward(args)...) {}\n\n T& get(galois::MethodFlag m = MethodFlag::WRITE) {\n galois::runtime::acquire(this, m);\n return val;\n }\n\n const T& get(galois::MethodFlag m = MethodFlag::WRITE) const {\n galois::runtime::acquire(const_cast(this), m);\n return val;\n }\n};\n\ntemplate <>\nclass GChecked : public galois::runtime::Lockable {\npublic:\n void get(galois::MethodFlag m = MethodFlag::WRITE) const {\n galois::runtime::acquire(const_cast(this), m);\n }\n};\n\n} // namespace galois\n\n#endif // _GALOIS_CHECKEDOBJECT_H\n" }, { "path": "libgalois/include/galois/CopyableTuple.h", "content": "/*\n * This file belongs to the Galois project, a C++ library for exploiting\n * parallelism. The code is being released under the terms of the 3-Clause BSD\n * License (a copy is located in LICENSE.txt at the top-level directory).\n *\n * Copyright (C) 2018, The University of Texas at Austin. All rights reserved.\n * UNIVERSITY EXPRESSLY DISCLAIMS ANY AND ALL WARRANTIES CONCERNING THIS\n * SOFTWARE AND DOCUMENTATION, INCLUDING ANY WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR ANY PARTICULAR PURPOSE, NON-INFRINGEMENT AND WARRANTIES OF\n * PERFORMANCE, AND ANY WARRANTY THAT MIGHT OTHERWISE ARISE FROM COURSE OF\n * DEALING OR USAGE OF TRADE. NO WARRANTY IS EITHER EXPRESS OR IMPLIED WITH\n * RESPECT TO THE USE OF THE SOFTWARE OR DOCUMENTATION. Under no circumstances\n * shall University be liable for incidental, special, indirect, direct or\n * consequential damages or loss of profits, interruption of business, or\n * related expenses which may arise from use of Software or Documentation,\n * including but not limited to those resulting from defects in Software and/or\n * Documentation, or loss or inaccuracy of data of any kind.\n */\n\n/**\n * @file CopyableTuple.h\n *\n * Contains copyable tuple classes whose elements are contiguous in memory\n */\n#pragma once\n\n#include \"galois/config.h\"\n\nnamespace galois {\n\n/**\n * Struct that contains 2 elements. Used over std::pair as std::pair memory\n * layout isn't guaranteed.\n *\n * @tparam T1 type of first element\n * @tparam T2 type of second element\n */\ntemplate \nstruct Pair {\n //! first element\n T1 first;\n //! second element\n T2 second;\n\n //! empty constructor\n Pair() {}\n\n //! Constructor that initializes 2 fields\n Pair(T1 one, T2 two) {\n first = one;\n second = two;\n }\n};\n\n/**\n * Struct that contains 3 elements. Used over std::tuple as std::tuple memory\n * layout isn't guaranteed.\n *\n * @tparam T1 type of first element\n * @tparam T2 type of second element\n * @tparam T3 type of third element\n */\ntemplate \nstruct TupleOfThree {\n //! first element\n T1 first;\n //! second element\n T2 second;\n //! third element\n T3 third;\n\n //! empty constructor\n TupleOfThree() {}\n\n //! Constructor that initializes 3 fields\n TupleOfThree(T1 one, T2 two, T3 three) {\n first = one;\n second = two;\n third = three;\n }\n};\n\n} // namespace galois\n" }, { "path": "libgalois/include/galois/DynamicBitset.h", "content": "/*\n * This file belongs to the Galois project, a C++ library for exploiting\n * parallelism. The code is being released under the terms of the 3-Clause BSD\n * License (a copy is located in LICENSE.txt at the top-level directory).\n *\n * Copyright (C) 2019, The University of Texas at Austin. All rights reserved.\n * UNIVERSITY EXPRESSLY DISCLAIMS ANY AND ALL WARRANTIES CONCERNING THIS\n * SOFTWARE AND DOCUMENTATION, INCLUDING ANY WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR ANY PARTICULAR PURPOSE, NON-INFRINGEMENT AND WARRANTIES OF\n * PERFORMANCE, AND ANY WARRANTY THAT MIGHT OTHERWISE ARISE FROM COURSE OF\n * DEALING OR USAGE OF TRADE. NO WARRANTY IS EITHER EXPRESS OR IMPLIED WITH\n * RESPECT TO THE USE OF THE SOFTWARE OR DOCUMENTATION. Under no circumstances\n * shall University be liable for incidental, special, indirect, direct or\n * consequential damages or loss of profits, interruption of business, or\n * related expenses which may arise from use of Software or Documentation,\n * including but not limited to those resulting from defects in Software and/or\n * Documentation, or loss or inaccuracy of data of any kind.\n */\n\n/**\n * @file galois/DynamicBitset.h\n *\n * Contains the DynamicBitSet class and most of its implementation.\n */\n\n#ifndef _GALOIS_DYNAMIC_BIT_SET_\n#define _GALOIS_DYNAMIC_BIT_SET_\n\n#include \n#include \n#include \n\n#include \n#include \n\n#include \"galois/config.h\"\n#include \"galois/AtomicWrapper.h\"\n#include \"galois/PODResizeableArray.h\"\n#include \"galois/GaloisForwardDecl.h\"\n#include \"galois/Traits.h\"\n#include \"galois/Galois.h\"\n\nnamespace galois {\n/**\n * Concurrent dynamically allocated bitset\n **/\nclass DynamicBitSet {\nprotected:\n galois::PODResizeableArray> bitvec;\n size_t num_bits;\n static constexpr uint32_t bits_uint64 = sizeof(uint64_t) * CHAR_BIT;\n\npublic:\n //! Constructor which initializes to an empty bitset.\n DynamicBitSet() : num_bits(0) {}\n\n /**\n * Returns the underlying bitset representation to the user\n *\n * @returns constant reference vector of copyable atomics that represents\n * the bitset\n */\n const auto& get_vec() const { return bitvec; }\n\n /**\n * Returns the underlying bitset representation to the user\n *\n * @returns reference to vector of copyable atomics that represents the\n * bitset\n */\n auto& get_vec() { return bitvec; }\n\n /**\n * Resizes the bitset.\n *\n * @param n Size to change the bitset to\n */\n void resize(uint64_t n) {\n assert(bits_uint64 == 64); // compatibility with other devices\n num_bits = n;\n bitvec.resize((n + bits_uint64 - 1) / bits_uint64);\n reset();\n }\n\n /**\n * Reserves capacity for the bitset.\n *\n * @param n Size to reserve the capacity of the bitset to\n */\n void reserve(uint64_t n) {\n assert(bits_uint64 == 64); // compatibility with other devices\n bitvec.reserve((n + bits_uint64 - 1) / bits_uint64);\n }\n\n /**\n * Gets the size of the bitset\n * @returns The number of bits held by the bitset\n */\n size_t size() const { return num_bits; }\n\n /**\n * Gets the space taken by the bitset\n * @returns the space in bytes taken by this bitset\n */\n // size_t alloc_size() const { return bitvec.size() * sizeof(uint64_t); }\n\n /**\n * Unset every bit in the bitset.\n */\n void reset() { std::fill(bitvec.begin(), bitvec.end(), 0); }\n\n /**\n * Unset a range of bits given an inclusive range\n *\n * @param begin first bit in range to reset\n * @param end last bit in range to reset\n */\n void reset(size_t begin, size_t end) {\n if (num_bits == 0)\n return;\n\n assert(begin <= (num_bits - 1));\n assert(end <= (num_bits - 1));\n\n // 100% safe implementation, but slow\n // for (unsigned long i = begin; i <= end; i++) {\n // size_t bit_index = i / bits_uint64;\n // uint64_t bit_offset = 1;\n // bit_offset <<= (i % bits_uint64);\n // uint64_t mask = ~bit_offset;\n // bitvec[bit_index] &= mask;\n //}\n\n // block which you are safe to clear\n size_t vec_begin = (begin + bits_uint64 - 1) / bits_uint64;\n size_t vec_end;\n\n if (end == (num_bits - 1))\n vec_end = bitvec.size();\n else\n vec_end = (end + 1) / bits_uint64; // floor\n\n if (vec_begin < vec_end) {\n std::fill(bitvec.begin() + vec_begin, bitvec.begin() + vec_end, 0);\n }\n\n vec_begin *= bits_uint64;\n vec_end *= bits_uint64;\n\n // at this point vec_begin -> vec_end-1 has been reset\n\n if (vec_begin > vec_end) {\n // no fill happened\n if (begin < vec_begin) {\n size_t diff = vec_begin - begin;\n assert(diff < 64);\n uint64_t mask = ((uint64_t)1 << (64 - diff)) - 1;\n\n size_t end_diff = end - vec_end + 1;\n uint64_t or_mask = ((uint64_t)1 << end_diff) - 1;\n mask |= ~or_mask;\n\n size_t bit_index = begin / bits_uint64;\n bitvec[bit_index] &= mask;\n }\n } else {\n if (begin < vec_begin) {\n size_t diff = vec_begin - begin;\n assert(diff < 64);\n uint64_t mask = ((uint64_t)1 << (64 - diff)) - 1;\n size_t bit_index = begin / bits_uint64;\n bitvec[bit_index] &= mask;\n }\n if (end >= vec_end) {\n size_t diff = end - vec_end + 1;\n assert(diff < 64);\n uint64_t mask = ((uint64_t)1 << diff) - 1;\n size_t bit_index = end / bits_uint64;\n bitvec[bit_index] &= ~mask;\n }\n }\n }\n\n /**\n * Check a bit to see if it is currently set.\n * Using this is recommeneded only if set() and reset()\n * are not being used in that parallel section/phase\n *\n * @param index Bit to check to see if set\n * @returns true if index is set\n */\n bool test(size_t index) const {\n size_t bit_index = index / bits_uint64;\n uint64_t bit_offset = 1;\n bit_offset <<= (index % bits_uint64);\n return ((bitvec[bit_index].load(std::memory_order_relaxed) & bit_offset) !=\n 0);\n }\n\n /**\n * Set a bit in the bitset.\n *\n * @param index Bit to set\n * @returns the old value\n */\n bool set(size_t index) {\n size_t bit_index = index / bits_uint64;\n uint64_t bit_offset = 1;\n bit_offset <<= (index % bits_uint64);\n uint64_t old_val = bitvec[bit_index];\n // test and set\n // if old_bit is 0, then atomically set it\n while (((old_val & bit_offset) == 0) &&\n !bitvec[bit_index].compare_exchange_weak(\n old_val, old_val | bit_offset, std::memory_order_relaxed))\n ;\n return (old_val & bit_offset);\n }\n\n /**\n * Reset a bit in the bitset.\n *\n * @param index Bit to reset\n * @returns the old value\n */\n bool reset(size_t index) {\n size_t bit_index = index / bits_uint64;\n uint64_t bit_offset = 1;\n bit_offset <<= (index % bits_uint64);\n uint64_t old_val = bitvec[bit_index];\n // test and reset\n // if old_bit is 1, then atomically reset it\n while (((old_val & bit_offset) != 0) &&\n !bitvec[bit_index].compare_exchange_weak(\n old_val, old_val & ~bit_offset, std::memory_order_relaxed))\n ;\n return (old_val & bit_offset);\n }\n\n // assumes bit_vector is not updated (set) in parallel\n void bitwise_or(const DynamicBitSet& other) {\n assert(size() == other.size());\n auto& other_bitvec = other.get_vec();\n galois::do_all(\n galois::iterate(size_t{0}, bitvec.size()),\n [&](size_t i) { bitvec[i] |= other_bitvec[i]; }, galois::no_stats());\n }\n\n // assumes bit_vector is not updated (set) in parallel\n\n /**\n * Does an IN-PLACE bitwise and of this bitset and another bitset\n *\n * @param other Other bitset to do bitwise and with\n */\n void bitwise_and(const DynamicBitSet& other) {\n assert(size() == other.size());\n auto& other_bitvec = other.get_vec();\n galois::do_all(\n galois::iterate(size_t{0}, bitvec.size()),\n [&](size_t i) { bitvec[i] &= other_bitvec[i]; }, galois::no_stats());\n }\n\n /**\n * Does an IN-PLACE bitwise and of 2 passed in bitsets and saves to this\n * bitset\n *\n * @param other1 Bitset to and with other 2\n * @param other2 Bitset to and with other 1\n */\n void bitwise_and(const DynamicBitSet& other1, const DynamicBitSet& other2) {\n assert(size() == other1.size());\n assert(size() == other2.size());\n auto& other_bitvec1 = other1.get_vec();\n auto& other_bitvec2 = other2.get_vec();\n\n galois::do_all(\n galois::iterate(size_t{0}, bitvec.size()),\n [&](size_t i) { bitvec[i] = other_bitvec1[i] & other_bitvec2[i]; },\n galois::no_stats());\n }\n\n /**\n * Does an IN-PLACE bitwise xor of this bitset and another bitset\n *\n * @param other Other bitset to do bitwise xor with\n */\n void bitwise_xor(const DynamicBitSet& other) {\n assert(size() == other.size());\n auto& other_bitvec = other.get_vec();\n galois::do_all(\n galois::iterate(size_t{0}, bitvec.size()),\n [&](size_t i) { bitvec[i] ^= other_bitvec[i]; }, galois::no_stats());\n }\n\n /**\n * Does an IN-PLACE bitwise and of 2 passed in bitsets and saves to this\n * bitset\n *\n * @param other1 Bitset to xor with other 2\n * @param other2 Bitset to xor with other 1\n */\n void bitwise_xor(const DynamicBitSet& other1, const DynamicBitSet& other2) {\n assert(size() == other1.size());\n assert(size() == other2.size());\n auto& other_bitvec1 = other1.get_vec();\n auto& other_bitvec2 = other2.get_vec();\n\n galois::do_all(\n galois::iterate(size_t{0}, bitvec.size()),\n [&](size_t i) { bitvec[i] = other_bitvec1[i] ^ other_bitvec2[i]; },\n galois::no_stats());\n }\n\n /**\n * Count how many bits are set in the bitset\n *\n * @returns number of set bits in the bitset\n */\n uint64_t count() const {\n galois::GAccumulator ret;\n galois::do_all(\n galois::iterate(bitvec.begin(), bitvec.end()),\n [&](uint64_t n) {\n#ifdef __GNUC__\n ret += __builtin_popcountll(n);\n#else\n n = n - ((n >> 1) & 0x5555555555555555UL);\n n = (n & 0x3333333333333333UL) + ((n >> 2) & 0x3333333333333333UL);\n ret +=\n (((n + (n >> 4)) & 0xF0F0F0F0F0F0F0FUL) * 0x101010101010101UL) >>\n 56;\n#endif\n },\n galois::no_stats());\n return ret.reduce();\n }\n\n /**\n * Returns a vector containing the set bits in this bitset in order\n * from left to right.\n * Do NOT call in a parallel region as it uses galois::on_each.\n *\n * @returns vector with offsets into set bits\n */\n // TODO uint32_t is somewhat dangerous; change in the future\n std::vector getOffsets() const {\n uint32_t activeThreads = galois::getActiveThreads();\n std::vector tPrefixBitCounts(activeThreads);\n\n // count how many bits are set on each thread\n galois::on_each([&](unsigned tid, unsigned nthreads) {\n size_t start;\n size_t end;\n std::tie(start, end) =\n galois::block_range((size_t)0, this->size(), tid, nthreads);\n\n unsigned int count = 0;\n for (unsigned int i = start; i < end; ++i) {\n if (this->test(i))\n ++count;\n }\n\n tPrefixBitCounts[tid] = count;\n });\n\n // calculate prefix sum of bits per thread\n for (unsigned int i = 1; i < activeThreads; ++i) {\n tPrefixBitCounts[i] += tPrefixBitCounts[i - 1];\n }\n\n // total num of set bits\n uint64_t bitsetCount = tPrefixBitCounts[activeThreads - 1];\n std::vector offsets;\n\n // calculate the indices of the set bits and save them to the offset\n // vector\n if (bitsetCount > 0) {\n offsets.resize(bitsetCount);\n galois::on_each([&](unsigned tid, unsigned nthreads) {\n size_t start;\n size_t end;\n std::tie(start, end) =\n galois::block_range((size_t)0, this->size(), tid, nthreads);\n unsigned int count = 0;\n unsigned int tPrefixBitCount;\n if (tid == 0) {\n tPrefixBitCount = 0;\n } else {\n tPrefixBitCount = tPrefixBitCounts[tid - 1];\n }\n\n for (unsigned int i = start; i < end; ++i) {\n if (this->test(i)) {\n offsets[tPrefixBitCount + count] = i;\n ++count;\n }\n }\n });\n }\n\n return offsets;\n }\n\n //! this is defined to\n using tt_is_copyable = int;\n};\n\n//! An empty bitset object; used mainly by InvalidBitsetFnTy\nstatic galois::DynamicBitSet EmptyBitset;\n\n//! A structure representing an empty bitset.\nstruct InvalidBitsetFnTy {\n //! Returns false as this is an empty bitset\n static constexpr bool is_vector_bitset() { return false; }\n\n //! Returns false as this is an empty bitset (invalid)\n static constexpr bool is_valid() { return false; }\n\n //! Returns the empty bitset\n static galois::DynamicBitSet& get() { return EmptyBitset; }\n\n //! No-op since it's an empty bitset\n static void reset_range(size_t, size_t) {}\n};\n} // namespace galois\n#endif\n" }, { "path": "libgalois/include/galois/Endian.h", "content": "/*\n * This file belongs to the Galois project, a C++ library for exploiting\n * parallelism. The code is being released under the terms of the 3-Clause BSD\n * License (a copy is located in LICENSE.txt at the top-level directory).\n *\n * Copyright (C) 2018, The University of Texas at Austin. All rights reserved.\n * UNIVERSITY EXPRESSLY DISCLAIMS ANY AND ALL WARRANTIES CONCERNING THIS\n * SOFTWARE AND DOCUMENTATION, INCLUDING ANY WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR ANY PARTICULAR PURPOSE, NON-INFRINGEMENT AND WARRANTIES OF\n * PERFORMANCE, AND ANY WARRANTY THAT MIGHT OTHERWISE ARISE FROM COURSE OF\n * DEALING OR USAGE OF TRADE. NO WARRANTY IS EITHER EXPRESS OR IMPLIED WITH\n * RESPECT TO THE USE OF THE SOFTWARE OR DOCUMENTATION. Under no circumstances\n * shall University be liable for incidental, special, indirect, direct or\n * consequential damages or loss of profits, interruption of business, or\n * related expenses which may arise from use of Software or Documentation,\n * including but not limited to those resulting from defects in Software and/or\n * Documentation, or loss or inaccuracy of data of any kind.\n */\n\n#ifndef GALOIS_ENDIAN_H\n#define GALOIS_ENDIAN_H\n\n#include \n\n#include \"galois/config.h\"\n\nnamespace galois {\n\nstatic inline uint32_t bswap32(uint32_t x) {\n#if defined(__GNUC__) || defined(__clang__)\n return __builtin_bswap32(x);\n#else\n return ((x << 24) & 0xff000000) | ((x << 8) & 0x00ff0000) |\n ((x >> 8) & 0x0000ff00) | ((x >> 24) & 0x000000ff);\n#endif\n}\n\nstatic inline uint64_t bswap64(uint64_t x) {\n#if defined(__GNUC__) || defined(__clang__)\n return __builtin_bswap64(x);\n#else\n return ((x << 56) & 0xff00000000000000UL) |\n ((x << 40) & 0x00ff000000000000UL) |\n ((x << 24) & 0x0000ff0000000000UL) |\n ((x << 8) & 0x000000ff00000000UL) | ((x >> 8) & 0x00000000ff000000UL) |\n ((x >> 24) & 0x0000000000ff0000UL) |\n ((x >> 40) & 0x000000000000ff00UL) |\n ((x >> 56) & 0x00000000000000ffUL);\n#endif\n}\n\n// NB: Wrap these standard functions with different names because\n// sometimes le64toh and such are implemented as macros and we don't\n// want any nasty surprises.\nstatic inline uint64_t convert_le64toh(uint64_t x) {\n#if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__\n return x;\n#else\n return bswap64(x);\n#endif\n}\n\nstatic inline uint32_t convert_le32toh(uint32_t x) {\n#if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__\n return x;\n#else\n return bswap32(x);\n#endif\n}\n\nstatic inline uint64_t convert_htobe64(uint64_t x) {\n#if __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__\n return x;\n#else\n return bswap64(x);\n#endif\n}\n\nstatic inline uint32_t convert_htobe32(uint32_t x) {\n#if __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__\n return x;\n#else\n return bswap32(x);\n#endif\n}\n\nstatic inline uint64_t convert_htole64(uint64_t x) {\n#if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__\n return x;\n#else\n return bswap64(x);\n#endif\n}\n\nstatic inline uint32_t convert_htole32(uint32_t x) {\n#if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__\n return x;\n#else\n return bswap32(x);\n#endif\n}\n\n} // namespace galois\n#endif\n" }, { "path": "libgalois/include/galois/FixedSizeRing.h", "content": "/*\n * This file belongs to the Galois project, a C++ library for exploiting\n * parallelism. The code is being released under the terms of the 3-Clause BSD\n * License (a copy is located in LICENSE.txt at the top-level directory).\n *\n * Copyright (C) 2018, The University of Texas at Austin. All rights reserved.\n * UNIVERSITY EXPRESSLY DISCLAIMS ANY AND ALL WARRANTIES CONCERNING THIS\n * SOFTWARE AND DOCUMENTATION, INCLUDING ANY WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR ANY PARTICULAR PURPOSE, NON-INFRINGEMENT AND WARRANTIES OF\n * PERFORMANCE, AND ANY WARRANTY THAT MIGHT OTHERWISE ARISE FROM COURSE OF\n * DEALING OR USAGE OF TRADE. NO WARRANTY IS EITHER EXPRESS OR IMPLIED WITH\n * RESPECT TO THE USE OF THE SOFTWARE OR DOCUMENTATION. Under no circumstances\n * shall University be liable for incidental, special, indirect, direct or\n * consequential damages or loss of profits, interruption of business, or\n * related expenses which may arise from use of Software or Documentation,\n * including but not limited to those resulting from defects in Software and/or\n * Documentation, or loss or inaccuracy of data of any kind.\n */\n\n#ifndef GALOIS_FIXEDSIZERING_H\n#define GALOIS_FIXEDSIZERING_H\n\n#include \n#include \n\n#include \n#include \n#include \n\n#include \"galois/config.h\"\n#include \"galois/optional.h\"\n#include \"galois/LazyArray.h\"\n\nnamespace galois {\n\n//! Unordered collection of bounded size\ntemplate \nclass FixedSizeBagBase {\n LazyArray datac;\n typedef typename boost::mpl::if_c,\n unsigned>::type Count;\n Count count;\n\n T* at(unsigned i) { return &datac[i]; }\n const T* at(unsigned i) const { return &datac[i]; }\n\n bool precondition() const { return count <= ChunkSize; }\n\npublic:\n typedef T value_type;\n typedef T* pointer;\n typedef const T* const_pointer;\n typedef T& reference;\n typedef const T& const_reference;\n typedef boost::reverse_iterator iterator;\n typedef boost::reverse_iterator const_iterator;\n typedef pointer reverse_iterator;\n typedef const_pointer const_reverse_iterator;\n\n FixedSizeBagBase() : count(0) {}\n\n template \n FixedSizeBagBase(InputIterator first, InputIterator last) : count(0) {\n while (first != last) {\n assert(count < ChunkSize);\n datac.emplace(count++, *first++);\n }\n }\n\n FixedSizeBagBase(const FixedSizeBagBase& o) = delete;\n FixedSizeBagBase& operator=(const FixedSizeBagBase& o) = delete;\n\n ~FixedSizeBagBase() { clear(); }\n\n unsigned size() const {\n assert(precondition());\n return count;\n }\n\n bool empty() const {\n assert(precondition());\n return count == 0;\n }\n\n bool full() const {\n assert(precondition());\n return count == ChunkSize;\n }\n\n void clear() {\n assert(precondition());\n for (unsigned x = 0; x < count; ++x)\n datac.destroy(x);\n count = 0;\n }\n\n template \n pointer push_back(U&& val) {\n return push_front(std::forward(val));\n }\n\n template \n pointer emplace_back(Args&&... args) {\n return emplace_front(std::forward(args)...);\n }\n\n template \n auto push_front(U&& val) -> typename std::enable_if::type {\n return emplace_front(std::forward(val));\n }\n\n template \n auto push_front(const value_type& val) ->\n typename std::enable_if::type {\n unsigned top;\n do {\n top = count.load(std::memory_order_relaxed);\n if (top >= ChunkSize)\n return nullptr;\n } while (!count.compare_exchange_weak(top, top + 1));\n return datac.emplace(top, val);\n }\n\n /**\n * emplace_front is not available for concurrent versions because it is not\n * possible for clients to know in advance whether insertion will succeed,\n * which will leave xvalue arguments in indeterminate state.\n */\n template \n auto emplace_front(Args&&... args) ->\n typename std::enable_if::type {\n if (full())\n return 0;\n unsigned top = count++;\n return datac.emplace(top, std::forward(args)...);\n }\n\n reference back() { return front(); }\n const_reference back() const { return front(); }\n galois::optional extract_back() { return extract_front(); }\n\n bool pop_back() { return pop_front(); }\n\n reference front() {\n assert(precondition());\n assert(!empty());\n return *at(count - 1);\n }\n\n const_reference front() const { return *at(count - 1); }\n\n template \n auto extract_front() ->\n typename std::enable_if>::type {\n if (!empty()) {\n galois::optional retval(back());\n pop_back();\n return retval;\n }\n return galois::optional();\n }\n\n //! returns true if something was popped\n template \n auto pop_front() -> typename std::enable_if::type {\n unsigned top;\n do {\n top = count.load(std::memory_order_relaxed);\n if (top == 0)\n return false;\n } while (!count.compare_exchange_weak(top, top - 1));\n datac.destroy(top);\n return true;\n }\n\n //! returns true if something was popped\n template \n auto pop_front() -> typename std::enable_if::type {\n if (count == 0)\n return false;\n datac.destroy(--count);\n return true;\n }\n\n reverse_iterator rbegin() { return &datac[0]; }\n reverse_iterator rend() { return &datac[count]; }\n const_reverse_iterator rbegin() const { return &datac[0]; }\n const_reverse_iterator rend() const { return &datac[count]; }\n\n iterator begin() { return iterator(rend()); }\n iterator end() { return iterator(rbegin()); }\n const_iterator begin() const { return const_iterator(rend()); }\n const_iterator end() const { return const_iterator(rbegin()); }\n};\n\n//! Unordered collection of bounded size\ntemplate \nusing FixedSizeBag = FixedSizeBagBase;\n\n//! Unordered collection of bounded size with concurrent insertion or deletion\n//! but not both simultaneously\ntemplate \nusing ConcurrentFixedSizeBag = FixedSizeBagBase;\n\n//! Ordered collection of bounded size\ntemplate \nclass FixedSizeRing {\n LazyArray datac;\n unsigned start;\n unsigned count;\n\n T* at(unsigned i) { return &datac[i]; }\n const T* at(unsigned i) const { return &datac[i]; }\n\n bool precondition() const { return count <= ChunkSize && start <= ChunkSize; }\n\n template \n class Iterator\n : public boost::iterator_facade, U,\n boost::random_access_traversal_tag> {\n friend class boost::iterator_core_access;\n U* base;\n unsigned cur;\n unsigned count;\n\n template \n bool equal(const Iterator& o) const {\n assert(base && o.base);\n return &base[cur] == &o.base[o.cur] && count == o.count;\n }\n\n U& dereference() const { return base[cur]; }\n\n void increment() {\n assert(base && count != 0);\n count -= 1;\n cur = (cur + 1) % ChunkSize;\n }\n\n void decrement() {\n assert(base && count < ChunkSize);\n count += 1;\n cur = (cur + ChunkSize - 1) % ChunkSize;\n }\n\n void advance(ptrdiff_t x) {\n count -= x;\n cur = (cur + ChunkSize + x) % ChunkSize;\n }\n\n ptrdiff_t distance_to(const Iterator& o) const {\n ptrdiff_t c = count;\n ptrdiff_t oc = o.count;\n return c - oc;\n }\n\n public:\n Iterator() : base(0), cur(0), count(0) {}\n\n template \n Iterator(const Iterator& o)\n : base(o.base), cur(o.cur), count(o.count) {}\n\n Iterator(U* b, unsigned c, unsigned co) : base(b), cur(c), count(co) {}\n };\n\npublic:\n typedef T value_type;\n typedef T* pointer;\n typedef T& reference;\n typedef const T& const_reference;\n typedef Iterator iterator;\n typedef Iterator const_iterator;\n typedef boost::reverse_iterator> reverse_iterator;\n typedef boost::reverse_iterator> const_reverse_iterator;\n\n FixedSizeRing() : start(0), count(0) {}\n\n template \n FixedSizeRing(InputIterator first, InputIterator last) : start(0), count(0) {\n while (first != last) {\n assert(count < ChunkSize);\n datac.emplace(count++, *first++);\n }\n }\n\n FixedSizeRing(const FixedSizeRing& o) = delete;\n FixedSizeRing& operator=(const FixedSizeRing& o) = delete;\n\n ~FixedSizeRing() { clear(); }\n\n unsigned size() const {\n assert(precondition());\n return count;\n }\n\n bool empty() const {\n assert(precondition());\n return count == 0;\n }\n\n bool full() const {\n assert(precondition());\n return count == ChunkSize;\n }\n\n reference getAt(unsigned x) {\n assert(precondition());\n assert(!empty());\n return *at((start + x) % ChunkSize);\n }\n\n const_reference getAt(unsigned x) const {\n assert(precondition());\n assert(!empty());\n return *at((start + x) % ChunkSize);\n }\n\n void clear() {\n assert(precondition());\n for (unsigned x = 0; x < count; ++x)\n datac.destroy((start + x) % ChunkSize);\n count = 0;\n start = 0;\n }\n\n // NB(ddn): Keeping emplace_front/_back code paths separate to improve\n // branch prediction etc\n template \n pointer emplace(iterator pos, Args&&... args) {\n if (full())\n return 0;\n unsigned i;\n if (pos == begin()) {\n i = start = (start + ChunkSize - 1) % ChunkSize;\n ++count;\n } else if (pos == end()) {\n i = (start + count) % ChunkSize;\n ++count;\n } else {\n auto d = std::distance(begin(), pos);\n i = (start + d) % ChunkSize;\n emplace_back();\n std::move_backward(begin() + d, end() - 1, end());\n datac.destroy(i);\n }\n return datac.emplace(i, std::forward(args)...);\n }\n\n template \n pointer push_front(U&& val) {\n return emplace_front(std::forward(val));\n }\n\n template \n pointer emplace_front(Args&&... args) {\n if (full())\n return 0;\n start = (start + ChunkSize - 1) % ChunkSize;\n ++count;\n return datac.emplace(start, std::forward(args)...);\n }\n\n template \n pointer push_back(U&& val) {\n return emplace_back(std::forward(val));\n }\n\n template \n pointer emplace_back(Args&&... args) {\n if (full())\n return 0;\n unsigned end = (start + count) % ChunkSize;\n ++count;\n return datac.emplace(end, std::forward(args)...);\n }\n\n reference front() {\n assert(precondition());\n assert(!empty());\n return *at(start);\n }\n\n const_reference front() const {\n assert(precondition());\n assert(!empty());\n return *at(start);\n }\n\n galois::optional extract_front() {\n if (!empty()) {\n galois::optional retval(front());\n pop_front();\n return retval;\n }\n return galois::optional();\n }\n\n void pop_front() {\n assert(precondition());\n assert(!empty());\n datac.destroy(start);\n start = (start + 1) % ChunkSize;\n --count;\n }\n\n reference back() {\n assert(precondition());\n assert(!empty());\n return *at((start + count - 1) % ChunkSize);\n }\n\n const_reference back() const {\n assert(precondition());\n assert(!empty());\n return *at((start + count - 1) % ChunkSize);\n }\n\n galois::optional extract_back() {\n if (!empty()) {\n galois::optional retval(back());\n pop_back();\n return retval;\n }\n return galois::optional();\n }\n\n void pop_back() {\n assert(precondition());\n assert(!empty());\n datac.destroy((start + count - 1) % ChunkSize);\n --count;\n }\n\n iterator begin() { return iterator(at(0), start, count); }\n iterator end() { return iterator(at(0), (start + count) % ChunkSize, 0); }\n const_iterator begin() const { return const_iterator(at(0), start, count); }\n const_iterator end() const {\n return const_iterator(at(0), (start + count) % ChunkSize, 0);\n }\n\n reverse_iterator rbegin() { return reverse_iterator(end()); }\n reverse_iterator rend() { return reverse_iterator(begin()); }\n const_iterator rbegin() const { const_reverse_iterator(this->end()); }\n const_iterator rend() const { const_reverse_iterator(this->begin()); }\n};\n\n} // namespace galois\n#endif\n" }, { "path": "libgalois/include/galois/FlatMap.h", "content": "/*\n * This file belongs to the Galois project, a C++ library for exploiting\n * parallelism. The code is being released under the terms of the 3-Clause BSD\n * License (a copy is located in LICENSE.txt at the top-level directory).\n *\n * Copyright (C) 2018, The University of Texas at Austin. All rights reserved.\n * UNIVERSITY EXPRESSLY DISCLAIMS ANY AND ALL WARRANTIES CONCERNING THIS\n * SOFTWARE AND DOCUMENTATION, INCLUDING ANY WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR ANY PARTICULAR PURPOSE, NON-INFRINGEMENT AND WARRANTIES OF\n * PERFORMANCE, AND ANY WARRANTY THAT MIGHT OTHERWISE ARISE FROM COURSE OF\n * DEALING OR USAGE OF TRADE. NO WARRANTY IS EITHER EXPRESS OR IMPLIED WITH\n * RESPECT TO THE USE OF THE SOFTWARE OR DOCUMENTATION. Under no circumstances\n * shall University be liable for incidental, special, indirect, direct or\n * consequential damages or loss of profits, interruption of business, or\n * related expenses which may arise from use of Software or Documentation,\n * including but not limited to those resulting from defects in Software and/or\n * Documentation, or loss or inaccuracy of data of any kind.\n */\n\n#ifndef GALOIS_FLATMAP_H\n#define GALOIS_FLATMAP_H\n\n#include \n#include \n#include \n#include \n\n#include \"galois/config.h\"\n\nnamespace galois {\n\n//! Simple map data structure, based off a single array.\ntemplate ,\n class _Alloc = std::allocator>,\n class _Store = std::vector, _Alloc>>\nclass flat_map {\npublic:\n typedef _Key key_type;\n typedef _Tp mapped_type;\n typedef std::pair<_Key, _Tp> value_type;\n typedef _Compare key_compare;\n typedef _Alloc allocator_type;\n\n class value_compare {\n friend class flat_map<_Key, _Tp, _Compare, _Alloc, _Store>;\n\n protected:\n _Compare comp;\n\n value_compare(_Compare __c) : comp(__c) {}\n\n public:\n bool operator()(const value_type& __x, const value_type& __y) const {\n return comp(__x.first, __y.first);\n }\n };\n\nprivate:\n /// This turns...\n typedef typename _Alloc::template rebind::other _Pair_alloc_type;\n\n typedef _Store _VectTy;\n _VectTy _data;\n _Compare _comp;\n\n class value_key_compare {\n friend class flat_map<_Key, _Tp, _Compare, _Alloc, _Store>;\n\n protected:\n _Compare comp;\n\n value_key_compare(_Compare __c) : comp(__c) {}\n\n public:\n bool operator()(const value_type& __x, const key_type& __y) const {\n return comp(__x.first, __y);\n }\n };\n\n value_key_compare value_key_comp() const {\n return value_key_compare(key_comp());\n }\n\n bool key_eq(const key_type& k1, const key_type& k2) const {\n return !key_comp()(k1, k2) && !key_comp()(k2, k1);\n }\n\n void resort() { std::sort(_data.begin(), _data.end(), value_comp()); }\n\npublic:\n typedef typename _Pair_alloc_type::pointer pointer;\n typedef typename _Pair_alloc_type::const_pointer const_pointer;\n typedef typename _Pair_alloc_type::reference reference;\n typedef typename _Pair_alloc_type::const_reference const_reference;\n typedef typename _VectTy::iterator iterator;\n typedef typename _VectTy::const_iterator const_iterator;\n typedef typename _VectTy::size_type size_type;\n typedef typename _VectTy::difference_type difference_type;\n typedef typename _VectTy::reverse_iterator reverse_iterator;\n typedef typename _VectTy::const_reverse_iterator const_reverse_iterator;\n\n flat_map() : _data(), _comp() {}\n\n explicit flat_map(const _Compare& __comp,\n const allocator_type& = allocator_type())\n // XXX :_data(_Pair_alloc_type(__a)), _comp(__comp) {}\n : _data(), _comp(__comp) {}\n\n flat_map(const flat_map& __x) : _data(__x._data), _comp(__x._comp) {}\n\n flat_map(flat_map&& __x)\n /* noexcept(std::is_nothrow_copy_constructible<_Compare>::value) */\n : _data(std::move(__x._data)), _comp(std::move(__x._comp)) {}\n\n /*\n flat_map(std::initializer_list __l,\n const _Compare& __comp = _Compare(),\n const allocator_type& __a = allocator_type())\n : _data(__l, _Pair_alloc_type(__a)), _comp(__comp) { resort(); }\n */\n\n template \n flat_map(_InputIterator __first, _InputIterator __last)\n : _data(__first, __last), _comp() {\n resort();\n }\n\n template \n flat_map(_InputIterator __first, _InputIterator __last, const _Compare&,\n const allocator_type& __a = allocator_type())\n : _data(__first, __last, _Pair_alloc_type(__a)) {\n resort();\n }\n\n flat_map& operator=(const flat_map& __x) {\n _data = __x._data;\n _comp = __x._comp;\n return *this;\n }\n\n flat_map& operator=(flat_map&& __x) {\n clear();\n swap(__x);\n return *this;\n }\n\n /*\n flat_map& operator=(std::initializer_list __l) {\n clear();\n insert(__l.begin(), __l.end());\n return *this;\n }\n */\n\n allocator_type get_allocator() const /* noexcept */ {\n return allocator_type(_data.get_allocator());\n }\n\n // iterators\n\n iterator begin() /* noexcept */ { return _data.begin(); }\n const_iterator begin() const /* noexcept */ { return _data.begin(); }\n iterator end() /* noexcept */ { return _data.end(); }\n const_iterator end() const /* noexcept */ { return _data.end(); }\n reverse_iterator rbegin() /* noexcept */ { return _data.rbegin(); }\n const_reverse_iterator rbegin() const /* noexcept */ {\n return _data.rbegin();\n }\n reverse_iterator rend() /* noexcept */ { return _data.rend(); }\n const_reverse_iterator rend() const /* noexcept */ { return _data.rend(); }\n const_iterator cbegin() const /* noexcept */ { return _data.begin(); }\n const_iterator cend() const /* noexcept */ { return _data.end(); }\n const_reverse_iterator crbegin() const /* noexcept */ {\n return _data.rbegin();\n }\n const_reverse_iterator crend() const /* noexcept */ { return _data.rend(); }\n\n bool empty() const /* noexcept */ { return _data.empty(); }\n size_type size() const /* noexcept */ { return _data.size(); }\n size_type max_size() const /* noexcept */ { return _data.max_size(); }\n\n template \n std::pair emplace(Args&&... args) {\n // assert(std::adjacent_find(_data.begin(), _data.end(), [&](const\n // value_type& a, const value_type& b) {\n // return key_comp()(b.first, a.first);\n //}) == _data.end());\n _data.emplace_back(std::forward(args)...);\n value_type& v = _data.back();\n auto ee = _data.end();\n --ee;\n auto __i = std::lower_bound(_data.begin(), ee, v.first, value_key_comp());\n // key < __i->first\n bool retval = __i == ee || key_comp()(v.first, (*__i).first);\n if (retval) {\n if (__i != ee) {\n value_type tmp = std::move(v);\n __i = _data.emplace(__i, std::move(tmp));\n _data.pop_back();\n }\n } else {\n // key == __i->first\n _data.pop_back();\n }\n return std::make_pair(__i, retval);\n }\n\n mapped_type& operator[](const key_type& __k) {\n iterator __i = lower_bound(__k);\n // __i->first is greater than or equivalent to __k.\n if (__i == end() || key_comp()(__k, (*__i).first))\n __i = _data.emplace(__i, std::piecewise_construct,\n std::forward_as_tuple(__k), std::tuple<>());\n return (*__i).second;\n }\n\n mapped_type& operator[](key_type&& __k) {\n iterator __i = lower_bound(__k);\n // __i->first is greater than or equivalent to __k.\n if (__i == end() || key_comp()(__k, (*__i).first))\n __i =\n _data.emplace(__i, std::piecewise_construct,\n std::forward_as_tuple(std::move(__k)), std::tuple<>());\n return (*__i).second;\n }\n\n mapped_type& at(const key_type& __k) {\n iterator __i = lower_bound(__k);\n if (__i == end() || key_comp()(__k, (*__i).first))\n throw std::out_of_range(\"flat_map::at\");\n return (*__i).second;\n }\n\n const mapped_type& at(const key_type& __k) const {\n const_iterator __i = lower_bound(__k);\n if (__i == end() || key_comp()(__k, (*__i).first))\n throw std::out_of_range(\"flat_map::at\");\n return (*__i).second;\n }\n\n template ::value>::type>\n std::pair insert(PairTy&& __x) {\n return emplace(std::forward(__x));\n }\n\n /*\n void insert(std::initializer_list __list) {\n insert(__list.begin(), __list.end());\n }\n */\n\n template \n void insert(_InputIterator __first, _InputIterator __last) {\n while (__first != __last)\n insert(*__first++);\n }\n\n iterator erase(const_iterator __position) { return _data.erase(__position); }\n iterator erase(iterator __position) { return _data.erase(__position); }\n\n size_type erase(const key_type& __x) {\n auto i = find(__x);\n if (i != end()) {\n _data.erase(i);\n return 1;\n }\n return 0;\n }\n\n iterator erase(const_iterator __first, const_iterator __last) {\n return _data.erase(__first, __last);\n }\n\n void swap(flat_map& __x) {\n _data.swap(__x._data);\n std::swap(_comp, __x._comp);\n }\n\n void clear() /* noexcept */ { _data.clear(); }\n\n key_compare key_comp() const { return _comp; }\n value_compare value_comp() const { return value_compare(key_comp()); }\n\n iterator find(const key_type& __x) {\n auto i = lower_bound(__x);\n if (i != end() && key_eq(i->first, __x))\n return i;\n return end();\n }\n\n const_iterator find(const key_type& __x) const {\n auto i = lower_bound(__x);\n if (i != end() && key_eq(i->first, __x))\n return i;\n return end();\n }\n\n size_type count(const key_type& __x) const {\n return find(__x) == end() ? 0 : 1;\n }\n\n iterator lower_bound(const key_type& __x) {\n return std::lower_bound(_data.begin(), _data.end(), __x, value_key_comp());\n }\n const_iterator lower_bound(const key_type& __x) const {\n return std::lower_bound(_data.begin(), _data.end(), __x, value_key_comp());\n }\n\n iterator upper_bound(const key_type& __x) {\n return std::upper_bound(_data.begin(), _data.end(), __x, value_key_comp());\n }\n const_iterator upper_bound(const key_type& __x) const {\n return std::upper_bound(_data.begin(), _data.end(), __x, value_key_comp());\n }\n\n std::pair equal_range(const key_type& __x) {\n return std::make_pair(lower_bound(__x), upper_bound(__x));\n }\n\n std::pair\n equal_range(const key_type& __x) const {\n return std::make_pair(lower_bound(__x), upper_bound(__x));\n }\n};\n\ntemplate \ninline bool operator==(const flat_map<_Key, _Tp, _Compare, _Alloc>& __x,\n const flat_map<_Key, _Tp, _Compare, _Alloc>& __y) {\n return __x._data == __y._data;\n}\n\ntemplate \ninline bool operator<(const flat_map<_Key, _Tp, _Compare, _Alloc>& __x,\n const flat_map<_Key, _Tp, _Compare, _Alloc>& __y) {\n return __x._data < __y._data;\n}\n\n/// Based on operator==\ntemplate \ninline bool operator!=(const flat_map<_Key, _Tp, _Compare, _Alloc>& __x,\n const flat_map<_Key, _Tp, _Compare, _Alloc>& __y) {\n return !(__x == __y);\n}\n\n/// Based on operator<\ntemplate \ninline bool operator>(const flat_map<_Key, _Tp, _Compare, _Alloc>& __x,\n const flat_map<_Key, _Tp, _Compare, _Alloc>& __y) {\n return __y < __x;\n}\n\n/// Based on operator<\ntemplate \ninline bool operator<=(const flat_map<_Key, _Tp, _Compare, _Alloc>& __x,\n const flat_map<_Key, _Tp, _Compare, _Alloc>& __y) {\n return !(__y < __x);\n}\n\n/// Based on operator<\ntemplate \ninline bool operator>=(const flat_map<_Key, _Tp, _Compare, _Alloc>& __x,\n const flat_map<_Key, _Tp, _Compare, _Alloc>& __y) {\n return !(__x < __y);\n}\n\n} // namespace galois\n\nnamespace std {\n\n/// See galois::flat_map::swap().\ntemplate \ninline void swap(galois::flat_map<_Key, _Tp, _Compare, _Alloc>& __x,\n galois::flat_map<_Key, _Tp, _Compare, _Alloc>& __y) {\n __x.swap(__y);\n}\n\n} // namespace std\n\n#endif\n" }, { "path": "libgalois/include/galois/Galois.h", "content": "/*\n * This file belongs to the Galois project, a C++ library for exploiting\n * parallelism. The code is being released under the terms of the 3-Clause BSD\n * License (a copy is located in LICENSE.txt at the top-level directory).\n *\n * Copyright (C) 2018, The University of Texas at Austin. All rights reserved.\n * UNIVERSITY EXPRESSLY DISCLAIMS ANY AND ALL WARRANTIES CONCERNING THIS\n * SOFTWARE AND DOCUMENTATION, INCLUDING ANY WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR ANY PARTICULAR PURPOSE, NON-INFRINGEMENT AND WARRANTIES OF\n * PERFORMANCE, AND ANY WARRANTY THAT MIGHT OTHERWISE ARISE FROM COURSE OF\n * DEALING OR USAGE OF TRADE. NO WARRANTY IS EITHER EXPRESS OR IMPLIED WITH\n * RESPECT TO THE USE OF THE SOFTWARE OR DOCUMENTATION. Under no circumstances\n * shall University be liable for incidental, special, indirect, direct or\n * consequential damages or loss of profits, interruption of business, or\n * related expenses which may arise from use of Software or Documentation,\n * including but not limited to those resulting from defects in Software and/or\n * Documentation, or loss or inaccuracy of data of any kind.\n */\n\n#ifndef GALOIS_GALOIS_H\n#define GALOIS_GALOIS_H\n\n#include \"galois/config.h\"\n#include \"galois/Loops.h\"\n#include \"galois/SharedMemSys.h\"\n#include \"galois/runtime/Mem.h\"\n\n#endif\n" }, { "path": "libgalois/include/galois/GaloisForwardDecl.h", "content": "/*\n * This file belongs to the Galois project, a C++ library for exploiting\n * parallelism. The code is being released under the terms of the 3-Clause BSD\n * License (a copy is located in LICENSE.txt at the top-level directory).\n *\n * Copyright (C) 2018, The University of Texas at Austin. All rights reserved.\n * UNIVERSITY EXPRESSLY DISCLAIMS ANY AND ALL WARRANTIES CONCERNING THIS\n * SOFTWARE AND DOCUMENTATION, INCLUDING ANY WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR ANY PARTICULAR PURPOSE, NON-INFRINGEMENT AND WARRANTIES OF\n * PERFORMANCE, AND ANY WARRANTY THAT MIGHT OTHERWISE ARISE FROM COURSE OF\n * DEALING OR USAGE OF TRADE. NO WARRANTY IS EITHER EXPRESS OR IMPLIED WITH\n * RESPECT TO THE USE OF THE SOFTWARE OR DOCUMENTATION. Under no circumstances\n * shall University be liable for incidental, special, indirect, direct or\n * consequential damages or loss of profits, interruption of business, or\n * related expenses which may arise from use of Software or Documentation,\n * including but not limited to those resulting from defects in Software and/or\n * Documentation, or loss or inaccuracy of data of any kind.\n */\n\n#include \"galois/config.h\"\n\nnamespace galois {\n\ntemplate \nvoid for_each(const RangeFunc& rangeMaker, FunctionTy&& fn,\n const Args&... args);\n\ntemplate \nvoid do_all(const RangeFunc& rangeMaker, FunctionTy&& fn, const Args&... args);\n\ntemplate \nvoid on_each(FunctionTy&& fn, const Args&... args);\n\n} // end namespace galois\n" }, { "path": "libgalois/include/galois/LargeArray.h", "content": "/*\n * This file belongs to the Galois project, a C++ library for exploiting\n * parallelism. The code is being released under the terms of the 3-Clause BSD\n * License (a copy is located in LICENSE.txt at the top-level directory).\n *\n * Copyright (C) 2018, The University of Texas at Austin. All rights reserved.\n * UNIVERSITY EXPRESSLY DISCLAIMS ANY AND ALL WARRANTIES CONCERNING THIS\n * SOFTWARE AND DOCUMENTATION, INCLUDING ANY WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR ANY PARTICULAR PURPOSE, NON-INFRINGEMENT AND WARRANTIES OF\n * PERFORMANCE, AND ANY WARRANTY THAT MIGHT OTHERWISE ARISE FROM COURSE OF\n * DEALING OR USAGE OF TRADE. NO WARRANTY IS EITHER EXPRESS OR IMPLIED WITH\n * RESPECT TO THE USE OF THE SOFTWARE OR DOCUMENTATION. Under no circumstances\n * shall University be liable for incidental, special, indirect, direct or\n * consequential damages or loss of profits, interruption of business, or\n * related expenses which may arise from use of Software or Documentation,\n * including but not limited to those resulting from defects in Software and/or\n * Documentation, or loss or inaccuracy of data of any kind.\n */\n\n#ifndef GALOIS_LARGEARRAY_H\n#define GALOIS_LARGEARRAY_H\n\n#include \n#include \n\n#include \n#include \n#include \n#include \n#include \n#include \n\n#include \"galois/config.h\"\n#include \"galois/Galois.h\"\n#include \"galois/gIO.h\"\n#include \"galois/ParallelSTL.h\"\n#include \"galois/runtime/Mem.h\"\n#include \"galois/substrate/NumaMem.h\"\n\nnamespace galois {\n\nnamespace runtime {\nextern unsigned activeThreads;\n} // end namespace runtime\n\n/**\n * Large array of objects with proper specialization for void type and\n * supporting various allocation and construction policies.\n *\n * @tparam T value type of container\n */\ntemplate \nclass LargeArray {\n substrate::LAptr m_realdata;\n T* m_data;\n size_t m_size;\n\npublic:\n typedef T raw_value_type;\n typedef T value_type;\n typedef size_t size_type;\n typedef ptrdiff_t difference_type;\n typedef value_type& reference;\n typedef const value_type& const_reference;\n typedef value_type* pointer;\n typedef const value_type* const_pointer;\n typedef pointer iterator;\n typedef const_pointer const_iterator;\n const static bool has_value = true;\n\n // Extra indirection to support incomplete T's\n struct size_of {\n const static size_t value = sizeof(T);\n };\n\nprotected:\n enum AllocType { Blocked, Local, Interleaved, Floating };\n void allocate(size_type n, AllocType t) {\n assert(!m_data);\n m_size = n;\n switch (t) {\n case Blocked:\n galois::gDebug(\"Block-alloc'd\");\n m_realdata =\n substrate::largeMallocBlocked(n * sizeof(T), runtime::activeThreads);\n break;\n case Interleaved:\n galois::gDebug(\"Interleave-alloc'd\");\n m_realdata = substrate::largeMallocInterleaved(n * sizeof(T),\n runtime::activeThreads);\n break;\n case Local:\n galois::gDebug(\"Local-allocd\");\n m_realdata = substrate::largeMallocLocal(n * sizeof(T));\n break;\n case Floating:\n galois::gDebug(\"Floating-alloc'd\");\n m_realdata = substrate::largeMallocFloating(n * sizeof(T));\n break;\n };\n m_data = reinterpret_cast(m_realdata.get());\n }\n\nprivate:\n /*\n * To support boost serialization\n */\n friend class boost::serialization::access;\n template \n void save(Archive& ar, const unsigned int) const {\n\n // TODO DON'T USE CERR\n // std::cerr << \"save m_size : \" << m_size << \" Threads : \" <<\n // runtime::activeThreads << \"\\n\";\n ar << m_size;\n // for(size_t i = 0; i < m_size; ++i){\n // ar << m_data[i];\n //}\n ar << boost::serialization::make_binary_object(m_data, m_size * sizeof(T));\n /*\n * Cas use make_array too as shown below\n * IMPORTANT: Use make_array as temp fix for benchmarks using non-trivial\n * structures in nodeData (Eg. SGD) This also requires changes in\n * libgalois/include/galois/graphs/Details.h (specified in the file).\n */\n // ar << boost::serialization::make_array(m_data, m_size);\n }\n template \n void load(Archive& ar, const unsigned int) {\n ar >> m_size;\n\n // TODO DON'T USE CERR\n // std::cerr << \"load m_size : \" << m_size << \" Threads : \" <<\n // runtime::activeThreads << \"\\n\";\n\n // TODO: For now, always use allocateInterleaved\n // Allocates and sets m_data pointer\n if (!m_data)\n allocateInterleaved(m_size);\n\n // for(size_t i = 0; i < m_size; ++i){\n // ar >> m_data[i];\n //}\n ar >> boost::serialization::make_binary_object(m_data, m_size * sizeof(T));\n /*\n * Cas use make_array too as shown below\n * IMPORTANT: Use make_array as temp fix for SGD\n * This also requires changes in\n * libgalois/include/galois/graphs/Details.h (specified in the file).\n */\n // ar >> boost::serialization::make_array(m_data, m_size);\n }\n // The macro BOOST_SERIALIZATION_SPLIT_MEMBER() generates code which invokes\n // the save or load depending on whether the archive is used for saving or\n // loading\n BOOST_SERIALIZATION_SPLIT_MEMBER()\n\npublic:\n /**\n * Wraps existing buffer in LargeArray interface.\n */\n LargeArray(void* d, size_t s) : m_data(reinterpret_cast(d)), m_size(s) {}\n\n LargeArray() : m_data(0), m_size(0) {}\n\n LargeArray(LargeArray&& o) : m_data(0), m_size(0) {\n std::swap(this->m_realdata, o.m_realdata);\n std::swap(this->m_data, o.m_data);\n std::swap(this->m_size, o.m_size);\n }\n\n LargeArray& operator=(LargeArray&& o) {\n std::swap(this->m_realdata, o.m_realdata);\n std::swap(this->m_data, o.m_data);\n std::swap(this->m_size, o.m_size);\n return *this;\n }\n\n LargeArray(const LargeArray&) = delete;\n LargeArray& operator=(const LargeArray&) = delete;\n\n ~LargeArray() {\n destroy();\n deallocate();\n }\n\n friend void swap(LargeArray& lhs, LargeArray& rhs) {\n std::swap(lhs.m_realdata, rhs.m_realdata);\n std::swap(lhs.m_data, rhs.m_data);\n std::swap(lhs.m_size, rhs.m_size);\n }\n\n const_reference at(difference_type x) const { return m_data[x]; }\n reference at(difference_type x) { return m_data[x]; }\n const_reference operator[](size_type x) const { return m_data[x]; }\n reference operator[](size_type x) { return m_data[x]; }\n void set(difference_type x, const_reference v) { m_data[x] = v; }\n size_type size() const { return m_size; }\n iterator begin() { return m_data; }\n const_iterator begin() const { return m_data; }\n iterator end() { return m_data + m_size; }\n const_iterator end() const { return m_data + m_size; }\n\n //! [allocatefunctions]\n //! Allocates interleaved across NUMA (memory) nodes.\n void allocateInterleaved(size_type n) { allocate(n, Interleaved); }\n\n /**\n * Allocates using blocked memory policy\n *\n * @param n number of elements to allocate\n */\n void allocateBlocked(size_type n) { allocate(n, Blocked); }\n\n /**\n * Allocates using Thread Local memory policy\n *\n * @param n number of elements to allocate\n */\n void allocateLocal(size_type n) { allocate(n, Local); }\n\n /**\n * Allocates using no memory policy (no pre alloc)\n *\n * @param n number of elements to allocate\n */\n void allocateFloating(size_type n) { allocate(n, Floating); }\n\n /**\n * Allocate memory to threads based on a provided array specifying which\n * threads receive which elements of data.\n *\n * @tparam RangeArrayTy The type of the threadRanges array; should either\n * be uint32_t* or uint64_t*\n * @param numberOfElements Number of elements to allocate space for\n * @param threadRanges An array specifying how elements should be split\n * among threads\n */\n template \n void allocateSpecified(size_type numberOfElements,\n RangeArrayTy& threadRanges) {\n assert(!m_data);\n\n m_realdata = substrate::largeMallocSpecified(numberOfElements * sizeof(T),\n runtime::activeThreads,\n threadRanges, sizeof(T));\n\n m_size = numberOfElements;\n m_data = reinterpret_cast(m_realdata.get());\n }\n //! [allocatefunctions]\n\n template \n void construct(Args&&... args) {\n for (T *ii = m_data, *ei = m_data + m_size; ii != ei; ++ii)\n new (ii) T(std::forward(args)...);\n }\n\n template \n void constructAt(size_type n, Args&&... args) {\n new (&m_data[n]) T(std::forward(args)...);\n }\n\n //! Allocate and construct\n template \n void create(size_type n, Args&&... args) {\n allocateInterleaved(n);\n construct(std::forward(args)...);\n }\n\n void deallocate() {\n m_realdata.reset();\n m_data = 0;\n m_size = 0;\n }\n\n void destroy() {\n if (!m_data)\n return;\n galois::ParallelSTL::destroy(m_data, m_data + m_size);\n }\n\n template \n std::enable_if_t::value> destroyAt(size_type n) {\n (&m_data[n])->~T();\n }\n\n template \n std::enable_if_t::value> destroyAt(size_type) {}\n\n // The following methods are not shared with void specialization\n const_pointer data() const { return m_data; }\n pointer data() { return m_data; }\n};\n\n//! Void specialization\ntemplate <>\nclass LargeArray {\n\nprivate:\n /*\n * To support boost serialization\n * Can use single function serialize instead of save and load, since both save\n * and load have identical code.\n */\n friend class boost::serialization::access;\n template \n void serialize(Archive&, const unsigned int) const {}\n\npublic:\n LargeArray(void*, size_t) {}\n LargeArray() = default;\n LargeArray(const LargeArray&) = delete;\n LargeArray& operator=(const LargeArray&) = delete;\n\n friend void swap(LargeArray&, LargeArray&) {}\n\n typedef void raw_value_type;\n typedef void* value_type;\n typedef size_t size_type;\n typedef ptrdiff_t difference_type;\n typedef value_type reference;\n typedef value_type const_reference;\n typedef value_type* pointer;\n typedef value_type* const_pointer;\n typedef pointer iterator;\n typedef const_pointer const_iterator;\n const static bool has_value = false;\n struct size_of {\n const static size_t value = 0;\n };\n\n const_reference at(difference_type) const { return 0; }\n reference at(difference_type) { return 0; }\n const_reference operator[](size_type) const { return 0; }\n template \n void set(difference_type, AnyTy) {}\n size_type size() const { return 0; }\n iterator begin() { return 0; }\n const_iterator begin() const { return 0; }\n iterator end() { return 0; }\n const_iterator end() const { return 0; }\n\n void allocateInterleaved(size_type) {}\n void allocateBlocked(size_type) {}\n void allocateLocal(size_type, bool = true) {}\n void allocateFloating(size_type) {}\n template \n void allocateSpecified(size_type, RangeArrayTy) {}\n\n template \n void construct(Args&&...) {}\n template \n void constructAt(size_type, Args&&...) {}\n template \n void create(size_type, Args&&...) {}\n\n void deallocate() {}\n void destroy() {}\n void destroyAt(size_type) {}\n\n const_pointer data() const { return 0; }\n pointer data() { return 0; }\n};\n\n} // namespace galois\n#endif\n" }, { "path": "libgalois/include/galois/LazyArray.h", "content": "/*\n * This file belongs to the Galois project, a C++ library for exploiting\n * parallelism. The code is being released under the terms of the 3-Clause BSD\n * License (a copy is located in LICENSE.txt at the top-level directory).\n *\n * Copyright (C) 2018, The University of Texas at Austin. All rights reserved.\n * UNIVERSITY EXPRESSLY DISCLAIMS ANY AND ALL WARRANTIES CONCERNING THIS\n * SOFTWARE AND DOCUMENTATION, INCLUDING ANY WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR ANY PARTICULAR PURPOSE, NON-INFRINGEMENT AND WARRANTIES OF\n * PERFORMANCE, AND ANY WARRANTY THAT MIGHT OTHERWISE ARISE FROM COURSE OF\n * DEALING OR USAGE OF TRADE. NO WARRANTY IS EITHER EXPRESS OR IMPLIED WITH\n * RESPECT TO THE USE OF THE SOFTWARE OR DOCUMENTATION. Under no circumstances\n * shall University be liable for incidental, special, indirect, direct or\n * consequential damages or loss of profits, interruption of business, or\n * related expenses which may arise from use of Software or Documentation,\n * including but not limited to those resulting from defects in Software and/or\n * Documentation, or loss or inaccuracy of data of any kind.\n */\n\n#ifndef GALOIS_LAZYARRAY_H\n#define GALOIS_LAZYARRAY_H\n\n#include \n#include \n#include \n#include \n#include \n#include \n\n#include \"galois/config.h\"\n#include \"galois/LazyObject.h\"\n\nnamespace galois {\n\n/**\n * This is a container that encapsulates space for a constant size array. The\n * initialization and destruction of items is explicitly under the control of\n * the user.\n */\ntemplate \nclass LazyArray {\n typedef typename std::aligned_storage<\n sizeof(_Tp), std::alignment_of<_Tp>::value>::type CharData;\n\n LazyObject<_Tp> data_[(_Size > 0 ? _Size : 1)];\n\n _Tp* get(size_t __n) { return &data_[__n].get(); }\n const _Tp* get(size_t __n) const { return &data_[__n].get(); }\n\npublic:\n typedef _Tp value_type;\n typedef size_t size_type;\n typedef ptrdiff_t difference_type;\n typedef value_type& reference;\n typedef const value_type& const_reference;\n typedef value_type* pointer;\n typedef const value_type* const_pointer;\n typedef pointer iterator;\n typedef const_pointer const_iterator;\n typedef std::reverse_iterator reverse_iterator;\n typedef std::reverse_iterator const_reverse_iterator;\n\n // iterators:\n iterator begin() { return iterator(get(0)); }\n const_iterator begin() const { return const_iterator(get(0)); }\n iterator end() { return iterator(get(_Size)); }\n const_iterator end() const { return const_iterator(get(_Size)); }\n\n reverse_iterator rbegin() { return reverse_iterator(end()); }\n const_reverse_iterator rbegin() const {\n return const_reverse_iterator(end());\n }\n reverse_iterator rend() { return reverse_iterator(begin()); }\n const_reverse_iterator rend() const {\n return const_reverse_iterator(begin());\n }\n\n const_iterator cbegin() const { return begin(); }\n const_iterator cend() const { return end(); }\n const_reverse_iterator crbegin() const { return rbegin(); }\n const_reverse_iterator crend() const { return rend(); }\n\n // capacity:\n size_type size() const { return _Size; }\n size_type max_size() const { return _Size; }\n bool empty() const { return _Size == 0; }\n\n // element access:\n reference operator[](size_type __n) { return *get(__n); }\n const_reference operator[](size_type __n) const { return *get(__n); }\n reference at(size_type __n) {\n if (__n >= _Size)\n throw std::out_of_range(\"lazyArray::at\");\n return get(__n);\n }\n const_reference at(size_type __n) const {\n if (__n >= _Size)\n throw std::out_of_range(\"lazyArray::at\");\n return get(__n);\n }\n\n reference front() { return *get(0); }\n const_reference front() const { return *get(0); }\n reference back() { return *get(_Size > 0 ? _Size - 1 : 0); }\n const_reference back() const { return *get(_Size > 0 ? _Size - 1 : 0); }\n\n pointer data() { return get(0); }\n const_pointer data() const { return get(0); }\n\n // missing: fill swap\n\n template \n pointer emplace(size_type __n, Args&&... args) {\n return new (get(__n)) _Tp(std::forward(args)...);\n }\n\n pointer construct(size_type __n, const _Tp& val) { return emplace(__n, val); }\n pointer construct(size_type __n, _Tp&& val) {\n return emplace(__n, std::move(val));\n }\n\n void destroy(size_type __n) { (get(__n))->~_Tp(); }\n};\n\n} // namespace galois\n#endif // GALOIS_LAZYARRAY_H\n" }, { "path": "libgalois/include/galois/LazyObject.h", "content": "/*\n * This file belongs to the Galois project, a C++ library for exploiting\n * parallelism. The code is being released under the terms of the 3-Clause BSD\n * License (a copy is located in LICENSE.txt at the top-level directory).\n *\n * Copyright (C) 2018, The University of Texas at Austin. All rights reserved.\n * UNIVERSITY EXPRESSLY DISCLAIMS ANY AND ALL WARRANTIES CONCERNING THIS\n * SOFTWARE AND DOCUMENTATION, INCLUDING ANY WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR ANY PARTICULAR PURPOSE, NON-INFRINGEMENT AND WARRANTIES OF\n * PERFORMANCE, AND ANY WARRANTY THAT MIGHT OTHERWISE ARISE FROM COURSE OF\n * DEALING OR USAGE OF TRADE. NO WARRANTY IS EITHER EXPRESS OR IMPLIED WITH\n * RESPECT TO THE USE OF THE SOFTWARE OR DOCUMENTATION. Under no circumstances\n * shall University be liable for incidental, special, indirect, direct or\n * consequential damages or loss of profits, interruption of business, or\n * related expenses which may arise from use of Software or Documentation,\n * including but not limited to those resulting from defects in Software and/or\n * Documentation, or loss or inaccuracy of data of any kind.\n */\n\n#ifndef GALOIS_LAZYOBJECT_H\n#define GALOIS_LAZYOBJECT_H\n\n#include \n#include \n\n#include \"galois/config.h\"\n#include \"galois/gIO.h\"\n\nnamespace galois {\n\n/**\n * Single object with specialization for void type. To take advantage of empty\n * member optimization, users should subclass this class, otherwise the\n * compiler will insert non-zero padding for fields (even when empty).\n */\ntemplate \nclass StrictObject {\n T data;\n\npublic:\n typedef T value_type;\n typedef T& reference;\n typedef const T& const_reference;\n const static bool has_value = true;\n\n StrictObject() {}\n StrictObject(const_reference t) : data(t) {}\n const_reference get() const { return data; }\n reference get() { return data; }\n};\n\ntemplate <>\nstruct StrictObject {\n typedef void* value_type;\n typedef void* reference;\n typedef void* const_reference;\n const static bool has_value = false;\n\n StrictObject() {}\n StrictObject(const_reference) {}\n reference get() const { return 0; }\n};\n\n/**\n * Single (uninitialized) object with specialization for void type. To take\n * advantage of empty member optimization, users should subclass this class,\n * otherwise the compiler will insert non-zero padding for fields (even when\n * empty).\n */\ntemplate \nclass LazyObject {\n typedef\n typename std::aligned_storage::value>::type CharData;\n\n union Data {\n CharData buf;\n T value_;\n\n // Declare constructor explicitly because Data must be default\n // constructable regardless of the constructability of T.\n Data() {} // NOLINT(modernize-use-equals-default)\n ~Data() {} // NOLINT(modernize-use-equals-default)\n\n T& value() { return value_; }\n const T& value() const { return value_; }\n };\n\n Data data_;\n\n T* cast() { return &data_.value(); }\n const T* cast() const { return &data_.value(); }\n\npublic:\n typedef T value_type;\n typedef T& reference;\n typedef const T& const_reference;\n const static bool has_value = true;\n // Can't support incomplete T's but provide same interface as\n // {@link galois::LargeArray} for consistency\n struct size_of {\n const static size_t value = sizeof(T);\n };\n\n void destroy() { cast()->~T(); }\n void construct(const_reference x) { new (cast()) T(x); }\n\n template \n void construct(Args&&... args) {\n new (cast()) T(std::forward(args)...);\n }\n\n const_reference get() const { return *cast(); }\n reference get() { return *cast(); }\n};\n\ntemplate <>\nstruct LazyObject {\n typedef void* value_type;\n typedef void* reference;\n typedef void* const_reference;\n const static bool has_value = false;\n struct size_of {\n const static size_t value = 0;\n };\n\n void destroy() {}\n void construct(const_reference) {}\n\n template \n void construct(Args&&...) {}\n\n const_reference get() const { return 0; }\n};\n\n} // namespace galois\n#endif\n" }, { "path": "libgalois/include/galois/Loops.h", "content": "/*\n * This file belongs to the Galois project, a C++ library for exploiting\n * parallelism. The code is being released under the terms of the 3-Clause BSD\n * License (a copy is located in LICENSE.txt at the top-level directory).\n *\n * Copyright (C) 2018, The University of Texas at Austin. All rights reserved.\n * UNIVERSITY EXPRESSLY DISCLAIMS ANY AND ALL WARRANTIES CONCERNING THIS\n * SOFTWARE AND DOCUMENTATION, INCLUDING ANY WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR ANY PARTICULAR PURPOSE, NON-INFRINGEMENT AND WARRANTIES OF\n * PERFORMANCE, AND ANY WARRANTY THAT MIGHT OTHERWISE ARISE FROM COURSE OF\n * DEALING OR USAGE OF TRADE. NO WARRANTY IS EITHER EXPRESS OR IMPLIED WITH\n * RESPECT TO THE USE OF THE SOFTWARE OR DOCUMENTATION. Under no circumstances\n * shall University be liable for incidental, special, indirect, direct or\n * consequential damages or loss of profits, interruption of business, or\n * related expenses which may arise from use of Software or Documentation,\n * including but not limited to those resulting from defects in Software and/or\n * Documentation, or loss or inaccuracy of data of any kind.\n */\n\n#ifndef GALOIS_LOOPS_H\n#define GALOIS_LOOPS_H\n\n#include \"galois/config.h\"\n#include \"galois/runtime/Executor_Deterministic.h\"\n#include \"galois/runtime/Executor_DoAll.h\"\n#include \"galois/runtime/Executor_ForEach.h\"\n#include \"galois/runtime/Executor_OnEach.h\"\n#include \"galois/runtime/Executor_Ordered.h\"\n#include \"galois/runtime/Executor_ParaMeter.h\"\n#include \"galois/worklists/WorkList.h\"\n\nnamespace galois {\n\n////////////////////////////////////////////////////////////////////////////////\n// Foreach\n////////////////////////////////////////////////////////////////////////////////\n\n/**\n * Galois unordered set iterator.\n * Operator should conform to fn(item, UserContext&) where item\n * is a value from the iteration range and T is the type of item.\n *\n * @param rangeMaker an iterate range maker typically returned by\n * galois::iterate(...)\n * (@see galois::iterate()). rangeMaker is a functor which when called returns a\n * range object\n * @param fn operator\n * @param args optional arguments to loop, e.g., {@see loopname}, {@see wl}\n */\n\ntemplate \nvoid for_each(const RangeFunc& rangeMaker, FunctionTy&& fn,\n const Args&... args) {\n auto tpl = std::make_tuple(args...);\n runtime::for_each_gen(rangeMaker(tpl), std::forward(fn), tpl);\n}\n\n/**\n * Standard do-all loop. All iterations should be independent.\n * Operator should conform to fn(item) where item is a value from\n * the iteration range.\n *\n * @param rangeMaker an iterate range maker typically returned by\n * galois::iterate(...)\n * (@see galois::iterate()). rangeMaker is a functor which when called returns a\n * range object\n * @param fn operator\n * @param args optional arguments to loop\n */\ntemplate \nvoid do_all(const RangeFunc& rangeMaker, FunctionTy&& fn, const Args&... args) {\n auto tpl = std::make_tuple(args...);\n runtime::do_all_gen(rangeMaker(tpl), std::forward(fn), tpl);\n}\n\n/**\n * Low-level parallel loop. Operator is applied for each running thread.\n * Operator should confirm to fn(tid, numThreads) where tid is\n * the id of the current thread and numThreads is the total number of running\n * threads.\n *\n * @param fn operator, which is never copied\n * @param args optional arguments to loop\n */\ntemplate \nvoid on_each(FunctionTy&& fn, const Args&... args) {\n runtime::on_each_gen(std::forward(fn), std::make_tuple(args...));\n}\n\n/**\n * Preallocates hugepages on each thread.\n *\n * @param num number of pages to allocate of size {@link\n * galois::runtime::MM::hugePageSize}\n */\nstatic inline void preAlloc(int num) {\n static const bool DISABLE_PREALLOC = false;\n if (DISABLE_PREALLOC) {\n galois::gWarn(\"preAlloc disabled\");\n\n } else {\n runtime::preAlloc_impl(num);\n }\n}\n\n/**\n * Reports number of hugepages allocated by the Galois system so far. The value\n * is printing using the statistics infrastructure.\n *\n * @param label Label to associated with report at this program point\n */\nstatic inline void reportPageAlloc(const char* label) {\n runtime::reportPageAlloc(label);\n}\n\n/**\n * Galois ordered set iterator for stable source algorithms.\n *\n * Operator should conform to fn(item, UserContext&) where item\n * is a value from the iteration range and T is the type of item. Comparison\n * function should conform to bool r = cmp(item1, item2) where r is\n * true if item1 is less than or equal to item2. Neighborhood function should\n * conform to nhFunc(item) and should visit every element in the\n * neighborhood of active element item.\n *\n * @param b begining of range of initial items\n * @param e end of range of initial items\n * @param cmp comparison function\n * @param nhFunc neighborhood function\n * @param fn operator\n * @param loopname string to identity loop in statistics output\n */\ntemplate \nvoid for_each_ordered(Iter b, Iter e, const Cmp& cmp, const NhFunc& nhFunc,\n const OpFunc& fn, const char* loopname = 0) {\n runtime::for_each_ordered_impl(b, e, cmp, nhFunc, fn, loopname);\n}\n\n/**\n * Galois ordered set iterator for unstable source algorithms.\n *\n * Operator should conform to fn(item, UserContext&) where item\n * is a value from the iteration range and T is the type of item. Comparison\n * function should conform to bool r = cmp(item1, item2) where r is\n * true if item1 is less than or equal to item2. Neighborhood function should\n * conform to nhFunc(item) and should visit every element in the\n * neighborhood of active element item. The stability test should conform to\n * bool r = stabilityTest(item) where r is true if item is a stable\n * source.\n *\n * @param b begining of range of initial items\n * @param e end of range of initial items\n * @param cmp comparison function\n * @param nhFunc neighborhood function\n * @param fn operator\n * @param stabilityTest stability test\n * @param loopname string to identity loop in statistics output\n */\ntemplate \nvoid for_each_ordered(Iter b, Iter e, const Cmp& cmp, const NhFunc& nhFunc,\n const OpFunc& fn, const StableTest& stabilityTest,\n const char* loopname = 0) {\n runtime::for_each_ordered_impl(b, e, cmp, nhFunc, fn, stabilityTest,\n loopname);\n}\n\n/**\n * Helper functor class to invoke galois::do_all on provided args\n * Can be used to choose between galois::do_all and other equivalents such as\n * std::for_each\n */\nstruct DoAll {\n template \n void operator()(const RangeFunc& rangeMaker, const F& f,\n Args&&... args) const {\n galois::do_all(rangeMaker, f, std::forward(args)...);\n }\n};\n\n/**\n * Helper functor to invoke std::for_each with the same interface as\n * galois::do_all\n */\n\nstruct StdForEach {\n template \n void operator()(const RangeFunc& rangeMaker, const F& f,\n Args&&... args) const {\n auto range = rangeMaker(std::make_tuple(args...));\n std::for_each(range.begin(), range.end(), f);\n }\n};\n\nstruct ForEach {\n template \n void operator()(const RangeFunc& rangeMaker, const F& f,\n Args&&... args) const {\n galois::for_each(rangeMaker, f, std::forward(args)...);\n }\n};\n\ntemplate \nstruct WhileQ {\n Q m_q;\n\n WhileQ(Q&& q = Q()) : m_q(std::move(q)) {}\n\n template \n void operator()(const RangeFunc& rangeMaker, const F& f, Args&&... args) {\n\n auto range = rangeMaker(std::make_tuple(args...));\n\n m_q.push(range.begin(), range.end());\n\n while (!m_q.empty()) {\n auto val = m_q.pop();\n\n f(val, m_q);\n }\n }\n};\n\n} // namespace galois\n\n#endif // GALOIS_LOOPS_H\n" }, { "path": "libgalois/include/galois/Mem.h", "content": "/*\n * This file belongs to the Galois project, a C++ library for exploiting\n * parallelism. The code is being released under the terms of the 3-Clause BSD\n * License (a copy is located in LICENSE.txt at the top-level directory).\n *\n * Copyright (C) 2018, The University of Texas at Austin. All rights reserved.\n * UNIVERSITY EXPRESSLY DISCLAIMS ANY AND ALL WARRANTIES CONCERNING THIS\n * SOFTWARE AND DOCUMENTATION, INCLUDING ANY WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR ANY PARTICULAR PURPOSE, NON-INFRINGEMENT AND WARRANTIES OF\n * PERFORMANCE, AND ANY WARRANTY THAT MIGHT OTHERWISE ARISE FROM COURSE OF\n * DEALING OR USAGE OF TRADE. NO WARRANTY IS EITHER EXPRESS OR IMPLIED WITH\n * RESPECT TO THE USE OF THE SOFTWARE OR DOCUMENTATION. Under no circumstances\n * shall University be liable for incidental, special, indirect, direct or\n * consequential damages or loss of profits, interruption of business, or\n * related expenses which may arise from use of Software or Documentation,\n * including but not limited to those resulting from defects in Software and/or\n * Documentation, or loss or inaccuracy of data of any kind.\n */\n\n#ifndef GALOIS_MEM_H\n#define GALOIS_MEM_H\n\n#include \"galois/config.h\"\n#include \"galois/runtime/Mem.h\"\n\nnamespace galois {\n\n//! [PerIterAllocTy example]\n//! Base allocator for per-iteration allocator\ntypedef galois::runtime::BumpWithMallocHeap<\n galois::runtime::FreeListHeap>\n IterAllocBaseTy;\n\n//! Per-iteration allocator that conforms to STL allocator interface\ntypedef galois::runtime::ExternalHeapAllocator\n PerIterAllocTy;\n//! [PerIterAllocTy example]\n\n//! Scalable fixed-sized allocator for T that conforms to STL allocator\n//! interface but does not support variable sized allocations\ntemplate \nusing FixedSizeAllocator = galois::runtime::FixedSizeAllocator;\n\n//! Scalable variable-sized allocator for T that allocates blocks of sizes in\n//! powers of 2 Useful for small and medium sized allocations, e.g. small or\n//! medium vectors, strings, deques\ntemplate \nusing Pow_2_VarSizeAlloc = typename runtime::Pow_2_BlockAllocator;\n\n} // namespace galois\n#endif\n" }, { "path": "libgalois/include/galois/MethodFlags.h", "content": "/*\n * This file belongs to the Galois project, a C++ library for exploiting\n * parallelism. The code is being released under the terms of the 3-Clause BSD\n * License (a copy is located in LICENSE.txt at the top-level directory).\n *\n * Copyright (C) 2018, The University of Texas at Austin. All rights reserved.\n * UNIVERSITY EXPRESSLY DISCLAIMS ANY AND ALL WARRANTIES CONCERNING THIS\n * SOFTWARE AND DOCUMENTATION, INCLUDING ANY WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR ANY PARTICULAR PURPOSE, NON-INFRINGEMENT AND WARRANTIES OF\n * PERFORMANCE, AND ANY WARRANTY THAT MIGHT OTHERWISE ARISE FROM COURSE OF\n * DEALING OR USAGE OF TRADE. NO WARRANTY IS EITHER EXPRESS OR IMPLIED WITH\n * RESPECT TO THE USE OF THE SOFTWARE OR DOCUMENTATION. Under no circumstances\n * shall University be liable for incidental, special, indirect, direct or\n * consequential damages or loss of profits, interruption of business, or\n * related expenses which may arise from use of Software or Documentation,\n * including but not limited to those resulting from defects in Software and/or\n * Documentation, or loss or inaccuracy of data of any kind.\n */\n\n#ifndef GALOIS_METHODFLAGS_H\n#define GALOIS_METHODFLAGS_H\n\n#include \"galois/config.h\"\n\nnamespace galois {\n\n/**\n * What should the runtime do when executing a method.\n *\n * Various methods take an optional parameter indicating what actions\n * the runtime should do on the user's behalf: (1) checking for conflicts,\n * and/or (2) saving undo information. By default, both are performed (ALL).\n */\nenum class MethodFlag : char {\n UNPROTECTED = 0,\n WRITE = 1,\n READ = 2,\n INTERNAL_MASK = 3,\n PREVIOUS = 4,\n};\n\n//! Bitwise & for method flags\ninline MethodFlag operator&(MethodFlag x, MethodFlag y) {\n return (MethodFlag)(((int)x) & ((int)y));\n}\n\n//! Bitwise | for method flags\ninline MethodFlag operator|(MethodFlag x, MethodFlag y) {\n return (MethodFlag)(((int)x) | ((int)y));\n}\n} // namespace galois\n\n#endif // GALOIS_METHODFLAGS_H\n" }, { "path": "libgalois/include/galois/NoDerefIterator.h", "content": "/*\n * This file belongs to the Galois project, a C++ library for exploiting\n * parallelism. The code is being released under the terms of the 3-Clause BSD\n * License (a copy is located in LICENSE.txt at the top-level directory).\n *\n * Copyright (C) 2018, The University of Texas at Austin. All rights reserved.\n * UNIVERSITY EXPRESSLY DISCLAIMS ANY AND ALL WARRANTIES CONCERNING THIS\n * SOFTWARE AND DOCUMENTATION, INCLUDING ANY WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR ANY PARTICULAR PURPOSE, NON-INFRINGEMENT AND WARRANTIES OF\n * PERFORMANCE, AND ANY WARRANTY THAT MIGHT OTHERWISE ARISE FROM COURSE OF\n * DEALING OR USAGE OF TRADE. NO WARRANTY IS EITHER EXPRESS OR IMPLIED WITH\n * RESPECT TO THE USE OF THE SOFTWARE OR DOCUMENTATION. Under no circumstances\n * shall University be liable for incidental, special, indirect, direct or\n * consequential damages or loss of profits, interruption of business, or\n * related expenses which may arise from use of Software or Documentation,\n * including but not limited to those resulting from defects in Software and/or\n * Documentation, or loss or inaccuracy of data of any kind.\n */\n\n#ifndef GALOIS_NODEREFITERATOR_H\n#define GALOIS_NODEREFITERATOR_H\n\n#include \"boost/iterator/iterator_adaptor.hpp\"\n\n#include \"galois/config.h\"\n\nnamespace galois {\n\n//! Modify an iterator so that *it == it\ntemplate \nstruct NoDerefIterator\n : public boost::iterator_adaptor, Iterator,\n Iterator, boost::use_default,\n const Iterator&> {\n NoDerefIterator() : NoDerefIterator::iterator_adaptor_() {}\n explicit NoDerefIterator(Iterator it)\n : NoDerefIterator::iterator_adaptor_(it) {}\n const Iterator& dereference() const {\n return NoDerefIterator::iterator_adaptor_::base_reference();\n }\n Iterator& dereference() {\n return NoDerefIterator::iterator_adaptor_::base_reference();\n }\n};\n\n//! Convenience function to create {@link NoDerefIterator}.\ntemplate \nNoDerefIterator make_no_deref_iterator(Iterator it) {\n return NoDerefIterator(it);\n}\n\n} // namespace galois\n\n#endif\n" }, { "path": "libgalois/include/galois/PODResizeableArray.h", "content": "/*\n * This file belongs to the Galois project, a C++ library for exploiting\n * parallelism. The code is being released under the terms of the 3-Clause BSD\n * License (a copy is located in LICENSE.txt at the top-level directory).\n *\n * Copyright (C) 2018, The University of Texas at Austin. All rights reserved.\n * UNIVERSITY EXPRESSLY DISCLAIMS ANY AND ALL WARRANTIES CONCERNING THIS\n * SOFTWARE AND DOCUMENTATION, INCLUDING ANY WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR ANY PARTICULAR PURPOSE, NON-INFRINGEMENT AND WARRANTIES OF\n * PERFORMANCE, AND ANY WARRANTY THAT MIGHT OTHERWISE ARISE FROM COURSE OF\n * DEALING OR USAGE OF TRADE. NO WARRANTY IS EITHER EXPRESS OR IMPLIED WITH\n * RESPECT TO THE USE OF THE SOFTWARE OR DOCUMENTATION. Under no circumstances\n * shall University be liable for incidental, special, indirect, direct or\n * consequential damages or loss of profits, interruption of business, or\n * related expenses which may arise from use of Software or Documentation,\n * including but not limited to those resulting from defects in Software and/or\n * Documentation, or loss or inaccuracy of data of any kind.\n */\n\n#ifndef GALOIS_PODRESIZEABLEARRAY_H\n#define GALOIS_PODRESIZEABLEARRAY_H\n\n#include \n#include \n#include \n#include \n#include \n#include \n\n#include \"galois/config.h\"\n\nnamespace galois {\n\n/**\n * This is a container that encapsulates a resizeable array\n * of plain-old-datatype (POD) elements.\n * There is no initialization or destruction of elements.\n */\ntemplate \nclass PODResizeableArray {\n _Tp* data_;\n size_t capacity_;\n size_t size_;\n\npublic:\n typedef _Tp value_type;\n typedef size_t size_type;\n typedef ptrdiff_t difference_type;\n typedef value_type& reference;\n typedef const value_type& const_reference;\n typedef value_type* pointer;\n typedef const value_type* const_pointer;\n typedef pointer iterator;\n typedef const_pointer const_iterator;\n typedef std::reverse_iterator reverse_iterator;\n typedef std::reverse_iterator const_reverse_iterator;\n\n PODResizeableArray() : data_(NULL), capacity_(0), size_(0) {}\n\n template \n PODResizeableArray(InputIterator first, InputIterator last)\n : data_(NULL), capacity_(0), size_(0) {\n size_t to_add = last - first;\n resize(to_add);\n std::copy_n(first, to_add, begin());\n }\n\n PODResizeableArray(size_t n) : data_(NULL), capacity_(0), size_(0) {\n resize(n);\n }\n\n //! disabled (shallow) copy constructor\n PODResizeableArray(const PODResizeableArray&) = delete;\n\n //! move constructor\n PODResizeableArray(PODResizeableArray&& v)\n : data_(v.data_), capacity_(v.capacity_), size_(v.size_) {\n v.data_ = NULL;\n v.capacity_ = 0;\n v.size_ = 0;\n }\n\n //! disabled (shallow) copy assignment operator\n PODResizeableArray& operator=(const PODResizeableArray&) = delete;\n\n //! move assignment operator\n PODResizeableArray& operator=(PODResizeableArray&& v) {\n if (data_ != NULL)\n free(data_);\n data_ = v.data_;\n capacity_ = v.capacity_;\n size_ = v.size_;\n v.data_ = NULL;\n v.capacity_ = 0;\n v.size_ = 0;\n return *this;\n }\n\n ~PODResizeableArray() {\n if (data_ != NULL)\n free(data_);\n }\n\n // iterators:\n iterator begin() { return iterator(&data_[0]); }\n const_iterator begin() const { return const_iterator(&data_[0]); }\n iterator end() { return iterator(&data_[size_]); }\n const_iterator end() const { return const_iterator(&data_[size_]); }\n\n reverse_iterator rbegin() { return reverse_iterator(end()); }\n const_reverse_iterator rbegin() const {\n return const_reverse_iterator(end());\n }\n reverse_iterator rend() { return reverse_iterator(begin()); }\n const_reverse_iterator rend() const {\n return const_reverse_iterator(begin());\n }\n\n const_iterator cbegin() const { return begin(); }\n const_iterator cend() const { return end(); }\n const_reverse_iterator crbegin() const { return rbegin(); }\n const_reverse_iterator crend() const { return rend(); }\n\n // size:\n size_type size() const { return size_; }\n size_type max_size() const { return capacity_; }\n bool empty() const { return size_ == 0; }\n\n void reserve(size_t n) {\n if (n > capacity_) {\n if (capacity_ == 0) {\n capacity_ = 1;\n }\n while (capacity_ < n) {\n capacity_ <<= 1;\n }\n data_ = static_cast<_Tp*>(\n realloc(reinterpret_cast(data_), capacity_ * sizeof(_Tp)));\n }\n }\n\n void resize(size_t n) {\n reserve(n);\n size_ = n;\n }\n\n void clear() { size_ = 0; }\n\n // element access:\n reference operator[](size_type __n) { return data_[__n]; }\n const_reference operator[](size_type __n) const { return data_[__n]; }\n reference at(size_type __n) {\n if (__n >= size_)\n throw std::out_of_range(\"PODResizeableArray::at\");\n return data_[__n];\n }\n const_reference at(size_type __n) const {\n if (__n >= size_)\n throw std::out_of_range(\"PODResizeableArray::at\");\n return data_[__n];\n }\n\n void assign(iterator first, iterator last) {\n size_t n = last - first;\n resize(n);\n memcpy(reinterpret_cast(data_), first, n * sizeof(_Tp));\n }\n\n reference front() { return data_[0]; }\n const_reference front() const { return data_[0]; }\n reference back() { return data_[size_ - 1]; }\n const_reference back() const { return data_[size_ - 1]; }\n\n pointer data() { return data_; }\n const_pointer data() const { return data_; }\n\n void push_back(const _Tp& value) {\n resize(size_ + 1);\n data_[size_ - 1] = value;\n }\n\n template \n void insert(iterator GALOIS_USED_ONLY_IN_DEBUG(position), InputIterator first,\n InputIterator last) {\n assert(position == end());\n size_t old_size = size_;\n size_t to_add = last - first;\n resize(old_size + to_add);\n std::copy_n(first, to_add, begin() + old_size);\n }\n\n void swap(PODResizeableArray& v) {\n std::swap(data_, v.data_);\n std::swap(size_, v.size_);\n std::swap(capacity_, v.capacity_);\n }\n};\n\n} // namespace galois\n#endif // GALOIS_PODRESIZEABLEARRAY_H\n" }, { "path": "libgalois/include/galois/ParallelSTL.h", "content": "/*\n * This file belongs to the Galois project, a C++ library for exploiting\n * parallelism. The code is being released under the terms of the 3-Clause BSD\n * License (a copy is located in LICENSE.txt at the top-level directory).\n *\n * Copyright (C) 2018, The University of Texas at Austin. All rights reserved.\n * UNIVERSITY EXPRESSLY DISCLAIMS ANY AND ALL WARRANTIES CONCERNING THIS\n * SOFTWARE AND DOCUMENTATION, INCLUDING ANY WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR ANY PARTICULAR PURPOSE, NON-INFRINGEMENT AND WARRANTIES OF\n * PERFORMANCE, AND ANY WARRANTY THAT MIGHT OTHERWISE ARISE FROM COURSE OF\n * DEALING OR USAGE OF TRADE. NO WARRANTY IS EITHER EXPRESS OR IMPLIED WITH\n * RESPECT TO THE USE OF THE SOFTWARE OR DOCUMENTATION. Under no circumstances\n * shall University be liable for incidental, special, indirect, direct or\n * consequential damages or loss of profits, interruption of business, or\n * related expenses which may arise from use of Software or Documentation,\n * including but not limited to those resulting from defects in Software and/or\n * Documentation, or loss or inaccuracy of data of any kind.\n */\n\n#ifndef GALOIS_PARALLELSTL_H\n#define GALOIS_PARALLELSTL_H\n\n#include \"galois/config.h\"\n#include \"galois/GaloisForwardDecl.h\"\n#include \"galois/NoDerefIterator.h\"\n#include \"galois/runtime/Range.h\"\n#include \"galois/Reduction.h\"\n#include \"galois/Traits.h\"\n#include \"galois/UserContext.h\"\n#include \"galois/Threads.h\"\n#include \"galois/worklists/Chunk.h\"\n\nnamespace galois {\n//! Parallel versions of STL library algorithms.\n// TODO: rename to gstl?\nnamespace ParallelSTL {\n\ntemplate \nsize_t count_if(InputIterator first, InputIterator last, Predicate pred) {\n\n galois::GAccumulator count;\n\n galois::do_all(galois::iterate(first, last), [&](const auto& v) {\n if (pred(v)) {\n count += 1;\n }\n });\n\n return count.reduce();\n}\n\ntemplate \nstruct find_if_helper {\n\n typedef galois::optional ElementTy;\n typedef substrate::PerThreadStorage AccumulatorTy;\n AccumulatorTy& accum;\n Predicate& f;\n\n find_if_helper(AccumulatorTy& a, Predicate& p) : accum(a), f(p) {}\n void operator()(const InputIterator& v, UserContext& ctx) {\n if (f(*v)) {\n *accum.getLocal() = v;\n ctx.breakLoop();\n }\n }\n};\n\ntemplate \nInputIterator find_if(InputIterator first, InputIterator last, Predicate pred) {\n typedef find_if_helper HelperTy;\n typedef typename HelperTy::AccumulatorTy AccumulatorTy;\n typedef galois::worklists::PerSocketChunkFIFO<256> WL;\n AccumulatorTy accum;\n HelperTy helper(accum, pred);\n for_each(galois::iterate(make_no_deref_iterator(first),\n make_no_deref_iterator(last)),\n helper, galois::disable_conflict_detection(), galois::no_pushes(),\n galois::parallel_break(), galois::wl());\n for (unsigned i = 0; i < accum.size(); ++i) {\n if (*accum.getRemote(i))\n return **accum.getRemote(i);\n }\n return last;\n}\n\ntemplate \nIterator choose_rand(Iterator first, Iterator last) {\n size_t dist = std::distance(first, last);\n if (dist)\n std::advance(first, rand() % dist);\n return first;\n}\n\ntemplate \nstruct sort_helper {\n Compare comp;\n\n //! Not equal in terms of less-than\n template \n struct neq_to {\n Compare comp;\n neq_to(Compare c) : comp(c) {}\n bool operator()(const value_type& a, const value_type& b) const {\n return comp(a, b) || comp(b, a);\n }\n };\n\n sort_helper(Compare c) : comp(c) {}\n\n template \n void operator()(std::pair bounds,\n Context& ctx) {\n if (std::distance(bounds.first, bounds.second) <= 1024) {\n std::sort(bounds.first, bounds.second, comp);\n } else {\n typedef\n typename std::iterator_traits::value_type VT;\n RandomAccessIterator pivot = choose_rand(bounds.first, bounds.second);\n VT pv = *pivot;\n pivot = std::partition(bounds.first, bounds.second,\n std::bind(comp, std::placeholders::_1, pv));\n // push the lower bit\n if (bounds.first != pivot)\n ctx.push(std::make_pair(bounds.first, pivot));\n // adjust the upper bit\n pivot =\n std::find_if(pivot, bounds.second,\n std::bind(neq_to(comp), std::placeholders::_1, pv));\n // push the upper bit\n if (bounds.second != pivot)\n ctx.push(std::make_pair(pivot, bounds.second));\n }\n }\n};\n\ntemplate \nstd::pair\ndual_partition(RandomAccessIterator first1, RandomAccessIterator last1,\n RandomAccessIterator first2, RandomAccessIterator last2,\n Predicate pred) {\n typedef std::reverse_iterator RI;\n RI first3(last2), last3(first2);\n while (true) {\n while (first1 != last1 && pred(*first1))\n ++first1;\n if (first1 == last1)\n break;\n while (first3 != last3 && !pred(*first3))\n ++first3;\n if (first3 == last3)\n break;\n std::swap(*first1++, *first3++);\n }\n return std::make_pair(first1, first3.base());\n}\n\ntemplate \nstruct partition_helper {\n typedef std::pair RP;\n struct partition_helper_state {\n RandomAccessIterator first, last;\n RandomAccessIterator rfirst, rlast;\n substrate::SimpleLock Lock;\n Predicate pred;\n typename std::iterator_traits::difference_type\n BlockSize() {\n return 1024;\n }\n\n partition_helper_state(RandomAccessIterator f, RandomAccessIterator l,\n Predicate p)\n : first(f), last(l), rfirst(l), rlast(f), pred(p) {}\n RP takeHigh() {\n Lock.lock();\n unsigned BS = std::min(BlockSize(), std::distance(first, last));\n last -= BS;\n RandomAccessIterator rv = last;\n Lock.unlock();\n return std::make_pair(rv, rv + BS);\n }\n RP takeLow() {\n Lock.lock();\n unsigned BS = std::min(BlockSize(), std::distance(first, last));\n RandomAccessIterator rv = first;\n first += BS;\n Lock.unlock();\n return std::make_pair(rv, rv + BS);\n }\n void update(RP low, RP high) {\n Lock.lock();\n if (low.first != low.second) {\n rfirst = std::min(rfirst, low.first);\n rlast = std::max(rlast, low.second);\n }\n if (high.first != high.second) {\n rfirst = std::min(rfirst, high.first);\n rlast = std::max(rlast, high.second);\n }\n Lock.unlock();\n }\n };\n\n partition_helper(partition_helper_state* s) : state(s) {}\n\n partition_helper_state* state;\n\n void operator()(unsigned, unsigned) {\n RP high, low;\n do {\n RP parts = dual_partition(low.first, low.second, high.first, high.second,\n state->pred);\n low.first = parts.first;\n high.second = parts.second;\n if (low.first == low.second)\n low = state->takeLow();\n if (high.first == high.second)\n high = state->takeHigh();\n } while (low.first != low.second && high.first != high.second);\n state->update(low, high);\n }\n};\n\ntemplate \nRandomAccessIterator partition(RandomAccessIterator first,\n RandomAccessIterator last, Predicate pred) {\n if (std::distance(first, last) <= 1024)\n return std::partition(first, last, pred);\n typedef partition_helper P;\n typename P::partition_helper_state s(first, last, pred);\n on_each(P(&s));\n if (s.rfirst == first && s.rlast == last) { // perfect !\n // abort();\n return s.first;\n }\n return std::partition(s.rfirst, s.rlast, pred);\n}\n\nstruct pair_dist {\n template \n bool operator()(const RP& x, const RP& y) {\n return std::distance(x.first, x.second) > std::distance(y.first, y.second);\n }\n};\n\ntemplate \nvoid sort(RandomAccessIterator first, RandomAccessIterator last, Compare comp) {\n if (std::distance(first, last) <= 1024) {\n std::sort(first, last, comp);\n return;\n }\n typedef galois::worklists::PerSocketChunkFIFO<1> WL;\n\n for_each(galois::iterate({std::make_pair(first, last)}),\n sort_helper(comp), galois::disable_conflict_detection(),\n galois::wl());\n}\n\ntemplate \nvoid sort(RandomAccessIterator first, RandomAccessIterator last) {\n galois::ParallelSTL::sort(\n first, last,\n std::less<\n typename std::iterator_traits::value_type>());\n}\n\ntemplate \nT accumulate(InputIterator first, InputIterator last, const T& identity,\n const BinaryOperation& binary_op) {\n\n auto id_fn = [=]() { return identity; };\n\n auto r = make_reducible(binary_op, id_fn);\n\n do_all(galois::iterate(first, last), [&](const T& v) { r.update(v); });\n\n return r.reduce();\n}\n\ntemplate \nT accumulate(InputIterator first, InputIterator last, const T& identity = T()) {\n return accumulate(first, last, identity, std::plus());\n}\n\ntemplate \nT map_reduce(InputIterator first, InputIterator last, MapFn map_fn,\n ReduceFn reduce_fn, const T& identity) {\n\n auto id_fn = [=]() { return identity; };\n\n auto r = make_reducible(reduce_fn, id_fn);\n\n galois::do_all(galois::iterate(first, last),\n [&](const auto& v) { r.update(map_fn(v)); });\n\n return r.reduce();\n}\n\ntemplate \nstd::enable_if_t>::value> destroy(I first,\n I last) {\n using T = internal::Val_ty;\n do_all(iterate(first, last), [=](T& i) { (&i)->~T(); });\n}\n\ntemplate \nstd::enable_if_t>::value> destroy(I, I) {}\n\n/**\n * Does a partial sum from first -> last and writes the results to the d_first\n * iterator.\n */\ntemplate \nOutputIt partial_sum(InputIt first, InputIt last, OutputIt d_first) {\n using ValueType = typename std::iterator_traits::value_type;\n\n size_t sizeOfVector = std::distance(first, last);\n\n // only bother with parallel execution if vector is larger than some size\n if (sizeOfVector >= 1024) {\n const size_t numBlocks = galois::getActiveThreads();\n const size_t blockSize = (sizeOfVector + numBlocks - 1) / numBlocks;\n assert(numBlocks * blockSize >= sizeOfVector);\n\n std::vector localSums(numBlocks);\n\n // get the block sums\n galois::do_all(\n galois::iterate((size_t)0, numBlocks), [&](const size_t& block) {\n // block start can extend past sizeOfVector if doesn't divide evenly\n size_t blockStart = std::min(block * blockSize, sizeOfVector);\n size_t blockEnd = std::min((block + 1) * blockSize, sizeOfVector);\n assert(blockStart <= blockEnd);\n\n // partial accumulation of each block done now\n std::partial_sum(first + blockStart, first + blockEnd,\n d_first + blockStart);\n // save the last number in this block: used for block prefix sum\n if (blockEnd > 0) {\n localSums[block] = *(d_first + blockEnd - 1);\n } else {\n localSums[block] = 0;\n }\n });\n\n // bulkPrefix[i] holds the starting sum of a particular block i\n std::vector bulkPrefix(numBlocks);\n // exclusive scan on local sums to get number to add to each block's\n // set of indices\n // Not using std::exclusive_scan because apparently it doesn't work for\n // some compilers\n ValueType runningSum = 0;\n for (size_t i = 0; i < numBlocks; i++) {\n bulkPrefix[i] = runningSum;\n runningSum += localSums[i];\n }\n\n galois::do_all(\n galois::iterate((size_t)0, numBlocks), [&](const size_t& block) {\n // add the sums of previous elements to blocks\n ValueType numToAdd = bulkPrefix[block];\n size_t blockStart = std::min(block * blockSize, sizeOfVector);\n size_t blockEnd = std::min((block + 1) * blockSize, sizeOfVector);\n assert(blockStart <= blockEnd);\n\n // transform applies addition to appropriate range\n std::transform(d_first + blockStart, d_first + blockEnd,\n d_first + blockStart,\n [&](ValueType& val) { return val + numToAdd; });\n });\n\n // return the iterator past the last element written\n return d_first + sizeOfVector;\n } else {\n // vector is small; do it serially using standard library\n return std::partial_sum(first, last, d_first);\n }\n}\n\n} // end namespace ParallelSTL\n} // end namespace galois\n#endif\n" }, { "path": "libgalois/include/galois/PerThreadContainer.h", "content": "/*\n * This file belongs to the Galois project, a C++ library for exploiting\n * parallelism. The code is being released under the terms of the 3-Clause BSD\n * License (a copy is located in LICENSE.txt at the top-level directory).\n *\n * Copyright (C) 2018, The University of Texas at Austin. All rights reserved.\n * UNIVERSITY EXPRESSLY DISCLAIMS ANY AND ALL WARRANTIES CONCERNING THIS\n * SOFTWARE AND DOCUMENTATION, INCLUDING ANY WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR ANY PARTICULAR PURPOSE, NON-INFRINGEMENT AND WARRANTIES OF\n * PERFORMANCE, AND ANY WARRANTY THAT MIGHT OTHERWISE ARISE FROM COURSE OF\n * DEALING OR USAGE OF TRADE. NO WARRANTY IS EITHER EXPRESS OR IMPLIED WITH\n * RESPECT TO THE USE OF THE SOFTWARE OR DOCUMENTATION. Under no circumstances\n * shall University be liable for incidental, special, indirect, direct or\n * consequential damages or loss of profits, interruption of business, or\n * related expenses which may arise from use of Software or Documentation,\n * including but not limited to those resulting from defects in Software and/or\n * Documentation, or loss or inaccuracy of data of any kind.\n */\n\n#ifndef GALOIS_PERTHREADCONTAINER_H\n#define GALOIS_PERTHREADCONTAINER_H\n\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\n#include \n#include \n#include \n\n#include \"galois/config.h\"\n#include \"galois/gdeque.h\"\n#include \"galois/gIO.h\"\n#include \"galois/gstl.h\"\n#include \"galois/PriorityQueue.h\"\n#include \"galois/runtime/Executor_DoAll.h\"\n#include \"galois/runtime/Executor_OnEach.h\"\n#include \"galois/runtime/Mem.h\"\n#include \"galois/substrate/PerThreadStorage.h\"\n#include \"galois/substrate/ThreadPool.h\"\n#include \"galois/Threads.h\"\n#include \"galois/TwoLevelIterator.h\"\n\nnamespace galois {\n\nnamespace {\n\nenum GlobalPos { GLOBAL_BEGIN, GLOBAL_END };\n\n#define ADAPTOR_BASED_OUTER_ITER\n\n// XXX: use a combination of boost::transform_iterator and\n// boost::counting_iterator to implement the following OuterPerThreadWLIter\n#ifdef ADAPTOR_BASED_OUTER_ITER\n\ntemplate \nstruct WLindexer {\n typedef typename PerThrdCont::container_type Ret_ty;\n\n PerThrdCont* wl;\n\n WLindexer() : wl(NULL) {}\n\n WLindexer(PerThrdCont& _wl) : wl(&_wl) {}\n\n Ret_ty& operator()(unsigned i) const {\n assert(wl != NULL);\n assert(i < wl->numRows());\n return const_cast(wl->get(i));\n }\n};\n\ntemplate \nstruct TypeFactory {\n typedef typename boost::transform_iterator,\n boost::counting_iterator>\n OuterIter;\n typedef typename std::reverse_iterator RvrsOuterIter;\n};\n\ntemplate \ntypename TypeFactory::OuterIter make_outer_begin(PerThrdCont& wl) {\n return boost::make_transform_iterator(boost::counting_iterator(0),\n WLindexer(wl));\n}\n\ntemplate \ntypename TypeFactory::OuterIter make_outer_end(PerThrdCont& wl) {\n return boost::make_transform_iterator(\n boost::counting_iterator(wl.numRows()),\n WLindexer(wl));\n}\n\ntemplate \ntypename TypeFactory::RvrsOuterIter\nmake_outer_rbegin(PerThrdCont& wl) {\n return typename TypeFactory::RvrsOuterIter(make_outer_end(wl));\n}\n\ntemplate \ntypename TypeFactory::RvrsOuterIter\nmake_outer_rend(PerThrdCont& wl) {\n return typename TypeFactory::RvrsOuterIter(make_outer_begin(wl));\n}\n\n#else\n\ntemplate \nclass OuterPerThreadWLIter\n : public boost::iterator_facade,\n typename PerThrdCont::container_type,\n boost::random_access_traversal_tag> {\n\n using container_type = typename PerThrdCont::container_type;\n using Diff_ty = ptrdiff_t;\n\n friend class boost::iterator_core_access;\n\n PerThrdCont* workList;\n // using Diff_ty due to reverse iterator, whose\n // end is -1, and, begin is numRows - 1\n Diff_ty row;\n\n void assertInRange() const {\n assert((row >= 0) && (row < workList->numRows()));\n }\n\n // container_type& getWL() {\n // assertInRange();\n // return (*workList)[row];\n // }\n\n container_type& getWL() const {\n assertInRange();\n return (*workList)[row];\n }\n\npublic:\n OuterPerThreadWLIter() : workList(NULL), row(0) {}\n\n OuterPerThreadWLIter(PerThrdCont& wl, const GlobalPos& pos)\n : workList(&wl), row(0) {\n\n switch (pos) {\n case GLOBAL_BEGIN:\n row = 0;\n break;\n case GLOBAL_END:\n row = wl.numRows();\n break;\n default:\n std::abort();\n }\n }\n\n container_type& dereference(void) const { return getWL(); }\n\n // const container_type& dereference (void) const {\n // getWL ();\n // }\n\n void increment(void) { ++row; }\n\n void decrement(void) { --row; }\n\n bool equal(const OuterPerThreadWLIter& that) const {\n assert(this->workList == that.workList);\n return this->row == that.row;\n }\n\n void advance(ptrdiff_t n) { row += n; }\n\n Diff_ty distance_to(const OuterPerThreadWLIter& that) const {\n assert(this->workList == that.workList);\n return that.row - this->row;\n }\n};\n\ntemplate \nOuterPerThreadWLIter make_outer_begin(PerThrdCont& wl) {\n return OuterPerThreadWLIter(wl, GLOBAL_BEGIN);\n}\n\ntemplate \nOuterPerThreadWLIter make_outer_end(PerThrdCont& wl) {\n return OuterPerThreadWLIter(wl, GLOBAL_END);\n}\n\ntemplate \nstd::reverse_iterator>\nmake_outer_rbegin(PerThrdCont& wl) {\n typedef typename std::reverse_iterator>\n Ret_ty;\n return Ret_ty(make_outer_end(wl));\n}\n\ntemplate \nstd::reverse_iterator>\nmake_outer_rend(PerThrdCont& wl) {\n typedef typename std::reverse_iterator>\n Ret_ty;\n return Ret_ty(make_outer_begin(wl));\n}\n\n#endif\n\n} // end namespace\n\ntemplate \nclass PerThreadContainer {\npublic:\n typedef Cont_tp container_type;\n typedef typename container_type::value_type value_type;\n typedef typename container_type::reference reference;\n typedef typename container_type::pointer pointer;\n typedef typename container_type::size_type size_type;\n\n typedef typename container_type::iterator local_iterator;\n typedef typename container_type::const_iterator local_const_iterator;\n typedef typename container_type::reverse_iterator local_reverse_iterator;\n typedef typename container_type::const_reverse_iterator\n local_const_reverse_iterator;\n\n typedef PerThreadContainer This_ty;\n\n#ifdef ADAPTOR_BASED_OUTER_ITER\n typedef typename TypeFactory::OuterIter OuterIter;\n typedef typename TypeFactory::RvrsOuterIter RvrsOuterIter;\n#else\n typedef OuterPerThreadWLIter OuterIter;\n typedef typename std::reverse_iterator RvrsOuterIter;\n#endif\n typedef typename galois::ChooseStlTwoLevelIterator<\n OuterIter, typename container_type::iterator>::type global_iterator;\n typedef typename galois::ChooseStlTwoLevelIterator<\n OuterIter, typename container_type::const_iterator>::type\n global_const_iterator;\n typedef typename galois::ChooseStlTwoLevelIterator<\n RvrsOuterIter, typename container_type::reverse_iterator>::type\n global_reverse_iterator;\n typedef typename galois::ChooseStlTwoLevelIterator<\n RvrsOuterIter, typename container_type::const_reverse_iterator>::type\n global_const_reverse_iterator;\n\n typedef global_iterator iterator;\n typedef global_const_iterator const_iterator;\n typedef global_reverse_iterator reverse_iterator;\n typedef global_const_reverse_iterator const_reverse_iterator;\n\nprivate:\n // XXX: for testing only\n\n#if 0\n struct FakePTS {\n std::vector v;\n\n FakePTS () {\n v.resize (size ());\n }\n\n container_type** getLocal () const {\n return getRemote (galois::runtime::LL::getTID ());\n }\n\n container_type** getRemote (size_t i) const {\n assert (i < v.size ());\n return const_cast (&v[i]);\n }\n\n size_t size () const { return galois::runtime::LL::getMaxThreads(); }\n\n };\n#endif\n // typedef FakePTS PerThrdCont_ty;\n typedef galois::substrate::PerThreadStorage PerThrdCont_ty;\n PerThrdCont_ty perThrdCont;\n\n void destroy() {\n for (unsigned i = 0; i < perThrdCont.size(); ++i) {\n delete *perThrdCont.getRemote(i);\n *perThrdCont.getRemote(i) = NULL;\n }\n }\n\nprotected:\n PerThreadContainer() : perThrdCont() {\n for (unsigned i = 0; i < perThrdCont.size(); ++i) {\n *perThrdCont.getRemote(i) = NULL;\n }\n }\n\n template \n void init(Args&&... args) {\n for (unsigned i = 0; i < perThrdCont.size(); ++i) {\n *perThrdCont.getRemote(i) =\n new container_type(std::forward(args)...);\n }\n }\n\n ~PerThreadContainer() {\n clear_all_parallel();\n destroy();\n }\n\npublic:\n unsigned numRows() const { return perThrdCont.size(); }\n\n container_type& get() { return **(perThrdCont.getLocal()); }\n\n const container_type& get() const { return **(perThrdCont.getLocal()); }\n\n container_type& get(unsigned i) { return **(perThrdCont.getRemote(i)); }\n\n const container_type& get(unsigned i) const {\n return **(perThrdCont.getRemote(i));\n }\n\n container_type& operator[](unsigned i) { return get(i); }\n\n const container_type& operator[](unsigned i) const { return get(i); }\n\n global_iterator begin_all() {\n return galois::stl_two_level_begin(make_outer_begin(*this),\n make_outer_end(*this));\n }\n\n global_iterator end_all() {\n return galois::stl_two_level_end(make_outer_begin(*this),\n make_outer_end(*this));\n }\n\n global_const_iterator begin_all() const { return cbegin_all(); }\n\n global_const_iterator end_all() const { return cend_all(); }\n\n // for compatibility with Range.h\n global_iterator begin() { return begin_all(); }\n\n global_iterator end() { return end_all(); }\n\n global_const_iterator begin() const { return begin_all(); }\n\n global_const_iterator end() const { return end_all(); }\n\n global_const_iterator cbegin() const { return cbegin_all(); }\n\n global_const_iterator cend() const { return cend_all(); }\n\n global_const_iterator cbegin_all() const {\n return galois::stl_two_level_cbegin(make_outer_begin(*this),\n make_outer_end(*this));\n }\n\n global_const_iterator cend_all() const {\n return galois::stl_two_level_cend(make_outer_begin(*this),\n make_outer_end(*this));\n }\n\n global_reverse_iterator rbegin_all() {\n return galois::stl_two_level_rbegin(make_outer_rbegin(*this),\n make_outer_rend(*this));\n }\n\n global_reverse_iterator rend_all() {\n return galois::stl_two_level_rend(make_outer_rbegin(*this),\n make_outer_rend(*this));\n }\n\n global_const_reverse_iterator rbegin_all() const { return crbegin_all(); }\n\n global_const_reverse_iterator rend_all() const { return crend_all(); }\n\n global_const_reverse_iterator crbegin_all() const {\n return galois::stl_two_level_crbegin(make_outer_rbegin(*this),\n make_outer_rend(*this));\n }\n\n global_const_reverse_iterator crend_all() const {\n return galois::stl_two_level_crend(make_outer_rbegin(*this),\n make_outer_rend(*this));\n }\n\n local_iterator local_begin() { return get().begin(); }\n local_iterator local_end() { return get().end(); }\n\n // legacy STL\n local_const_iterator local_begin() const { return get().begin(); }\n local_const_iterator local_end() const { return get().end(); }\n\n local_const_iterator local_cbegin() const { return get().cbegin(); }\n local_const_iterator local_cend() const { return get().cend(); }\n\n local_reverse_iterator local_rbegin() { return get().rbegin(); }\n local_reverse_iterator local_rend() { return get().rend(); }\n\n local_const_reverse_iterator local_crbegin() const { return get().crbegin(); }\n local_const_reverse_iterator local_crend() const { return get().crend(); }\n\n size_type size_all() const {\n size_type sz = 0;\n\n for (unsigned i = 0; i < perThrdCont.size(); ++i) {\n sz += get(i).size();\n }\n\n return sz;\n }\n\n // XXX: disabling because of per thread memory allocators\n // void clear_all() {\n // for (unsigned i = 0; i < perThrdCont.size(); ++i) {\n // get(i).clear();\n // }\n // }\n\n void clear_all_parallel(void) {\n galois::runtime::on_each_gen(\n [this](const unsigned, const unsigned) { get().clear(); },\n std::make_tuple());\n }\n\n bool empty_all() const {\n bool res = true;\n for (unsigned i = 0; i < perThrdCont.size(); ++i) {\n res = res && get(i).empty();\n }\n\n return res;\n }\n\n template \n void fill_parallel(const Range& range,\n Ret (container_type::*pushFn)(const value_type&) =\n &container_type::push_back) {\n galois::runtime::do_all_gen(\n range,\n [this, pushFn](const typename Range::value_type& v) {\n container_type& my = get();\n (my.*pushFn)(v);\n // (get ().*pushFn)(v);\n },\n std::make_tuple());\n }\n};\n\ntemplate \nclass PerThreadVector\n : public PerThreadContainer> {\npublic:\n typedef typename gstl::template Pow2Alloc Alloc_ty;\n typedef typename gstl::template Vector container_type;\n\nprotected:\n typedef PerThreadContainer Super_ty;\n\n Alloc_ty alloc;\n\npublic:\n PerThreadVector() : Super_ty(), alloc() { Super_ty::init(alloc); }\n\n void reserve_all(size_t sz) {\n size_t numT = galois::getActiveThreads();\n size_t perT = (sz + numT - 1) / numT; // round up\n\n for (unsigned i = 0; i < numT; ++i) {\n Super_ty::get(i).reserve(perT);\n }\n }\n};\n\ntemplate \nclass PerThreadDeque\n : public PerThreadContainer> {\n\npublic:\n typedef typename gstl::template Pow2Alloc Alloc_ty;\n\nprotected:\n typedef typename gstl::template Deque container_type;\n typedef PerThreadContainer Super_ty;\n\n Alloc_ty alloc;\n\npublic:\n PerThreadDeque() : Super_ty(), alloc() { Super_ty::init(alloc); }\n};\n\ntemplate \nclass PerThreadGdeque\n : public PerThreadContainer> {\n\n using Super_ty = PerThreadContainer>;\n\npublic:\n PerThreadGdeque() : Super_ty() { Super_ty::init(); }\n};\n\ntemplate \nclass PerThreadList\n : public PerThreadContainer> {\n\npublic:\n typedef typename gstl::template FixedSizeAlloc Alloc_ty;\n\nprotected:\n typedef typename gstl::template List container_type;\n typedef PerThreadContainer Super_ty;\n\n Alloc_ty alloc;\n\npublic:\n PerThreadList() : Super_ty(), alloc() { Super_ty::init(alloc); }\n};\n\ntemplate >\nclass PerThreadMap\n : public PerThreadContainer> {\n\npublic:\n typedef typename gstl::template Map container_type;\n typedef typename gstl::template FixedSizeAlloc<\n typename container_type::value_type>\n Alloc_ty;\n\nprotected:\n typedef PerThreadContainer Super_ty;\n\n Alloc_ty alloc;\n\npublic:\n explicit PerThreadMap(const C& cmp = C()) : Super_ty(), alloc() {\n Super_ty::init(cmp, alloc);\n }\n\n typedef typename Super_ty::global_const_iterator global_const_iterator;\n typedef typename Super_ty::global_const_reverse_iterator\n global_const_reverse_iterator;\n\n // hiding non-const (and const) versions in Super_ty\n global_const_iterator begin_all() const { return Super_ty::cbegin_all(); }\n global_const_iterator end_all() const { return Super_ty::cend_all(); }\n\n // hiding non-const (and const) versions in Super_ty\n global_const_reverse_iterator rbegin_all() const {\n return Super_ty::crbegin_all();\n }\n global_const_reverse_iterator rend_all() const {\n return Super_ty::crend_all();\n }\n};\n\ntemplate >\nclass PerThreadSet\n : public PerThreadContainer> {\n\npublic:\n typedef typename gstl::template FixedSizeAlloc Alloc_ty;\n\nprotected:\n typedef typename gstl::template Set container_type;\n typedef PerThreadContainer Super_ty;\n\n Alloc_ty alloc;\n\npublic:\n explicit PerThreadSet(const C& cmp = C()) : Super_ty(), alloc() {\n Super_ty::init(cmp, alloc);\n }\n\n typedef typename Super_ty::global_const_iterator global_const_iterator;\n typedef typename Super_ty::global_const_reverse_iterator\n global_const_reverse_iterator;\n\n // hiding non-const (and const) versions in Super_ty\n global_const_iterator begin_all() const { return Super_ty::cbegin_all(); }\n global_const_iterator end_all() const { return Super_ty::cend_all(); }\n\n // hiding non-const (and const) versions in Super_ty\n global_const_reverse_iterator rbegin_all() const {\n return Super_ty::crbegin_all();\n }\n global_const_reverse_iterator rend_all() const {\n return Super_ty::crend_all();\n }\n};\n\ntemplate >\nclass PerThreadMinHeap\n : public PerThreadContainer> {\n\npublic:\n typedef typename gstl::template Pow2Alloc Alloc_ty;\n\nprotected:\n typedef typename gstl::template Vector Vec_ty;\n typedef typename gstl::template PQ container_type;\n typedef PerThreadContainer Super_ty;\n\n Alloc_ty alloc;\n\npublic:\n explicit PerThreadMinHeap(const C& cmp = C()) : Super_ty(), alloc() {\n Super_ty::init(cmp, Vec_ty(alloc));\n }\n\n typedef typename Super_ty::global_const_iterator global_const_iterator;\n typedef typename Super_ty::global_const_reverse_iterator\n global_const_reverse_iterator;\n\n // hiding non-const (and const) versions in Super_ty\n global_const_iterator begin_all() const { return Super_ty::cbegin_all(); }\n global_const_iterator end_all() const { return Super_ty::cend_all(); }\n\n // hiding non-const (and const) versions in Super_ty\n global_const_reverse_iterator rbegin_all() const {\n return Super_ty::crbegin_all();\n }\n global_const_reverse_iterator rend_all() const {\n return Super_ty::crend_all();\n }\n};\n\n} // end namespace galois\n#endif // GALOIS_PERTHREADCONTAINER_H\n" }, { "path": "libgalois/include/galois/PriorityQueue.h", "content": "/*\n * This file belongs to the Galois project, a C++ library for exploiting\n * parallelism. The code is being released under the terms of the 3-Clause BSD\n * License (a copy is located in LICENSE.txt at the top-level directory).\n *\n * Copyright (C) 2018, The University of Texas at Austin. All rights reserved.\n * UNIVERSITY EXPRESSLY DISCLAIMS ANY AND ALL WARRANTIES CONCERNING THIS\n * SOFTWARE AND DOCUMENTATION, INCLUDING ANY WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR ANY PARTICULAR PURPOSE, NON-INFRINGEMENT AND WARRANTIES OF\n * PERFORMANCE, AND ANY WARRANTY THAT MIGHT OTHERWISE ARISE FROM COURSE OF\n * DEALING OR USAGE OF TRADE. NO WARRANTY IS EITHER EXPRESS OR IMPLIED WITH\n * RESPECT TO THE USE OF THE SOFTWARE OR DOCUMENTATION. Under no circumstances\n * shall University be liable for incidental, special, indirect, direct or\n * consequential damages or loss of profits, interruption of business, or\n * related expenses which may arise from use of Software or Documentation,\n * including but not limited to those resulting from defects in Software and/or\n * Documentation, or loss or inaccuracy of data of any kind.\n */\n\n#ifndef GALOIS_PRIORITYQUEUE_H\n#define GALOIS_PRIORITYQUEUE_H\n\n#include \n#include \n#include \n\n#include \"galois/config.h\"\n#include \"galois/Mem.h\"\n#include \"galois/substrate/PaddedLock.h\"\n#include \"galois/substrate/CompilerSpecific.h\"\n\nnamespace galois {\n\n/**\n * Thread-safe ordered set. Faster than STL heap operations (about 10%-15%\n * faster on serially) and can use scalable allocation, e.g., {@link\n * FixedSizeAllocator}.\n */\ntemplate ,\n typename Alloc = galois::FixedSizeAllocator>\nclass ThreadSafeOrderedSet {\n typedef std::set Set;\n\npublic:\n typedef Set container_type;\n typedef typename container_type::value_type value_type;\n typedef typename container_type::reference reference;\n typedef typename container_type::const_reference const_reference;\n typedef typename container_type::pointer pointer;\n typedef typename container_type::size_type size_type;\n typedef typename container_type::const_iterator iterator;\n typedef typename container_type::const_iterator const_iterator;\n typedef typename container_type::const_reverse_iterator reverse_iterator;\n typedef\n typename container_type::const_reverse_iterator const_reverse_iterator;\n typedef galois::substrate::SimpleLock Lock_ty;\n\nprivate:\n alignas(substrate::GALOIS_CACHE_LINE_SIZE) Lock_ty mutex;\n Set orderedSet;\n\npublic:\n template ,\n typename _Alloc = galois::FixedSizeAllocator<_T>>\n using retype =\n ThreadSafeOrderedSet<_T, _Cmp,\n _Alloc>; // FIXME: loses Alloc and Cmp types\n\n explicit ThreadSafeOrderedSet(const Cmp& cmp = Cmp(),\n const Alloc& alloc = Alloc())\n : orderedSet(cmp, alloc) {}\n\n template \n ThreadSafeOrderedSet(Iter b, Iter e, const Cmp& cmp = Cmp(),\n const Alloc& alloc = Alloc())\n : orderedSet(cmp, alloc) {\n for (; b != e; ++b) {\n orderedSet.insert(*b);\n }\n }\n\n bool empty() const {\n mutex.lock();\n bool ret = orderedSet.empty();\n mutex.unlock();\n\n return ret;\n }\n\n size_type size() const {\n mutex.lock();\n size_type sz = orderedSet.size();\n mutex.unlock();\n\n return sz;\n }\n\n value_type top() const {\n mutex.lock();\n value_type x = *orderedSet.begin();\n mutex.unlock();\n return x;\n }\n\n bool find(const value_type& x) const {\n mutex.lock();\n bool ret = (orderedSet.find(x) != orderedSet.end());\n mutex.unlock();\n return ret;\n }\n\n // for compatibility with various stl types\n inline void push_back(const value_type& x) { this->push(x); }\n inline void insert(const value_type& x) { this->push(x); }\n\n bool push(const value_type& x) {\n mutex.lock();\n auto p = orderedSet.insert(x);\n mutex.unlock();\n return p.second;\n }\n\n value_type pop() {\n mutex.lock();\n value_type x = *orderedSet.begin();\n orderedSet.erase(orderedSet.begin());\n mutex.unlock();\n return x;\n }\n\n bool remove(const value_type& x) {\n mutex.lock();\n bool ret = false;\n\n if (x == *orderedSet.begin()) {\n orderedSet.erase(orderedSet.begin());\n ret = true;\n } else {\n size_type s = orderedSet.erase(x);\n ret = (s > 0);\n }\n mutex.unlock();\n\n return ret;\n }\n\n void clear() {\n mutex.lock();\n orderedSet.clear();\n mutex.unlock();\n }\n\n const_iterator begin() const { return orderedSet.begin(); }\n const_iterator end() const { return orderedSet.end(); }\n};\n\ntemplate ,\n typename Cont = std::vector>>\nclass MinHeap {\npublic:\n typedef runtime::Pow_2_BlockAllocator alloc_type;\n typedef Cont container_type;\n\n typedef typename container_type::value_type value_type;\n typedef typename container_type::reference reference;\n typedef typename container_type::const_reference const_reference;\n typedef typename container_type::pointer pointer;\n typedef typename container_type::size_type size_type;\n typedef typename container_type::const_iterator iterator;\n typedef typename container_type::const_iterator const_iterator;\n typedef typename container_type::const_reverse_iterator reverse_iterator;\n typedef\n typename container_type::const_reverse_iterator const_reverse_iterator;\n // typedef typename container_type::const_iterator iterator;\n\nprotected:\n struct RevCmp {\n Cmp cmp;\n\n explicit RevCmp(const Cmp& cmp) : cmp(cmp) {}\n\n bool operator()(const T& left, const T& right) const {\n return cmp(right, left);\n }\n };\n\n Cont container;\n RevCmp revCmp;\n\n const_reference top_internal() const {\n assert(!container.empty());\n return container.front();\n }\n\n value_type pop_internal() {\n assert(!container.empty());\n std::pop_heap(container.begin(), container.end(), revCmp);\n\n value_type x = container.back();\n container.pop_back();\n\n return x;\n }\n\npublic:\n explicit MinHeap(const Cmp& cmp = Cmp(), const Cont& container = Cont())\n : container(container), revCmp(cmp) {}\n\n template \n MinHeap(Iter b, Iter e, const Cmp& cmp = Cmp())\n : container(b, e), revCmp(cmp) {\n std::make_heap(container.begin(), container.end());\n }\n\n bool empty() const { return container.empty(); }\n\n size_type size() const { return container.size(); }\n\n const_reference top() const { return container.front(); }\n\n // for compatibility with various stl types\n inline void push_back(const value_type& x) { this->push(x); }\n inline void insert(const value_type& x) { this->push(x); }\n\n void push(const value_type& x) {\n container.push_back(x);\n std::push_heap(container.begin(), container.end(), revCmp);\n }\n\n value_type pop() {\n assert(!container.empty());\n std::pop_heap(container.begin(), container.end(), revCmp);\n\n value_type x = container.back();\n container.pop_back();\n return x;\n }\n\n bool remove(const value_type& x) {\n bool ret = false;\n\n // TODO: write a better remove method\n if (x == top()) {\n pop();\n ret = true;\n } else {\n typename container_type::iterator nend =\n std::remove(container.begin(), container.end(), x);\n\n ret = (nend != container.end());\n container.erase(nend, container.end());\n\n std::make_heap(container.begin(), container.end(), revCmp);\n }\n\n return ret;\n }\n\n bool find(const value_type& x) const {\n return (std::find(begin(), end(), x) != end());\n }\n\n void clear() { container.clear(); }\n\n const_iterator begin() const { return container.begin(); }\n const_iterator end() const { return container.end(); }\n\n void reserve(size_type s) { container.reserve(s); }\n};\n\n/**\n * Thread-safe min heap.\n */\ntemplate >\nclass ThreadSafeMinHeap {\npublic:\n typedef MinHeap container_type;\n\n typedef typename container_type::value_type value_type;\n typedef typename container_type::reference reference;\n typedef typename container_type::const_reference const_reference;\n typedef typename container_type::pointer pointer;\n typedef typename container_type::size_type size_type;\n typedef typename container_type::const_iterator iterator;\n typedef typename container_type::const_iterator const_iterator;\n typedef typename container_type::const_reverse_iterator reverse_iterator;\n typedef\n typename container_type::const_reverse_iterator const_reverse_iterator;\n\nprotected:\n typedef galois::substrate::SimpleLock Lock_ty;\n\n alignas(substrate::GALOIS_CACHE_LINE_SIZE) Lock_ty mutex;\n container_type heap;\n\npublic:\n explicit ThreadSafeMinHeap(const Cmp& cmp = Cmp()) : heap(cmp) {}\n\n template \n ThreadSafeMinHeap(Iter b, Iter e, const Cmp& cmp = Cmp()) : heap(b, e, cmp) {}\n\n bool empty() const {\n mutex.lock();\n bool ret = heap.empty();\n mutex.unlock();\n\n return ret;\n }\n\n size_type size() const {\n mutex.lock();\n size_type sz = heap.size();\n mutex.unlock();\n\n return sz;\n }\n\n // can't return a reference, because the reference may not be pointing\n // to a valid location due to vector doubling in size and moving to\n // another memory location\n value_type top() const {\n mutex.lock();\n value_type x = heap.top();\n mutex.unlock();\n\n return x;\n }\n\n // for compatibility with various stl types\n inline void push_back(const value_type& x) { this->push(x); }\n inline void insert(const value_type& x) { this->push(x); }\n\n void push(const value_type& x) {\n mutex.lock();\n heap.push(x);\n mutex.unlock();\n }\n\n value_type pop() {\n mutex.lock();\n value_type x = heap.pop();\n mutex.unlock();\n return x;\n }\n\n bool remove(const value_type& x) {\n // TODO: write a better remove method\n mutex.lock();\n bool ret = heap.remove(x);\n mutex.unlock();\n\n return ret;\n }\n\n bool find(const value_type& x) const {\n mutex.lock();\n bool ret = heap.find(x);\n mutex.unlock();\n\n return ret;\n }\n\n void clear() {\n mutex.lock();\n heap.clear();\n mutex.unlock();\n }\n\n // TODO: can't use in parallel context\n const_iterator begin() const { return heap.begin(); }\n const_iterator end() const { return heap.end(); }\n\n void reserve(size_type s) { heap.reserve(s); }\n};\n\n} // namespace galois\n\n#endif\n" }, { "path": "libgalois/include/galois/Reduction.h", "content": "/*\n * This file belongs to the Galois project, a C++ library for exploiting\n * parallelism. The code is being released under the terms of the 3-Clause BSD\n * License (a copy is located in LICENSE.txt at the top-level directory).\n *\n * Copyright (C) 2018, The University of Texas at Austin. All rights reserved.\n * UNIVERSITY EXPRESSLY DISCLAIMS ANY AND ALL WARRANTIES CONCERNING THIS\n * SOFTWARE AND DOCUMENTATION, INCLUDING ANY WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR ANY PARTICULAR PURPOSE, NON-INFRINGEMENT AND WARRANTIES OF\n * PERFORMANCE, AND ANY WARRANTY THAT MIGHT OTHERWISE ARISE FROM COURSE OF\n * DEALING OR USAGE OF TRADE. NO WARRANTY IS EITHER EXPRESS OR IMPLIED WITH\n * RESPECT TO THE USE OF THE SOFTWARE OR DOCUMENTATION. Under no circumstances\n * shall University be liable for incidental, special, indirect, direct or\n * consequential damages or loss of profits, interruption of business, or\n * related expenses which may arise from use of Software or Documentation,\n * including but not limited to those resulting from defects in Software and/or\n * Documentation, or loss or inaccuracy of data of any kind.\n */\n\n#ifndef GALOIS_REDUCTION_H\n#define GALOIS_REDUCTION_H\n\n#include \n#include \n\n#include \"galois/config.h\"\n#include \"galois/substrate/PerThreadStorage.h\"\n\nnamespace galois {\n\n/**\n * A Reducible stores per-thread values of a variable of type T and merges\n * multiple values into one.\n *\n * The reduced value is obtained by merging per thread values using the binary\n * functor MergeFunc. MergeFunc takes two values of type T and produces the\n * resulting merged value:\n *\n * T operator()(T lhs, T rhs)\n *\n * If T is expensive to copy, a moving merge function is more appropriate:\n *\n * T& operator()(T& lhs, T&& rhs)\n *\n * IdFunc returns the identity element, which is used to initialize and reset\n * the per thread values.\n *\n * Both MergeFunc and IdFunc should be copy constructable.\n *\n * The MergeFunc and IdFunc should be related as follows:\n *\n * MergeFunc(x, IdFunc()) == x for all x in X\n *\n * An example of using a move merge function:\n *\n * auto merge_func = [](T& lhs, T&& rhs) -> T& { ... }\n * auto identity_func = []() -> T { ... }\n *\n * auto r = make_reducible(merge_func, identity_func);\n * T u = ...\n * r.update(std::move(u));\n * T& result = r.reduce();\n */\ntemplate \nclass Reducible : public MergeFunc, public IdFunc {\n\n galois::substrate::PerThreadStorage data_;\n\n void merge(T& lhs, T&& rhs) {\n T v{std::move(MergeFunc::operator()(lhs, std::move(rhs)))};\n lhs = std::move(v);\n }\n\n void merge(T& lhs, const T& rhs) { lhs = MergeFunc::operator()(lhs, rhs); }\n\npublic:\n using value_type = T;\n\n Reducible(MergeFunc merge_func, IdFunc id_func)\n : MergeFunc(merge_func), IdFunc(id_func) {\n for (unsigned i = 0; i < data_.size(); ++i) {\n *(data_.getRemote(i)) = IdFunc::operator()();\n }\n }\n\n /**\n * Updates the thread local value by applying the reduction operator to\n * current and newly provided value\n */\n void update(T&& rhs) { merge(*data_.getLocal(), std::move(rhs)); }\n\n void update(const T& rhs) { merge(*data_.getLocal(), rhs); }\n\n /**\n * Returns a reference to the local value of T.\n */\n T& getLocal() { return *data_.getLocal(); }\n\n /**\n * Returns the final reduction value. Only valid outside the parallel region.\n */\n T& reduce() {\n T& lhs = *data_.getLocal();\n for (unsigned int i = 1; i < data_.size(); ++i) {\n T& rhs = *data_.getRemote(i);\n merge(lhs, std::move(rhs));\n rhs = IdFunc::operator()();\n }\n\n return lhs;\n }\n\n void reset() {\n for (unsigned int i = 0; i < data_.size(); ++i) {\n *data_.getRemote(i) = IdFunc::operator()();\n }\n }\n};\n\n/**\n * make_reducible creates a Reducible from a merge function and identity\n * function.\n */\ntemplate \nauto make_reducible(const MergeFn& mergeFn, const IdFn& idFn) {\n return Reducible, MergeFn, IdFn>(mergeFn, idFn);\n}\n\n//! gmax is the functional form of std::max\ntemplate \nstruct gmax {\n constexpr T operator()(const T& lhs, const T& rhs) const {\n return std::max(lhs, rhs);\n }\n};\n\n//! gmax is the functional form of std::max\ntemplate \nstruct gmin {\n constexpr T operator()(const T& lhs, const T& rhs) const {\n return std::min(lhs, rhs);\n }\n};\n\ntemplate \nstruct identity_value {\n constexpr T operator()() const { return T{value}; }\n};\n\n// The following identity_value specializations exist because floating point\n// numbers cannot be template arguments.\n\ntemplate \nstruct identity_value_zero {\n constexpr T operator()() const { return T{0}; }\n};\n\ntemplate \nstruct identity_value_min {\n constexpr T operator()() const { return std::numeric_limits::min(); }\n};\n\ntemplate \nstruct identity_value_max {\n constexpr T operator()() const { return std::numeric_limits::max(); }\n};\n\n//! Accumulator for T where accumulation is plus\ntemplate \nclass GAccumulator : public Reducible, identity_value_zero> {\n using base_type = Reducible, identity_value_zero>;\n\npublic:\n GAccumulator() : base_type(std::plus(), identity_value_zero()) {}\n\n GAccumulator& operator+=(const T& rhs) {\n base_type::update(rhs);\n return *this;\n }\n\n GAccumulator& operator-=(const T& rhs) {\n base_type::update(rhs);\n return *this;\n }\n};\n\n//! Accumulator for T where accumulation is max\ntemplate \nclass GReduceMax : public Reducible, identity_value_min> {\n using base_type = Reducible, identity_value_min>;\n\npublic:\n GReduceMax() : base_type(gmax(), identity_value_min()) {}\n};\n\n//! Accumulator for T where accumulation is min\ntemplate \nclass GReduceMin : public Reducible, identity_value_max> {\n using base_type = Reducible, identity_value_max>;\n\npublic:\n GReduceMin() : base_type(gmin(), identity_value_max()) {}\n};\n\n//! logical AND reduction\nclass GReduceLogicalAnd : public Reducible,\n identity_value> {\n using base_type =\n Reducible, identity_value>;\n\npublic:\n GReduceLogicalAnd()\n : base_type(std::logical_and(), identity_value()) {}\n};\n\n//! logical OR reduction\nclass GReduceLogicalOr : public Reducible,\n identity_value> {\n using base_type =\n Reducible, identity_value>;\n\npublic:\n GReduceLogicalOr()\n : base_type(std::logical_or(), identity_value()) {}\n};\n\n} // namespace galois\n#endif // GALOIS_REDUCTION_H\n" }, { "path": "libgalois/include/galois/SharedMemSys.h", "content": "#ifndef GALOIS_SHAREDMEMSYS_H\n#define GALOIS_SHAREDMEMSYS_H\n\n#include \"galois/config.h\"\n#include \"galois/runtime/SharedMem.h\"\n\nnamespace galois {\n\n/**\n * SharedMemSys is an explicit class to initialize the Galois runtime. The\n * runtime is destroyed when this object is destroyed.\n */\nclass SharedMemSys : public runtime::SharedMem {\n\npublic:\n explicit SharedMemSys();\n ~SharedMemSys();\n\n SharedMemSys(const SharedMemSys&) = delete;\n SharedMemSys& operator=(const SharedMemSys&) = delete;\n\n SharedMemSys(SharedMemSys&&) = delete;\n SharedMemSys& operator=(SharedMemSys&&) = delete;\n};\n\n} // namespace galois\n\n#endif\n" }, { "path": "libgalois/include/galois/Threads.h", "content": "/*\n * This file belongs to the Galois project, a C++ library for exploiting\n * parallelism. The code is being released under the terms of the 3-Clause BSD\n * License (a copy is located in LICENSE.txt at the top-level directory).\n *\n * Copyright (C) 2018, The University of Texas at Austin. All rights reserved.\n * UNIVERSITY EXPRESSLY DISCLAIMS ANY AND ALL WARRANTIES CONCERNING THIS\n * SOFTWARE AND DOCUMENTATION, INCLUDING ANY WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR ANY PARTICULAR PURPOSE, NON-INFRINGEMENT AND WARRANTIES OF\n * PERFORMANCE, AND ANY WARRANTY THAT MIGHT OTHERWISE ARISE FROM COURSE OF\n * DEALING OR USAGE OF TRADE. NO WARRANTY IS EITHER EXPRESS OR IMPLIED WITH\n * RESPECT TO THE USE OF THE SOFTWARE OR DOCUMENTATION. Under no circumstances\n * shall University be liable for incidental, special, indirect, direct or\n * consequential damages or loss of profits, interruption of business, or\n * related expenses which may arise from use of Software or Documentation,\n * including but not limited to those resulting from defects in Software and/or\n * Documentation, or loss or inaccuracy of data of any kind.\n */\n\n#ifndef GALOIS_THREADS_H\n#define GALOIS_THREADS_H\n\n#include \"galois/config.h\"\n\nnamespace galois {\n\n/**\n * Sets the number of threads to use when running any Galois iterator. Returns\n * the actual value of threads used, which could be less than the requested\n * value. System behavior is undefined if this function is called during\n * parallel execution or after the first parallel execution.\n */\nunsigned int setActiveThreads(unsigned int num) noexcept;\n\n/**\n * Returns the number of threads in use.\n */\nunsigned int getActiveThreads() noexcept;\n\n} // namespace galois\n#endif\n" }, { "path": "libgalois/include/galois/Timer.h", "content": "/*\n * This file belongs to the Galois project, a C++ library for exploiting\n * parallelism. The code is being released under the terms of the 3-Clause BSD\n * License (a copy is located in LICENSE.txt at the top-level directory).\n *\n * Copyright (C) 2018, The University of Texas at Austin. All rights reserved.\n * UNIVERSITY EXPRESSLY DISCLAIMS ANY AND ALL WARRANTIES CONCERNING THIS\n * SOFTWARE AND DOCUMENTATION, INCLUDING ANY WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR ANY PARTICULAR PURPOSE, NON-INFRINGEMENT AND WARRANTIES OF\n * PERFORMANCE, AND ANY WARRANTY THAT MIGHT OTHERWISE ARISE FROM COURSE OF\n * DEALING OR USAGE OF TRADE. NO WARRANTY IS EITHER EXPRESS OR IMPLIED WITH\n * RESPECT TO THE USE OF THE SOFTWARE OR DOCUMENTATION. Under no circumstances\n * shall University be liable for incidental, special, indirect, direct or\n * consequential damages or loss of profits, interruption of business, or\n * related expenses which may arise from use of Software or Documentation,\n * including but not limited to those resulting from defects in Software and/or\n * Documentation, or loss or inaccuracy of data of any kind.\n */\n\n#ifndef GALOIS_TIMER_H\n#define GALOIS_TIMER_H\n\n#include \n\n#include \"galois/config.h\"\n#include \"galois/gstl.h\"\n\nnamespace galois {\n\n//! A simple timer\nclass Timer {\n typedef std::chrono::steady_clock clockTy;\n // typedef std::chrono::high_resolution_clock clockTy;\n std::chrono::time_point startT, stopT;\n\npublic:\n void start();\n void stop();\n uint64_t get() const;\n uint64_t get_usec() const;\n};\n\n//! A multi-start time accumulator.\n//! Gives the final runtime for a series of intervals\nclass TimeAccumulator {\n Timer ltimer;\n uint64_t acc;\n\npublic:\n TimeAccumulator();\n\n void start();\n //! adds the current timed interval to the total\n void stop();\n uint64_t get() const;\n uint64_t get_usec() const;\n TimeAccumulator& operator+=(const TimeAccumulator& rhs);\n TimeAccumulator& operator+=(const Timer& rhs);\n};\n\n//! Galois Timer that automatically reports stats upon destruction\n//! Provides statistic interface around timer\nclass StatTimer : public TimeAccumulator {\n gstl::Str name_;\n gstl::Str region_;\n bool valid_;\n\npublic:\n StatTimer(const char* name, const char* region);\n\n StatTimer(const char* const n) : StatTimer(n, nullptr) {}\n\n StatTimer() : StatTimer(nullptr, nullptr) {}\n\n StatTimer(const StatTimer&) = delete;\n StatTimer(StatTimer&&) = delete;\n StatTimer& operator=(const StatTimer&) = delete;\n StatTimer& operator=(StatTimer&&) = delete;\n\n ~StatTimer();\n\n void start();\n void stop();\n uint64_t get_usec() const;\n};\n\ntemplate \nclass CondStatTimer : public StatTimer {\npublic:\n CondStatTimer(const char* const n, const char* region)\n : StatTimer(n, region) {}\n\n CondStatTimer(const char* region) : CondStatTimer(\"Time\", region) {}\n};\n\ntemplate <>\nclass CondStatTimer {\npublic:\n CondStatTimer(const char*) {}\n CondStatTimer(const char* const, const char*) {}\n\n void start() const {}\n void stop() const {}\n uint64_t get_usec() const { return 0; }\n};\n\ntemplate \nvoid timeThis(const F& f, const char* const name) {\n StatTimer t(\"Time\", name);\n\n t.start();\n\n f();\n\n t.stop();\n}\n\n} // end namespace galois\n#endif\n" }, { "path": "libgalois/include/galois/Traits.h", "content": "/*\n * This file belongs to the Galois project, a C++ library for exploiting\n * parallelism. The code is being released under the terms of the 3-Clause BSD\n * License (a copy is located in LICENSE.txt at the top-level directory).\n *\n * Copyright (C) 2018, The University of Texas at Austin. All rights reserved.\n * UNIVERSITY EXPRESSLY DISCLAIMS ANY AND ALL WARRANTIES CONCERNING THIS\n * SOFTWARE AND DOCUMENTATION, INCLUDING ANY WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR ANY PARTICULAR PURPOSE, NON-INFRINGEMENT AND WARRANTIES OF\n * PERFORMANCE, AND ANY WARRANTY THAT MIGHT OTHERWISE ARISE FROM COURSE OF\n * DEALING OR USAGE OF TRADE. NO WARRANTY IS EITHER EXPRESS OR IMPLIED WITH\n * RESPECT TO THE USE OF THE SOFTWARE OR DOCUMENTATION. Under no circumstances\n * shall University be liable for incidental, special, indirect, direct or\n * consequential damages or loss of profits, interruption of business, or\n * related expenses which may arise from use of Software or Documentation,\n * including but not limited to those resulting from defects in Software and/or\n * Documentation, or loss or inaccuracy of data of any kind.\n */\n\n#ifndef GALOIS_TRAITS_H\n#define GALOIS_TRAITS_H\n\n#include \n#include \n\n#include \"galois/config.h\"\n#include \"galois/worklists/WorkList.h\"\n\nnamespace galois {\n\n// Trait classifications\n\ntemplate \nstruct trait_has_type {\n typedef T type;\n};\n\ntemplate \nstruct trait_has_value {\n typedef T type;\n type value;\n trait_has_value(const type& v) : value(v) {}\n trait_has_value(type&& v) : value(std::move(v)) {}\n T getValue() const { return value; }\n};\n\ntemplate \nstruct trait_has_svalue {\n typedef T type;\n static const type value = V;\n T getValue() const { return V; }\n};\n\n/**\n * Utility function to simplify creating traits that take unnamed functions\n * (i.e., lambdas).\n */\ntemplate