Merge branch 'main' into matmul-nd

Author: SwayamInSync

.github/workflows/build_wheels.yml

@@ -114,7 +114,9 @@ jobs:
           path: ./wheelhouse/*.whl
           name: wheels-${{ matrix.os }}
 
-  # disabling QBLAS optimization for windows due to incompatibility with MSVC
+  # QBLAS is auto-disabled on Windows by meson.build (it uses GCC/POSIX-only
+  # constructs that MSVC does not support); the wheel falls back to the
+  # naive matmul kernel.
   build_wheels_windows:
     name: Build wheels on Windows
     runs-on: windows-latest
@@ -153,9 +155,6 @@ jobs:
           CIBW_BUILD_VERBOSITY: "3"
           DISTUTILS_USE_SDK: "1"
           MSSdk: "1"
-          CIBW_ENVIRONMENT: >
-            CFLAGS="/DDISABLE_QUADBLAS $CFLAGS"
-            CXXFLAGS="/DDISABLE_QUADBLAS $CXXFLAGS"
           CIBW_REPAIR_WHEEL_COMMAND: 'delvewheel repair -w {dest_dir} {wheel} --add-path C:\sleef\bin'
           CIBW_TEST_COMMAND_WINDOWS: pip install numpy && pip install --no-deps {wheel} && pip install pytest pytest-run-parallel && pytest -s {project}/tests
           CIBW_TEST_EXTRAS: test

.github/workflows/test_old_cpu.yml

@@ -1,8 +1,4 @@
-name: Test on Older CPUs (x86_64-v2)
-
-# This workflow tests numpy-quaddtype on older x86 CPUs using Intel SDE.
-# It ensures compatibility with x86_64-v2 baseline CPUs (e.g., Sandy Bridge)
-# that don't have AVX2/FMA support.
+name: Test Older CPUs + Build Options
 
 on:
   push:
@@ -11,16 +7,26 @@ on:
   pull_request:
   workflow_dispatch:
 
+permissions:
+  contents: read
+
 jobs:
   test_old_cpu:
-    name: Test on ${{ matrix.cpu[1] }}
+    name: Test ${{ matrix.config.name }}
     runs-on: ubuntu-24.04
     strategy:
       fail-fast: false
       matrix:
-        cpu:
-          - ['snb', 'Sandy Bridge (x86_64-v2)']
-          - ['hsw', 'Haswell (x86_64-v3)']
+        config:
+          - name: "Sandy Bridge (x86_64-v2)"
+            sde_cpu: "snb"
+            meson_args: "-Csetup-args=-Ddisable_fma=true"
+          - name: "Haswell (x86_64-v3)"
+            sde_cpu: "hsw"
+            meson_args: ""
+          - name: "Haswell, no QBLAS"
+            sde_cpu: "hsw"
+            meson_args: "-Csetup-args=-Ddisable_quadblas=true"
     steps:
       - uses: actions/checkout@v6
         with:
@@ -51,27 +57,21 @@ jobs:
         env:
           LDFLAGS: "-fopenmp"
         run: |
-          # For Sandy Bridge (x86-64-v2), we need to disable FMA code paths
-          # since FMA instructions are not available on that microarchitecture
-          if [ "${{ matrix.cpu[0] }}" = "snb" ]; then
-            pip install .[test] --no-build-isolation -v -Csetup-args=-Ddisable_fma=true
-          else
-            pip install .[test] --no-build-isolation -v
-          fi
+          pip install .[test] --no-build-isolation -v ${{ matrix.config.meson_args }}
 
-      - name: Test import on ${{ matrix.cpu[1] }}
+      - name: Test import on ${{ matrix.config.name }}
         run: |
-          echo "Testing basic import on ${{ matrix.cpu[1] }}..."
-          sde -${{ matrix.cpu[0] }} -- python -c "
+          echo "Testing basic import on ${{ matrix.config.name }}..."
+          sde -${{ matrix.config.sde_cpu }} -- python -c "
           import numpy as np
           print('NumPy version:', np.__version__)
           from numpy_quaddtype import QuadPrecDType
           print('QuadPrecDType imported successfully!')
           arr = np.zeros(3, dtype=QuadPrecDType())
           print('Created quad array:', arr)
-          print('SUCCESS: Works on ${{ matrix.cpu[1] }}!')
+          print('SUCCESS: Works on ${{ matrix.config.name }}!')
           "
 
-      - name: Run tests on ${{ matrix.cpu[1] }}
+      - name: Run tests on ${{ matrix.config.name }}
         run: |
-          sde -${{ matrix.cpu[0] }} -- python -m pytest tests/ -v --tb=short -v -s
+          sde -${{ matrix.config.sde_cpu }} -- python -m pytest tests/ -v --tb=short -v -s

.gitignore

@@ -146,3 +146,4 @@ compile_commands.json
 
 # docs
 /docs/_build/
+build_log.txt

meson.build

@@ -15,10 +15,7 @@ if is_windows
   add_project_arguments('-DWIN32', '-D_WINDOWS', language : ['c', 'cpp'])
 endif
 
-qblas_dep = dependency('qblas', fallback: ['qblas', 'qblas_dep'])
 
-# Try to find SLEEF system-wide first, fall back to subproject if not found
-# Required SLEEF version (must match sleef.wrap revision)
 required_sleef_version = '3.9.0'
 # Don't use fallback here - we need to call subproject() explicitly later with disable_fma option
 sleef_dep = dependency('sleef', version: '>=' + required_sleef_version, required: false)
@@ -30,7 +27,7 @@ if sleef_dep.found() and sleef_dep.version().startswith(required_sleef_version)
   # SLEEF found system-wide - verify quad-precision support
   cpp = meson.get_compiler('cpp')
   sleefquad_lib = cpp.find_library('sleefquad', required: false)
-  
+
   if sleefquad_lib.found()
     sleefquad_test_code = '''
     #include <sleefquad.h>
@@ -48,7 +45,7 @@ if sleef_dep.found() and sleef_dep.version().startswith(required_sleef_version)
       dependencies: [sleef_dep, sleefquad_lib],
       name: 'SLEEF quad-precision support'
     )
-    
+
     if quad_works
       sleefquad_dep = declare_dependency(
         dependencies: [sleef_dep, sleefquad_lib]
@@ -80,6 +77,23 @@ else
   message('Proceeding with vendored SLEEF subproject instead')
 endif
 
+# QBLAS does not build under MSVC (GCC-only flags, POSIX-only APIs, GCC
+# built-ins for CPUID); force-disable it on Windows. Users on other
+# platforms can opt out via -Ddisable_quadblas=true to fall back to the
+# naive matmul kernel.
+disable_quadblas = is_windows or get_option('disable_quadblas')
+if disable_quadblas
+  if is_windows
+    message('QBLAS disabled (Windows / MSVC) - using naive matmul kernel')
+  else
+    message('QBLAS disabled by user option - using naive matmul kernel')
+  endif
+  add_project_arguments('-DDISABLE_QUADBLAS', language: ['c', 'cpp'])
+  qblas_dep = declare_dependency()
+else
+  qblas_dep = dependency('qblas', fallback: ['qblas', 'qblas_dep'])
+endif
+
 incdir_numpy = run_command(py,
   ['-c', 'import numpy; print(numpy.get_include())'],
   check : true
@@ -101,12 +115,6 @@ npymath_lib = c.find_library('npymath', dirs: npymath_path)
 
 dependencies = [py_dep, qblas_dep, sleef_dep, sleefquad_dep, npymath_lib]
 
-# Add OpenMP dependency (optional, for threading)
-openmp_dep = dependency('openmp', required: false, static: false)
-if openmp_dep.found()
-    dependencies += openmp_dep
-endif
-
 # compiler flags for QBLAS compatibility
 if not is_windows
     # QBLAS requires extended numeric literals for Q suffix support

meson.options

@@ -1,3 +1,9 @@
 option('disable_fma', type: 'boolean', value: false,
        description: 'Disable FMA (Fused Multiply-Add) code paths' +
-                    'Set to true when building for older CPUs like Sandy Bridge that lack FMA support.')
+                    'Set to true when building for older CPUs like Sandy Bridge that lack FMA support.')
+
+option('disable_quadblas', type: 'boolean', value: false,
+       description: 'Skip the QBLAS subproject and fall back to naive ' +
+                    'matmul kernels. Auto-enabled on Windows because ' +
+                    'QBLAS uses GCC/POSIX-only constructs that do not ' +
+                    'build under MSVC.')

src/csrc/casts.cpp

@@ -1223,13 +1223,25 @@ from_quad<spec_npy_bool>(const quad_value *x, QuadBackendType backend)
     }
 }
 
+// NumPy convention: casting NaN to any integer type yields 0.
+// Without this, SLEEF saturates NaN to INT_MAX / UINT_MAX, and the
+// long-double path invokes undefined behavior. See gh-98.
+static inline bool
+quad_is_nan(const quad_value *x, QuadBackendType backend)
+{
+    if (backend == BACKEND_SLEEF) {
+        return quad_isnan(&x->sleef_value);
+    }
+    return std::isnan(x->longdouble_value);
+}
+
 template <>
 inline npy_byte
 from_quad<npy_byte>(const quad_value *x, QuadBackendType backend)
 {
-    // runtime warnings often comes from/to casting of NaN, inf
-    // casting is used by ops at several positions leading to warnings
-    // fix can be catching the cases and returning corresponding type value without casting
+    if (quad_is_nan(x, backend)) {
+        return (npy_byte)0;
+    }
     if (backend == BACKEND_SLEEF) {
         return (npy_byte)Sleef_cast_to_int64q1(x->sleef_value);
     }
@@ -1242,6 +1254,9 @@ template <>
 inline npy_ubyte
 from_quad<npy_ubyte>(const quad_value *x, QuadBackendType backend)
 {
+    if (quad_is_nan(x, backend)) {
+        return (npy_ubyte)0;
+    }
     if (backend == BACKEND_SLEEF) {
         return (npy_ubyte)Sleef_cast_to_uint64q1(x->sleef_value);
     }
@@ -1254,6 +1269,9 @@ template <>
 inline npy_short
 from_quad<npy_short>(const quad_value *x, QuadBackendType backend)
 {
+    if (quad_is_nan(x, backend)) {
+        return (npy_short)0;
+    }
     if (backend == BACKEND_SLEEF) {
         return (npy_short)Sleef_cast_to_int64q1(x->sleef_value);
     }
@@ -1266,6 +1284,9 @@ template <>
 inline npy_ushort
 from_quad<npy_ushort>(const quad_value *x, QuadBackendType backend)
 {
+    if (quad_is_nan(x, backend)) {
+        return (npy_ushort)0;
+    }
     if (backend == BACKEND_SLEEF) {
         return (npy_ushort)Sleef_cast_to_uint64q1(x->sleef_value);
     }
@@ -1278,6 +1299,9 @@ template <>
 inline npy_int
 from_quad<npy_int>(const quad_value *x, QuadBackendType backend)
 {
+    if (quad_is_nan(x, backend)) {
+        return (npy_int)0;
+    }
     if (backend == BACKEND_SLEEF) {
         return (npy_int)Sleef_cast_to_int64q1(x->sleef_value);
     }
@@ -1290,6 +1314,9 @@ template <>
 inline npy_uint
 from_quad<npy_uint>(const quad_value *x, QuadBackendType backend)
 {
+    if (quad_is_nan(x, backend)) {
+        return (npy_uint)0;
+    }
     if (backend == BACKEND_SLEEF) {
         return (npy_uint)Sleef_cast_to_uint64q1(x->sleef_value);
     }
@@ -1302,6 +1329,9 @@ template <>
 inline npy_long
 from_quad<npy_long>(const quad_value *x, QuadBackendType backend)
 {
+    if (quad_is_nan(x, backend)) {
+        return (npy_long)0;
+    }
     if (backend == BACKEND_SLEEF) {
         return (npy_long)Sleef_cast_to_int64q1(x->sleef_value);
     }
@@ -1314,6 +1344,9 @@ template <>
 inline npy_ulong
 from_quad<npy_ulong>(const quad_value *x, QuadBackendType backend)
 {
+    if (quad_is_nan(x, backend)) {
+        return (npy_ulong)0;
+    }
     if (backend == BACKEND_SLEEF) {
         return (npy_ulong)Sleef_cast_to_uint64q1(x->sleef_value);
     }
@@ -1326,6 +1359,9 @@ template <>
 inline npy_longlong
 from_quad<npy_longlong>(const quad_value *x, QuadBackendType backend)
 {
+    if (quad_is_nan(x, backend)) {
+        return (npy_longlong)0;
+    }
     if (backend == BACKEND_SLEEF) {
         return Sleef_cast_to_int64q1(x->sleef_value);
     }
@@ -1338,6 +1374,9 @@ template <>
 inline npy_ulonglong
 from_quad<npy_ulonglong>(const quad_value *x, QuadBackendType backend)
 {
+    if (quad_is_nan(x, backend)) {
+        return (npy_ulonglong)0;
+    }
     if (backend == BACKEND_SLEEF) {
         return Sleef_cast_to_uint64q1(x->sleef_value);
     }