Merge branch 'main' into prune-dangling

Author: ggorman

.github/azure/startVM.ps1

@@ -23,10 +23,7 @@ jobs:
             tag: 'nvidia-nvc'
             # Respect CUDA_VISIBLE_DEVICES set by the runner and hard-limit docker to that device.
             # (--env without value forwards host var; --gpus maps only that device)
-            flag: |
-              --init
-              --env CUDA_VISIBLE_DEVICES
-              --gpus "device=${CUDA_VISIBLE_DEVICES:-all}"
+            flag: --init --env CUDA_VISIBLE_DEVICES --gpus "device=${CUDA_VISIBLE_DEVICES:-all}"
             test: 'tests/test_gpu_openacc.py tests/test_gpu_common.py'
             runner: ["self-hosted", "nvidiagpu"]
 
@@ -55,7 +52,7 @@ jobs:
 
       - name: Set per‑runner variables
         run: |
-          echo "CONTAINER_NAME=testrun-${{ matrix.tag }}-$RUNNER_NAME" >> $GITHUB_ENV
+          echo "CONTAINER_NAME=testrun-${{ matrix.tag }}-${RUNNER_NAME// /_}" >> $GITHUB_ENV
 
       - name: Check event name
         run: echo ${{ github.event_name }}

.github/azure/stopVM.ps1

@@ -81,8 +81,8 @@ jobs:
 
       - name: Set per-runner tags
         run: |
-          echo "DOCKER_IMAGE=${{ matrix.name }}-$RUNNER_NAME" >> $GITHUB_ENV
-          echo "CONTAINER_BASENAME=testrun-${{ matrix.name }}-$RUNNER_NAME" >> $GITHUB_ENV
+          echo "DOCKER_IMAGE=${{ matrix.name }}-${RUNNER_NAME// /_}" >> $GITHUB_ENV
+          echo "CONTAINER_BASENAME=testrun-${{ matrix.name }}-${RUNNER_NAME// /_}" >> $GITHUB_ENV
 
       - name: Build docker image
         run: |

.github/workflows/docker-devito.yml

@@ -36,15 +36,19 @@ If you publish results using Devito, we would be grateful if you would cite the
 ```
 
 Additionally, if you use Devito for distributed runs, you may want to cite the following paper as well:
+
 ```bibtex
 @misc{bisbas2024automatedmpixcodegeneration,
-      title={Automated MPI-X code generation for scalable finite-difference solvers}, 
-      author={George Bisbas and Rhodri Nelson and Mathias Louboutin and Fabio Luporini and Paul H. J. Kelly and Gerard Gorman},
-      year={2024},
-      eprint={2312.13094},
-      archivePrefix={arXiv},
-      primaryClass={cs.DC},
-      url={https://arxiv.org/abs/2312.13094}, 
+  title={Automated MPI-X code generation for scalable finite-difference solvers},
+  author={Bisbas, George and Nelson, Rhodri and Louboutin, Mathias and Luporini, Fabio and Kelly, Paul H.J. and Gorman, Gerard},
+  booktitle={2025 IEEE International Parallel and Distributed Processing Symposium (IPDPS)}, 
+  title={Automated MPI-X Code Generation for Scalable Finite-Difference Solvers}, 
+  year={2025},
+  volume={},
+  number={},
+  pages={689-701},
+  keywords={Codes;Source coding;Parallel processing;Throughput;Mathematical models;Hybrid power systems;DSL;Kernel;Tuning;Finite difference methods;DSLs;finite-difference method;symbolic computation;stencil computation;MPI;distributed-memory parallelism;compilation;high-performance computing;CPUs;GPUs},
+  doi={10.1109/IPDPS64566.2025.00067}
 }
 ```
 

.github/workflows/pytest-gpu.yml

@@ -25,9 +25,7 @@ pinned to specific CPU cores, to get reliable and deterministic results. There
 are several ways to achieve this:
 
 * Through environment variables. All MPI/OpenMP distributions provide a set of
-  environment variables to control process/thread pinning.  Devito also
-  supplies the `set_omp_pinning.sh` program (under `/scripts`), which helps
-  with thread pinning (though, currently, only limited to Intel architectures).
+  environment variables to control process/thread pinning.
 * Through a program such as `numactl` or `taskset`.
 
 If running on a NUMA system, where multiple nodes of CPU cores ("sockets") and
@@ -46,7 +44,7 @@ working set). There are multiple scenarios that are worth considering:
   logical cores are created. This can be changed by setting the OpenMP-standard
   `OMP_NUM_THREADS` environment variable to a different value. When might we
   want to do this?
-  - Unless on a hyperthreads-centerd system, such as an Intel Knights Landing,
+  - Unless on a hyperthreads-centered system, such as an Intel Knights Landing,
     spawning only as many threads as *physical* cores usually results in
     slightly better performance due to less contention for hardware resources.
   - Since, here, we are merely interested in benchmarking, when running on a

CITATION.md

@@ -16,6 +16,7 @@
 from devito import configuration
 from devito.arch.compiler import AOMPCompiler
 from devito.symbolics.inspection import has_integer_args, sympy_dtype
+from devito.symbolics.queries import q_leaf
 from devito.types.basic import AbstractFunction
 from devito.tools import ctypes_to_cstr, dtype_to_ctype, ctypes_vector_mapper
 
@@ -364,7 +365,7 @@ def _print_InlineIf(self, expr):
     def _print_UnaryOp(self, expr, op=None, parenthesize=False):
         op = op or expr._op
         base = self._print(expr.base)
-        if not expr.base.is_Symbol or parenthesize:
+        if not q_leaf(expr.base) or parenthesize:
             base = f'({base})'
         return f'{op}{base}'
 

benchmarks/user/README.md

@@ -37,9 +37,12 @@ def q_comp_acc(expr):
 
 
 def q_leaf(expr):
-    return (expr.is_Atom or
-            expr.is_Indexed or
-            isinstance(expr, extra_leaves))
+    try:
+        return (expr.is_Atom or
+                expr.is_Indexed or
+                isinstance(expr, extra_leaves))
+    except AttributeError:
+        return False
 
 
 def q_indexed(expr):