fix shellcheck lint

Author: trxcllnt

.devcontainer/cccl-entrypoint.sh

@@ -5,7 +5,8 @@
 set -e;
 
 if ! test -n "${DISABLE_SCCACHE:+x}" && test -n "${DEVCONTAINER_UTILS_ENABLE_SCCACHE_DIST:+x}" && ! test -n "${SCCACHE_DIST_URL:+x}"; then
-    export SCCACHE_DIST_URL="https://$(dpkg --print-architecture).$(uname -s | tr '[:upper:]' '[:lower:]').sccache.rapids.nvidia.com";
+    SCCACHE_DIST_URL="https://$(uname -m | sed -e 's/x86_/amd/' -e 's/aarch/arm/').linux.sccache.rapids.nvidia.com";
+    export SCCACHE_DIST_URL;
     echo "export SCCACHE_DIST_URL=$SCCACHE_DIST_URL" >> ~/.bashrc;
 fi
 

.devcontainer/docker-entrypoint.sh

@@ -8,14 +8,16 @@
 : "${NEW_UID:=}";
 : "${NEW_GID:=}";
 
-eval "$(sed -n "s/${REMOTE_USER}:[^:]*:\([^:]*\):\([^:]*\):[^:]*:\([^:]*\).*/OLD_UID=\1;OLD_GID=\2;HOME_FOLDER=\3/p" /etc/passwd)";
-eval "$(sed -n "s/\([^:]*\):[^:]*:${NEW_UID}:.*/EXISTING_USER=\1/p" /etc/passwd)";
-eval "$(sed -n "s/\([^:]*\):[^:]*:${NEW_GID}:.*/EXISTING_GROUP=\1/p" /etc/group)";
+OLD_UID="$(sed -n "s/${REMOTE_USER}:[^:]*:\([^:]*\):\([^:]*\):[^:]*:\([^:]*\).*/\1/p" /etc/passwd)";
+OLD_GID="$(sed -n "s/${REMOTE_USER}:[^:]*:\([^:]*\):\([^:]*\):[^:]*:\([^:]*\).*/\2/p" /etc/passwd)";
+HOME_FOLDER="$(sed -n "s/${REMOTE_USER}:[^:]*:\([^:]*\):\([^:]*\):[^:]*:\([^:]*\).*/\3/p" /etc/passwd)";
+EXISTING_USER="$(sed -n "s/\([^:]*\):[^:]*:${NEW_UID}:.*/\1/p" /etc/passwd)";
+EXISTING_GROUP="$(sed -n "s/\([^:]*\):[^:]*:${NEW_GID}:.*/\1/p" /etc/group)";
 
-if [ -z "$OLD_UID" ]; then
+if [[ -z "$OLD_UID" ]]; then
     echo "Remote user not found in /etc/passwd ($REMOTE_USER).";
     exec "$(pwd)/.devcontainer/cccl-entrypoint.sh" "$@";
-elif [ "$OLD_UID" = "$NEW_UID" ] && [ "$OLD_GID" = "$NEW_GID" ]; then
+elif [[ "$OLD_UID" = "$NEW_UID" ]] && [[ "$OLD_GID" = "$NEW_GID" ]]; then
     echo "UIDs and GIDs are the same ($NEW_UID:$NEW_GID).";
     # Even when IDs match, ensure we execute as the non-root REMOTE_USER so
     # gh and sccache use the mapped HOME (/home/coder) where ~/.aws is bind-mounted.
@@ -27,17 +29,17 @@ elif [ "$OLD_UID" = "$NEW_UID" ] && [ "$OLD_GID" = "$NEW_GID" ]; then
     export XDG_STATE_HOME="$HOME_FOLDER/.local/state";
     export PYTHONHISTFILE="$HOME_FOLDER/.local/state/.python_history";
     exec su -p "$REMOTE_USER" -- "$(pwd)/.devcontainer/cccl-entrypoint.sh" "$@";
-elif [ "$OLD_UID" != "$NEW_UID" ] && [ -n "$EXISTING_USER" ]; then
+elif [[ "$OLD_UID" != "$NEW_UID" ]] && [[ -n "$EXISTING_USER" ]]; then
     echo "User with UID exists ($EXISTING_USER=$NEW_UID).";
     exec "$(pwd)/.devcontainer/cccl-entrypoint.sh" "$@";
 else
-    if [ "$OLD_GID" != "$NEW_GID" ] && [ -n "$EXISTING_GROUP" ]; then
+    if [[ "$OLD_GID" != "$NEW_GID" ]] && [[ -n "$EXISTING_GROUP" ]]; then
         echo "Group with GID exists ($EXISTING_GROUP=$NEW_GID).";
         NEW_GID="$OLD_GID";
     fi
     echo "Updating UID:GID from $OLD_UID:$OLD_GID to $NEW_UID:$NEW_GID.";
     sed -i -e "s/\(${REMOTE_USER}:[^:]*:\)[^:]*:[^:]*/\1${NEW_UID}:${NEW_GID}/" /etc/passwd;
-    if [ "$OLD_GID" != "$NEW_GID" ]; then
+    if [[ "$OLD_GID" != "$NEW_GID" ]]; then
         sed -i -e "s/\([^:]*:[^:]*:\)${OLD_GID}:/\1${NEW_GID}:/" /etc/group;
     fi
 
@@ -57,19 +59,5 @@ else
     export XDG_STATE_HOME="$HOME_FOLDER/.local/state";
     export PYTHONHISTFILE="$HOME_FOLDER/.local/state/.python_history";
 
-    if command -V module 2>&1 | grep -q function; then
-        # "deactivate" lmod so it will be reactivated as the non-root user
-        export LMOD_CMD=
-        export LMOD_DEFAULT_MODULEPATH=
-        export LMOD_DIR=
-        export LMOD_PKG=
-        export LOADEDMODULES=
-        export MANPATH=
-        export MODULEPATH_ROOT=
-        export MODULEPATH=
-        export MODULESHOME=
-        export -fn module
-    fi
-
     exec su -p "$REMOTE_USER" -- "$(pwd)/.devcontainer/cccl-entrypoint.sh" "$@";
 fi

.devcontainer/launch.sh

@@ -30,9 +30,10 @@ print_help() {
 _upvar() {
     if unset -v "$1"; then
         if (( $# == 2 )); then
-            eval $1=\"\$2\";
+            eval "$1"=\"\$2\";
         else
-            eval $1=\(\"\${@:2}\"\);
+            # shellcheck disable=SC1083
+            eval "$1"=\(\"\${@:2}\"\);
         fi;
     fi
 }
@@ -47,7 +48,7 @@ parse_options() {
     # implementations of getopt(1), and this version if the environment variable
     # GETOPT_COMPATIBLE is set, will return '--' and error status 0.
     set +e
-    getopt -T 2>&1 > /dev/null
+    getopt -T >/dev/null 2>&1
     getopt_ret=$?
     set -e
 
@@ -135,13 +136,15 @@ launch_docker() {
     # Introduces the `DOCKER_IMAGE`, `ENTRYPOINTS`, `ENV_VARS`, `GPU_REQUEST`,
     # `INITIALIZE_COMMANDS`, `MOUNTS`, `REMOTE_USER`, `RUN_ARGS`, and
     # `WORKSPACE_FOLDER` variables
+    # shellcheck disable=SC2312,SC1090
     source <(python3 .devcontainer/launch.py "${path}/devcontainer.json")
 
     ###
     # Run the initialize command(s) before starting the container
     ###
 
     local init_cmd;
+    # shellcheck disable=SC2154
     for init_cmd in "${INITIALIZE_COMMANDS[@]}"; do
         eval "${init_cmd}"
     done
@@ -163,6 +166,7 @@ launch_docker() {
         RUN_ARGS+=(--gpus "${gpu_request}")
     else
         # Otherwise read and infer from hostRequirements.gpu
+        # shellcheck disable=SC2154,SC2153
         RUN_ARGS+=("${GPU_REQUEST[@]}")
     fi
 
@@ -176,6 +180,7 @@ launch_docker() {
                 ENV_VARS+=(--env NEW_UID="$(id -u)")
                 ENV_VARS+=(--env NEW_GID="$(id -g)")
                 ENV_VARS+=(--env REMOTE_USER="$REMOTE_USER")
+                # shellcheck disable=SC2154
                 ENTRYPOINTS+=("${WORKSPACE_FOLDER}/.devcontainer/docker-entrypoint.sh")
                 ;;
         esac
@@ -201,6 +206,7 @@ launch_docker() {
             echo "::group::Docker run command"
             set -x
         fi
+        # shellcheck disable=SC2154
         exec docker run \
           "${RUN_ARGS[@]}" \
           "${ENV_VARS[@]}" \
@@ -225,14 +231,17 @@ launch_vscode() {
     # and compiler environment into this temporary directory, adjusting paths to ensure the
     # correct workspace is loaded. A special URL is then generated to instruct VSCode to
     # launch the development container using this temporary configuration.
-    local workspace="$(basename "$(pwd)")"
-    local tmpdir="$(mktemp -d)/${workspace}"
+    local workspace
+    workspace="$(basename "$(pwd)")"
+    local tmpdir
+    tmpdir="$(mktemp -d)/${workspace}"
     mkdir -p "${tmpdir}"
     mkdir -p "${tmpdir}/.devcontainer"
     cp -arL "${path}/devcontainer.json" "${tmpdir}/.devcontainer"
     sed -i "s@\${localWorkspaceFolder}@$(pwd)@g" "${tmpdir}/.devcontainer/devcontainer.json"
     local path="${tmpdir}"
-    local hash="$(echo -n "${path}" | xxd -pu - | tr -d '[:space:]')"
+    local hash
+    hash="$(echo -n "${path}" | xxd -pu - | tr -d '[:space:]')"
     local url="vscode://vscode-remote/dev-container+${hash}/home/coder/cccl"
 
     local launch=""
@@ -242,7 +251,7 @@ launch_vscode() {
         launch="xdg-open"
     fi
 
-    if [ -n "${launch}" ]; then
+    if [[ -n "${launch}" ]]; then
         echo "Launching VSCode Dev Container URL: ${url}"
         code --new-window "${tmpdir}"
         exec "${launch}" "${url}" >/dev/null 2>&1

.devcontainer/make_devcontainers.sh

@@ -39,15 +39,15 @@ update_devcontainer() {
 
     # NVHPC SDK comes with its own bundled toolkit
     local toolkit_name="-cuda${cuda_version}${cuda_suffix}"
-    if [ $compiler_name == "nvhpc" ]; then
+    if [[ "$compiler_name" == "nvhpc" ]]; then
         toolkit_name=""
     fi
 
     local IMAGE_ROOT="rapidsai/devcontainers:${devcontainer_version}-cpp-"
     local INTERNAL_ROOT="gitlab-master.nvidia.com:5005/cccl/cccl-devcontainers:cpp-"
 
     img=$IMAGE_ROOT
-    if [ "$internal" == "true" ]; then
+    if [[ "$internal" == "true" ]]; then
         img=$INTERNAL_ROOT
     fi;
 
@@ -111,43 +111,55 @@ MATRIX_FILE="../ci/matrix.yaml"
 COMPUTE_MATRIX="../.github/actions/workflow-build/build-workflow.py"
 
 # Enable verbose mode if requested
-if [ "$VERBOSE" = true ]; then
+if [[ "$VERBOSE" = true ]]; then
     set -x
-    cat ${MATRIX_FILE}
+    cat "${MATRIX_FILE}"
 fi
 
 # Read matrix.yaml and convert it to json
-matrix_json=$(python3 ${COMPUTE_MATRIX} ${MATRIX_FILE} --devcontainer-info)
+matrix_json=$(python3 "${COMPUTE_MATRIX}" "${MATRIX_FILE}" --devcontainer-info)
 
-if [ "$VERBOSE" = true ]; then
+if [[ "$VERBOSE" = true ]]; then
     echo "$matrix_json"
 fi
 
 # Get the devcontainer image version and define image tag root
-readonly DEVCONTAINER_VERSION=$(echo "$matrix_json" | jq -r '.devcontainer_version')
+DEVCONTAINER_VERSION=$(echo "$matrix_json" | jq -r '.devcontainer_version')
+readonly DEVCONTAINER_VERSION
 
 # Internal image compiler versions:
-readonly CUDA99_GCC_VERSION=$( echo "$matrix_json" | jq -r '.cuda99_gcc_version')
-readonly CUDA99_LLVM_VERSION=$(echo "$matrix_json" | jq -r '.cuda99_clang_version')
+CUDA99_GCC_VERSION=$( echo "$matrix_json" | jq -r '.cuda99_gcc_version')
+readonly CUDA99_GCC_VERSION
+CUDA99_LLVM_VERSION=$(echo "$matrix_json" | jq -r '.cuda99_clang_version')
+readonly CUDA99_LLVM_VERSION
 
 # Get unique combinations of cuda version, compiler name/version, and Ubuntu version
-readonly combinations=$(echo "$matrix_json" | jq -c '.combinations[]')
+combinations=$(echo "$matrix_json" | jq -c '.combinations[]')
+readonly combinations
 
 # Update the base devcontainer with the default values
 # The root devcontainer.json file is used as the default container as well as a template for all
 # other devcontainer.json files by replacing the `image:` field with the appropriate image name
 readonly base_devcontainer_file="./devcontainer.json"
-readonly NEWEST_GCC_CUDA_ENTRY=$(echo "$combinations" | jq -rs '[.[] | select(.compiler_name == "gcc")] | sort_by((.cuda | tonumber), (.compiler_version | tonumber)) | .[-1]')
-readonly NEWEST_LLVM_CUDA_ENTRY=$(echo "$combinations" | jq -rs '[.[] | select(.compiler_name == "llvm")] | sort_by((.cuda | tonumber), (.compiler_version | tonumber)) | .[-1]')
-readonly DEFAULT_CUDA=$(echo "$NEWEST_GCC_CUDA_ENTRY" | jq -r '.cuda')
+NEWEST_GCC_CUDA_ENTRY=$(echo "$combinations" | jq -rs '[.[] | select(.compiler_name == "gcc")] | sort_by((.cuda | tonumber), (.compiler_version | tonumber)) | .[-1]')
+readonly NEWEST_GCC_CUDA_ENTRY
+NEWEST_LLVM_CUDA_ENTRY=$(echo "$combinations" | jq -rs '[.[] | select(.compiler_name == "llvm")] | sort_by((.cuda | tonumber), (.compiler_version | tonumber)) | .[-1]')
+# shellcheck disable=SC2034
+readonly NEWEST_LLVM_CUDA_ENTRY
+DEFAULT_CUDA=$(echo "$NEWEST_GCC_CUDA_ENTRY" | jq -r '.cuda')
+readonly DEFAULT_CUDA
 readonly DEFAULT_CUDA_EXT=false
-readonly DEFAULT_COMPILER_NAME=$(echo "$NEWEST_GCC_CUDA_ENTRY" | jq -r '.compiler_name')
-readonly DEFAULT_COMPILER_EXE=$(echo "$NEWEST_GCC_CUDA_ENTRY" | jq -r '.compiler_exe')
-readonly DEFAULT_COMPILER_VERSION=$(echo "$NEWEST_GCC_CUDA_ENTRY" | jq -r '.compiler_version')
-readonly DEFAULT_NAME=$(make_name "$DEFAULT_CUDA" "$DEFAULT_CUDA_EXT" "$DEFAULT_COMPILER_NAME" "$DEFAULT_COMPILER_VERSION")
-
-update_devcontainer ${base_devcontainer_file} "./temp_devcontainer.json" "$DEFAULT_NAME" "$DEFAULT_CUDA" "$DEFAULT_CUDA_EXT" "$DEFAULT_COMPILER_NAME" "$DEFAULT_COMPILER_EXE" "$DEFAULT_COMPILER_VERSION" "$DEVCONTAINER_VERSION" "false"
-mv "./temp_devcontainer.json" ${base_devcontainer_file}
+DEFAULT_COMPILER_NAME=$(echo "$NEWEST_GCC_CUDA_ENTRY" | jq -r '.compiler_name')
+readonly DEFAULT_COMPILER_NAME
+DEFAULT_COMPILER_EXE=$(echo "$NEWEST_GCC_CUDA_ENTRY" | jq -r '.compiler_exe')
+readonly DEFAULT_COMPILER_EXE
+DEFAULT_COMPILER_VERSION=$(echo "$NEWEST_GCC_CUDA_ENTRY" | jq -r '.compiler_version')
+readonly DEFAULT_COMPILER_VERSION
+DEFAULT_NAME=$(make_name "$DEFAULT_CUDA" "$DEFAULT_CUDA_EXT" "$DEFAULT_COMPILER_NAME" "$DEFAULT_COMPILER_VERSION")
+readonly DEFAULT_NAME
+
+update_devcontainer "${base_devcontainer_file}" "./temp_devcontainer.json" "$DEFAULT_NAME" "$DEFAULT_CUDA" "$DEFAULT_CUDA_EXT" "$DEFAULT_COMPILER_NAME" "$DEFAULT_COMPILER_EXE" "$DEFAULT_COMPILER_VERSION" "$DEVCONTAINER_VERSION" "false"
+mv "./temp_devcontainer.json" "${base_devcontainer_file}"
 
 # Create an array to keep track of valid subdirectory names
 valid_subdirs=()
@@ -178,10 +190,14 @@ make_compiler_entry() {
     }" | jq -c '.'
 }
 
-readonly cuda99_8_gcc=$( make_compiler_entry "gcc"  "$CUDA99_GCC_VERSION"  "gcc"   "99.8" "false" "true")
-readonly cuda99_9_gcc=$( make_compiler_entry "gcc"  "$CUDA99_GCC_VERSION"  "gcc"   "99.9" "false" "true")
-readonly cuda99_8_llvm=$(make_compiler_entry "llvm" "$CUDA99_LLVM_VERSION" "clang" "99.8" "false" "true")
-readonly cuda99_9_llvm=$(make_compiler_entry "llvm" "$CUDA99_LLVM_VERSION" "clang" "99.9" "false" "true")
+cuda99_8_gcc=$( make_compiler_entry "gcc"  "$CUDA99_GCC_VERSION"  "gcc"   "99.8" "false" "true")
+readonly cuda99_8_gcc
+cuda99_9_gcc=$( make_compiler_entry "gcc"  "$CUDA99_GCC_VERSION"  "gcc"   "99.9" "false" "true")
+readonly cuda99_9_gcc
+cuda99_8_llvm=$(make_compiler_entry "llvm" "$CUDA99_LLVM_VERSION" "clang" "99.8" "false" "true")
+readonly cuda99_8_llvm
+cuda99_9_llvm=$(make_compiler_entry "llvm" "$CUDA99_LLVM_VERSION" "clang" "99.9" "false" "true")
+readonly cuda99_9_llvm
 
 readonly all_comb="$combinations $cuda99_9_gcc $cuda99_8_gcc $cuda99_9_llvm $cuda99_8_llvm"
 # For each unique combination
@@ -205,9 +221,9 @@ for combination in $all_comb; do
 done
 
 # Clean up stale subdirectories and devcontainer.json files
-if [ "$CLEAN" = true ]; then
+if [[ "$CLEAN" = true ]]; then
     for subdir in ./*; do
-        if [ -d "$subdir" ] && [[ ! " ${valid_subdirs[@]} " =~ " ${subdir#./} " ]]; then
+        if [[ -d "$subdir" ]] && [[ " ${valid_subdirs[*]} " != *" ${subdir#./} "* ]]; then
             echo "Removing stale subdirectory: $subdir"
             rm -r "$subdir"
         fi

.devcontainer/verify_devcontainer.sh

@@ -19,10 +19,13 @@ check_envvars() {
 }
 
 check_host_compiler_version() {
-    local version_output=$($CXX --version)
+    local version_output
+    # shellcheck disable=SC2154
+    version_output=$("$CXX" --version)
 
     if [[ "$CXX" == "g++" ]]; then
-        local actual_version=$(echo "$version_output" | head -n 1 | cut -d ' ' -f 4 | cut -d '.' -f 1)
+        local actual_version
+        actual_version=$(echo "$version_output" | head -n 1 | cut -d ' ' -f 4 | cut -d '.' -f 1)
         local expected_compiler="gcc"
     elif [[ "$CXX" == "clang++" ]]; then
         if [[ $version_output =~ clang\ version\ ([0-9]+) ]]; then
@@ -33,20 +36,23 @@ check_host_compiler_version() {
         fi
         expected_compiler="llvm"
     elif [[ "$CXX" == "icpc" ]]; then
-        local actual_version=$(echo "$version_output" | head -n 1 | cut -d ' ' -f 3 )
+        local actual_version
+        actual_version=$(echo "$version_output" | head -n 1 | cut -d ' ' -f 3 )
         # The icpc compiler version of oneAPI release 2023.2.0 is 2021.10.0
         if [[ "$actual_version" == "2021.10.0" ]]; then
             actual_version="2023.2.0"
         fi
         expected_compiler="oneapi"
-    elif [[ "$CXX" =~ "nvc++" ]]; then
-        local actual_version=$(echo "$version_output" | head -n 2 | cut -d ' ' -f 2 | cut -d '-' -f 1 | tail -n 1)
+    elif [[ "$CXX" =~ nvc++ ]]; then
+        local actual_version
+        actual_version=$(echo "$version_output" | head -n 2 | cut -d ' ' -f 2 | cut -d '-' -f 1 | tail -n 1)
         local expected_compiler="nvhpc"
     else
         echo "::error:: Unexpected CXX value ($CXX)."
         exit 1
     fi
 
+    # shellcheck disable=SC2154
     if [[ "$expected_compiler" != "${CCCL_HOST_COMPILER}" || "$actual_version" != "$CCCL_HOST_COMPILER_VERSION" ]]; then
         echo "::error:: CXX ($CXX) version ($actual_version) does not match the expected compiler (${CCCL_HOST_COMPILER}) and version (${CCCL_HOST_COMPILER_VERSION})."
         exit 1
@@ -56,14 +62,16 @@ check_host_compiler_version() {
 }
 
 check_cuda_version() {
-    local cuda_version_output=$(nvcc --version)
+    local cuda_version_output
+    cuda_version_output=$(nvcc --version)
     if [[ $cuda_version_output =~ release\ ([0-9]+\.[0-9]+) ]]; then
         local actual_cuda_version=${BASH_REMATCH[1]}
     else
         echo "::error:: Unable to determine CUDA version from nvcc."
         exit 1
     fi
 
+    # shellcheck disable=SC2154
     if [[ "$actual_cuda_version" != "$CCCL_CUDA_VERSION" ]]; then
         echo "::error:: CUDA version ($actual_cuda_version) does not match the expected CUDA version ($CCCL_CUDA_VERSION)."
         exit 1

benchmarks/scripts/submit_benchmark_job.sh

@@ -9,7 +9,7 @@ jobtime="4:00:00"
 benchmark_preset="benchmark"
 
 batch_script=$scratch/batch.sh
-cat << BATCH_SCRIPT > $batch_script
+cat << BATCH_SCRIPT > "$batch_script"
 #!/bin/bash
 
 pip install --break-system-packages fpzip pandas scipy
@@ -37,11 +37,11 @@ export PYTHONPATH=../benchmarks/scripts/
 
 echo "Benchmark done. Results in $scratch/\$host/cccl/build_perf/cccl_meta_bench.db"
 BATCH_SCRIPT
-chmod +x $batch_script
+chmod +x "$batch_script"
 
 # schedule SLURM job
 echo "Scheduling script $batch_script"
 echo "#################################################################################"
-cat $batch_script
+cat "$batch_script"
 echo "#################################################################################"
-crun -q "$node_selector" -ex -t $jobtime -img $container_image -b $batch_script
+crun -q "$node_selector" -ex -t "$jobtime" -img "$container_image" -b "$batch_script"

ci/build_cccl_c_parallel.sh

@@ -2,14 +2,15 @@
 
 set -euo pipefail
 
+# shellcheck source=ci/build_common.sh
 source "$(dirname "${BASH_SOURCE[0]}")/build_common.sh"
 
 print_environment_details
 
 PRESET="cccl-c-parallel"
 
-CMAKE_OPTIONS="-DCMAKE_CXX_STANDARD=${CXX_STANDARD} -DCMAKE_CUDA_STANDARD=${CXX_STANDARD}"
+CMAKE_OPTIONS=("-DCMAKE_CXX_STANDARD=${CXX_STANDARD}" "-DCMAKE_CUDA_STANDARD=${CXX_STANDARD}")
 
-configure_and_build_preset "CCCL C Parallel Library" "$PRESET" "$CMAKE_OPTIONS"
+configure_and_build_preset "CCCL C Parallel Library" "$PRESET" "${CMAKE_OPTIONS[@]}"
 
 print_time_summary