[Only for CI] Extensions #9848

Workflow file for this run

.github/workflows/general-ci.yml at d01bb89

	name: General Tests

	on:
	push:
	branches: [ main, ci-fix ]
	pull_request:
	branches: [ main, ci-fix ]
	merge_group:
	branches: [ main, ci-fix ]

	env:
	# Unpinned, string-keyed set iteration order changes per run, and with it transformation order
	# and codegen -- a red that reproduces on one runner and not the next is undebuggable.
	PYTHONHASHSEED: '0'
	UV_FROZEN: 1 # sync without updating uv.lock
	UV_NO_DEV: 1 # don't install dev dependency group by default

	concurrency:
	group: ${{github.workflow}}-${{github.ref}}
	cancel-in-progress: true

	jobs:
	test:
	if: "!contains(github.event.pull_request.labels.*.name, 'no-ci')"
	runs-on: ubuntu-latest
	timeout-minutes: 120
	strategy:
	fail-fast: false
	matrix:
	python-version: ['3.14']
	simplify: [0,1,autoopt]

	steps:
	- uses: actions/checkout@v7
	with:
	submodules: 'recursive'
	- uses: ./.github/actions/setup-dace
	with:
	python-version: ${{ matrix.python-version }}
	# cBLAS / LAPACK / FFTW3 / PAPI.
	# g++-aarch64-linux-gnu: aarch64 cross C++ toolchain (driver + libstdc++/glibc
	# sysroot) for the NEON/SVE -fsyntax-only intrinsic-header tests in
	# tests/passes/vectorization/intrinsics/test_horizontal_reduce_header.py. Without
	# it those tests skip (the host is x86_64; clang alone can't supply an aarch64
	# standard-library sysroot).
	# libfftw3-dev: FFTW3 headers for the few unmarked tests that lower FFT nodes; the
	# backend-marked FFT/BLAS suites themselves run in the libnode job.
	apt-packages: >-
	libyaml-dev cmake
	libblas-dev libopenblas-dev liblapacke-dev liblapack-dev libfftw3-dev
	libpapi-dev papi-tools g++-aarch64-linux-gnu
	pip-packages: flake8 pytest-xdist coverage
	codecov: 'true'

	- name: Test dependencies
	run: \|
	uv run papi_avail

	- name: Test with pytest
	run: \|
	export NOSTATUSBAR=1
	ulimit -s 65536 \|\| true
	export OMP_STACKSIZE=64M
	export DACE_compiler_max_stack_array_size=65536
	export DACE_testing_serialization=1
	export DACE_testing_deserialize_exception=1
	export DACE_cache=unique
	if [ "${{ matrix.simplify }}" = "autoopt" ]; then
	export DACE_optimizer_automatic_simplification=1
	export DACE_optimizer_autooptimize=1
	echo "Auto-optimization heuristics"
	else
	export DACE_optimizer_automatic_simplification=${{ matrix.simplify }}
	fi
	# idxalg is an optional out-of-tree symbolic backend; its seam tests stay in the repo but do not run here.
	# --ignore=tests/library: the library-node tree (marked and unmarked) runs once in the
	# libnode-loop2x-transformations job instead of once per matrix cell here.
	pytest -n auto --cov-report=xml --cov=dace --tb=short --timeout_method thread --timeout=300 --ignore=tests/symbolic/optional_idxalg_backend_test.py --ignore=tests/library -m "not gpu and not autodiff and not torch and not onnx and not tensorflow and not mkl and not openblas and not sve and not papi and not mlir and not lapack and not tblis and not mpi and not scalapack and not datainstrument and not long and not integration and not sequential and not vectorization and not canonicalization and not corpus and not loop2x_libnodes and not layout"
	./codecov

	- name: Run sequential tests
	run: \|
	export NOSTATUSBAR=1
	ulimit -s 65536 \|\| true
	export OMP_STACKSIZE=64M
	export DACE_compiler_max_stack_array_size=65536
	export DACE_testing_serialization=1
	export DACE_testing_deserialize_exception=1
	export DACE_cache=unique
	if [ "${{ matrix.simplify }}" = "autoopt" ]; then
	export DACE_optimizer_automatic_simplification=1
	export DACE_optimizer_autooptimize=1
	echo "Auto-optimization heuristics"
	else
	export DACE_optimizer_automatic_simplification=${{ matrix.simplify }}
	fi
	# The dedicated-runner markers are excluded here for the same reason they are excluded from
	# the general selection above: those suites have their own workflows, with their own
	# configuration. A test carrying both `sequential` and one of them would otherwise run here
	# under general CI's settings rather than under the ones its own workflow sets.
	uv run pytest -n 1 --cov-report=xml --cov=dace --tb=short --timeout_method thread --timeout=300 -m "sequential and not vectorization and not canonicalization and not corpus and not loop2x_libnodes and not layout"
	./codecov

	- name: Run other tests
	run: \|
	export NOSTATUSBAR=1
	ulimit -s 65536 \|\| true
	export OMP_STACKSIZE=64M
	export DACE_compiler_max_stack_array_size=65536
	export DACE_testing_serialization=0
	export DACE_testing_deserialize_exception=1
	export DACE_cache=single
	export DACE_optimizer_automatic_simplification=${{ matrix.simplify }}
	export PYTHON_BINARY="coverage run --source=dace --parallel-mode"
	./tests/xform_test.sh
	uv run coverage combine .; uv run coverage report; uv run coverage xml

	- uses: codecov/codecov-action@v6
	with:
	token: ${{ secrets.CODECOV_TOKEN }}
	verbose: true

	# --- Canonicalization (was canonicalization-ci.yml) ---
	canonicalization:
	if: "!contains(github.event.pull_request.labels.*.name, 'no-ci')"
	runs-on: ubuntu-latest
	timeout-minutes: 90

	steps:
	- uses: actions/checkout@v7
	with:
	submodules: 'recursive'
	- uses: ./.github/actions/setup-dace
	with:
	python-version: '3.14'
	apt-packages: >-
	libyaml-dev cmake
	libblas-dev libopenblas-dev liblapacke-dev liblapack-dev
	pip-packages: pytest-xdist
	groups: testing

	- name: Test with pytest
	run: \|
	export NOSTATUSBAR=1
	ulimit -s 65536 \|\| true
	export OMP_STACKSIZE=64M
	export OMP_NUM_THREADS=4
	export DACE_compiler_max_stack_array_size=65536
	export DACE_cache=unique
	# New codegens only; no autoopt, no serialization round-trip.
	export DACE_compiler_cpu_implementation=experimental_readable
	export DACE_compiler_cuda_implementation=experimental
	export DACE_optimizer_automatic_simplification=1
	# Pinned, not left to the defaults: build caching is most of the wall time here.
	export DACE_compiler_command_cache=1
	export DACE_compiler_precompiled_header=1
	# loadgroup, not the default load: corpus cases carry xdist_group(kernel) so one kernel's
	# phases land on one worker and share its memoized base SDFG instead of rebuilding per worker.
	# ``not integration``: tests/canonicalize also holds three whole-application harnesses that
	# take far longer than the 600s per-test cap here (the staged CloudSC walk builds and
	# verifies the kernel once per phase; the determinism probe spawns a 1800s subprocess; the A/B
	# map-count scratch parses CloudSC from scratch on a cache miss). They are marked
	# ``integration`` and run in the dedicated integration workflow, which budgets 7200s per test.
	pytest -n auto --dist loadgroup --tb=short --timeout_method thread --timeout=600 \
	-m "canonicalization and not gpu and not long and not sequential and not perf and not integration"
	# The sequential members of this marker run here too, one at a time. General CI no longer
	# selects them (its own selection excludes this marker), so without this leg a test that is
	# both `canonicalization` and `sequential` would run nowhere. Exit status 5 is pytest for
	# "nothing matched", which is the expected outcome while no such test exists.
	pytest -n 1 --tb=short --timeout_method thread --timeout=600 \
	-m "canonicalization and sequential and not gpu and not long and not perf and not integration" \
	\|\| [ $? -eq 5 ]

	# --- Vectorization (was vectorization-ci.yml) ---
	vectorization:
	if: "!contains(github.event.pull_request.labels.*.name, 'no-ci')"
	runs-on: ubuntu-latest
	timeout-minutes: 90

	strategy:
	fail-fast: false
	matrix:
	include:
	- cell: canon-vectorization-npbench
	# The vectorization unit tests plus the npbench / polybench canonicalize-then-vectorize
	# corpora -- everything except the two TSVC corpora, which are cell 2.
	paths: >-
	tests/passes/vectorization
	--ignore=tests/passes/vectorization/tsvc_canonicalize_vectorize_corpus_test.py
	--ignore=tests/passes/vectorization/tsvc_2_5_canonicalize_vectorize_corpus_test.py
	- cell: canon-vectorization-tsvc
	paths: >-
	tests/passes/vectorization/tsvc_canonicalize_vectorize_corpus_test.py
	tests/passes/vectorization/tsvc_2_5_canonicalize_vectorize_corpus_test.py

	name: ${{ matrix.cell }}

	steps:
	- uses: actions/checkout@v7
	with:
	submodules: 'recursive'
	- uses: ./.github/actions/setup-dace
	with:
	python-version: '3.14'
	apt-packages: >-
	libyaml-dev cmake
	libblas-dev libopenblas-dev liblapacke-dev liblapack-dev
	g++-aarch64-linux-gnu
	pip-packages: pytest-xdist
	groups: testing

	- name: Test with pytest
	run: \|
	export NOSTATUSBAR=1
	ulimit -s 65536 \|\| true
	export OMP_STACKSIZE=64M
	export OMP_NUM_THREADS=4
	export DACE_compiler_max_stack_array_size=65536
	export DACE_cache=unique
	# New codegens only; no autoopt, no serialization round-trip.
	export DACE_compiler_cpu_implementation=experimental_readable
	export DACE_compiler_cuda_implementation=experimental
	export DACE_optimizer_automatic_simplification=1
	# Pinned, not left to the defaults: build caching is most of the wall time here.
	export DACE_compiler_command_cache=1
	export DACE_compiler_precompiled_header=1
	# loadgroup, not the default load: corpus cases carry xdist_group(kernel) so one kernel's
	# phases land on one worker and share its memoized base SDFG instead of rebuilding per worker.
	pytest ${{ matrix.paths }} \
	-n auto --dist loadgroup --tb=short --timeout_method thread --timeout=600 \
	-m "vectorization and not gpu and not long and not sequential and not perf and not avx512 and not arm_cross"
	# The sequential members of this marker run here too, one at a time. General CI no longer
	# selects them (its own selection excludes this marker), so without this leg a test that is
	# both `vectorization` and `sequential` would run nowhere. Exit status 5 is pytest for
	# "nothing matched", which is the expected outcome while no such test exists.
	pytest ${{ matrix.paths }} -n 1 --tb=short --timeout_method thread --timeout=600 \
	-m "vectorization and sequential and not gpu and not long and not perf and not avx512 and not arm_cross" \
	\|\| [ $? -eq 5 ]

	# --- Corpus (was corpus-ci.yml) ---
	corpus:
	if: "!contains(github.event.pull_request.labels.*.name, 'no-ci')"
	runs-on: ubuntu-latest
	timeout-minutes: 90

	steps:
	- uses: actions/checkout@v7
	with:
	submodules: 'recursive'
	- uses: ./.github/actions/setup-dace
	with:
	python-version: '3.14'
	apt-packages: >-
	libyaml-dev cmake
	libblas-dev libopenblas-dev liblapacke-dev liblapack-dev
	pip-packages: pytest-xdist
	groups: testing

	- name: Test with pytest
	run: \|
	export NOSTATUSBAR=1
	ulimit -s 65536 \|\| true
	export OMP_STACKSIZE=64M
	export DACE_compiler_max_stack_array_size=65536
	export DACE_cache=unique
	# Pinned, not left to the defaults: nearly every case compiles, so build caching is most of
	# the wall time here.
	export DACE_compiler_command_cache=1
	export DACE_compiler_precompiled_header=1
	pytest -n auto --tb=short --timeout_method thread --timeout=600 \
	-m "corpus and not gpu and not long and not sequential and not perf and not mpi"
	# The sequential members of this marker run here too, one at a time. General CI no longer
	# selects them (its own selection excludes this marker), so without this leg a test that is
	# both `corpus` and `sequential` would run nowhere. Exit status 5 is pytest for
	# "nothing matched", which is the expected outcome while no such test exists.
	pytest -n 1 --tb=short --timeout_method thread --timeout=600 \
	-m "corpus and sequential and not gpu and not long and not perf and not mpi" \
	\|\| [ $? -eq 5 ]

	# --- Library nodes + loop-to-libnode lifts (was loop2x-libnodes-ci.yml) ---
	libnode-loop2x-transformations:
	name: LibNodes + LoopToLibNodeLifts
	if: "!contains(github.event.pull_request.labels.*.name, 'no-ci')"
	runs-on: ubuntu-latest
	timeout-minutes: 90

	steps:
	- uses: actions/checkout@v7
	with:
	submodules: 'recursive'
	- uses: ./.github/actions/setup-dace
	with:
	python-version: '3.14'
	# libfftw3-dev: the FFT lowering tests in this suite include ``fftw3.h``. The
	# ``fft_interpolate_*`` cases are not ``fftw``-marked, so this runner is their only home
	# -- without the package they are permanently red rather than skipped.
	apt-packages: >-
	libyaml-dev cmake
	libblas-dev libopenblas-dev liblapacke-dev liblapack-dev libfftw3-dev
	pip-packages: pytest-xdist
	groups: testing

	- name: Install Intel oneAPI MKL
	# The Syrk / Symm nodes are parametrized over the ``MKL`` implementation, whose expansion
	# includes ``mkl.h``; without the dev meta-package those cases fail to compile. The
	# ``mkl``-marked per-routine BLAS suites run here too (moved out of General Tests, where
	# they repeated per matrix cell).
	run: \|
	wget -qO- https://apt.repos.intel.com/intel-gpg-keys/GPG-PUB-KEY-INTEL-SW-PRODUCTS.PUB \
	\| gpg --dearmor \| sudo tee /usr/share/keyrings/oneapi-archive-keyring.gpg > /dev/null
	echo "deb [signed-by=/usr/share/keyrings/oneapi-archive-keyring.gpg] https://apt.repos.intel.com/oneapi all main" \
	\| sudo tee /etc/apt/sources.list.d/oneAPI.list
	sudo apt-get update
	sudo apt-get install -y intel-oneapi-mkl intel-oneapi-mkl-devel

	- name: Build TBLIS
	# TBLIS has no apt package; build the shared library from source and point ``TBLIS_ROOT``
	# at it. Serves the ``tblis``-marked TensorDot tests, moved here from General Tests where
	# this source build repeated once per matrix cell.
	run: \|
	sudo apt-get install -y libhwloc-dev
	git clone --depth 1 --recursive https://github.com/MatthewsResearchGroup/tblis.git /tmp/tblis
	cmake -S /tmp/tblis -B /tmp/tblis/build -DCMAKE_INSTALL_PREFIX=/usr/local
	cmake --build /tmp/tblis/build -j"$(nproc)"
	sudo cmake --install /tmp/tblis/build
	sudo ldconfig

	- name: Test with pytest
	run: \|
	# ``MKLROOT`` for the expansion's include/link paths, ``LD_LIBRARY_PATH`` for loading
	# libmkl_rt at run time. Must be sourced in the step that runs pytest -- env does not
	# carry across steps.
	source /opt/intel/oneapi/setvars.sh \|\| true
	# setvars puts Intel's OpenMP runtime on the load path next to libgomp, which the
	# generated kernels are built against. Two runtimes in one process partition a
	# parallel loop against different team sizes and silently drop iterations; MKL on
	# libgomp keeps one runtime.
	export MKL_THREADING_LAYER=GNU
	export NOSTATUSBAR=1
	ulimit -s 65536 \|\| true
	export OMP_STACKSIZE=64M
	export DACE_compiler_max_stack_array_size=65536
	export DACE_cache=unique
	# Pinned, not left to the defaults: every case here compiles, so build caching is most of
	# the wall time.
	export DACE_compiler_command_cache=1
	export DACE_compiler_precompiled_header=1
	pytest -n auto --tb=short --timeout_method thread --timeout=600 \
	-m "loop2x_libnodes and not gpu and not long and not sequential and not perf and not mpi and not tblis"
	# The sequential members of this marker run here too, one at a time. General CI no longer
	# selects them (its own selection excludes this marker), so without this leg a test that is
	# both `loop2x_libnodes` and `sequential` would run nowhere. Exit status 5 is pytest for
	# "nothing matched", which is the expected outcome while no such test exists.
	pytest -n 1 --tb=short --timeout_method thread --timeout=600 \
	-m "loop2x_libnodes and sequential and not gpu and not long and not perf and not mpi and not tblis" \
	\|\| [ $? -eq 5 ]

	- name: Library-node backend suites
	# The ``lapack`` / ``openblas`` / ``mkl`` / ``fftw`` / ``tblis`` suites, moved from General
	# Tests: they exercise library-node backends, not the optimizer, so one cell here replaces
	# six matrix repetitions there (including a TBLIS source build per cell). ``lapack`` keeps
	# its historical ``-n 1``. ``not loop2x_libnodes`` avoids re-running the Syrk/Symm
	# parametrizations the step above already covers.
	run: \|
	source /opt/intel/oneapi/setvars.sh \|\| true
	export MKL_THREADING_LAYER=GNU
	export TBLIS_ROOT=/usr/local
	export NOSTATUSBAR=1
	ulimit -s 65536 \|\| true
	export OMP_STACKSIZE=64M
	export DACE_compiler_max_stack_array_size=65536
	export DACE_cache=unique
	export DACE_testing_serialization=1
	export DACE_testing_deserialize_exception=1
	export DACE_compiler_command_cache=1
	export DACE_compiler_precompiled_header=1
	pytest -n 1 --tb=short --timeout_method thread --timeout=300 -m "lapack"
	# The whole library-node test tree, marked and unmarked -- General Tests ignores it now.
	pytest tests/library -n auto --tb=short --timeout_method thread --timeout=600 \
	-m "not loop2x_libnodes and not lapack and not gpu and not long and not sequential and not perf and not mpi and not scalapack and not datainstrument"
	# Backend-marked suites living OUTSIDE tests/library (e.g. tests/blas).
	pytest --ignore=tests/library -n auto --tb=short --timeout_method thread --timeout=600 \
	-m "(openblas or mkl or fftw or tblis) and not loop2x_libnodes and not gpu and not long and not sequential and not perf and not mpi"

	# --- CPU Codegen + External TU (was codegen-external-tu-ci.yml) ---

	# --- Extensions: the short blocking suites, on one runner ---
	# Each of these was its own job for a few minutes of tests, paying a checkout and an environment
	# sync to do it. A failing step still names itself, so a red is no harder to read.
	extensions:
	if: "!contains(github.event.pull_request.labels.*.name, 'no-ci')"
	runs-on: ubuntu-latest
	timeout-minutes: 90
	steps:
	- uses: actions/checkout@v7
	with:
	submodules: 'recursive'
	- uses: ./.github/actions/setup-dace
	with:
	python-version: '3.14'
	# Union of what the steps below need. cmake + ninja: the build cache replays a recorded
	# ``ninja -t compdb``, and dace/codegen/compiler.py only selects the Ninja generator when
	# ``ninja`` is on PATH. BLAS/LAPACK: the readable library-lowering test lowers BLAS library
	# nodes and the corpus kernels link against cBLAS/LAPACKE.
	apt-packages: libyaml-dev cmake ninja-build libblas-dev libopenblas-dev liblapacke-dev liblapack-dev
	pip-packages: pytest-xdist rustworkx
	groups: testing

	- name: Codegen knob suite + CPU external TU
	run: \|
	export NOSTATUSBAR=1
	ulimit -s 65536 \|\| true
	export OMP_STACKSIZE=64M
	export DACE_compiler_max_stack_array_size=65536
	export DACE_cache=unique
	# Multithreaded, like the rest of the suite: a numerical comparison pinned to one thread
	# grades a build nobody ships. The legacy-vs-experimental compare stays bit-exact anyway
	# -- both sides are the same SDFG with the same schedules, so the two generators split a
	# reduction identically and the thread count cancels out. Measured: 60/60 at 4 threads.
	export OMP_NUM_THREADS=4
	# Pinned, not left to the defaults: build caching is most of the wall time here.
	export DACE_compiler_command_cache=1
	export DACE_compiler_precompiled_header=1
	export DACE_compiler_configure_cache=1
	# Both suites drive legacy AND experimental_readable internally; -m "not gpu" keeps this
	# CPU-only. The GPU external-TU file's codegen-shape tests (per-kernel .cu split) are not
	# gpu marked and run here too -- they only generate code, no device needed.
	pytest -v --tb=short --timeout_method thread --timeout=600 -m "not gpu" \
	tests/codegen/readable \
	tests/codegen/split_nsdfg_translation_units_test.py

	- name: Test with pytest (tests/graphlib, rustworkx backend)
	run: \|
	export NOSTATUSBAR=1
	ulimit -s 65536 \|\| true
	export OMP_STACKSIZE=64M
	export DACE_compiler_max_stack_array_size=65536
	export DACE_testing_serialization=1
	export DACE_testing_deserialize_exception=1
	export DACE_cache=unique
	export DACE_optimizer_automatic_simplification=1
	# Config FILE, not DACE_graph_backend: an env var beats Config.set, so every
	# set_default_backend() in tests/graphlib would be a silent no-op under it.
	export DACE_CONFIG=$PWD/.ci-graph-backend.conf
	printf 'graph:\n backend: rustworkx\n' > $DACE_CONFIG
	pytest -n auto --tb=short --timeout_method thread --timeout=300 \
	tests/graphlib \
	-m "not gpu and not long and not sequential"

	# --- Advisory suites, on one runner ---
	# Both of these are non-blocking, for reasons recorded on each step. They are kept apart from the
	# blocking jobs on purpose: continue-on-error is a JOB-level setting, so putting either of them
	# in with a real gate would swallow that gate's failures too.
	advisory:
	if: "!contains(github.event.pull_request.labels.*.name, 'no-ci')"
	runs-on: ubuntu-latest
	timeout-minutes: 120
	continue-on-error: true
	steps:
	- uses: actions/checkout@v7
	with:
	submodules: 'recursive'
	- uses: ./.github/actions/setup-dace
	with:
	python-version: '3.14'
	apt-packages: >-
	libyaml-dev cmake
	libblas-dev libopenblas-dev liblapacke-dev liblapack-dev
	pip-packages: pytest-xdist
	groups: testing

	# Non-blocking until the isolation tests stop racing each other under xdist: seven of them fail
	# at -n4 and pass at -n2 and serially, because the workers share one build folder. The
	# ``layout`` marker is excluded from every other job's selection, so until this ran, its 895
	# tests -- all of tests/transformations/layout -- ran nowhere in CI.
	- name: Test with pytest (layout)
	if: always()
	run: \|
	export NOSTATUSBAR=1
	ulimit -s 65536 \|\| true
	export OMP_STACKSIZE=64M
	export DACE_compiler_max_stack_array_size=65536
	export DACE_testing_serialization=1
	export DACE_testing_deserialize_exception=1
	export DACE_cache=unique
	export DACE_optimizer_automatic_simplification=1
	pytest -n auto --tb=short --timeout_method thread --timeout=300 \
	-m "layout and not gpu and not long and not sequential and not tblis"

	# Non-blocking until the ratchet's baselines are re-measured on an idle machine: the numbers in
	# ``_KNOWN_SLOWER`` were taken on a box running eleven other pytest processes, which moved
	# several of them by a factor of two.
	- name: Canonicalization performance ratchet
	if: always()
	run: \|
	export NOSTATUSBAR=1
	ulimit -s 65536 \|\| true
	export OMP_STACKSIZE=64M
	export DACE_compiler_max_stack_array_size=65536
	export DACE_cache=unique
	# Every other job filters these out with "not perf", so this is the only place they run.
	# What they assert is a RATIO -- canonicalize against auto_optimize, both built and timed in
	# this same process on this same machine -- so a slow shared runner moves both numbers and
	# the comparison survives it. No wall-clock number is asserted.
	export DACE_PERF_TEST=1
	# Sequential and 8 threads: two lowerings timed against each other cannot share cores with
	# xdist workers, or the ratio measures the scheduler rather than the code.
	export OMP_NUM_THREADS=8
	# ``not long``: the canonicalize corpus sweep carries ``perf`` too, but it is the batch
	# measurement harness -- a few hundred kernels times eight arms -- and belongs in a
	# deliberate run, not in every push.
	pytest -n 1 --tb=short --timeout_method thread --timeout=1200 -m "perf and not long"

Navigation Menu

[Only for CI] Extensions #9848

Workflow file

[Only for CI] Extensions #9848

Uh oh!

Workflow file for this run