ahh stupid me :), fallback to naive for MSVC

Author: SwayamInSync

quaddtype/numpy_quaddtype/__init__.py

@@ -39,8 +39,4 @@ def LongDoubleQuadPrecDType():
 ln10 = get_sleef_constant("ln10")
 max_value = get_sleef_constant("quad_max")
 min_value = get_sleef_constant("quad_min")
-epsilon = get_sleef_constant("epsilon")
-
-num_cores = multiprocessing.cpu_count()
-# set default number of threads for QuadBLAS
-set_num_threads(num_cores)
+epsilon = get_sleef_constant("epsilon")

quaddtype/numpy_quaddtype/src/quadblas_interface.cpp

@@ -1,10 +1,16 @@
 #include "quadblas_interface.h"
-#include "../QBLAS/include/quadblas/quadblas.hpp"
 #include <cstring>
 #include <algorithm>
 
+#ifndef DISABLE_QUADBLAS
+#include "../QBLAS/include/quadblas/quadblas.hpp"
+#endif // DISABLE_QUADBLAS
+
 extern "C" {
 
+
+#ifndef  DISABLE_QUADBLAS
+
 int
 qblas_dot(size_t n, Sleef_quad *x, size_t incx, Sleef_quad *y, size_t incy, Sleef_quad *result)
 {
@@ -138,4 +144,90 @@ py_quadblas_get_version(PyObject *self, PyObject *args)
     return PyUnicode_FromString("QuadBLAS 1.0.0 - High Performance Quad Precision BLAS");
 }
 
+int
+quadblas_set_num_threads(int num_threads)
+{
+    QuadBLAS::set_num_threads(num_threads);
+    return 0;
+}
+
+int
+quadblas_get_num_threads(void)
+{
+    int num_threads = QuadBLAS::get_num_threads();
+    return num_threads;
+}
+
+#else  // DISABLE_QUADBLAS
+
+
+int
+qblas_dot(size_t n, Sleef_quad *x, size_t incx, Sleef_quad *y, size_t incy, Sleef_quad *result)
+{
+    return -1;  // QBLAS is disabled, dot product not available
+}
+
+int
+qblas_gemv(char layout, char trans, size_t m, size_t n, Sleef_quad *alpha, Sleef_quad *A,
+           size_t lda, Sleef_quad *x, size_t incx, Sleef_quad *beta, Sleef_quad *y, size_t incy)
+{
+    return -1;  // QBLAS is disabled, GEMV not available
+}
+
+int
+qblas_gemm(char layout, char transa, char transb, size_t m, size_t n, size_t k, Sleef_quad *alpha,
+           Sleef_quad *A, size_t lda, Sleef_quad *B, size_t ldb, Sleef_quad *beta, Sleef_quad *C,
+           size_t ldc)
+{
+    return -1;  // QBLAS is disabled, GEMM not available
+}
+
+int
+qblas_supports_backend(QuadBackendType backend)
+{
+    return -1; // QBLAS is disabled, backend support not available
+}
+
+PyObject *
+py_quadblas_set_num_threads(PyObject *self, PyObject *args)
+{
+    // raise error
+    PyErr_SetString(PyExc_NotImplementedError, "QuadBLAS is disabled");
+    return NULL;
+}
+
+PyObject *
+py_quadblas_get_num_threads(PyObject *self, PyObject *args)
+{
+    // raise error
+    PyErr_SetString(PyExc_NotImplementedError, "QuadBLAS is disabled");
+    return NULL;
+}
+
+PyObject *
+py_quadblas_get_version(PyObject *self, PyObject *args)
+{
+    // raise error
+    PyErr_SetString(PyExc_NotImplementedError, "QuadBLAS is disabled");
+    return NULL;
+}
+
+int
+quadblas_set_num_threads(int num_threads)
+{
+    // raise error
+    PyErr_SetString(PyExc_NotImplementedError, "QuadBLAS is disabled");
+    return -1;
+}
+
+int
+quadblas_get_num_threads(void)
+{
+    // raise error
+    PyErr_SetString(PyExc_NotImplementedError, "QuadBLAS is disabled");
+    return -1;
+}
+
+#endif // DISABLE_QUADBLAS
+
 }  // extern "C"

quaddtype/numpy_quaddtype/src/quadblas_interface.h

@@ -32,6 +32,11 @@ py_quadblas_get_num_threads(PyObject *self, PyObject *args);
 PyObject *
 py_quadblas_get_version(PyObject *self, PyObject *args);
 
+int
+quadblas_set_num_threads(int num_threads);
+int
+quadblas_get_num_threads(void);
+
 #ifdef __cplusplus
 }
 #endif

quaddtype/numpy_quaddtype/src/umath/matmul.cpp

@@ -289,10 +289,21 @@ init_matmul_ops(PyObject *numpy)
 
     PyArray_DTypeMeta *dtypes[3] = {&QuadPrecDType, &QuadPrecDType, &QuadPrecDType};
 
+    #ifndef DISABLE_QUADBLAS
+    // set threading to max
+    int num_threads = quadblas_get_num_threads();
+    quadblas_set_num_threads(num_threads);
+    
     PyType_Slot slots[] = {{NPY_METH_resolve_descriptors, (void *)&quad_matmul_resolve_descriptors},
                            {NPY_METH_strided_loop, (void *)&quad_matmul_strided_loop},
                            {NPY_METH_unaligned_strided_loop, (void *)&naive_matmul_strided_loop},
                            {0, NULL}};
+    #else
+    PyType_Slot slots[] = {{NPY_METH_resolve_descriptors, (void *)&quad_matmul_resolve_descriptors},
+                           {NPY_METH_strided_loop, (void *)&naive_matmul_strided_loop},
+                           {NPY_METH_unaligned_strided_loop, (void *)&naive_matmul_strided_loop},
+                           {0, NULL}};
+    #endif // DISABLE_QUADBLAS
 
     PyArrayMethod_Spec Spec = {
             .name = "quad_matmul_qblas",