Script that installs `graph-dispatching` on machines on which we don't have `Docker`

[romintomasetti]

It basically performs the same steps as the Dockerfile.

The main script.

set -ex

ROOT_DIR=$PWD
KOKKOS_SHA=d61242a6ed983727202cfa5d67e8346c96491b44
KOKKOS_KERNELS_SHA=5.1.1
KOKKOS_TOOLS_SHA=6493964271d2e887432489f20559b72757db02b0
KOKKOS_UTILS_SHA=6f861f019050b47570ba0b54097b89fba357f0c7
NVIDIA_STDEXEC_REF=0758df65c6571076d67276362c07146e13958740
GOOGLETEST_VERSION=1.17.0
GOOGLEBENCHMARK_VERSION=1.9.5
PYTHON_VERSION=3.12.11
VIRTUAL_ENV=$ROOT_DIR/${PRESET}/venv-${PYTHON_VERSION}

function install_kokkos()
{
 if [ ! -d $ROOT_DIR/github/kokkos/kokkos ];then
 mkdir -p $ROOT_DIR/github/kokkos
 git clone https://github.com/kokkos/kokkos $ROOT_DIR/github/kokkos/kokkos
 fi

 cd $ROOT_DIR/github/kokkos/kokkos && git remote update

 git checkout $KOKKOS_SHA

 rm -rf build-with-${PRESET}

 cmake -S . -B build-with-${PRESET} \
 -DCMAKE_BUILD_TYPE=Release \
 -DCMAKE_CXX_STANDARD=20 \
 -DCMAKE_CXX_EXTENSIONS=OFF \
 -DCMAKE_CXX_COMPILER=g++ \
 -DBUILD_SHARED_LIBS=ON \
 -DCMAKE_C_COMPILER=should-not-be-needed \
 -DKokkos_ENABLE_SERIAL=ON \
 -DKokkos_ENABLE_OPENMP=ON \
 -DKokkos_ENABLE_TESTS=OFF \
 "${KOKKOS_OPTS[@]}" \
 -DCMAKE_INSTALL_PREFIX=$ROOT_DIR/libraries/kokkos/kokkos-${KOKKOS_SHA}/$PRESET

 cmake --build build-with-${PRESET} --verbose -j16 --target install
}

function install_kokkos_kernels()
{
 if [ ! -d $ROOT_DIR/github/kokkos/kokkos-kernels ];then
 mkdir -p $ROOT_DIR/github/kokkos
 git clone https://github.com/kokkos/kokkos-kernels $ROOT_DIR/github/kokkos/kokkos-kernels
 fi

 cd $ROOT_DIR/github/kokkos/kokkos-kernels && git remote update

 git checkout $KOKKOS_KERNELS_SHA

 rm -rf build-with-${PRESET}

 cmake -S . -B build-with-${PRESET} \
 "${KOKKOS_KERNELS_OPTS[@]}" \
 -DCMAKE_BUILD_TYPE=Release \
 -DCMAKE_CXX_STANDARD=20 \
 -DBUILD_SHARED_LIBS=ON \
 -DCMAKE_C_COMPILER=should-not-be-needed \
 -DCMAKE_INSTALL_PREFIX=$ROOT_DIR/libraries/kokkos/kokkos-kernels-${KOKKOS_KERNELS_SHA}/$PRESET

 cmake --build build-with-${PRESET} -j16 --target install
}

function install_kokkos_tools()
{
 if [ ! -d $ROOT_DIR/github/kokkos/kokkos-tools ];then
 mkdir -p $ROOT_DIR/github/kokkos
 git clone https://github.com/kokkos/kokkos-tools $ROOT_DIR/github/kokkos/kokkos-tools
 fi

 cd $ROOT_DIR/github/kokkos/kokkos-tools && git remote update

 git checkout $KOKKOS_TOOLS_SHA

 rm -rf build

 cmake -S . -B build \
 -DCMAKE_BUILD_TYPE=Release \
 -DCMAKE_CXX_STANDARD=20 \
 -DCMAKE_C_COMPILER=not-needed \
 -DCMAKE_INSTALL_PREFIX=$ROOT_DIR/libraries/kokkos/kokkos-tools-${KOKKOS_TOOLS_SHA}/$PRESET

 cmake --build build -j16 --target install
}

function install_kokkos_utils()
{
 if [ ! -d $ROOT_DIR/github/uliegecsm/kokkos-utils ];then
 mkdir -p $ROOT_DIR/github/uliegecsm
 git clone https://github.com/uliegecsm/kokkos-utils $ROOT_DIR/github/uliegecsm/kokkos-utils
 fi

 cd $ROOT_DIR/github/uliegecsm/kokkos-utils && git remote update

 git checkout $KOKKOS_UTILS_SHA

 rm -rf build

 cmake -S . -B build \
 -DCMAKE_CXX_EXTENSIONS=OFF \
 -DKokkosUtils_ENABLE_TESTS=OFF \
 -DKokkosUtils_ENABLE_DOC=OFF \
 -DCMAKE_BUILD_TYPE=Release \
 -DCMAKE_CXX_STANDARD=20 \
 -DCMAKE_C_COMPILER=not-needed \
 -DCMAKE_INSTALL_PREFIX=$ROOT_DIR/libraries/uliegecsm/kokkos-utils-${KOKKOS_UTILS_SHA}/$PRESET

 cmake --build build -j16 --target install
}

function install_nvidia_stdexec()
{
 if [ ! -d $ROOT_DIR/github/nvidia/stdexec ];then
 mkdir -p $ROOT_DIR/github/nvidia
 git clone https://github.com/nvidia/stdexec $ROOT_DIR/github/nvidia/stdexec
 fi

 cd $ROOT_DIR/github/nvidia/stdexec && git remote update

 git checkout $NVIDIA_STDEXEC_REF
}

function install_google_test()
{
 if [ ! -d $ROOT_DIR/github/google/googletest ];then
 mkdir -p $ROOT_DIR/github/google
 git clone --depth=1 --branch=v${GOOGLETEST_VERSION} https://github.com/google/googletest $ROOT_DIR/github/google/googletest
 fi

 cd $ROOT_DIR/github/google/googletest && git remote update

 git checkout ${GOOGLETEST_VERSION}

 rm -rf build

 cmake -S . -B build \
 "${GOOGLETEST_OPTS[@]}" \
 -DCMAKE_BUILD_TYPE=Release \
 -DCMAKE_INSTALL_PREFIX=$ROOT_DIR/libraries/google/googletest-${GOOGLETEST_VERSION}/${PRESET}

 cmake --build build -j16 --target install
}

function install_google_benchmark()
{
 if [ ! -d $ROOT_DIR/github/google/benchmark ];then
 mkdir -p $ROOT_DIR/github/google
 git clone --depth=1 --branch=v${GOOGLEBENCHMARK_VERSION} https://github.com/google/benchmark $ROOT_DIR/github/google/benchmark
 fi

 cd $ROOT_DIR/github/google/benchmark && git remote update

 git checkout ${GOOGLEBENCHMARK_VERSION}

 rm -rf build

 cmake -S . -B build \
 "${GOOGLETEST_OPTS[@]}" \
 -DCMAKE_CXX_FLAGS="-Wno-error=suggest-override" \
 -DCMAKE_BUILD_TYPE=Release \
 -DBENCHMARK_ENABLE_TESTING=OFF \
 -DBENCHMARK_INSTALL_DOCS=OFF \
 -DCMAKE_INSTALL_PREFIX=$ROOT_DIR/libraries/google/benchmark-${GOOGLEBENCHMARK_VERSION}/${PRESET}

 cmake --build build -j16 --target install
}

function install_graph_dispatching()
{
 if [ ! -d $ROOT_DIR/github/uliegecsm/graph-dispatching ];then
 mkdir -p $ROOT_DIR/github/uliegecsm
 git clone --recurse-submodules https://github.com/uliegecsm/graph-dispatching $ROOT_DIR/github/uliegecsm/graph-dispatching
 fi

 cd $ROOT_DIR/github/uliegecsm/graph-dispatching

 rm -rf build-with-${PRESET}

 git remote update

 git checkout origin/main

 cmake -S . --preset=${PRESET} \
 -DCMAKE_BUILD_TYPE=Release \
 -DENABLE_DOXYGEN=OFF \
 -DENABLE_HPX_TESTING=OFF \
 -DENABLE_CLANG_TIDY=OFF \
 -DGRAPH_DISPATCHING_ENABLE_STDEXEC_TESTS=OFF \
 -DCMAKE_CXX_COMPILER_LAUNCHER=

 cmake --build --preset=${PRESET} -j16
}

function generate_results()
{
 echo "----------------------------------------------------------------"

 cd $ROOT_DIR/github/uliegecsm/graph-dispatching

 python -m pip install -r requirements/requirements.python.benchmarks.txt
 python -m pip install typeguard scipy matplot2tikz pandas

 export PYTHONPATH=$PWD:$PYTHONPATH

 cmake --build --verbose --preset=${PRESET} -j16 \
 --target=benchmarks_cg_compare \
 --target=benchmarks_pcg_compare \
 --target=benchmarks_newton_compare \
 --target=benchmarks_graph_straight_line \
 --target=benchmarks_graph_fork

 # ctest --preset=${PRESET} --verbose -R tests_cg_graph
 # ctest --preset=${PRESET} --verbose -R tests_pcg_graph
 # ctest --preset=${PRESET} --verbose -R tests_newton_JacobiPCG

 # python3 benchmarks/cg/benchmark_compare.py --target build-with-${PRESET}/benchmarks/cg/benchmarks_cg_compare -- --v=0
 # python3 benchmarks/pcg/benchmark_compare.py --target build-with-${PRESET}/benchmarks/pcg/benchmarks_pcg_compare -- --v=3
 # python3 benchmarks/newton/benchmark_compare.py --target build-with-gcc-Cuda/benchmarks/newton/benchmarks_newton_compare -- --v=3
 python3 benchmarks/graph/benchmark_straight_line.py --target build-with-${PRESET}/benchmarks/graph/benchmarks_graph_straight_line -- --v=0
 # python3 benchmarks/graph/benchmark_fork.py --target build-with-${PRESET}/benchmarks/graph/benchmarks_graph_fork -- --v=0
}

# Load modules.
module load python/$PYTHON_VERSION

# Create Python virtual environment.
python3 -m venv $VIRTUAL_ENV
PATH=$VIRTUAL_ENV/bin:$PATH
export PATH=$VIRTUAL_ENV/bin:$PATH

install_kokkos

export Kokkos_ROOT=$ROOT_DIR/libraries/kokkos/kokkos-${KOKKOS_SHA}/${PRESET}

test -d $Kokkos_ROOT

install_kokkos_kernels

export KokkosKernels_ROOT=$ROOT_DIR/libraries/kokkos/kokkos-kernels-${KOKKOS_KERNELS_SHA}/${PRESET}

test -d $KokkosKernels_ROOT

install_kokkos_tools

install_kokkos_utils

export KokkosUtils_ROOT=$ROOT_DIR/libraries/uliegecsm/kokkos-utils-${KOKKOS_UTILS_SHA}/$PRESET

test -d $KokkosUtils_ROOT

install_nvidia_stdexec

export Stdexec_ROOT=$ROOT_DIR/github/nvidia/stdexec

test -d $Stdexec_ROOT

install_google_test

export GTest_ROOT=$ROOT_DIR/libraries/google/googletest-${GOOGLETEST_VERSION}/${PRESET}

test -d $GTest_ROOT

install_google_benchmark

export benchmark_ROOT=$ROOT_DIR/libraries/google/benchmark-${GOOGLEBENCHMARK_VERSION}/${PRESET}

test -d $benchmark_ROOT

install_graph_dispatching

generate_results

intel-SYCL on headroom

set -ex

SOURCE_DIR="$(dirname "$0")"

echo "Directory of the script is $SOURCE_DIR."

# The preset we'll use.
PRESET=intel-SYCL

# If you need to install CMake.
# wget https://github.com/Kitware/CMake/releases/download/v4.2.3/cmake-4.2.3-linux-x86_64.sh
# bash cmake-4.2.3-linux-x86_64.sh
export PATH=$PWD/cmake-4.2.3-linux-x86_64/bin:${PATH}

cmake --version

# GCC version, load from Spack.
GCC_VERSION=15
. spack/share/spack/setup-env.sh
spack load gcc@${GCC_VERSION}

# 'icpx' is an llvm-based compiler, so we need to tell it the
# GCC toolchain we want to use (for the standard library headers).
# Note that we also need to load the machine gcc 13 to avoid runtime issues like
# GLIBCXX_... not found
GCC_TOOLCHAIN="--gcc-toolchain=$(spack location -i gcc@15)"
echo "GCC toolchain is $GCC_TOOLCHAIN."

module load gcc/13.2.0

# Options for Kokkos.
KOKKOS_OPTS=(
 "-DCMAKE_CXX_COMPILER=icpx"
 "-DCMAKE_CXX_FLAGS='${GCC_TOOLCHAIN} -Wno-zero-length-array -Werror -fsycl-device-code-split=per_kernel -fp-model=precise'"
 "-DCMAKE_EXE_LINKER_FLAGS='-fsycl -flink-huge-device-code'"
 "-DKokkos_ENABLE_SYCL=ON"
 "-DKokkos_ARCH_INTEL_PVC=ON"
 "-DKokkos_ARCH_SPR=ON"
)

# Options for Kokkos Kernels.
KOKKOS_KERNELS_OPTS=(
 "-DCMAKE_C_COMPILER=icx"
 "-DCMAKE_CXX_COMPILER=icpx"
 "-DCMAKE_CXX_FLAGS='${GCC_TOOLCHAIN} -Wno-zero-length-array -fsycl-device-code-split=per_kernel -fp-model=precise'"
 "-DCMAKE_EXE_LINKER_FLAGS='-fsycl -flink-huge-device-code'"
)

# Options for Google Test.
GOOGLETEST_OPTS=(
 "-DCMAKE_C_COMPILER=icx"
 "-DCMAKE_CXX_COMPILER=icpx"
 "-DCMAKE_CXX_FLAGS=${GCC_TOOLCHAIN}"
)

# Options for graph-dispatching.
GRAPH_DISPATCHING_OPTS=(
 -DCMAKE_CXX_FLAGS=${GCC_TOOLCHAIN}
)

# Compiler loading.
# We could load one of the modules of the machine, such as:
# module load compiler-intel-llvm/2025.1.0
# but since there are recent developments in SYCL command graph, let's be bleeding edge.
# Note that loading a recent gcc is required, otherwise 'icpx' will use whatever (very) old GNU standard library headers
# it will find and the compilation will likely fail.
. spack/share/spack/setup-env.sh
spack load gcc@${GCC_VERSION} intel-oneapi-compilers@2026.0.0

# Libraries loading.
module load dpl/2022.8

. $SOURCE_DIR/prepare_graph_dispatching.sh