updates for free-threading

Author: jcapriot

.github/workflows/python-package-conda.yml

@@ -22,41 +22,51 @@ jobs:
     strategy:
       fail-fast: False
       matrix:
-        os: [ubuntu-latest, macos-12, windows-latest]
-        python-version: ["3.10", "3.11", "3.12", "3.13"]
-        mkl-version: ['2023', '2024']
+        os: [ubuntu-latest, windows-latest]
+        python-version: ["3.11", "3.12", "3.13", "3.14"]
+        mkl-version: ['2024', '2025']
+        free-threaded: [true, false]
         include:
           - os: ubuntu-latest
             python-version: "3.12"
             coverage: ${{ true }}
+          - os: macos-15-intel
+            python-version: "3.12"
+            mkl-version: "2023"
+            free-threaded: false
         exclude:
-          - os: macos-12
-            mkl-version: "2024"
+          - python-version: "3.11"
+            free-threaded: true
+          - python-version: "3.12"
+            free-threaded: true
 
     steps:
-    - uses: actions/checkout@v4
+    - uses: actions/checkout@v5
+      with:
+        fetch-depth: 0
+
     - name: Setup Conda
       uses: conda-incubator/setup-miniconda@v3
       with:
-        python-version: ${{ matrix.python-version }}
         channels: conda-forge, defaults
         channel-priority: true
         activate-environment: dev
 
-    - name: Conda information
-      run: |
-        conda info
-        conda list
-        conda config --show
-
     - name: Create environment
       run: |
         conda install --quiet --yes -c conda-forge \
+          ${{ matrix.free-threaded && "python-freethreaded" || "python" }}=${{ matrix.python-version }} \
           pip numpy scipy cython mkl=${{ matrix.mkl-version }} pytest \
           mkl-devel pkg-config meson-python meson ninja setuptools_scm \
           ${{ matrix.coverage && 'coverage' || ''}} \
           ${{ matrix.os == 'windows-latest' && '"libblas=*=*mkl"' || ''}}
 
+    - name: Conda information
+      run: |
+        conda info
+        conda list
+        conda config --show
+
     - name: Install Our Package
       run: |
         python -m pip install --no-build-isolation --verbose --editable . \

.gitignore

@@ -10,3 +10,5 @@ mkl_solver.c.dep
 coverage.xml
 
 .idea/
+
+.vscode/

pydiso/_mkl_solver.pyx.in renamed to pydiso/_mkl_solver.in.pyx

@@ -1,13 +1,8 @@
-#cython: language_level=3
+# cython: language_level=3
+# cython: embedsignature=True, language_level=3
+# cython: freethreading_compatible=True
 cimport numpy as np
 import cython
-from cpython.pythread cimport (
-    PyThread_type_lock,
-    PyThread_allocate_lock,
-    PyThread_acquire_lock,
-    PyThread_release_lock,
-    PyThread_free_lock
-)
 
 import numpy as np
 import os
@@ -79,7 +74,6 @@ class PardisoError(Exception):
 class PardisoWarning(UserWarning):
     pass
 
-
 #call pardiso (pt, maxfct, mnum, mtype, phase, n, a, ia, ja, perm, nrhs, iparm, msglvl, b, x, error)
 cdef int mkl_progress(int *thread, int* step, char* stage, int stage_len) nogil:
     # must be a nogil process to pass to mkl pardiso progress reporting
@@ -175,7 +169,7 @@ ctypedef fused real_or_complex:
 {{for int_type in ["int_t", "long_t"]}}
 cdef class _PardisoHandle_{{int_type}}:
     cdef _MKL_DSS_HANDLE_t handle[64]
-    cdef PyThread_type_lock lock
+    cdef cython.pymutex lock
 
     cdef {{int_type}} n, maxfct, mnum, msglvl
     cdef public {{int_type}} matrix_type
@@ -184,7 +178,6 @@ cdef class _PardisoHandle_{{int_type}}:
 
     @cython.boundscheck(False)
     def __cinit__(self, A_dat_dtype, n, matrix_type, maxfct, mnum, msglvl):
-        self.lock = PyThread_allocate_lock()
 
         np_int_dtype = np.dtype(f"i{sizeof({{int_type}})}")
 
@@ -197,11 +190,13 @@ cdef class _PardisoHandle_{{int_type}}:
         self.mnum = mnum
         self.msglvl = msglvl
 
-        if self.msglvl:
-            #for reporting factorization progress via python's `print`
-            mkl_set_progress(mkl_progress)
-        else:
-            mkl_set_progress(mkl_no_progress)
+
+        with self.lock:
+            if self.msglvl:
+                #for reporting factorization progress via python's `print`
+                mkl_set_progress(mkl_progress)
+            else:
+                mkl_set_progress(mkl_no_progress)
 
         is_single_precision = np.issubdtype(A_dat_dtype, np.single) or np.issubdtype(A_dat_dtype, np.csingle)
 
@@ -264,14 +259,13 @@ cdef class _PardisoHandle_{{int_type}}:
         cdef {{int_type}} error, nrhs
         with nogil:
             nrhs = rhs.shape[1]
-            PyThread_acquire_lock(self.lock, mode=1)
-            pardiso{{if int_type == "long_t"}}_64{{endif}}(
-                    self.handle, &self.maxfct, &self.mnum, &self.matrix_type, &phase, &self.n,
-                    &a_data[0], &a_indptr[0], &a_indices[0], &self.perm[0],
-                    &nrhs, self.iparm, &self.msglvl,
-                    &rhs[0, 0], &out[0, 0], &error
-                )
-            PyThread_release_lock(self.lock)
+            with self.lock:
+                pardiso{{if int_type == "long_t"}}_64{{endif}}(
+                        self.handle, &self.maxfct, &self.mnum, &self.matrix_type, &phase, &self.n,
+                        &a_data[0], &a_indptr[0], &a_indices[0], &self.perm[0],
+                        &nrhs, self.iparm, &self.msglvl,
+                        &rhs[0, 0], &out[0, 0], &error
+                    )
         return error
 
     @cython.boundscheck(False)
@@ -280,20 +274,15 @@ cdef class _PardisoHandle_{{int_type}}:
         cdef {{int_type}} phase = -1, nrhs = 0, error = 0
 
         with nogil:
-            PyThread_acquire_lock(self.lock, mode=1)
-            if self._initialized():
-                pardiso{{if int_type == "long_t"}}_64{{endif}}(
-                            self.handle, &self.maxfct, &self.mnum, &self.matrix_type,
-                            &phase, &self.n, NULL, NULL, NULL, NULL, &nrhs, self.iparm,
-                            &self.msglvl, NULL, NULL, &error)
-                if error == 0:
-                    for i in range(64):
-                        self.handle[i] = NULL
-            PyThread_release_lock(self.lock)
+            with self.lock:
+                if self._initialized():
+                    pardiso{{if int_type == "long_t"}}_64{{endif}}(
+                                self.handle, &self.maxfct, &self.mnum, &self.matrix_type,
+                                &phase, &self.n, NULL, NULL, NULL, NULL, &nrhs, self.iparm,
+                                &self.msglvl, NULL, NULL, &error)
+                    if error == 0:
+                        for i in range(64):
+                            self.handle[i] = NULL
         if error != 0:
             raise MemoryError("Pardiso Memory release error: " + _err_messages[error])
-        if self.lock:
-            #deallocate the lock
-            PyThread_free_lock(self.lock)
-            self.lock = NULL
 {{endfor}}

pydiso/meson.build

@@ -1,5 +1,5 @@
 cython_file = custom_target(
-    input: '_mkl_solver.pyx.in',
+    input: '_mkl_solver.in.pyx',
     output: '_mkl_solver.pyx',
     command: [py,
   '-c',
@@ -60,6 +60,11 @@ else
 
 endif
 
+cython_args = []
+if cy.version().version_compare('>=3.1.0')
+  cython_args += ['-Xfreethreading_compatible=True']
+endif
+
 c_undefined_ok = ['-Wno-maybe-uninitialized']
 cython_c_args = [numpy_nodepr_api, '-DCYTHON_CCOMPLEX=0']
 
@@ -68,6 +73,7 @@ module_path = 'pydiso'
 py.extension_module(
     '_mkl_solver',
     cython_file,
+    cython_args: cython_args,
     c_args: cython_c_args,
     install: true,
     subdir: module_path,

pyproject.toml

@@ -3,7 +3,7 @@
 build-backend = 'mesonpy'
 requires = [
     "meson-python>=0.15.0",
-    "Cython>=3.0.8",
+    "Cython>=3.1.0",
     "setuptools_scm[toml]>=6.2",
     "numpy>=2.0.0rc1",
 ]
@@ -13,7 +13,7 @@ name = 'pydiso'
 dynamic = ["version"]
 description = "Wrapper for intel's pardiso implementation in the MKL"
 readme = 'README.md'
-requires-python = '>=3.10'
+requires-python = '>=3.11'
 authors = [
   {name = 'SimPEG developers', email = '[email protected]'},
 ]
@@ -28,7 +28,7 @@ dependencies = [
     # TODO: update to "pin-compatible" once possible, see
     # https://github.com/mesonbuild/meson-python/issues/29
     "numpy>=1.22.4",
-    "scipy>=1.8",
+    "scipy>=1.12",
 ]
 classifiers = [
     "Development Status :: 4 - Beta",
@@ -57,11 +57,11 @@ test = [
 ]
 
 build = [
-    "meson-python>=0.14.0",
+    "meson-python>=0.15.0",
     "meson",
     "ninja",
-    "numpy>=1.22.4",
-    "cython>=0.29.35",
+    "numpy>=2.0.0rc1",
+    "cython>=3.1.0",
     "setuptools_scm",
 ]
 
@@ -74,7 +74,6 @@ Repository = 'https://github.com/simpeg/pydiso.git'
 
 [tool.coverage.run]
 branch = true
-plugins = ["Cython.Coverage"]
 source = ["pydiso", "tests"]
 
 [tool.coverage.report]