Patch NAMD

repos/spack_repo/hygon/tsoc/packages/namd/inherited-member-2.13.patch

+--- a/src/colvarproxy_namd.C	2020-09-04 12:07:22.649591658 -0700
++++ b/src/colvarproxy_namd.C	2020-09-04 12:08:41.724079519 -0700
+@@ -479,13 +479,13 @@
+ 
+ // Callback functions
+ 
++#ifdef NAMD_TCL
+ void colvarproxy_namd::init_tcl_pointers()
+ {
+-#ifdef NAMD_TCL
+   // Store pointer to NAMD's Tcl interpreter
+   _tcl_interp = reinterpret_cast<void *>(Node::Object()->getScript()->interp);
+-#endif
+ }
++#endif
+ 
+ int colvarproxy_namd::run_force_callback()
+ {

repos/spack_repo/hygon/tsoc/packages/namd/inherited-member-2.14.patch

+--- a/src/colvarproxy_namd.C	2020-10-02 15:11:37.205197956 -0700
++++ b/src/colvarproxy_namd.C	2020-10-02 15:11:47.865071117 -0700
+@@ -94,12 +94,11 @@
+           "the output restart file could be defined, exiting.\n");
+   }
+ 
++  init_tcl_pointers();
+ 
+ #ifdef NAMD_TCL
+   have_scripts = true;
+ 
+-  init_tcl_pointers();
+-
+   // See is user-scripted forces are defined
+   if (Tcl_FindCommand(reinterpret_cast<Tcl_Interp *>(tcl_interp_),
+                       "calc_colvar_forces", NULL, 0) == NULL) {

repos/spack_repo/hygon/tsoc/packages/namd/namd-cudalocalrecord-link-fix.patch

+--- a/src/Sequencer.C
++++ b/src/Sequencer.C
+@@ -76,10 +76,8 @@
+ #define __thread __declspec(thread)
+ #endif
+ extern __thread DeviceCUDA *deviceCUDA;
+-#ifdef __IBMCPP__
+-// IBM compiler requires separate definition for static members
++// Required for C++11 toolchains when odr-used.
+ constexpr int CudaLocalRecord::num_inline_peer;
+-#endif
+ #endif
+ 
+ #define SPECIAL_PATCH_ID  91

repos/spack_repo/hygon/tsoc/packages/namd/namd-hiparch-override.patch

+--- a/arch/Linux-x86_64.hip
++++ b/arch/Linux-x86_64.hip
+@@ -15,12 +15,15 @@ endif
+ ROCMV = $(shell export HIP_PLATFORM=$(PLATFORM); $(HIPDIR)/bin/hipconfig -v | cut -d "." -f 1,2 )
+ 
+ ifeq ($(PLATFORM),amd)
+-    # set HIPARCH targets based on ROCMV
+-    ifeq (1,$(shell echo "$(ROCMV) >= 7.1" | bc))
+-        # We're dropping gfx1030 to avoid a rocPRIM issue for now
+-        HIPARCH = "gfx906,gfx908,gfx90a,gfx942,gfx950"
+-    else
+-        HIPARCH = "gfx906,gfx908,gfx90a,gfx1030"
++    # Allow callers (e.g. package managers) to override HIPARCH.
++    # When not provided, keep the original ROCm-version-based defaults.
++    ifeq ($(HIPARCH),)
++        ifeq (1,$(shell echo "$(ROCMV) >= 7.1" | bc))
++            # We're dropping gfx1030 to avoid a rocPRIM issue for now
++            HIPARCH = "gfx906,gfx908,gfx90a,gfx942,gfx950"
++        else
++            HIPARCH = "gfx906,gfx908,gfx90a,gfx1030"
++        endif
+     endif
+ endif
+ 

repos/spack_repo/hygon/tsoc/packages/namd/namd-python38.patch

+diff -Naur spack-src/config spack-src.patched/config
+--- spack-src/config	2020-08-05 13:51:21.000000000 -0400
++++ spack-src.patched/config	2021-12-30 17:59:44.574264378 -0500
+@@ -501,7 +501,12 @@
+       echo "Using $PYTHON_CONFIG to configure Python."
+       PYTHON_PREFIX=$($PYTHON_CONFIG --prefix)
+       PYTHON_INCFLAGS=$($PYTHON_CONFIG --includes)
+-      PYTHON_LDFLAGS=$($PYTHON_CONFIG --ldflags)
++      # Payerle 2021-12-30: python@3.8 python-config omits -lpython unless --embed given
++      # Try first with embed, and if fails, try w/out embed
++      PYTHON_LDFLAGS=$($PYTHON_CONFIG --ldflags --embed)
++      if echo "$PYTHON_LDFLAGS" | grep -q '^Usage'; then
++	      PYTHON_LDFLAGS=$($PYTHON_CONFIG --ldflags)
++      fi
+       if ! echo "$PYTHON_LDFLAGS" | grep -q -- '-L'; then
+         echo "$PYTHON_CONFIG did not return a -L flag: using Anaconda?"
+         if [ -d "$PYTHON_PREFIX/lib" ]; then

repos/spack_repo/hygon/tsoc/packages/namd/package.py

+# Copyright Spack Project Developers. See COPYRIGHT file for details.
+#
+# SPDX-License-Identifier: (Apache-2.0 OR MIT)
+
+import os
+import platform
+import sys
+
+from spack_repo.builtin.build_systems.cuda import CudaPackage
+from spack_repo.builtin.build_systems.makefile import MakefilePackage
+from spack_repo.builtin.build_systems.rocm import ROCmPackage
+
+from spack.package import *
+
+
+class Namd(MakefilePackage, CudaPackage, ROCmPackage):
+    """NAMD is a parallel molecular dynamics code designed for
+    high-performance simulation of large biomolecular systems."""
+
+    homepage = "https://www.ks.uiuc.edu/Research/namd/"
+    url = "file://{0}/NAMD_2.12_Source.tar.gz".format(os.getcwd())
+    git = "https://charm.cs.illinois.edu/gerrit/namd.git"
+    manual_download = True
+    redistribute(source=False, binary=False)
+
+    maintainers("jcphill")
+
+    version("master", branch="master")
+    version("3.0.2", sha256="0916700dec3342165b7ba2c3b5f99dcff767879d2a4931b5028dba47acd68bd5")
+    version("3.0.1", sha256="3be0854545c45e58afb439a96708e127aef435d30113cc89adbab8f4b6888733")
+    version(
+        "2.14",
+        sha256="34044d85d9b4ae61650ccdba5cda4794088c3a9075932392dd0752ef8c049235",
+        preferred=True,
+    )
+    version("2.13", md5="9e3323ed856e36e34d5c17a7b0341e38")
+    version("2.12", md5="2a1191909b1ab03bf0205971ad4d8ee9")
+
+    variant(
+        "fftw",
+        default="3",
+        values=("none", "2", "3", "mkl", "amdfftw"),
+        description="Enable the use of FFTW/FFTW3/MKL FFT/AMDFFTW",
+    )
+
+    variant(
+        "interface",
+        default="tcl",
+        values=("none", "tcl", "python"),
+        description="Enables Tcl and/or python interface",
+    )
+
+    variant(
+        "avxtiles",
+        when="target=x86_64_v4: @2.15:",
+        default=False,
+        description="Enable avxtiles supported with NAMD 2.15+",
+    )
+    variant("single_node_gpu", default=False, description="Single node GPU")
+
+    # Adding memopt variant to build memory-optimized mode that utilizes a compressed
+    # version of the molecular structure and also supports parallel I/O.
+    # Refer: https://www.ks.uiuc.edu/Research/namd/wiki/index.cgi?NamdMemoryReduction
+    variant(
+        "memopt",
+        when="@2.8:",
+        default=False,
+        description="Enable memory-optimized build supported with NAMD 2.8+",
+    )
+
+    # init_tcl_pointers() declaration and implementation are inconsistent
+    # "src/colvarproxy_namd.C", line 482: error: inherited member is not
+    # allowed
+    patch("inherited-member-2.13.patch", when="@2.13")
+    patch("inherited-member-2.14.patch", when="@2.14")
+    # Handle change in python-config for python@3.8:
+    patch("namd-python38.patch", when="interface=python ^python@3.8:")
+    # Allow Spack to drive HIP offload targets via HIPARCH.
+    patch("namd-hiparch-override.patch", when="@3.0.2: +rocm")
+    # Fix missing CudaLocalRecord::num_inline_peer symbol with C++11 HIP builds.
+    patch("namd-cudalocalrecord-link-fix.patch", when="@3.0.2: +rocm")
+
+    depends_on("c", type="build")
+    depends_on("cxx", type="build")
+
+    depends_on("charmpp@7.0.0:", when="@3.0:")
+    depends_on("charmpp@6.10.1:6", when="@2.14:2")
+    depends_on("charmpp@6.8.2", when="@2.13")
+    depends_on("charmpp@6.7.1", when="@2.12")
+
+    depends_on("fftw@:2", when="fftw=2")
+    depends_on("fftw@3:", when="fftw=3")
+
+    depends_on("amdfftw", when="fftw=amdfftw")
+
+    depends_on("mkl", when="fftw=mkl")
+
+    depends_on("tcl", when="interface=tcl")
+
+    depends_on("tcl", when="interface=python")
+    depends_on("python", when="interface=python")
+
+    conflicts("+rocm", when="+cuda", msg="NAMD supports only one GPU backend at a time")
+    conflicts("+single_node_gpu", when="~cuda~rocm")
+    conflicts(
+        "+memopt",
+        when="+single_node_gpu",
+        msg="memopt mode is not compatible with GPU-resident builds",
+    )
+
+    # https://www.ks.uiuc.edu/Research/namd/2.12/features.html
+    # https://www.ks.uiuc.edu/Research/namd/2.13/features.html
+    # https://www.ks.uiuc.edu/Research/namd/2.14/features.html
+    depends_on("cuda@6.5.14:7.5.18", when="@2.12 +cuda")
+    depends_on("cuda@8.0.61:", when="@2.13: +cuda")
+
+    def _copy_arch_file(self, lib):
+        config_filename = "arch/{0}.{1}".format(self.arch, lib)
+        if self.arch == "linux-aarch64":
+            copy("arch/Linux-ARM64.{0}".format(lib), config_filename)
+        else:
+            copy("arch/Linux-x86_64.{0}".format(lib), config_filename)
+
+        if lib == "tcl":
+            filter_file(
+                r"-ltcl8\.5", "-ltcl{0}".format(self.spec["tcl"].version.up_to(2)), config_filename
+            )
+
+    def _append_option(self, opts, lib):
+        if lib != "python":
+            self._copy_arch_file(lib)
+        lib_pkg = self[lib]
+        lib_prefix = (
+            lib_pkg.component_prefix if lib_pkg.name == "intel-oneapi-mkl" else lib_pkg.prefix
+        )
+        opts.extend(["--with-{0}".format(lib), "--{0}-prefix".format(lib), lib_prefix])
+
+    @property
+    def arch(self):
+        plat = sys.platform
+        if plat.startswith("linux"):
+            plat = "linux"
+        march = platform.machine()
+        return "{0}-{1}".format(plat, march)
+
+    @property
+    def build_directory(self):
+        return "{0}-spack".format(self.arch)
+
+    def _edit_arch_generic(self, spec, prefix):
+        """Generic arch makefile generation"""
+        m64 = "-m64 " if not spec.satisfies("arch=aarch64:") else ""
+        with working_dir("arch"):
+            with open("{0}.arch".format(self.build_directory), "w") as fh:
+                # this options are take from the default provided
+                # configuration files
+                # https://github.com/UIUC-PPL/charm/pull/2778
+                archopt = microarchitecture_flags(self.spec, "c")
+
+                if self.spec.satisfies("^charmpp@:6.10.1"):
+                    optims_opts = {
+                        "gcc": m64
+                        + "-O3 -fexpensive-optimizations -ffast-math -lpthread "
+                        + archopt,
+                        "intel": "-O2 -ip -qopenmp-simd " + archopt,
+                        "clang": m64 + "-O3 -ffast-math -fopenmp " + archopt,
+                        "aocc": m64 + "-O3 -ffp-contract=fast -ffast-math -fopenmp " + archopt,
+                    }
+                else:
+                    optims_opts = {
+                        "gcc": m64
+                        + "-O3 -fexpensive-optimizations -ffast-math -lpthread "
+                        + archopt,
+                        "intel": "-O2 -ip " + archopt,
+                        "clang": m64 + "-O3 -ffast-math -fopenmp " + archopt,
+                        "aocc": m64 + "-O3 -ffp-contract=fast -ffast-math " + archopt,
+                        "intel-oneapi-compilers": m64
+                        + "-O3 -ffp-contract=fast -ffast-math "
+                        + archopt,
+                    }
+
+                if self.spec.satisfies("+avxtiles"):
+                    optims_opts["aocc"] += " -DNAMD_AVXTILES"
+                    optims_opts["clang"] += " -DNAMD_AVXTILES"
+                    optims_opts["gcc"] += " -DNAMD_AVXTILES"
+                    optims_opts["intel"] += " -DNAMD_AVXTILES"
+                    optims_opts["intel-oneapi-compilers"] += " -DNAMD_AVXTILES -xCORE-AVX512"
+
+                optim_opts = (
+                    optims_opts[self.compiler.name] if self.compiler.name in optims_opts else ""
+                )
+
+                fh.write(
+                    "\n".join(
+                        [
+                            "NAMD_ARCH = {0}".format(self.arch),
+                            "CHARMARCH = {0}".format(self.spec["charmpp"].charmarch),
+                            "CXX = {0.cxx} {0.cxx11_flag}".format(self.compiler),
+                            "CXXOPTS = {0} {1} {2} {3}".format(
+                                " ".join(spec.compiler_flags["cppflags"]),
+                                optim_opts,
+                                " ".join(spec.compiler_flags["cxxflags"]),
+                                " ".join(spec.compiler_flags["ldflags"]),
+                            ),
+                            "CC = {0}".format(self.compiler.cc),
+                            "COPTS = {0} {1} {2} {3}".format(
+                                " ".join(spec.compiler_flags["cppflags"]),
+                                optim_opts,
+                                " ".join(spec.compiler_flags["cflags"]),
+                                " ".join(spec.compiler_flags["ldflags"]),
+                            ),
+                            "EXTRALINKLIBS = {0}".format(" ".join(spec.compiler_flags["ldlibs"])),
+                            "",
+                        ]
+                    )
+                )
+
+    def _edit_arch_target_based(self, spec, prefix):
+        """Try to use target base arch file return True if succeed"""
+        if spec.version < Version("2.14"):
+            return False
+
+        found_special_opt = False
+        with working_dir("arch"):
+            arch_filename = "{0}.arch".format(self.build_directory)
+
+            replace = [
+                [r"^CHARMARCH = .*$", "CHARMARCH = {0}".format(self.spec["charmpp"].charmarch)],
+                [r"^NAMD_ARCH = .*$", "NAMD_ARCH = {0}".format(self.arch)],
+            ]
+
+            # Optimizations for skylake_avx512
+            if (
+                spec.platform == "linux"
+                and self.compiler.name == "intel"
+                and "avx512" in spec.target
+                and spec.target >= "skylake_avx512"
+            ):
+                if spec.version >= Version("2.15") and os.path.exists("Linux-AVX512-icc.arch"):
+                    tty.info("Building binaries with AVX512-tile optimization")
+                    copy("Linux-AVX512-icc.arch", arch_filename)
+                elif spec.version >= Version("2.14") and os.path.exists("Linux-SKX-icc.arch"):
+                    tty.info("Building binaries with Skylake-X AVX512 optimization")
+                    copy("Linux-SKX-icc.arch", arch_filename)
+                else:
+                    return False
+
+                replace.append([r"^CXX = icpc", "CXX = {0}".format(self.compiler.cxx)])
+                replace.append([r"^CC = icc", "CC = {0}".format(self.compiler.cc)])
+                found_special_opt = True
+
+            if found_special_opt:
+                for pattern, replacement in replace:
+                    filter_file(pattern, replacement, arch_filename)
+
+        return found_special_opt
+
+    def _edit_arch(self, spec, prefix):
+        """Try to use target base arch file, if not make generic"""
+        if not self._edit_arch_target_based(spec, prefix):
+            self._edit_arch_generic(spec, prefix)
+
+    def setup_build_environment(self, env):
+        if self.spec.satisfies("@3.0.2: +rocm"):
+            # Avoid leaking external PLATFORM into NAMD's HIP make logic.
+            # A leaked PLATFORM (e.g. linux) can bypass AMD autodetection and
+            # incorrectly inject CUDA defines/headers in ROCm-only builds.
+            env.unset("PLATFORM")
+            rocm_archs = self.spec.variants["amdgpu_target"].value
+            if "none" not in rocm_archs:
+                env.set("HIPARCH", ",".join(rocm_archs))
+
+    def edit(self, spec, prefix):
+        self._edit_arch(spec, prefix)
+
+        self._copy_arch_file("base")
+
+        opts = ["--charm-base", spec["charmpp"].prefix]
+        fftw_version = spec.variants["fftw"].value
+        if fftw_version == "none":
+            opts.append("--without-fftw")
+        elif fftw_version == "mkl":
+            self._append_option(opts, "mkl")
+        elif fftw_version == "amdfftw":
+            self._copy_arch_file("fftw3")
+            opts.extend(["--with-fftw3", "--fftw-prefix", spec["amdfftw"].prefix])
+        else:
+            _fftw = "fftw{0}".format("" if fftw_version == "2" else "3")
+
+            self._copy_arch_file(_fftw)
+            opts.extend(["--with-{0}".format(_fftw), "--fftw-prefix", spec["fftw"].prefix])
+
+        interface_type = spec.variants["interface"].value
+        if interface_type != "none":
+            self._append_option(opts, "tcl")
+
+            if interface_type == "python":
+                self._append_option(opts, "python")
+        else:
+            opts.extend(["--without-tcl", "--without-python"])
+
+        if "+cuda" in spec:
+            self._append_option(opts, "cuda")
+            filter_file(
+                "^CUDADIR=.*$",
+                "CUDADIR={0}".format(spec["cuda"].prefix),
+                join_path("arch", self.arch + ".cuda"),
+            )
+            for cuda_arch in spec.variants["cuda_arch"].value:
+                opts.extend(["--cuda-gencode", f"arch=compute_{cuda_arch},code=sm_{cuda_arch}"])
+
+            if "+single_node_gpu" in spec:
+                opts.extend(["--with-single-node-cuda"])
+
+        if "+rocm" in spec:
+            self._copy_arch_file("hip")
+            opts.append("--with-hip")
+            opts.extend(["--rocm-prefix", os.environ["ROCM_PATH"]])
+
+            if "+single_node_gpu" in spec:
+                opts.extend(["--with-single-node-hip"])
+
+        if spec.satisfies("+memopt"):
+            opts.append("--with-memopt")
+
+        config = Executable("./config")
+
+        config(self.build_directory, *opts)
+
+        # patch Make.config if needed
+        # spack install charmpp straight to prefix
+        # (not to $(CHARMBASE)/$(CHARMARCH))
+        if not os.path.exists(
+            join_path(self.spec["charmpp"].prefix, self.spec["charmpp"].charmarch)
+        ):
+            filter_file(
+                r"^CHARM = \$\(CHARMBASE\)/\$\(CHARMARCH\)",
+                "CHARM = $(CHARMBASE)",
+                join_path(self.build_directory, "Make.config"),
+            )
+
+    def install(self, spec, prefix):
+        with working_dir(self.build_directory):
+            mkdirp(prefix.bin)
+            if spec.version < Version("3"):
+                install("namd2", prefix.bin)
+            else:
+                install("namd3", prefix.bin)
+            install("psfgen", prefix.bin)
+
+            # I'm not sure this is a good idea or if an autoload of the charm
+            # module would not be better.
+            install("charmrun", prefix.bin)