Testing Embree4 + WinArm

.github/workflows/continuous.yaml

@@ -19,6 +19,7 @@ jobs:
   ####################
 
   Unix:
+    if: false  # DIAGNOSTIC: temporarily disabled to iterate fast on Windows ARM64 Debug Eigen alignment investigation
     name: ${{ matrix.os }} (${{ matrix.compiler }}, ${{ matrix.config }}, ${{ matrix.sanitizer }}Sanitizer)
     runs-on: ${{ matrix.os }}
     strategy:
@@ -195,14 +196,17 @@ jobs:
   ####################
 
   Windows:
-    name: windows-2025 (${{ matrix.config }})
-    runs-on: windows-2025
+    name: ${{ matrix.os }} (${{ matrix.config }})
+    runs-on: ${{ matrix.os }}
     env:
       SCCACHE_GHA_ENABLED: "true"
     strategy:
       fail-fast: false
       matrix:
-        config: [Release, Debug]
+        # DIAGNOSTIC: only the failing config (Win ARM64 Debug) while we hunt the
+        # Eigen alignment issue in serialization2.
+        os: [windows-11-arm]
+        config: [Debug]
     steps:
       - name: Show disk space
         run: Get-PSDrive
@@ -214,9 +218,26 @@ jobs:
           fetch-depth: 0
 
       - uses: actions/setup-python@v5
+        if: matrix.os != 'windows-11-arm'
         with:
           python-version: 3.13
 
+        # On windows-11-arm the hostedtoolcache Python ships only the interpreter binary;
+        # it lacks include/ headers and libs/python3XX.lib, so CMake cannot satisfy the
+        # Development.Module component. Use uv instead: it pulls python-build-standalone
+        # distributions which include full dev files. uv defaults to x64-emulated Python
+        # on ARM64 Windows (uv PR #13724), so we must pin the aarch64 specifier.
+      - uses: astral-sh/setup-uv@v6
+        if: matrix.os == 'windows-11-arm'
+
+      - name: Install native ARM64 Python via uv
+        if: matrix.os == 'windows-11-arm'
+        shell: pwsh
+        run: |
+          uv python install cpython-3.13-windows-aarch64
+          $pyExe = (uv python find cpython-3.13-windows-aarch64).Trim()
+          echo "PYTHON_ARM64_EXE=$($pyExe -replace '\\', '/')" >> $env:GITHUB_ENV
+
       - name: Install Ninja
         uses: seanmiddleditch/gha-setup-ninja@master
 
@@ -227,33 +248,61 @@ jobs:
           # starving sccache of requests until the default 600s timeout kills the server.
           echo "SCCACHE_IDLE_TIMEOUT=0" >> ${env:GITHUB_ENV}
 
-      - name: Select embree isa (Windows)
-        if: runner.os == 'Windows'
-        run: echo "embree_max_isa=AVX2" >> ${env:GITHUB_ENV}
-
       - name: Get number of CPU cores
         uses: SimenB/github-actions-cpu-cores@v1
         id: cpu-cores
 
       - name: Sccache
         uses: mozilla-actions/sccache-action@v0.0.10
 
-        # We run configure + build in the same step, since they both need to call VsDevCmd
-        # Also, cmd uses ^ to break commands into multiple lines (in powershell this is `)
-      - name: Configure and build
-        shell: cmd
+      - name: Set x64 vars
+        if: matrix.os == 'windows-2025'
+        run: |
+            echo "BUILD_DIR=D:/build" >> ${env:GITHUB_ENV}
+            echo "ARCH=x64" >> ${env:GITHUB_ENV}
+
+      - name: Set arm64 vars
+        if: matrix.os == 'windows-11-arm'
+        run: |
+            echo "BUILD_DIR=C:/build" >> ${env:GITHUB_ENV}
+            echo "ARCH=arm64" >> ${env:GITHUB_ENV}
+
+      - name: Setup MSVC Developer Command Prompt
+        uses: ilammy/msvc-dev-cmd@v1
+        with:
+          arch: ${{ env.ARCH }}
+
+        # Cmd uses ^ to break commands into multiple lines, powershell uses `
+      - name: Configure
+        if: matrix.os != 'windows-11-arm'
+        run: |
+          cmake --version
+          cmake -G Ninja `
+            -DCMAKE_BUILD_TYPE=${{ matrix.config }} `
+            -DLAGRANGE_JENKINS=ON `
+            -DLAGRANGE_ALL=ON `
+            -DLAGRANGE_POLYSCOPE_MOCK_BACKEND=ON `
+            -B ${{ env.BUILD_DIR }} `
+            -S .
+
+        # DIAGNOSTIC: minimal configure for Win ARM64 — enable only the failing module
+        # (serialization2) so we get a fast iteration loop while we capture cpptrace
+        # stack traces for the Eigen alignment assertion. LAGRANGE_ALL=OFF, no Python.
+      - name: Configure (ARM64)
+        if: matrix.os == 'windows-11-arm'
         run: |
-          call "C:\Program Files\Microsoft Visual Studio\2022\Enterprise\Common7\Tools\VsDevCmd.bat" -arch=x64
           cmake --version
-          cmake -G Ninja ^
-            -DCMAKE_BUILD_TYPE=${{ matrix.config }} ^
-            -DLAGRANGE_JENKINS=ON ^
-            -DLAGRANGE_ALL=ON ^
-            -DLAGRANGE_POLYSCOPE_MOCK_BACKEND=ON ^
-            -DEMBREE_MAX_ISA=${{ env.embree_max_isa }} ^
-            -B "D:/build" ^
+          cmake -G Ninja `
+            -DCMAKE_BUILD_TYPE=${{ matrix.config }} `
+            -DLAGRANGE_JENKINS=ON `
+            -DLAGRANGE_ALL=OFF `
+            -DLAGRANGE_MODULE_SERIALIZATION2=ON `
+            -DLAGRANGE_MODULE_PYTHON=OFF `
+            -B ${{ env.BUILD_DIR }} `
             -S .
-          cmake --build "D:/build" -j ${{ steps.cpu-cores.outputs.count }}
+
+      - name: Build
+        run: cmake --build ${{ env.BUILD_DIR }} -j ${{ steps.cpu-cores.outputs.count }}
 
       - name: Sccache stats
         if: always()
@@ -265,4 +314,6 @@ jobs:
         run: Get-PSDrive
 
       - name: Tests
-        run: cd "D:/build"; ctest --verbose -j ${{ steps.cpu-cores.outputs.count }}
+        # DIAGNOSTIC: scope ctest to the serialization2 suite (the only one firing the assert).
+        # --verbose is critical: cpptrace writes to stderr and we need it captured in the log.
+        run: cd ${{ env.BUILD_DIR }}; ctest --verbose -j ${{ steps.cpu-cores.outputs.count }} -R "serialization2|serialize_"

cmake/recipes/external/Boost.cmake

@@ -79,12 +79,15 @@ option(BOOST_IOSTREAMS_ENABLE_BZIP2 "Boost.Iostreams: Enable BZip2 support" OFF)
 option(BOOST_IOSTREAMS_ENABLE_LZMA "Boost.Iostreams: Enable LZMA support" OFF)
 option(BOOST_IOSTREAMS_ENABLE_ZSTD "Boost.Iostreams: Enable Zstd support" OFF)
 
-set(BOOST_PATCHES "")
+set(BOOST_PATCHES)
 if(EMSCRIPTEN)
     # Wasm doesn't have rounding mode control yet, so we trick Boost::interval into thinking it has.
     # https://github.com/WebAssembly/rounding-mode-control
     # https://github.com/boostorg/interval/issues/44
-    set(BOOST_PATCHES PATCHES Boost.wasm.patch)
+    list(APPEND BOOST_PATCHES Boost.wasm.patch)
+endif()
+if(WIN32)
+    list(APPEND BOOST_PATCHES Boost.winarm.patch)
 endif()
 
 # Modern CMake target support was added in Boost 1.82.0
@@ -95,7 +98,7 @@ CPMAddPackage(
     URL https://github.com/boostorg/boost/releases/download/boost-1.84.0/boost-1.84.0.tar.xz
     URL_HASH SHA256=2e64e5d79a738d0fa6fb546c6e5c2bd28f88d268a2a080546f74e5ff98f29d0e
     EXCLUDE_FROM_ALL ON
-    ${BOOST_PATCHES}
+    PATCHES ${BOOST_PATCHES}
 )
 
 # Due to MKL, we may require the release runtime (/MD) even when compiling in Debug mode.

cmake/recipes/external/Boost.winarm.patch

@@ -0,0 +1,132 @@
+Submodule libs/context contains modified content
+diff --git i/libs/context/CMakeLists.txt w/libs/context/CMakeLists.txt
+index dca5349..bd064b1 100644
+--- i/libs/context/CMakeLists.txt
++++ w/libs/context/CMakeLists.txt
+@@ -12,7 +12,7 @@ list(APPEND CMAKE_MODULE_PATH ${boost_context_SOURCE_DIR}/cmake)
+
+ ## Binary format
+
+-if(WIN32)
++if(WIN32 OR CYGWIN)
+   set(_default_binfmt pe)
+ elseif(APPLE)
+   set(_default_binfmt mach-o)
+@@ -31,7 +31,7 @@ math(EXPR _bits "${CMAKE_SIZEOF_VOID_P}*8")
+
+ if(CMAKE_SYSTEM_PROCESSOR MATCHES "^[Aa][Rr][Mm]" OR CMAKE_SYSTEM_PROCESSOR STREQUAL "aarch64")
+   set(_default_abi aapcs)
+-elseif(WIN32)
++elseif(WIN32 OR CYGWIN)
+   set(_default_abi ms)
+ elseif(CMAKE_SYSTEM_PROCESSOR MATCHES "^mips")
+   if(_bits EQUAL 32)
+@@ -60,6 +60,8 @@ elseif(_bits EQUAL 32)
+     set(_default_arch arm)
+   elseif(CMAKE_SYSTEM_PROCESSOR MATCHES "^mips")
+     set(_default_arch mips32)
++  elseif(CMAKE_SYSTEM_PROCESSOR MATCHES "^(powerpc|ppc32)")
++    set(_default_arch ppc32)
+   else()
+     set(_default_arch i386)
+   endif()
+@@ -69,6 +71,8 @@ else()
+     set(_default_arch arm64)
+   elseif(CMAKE_SYSTEM_PROCESSOR MATCHES "^mips")
+     set(_default_arch mips64)
++  elseif(CMAKE_SYSTEM_PROCESSOR MATCHES "^(powerpc|ppc64)")
++    set(_default_arch ppc64)
+   else()
+     set(_default_arch x86_64)
+   endif()
+@@ -89,18 +93,22 @@ if(MSVC)
+   else()
+     set(_default_asm masm)
+   endif()
++elseif(BOOST_CONTEXT_ARCHITECTURE STREQUAL arm64 AND MINGW)
++  set(_default_asm armclang)
+ else()
+   set(_default_asm gas)
+ endif()
+
+-set(BOOST_CONTEXT_ASSEMBLER "${_default_asm}" CACHE STRING "Boost.Context assembler (masm, gas, armasm)")
+-set_property(CACHE BOOST_CONTEXT_ASSEMBLER PROPERTY STRINGS masm gas armasm)
++set(BOOST_CONTEXT_ASSEMBLER "${_default_asm}" CACHE STRING "Boost.Context assembler (masm, gas, armasm, armclang)")
++set_property(CACHE BOOST_CONTEXT_ASSEMBLER PROPERTY STRINGS masm gas armasm armclang)
+
+ unset(_default_asm)
+
+ ## Assembler source suffix
+
+-if(BOOST_CONTEXT_BINARY_FORMAT STREQUAL pe)
++if(BOOST_CONTEXT_ASSEMBLER STREQUAL armclang)
++  set(_default_ext .S)
++elseif(BOOST_CONTEXT_BINARY_FORMAT STREQUAL pe)
+   set(_default_ext .asm)
+ elseif(BOOST_CONTEXT_ASSEMBLER STREQUAL gas)
+   set(_default_ext .S)
+@@ -133,18 +141,22 @@ message(STATUS "Boost.Context: "
+   "implementation ${BOOST_CONTEXT_IMPLEMENTATION}")
+
+ # Enable the right assembler
+-
++set(ASM_LANGUAGE)
+ if(BOOST_CONTEXT_IMPLEMENTATION STREQUAL "fcontext")
+-  if(BOOST_CONTEXT_ASSEMBLER STREQUAL gas)
++  if(BOOST_CONTEXT_ASSEMBLER STREQUAL gas OR BOOST_CONTEXT_ASSEMBLER STREQUAL armclang)
+     if(CMAKE_CXX_PLATFORM_ID MATCHES "Cygwin")
+-      enable_language(ASM-ATT)
++      set(ASM_LANGUAGE ASM-ATT)
+     else()
+-      enable_language(ASM)
++      set(ASM_LANGUAGE ASM)
+     endif()
+   elseif(BOOST_CONTEXT_ASSEMBLER STREQUAL armasm)
+-    enable_language(ASM_ARMASM)
++    if(MSVC)
++      set(ASM_LANGUAGE ASM_MARMASM)
++    else()
++      set(ASM_LANGUAGE ASM_ARMASM)
++    endif()
+   else()
+-    enable_language(ASM_MASM)
++    set(ASM_LANGUAGE ASM_MASM)
+   endif()
+ endif()
+
+@@ -170,13 +182,29 @@ if(BOOST_CONTEXT_IMPLEMENTATION STREQUAL "fcontext")
+
+   set(IMPL_SOURCES ${ASM_SOURCES})
+
+-  if(BOOST_CONTEXT_ASSEMBLER STREQUAL masm AND BOOST_CONTEXT_ARCHITECTURE STREQUAL i386)
+-      set_source_files_properties(${ASM_SOURCES} PROPERTIES COMPILE_FLAGS "/safeseh")
+-  endif()
++  if(BOOST_CONTEXT_ASSEMBLER STREQUAL masm)
+
+-  if(CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
+-    set_property(SOURCE ${ASM_SOURCES} APPEND PROPERTY COMPILE_OPTIONS "-x" "assembler-with-cpp")
+-  endif()
++    set_property(SOURCE ${ASM_SOURCES} APPEND PROPERTY COMPILE_OPTIONS "/nologo")
++
++    if(MSVC AND NOT(MSVC_VERSION LESS 1936) AND NOT(CMAKE_CXX_SIMULATE_VERSION))
++      set_property(SOURCE ${ASM_SOURCES} APPEND PROPERTY COMPILE_OPTIONS "/quiet")
++    endif()
++
++    if(BOOST_CONTEXT_ARCHITECTURE STREQUAL i386)
++      set_property(SOURCE ${ASM_SOURCES} APPEND PROPERTY COMPILE_OPTIONS "/safeseh")
++    endif()
++
++  # armasm doesn't support most of these options
++  elseif(NOT BOOST_CONTEXT_ASSEMBLER STREQUAL armasm) # masm
++    if(CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
++      set_property(SOURCE ${ASM_SOURCES} APPEND PROPERTY COMPILE_OPTIONS "-x" "assembler-with-cpp")
++    elseif(CMAKE_CXX_COMPILER_ID STREQUAL "Clang")
++      set_property(SOURCE ${ASM_SOURCES} APPEND PROPERTY COMPILE_OPTIONS "-Wno-unused-command-line-argument")
++    endif()
++  endif() # masm
++
++  enable_language(${ASM_LANGUAGE})
++  set_source_files_properties(${ASM_SOURCES} PROPERTIES LANGUAGE ${ASM_LANGUAGE})
+ else()
+   set(IMPL_SOURCES
+     src/continuation.cpp

cmake/recipes/external/Eigen3.cmake

@@ -46,6 +46,36 @@ if(EIGEN_DONT_VECTORIZE)
     target_compile_definitions(Eigen3_Eigen INTERFACE EIGEN_DONT_VECTORIZE)
 endif()
 
+# Diagnostic only — TEMPORARY: on Windows ARM64 Debug, force-include a header that overrides
+# eigen_assert with a non-fatal handler. When the assertion comes from DenseStorage.h (i.e. the
+# plain_array<> alignment check) we capture a cpptrace stack trace so we can pinpoint the call
+# site that constructs a misaligned fixed-size Eigen object. All other eigen_assert failures
+# still abort, so unrelated invariants are not masked.
+#
+# The cpptrace dependency stays in a separate static library (lagrange_eigen_align_diag) so it
+# does not leak into every Eigen consumer's interface.
+if(WIN32 AND CMAKE_SYSTEM_PROCESSOR STREQUAL "ARM64" AND MSVC AND CMAKE_BUILD_TYPE STREQUAL "Debug")
+    include(cpptrace)
+    add_library(lagrange_eigen_align_diag STATIC
+        ${CMAKE_CURRENT_LIST_DIR}/eigen_alignment_diag.cpp
+        ${CMAKE_CURRENT_LIST_DIR}/eigen_alignment_diag.h
+    )
+    target_include_directories(lagrange_eigen_align_diag PUBLIC ${CMAKE_CURRENT_LIST_DIR})
+    target_compile_definitions(lagrange_eigen_align_diag PUBLIC LAGRANGE_DIAG_EIGEN_ALIGN=1)
+    target_link_libraries(lagrange_eigen_align_diag PRIVATE cpptrace::cpptrace)
+    set_target_properties(lagrange_eigen_align_diag PROPERTIES FOLDER third_party)
+
+    set(_lagrange_eigen_diag_header "${CMAKE_CURRENT_LIST_DIR}/eigen_alignment_diag.h")
+    # Wrap with $<BUILD_INTERFACE:> so install(EXPORT Eigen_Targets) does not see the
+    # diagnostic target (which is intentionally not part of the export set).
+    target_compile_options(Eigen3_Eigen INTERFACE
+        "$<BUILD_INTERFACE:/FI${_lagrange_eigen_diag_header}>")
+    target_compile_definitions(Eigen3_Eigen INTERFACE
+        $<BUILD_INTERFACE:LAGRANGE_DIAG_EIGEN_ALIGN=1>)
+    target_link_libraries(Eigen3_Eigen INTERFACE
+        $<BUILD_INTERFACE:lagrange_eigen_align_diag>)
+endif()
+
 if(EIGEN_WITH_MKL)
     # TODO: Checks that, on 64bits systems, `MKL::MKL` is using the LP64 interface
     # (by looking at the compile definition of the target)