virtual-casing 0.2.2__tar.gz → 0.3.0__tar.gz

{virtual_casing-0.2.2 → virtual_casing-0.3.0}/.github/workflows/test.yml

@@ -126,13 +126,22 @@ jobs:
         python-version: '3.11'
 
     - name: Install package and stubgen
-      run: python -m pip install . "pybind11-stubgen>=2.5" mypy
+      run: python -m pip install . "pybind11-stubgen>=3.0,<4" mypy
 
     - name: Regenerate stubs and compare
       run: |
         # force the variant being introspected: importing two of them into one
         # process fails, since they register the same pybind11 types
-        VIRTUAL_CASING_ISA=baseline pybind11-stubgen virtual_casing._vc_baseline -o regenerated
+        VIRTUAL_CASING_ISA=baseline python -c "
+        import sys, virtual_casing._vc_baseline as m
+        # __init__.py presents the classes as virtual_casing, which would make
+        # stubgen re-export them rather than declare them; restore their real home
+        for o in vars(m).values():
+            if isinstance(o, type):
+                o.__module__ = m.__name__
+        sys.argv = ['pybind11-stubgen', '--print-value-comments', 'virtual_casing._vc_baseline', '-o', 'regenerated']
+        from pybind11_stubgen import main; main()
+        "
         # stubgen leaves trailing whitespace in docstrings; the committed copy has
         # it stripped, so normalise before comparing
         sed -i 's/[[:space:]]*$//' regenerated/virtual_casing/_vc_baseline.pyi

{virtual_casing-0.2.2 → virtual_casing-0.3.0}/.github/workflows/wheel.yml

@@ -47,14 +47,23 @@ jobs:
         run: python -m cibuildwheel --output-dir wheelhouse
         env:
           CIBW_ARCHS_LINUX: x86_64
-          CIBW_ENVIRONMENT_LINUX: CI=True VC_ARCH_FLAG=${{ matrix.arch_flag }}
-          CIBW_BEFORE_ALL_LINUX: yum install -y lapack-devel openblas-devel fftw-devel
+          CIBW_ENVIRONMENT_LINUX: CI=True VC_ARCH_FLAG=${{ matrix.arch_flag }} LIBXSMM_DIR=/opt/libxsmm
+          # LIBXSMM's own code is built for SSE4.2; the matrix kernels it generates use the CPU that runs them
+          CIBW_BEFORE_ALL_LINUX: >
+            yum install -y lapack-devel openblas-devel fftw-devel &&
+            git clone --depth 1 --branch 2.1.0 https://github.com/libxsmm/libxsmm.git /opt/libxsmm &&
+            make -C /opt/libxsmm -j$(nproc) STATIC=1 SSE=4 lib
           CIBW_BEFORE_BUILD_LINUX: python -m pip install --upgrade pip setuptools wheel numpy cmake ninja && git config --global --add safe.directory /project
           CIBW_MANYLINUX_X86_64_IMAGE: quay.io/pypa/manylinux_2_28_x86_64
           CIBW_SKIP: "*-musllinux_*"
-          CIBW_ENVIRONMENT_MACOS: CI=True VC_ARCH_FLAG=${{ matrix.arch_flag }} MACOSX_DEPLOYMENT_TARGET=${{ matrix.deployment_target }} CC=gcc-12 CXX=g++-12 # with GCC
+          CIBW_ENVIRONMENT_MACOS: CI=True VC_ARCH_FLAG=${{ matrix.arch_flag }} MACOSX_DEPLOYMENT_TARGET=${{ matrix.deployment_target }} CC=gcc-12 CXX=g++-12 LIBXSMM_DIR=/tmp/libxsmm # with GCC
           #CIBW_ENVIRONMENT_MACOS: CI=True VC_ARCH_FLAG=${{ matrix.arch_flat }} MACOSX_DEPLOYMENT_TARGET=${{ matrix.deployment_target }} OpenMP_ROOT=$(brew --prefix)/opt/libomp # with Apple Clang
-          CIBW_BEFORE_ALL_MACOS: brew install fftw lapack gcc@12 libomp openblas
+          # LIBXSMM's own code is built for the runner (SSE4.2 on x86_64); the matrix kernels it generates use the CPU
+          # that runs them
+          CIBW_BEFORE_ALL_MACOS: >
+            brew install fftw lapack gcc@12 libomp openblas &&
+            git clone --depth 1 --branch 2.1.0 https://github.com/libxsmm/libxsmm.git /tmp/libxsmm &&
+            MACOSX_DEPLOYMENT_TARGET=${{ matrix.deployment_target }} make -C /tmp/libxsmm -j$(sysctl -n hw.ncpu) STATIC=1 lib
           CIBW_BEFORE_BUILD_MACOS: python -m pip install --upgrade pip setuptools wheel numpy cmake ninja && git config --global --add safe.directory /project
           CIBW_BUILD: cp310-* cp311-* cp312-* cp313-* cp314-*
           # exercise the repaired wheel, not the source build test.yml already covers

{virtual_casing-0.2.2 → virtual_casing-0.3.0}/CMakeLists.txt

@@ -53,6 +53,35 @@ if(FFTW_DOUBLE_LIB_FOUND)
 endif()
 # float/long-double FFTW is never called; linking it only bloats the wheel
 
+# LIBXSMM generates SCTL's small matrix products for the CPU that runs them, whatever the compiler flags
+option (VC_USE_LIBXSMM "Link LIBXSMM, if found in LIBXSMM_DIR or the default paths, for SCTL's small matrix products" ON)
+if (VC_USE_LIBXSMM)
+    find_path (LIBXSMM_INCLUDE_DIR libxsmm.h HINTS "$ENV{LIBXSMM_DIR}/include")
+    find_library (LIBXSMM_LIBRARY NAMES libxsmm.a xsmm HINTS "$ENV{LIBXSMM_DIR}/lib")
+endif ()
+if (LIBXSMM_INCLUDE_DIR AND LIBXSMM_LIBRARY)
+    find_package (Threads REQUIRED)
+    set (LIBXSMM_LIBRARIES ${LIBXSMM_LIBRARY} Threads::Threads ${CMAKE_DL_LIBS} m)
+    if (NOT APPLE)
+        list (APPEND LIBXSMM_LIBRARIES rt)
+    endif ()
+    # versions before 2.0 lack this interface
+    include (CheckCXXSourceCompiles)
+    set (CMAKE_REQUIRED_INCLUDES ${LIBXSMM_INCLUDE_DIR})
+    set (CMAKE_REQUIRED_LIBRARIES ${LIBXSMM_LIBRARIES})
+    check_cxx_source_compiles ("#include <libxsmm.h>
+        int main() {
+          const libxsmm_gemm_shape shape = libxsmm_create_gemm_shape(1, 1, 1, 1, 1, 1, LIBXSMM_DATATYPE_F64, LIBXSMM_DATATYPE_F64, LIBXSMM_DATATYPE_F64, LIBXSMM_DATATYPE_F64);
+          return libxsmm_dispatch_gemm(shape, 0, 0) == nullptr;
+        }" LIBXSMM_FOUND)
+    unset (CMAKE_REQUIRED_INCLUDES)
+    unset (CMAKE_REQUIRED_LIBRARIES)
+endif ()
+if (LIBXSMM_FOUND)
+    add_definitions (-DSCTL_HAVE_LIBXSMM)
+    include_directories ("${LIBXSMM_INCLUDE_DIR}")
+endif ()
+
 find_package(Git QUIET)
 if(GIT_FOUND AND EXISTS "${PROJECT_SOURCE_DIR}/.git")
 # Update submodules as needed
@@ -113,8 +142,12 @@ if (SKBUILD)
         target_include_directories(${tgt} PRIVATE "$<$<BOOL:${FFTW_DOUBLE_LIB_FOUND}>:${FFTW_INCLUDE_DIRS}>"
                                                   "include" "extern/SCTL/include" "extern/BIEST/include")
         target_link_libraries(${tgt} PRIVATE "$<$<BOOL:${OpenMP_CXX_FOUND}>:OpenMP::OpenMP_CXX>"
-            "$<$<BOOL:${FFTW_DOUBLE_LIB_FOUND}>:FFTW::Double>"
+            "$<$<BOOL:${FFTW_DOUBLE_LIB_FOUND}>:FFTW::Double>" "$<$<BOOL:${LIBXSMM_FOUND}>:${LIBXSMM_LIBRARIES}>"
             "$<$<BOOL:${BLAS_FOUND}>:${BLAS_LIBRARIES}>" "$<$<BOOL:${LAPACK_FOUND}>:${LAPACK_LIBRARIES}>")
+        if (LIBXSMM_FOUND AND NOT APPLE)
+            # not exported, so that another copy of LIBXSMM in the process does not replace these functions
+            target_link_options(${tgt} PRIVATE "LINKER:--exclude-libs,libxsmm.a")
+        endif ()
         install(TARGETS ${tgt} LIBRARY DESTINATION ${PROJECT_NAME})
     endforeach()
 
@@ -131,5 +164,6 @@ target_compile_options(vc_testing PUBLIC "$<$<CXX_COMPILER_ID:PGI>:-Wc,--pending
 target_include_directories(vc_testing PRIVATE "$<$<BOOL:${FFTW_DOUBLE_LIB_FOUND}>:${FFTW_INCLUDE_DIRS}>"
 					      "include" "extern/SCTL/include" "extern/BIEST/include")
 target_link_libraries(vc_testing PUBLIC $<$<BOOL:${FFTW_DOUBLE_LIB_FOUND}>:FFTW::Double>
+    "$<$<BOOL:${LIBXSMM_FOUND}>:${LIBXSMM_LIBRARIES}>"
     "$<$<BOOL:${BLAS_FOUND}>:${BLAS_LIBRARIES}>"
     "$<$<BOOL:${LAPACK_FOUND}>:${LAPACK_LIBRARIES}>" $<$<BOOL:${OpenMP_CXX_FOUND}>:OpenMP::OpenMP_CXX>)

{virtual_casing-0.2.2 → virtual_casing-0.3.0}/Makefile

@@ -53,6 +53,11 @@ CXXFLAGS += -lfftw3 -DSCTL_HAVE_FFTW
 CXXFLAGS += -lfftw3f -DSCTL_HAVE_FFTWF
 CXXFLAGS += -lfftw3l -DSCTL_HAVE_FFTWL
 
+ifdef LIBXSMM_DIR # use LIBXSMM (version 2.0 or newer) for SCTL's small matrix products
+	CXXFLAGS += -I$(LIBXSMM_DIR)/include -DSCTL_HAVE_LIBXSMM
+	LDLIBS += $(LIBXSMM_DIR)/lib/libxsmm.a -lpthread -ldl -lm $(if $(filter Darwin,$(OS)),,-lrt)
+endif
+
 CXXFLAGS += -lmvec -lm -DSCTL_HAVE_LIBMVEC
 #CXXFLAGS += -DSCTL_HAVE_SVML
 

{virtual_casing-0.2.2 → virtual_casing-0.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: virtual_casing
-Version: 0.2.2
+Version: 0.3.0
 Summary: Python Wrapper for Virtual Casing
 Author: Dhairya Malhotra, Matt Landreman, Chris Smiet, Manas Rachh, Antoine Cerfon, Misha Padidar
 Author-Email: Bharat Medasani <mbkumar@gmail.com>
@@ -16,11 +16,12 @@ Classifier: Programming Language :: Python :: 3.14
 Classifier: Programming Language :: C++
 Classifier: Operating System :: OS Independent
 Project-URL: Repository, https://github.com/hiddenSymmetries/virtual-casing
+Project-URL: Issues, https://github.com/hiddenSymmetries/virtual-casing/issues
 Requires-Python: >=3.10
 Provides-Extra: test
 Requires-Dist: pytest>=6.0; extra == "test"
 Provides-Extra: dev
-Requires-Dist: pybind11-stubgen>=2.5; extra == "dev"
+Requires-Dist: pybind11-stubgen<4,>=3.0; extra == "dev"
 Requires-Dist: pytest; extra == "dev"
 Description-Content-Type: text/markdown
 
@@ -48,6 +49,10 @@ If the above command succeeds, we can go to the next step. Build the ``vc_testin
   
 If the compilation is successful, you will have ``vc_testing`` in the ``build`` folder. 
 
+Optionally, set the environment variable ``LIBXSMM_DIR`` to a build of [LIBXSMM](https://github.com/libxsmm/libxsmm)
+(version 2.0 or newer) before running cmake, or before installing the Python package, to use it for small matrix
+products. The Makefile uses it in the same way.
+
 
 ### Python package
 

{virtual_casing-0.2.2 → virtual_casing-0.3.0}/README.md

@@ -22,6 +22,10 @@ If the above command succeeds, we can go to the next step. Build the ``vc_testin
   
 If the compilation is successful, you will have ``vc_testing`` in the ``build`` folder. 
 
+Optionally, set the environment variable ``LIBXSMM_DIR`` to a build of [LIBXSMM](https://github.com/libxsmm/libxsmm)
+(version 2.0 or newer) before running cmake, or before installing the Python package, to use it for small matrix
+products. The Makefile uses it in the same way.
+
 
 ### Python package
 

virtual_casing-0.3.0/extern/BIEST/extern/SCTL/.github/run-tests.sh

@@ -0,0 +1,17 @@
+# Runs the Makefile's tests, also after a failure, each failure as a GitHub annotation; exits with 1 if any failed.
+# SCTL_TESTS: the tests to run instead; SCTL_TEST_RUNNER: a command to run them under
+set +e
+s=0
+for t in ${SCTL_TESTS:-$(sed -n '/^test: /,/^$/p' Makefile | grep -o '/test[^/ ]*$' | cut -c2-)}; do
+  echo "=== $t"
+  $SCTL_TEST_RUNNER ./bin/$t 2>&1 | tee $t.log
+  st=${PIPESTATUS[0]}
+  echo "=== $t: exit $st"
+  if [ $st -ne 0 ]; then
+    s=1
+    msg=$(grep -a -m4 -E 'Assertion|failed|Error|error' $t.log | cut -c1-500 | awk '{printf "%s%%0A", $0}')
+    [ -n "$msg" ] || msg=$(tail -n 5 $t.log | cut -c1-500 | awk '{printf "%s%%0A", $0}')
+    echo "::error title=$t exit $st::$msg"
+  fi
+done
+exit $s

virtual_casing-0.3.0/extern/BIEST/extern/SCTL/.github/workflows/build-test.yml

@@ -0,0 +1,190 @@
+name: Build and Test
+
+on:
+  push:
+    branches:
+      - master
+  pull_request:
+    branches:
+      - master
+
+# a new push cancels the run in progress
+concurrency:
+  group: ${{ github.workflow }}-${{ github.ref }}
+  cancel-in-progress: true
+
+jobs:
+  build:
+    strategy:
+      fail-fast: false
+      matrix:
+        os:
+          - ubuntu-24.04 # GCC 13.3, 14.2 (bug 117159)
+          - macos-latest
+        compiler:
+          - g++-13
+          - g++-14
+          - clang++
+        vecflag:
+          - -march=native
+        memdbgflag:
+          - ""
+          - -DSCTL_MEMDEBUG
+        optflag:
+          - -O0
+          - -O3
+        earlyra: # GCC 14 on Apple silicon: off adds -mearly-ra=none
+          - "off"
+        include:
+          # GCC 14 with its early register allocator: tests the workarounds in the code
+          - os: macos-latest
+            compiler: g++-14
+            vecflag: -march=native
+            memdbgflag: ""
+            optflag: -O3
+            earlyra: "on"
+
+    runs-on: ${{ matrix.os }}
+
+    env:
+      CPPFLAGS: >-
+        -std=c++17 -g1 -rdynamic -fopenmp -Wall -Wfloat-conversion
+        -DSCTL_GLOBAL_MEM_BUFF=500 -DSCTL_PROFILE=5 -DSCTL_VERBOSE
+        -DSCTL_SIG_HANDLER -fstack-protector
+      ASANFLAGS: >-
+        -fsanitize=address,leak,undefined,pointer-compare,pointer-subtract,float-divide-by-zero,float-cast-overflow
+        -fno-sanitize-recover=all
+
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v7
+
+      - name: Setup dependencies (Linux)
+        if: runner.os == 'Linux'
+        run: |
+          sudo apt-get update
+          sudo apt-get install -y libomp-dev g++-14
+
+      - name: Setup dependencies (macOS)
+        if: runner.os == 'macOS'
+        run: |
+          brew install gcc@13 gcc@14 llvm libomp
+          echo "PATH=$(brew --prefix llvm)/bin:$PATH" >> $GITHUB_ENV
+          echo "LDFLAGS=-L$(brew --prefix llvm)/lib" >> $GITHUB_ENV
+          echo "CPPFLAGS=$CPPFLAGS -I$(brew --prefix llvm)/include" >> $GITHUB_ENV
+          echo "LIBRARY_PATH=$(brew --prefix llvm)/lib:$LIBRARY_PATH" >> $GITHUB_ENV
+          echo "MACOSX_DEPLOYMENT_TARGET=$(sw_vers -productVersion | cut -d. -f1).0" >> $GITHUB_ENV # GCC 13 assumes 16.0 on macOS 26
+
+      - name: CPU
+        run: |
+          if [ "$RUNNER_OS" == "Linux" ]; then
+            echo "::notice::CPU: $(lscpu | sed -n 's/^Model name: *//p'); AVX-512: $(grep -q -w avx512f /proc/cpuinfo && echo yes || echo no)"
+          else
+            echo "::notice::CPU: $(sysctl -n machdep.cpu.brand_string)"
+          fi
+
+      - name: Build project
+        run: |
+          CXXFLAGS="${CPPFLAGS} ${{ matrix.optflag }} ${{ matrix.memdbgflag }}"
+          if [ "$(uname -s)" == "Darwin" ] && [ "$(uname -m)" == "arm64" ]; then
+            CXXFLAGS+=" -mcpu=apple-m1"
+            if [[ "${{ matrix.compiler }}" == g++* ]]; then
+              CXXFLAGS+=" -lomp" # clang's -fopenmp links libomp
+            fi
+            if [ "${{ matrix.compiler }}" == "g++-14" ] && [ "${{ matrix.earlyra }}" == "off" ]; then
+              CXXFLAGS+=" -mearly-ra=none" # see README
+            fi
+          else
+            CXXFLAGS+=" ${{ matrix.vecflag }} ${ASANFLAGS}"
+          fi
+          # __float128: x86, and GCC on Apple silicon
+          if [ "$(uname -m)" == "x86_64" ] || [[ "${{ matrix.compiler }}" == g++* ]]; then
+            CXXFLAGS+=" -DSCTL_QUAD_T=__float128"
+          fi
+          # one compile per core: the sanitizer builds of the largest tests come close to the runner's memory
+          make -j$(getconf _NPROCESSORS_ONLN) CXX="${{ matrix.compiler }}" CXXFLAGS="${CXXFLAGS}"
+
+      - name: Run tests
+        run: bash .github/run-tests.sh
+
+  # without sanitizers, which hid GCC bug 117159; x86-64-v4 under Intel SDE on runners without AVX-512
+  release:
+    strategy:
+      fail-fast: false
+      matrix:
+        os:
+          - ubuntu-24.04
+        compiler:
+          - g++-13
+          - g++-14
+          - clang++
+        isa:
+          - x86-64-v3
+          - x86-64-v4
+        optflag:
+          - -O2
+          - -O3
+        include:
+          - {os: ubuntu-24.04, compiler: g++-12, isa: x86-64-v3, optflag: -O3}
+          - {os: ubuntu-24.04, compiler: g++-12, isa: x86-64-v4, optflag: -O3}
+          - {os: ubuntu-26.04, compiler: g++-15, isa: x86-64-v3, optflag: -O3}
+          - {os: ubuntu-26.04, compiler: g++-15, isa: x86-64-v4, optflag: -O3}
+          - {os: ubuntu-26.04, compiler: clang++-22, isa: x86-64-v3, optflag: -O3}
+          - {os: ubuntu-26.04, compiler: clang++-22, isa: x86-64-v4, optflag: -O3}
+
+    runs-on: ${{ matrix.os }}
+
+    env:
+      CPPFLAGS: >-
+        -std=c++17 -g1 -rdynamic -fopenmp -Wall -Wfloat-conversion
+        -DSCTL_GLOBAL_MEM_BUFF=500 -DSCTL_PROFILE=5 -DSCTL_VERBOSE
+        -DSCTL_SIG_HANDLER -fstack-protector
+
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v7
+
+      - name: Setup dependencies
+        run: |
+          sudo apt-get update
+          c="${{ matrix.compiler }}"
+          case "$c" in
+            g++-*) sudo apt-get install -y libomp-dev "$c" ;;
+            clang++-*) sudo apt-get install -y "clang-${c#clang++-}" "libomp-${c#clang++-}-dev" ;;
+            *) sudo apt-get install -y libomp-dev ;;
+          esac
+
+      - name: CPU
+        id: cpu
+        run: |
+          avx512=$(grep -q -w avx512f /proc/cpuinfo && echo yes || echo no)
+          echo "::notice::CPU: $(lscpu | sed -n 's/^Model name: *//p'); AVX-512: ${avx512}"
+          if [ "${{ matrix.isa }}" == "x86-64-v4" ] && [ "${avx512}" != "yes" ]; then
+            echo "emulate=yes" >> $GITHUB_OUTPUT
+            echo "::notice::No AVX-512 on this runner: test-vec runs under Intel SDE, which emulates it; the other tests are not run"
+          fi
+
+      # Intel SDE 10.13.1, checked against Intel's SHA256
+      - name: Install Intel SDE
+        if: steps.cpu.outputs.emulate == 'yes'
+        run: |
+          curl -sSL --retry 3 -o "$RUNNER_TEMP/sde.tar.xz" https://media.githubusercontent.com/media/petarpetrovt/setup-sde/dfe773d77ce97b3da48d34ff9e6ff45a774ff4ff/binaries/sde-external-10.13.1-2026-07-28-lin.tar.xz
+          echo "94e97d623fec54385686e1e7ba65ebc9941748c05ee451423948334892bf2b50  $RUNNER_TEMP/sde.tar.xz" | sha256sum -c -
+          mkdir -p "$RUNNER_TEMP/sde"
+          tar -xJf "$RUNNER_TEMP/sde.tar.xz" -C "$RUNNER_TEMP/sde" --strip-components=1
+
+      - name: Build project
+        run: |
+          target=
+          if [ "${{ steps.cpu.outputs.emulate }}" == "yes" ]; then
+            target=bin/test-vec
+          fi
+          make -j$(getconf _NPROCESSORS_ONLN) ${target} CXX="${{ matrix.compiler }}" CXXFLAGS="${CPPFLAGS} ${{ matrix.optflag }} -march=${{ matrix.isa }} -DSCTL_QUAD_T=__float128"
+
+      - name: Run tests
+        run: |
+          if [ "${{ steps.cpu.outputs.emulate }}" == "yes" ]; then
+            SCTL_TESTS=test-vec SCTL_TEST_RUNNER="$RUNNER_TEMP/sde/sde64 -icx --" bash .github/run-tests.sh
+          else
+            bash .github/run-tests.sh
+          fi

{virtual_casing-0.2.2 → virtual_casing-0.3.0/extern/BIEST}/extern/SCTL/.github/workflows/codecov.yml

@@ -7,12 +7,12 @@ on:
 
 jobs:
   build:
-    runs-on: ubuntu-latest
+    runs-on: ubuntu-24.04
 
     steps:
       # Step 1: Checkout the repository
       - name: Checkout repository
-        uses: actions/checkout@v3
+        uses: actions/checkout@v7
 
       # Step 2: Compile the project
       - name: Compile

{virtual_casing-0.2.2 → virtual_casing-0.3.0/extern/BIEST}/extern/SCTL/Makefile

@@ -12,18 +12,13 @@ endif
 
 OS = $(shell uname -s)
 ifeq "$(OS)" "Darwin"
-	CXXFLAGS += -g -rdynamic -Wl,-no_pie # for stack trace (on Mac)
+	CXXFLAGS += -g -rdynamic # for stack trace
 else
 	CXXFLAGS += -gdwarf-4 -g -rdynamic # for stack trace
-	CXXFLAGS += -ldl # dladdr() in stacktrace.h (libc on glibc >=2.34, libdl otherwise)
+	CXXFLAGS += -ldl # dladdr(), for glibc < 2.34
 endif
 
-# GCC `-march=native` on Sapphire Rapids and newer Intel CPUs emits AVX-512-FP16
-# instructions (e.g. `vmovw`) that pre-2.38 binutils' system assembler can't
-# decode. Disable just the FP16 subset; the rest of -march=native is fine. If a
-# newer binutils is available (e.g. `module load binutils/2.43.1`), the user can
-# remove this flag manually. macOS clang doesn't emit avx512fp16 and doesn't
-# recognise the flag on Apple Silicon — skip there.
+# AVX-512-FP16 of -march=native (Sapphire Rapids), which binutils before 2.38 can't assemble
 ifneq "$(OS)" "Darwin"
        CXXFLAGS += -mno-avx512fp16
 endif
@@ -33,10 +28,15 @@ CXXFLAGS += -DSCTL_GLOBAL_MEM_BUFF=0 # Global memory buffer size in MB
 CXXFLAGS += -DSCTL_PROFILE=5 -DSCTL_VERBOSE # Enable profiling
 CXXFLAGS += -DSCTL_SIG_HANDLER # Enable SCTL stack trace
 
-CXXFLAGS += -DSCTL_QUAD_T=__float128 # Enable quadruple precision
+CXXFLAGS += -DSCTL_QUAD_T=__float128 # Enable quadruple precision (x86, or GCC on Apple silicon)
+
+#CXXFLAGS += -DSCTL_MAX_DEPTH=20 # Morton/Tree depth limit
 
 #CXXFLAGS += -DSCTL_HAVE_MPI #use MPI
 
+#CXXFLAGS += -DSCTL_COMM_PTRACER # allow direct reads; exposes rank memory to the same user
+#CXXFLAGS += -DSCTL_COMM_NO_DIRECT # disable direct reads (overrides the above)
+
 CXXFLAGS += -lblas -DSCTL_HAVE_BLAS # use BLAS
 CXXFLAGS += -llapack -DSCTL_HAVE_LAPACK # use LAPACK
 #CXXFLAGS += -qmkl -DSCTL_HAVE_BLAS -DSCTL_HAVE_LAPACK -DSCTL_HAVE_FFTW3_MKL # use MKL BLAS, LAPACK and FFTW (Intel compiler)
@@ -50,13 +50,14 @@ CXXFLAGS += -lfftw3l -DSCTL_HAVE_FFTWL
 #CXXFLAGS += -lmvec -lm -DSCTL_HAVE_LIBMVEC
 #CXXFLAGS += -DSCTL_HAVE_SVML
 
+#CXXFLAGS += -I$(LIBXSMM_DIR)/include -L$(LIBXSMM_DIR)/lib -l:libxsmm.a -lpthread -lrt -ldl -lm -DSCTL_HAVE_LIBXSMM # use LIBXSMM for SmallGEMM
+
 #CXXFLAGS += -I${PETSC_DIR}/include -I${PETSC_DIR}/../include -DSCTL_HAVE_PETSC
 #LDLIBS += -L${PETSC_DIR}/lib -lpetsc
 
 #PVFMM_INC_DIR = ../include
 #CXXFLAGS += -DSCTL_HAVE_PVFMM -I$(PVFMM_INC_DIR)
 
-
 RM = rm -f
 MKDIRS = mkdir -p
 
@@ -71,6 +72,7 @@ TARGET_BIN = \
        $(BINDIR)/test-boundary_integral \
        $(BINDIR)/test-cheb_utils \
        $(BINDIR)/test-fft-fallback \
+       $(BINDIR)/test-function-table \
        $(BINDIR)/test-generic-kernel \
        $(BINDIR)/test-intrin-wrapper \
        $(BINDIR)/test-iterator \
@@ -93,15 +95,17 @@ TARGET_BIN = \
        $(BINDIR)/test-linear-solver \
        $(BINDIR)/test-ode-solver \
        $(BINDIR)/test-pt-tree \
+       $(BINDIR)/test-sort-scatter \
        $(BINDIR)/test-quadrule \
        $(BINDIR)/test-sph-harm \
        $(BINDIR)/test-tensor \
        $(BINDIR)/test-vec \
-       $(BINDIR)/test-quad-elem \
        $(BINDIR)/test-scratch-pool \
-       $(BINDIR)/test-scratch-pool-perf
+       $(BINDIR)/test-scratch-pool-perf \
+       $(BINDIR)/test-small-gemm \
+	   $(BINDIR)/test-quad-elem
 
-.PHONY: all test clean
+.PHONY: all gpu test clean
 
 all : $(TARGET_BIN)
 
@@ -112,9 +116,39 @@ ifeq "$(OS)" "Darwin"
 	/usr/bin/dsymutil $@ -o $@.dSYM
 endif
 
+# link-only flags of CXXFLAGS, left out of compiles (clang warns of them)
+LINK_ONLY_FLAGS = -l% -L% -Wl,% -rdynamic
+
 $(OBJDIR)/%.o: $(SRCDIR)/%.cpp
 	-@$(MKDIRS) $(dir $@)
-	$(CXX) $(CXXFLAGS) -I$(INCDIR) -c $^ -o $@
+	$(CXX) $(filter-out $(LINK_ONLY_FLAGS),$(CXXFLAGS)) -MMD -MP -I$(INCDIR) -c $< -o $@
+
+# header dependencies (-MMD -MP)
+-include $(wildcard $(OBJDIR)/*.d)
+
+# keep the objects, which the dependency files name
+.SECONDARY: $(patsubst $(BINDIR)/%,$(OBJDIR)/%.o,$(TARGET_BIN))
+
+# GPU tree: needs CUDA and a CUDA-aware MPI (not in `all`)
+NVCC = nvcc -ccbin mpicxx
+NVCCFLAGS = -x cu -std=c++17 -O3 -arch=native -rdc=true --expt-relaxed-constexpr -Xcompiler "-fopenmp" \
+            -DSCTL_HAVE_MPI -DSCTL_MAX_DEPTH=20 -DTHRUST_HOST_SYSTEM=THRUST_HOST_SYSTEM_OMP
+NVCCLIBS = -ldl
+
+GPU_BIN = \
+       $(BINDIR)/test-device-scratch \
+       $(BINDIR)/test-gpu-tree \
+       $(BINDIR)/test-gpu-sort-scatter \
+       $(BINDIR)/example-gpu-tree
+
+gpu: $(GPU_BIN)
+
+GPU_DEPS = $(wildcard $(INCDIR)/*.hpp $(INCDIR)/sctl/*.hpp $(INCDIR)/sctl/*.txx \
+                      $(INCDIR)/sctl/experimental/*.hpp $(INCDIR)/sctl/experimental/*.txx)
+
+$(BINDIR)/%: $(SRCDIR)/%.cu $(GPU_DEPS)
+	-@$(MKDIRS) $(dir $@)
+	$(NVCC) $(NVCCFLAGS) -I$(INCDIR) $< $(NVCCLIBS) -o $@
 
 test: $(TARGET_BIN)
 	./$(BINDIR)/test
@@ -122,6 +156,7 @@ test: $(TARGET_BIN)
 	./$(BINDIR)/test-boundary_integral
 	./$(BINDIR)/test-cheb_utils
 	./$(BINDIR)/test-fft-fallback
+	./$(BINDIR)/test-function-table
 	./$(BINDIR)/test-generic-kernel
 	./$(BINDIR)/test-intrin-wrapper
 	./$(BINDIR)/test-iterator
@@ -144,12 +179,14 @@ test: $(TARGET_BIN)
 	./$(BINDIR)/test-linear-solver
 	./$(BINDIR)/test-ode-solver
 	./$(BINDIR)/test-pt-tree
+	./$(BINDIR)/test-sort-scatter
 	./$(BINDIR)/test-quadrule
 	./$(BINDIR)/test-sph-harm
 	./$(BINDIR)/test-tensor
 	./$(BINDIR)/test-vec
-	./$(BINDIR)/test-quad-elem
 	./$(BINDIR)/test-scratch-pool
+	./$(BINDIR)/test-small-gemm
+	./$(BINDIR)/test-quad-elem
 
 clean:
 	$(RM) -r $(BINDIR)/* $(OBJDIR)/*

{virtual_casing-0.2.2 → virtual_casing-0.3.0}/extern/BIEST/extern/SCTL/README.md

@@ -11,6 +11,8 @@
 
 The only requirement to use SCTL is a working C++17 compliant compiler with OpenMP 4.0 support. It has been tested with GCC-9 and newer.
 
+**GCC 14 and newer on AArch64 (ARM, including Apple silicon):** compile with `-mearly-ra=none`. GCC's early register allocator for vector registers can assign one register to two values in use at the same time, which gave wrong results in `Vec` at `-O3` with GCC 14. GCC 15 and 16 have the same bug, hidden in the cases found so far. GCC 11 to 13 reject the flag.
+
 ## Getting Started
 
 To get started, download the latest version of SCTL from the [SCTL GitHub](https://github.com/dmalhotra/SCTL).
@@ -27,6 +29,8 @@ Since SCTL is a header-only library, it does not require compilation or installa
 
 Ensure the compiler can locate the header file by providing the path to `SCTL_ROOT/include` using the flag `-I ${SCTL_ROOT}/include`.
 
+The included `Makefile` builds the tests (`make test`). On Apple silicon with Homebrew: `CPATH=/opt/homebrew/include LIBRARY_PATH=/opt/homebrew/lib make CXX=g++-15`.
+
 ## Optional Dependencies
 
 The following libraries can be optionally used when available. If not available, SCTL uses its own implementation which may be slower.
@@ -50,7 +54,7 @@ The following compiler flags can be used to enable or disable specific features
 - `-DSCTL_PROFILE=<level>`: Enable [profiling](include/sctl/profile.hpp).
 - `-DSCTL_VERBOSE`: Enable verbose [profiling](include/sctl/profile.hpp) output.
 - `-DSCTL_SIG_HANDLER`: Enable [stack trace](include/sctl/stacktrace.h). On Linux with glibc < 2.34, link with `-ldl` (newer glibc has it merged into libc).
-- `-DSCTL_QUAD_T`: Enable support for [quad-precision type](include/sctl/math_utils.hpp).
+- `-DSCTL_QUAD_T=<type>`: Enable support for [quad-precision type](include/sctl/math_utils.hpp), e.g. `__float128` on x86 and with GCC on Apple silicon.
 
 ## Features and Capabilities
 
@@ -72,6 +76,7 @@ The following list outlines the primary features and capabilities provided by th
   - [ChebQuadRule, LegQuadRule](include/sctl/quadrule.hpp): Clenshaw-Curtis and Gauss-Legendre quadrature rules.
   - [InterpQuadRule](include/sctl/quadrule.hpp): Generating special quadrature rules.
   - [Tree, PtTree](include/sctl/tree.hpp), [Morton](include/sctl/morton.hpp): Morton order based N-dimensional parallel tree structure.
+  - [SortScatter](include/sctl/sort-scatter.hpp): keys sorted into a rank-partitioned order, kept together with the permutation to and from the caller's order; the trees move particle data with it.
 
 - **Spectral Methods**:
   Methods for spectral representations and transformations.
@@ -105,8 +110,12 @@ The following list outlines the primary features and capabilities provided by th
   - [Stacktrace utility](include/sctl/stacktrace.h): Prints stack traces for debugging.
   - [GEMM, SVD (unoptimized)](include/sctl/mat_utils.hpp): Provides basic implementations of GEMM and SVD operations.
 
+- **Experimental**:
+  Components whose interfaces may still change.
+
+  - [GPUTree, PtTree](include/sctl/experimental/gpu-tree.hpp): The `Tree`/`PtTree` interface on a thrust backend, OpenMP host or CUDA device, with CUDA-aware MPI (`make gpu`).
+
 - **Legacy (Unmaintained)**:
   Older functionalities that are no longer actively maintained.
 
-  - [Boundary quadrature](include/sctl/boundary_quadrature.hpp): Boundary integrals on quad-patches using hedgehog quadrature.
   - [ChebBasis](include/sctl/cheb_utils.hpp): Tensor product Chebyshev basis for general-dimension computations.