Merge branch 'main' into bot_script_ci

bedroge · web-flow · commit b640b0c1aab1 · 2026-04-21T12:56:07.000+02:00
diff --git a/create_lmodsitepackage.py b/create_lmodsitepackage.py
@@ -172,7 +172,6 @@
         else
             cudaDriverDir = eessi_eprefix .. "/lib/nvidia"
         end
-        local cudaVersionFile = cudaDriverDir .. "/cuda_version.txt"
         local cudaDriverFile = cudaDriverDir .. "/libcuda.so"
         local cudaDriverExists = isFile(cudaDriverFile)
         local singularityCudaExists = isFile("/.singularity.d/libs/libcuda.so")
@@ -189,28 +188,46 @@
         else
             -- CUDA driver exists, now we check its version to see if an update is needed
             if cudaDriverExists then
-                local cudaVersion = read_file(cudaVersionFile)
-                if not cudaVersion then
-                    LmodError("No CUDA version file\\n" .. cudaVersionFile .. "\\nfound. " .. refer_to_docs)
+                local cudaVersion = os.getenv("EESSI_CUDA_DRIVER_VERSION")
+                if not cudaVersion or cudaVersion == "" then
+                    local eessi_prefix = os.getenv("EESSI_PREFIX")
+                    local script = pathJoin(eessi_prefix, 'scripts', 'gpu_support', 'nvidia', 'get_cuda_driver_version.sh')
+                    source_sh("bash", script)
                 end
+                cudaVersion = os.getenv("EESSI_CUDA_DRIVER_VERSION")
                 local cudaVersion_req = os.getenv("EESSICUDAVERSION")
-                -- driver CUDA versions don't give a patch version for CUDA
-                local major, minor = string.match(cudaVersion, "(%d+)%.(%d+)")
-                local major_req, minor_req, patch_req = string.match(cudaVersion_req, "(%d+)%.(%d+)%.(%d+)")
-                local driver_libs_need_update = false
-                if major < major_req then
-                    driver_libs_need_update = true
-                elseif major == major_req then
-                    if minor < minor_req then
+                -- Account for the fact that the script sourced above was designed to never return a non-zero exit code,
+                -- even if it fails to set EESSI_CUDA_DRIVER_VERSION
+                -- Essentially, we handle that case here by raising an error, which can be suppressed
+                if not cudaVersion or cudaVersion == "" then
+                    local suppress_var = "EESSI_CUDA_DRIVER_VERSION_SUPPRESS_WARNING"
+                    local warn = "Environment variable EESSI_CUDA_DRIVER_VERSION not found. "
+                    warn = warn .. "Cannot ensure that driver version is new enough for CUDA toolkit version: '"
+                    warn = warn .. cudaVersion_req .. "'. This module will still be loaded, but may not function "
+                    warn = warn .. "as expected. Export " .. suppress_var .. "=1"
+                    local suppress_warn = os.getenv(suppress_var)
+                    if not suppress_warn or suppress_warn == 1 then
+                        LmodWarning(warn)
+                    end
+                else
+                    -- driver CUDA versions don't give a patch version for CUDA
+                    local major, minor = string.match(cudaVersion, "(%d+)%.(%d+)")
+                    local major_req, minor_req, patch_req = string.match(cudaVersion_req, "(%d+)%.(%d+)%.(%d+)")
+                    local driver_libs_need_update = false
+                    if tonumber(major) < tonumber(major_req) then
                         driver_libs_need_update = true
+                    elseif tonumber(major) == tonumber(major_req) then
+                        if tonumber(minor) < tonumber(minor_req) then
+                            driver_libs_need_update = true
+                        end
+                    end
+                    if driver_libs_need_update == true then
+                        local advice = "but the module you want to load requires CUDA  " .. cudaVersion_req .. ". "
+                        advice = advice .. "Please update your CUDA driver libraries and then "
+                        advice = advice .. "let EESSI know about the update.\\n"
+                        advice = advice .. refer_to_docs
+                        LmodError("\\nYour driver CUDA version is ", cudaVersion, " ", advice)
                     end
-                end
-                if driver_libs_need_update == true then
-                    local advice = "but the module you want to load requires CUDA  " .. cudaVersion_req .. ". "
-                    advice = advice .. "Please update your CUDA driver libraries and then "
-                    advice = advice .. "let EESSI know about the update.\\n"
-                    advice = advice .. refer_to_docs
-                    LmodError("\\nYour driver CUDA version is ", cudaVersion, " ", advice)
                 end
             end
         end
diff --git a/eb_hooks.py b/eb_hooks.py
@@ -449,6 +449,9 @@ def pre_prepare_hook(self, *args, **kwargs):
     # Always trigger this, regardless of ec.name
     pre_prepare_hook_unsupported_modules(self, *args, **kwargs)
 
+    # Always trigger this, regardless of ec.name
+    pre_prepare_hook_cuda_dependant(self, *args, **kwargs)
+
 
 def post_prepare_hook_gcc_prefixed_ld_rpath_wrapper(self, *args, **kwargs):
     """
@@ -910,6 +913,20 @@ def post_easyblock_hook_copy_easybuild_subdir(self, *args, **kwargs):
     copy_dir(app_easybuild_dir, app_reprod_dir)
 
 
+def pre_prepare_hook_cuda_dependant(self, *args, **kwargs):
+    """
+    CUDA 12.8.0 doesn't support the 10.0f and 12.0f targets, only 10.0 and 12.0. This hook converts
+    any CC 10.0f / 12.0f into 10.0 / 12.0 if the current package depends on CUDA.
+    """
+
+    cudaver = get_dependency_software_version("CUDA", ec=self.cfg, check_deps=True, check_builddeps=True)
+    if cudaver and cudaver == '12.8.0':
+        cuda_cc = build_option('cuda_compute_capabilities')
+        if cuda_cc and ('10.0f' in cuda_cc or '12.0f' in cuda_cc):
+            updated_cuda_cc = [v.replace('.0f', '.0') if v in ['10.0f', '12.0f'] else v for v in cuda_cc]
+            update_build_option('cuda_compute_capabilities', updated_cuda_cc)
+
+
 def pre_prepare_hook_cudnn(self, *args, **kwargs):
     """
     cuDNN is a binary install, that doesn't always have the device code for the suffixed CUDA
@@ -1110,6 +1127,31 @@ def pre_configure_hook_score_p(self, *args, **kwargs):
         raise EasyBuildError("Score-P-specific hook triggered for non-Score-P easyconfig?!")
 
 
+def pre_configure_hook_dyninst(self, *args, **kwargs):
+    """
+    Pre-configure hook for Dyninst
+    - specify correct path to binutils (in compat layer)
+    """
+    if self.name == 'Dyninst':
+
+        # determine path to Prefix installation in compat layer via $EPREFIX
+        eprefix = get_eessi_envvar('EPREFIX')
+
+        binutils_lib_path_glob_pattern = os.path.join(eprefix, 'usr', 'lib*', 'binutils', '*-linux-gnu', '2.*')
+        binutils_lib_path = glob.glob(binutils_lib_path_glob_pattern)
+        if len(binutils_lib_path) == 1:
+            print_msg("Defining LibIberty variables for Dyninst...")
+            self.cfg.update('configopts', '-DLibIberty_ROOT_DIR=' + binutils_lib_path[0])
+            self.cfg.update('configopts', '-DLibIberty_INCLUDE_DIRS=' + os.path.join(binutils_lib_path[0], 'include'))
+            self.cfg.update('configopts', '-DLibIberty_LIBRARIES=' + os.path.join(binutils_lib_path[0], 'libiberty.a'))
+        else:
+            raise EasyBuildError("Failed to isolate path for binutils libraries using %s, got %s",
+                                 binutils_lib_path_glob_pattern, binutils_lib_path)
+
+    else:
+        raise EasyBuildError("Dyninst-specific hook triggered for non-Dyninst easyconfig?!")
+
+
 def pre_configure_hook_extrae(self, *args, **kwargs):
     """
     Pre-configure hook for Extrae
@@ -1987,6 +2029,7 @@ def pre_run_shell_cmd_hook(cmd, work_dir=None, **kwargs):
     'WRF': pre_configure_hook_wrf_aarch64,
     'LAMMPS': pre_configure_hook_LAMMPS_zen4_and_aarch64_cuda,
     'Score-P': pre_configure_hook_score_p,
+    'Dyninst': pre_configure_hook_dyninst,
     'CMake': pre_configure_hook_cmake_system,
 }
 
diff --git a/eessi_container.sh b/eessi_container.sh
@@ -113,6 +113,9 @@ display_help() {
   echo "                            when a directory is provided, the format of the"
   echo "                            tarball's name will be {REPO_ID}-{TIMESTAMP}.tgz"
   echo "                            [default: not set]"
+  echo "  -S | --sandbox          - use sandbox mode (i.e. convert .sif image to sandbox and then run" 
+  echo "                            it instead)"
+  echo "                            [default: not set]"
   echo "  -v | --verbose          - display more information [default: false]"
   echo "  -x | --http-proxy URL   - provides URL for the env variable http_proxy"
   echo "                            [default: not set]; uses env var \$http_proxy if set"
@@ -275,6 +278,10 @@ while [[ $# -gt 0 ]]; do
       SAVE="$2"
       shift 2
       ;;
+    -S|--sandbox)
+      SANDBOX=1
+      shift 1
+      ;;
     -u|--resume)
       RESUME="$2"
       shift 2
@@ -1039,10 +1046,23 @@ for arg in "${PASS_THROUGH[@]}"; do
     ADDITIONAL_CONTAINER_OPTIONS+=(${arg})
 done
 
-echo "Launching container with command (next line):"
-echo "singularity ${RUN_QUIET} ${MODE} ${ADDITIONAL_CONTAINER_OPTIONS[@]} ${EESSI_FUSE_MOUNTS[@]} ${CONTAINER} $@"
-singularity ${RUN_QUIET} ${MODE} "${ADDITIONAL_CONTAINER_OPTIONS[@]}" "${EESSI_FUSE_MOUNTS[@]}" ${CONTAINER} "$@"
-exit_code=$?
+# EESSI_SINGULARITY_SANDBOX is an environment variable (typically set in site_config.sh, if needed)
+if [[ -n "${EESSI_SINGULARITY_SANDBOX}"  ||  ${SANDBOX} -eq 1 ]]; then
+    # using a sandbox image mode is more robust at the cleanup phase at the end
+    CONTAINER_SANDBOX="${CONTAINER%.sif}.sandbox"
+    echo "Building a sandbox image with command (next line):"
+    echo "singularity build --sandbox --force ${CONTAINER_SANDBOX} ${CONTAINER}"
+    singularity build --sandbox --force ${CONTAINER_SANDBOX} ${CONTAINER}
+    echo "Launching sandbox container with command (next line):"
+    echo "singularity ${RUN_QUIET} ${MODE} ${ADDITIONAL_CONTAINER_OPTIONS[@]} ${EESSI_FUSE_MOUNTS[@]} ${CONTAINER_SANDBOX} $@"
+    singularity ${RUN_QUIET} ${MODE} "${ADDITIONAL_CONTAINER_OPTIONS[@]}" "${EESSI_FUSE_MOUNTS[@]}" ${CONTAINER_SANDBOX} "$@"
+    exit_code=$?
+else
+    echo "Launching container with command (next line):"
+    echo "singularity ${RUN_QUIET} ${MODE} ${ADDITIONAL_CONTAINER_OPTIONS[@]} ${EESSI_FUSE_MOUNTS[@]} ${CONTAINER} $@"
+    singularity ${RUN_QUIET} ${MODE} "${ADDITIONAL_CONTAINER_OPTIONS[@]}" "${EESSI_FUSE_MOUNTS[@]}" ${CONTAINER} "$@"
+    exit_code=$?
+fi
 
 # 6. save tmp if requested (arg -s|--save)
 if [[ ! -z ${SAVE} ]]; then
diff --git a/install_scripts.sh b/install_scripts.sh
@@ -211,6 +211,7 @@ nvidia_files=(
     install_cuda_and_libraries.sh
     install_cuda_host_injections.sh
     link_nvidia_host_libraries.sh
+    get_cuda_driver_version.sh
 )
 copy_files_by_list ${TOPDIR}/scripts/gpu_support/nvidia ${INSTALL_PREFIX}/scripts/gpu_support/nvidia "${nvidia_files[@]}"
 
diff --git a/scripts/gpu_support/nvidia/get_cuda_driver_version.sh b/scripts/gpu_support/nvidia/get_cuda_driver_version.sh
@@ -0,0 +1,6 @@
+# This can be leveraged by the source_sh() feature of Lmod
+# Because we want to source this without immediately raising an LmodError upon failure, this script
+# is designed to ALWAYS return a 0 exit code
+EESSI_CUDA_DRIVER_VERSION=$(nvidia-smi --query | grep -oP 'CUDA Version\s*:\s*\K[0-9.]+') || return 0
+# The || return 0 shouldn't be needed, but just to be overly sure that this script always returns 0
+export EESSI_CUDA_DRIVER_VERSION || return 0

Original file line number	Diff line number	Diff line change
`@@ -211,6 +211,7 @@ nvidia_files=(`
`211`	`211`	`install_cuda_and_libraries.sh`
`212`	`212`	`install_cuda_host_injections.sh`
`213`	`213`	`link_nvidia_host_libraries.sh`
	`214`	`+ get_cuda_driver_version.sh`
`214`	`215`	`)`
`215`	`216`	`copy_files_by_list ${TOPDIR}/scripts/gpu_support/nvidia ${INSTALL_PREFIX}/scripts/gpu_support/nvidia "${nvidia_files[@]}"`
`216`	`217`