commit: 9126c0cf5edb908b8c0067d8df40ce8d94b632b2
Author: Paul Zander <negril.nx+gentoo <AT> gmail <DOT> com>
AuthorDate: Fri Feb 7 18:39:53 2025 +0000
Commit: Sam James <sam <AT> gentoo <DOT> org>
CommitDate: Sun Feb 23 18:43:25 2025 +0000
URL: https://gitweb.gentoo.org/repo/gentoo.git/commit/?id=9126c0cf
dev-util/nvidia-cuda-toolkit: add 12.8.0, rework ebuild
Add support for arm64.
Add support for clang.
Add checks for DRIVER_PV and GCC_MAX_VER/CLANG_MAX_VER.
Drop Visual Tools to add them as separate packages.
Use makepkg script to unpack the archive. unpacker.eclass doesn't allow to
exclude files, which we rely on to keep the temp dir size down.
Use the manifest file from the archive to generate the file list.
Use move instead of doins. This ensures we do not miss files and permissions as
older versions did.
This method also adds the pkgconfig files that were never generated or installed
prior.
This no longer installs the toolkit to /opt/cuda, but /opt/cuda-${PV} and
creates a symlink from the old location. Once we removed cuda-config in favour
of a run-time detection via cuda.eclass, this will allow a slotted install of
multiple CUDA versions.
Closes: https://bugs.gentoo.org/947042
Closes: https://bugs.gentoo.org/939906
Closes: https://bugs.gentoo.org/916976
Closes: https://bugs.gentoo.org/840140
Signed-off-by: Paul Zander <negril.nx+gentoo <AT> gmail.com>
Closes: https://github.com/gentoo/gentoo/pull/40539
Signed-off-by: Sam James <sam <AT> gentoo.org>
dev-util/nvidia-cuda-toolkit/Manifest | 2 +
.../nvidia-cuda-toolkit/files/parse_manifest.py | 223 +++++++++++++
.../nvidia-cuda-toolkit-12.8.0.ebuild | 370 +++++++++++++++++++++
profiles/arch/arm64/package.use.mask | 4 +
4 files changed, 599 insertions(+)
diff --git a/dev-util/nvidia-cuda-toolkit/Manifest
b/dev-util/nvidia-cuda-toolkit/Manifest
index 23b4f30c3ad3..9c8748438cee 100644
--- a/dev-util/nvidia-cuda-toolkit/Manifest
+++ b/dev-util/nvidia-cuda-toolkit/Manifest
@@ -6,3 +6,5 @@ DIST cuda_12.5.0_555.42.02_linux.run 4294677299 BLAKE2B
ffefb576feb9f8e6ea8975bf
DIST cuda_12.5.1_555.42.06_linux.run 4311634770 BLAKE2B
3546faeb24687dd11ad0a61a4f02cfbd97119d9e3cd3e24ea294b81ed488de7dfef03607c69d7b5a8087db10cf794205936add7cfa8ccda207e3aca315be48df
SHA512
604843e09717c2af0873b2d5a2e242ff1b99122d515b6a7a29e70c55ab605524744359781f5b642059550b4def57877597111914965efe7d3a1a1387c9dbb1a0
DIST cuda_12.6.0_560.28.03_linux.run 4333105923 BLAKE2B
533e9080dbf087a661ab6e59548e48ca0d2b514f47c3e97ac89b628f79197875a7425ad69c4d271b5fa8243561c1ccba698e3bf322b194b29a5f7fa031ea8f06
SHA512
fe5710c168298d2283a3f636ad5e1e212970fe8d9554ab450aa61d786536f50efb9d9e9396b6ac59638bd4204faadb5a99ec8a8c02e2c57a18f479123aaff3c9
DIST cuda_12.6.1_560.35.03_linux.run 4345714567 BLAKE2B
147c7f03e0d9ade4c603d93920d0cd6bb1706efc268797ae870b5244feaa8159393015f96e920c6255e93d8040dd5b046075804cfa7c5da18a645800d65b8c3d
SHA512
514ec89f847457c3ba78cd0dc22c25aebf2a19a6bbd5a8d071f31519d1007889cde6ba888a01596434216a8a88bfba21059cdc8e3fa9397133c93d2a9f0c015e
+DIST cuda_12.8.0_570.86.10_linux.run 5412604598 BLAKE2B
21ea184fd428ea638934788847e023213c38c1079d489d04bbd1ca277d1c285d57a7ac9c02020cbd73970e703daeec9e806831cf54a427cff90fc036c4da7705
SHA512
7939552d38c39b184946df455233eb9ffe91051656b3091b0414b2acc2939bc35dd92724b584e507976c3b4cd51f489abee2e2d0da27bfebaf8999c3f2c2bb2e
+DIST cuda_12.8.0_570.86.10_linux_sbsa.run 4636253689 BLAKE2B
53df0ee05a9563bf9db1b813a75d4a81c391cf67c24bc0b9fadf74809ebf1534cbf5762317e2f04e4e7482adf97612d8d3f16d78146abe715a9dc4b8654a1bbf
SHA512
bcd91a914d09e72a2f2320d9912a3928a491c8d7062f65d027bc172630944bc0fc319ef2ded10e3c4ade564cf2a4f9a166698dca1d493632ee7ef7ff5d7f1ad5
diff --git a/dev-util/nvidia-cuda-toolkit/files/parse_manifest.py
b/dev-util/nvidia-cuda-toolkit/files/parse_manifest.py
new file mode 100644
index 000000000000..57adad1ca975
--- /dev/null
+++ b/dev-util/nvidia-cuda-toolkit/files/parse_manifest.py
@@ -0,0 +1,223 @@
+#!/usr/bin/env python
+# Copyright 2024-2025 Gentoo Authors
+# Distributed under the terms of the GNU General Public License v2
+#
+#
+# Takes the manifests/*.xml file from the NVIDIA CUDA Toolkit as input.
+# Those files contain a nested tree of package items.
+#
+# For each package node a if block is output that checks the package's
+# name attribute against the environment provided array SKIP_COMPONENTS
+# and skips that whole package if it's listed in it.
+#
+# Each item contains four nodes that reference things to install,
+# `dir`, `file`, `desktopFile`, & `pcfile`, and metadata that further
+# detail these. This script will output calls to do* calls that
+# use the metadata.
+# - dodir would create an empty file - we handle this in dofile
+# - dofile copies a regex file glob
+# - dodesktopFile creates a .desktop file
+# - dopcfile creates a pkgconfig file
+#
+# The resulting bash code can be run inside src_install().
+#
+# Usage: python parse_manifest.py <cuda_aarch64.xml|cuda_x86_64.xml>
+
+
+import argparse
+import xml.etree.ElementTree
+
+import defusedxml.ElementTree
+from pathlib import Path
+
+ind = "\t"
+indent = 1
+
+
+def main():
+ parser = argparse.ArgumentParser()
+ parser.add_argument('filename') # positional argument
+
+ args = parser.parse_args()
+
+ basedir = Path(args.filename).parents[1]
+
+ et = defusedxml.ElementTree.parse(args.filename)
+
+ # Find all packages under the package with the id main (i.e. under "CUDA
Installer")
+ for e in et.findall("[@id='main']/package"):
+ def p_package(el: xml.etree.ElementTree.Element, level: int = 0):
+
+ skip = {
+ "Documentation", # obsolete
+ "Driver", # unused
+ # "Kernel Objects", # split
+ # "Demo Suite",
+ # "Visual Tools",
+ # old eclipse
+ # "nsight",
+ # old java
+ # "nvvp",
+ # "cuda-gdb-src"
+ }
+
+ name = el.get("name")
+
+ # trim leading CUDA and trailing version
+ if name.startswith("CUDA"):
+ name2 = ' '.join(name.split(" ")[1:-1])
+ else:
+ name2 = name
+
+ if name2 in skip:
+ return
+
+ # avoid having to deal with whitespaces in bash
+ name2 = name2.replace(" ", "_")
+
+ path = ""
+
+ print(f"{ind * (level + 0) * indent}if ! has {name2}
\"${{SKIP_COMPONENTS[@]}}\"; then # \"{name}\"")
+
+ # output attributes from unhandled tags
+ for child in el:
+ if child.tag == "package":
+ continue
+ if child.tag == "file":
+ continue
+ if child.tag == "desktopFile":
+ continue
+ if child.tag == "pcfile":
+ continue
+ for attrib in child.attrib:
+ print(f"{child.tag} {attrib}={child.attrib[attrib]}")
+
+ # <name>CUDA Installer</name>
+ # only for CUDA Installer
+ # unused
+ for node in el.findall("./name"):
+ print(f"{ind * (level + 1) * indent}# {node.tag}:
\"{node.text}\"")
+
+ # <type>compiler</type>
+ # category. We use the package name instead.
+ # unused
+ # for node in el.findall("./type"):
+ # print(f"{ind * (level + 1) * indent}# {node.tag}:
\"{node.text}\"")
+
+ # <priority>1</priority>
+ # probably sorting for the tui installer
+ # unused
+ # for node in el.findall("./priority"):
+ # print(f"{ind * (level + 1) * indent}# {node.tag}:
\"{node.text}\"")
+
+ # <single-selection/>
+ # proably for tui installer
+ # unused
+ # for node in el.findall("./single-selection"):
+ # print(f"{ind * (level + 1) * indent}# {node.tag}:
\"{node.text}\"")
+
+ # <koversion>2.24.2</koversion>
+ # version of the installed kernel object (Kernel Objects only)
+ # unused
+ for node in el.findall("./koversion"):
+ print(f"{ind * (level + 1) * indent}# {node.tag}:
\"{node.text}\"")
+
+ # <installPath>/usr/local/cuda-12.8</installPath>
+ # overrides the install location
+ # unused
+ # for node in el.findall("./installPath"):
+ # print(f"{ind * (level + 1) * indent}# {node.tag}:
\"{node.text}\"")
+
+ # <buildPath>./builds/cuda_cccl/</buildPath>
+ # path where the package files are found
+ # we cd into it
+ for node in el.findall("./buildPath"):
+ path = node.text.removeprefix('./')
+ print(f"{ind * (level + 1) * indent}cd \"${{S}}/{path}\" ||
die \"cd ${{S}}/{path} failed\"")
+ print()
+
+ # <dir>bin</dir>
+ # would install empty dirs
+ # unused
+ # for node in el.findall("./dir"):
+ # pass
+
+ # <file dir="bin/">.*</file>
+ # <file>targets/x86_64-linux/lib/.*\.so</file>
+ # regex glob of files to install.
+ for node in el.findall("./file"):
+ # unescape '.*' -> '*' & '\.' -> '.'
+ file = (node.text
+ .replace(".*", "*")
+ .replace(r"\.", ".")
+ .replace("x86_64", "${narch}")
+ .replace("sbsa", "${narch}")
+ )
+
+ # optional dir offset, we merge it into path
+ dir = ""
+ if "dir" in node.attrib:
+ dir = f" \"{Path(node.attrib["dir"])}\""
+
+ filepath = basedir / path / file
+
+ # ignore existing symlinks ( include, lib* ) and the
uninstallers
+ if not filepath.is_symlink() and not
file.endswith("-uninstaller"):
+ print(f"{ind * (level + 1) * indent}dofile
\"{file}\"{dir}")
+
+ # <pcfile description="CUDA Runtime
Library">opencl-12.8.pc</pcfile>
+ # create a pkgconfig file for the given description and lib
name/version
+ for node in el.findall("./pcfile"):
+ offset = node.text.rfind('-')
+ if offset == -1:
+ raise RuntimeError(f"failed to split pcfile {node.text}")
+
+ lib_name = node.text[:offset]
+
+ if not node.text.endswith('.pc'):
+ raise RuntimeError(f"pcfile does not end in '.pc'
{node.text}")
+ lib_version = node.text[offset+1:-3]
+
+ if "description" not in node.attrib:
+ raise RuntimeError(f"no description for {node.text}")
+
+ subdir = ""
+ if "subdir" in node.attrib:
+ subdir = f" \"{node.attrib["subdir"]}\""
+
+ print(f"{ind * (level + 1) * indent}dopcfile "
+ f"\"{lib_name}\" "
+ f"\"{lib_version}\" "
+ f"\"{node.attrib["description"]}\"{subdir}")
+
+ # <desktopFile
+ # filename="nsight"
+ # name="Nsight Eclipse Edition"
+ # categories="Development;IDE;Debugger;ParallelComputing"
+ # keywords="cuda;gpu;nvidia;debugger;"
+ # iconPath="libnsight/icon.xpm"
+ # execPath="bin/nsight"
+ # tryExecPath="bin/nsight"
+ # />
+ # create a .desktop file
+ for node in el.findall("./desktopFile"):
+ print(f"{ind * (level + 1) * indent}dodesktopFile \\")
+ print(f"{ind * (level + 2) *
indent}\"{node.attrib["filename"]}\" \\")
+ print(f"{ind * (level + 2) * indent}\"{node.attrib["name"]}\"
\\")
+ print(f"{ind * (level + 2) *
indent}\"{node.attrib["categories"]}\" \\")
+ print(f"{ind * (level + 2) *
indent}\"{node.attrib["keywords"]}\" \\")
+ print(f"{ind * (level + 2) *
indent}\"{node.attrib["iconPath"]}\" \\")
+ print(f"{ind * (level + 2) *
indent}\"{node.attrib["execPath"]}\" \\")
+ print(f"{ind * (level + 2) *
indent}\"{node.attrib["tryExecPath"]}\"")
+
+ # iterator over all nested packages
+ for node in el.findall("./package"):
+ p_package(node, level + 1)
+
+ print(f"{ind * (level + 0) * indent}fi")
+
+ p_package(e)
+
+
+if __name__ == "__main__":
+ main()
diff --git a/dev-util/nvidia-cuda-toolkit/nvidia-cuda-toolkit-12.8.0.ebuild
b/dev-util/nvidia-cuda-toolkit/nvidia-cuda-toolkit-12.8.0.ebuild
new file mode 100644
index 000000000000..0d731b90adfa
--- /dev/null
+++ b/dev-util/nvidia-cuda-toolkit/nvidia-cuda-toolkit-12.8.0.ebuild
@@ -0,0 +1,370 @@
+# Copyright 1999-2025 Gentoo Authors
+# Distributed under the terms of the GNU General Public License v2
+
+# shellcheck disable=SC2317
+
+EAPI=8
+
+PYTHON_COMPAT=( python3_{10..13} )
+inherit check-reqs toolchain-funcs
+inherit python-r1
+
+DRIVER_PV="570.86.10"
+GCC_MAX_VER="14"
+CLANG_MAX_VER="19"
+
+DESCRIPTION="NVIDIA CUDA Toolkit (compiler and friends)"
+HOMEPAGE="https://developer.nvidia.com/cuda-zone";
+SRC_URI="
+ amd64? (
+
https://developer.download.nvidia.com/compute/cuda/${PV}/local_installers/cuda_${PV}_${DRIVER_PV}_linux.run
+ )
+ arm64? (
+
https://developer.download.nvidia.com/compute/cuda/${PV}/local_installers/cuda_${PV}_${DRIVER_PV}_linux_sbsa.run
+ )
+"
+S="${WORKDIR}"
+
+LICENSE="NVIDIA-CUDA"
+
+SLOT="0/${PV}" # UNSLOTTED
+# SLOT="${PV}" # SLOTTED
+
+KEYWORDS="-* ~amd64 ~arm64 ~amd64-linux ~arm64-linux"
+IUSE="debugger examples profiler rdma sanitizer"
+RESTRICT="bindist mirror strip test"
+
+REQUIRED_USE="${PYTHON_REQUIRED_USE}"
+
+# since CUDA 11, the bundled toolkit driver (== ${DRIVER_PV}) and the
+# actual required minimum driver version are different.
+RDEPEND="
+ || (
+ <sys-devel/gcc-$(( GCC_MAX_VER + 1 ))_pre[cxx]
+ <llvm-core/clang-$(( CLANG_MAX_VER + 1 ))_pre
+ )
+ sys-process/numactl
+ debugger? (
+ ${PYTHON_DEPS}
+ )
+ examples? (
+ media-libs/freeglut
+ media-libs/glu
+ )
+ rdma? ( sys-cluster/rdma-core )
+"
+BDEPEND="
+ $(python_gen_any_dep '
+ dev-python/defusedxml[${PYTHON_USEDEP}]
+ ')
+"
+
+CUDA_PATH="/opt/cuda-${PV}"
+QA_PREBUILT="${CUDA_PATH#/}/*"
+
+PATCHES=(
+ "${FILESDIR}/nvidia-cuda-toolkit-glibc-2.41.patch"
+)
+
+python_check_deps() {
+ python_has_version "dev-python/defusedxml[${PYTHON_USEDEP}]"
+}
+
+cuda-toolkit_check_reqs() {
+ if use amd64; then
+ export CHECKREQS_DISK_BUILD="6645M"
+ elif use arm64; then
+ export CHECKREQS_DISK_BUILD="6412M"
+ fi
+
+ "check-reqs_pkg_${EBUILD_PHASE}"
+}
+
+cuda_verify() {
+ if has_version "sys-apps/grep[pcre]"; then
+ local DRIVER_PV_info
+ DRIVER_PV_info="$(bash "${DISTDIR}/${A}" --info | grep -oP
"cuda_${PV}.*run" | cut -d '_' -f 3)"
+
+ if [[ "${DRIVER_PV}" != "${DRIVER_PV_info}" ]]; then
+ die "check DRIVER_PV is ${DRIVER_PV} and should be
${DRIVER_PV_info}"
+ fi
+ fi
+
+ # rest only works in with unpacked sources
+ [[ "${EBUILD_PHASE}" != prepare ]] && return
+
+ # run self checks
+ local compiler_versions GCC_HAS_VER CLANG_HAS_VER
+ compiler_versions="$(
+ grep -oP "unsupported (GNU|clang) version.*(gcc versions later
than|clang version must be less than) [0-9]*" \
+
"${S}"/builds/cuda_nvcc/targets/*/include/crt/host_config.h
+ )"
+
+ GCC_HAS_VER="$( echo "${compiler_versions}" | grep gcc | grep -oP
"(?<=than )[0-9]*")"
+ if [[ "${GCC_MAX_VER}" -ne "${GCC_HAS_VER}" ]]; then
+ eqawarn "check GCC_MAX_VER is ${GCC_MAX_VER} and should be
${GCC_HAS_VER}"
+ fi
+
+ CLANG_HAS_VER="$(( $(echo "${compiler_versions}" | grep clang | grep
-oP "(?<=than )[0-9]*") - 1 ))"
+ if [[ "${CLANG_MAX_VER}" -ne "${CLANG_HAS_VER}" ]]; then
+ eqawarn "check CLANG_MAX_VER is ${CLANG_MAX_VER} and should be
${CLANG_HAS_VER}"
+ fi
+}
+
+pkg_pretend() {
+ cuda-toolkit_check_reqs
+}
+
+pkg_setup() {
+ cuda-toolkit_check_reqs
+
+ # we need python for manifest parsing and to determine the supported
python versions for cuda-gdb
+ python_setup
+
+ if use amd64; then
+ narch=x86_64
+ elif use arm64; then
+ narch=sbsa
+ else
+ die "unknown arch ${ARCH}"
+ fi
+
+ export narch
+}
+
+src_unpack() {
+ cuda_verify
+
+ local exclude=(
+ "cuda-installer"
+ "*-uninstaller"
+ "NVIDIA-Linux-${narch}-${DRIVER_PV}.run"
+ "builds/cuda_documentation"
+ "builds/cuda_nsight"
+ "builds/cuda_nvvp"
+ "builds/nsight_compute"
+ "builds/nsight_systems"
+ "builds/nvidia_fs"
+ )
+
+ bash "${DISTDIR}/${A}" --tar xf -X <(printf "%s\n" "${exclude[@]}") ||
die "failed to extract ${A}"
+}
+
+src_configure() {
+ :
+}
+
+src_compile() {
+ :
+}
+
+src_install() {
+ local -x SKIP_COMPONENTS=(
+ "Kernel_Objects"
+ "Visual_Tools"
+ "Documentation" # obsolete
+ "cuda-gdb-src" # not used
+ )
+
+ ! use debugger && SKIP_COMPONENTS+=( "cuda-gdb" )
+ ! use examples && SKIP_COMPONENTS+=( "Demo_Suite" )
+ ! use profiler && SKIP_COMPONENTS+=( "cuda-cupti"
"cuda-profiler-api" "nvprof" )
+ ! use sanitizer && SKIP_COMPONENTS+=( "compute-sanitizer" )
+
+ dodir "${CUDA_PATH}"
+ into "${CUDA_PATH}"
+
+ dofile() {
+ debug-print-function "${FUNCNAME[0]}" "$@"
+
+ if [[ $# -ne 1 ]] && [[ $# -ne 2 ]]; then
+ die "${FUNCNAME[0]} must receive one or two arguments"
+ fi
+
+ local _DESTDIR
+ _DESTDIR="$(dirname "${CUDA_PATH}/${1%/}")${2:+/${2%/}}"
+ mkdir -p "${ED}${_DESTDIR}" || die "mkdir ${_DESTDIR} failed"
+
+ local dir
+ dir="$(dirname "${1}")"
+
+ if test -z "$(find "${dir}" -maxdepth 1 -name "$(basename
"$1")" -print -quit)"; then
+ if [[ -e "${ED}${_DESTDIR}/$(basename "${1}")" ]]; then
+ return
+ fi
+ if [[ "$1" ==
"targets/x86_64-linux/lib/stubs/libcusolverMg*" ]] ||
+ [[ "$1" ==
"targets/x86_64-linux/lib/libcusparse.so.*" ]]; then
+ return
+ fi
+ return
+ fi
+
+ if [[ -e "${ED}${_DESTDIR}/$(basename "${1}")" ]]; then
+ # skip noisy warnings
+ if [[ "$(basename "${1}")" == "include" ]] ||
+ [[ "$(basename "${1}")" == "lib64" ]]; then
+ return
+ fi
+ eqawarn "${ED}${_DESTDIR}/$(basename "${1}") exists"
+ return
+ fi
+
+ eval mv -i "${1}" "${ED}${_DESTDIR}" || die "mv failed ${PWD} /
${1} -> ${ED} ${_DESTDIR}"
+ }
+
+ dopcfile() {
+ [[ $# -eq 0 ]] && return
+
+ dodir "${CUDA_PATH}/pkgconfig"
+ cat > "${ED}${CUDA_PATH}/pkgconfig/${1}-${2}.pc" <<-EOF || die
"dopcfile"
+ cudaroot=${EPREFIX}${CUDA_PATH}
+ libdir=\${cudaroot}/targets/${narch}-linux/lib${4}
+ includedir=\${cudaroot}/targets/${narch}-linux/include
+
+ Name: ${1}
+ Description: ${3}
+ Version: ${2}
+ Libs: -L\${libdir} -l${1}
+ Cflags: -I\${includedir}
+ EOF
+ }
+
+ pushd builds >/dev/null || die
+ fix_executable_bit=(
+
cuda_cupti/extras/CUPTI/samples/pc_sampling_utility/pc_sampling_utility_helper.h
+
cuda_cupti/extras/CUPTI/samples/pc_sampling_continuous/libpc_sampling_continuous.pl
+
+ libcufile/gds/tools/run_gdsio.cfg
+ )
+
+ if use amd64; then
+ fix_executable_bit+=(
+ cuda_opencl/targets/*/include/CL/cl.hpp
+
+ libcufile/targets/*/lib/libcufile_rdma_static.a
+ libcufile/targets/*/lib/libcufile_static.a
+ )
+ fi
+ chmod -x "${fix_executable_bit[@]}" || die "failed chmod"
+ popd >/dev/null || die
+
+ ebegin "parsing manifest" "${S}/manifests/cuda_"*.xml # {{{
+
+ "${EPYTHON}" "${FILESDIR}/parse_manifest.py"
"${S}/manifests/cuda_"*".xml" &> "${T}/install.sh" \
+ || die "failed to parse manifest"
+ # shellcheck disable=SC1091
+ source "${T}/install.sh" || die "failed to source install script"
+
+ eend $? # }}}
+
+ if use debugger; then
+ if [[ -d "${ED}/${CUDA_PATH}/extras/Debugger/lib64" ]]; then
+ rmdir "${ED}/${CUDA_PATH}/extras/Debugger/lib64" || die
"remove debugger lib64"
+ fi
+
+ find "${ED}/${CUDA_PATH}/bin" -maxdepth 1 -name
"cuda-gdb-*-tui" -print0 | while read -rd $'\0' tui_name; do
+ impl="$(basename "${tui_name}" | cut -d '-' -f 3 | tr
'.' '_')"
+
+ if ! has "${impl}" "${PYTHON_COMPAT[@]}" || ! use
"python_targets_${impl}"; then
+ rm "${tui_name}" || die "tui-name rm
${tui_name}"
+ sed -e "/$(basename "${tui_name}")\"/d" -i
"${ED}/${CUDA_PATH}/bin/cuda-gdb" || die "tui_name sed"
+ fi
+ done
+ fi
+
+ # remove rdma libs (unless USE=rdma)
+ if ! use rdma; then
+ rm
"${ED}/${CUDA_PATH}/targets/${narch}-linux/lib/libcufile_rdma"* || die "failed
to remove rdma files"
+ fi
+
+ # Add include and lib symlinks
+ dosym "targets/${narch}-linux/include" "${CUDA_PATH}/include"
+ dosym "targets/${narch}-linux/lib" "${CUDA_PATH}/lib64"
+
+ find "${ED}/${CUDA_PATH}" -empty -delete || die
+
+ local ldpathextradirs pathextradirs
+
+ use debugger &&
ldpathextradirs+=":${EPREFIX}${CUDA_PATH}/extras/Debugger/lib64"
+ use profiler &&
ldpathextradirs+=":${EPREFIX}${CUDA_PATH}/extras/CUPTI/lib64"
+
+ local revord=$(( 999999 - $(printf "%02d%02d%02d" "$(ver_cut 1)"
"$(ver_cut 2)" "$(ver_cut 3)") ))
+ newenvd - "99cuda${revord}" <<-EOF
+ PATH=${EPREFIX}${CUDA_PATH}/bin${pathextradirs}
+ PKG_CONFIG_PATH=${EPREFIX}${CUDA_PATH}/pkgconfig
+
LDPATH=${EPREFIX}${CUDA_PATH}/lib64:${EPREFIX}${CUDA_PATH}/nvvm/lib64${ldpathextradirs}
+ EOF
+
+ # CUDA prepackages libraries, don't revdep-build on them
+ insinto /etc/revdep-rebuild
+ newins - "80${PN}${revord}" <<-EOF
+ SEARCH_DIRS_MASK="${EPREFIX}${CUDA_PATH}"
+ EOF
+
+ # https://bugs.gentoo.org/926116
+ insinto /etc/sandbox.d
+ newins - "80${PN}" <<-EOF
+ SANDBOX_PREDICT="/proc/self/task"
+ EOF
+
+ # TODO drop and replace with runtime detection similar to what python
does {{{
+ # ATTENTION: change requires revbump, see link below for supported GCC
# versions
+ #
https://docs.nvidia.com/cuda/cuda-installation-guide-linux/index.html#system-requirements
+ local cuda_supported_gcc=( 8.5 9.5 10 11 12 13 "${GCC_MAX_VER}" )
+
+ sed \
+ -e "s:CUDA_SUPPORTED_GCC:${cuda_supported_gcc[*]}:g" \
+ "${FILESDIR}"/cuda-config.in >
"${ED}/${CUDA_PATH}/bin/cuda-config" || die
+ fperms +x "${CUDA_PATH}/bin/cuda-config"
+ # }}}
+
+ if [[ "${SLOT}" != "${PV}" ]]; then
+ dosym "${CUDA_PATH}" "${CUDA_PATH%"-${PV}"}"
+ fi
+
+ fowners -R root:root "${CUDA_PATH}"
+}
+
+pkg_postinst_check() {
+ if tc-is-gcc &&
+ ver_test "$(gcc-major-version)" -gt "${GCC_MAX_VER}"; then
+ ewarn
+ ewarn "gcc > ${GCC_MAX_VER} will not work with CUDA"
+ ewarn
+ ewarn "Append --ccbin= pointing to a gcc bindir to the
nvcc compiler flags (NVCCFLAGS)"
+ ewarn "or set NVCC_CCBIN to the same bindir."
+ ewarn " NVCCFLAGS=\"--ccbin=$(eval echo
"${EPREFIX}/usr/*-linux-gnu/gcc-bin/${GCC_MAX_VER}")\""
+ ewarn " NVCC_CCBIN=$(eval echo
"${EPREFIX}/usr/*-linux-gnu/gcc-bin/${GCC_MAX_VER}")"
+ ewarn
+ fi
+
+ if tc-is-clang &&
+ ver_test "$(clang-major-version)" -gt "${CLANG_MAX_VER}"; then
+ ewarn
+ ewarn "clang > ${CLANG_MAX_VER} will not work with CUDA"
+ ewarn
+ ewarn "Append --ccbin= pointing to a clang bindir to
the nvcc compiler flags (NVCCFLAGS)"
+ ewarn "or set NVCC_CCBIN to the same bindir."
+ ewarn " NVCCFLAGS=\"--ccbin=$(eval echo
"${EPREFIX}/usr/lib/llvm/*/bin${CLANG_MAX_VER}")\""
+ ewarn " NVCC_CCBIN=$(eval echo
"${EPREFIX}/usr/lib/llvm/*/bin${CLANG_MAX_VER}")"
+ ewarn
+ fi
+}
+
+pkg_postinst() {
+ if [[ ${MERGE_TYPE} != binary ]]; then
+ pkg_postinst_check
+ fi
+
+ if use profiler; then
+ einfo
+ einfo "nvidia-drivers restricts access to performance counters."
+ einfo "You'll need to run profiling tools (nvprof) "
+ einfo "using sudo (needs cap SYS_ADMIN) or add the following
line to "
+ einfo "a modprobe configuration file "
+ einfo "(e.g. /etc/modprobe.d/nvidia-prof.conf): "
+ einfo
+ einfo "options nvidia NVreg_RestrictProfilingToAdminUsers=0"
+ einfo
+ fi
+}
diff --git a/profiles/arch/arm64/package.use.mask
b/profiles/arch/arm64/package.use.mask
index ff3c8d387d62..bad25872aff3 100644
--- a/profiles/arch/arm64/package.use.mask
+++ b/profiles/arch/arm64/package.use.mask
@@ -1,6 +1,10 @@
# Copyright 1999-2025 Gentoo Authors
# Distributed under the terms of the GNU General Public License v2
+# Paul Zander <[email protected]> (2025-02-23)
+# Not part of the arm64 archive
+dev-util/nvidia-cuda-toolkit -examples -rdma
+
# Alfred Wingate <[email protected]> (2025-02-22)
# media-libs/zint is not keyworded here
media-libs/zxing-cpp experimental
