grace-runtime 0.1.2__tar.gz → 0.1.3__tar.gz

{grace_runtime-0.1.2 → grace_runtime-0.1.3}/CHANGELOG.md

@@ -3,6 +3,37 @@
 Notable changes of grace-runtime, grace-runtime-cuda12 and grace-runtime-rocm6 (they share one version). Each
 release has a section "Changed defaults" when a default behaves differently.
 
+## [0.1.3](https://github.com/ICAMS/grace-runtime/releases/tag/0.1.3) (2026-11-03)
+
+Fixes, and the LAMMPS fork on the current stable LAMMPS.
+
+### Fixed
+
+- macOS: when PyTorch from PyPI is loaded in the same process, two OpenMP runtimes are present and the process used to
+  abort with `OMP: Error #15`. grace-runtime now raises a `RuntimeError` that explains the conflict and how to install
+  PyTorch from conda-forge instead. (Not when `KMP_DUPLICATE_LIB_OK` is set, as with scikit-learn.)
+- Python: setting or unsetting `GRACE_GENERIC_KERNELS` in a running process now takes effect with the next model
+  load on the GPU, with the warning. Before, a GPU model loaded earlier was reused and ran the generic kernels without
+  a warning, or kept them after the variable was unset.
+
+### LAMMPS (`grace-runtime` branch of the LAMMPS fork)
+
+- Based on the stable LAMMPS release of 30 September 2026 (update 1, with Kokkos 5.2.1).
+- `grace/runtime/kk`: GRACE-2L and GRACE-3L with `comm_style tiled` work with the device-side communication of this
+  LAMMPS version.
+- `pace/kk`, `pace/extrapolation/kk`: the keyword `neigh` (`auto`, `shared`, `global`) selects where the short neighbor
+  list is kept on the GPU; with `auto` a list too large for on-chip memory uses global memory with a warning instead
+  of stopping the run. On a CPU backend, the styles no longer leak their per-atom energy and stress arrays.
+- AMD GPUs: the bundled Kokkos is built with `Kokkos_ENABLE_IMPL_HIP_MALLOC_ASYNC=OFF`, so that `chunksize auto` sees
+  the freed GPU memory (with it on, GRACE-3L ran about 10 % slower on MI250X).
+- With Kokkos 5.2.1, GRACE-1L and GRACE-2L-medium run about 2 % slower on an H200 than with the earlier Kokkos.
+
+### Changed defaults
+
+- macOS: two OpenMP runtimes in one process raise a `RuntimeError` (see above).
+- LAMMPS `pace/kk`: a short neighbor list that does not fit on-chip memory runs in global memory with a warning.
+- LAMMPS, AMD GPUs: `Kokkos_ENABLE_IMPL_HIP_MALLOC_ASYNC` is OFF for the bundled Kokkos.
+
 ## [0.1.2](https://github.com/ICAMS/grace-runtime/releases/tag/0.1.2) (2026-11-01)
 
 The early GRACE-1L/2L models, and fast GPU kernels for more GRACE-1L/2L fits.

{grace_runtime-0.1.2 → grace_runtime-0.1.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: grace-runtime
-Version: 0.1.2
+Version: 0.1.3
 Summary: Fast CPU and GPU inference of GRACE and PACE interatomic potentials with ASE, batching and TorchSim
 License: Academic Software License (ASL); bundled third-party code: see THIRD_PARTY_NOTICES.md
 Classifier: License :: Other/Proprietary License

{grace_runtime-0.1.2 → grace_runtime-0.1.3}/docs/lammps.md

@@ -30,7 +30,7 @@ cd lammps
 ## 2. Build
 
 The pair styles are part of the `ML-PACE` package. When CMake configures the build, it downloads grace-runtime
-0.1.2 from GitHub, so the configure step needs network access. It also downloads the ML-PACE library. Pick one of the
+0.1.3 from GitHub, so the configure step needs network access. It also downloads the ML-PACE library. Pick one of the
 three recipes; run each from the `lammps` folder.
 
 ### CPU
@@ -91,6 +91,11 @@ cmake --build build-hip -j 8
 `GPU_TARGETS` names the same target as `Kokkos_ARCH_...` for ROCm's own CMake files, which otherwise warn and choose
 a default target when no GPU is visible (for example on a login node).
 
+The fork builds its bundled Kokkos for HIP with `Kokkos_ENABLE_IMPL_HIP_MALLOC_ASYNC=OFF`. With that option on, memory
+freed by Kokkos stays reserved and is not reported as free, and `chunksize auto` then chooses smaller chunks
+(GRACE-3L runs about 10 % slower). If you build against your own Kokkos (`-D EXTERNAL_KOKKOS=yes`), configure it with
+`-D Kokkos_ENABLE_IMPL_HIP_MALLOC_ASYNC=OFF` too.
+
 On HPE Cray systems (`PrgEnv-amd` with `cray-mpich`), also add `-D GRACE_BLAS=OFF`: the Cray compiler wrappers find
 a BLAS at configure time that `hipcc` does not link, and the link then fails with `undefined symbol: cblas_sgemm`. The
 setting affects only the CPU styles, which then use their built-in matrix product.
@@ -131,10 +136,10 @@ Other AMD GPUs ([GPU backends](backends.md#amd-rocm)):
 
 ### Without network access
 
-Download grace-runtime 0.1.2 on a machine with network access, copy it over and pass its path:
+Download grace-runtime 0.1.3 on a machine with network access, copy it over and pass its path:
 
 ```bash
-git clone --depth 1 -b 0.1.2 https://github.com/ICAMS/grace-runtime.git
+git clone --depth 1 -b 0.1.3 https://github.com/ICAMS/grace-runtime.git
 cmake -S cmake -B build-cpu ... -D LOCAL_GRACE_RUNTIME=$PWD/grace-runtime
 ```
 

{grace_runtime-0.1.2 → grace_runtime-0.1.3}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "scikit_build_core.build"
 
 [project]
 name = "grace-runtime"
-version = "0.1.2"
+version = "0.1.3"
 description = "Fast CPU and GPU inference of GRACE and PACE interatomic potentials with ASE, batching and TorchSim"
 readme = "README.md"
 requires-python = ">=3.10"

grace_runtime-0.1.3/python/grace_runtime/_core.py

@@ -0,0 +1,91 @@
+# SPDX-License-Identifier: LicenseRef-ASL   (Academic Software Licence, see LICENSE.md)
+"""grace_runtime._core: the extension built for this CPU (see ``_dispatch``), re-exported under one name."""
+import functools
+import importlib
+import os
+import sys
+
+from . import _dispatch, registry
+
+cpu_module = _dispatch.select(_dispatch.cpu_flags(), os.environ.get("GRACE_RUNTIME_CPU"), _dispatch.available())
+_ext = importlib.import_module(f"._core_{cpu_module}", __package__)
+globals().update({k: v for k, v in vars(_ext).items() if not k.startswith("__")})
+
+
+def _openmp_libraries() -> list:
+    """the OpenMP runtime files loaded in this process (macOS)"""
+    import ctypes
+    dyld = ctypes.CDLL(None)
+    dyld._dyld_get_image_name.restype = ctypes.c_char_p
+    names = (os.fsdecode(dyld._dyld_get_image_name(i) or b"") for i in range(dyld._dyld_image_count()))
+    return sorted({os.path.realpath(n) for n in names if os.path.basename(n) in ("libomp.dylib", "libiomp5.dylib")})
+
+
+def _kmp_true(value: str) -> bool:
+    """libomp's __kmp_str_match_true: whether it reads `value` as true (KMP_DUPLICATE_LIB_OK)"""
+    value = value.lower()
+
+    def match(word, n):    # __kmp_str_match: equal up to the shorter end, and at least n characters (n = 0: all)
+        i = len(os.path.commonprefix([word, value]))
+        if i < min(len(word), len(value)):
+            return False
+        return i >= n if n else i == len(word) == len(value)
+    return any(match(w, n) for w, n in (("true", 1), ("on", 2), ("1", 1), (".true.", 2), (".t.", 2), ("yes", 1),
+                                        ("enable", 0)))
+
+
+@functools.cache    # once it passed; a failure is checked again
+def _check_openmp():
+    """macOS, before our first OpenMP call: two OpenMP runtimes in one process (PyTorch from PyPI ships its own) abort it
+    with "OMP: Error #15" when the second starts, unless KMP_DUPLICATE_LIB_OK is set (scikit-learn sets it); raise
+    instead. A runtime loaded after ours has started aborts in its own library (e.g. import torch), out of our reach."""
+    libs = _openmp_libraries()
+    if len(libs) > 1 and not _kmp_true(os.environ.get("KMP_DUPLICATE_LIB_OK", "")):
+        raise RuntimeError(f"two OpenMP runtimes in this process ({', '.join(libs)}): the process would abort with "
+                           "'OMP: Error #15'. PyTorch from PyPI ships its own on macOS: install PyTorch from conda-forge "
+                           "instead, which shares one runtime with grace-runtime; a source build in a conda environment: "
+                           "build it with that environment activated (see the macOS section of the installation docs)")
+
+
+def _after_openmp_check(fn):
+    @functools.wraps(fn)
+    def call(*args, **kwargs):
+        _check_openmp()
+        return fn(*args, **kwargs)
+    return call
+
+
+class Model(_ext.Model):
+    """A loaded GRACE kokkos.npz or PACE .yaml model on the host, shared across calculators and batch calls.
+
+    path: a model file (GRACE kokkos.npz or PACE pacemaker B-basis .yaml) or a registry name (downloaded once into the
+        cache); a path with a directory, .npz or .yaml / .yml is never looked up in the registry. A PACE .yaml is
+        converted to its C-tilde basis on the fly when loaded.
+    spline: intervals of the radial tables (default 1024) on CPU and GPU; for PACE models also 0 (direct radial
+        evaluation).
+    store_max_gb: CPU limit in GB for keeping per-atom forward tensors of GRACE-2L / 3L (~64 KB/atom for
+        GRACE-2L-OMAT-medium); above it the backward pass recomputes them (same results, ~10% slower, warns once).
+        Default None: half the available host memory, within the memory limit of the job (e.g. Slurm --mem).
+    asi: active-set file (pacemaker .asi) of a PACE .yaml, enabling the extrapolation grade gamma (uq=True).
+    """
+
+    def __init__(self, path, *args, asi=None, **kwargs):
+        path = os.fspath(path)
+        if asi is not None:
+            asi = os.fspath(asi)
+            if not path.endswith((".yaml", ".yml")):
+                raise ValueError("asi= goes with a PACE .yaml")
+        elif os.sep not in path and not path.endswith((".npz", ".yaml", ".yml")):
+            path = registry.resolve(path)
+        super().__init__(path, *args, **({} if asi is None else {"asi": asi}), **kwargs)
+
+
+if sys.platform == "darwin":    # any call into the extension may start our OpenMP runtime: check before the first
+    for _k, _v in vars(_ext).items():
+        if callable(_v) and not _k.startswith("__") and not isinstance(_v, type):
+            globals()[_k] = _after_openmp_check(_v)
+    for _k, _v in vars(_ext.Model).items():
+        if callable(_v) and not _k.startswith("__"):
+            setattr(Model, _k, _after_openmp_check(_v))
+    Model.__init__ = _after_openmp_check(Model.__init__)
+    del _k, _v

{grace_runtime-0.1.2 → grace_runtime-0.1.3}/python/grace_runtime/calculator.py

@@ -16,7 +16,7 @@ from ._core import Model
 from .dispersion import resolve as _resolve_dispersion
 from .neighbors import NeighborList, _padded_cell, check_skin
 
-_KK_MODELS = {}    # path -> GPU model (weights loaded once per process)
+_KK_MODELS = {}    # _kk_model_key -> GPU model (weights loaded once per process)
 _KK_LOCK = threading.Lock()    # guards _KK_MODELS and grace_runtime.batch's Batch cache
 _KK_CALCS = weakref.WeakSet()    # live GPU calculators (grace_runtime.free_gpu_memory() returns their buffers)
 _STORE_WARNED = set()    # model paths whose CPU reverse pass recomputes instead of storing (warned once per model)
@@ -71,8 +71,11 @@ def _cpu_fallback(why: str):
 
 
 def _kk_model_key(model) -> str:
+    """GRACE_GENERIC_KERNELS is part of the key: a GPU model sets up its engine (and warns) for the value at its load"""
     asi = getattr(model, "asi", None)
-    return f"{model.path}\0{asi}" if asi else model.path
+    key = f"{model.path}\0{asi}" if asi else model.path
+    generic = os.environ.get("GRACE_GENERIC_KERNELS")
+    return f"{key}\0{generic}" if generic is not None else key
 
 
 def _load_kk_model(kk, model):

{grace_runtime-0.1.2 → grace_runtime-0.1.3}/python/tests/test_auto_device.py

@@ -50,16 +50,25 @@ def test_environment_overrides_auto(monkeypatch):
 
 
 @pytest.mark.skipif(not UNSUPPORTED.exists(), reason="unsupported test model absent")
-def test_auto_falls_back_for_a_model_outside_the_fused_kernels(monkeypatch):
+def test_auto_stays_on_the_gpu_for_a_model_outside_the_compiled_kernels(monkeypatch):
+    """a GRACE-2L model wider than every compiled width set: "auto" raises (naming GRACE_GENERIC_KERNELS=1) instead of
+    taking the CPU; with the variable it runs the model on the generic GPU kernels, with a warning, as the CPU"""
     monkeypatch.delenv("GRACE_RUNTIME_DEVICE", raising=False)
-    with pytest.warns(RuntimeWarning, match="fused GPU kernels"):
-        calc = GRACERuntimeCalculator(str(UNSUPPORTED))
-    assert calc.backend == "cpu"
-    with pytest.raises(ValueError, match=f"not supported on device='{PLATFORM}'"):
+    monkeypatch.delenv("GRACE_GENERIC_KERNELS", raising=False)
+    with pytest.raises(ValueError, match="GRACE_GENERIC_KERNELS=1"):
+        GRACERuntimeCalculator(str(UNSUPPORTED))
+    with pytest.raises(ValueError, match="GRACE_GENERIC_KERNELS=1"):
         GRACERuntimeCalculator(str(UNSUPPORTED), device=GPU).get_potential_energy(wmo54())
-    with pytest.warns(RuntimeWarning, match="fused GPU kernels"):
-        r = compute_batch(str(UNSUPPORTED), [wmo54()])
-    assert "energy" in r[0]
+    with pytest.raises(ValueError, match="GRACE_GENERIC_KERNELS=1"):
+        compute_batch(str(UNSUPPORTED), [wmo54()])
+    monkeypatch.setenv("GRACE_GENERIC_KERNELS", "1")
+    at, ref = wmo54(), wmo54()
+    with pytest.warns(RuntimeWarning, match="generic GPU kernels"):
+        at.calc = GRACERuntimeCalculator(str(UNSUPPORTED))
+    assert at.calc.backend.startswith(PLATFORM + ":"), at.calc.backend
+    ref.calc = GRACERuntimeCalculator(str(UNSUPPORTED), device="cpu")
+    assert abs(at.get_potential_energy() - ref.get_potential_energy()) <= 1e-5 * len(at)
+    assert np.abs(at.get_forces() - ref.get_forces()).max() <= 1e-4
 
 
 def test_auto_falls_back_without_a_module_for_the_gpu():

grace_runtime-0.1.3/python/tests/test_openmp_check.py

@@ -0,0 +1,66 @@
+# SPDX-License-Identifier: LicenseRef-ASL   (Academic Software Licence, see LICENSE.md)
+"""macOS: a second OpenMP runtime in the process (PyTorch from PyPI) gives a RuntimeError at our first call into the
+extension instead of the abort "OMP: Error #15"; the libraries loaded are faked here."""
+import sys
+
+import numpy as np
+import pytest
+
+from grace_runtime import _core
+
+TWO = ["/env/lib/libomp.dylib", "/env/lib/python3.12/site-packages/torch/lib/libomp.dylib"]
+macos = pytest.mark.skipif(sys.platform != "darwin", reason="the OpenMP check runs on macOS only")
+
+
+@pytest.fixture
+def unchecked(monkeypatch):
+    _core._check_openmp.cache_clear()
+    monkeypatch.delenv("KMP_DUPLICATE_LIB_OK", raising=False)
+    yield monkeypatch
+    _core._check_openmp.cache_clear()
+
+
+def test_two_runtimes_raise(unchecked):
+    unchecked.setattr(_core, "_openmp_libraries", lambda: TWO)
+    for _ in range(2):    # a failure is checked again
+        with pytest.raises(RuntimeError, match="two OpenMP runtimes .*torch/lib/libomp.dylib.*conda-forge"):
+            _core._check_openmp()
+
+
+@pytest.mark.parametrize("libs, env", [(TWO[:1], None), ([], None), (TWO, "True"), (TWO, "1"), (TWO, "y")])
+def test_one_runtime_or_duplicates_allowed(unchecked, libs, env):
+    unchecked.setattr(_core, "_openmp_libraries", lambda: libs)
+    if env:
+        unchecked.setenv("KMP_DUPLICATE_LIB_OK", env)    # libomp does not abort then (scikit-learn sets it)
+    _core._check_openmp()
+    unchecked.setattr(_core, "_openmp_libraries", lambda: TWO)
+    unchecked.delenv("KMP_DUPLICATE_LIB_OK", raising=False)
+    _core._check_openmp()    # checked once: a runtime loaded after ours has started is out of reach
+
+
+@pytest.mark.parametrize("value, true", [("TRUE", True), ("t", True), ("tr", True), ("on", True), ("o", False),
+                                         ("1", True), (".TRUE.", True), (".t.", True), ("y", True), ("enable", True),
+                                         ("enabl", False), ("", False), ("0", False), ("false", False), ("no", False)])
+def test_kmp_true_reads_values_as_libomp(value, true):
+    assert _core._kmp_true(value) is true
+
+
+@macos
+def test_every_call_into_the_extension_checks(unchecked, models):
+    unchecked.setattr(_core, "_openmp_libraries", lambda: TWO)
+    with pytest.raises(RuntimeError, match="two OpenMP runtimes"):
+        _core.neighbor_search(np.zeros((1, 3)), np.eye(3) * 5, np.ones(3, dtype=bool), 3.0)
+    unchecked.setattr(_core, "_openmp_libraries", lambda: TWO[:1])
+    model = _core.Model(models["3l"])    # GRACE-3L: cutoff_matrix starts OpenMP (the network tables)
+    _core._check_openmp.cache_clear()
+    unchecked.setattr(_core, "_openmp_libraries", lambda: TWO)
+    with pytest.raises(RuntimeError, match="two OpenMP runtimes"):
+        model.cutoff_matrix(["W"])
+    for k, v in [*vars(_core._ext).items(), *vars(_core._ext.Model).items()]:
+        if callable(v) and not k.startswith("__") and not isinstance(v, type):
+            assert getattr(_core.Model if k in vars(_core._ext.Model) else _core, k).__wrapped__ is v, k
+
+
+@macos
+def test_the_loaded_runtime_is_found():
+    assert len(_core._openmp_libraries()) == 1

{grace_runtime-0.1.2 → grace_runtime-0.1.3}/python-cuda/pyproject.toml

@@ -4,13 +4,13 @@ build-backend = "scikit_build_core.build"
 
 [project]
 name = "grace-runtime-cuda12"
-version = "0.1.2"    # = grace-runtime (scripts/build_cuda_wheels.sh sets both from the repository pyproject)
+version = "0.1.3"    # = grace-runtime (scripts/build_cuda_wheels.sh sets both from the repository pyproject)
 description = "NVIDIA GPU backend (CUDA 12) of grace-runtime: fused GRACE-1L/2L/3L Kokkos kernels for V100, RTX 20xx/30xx/40xx/50xx, A100/A30, L40S, H100/H200, B200/B300"
 readme = "README.md"
 requires-python = ">=3.10"
 license = { text = "Academic Software License (ASL); bundled third-party code (Kokkos: Apache-2.0 WITH LLVM-exception): see THIRD_PARTY_NOTICES.md" }
 classifiers = ["License :: Other/Proprietary License"]
-dependencies = ["grace-runtime==0.1.2"]
+dependencies = ["grace-runtime==0.1.3"]
 
 [project.urls]
 Homepage = "https://github.com/ICAMS/grace-runtime"

grace_runtime-0.1.2/python/grace_runtime/_core.py

@@ -1,35 +0,0 @@
-# SPDX-License-Identifier: LicenseRef-ASL   (Academic Software Licence, see LICENSE.md)
-"""grace_runtime._core: the extension built for this CPU (see ``_dispatch``), re-exported under one name."""
-import importlib
-import os
-
-from . import _dispatch, registry
-
-cpu_module = _dispatch.select(_dispatch.cpu_flags(), os.environ.get("GRACE_RUNTIME_CPU"), _dispatch.available())
-_ext = importlib.import_module(f"._core_{cpu_module}", __package__)
-globals().update({k: v for k, v in vars(_ext).items() if not k.startswith("__")})
-
-
-class Model(_ext.Model):
-    """A loaded GRACE kokkos.npz or PACE .yaml model on the host, shared across calculators and batch calls.
-
-    path: a model file (GRACE kokkos.npz or PACE pacemaker B-basis .yaml) or a registry name (downloaded once into the
-        cache); a path with a directory, .npz or .yaml / .yml is never looked up in the registry. A PACE .yaml is
-        converted to its C-tilde basis on the fly when loaded.
-    spline: intervals of the radial tables (default 1024) on CPU and GPU; for PACE models also 0 (direct radial
-        evaluation).
-    store_max_gb: CPU limit in GB for keeping per-atom forward tensors of GRACE-2L / 3L (~64 KB/atom for
-        GRACE-2L-OMAT-medium); above it the backward pass recomputes them (same results, ~10% slower, warns once).
-        Default None: half the available host memory, within the memory limit of the job (e.g. Slurm --mem).
-    asi: active-set file (pacemaker .asi) of a PACE .yaml, enabling the extrapolation grade gamma (uq=True).
-    """
-
-    def __init__(self, path, *args, asi=None, **kwargs):
-        path = os.fspath(path)
-        if asi is not None:
-            asi = os.fspath(asi)
-            if not path.endswith((".yaml", ".yml")):
-                raise ValueError("asi= goes with a PACE .yaml")
-        elif os.sep not in path and not path.endswith((".npz", ".yaml", ".yml")):
-            path = registry.resolve(path)
-        super().__init__(path, *args, **({} if asi is None else {"asi": asi}), **kwargs)