scs 0.5.6 → 0.6.0

data/vendor/scs/linsys/cpu/indirect/private.h

@@ -25,6 +25,34 @@ struct SCS_LIN_SYS_WORK {
   /* preconditioning */
   scs_float *z;
   scs_float *M;
+  /* eigCG deflation (Stathopoulos & Orginos 2010). During the deep
+   * solve for g = K^{-1}h (cold, run to CG_BEST_TOL, once per metric
+   * change) the CG recurrence is observed -- never perturbed -- and
+   * approximate eigenvectors of the smallest eigenvalues of the
+   * preconditioned operator are extracted by thick-restarted Lanczos on
+   * CG's own scalars. Later warm solves Galerkin-project their initial
+   * residual against this near-invariant subspace, which removes the
+   * slowly-converging components; because the subspace is
+   * near-invariant, CG does not reintroduce them. Discarded whenever
+   * the metric changes; the deep re-solve re-harvests. */
+  scs_float *dfl_p;  /* W: harvested eigenvectors, n x dfl_max */
+  scs_float *dfl_Ap; /* A W images, n x dfl_max */
+  scs_float *dfl_G;  /* Cholesky factor of W'AW, dfl_max x dfl_max */
+  scs_float *dfl_c;  /* projection coefficients, dfl_max */
+  scs_int dfl_max, dfl_count, dfl_harvest;
+  /* eigCG window state (live only while harvesting) */
+  scs_float *eig_V;    /* n x eig_win basis (Lanczos / locked Ritz) */
+  scs_float *eig_T;    /* eig_win x eig_win projected operator */
+  scs_float *eig_E;    /* eig_win x eig_win syev scratch */
+  scs_float *eig_w;    /* eigenvalue scratch */
+  scs_float *eig_S;    /* eig_win x 2 dfl_max restart stack */
+  scs_float *eig_TS;   /* eig_win x 2 dfl_max scratch */
+  scs_float *eig_H;    /* 2 dfl_max x 2 dfl_max small projection */
+  scs_float *eig_G;    /* eig_win x 2 dfl_max restart transform */
+  scs_float *eig_VS;   /* n x 2 dfl_max basis-update scratch */
+  scs_float *eig_work; /* syev workspace */
+  scs_int eig_win, eig_j, eig_jd, eig_step, eig_have_prev, eig_dead, eig_lwork;
+  scs_float eig_pa, eig_pb; /* previous iteration's alpha / beta */
   /* reporting */
   scs_int tot_cg_its;
   const scs_float *diag_r;

data/vendor/scs/linsys/csparse.c

@@ -205,11 +205,17 @@ ScsMatrix *SCS(form_kkt)(const ScsMatrix *A, const ScsMatrix *P,
   }
 
   idx_mapping = (scs_int *)scs_calloc(count, sizeof(scs_int));
-  Kcsc = SCS(cs_compress)(K, count, idx_mapping);
-  for (i = 0; i < m + n; i++) {
-    diag_r_idxs[i] = idx_mapping[diag_r_idxs[i]];
+  if (!idx_mapping) {
+    SCS(cs_spfree)(K);
+    return SCS_NULL;
   }
+  Kcsc = SCS(cs_compress)(K, count, idx_mapping);
   SCS(cs_spfree)(K);
+  if (Kcsc) {
+    for (i = 0; i < m + n; i++) {
+      diag_r_idxs[i] = idx_mapping[diag_r_idxs[i]];
+    }
+  }
   scs_free(idx_mapping);
   return Kcsc;
 }

data/vendor/scs/linsys/csparse.h

@@ -1,4 +1,7 @@
-/* Routines modified from CSparse, T. Davis et al */
+/*
+ * Sparse matrix utilities adapted from CSparse (T. Davis).
+ * Provides allocation, triplet-to-CSC compression, and KKT matrix formation.
+ */
 
 #ifndef CS_H_GUARD
 #define CS_H_GUARD
@@ -8,7 +11,6 @@ extern "C" {
 #endif
 
 #include "glbopts.h"
-#include "scs.h"
 
 ScsMatrix *SCS(cs_spalloc)(scs_int m, scs_int n, scs_int nzmax, scs_int values,
                            scs_int triplet);

data/vendor/scs/linsys/cudss/direct/private.c

@@ -1,5 +1,6 @@
 #include "private.h"
 #include "linsys.h"
+#include <string.h>
 
 /* In case of error abort freeing p */
 #define CUDSS_CHECK_ABORT(call, p, fname)                                      \
@@ -31,7 +32,23 @@ const char *scs_get_lin_sys_method() {
 /* Free allocated resources for the linear system solver */
 void scs_free_lin_sys_work(ScsLinSysWork *p) {
   if (p) {
-    /* Free GPU resources */
+    /* Free cuDSS resources first, before freeing the GPU memory they reference */
+    if (p->solver_data && p->handle)
+      cudssDataDestroy(p->handle, p->solver_data);
+    if (p->solver_config)
+      cudssConfigDestroy(p->solver_config);
+
+    if (p->d_kkt_mat)
+      cudssMatrixDestroy(p->d_kkt_mat);
+    if (p->d_b_mat)
+      cudssMatrixDestroy(p->d_b_mat);
+    if (p->d_sol_mat)
+      cudssMatrixDestroy(p->d_sol_mat);
+
+    if (p->handle)
+      cudssDestroy(p->handle);
+
+    /* Free GPU memory */
     if (p->d_kkt_val)
       cudaFree(p->d_kkt_val);
     if (p->d_kkt_row_ptr)
@@ -43,26 +60,15 @@ void scs_free_lin_sys_work(ScsLinSysWork *p) {
     if (p->d_sol)
       cudaFree(p->d_sol);
 
-    /* Free cuDSS resources */
-    if (p->d_kkt_mat)
-      cudssMatrixDestroy(p->d_kkt_mat);
-    if (p->d_b_mat)
-      cudssMatrixDestroy(p->d_b_mat);
-    if (p->d_sol_mat)
-      cudssMatrixDestroy(p->d_sol_mat);
-
-    if (p->solver_config)
-      cudssConfigDestroy(p->solver_config);
-    if (p->solver_data && p->handle)
-      cudssDataDestroy(p->handle, p->solver_data);
-    if (p->handle)
-      cudssDestroy(p->handle);
+    /* Free pinned host memory */
+    if (p->h_b_pinned)
+      cudaFreeHost(p->h_b_pinned);
+    if (p->h_sol_pinned)
+      cudaFreeHost(p->h_sol_pinned);
 
     /* Free CPU resources */
     if (p->kkt)
       SCS(cs_spfree)(p->kkt);
-    if (p->sol)
-      scs_free(p->sol);
     if (p->diag_r_idxs)
       scs_free(p->diag_r_idxs);
     if (p->diag_p)
@@ -85,12 +91,6 @@ ScsLinSysWork *scs_init_lin_sys_work(const ScsMatrix *A, const ScsMatrix *P,
   p->n_plus_m = p->n + p->m;
 
   /* Allocate CPU memory */
-  p->sol = (scs_float *)scs_malloc(sizeof(scs_float) * p->n_plus_m);
-  if (!p->sol) {
-    scs_free_lin_sys_work(p);
-    return SCS_NULL;
-  }
-
   p->diag_r_idxs = (scs_int *)scs_calloc(p->n_plus_m, sizeof(scs_int));
   if (!p->diag_r_idxs) {
     scs_free_lin_sys_work(p);
@@ -112,9 +112,6 @@ ScsLinSysWork *scs_init_lin_sys_work(const ScsMatrix *A, const ScsMatrix *P,
     return SCS_NULL;
   }
 
-  cudssStatus_t status;
-  cudaError_t cuda_error;
-
   /* Create cuDSS handle */
   CUDSS_CHECK_ABORT(cudssCreate(&p->handle), p, "cudssCreate");
   /* Creating cuDSS solver configuration and data objects */
@@ -154,11 +151,23 @@ ScsLinSysWork *scs_init_lin_sys_work(const ScsMatrix *A, const ScsMatrix *P,
   cudssMatrixType_t mtype = CUDSS_MTYPE_SYMMETRIC;
   cudssMatrixViewType_t mview = CUDSS_MVIEW_LOWER;
   cudssIndexBase_t base = CUDSS_BASE_ZERO;
+  /* cuDSS 0.8.0+ added an offsetType parameter before indexType. The two
+   * arrays use the same scs_int type for us, so we pass SCS_CUDA_INDEX
+   * twice. */
+#if SCS_CUDSS_NEW_API
+  CUDSS_CHECK_ABORT(cudssMatrixCreateCsr(
+                        &p->d_kkt_mat, p->kkt->m, p->kkt->n, nnz,
+                        p->d_kkt_row_ptr, NULL, p->d_kkt_col_ind, p->d_kkt_val,
+                        SCS_CUDA_INDEX, SCS_CUDA_INDEX, SCS_CUDA_FLOAT,
+                        mtype, mview, base),
+                    p, "cudssMatrixCreateCsr");
+#else
   CUDSS_CHECK_ABORT(cudssMatrixCreateCsr(
                         &p->d_kkt_mat, p->kkt->m, p->kkt->n, nnz,
                         p->d_kkt_row_ptr, NULL, p->d_kkt_col_ind, p->d_kkt_val,
                         SCS_CUDA_INDEX, SCS_CUDA_FLOAT, mtype, mview, base),
                     p, "cudssMatrixCreateCsr");
+#endif
 
   /* Allocate device memory for vectors */
   CUDA_CHECK_ABORT(
@@ -168,6 +177,14 @@ ScsLinSysWork *scs_init_lin_sys_work(const ScsMatrix *A, const ScsMatrix *P,
       cudaMalloc((void **)&p->d_sol, p->n_plus_m * sizeof(scs_float)), p,
       "cudaMalloc: sol");
 
+  /* Allocate pinned host memory for faster H<->D transfers in solve loop */
+  CUDA_CHECK_ABORT(
+      cudaMallocHost((void **)&p->h_b_pinned, p->n_plus_m * sizeof(scs_float)),
+      p, "cudaMallocHost: b");
+  CUDA_CHECK_ABORT(cudaMallocHost((void **)&p->h_sol_pinned,
+                                  p->n_plus_m * sizeof(scs_float)),
+                   p, "cudaMallocHost: sol");
+
   /* Create RHS and solution matrix descriptors */
   scs_int nrhs = 1;
   CUDSS_CHECK_ABORT(cudssMatrixCreateDn(&p->d_b_mat, p->n_plus_m, nrhs,
@@ -191,24 +208,39 @@ ScsLinSysWork *scs_init_lin_sys_work(const ScsMatrix *A, const ScsMatrix *P,
                                  p->d_sol_mat, p->d_b_mat),
                     p, "cudssExecute: factorization");
 
+  /* Inertia check: verify P is PSD by checking positive eigenvalue count */
+  {
+    scs_int inertia[2]; /* [0] = positive, [1] = negative */
+    size_t inertia_written;
+    CUDSS_CHECK_ABORT(
+        cudssDataGet(p->handle, p->solver_data, CUDSS_DATA_INERTIA, inertia,
+                     sizeof(inertia), &inertia_written),
+        p, "cudssDataGet: inertia");
+    if (inertia[0] < p->n) {
+      scs_printf("KKT matrix has < n positive eigenvalues. P not PSD.");
+      scs_free_lin_sys_work(p);
+      return SCS_NULL;
+    }
+  }
+
   return p;
 }
 
 /* Solve the linear system for a given RHS b */
 scs_int scs_solve_lin_sys(ScsLinSysWork *p, scs_float *b, const scs_float *ws,
                           scs_float tol) {
-  /* Copy right-hand side to device */
-  cudaError_t custatus = cudaMemcpy(p->d_b, b, p->n_plus_m * sizeof(scs_float),
-                                    cudaMemcpyHostToDevice);
+  size_t vec_bytes = p->n_plus_m * sizeof(scs_float);
+
+  /* Copy RHS to pinned staging buffer, then to device */
+  memcpy(p->h_b_pinned, b, vec_bytes);
+  cudaError_t custatus =
+      cudaMemcpy(p->d_b, p->h_b_pinned, vec_bytes, cudaMemcpyHostToDevice);
   if (custatus != cudaSuccess) {
-    scs_printf("scs_solve_lin_sys: Error copying `b` side to device: %d\n",
+    scs_printf("scs_solve_lin_sys: Error copying b to device: %d\n",
                (int)custatus);
     return custatus;
   }
 
-  // is this really needed?
-  cudssMatrixSetValues(p->d_b_mat, p->d_b);
-
   /* Solve the system */
   cudssStatus_t status =
       cudssExecute(p->handle, CUDSS_PHASE_SOLVE, p->solver_config,
@@ -219,20 +251,21 @@ scs_int scs_solve_lin_sys(ScsLinSysWork *p, scs_float *b, const scs_float *ws,
     return status;
   }
 
-  /* Copy solution back to host */
-  custatus = cudaMemcpy(b, p->d_sol, p->n_plus_m * sizeof(scs_float),
-                        cudaMemcpyDeviceToHost);
-  if (status != cudaSuccess) {
+  /* Copy solution from device to pinned staging buffer, then to output */
+  custatus =
+      cudaMemcpy(p->h_sol_pinned, p->d_sol, vec_bytes, cudaMemcpyDeviceToHost);
+  if (custatus != cudaSuccess) {
     scs_printf("scs_solve_lin_sys: Error copying d_sol to host: %d\n",
-               (int)status);
-    return status;
+               (int)custatus);
+    return custatus;
   }
+  memcpy(b, p->h_sol_pinned, vec_bytes);
 
   return 0; /* Success */
 }
 
 /* Update the KKT matrix when R changes */
-void scs_update_lin_sys_diag_r(ScsLinSysWork *p, const scs_float *diag_r) {
+scs_int scs_update_lin_sys_diag_r(ScsLinSysWork *p, const scs_float *diag_r) {
   scs_int i;
 
   /* Update KKT matrix on CPU */
@@ -253,7 +286,7 @@ void scs_update_lin_sys_diag_r(ScsLinSysWork *p, const scs_float *diag_r) {
     scs_printf(
         "scs_update_lin_sys_diag_r: Error copying kkt->x to device: %d\n",
         (int)custatus);
-    return;
+    return (scs_int)custatus;
   }
 
   /* Update the matrix values in cuDSS */
@@ -264,7 +297,7 @@ void scs_update_lin_sys_diag_r(ScsLinSysWork *p, const scs_float *diag_r) {
     scs_printf(
         "scs_update_lin_sys_diag_r: Error updating kkt matrix on device: %d\n",
         (int)status);
-    return;
+    return (scs_int)status;
   }
 
   /* Perform Refactorization with the updated matrix */
@@ -274,6 +307,7 @@ void scs_update_lin_sys_diag_r(ScsLinSysWork *p, const scs_float *diag_r) {
   if (status != CUDSS_STATUS_SUCCESS) {
     scs_printf("scs_update_lin_sys_diag_r: Error during re-factorization: %d\n",
                (int)status);
-    return;
+    return (scs_int)status;
   }
+  return 0;
 }

data/vendor/scs/linsys/cudss/direct/private.h

@@ -5,22 +5,45 @@
 extern "C" {
 #endif
 
+#include "csparse.h"
+#include "linsys.h"
+#include <cuda_runtime.h>
+#include <cudss.h>
+
+/* cuDSS 0.8.0 renamed cudaDataType_t to cudssDataType_t (so CUDA_R_* enum
+ * values become CUDSS_R_*) and added an offsetType parameter to
+ * cudssMatrixCreateCsr. cudss.h exposes CUDSS_VERSION = MAJOR*10000 +
+ * MINOR*100 + PATCH; gate on that so the same source still builds against
+ * older cuDSS (<=0.7.x). */
+#if defined(CUDSS_VERSION) && CUDSS_VERSION >= 800
+#define SCS_CUDSS_NEW_API 1
+#else
+#define SCS_CUDSS_NEW_API 0
+#endif
+
+#if SCS_CUDSS_NEW_API
+#ifndef SFLOAT
+#define SCS_CUDA_FLOAT CUDSS_R_64F
+#else
+#define SCS_CUDA_FLOAT CUDSS_R_32F
+#endif
+#ifndef DLONG
+#define SCS_CUDA_INDEX CUDSS_R_32I
+#else
+#define SCS_CUDA_INDEX CUDSS_R_64I
+#endif
+#else
 #ifndef SFLOAT
 #define SCS_CUDA_FLOAT CUDA_R_64F
 #else
 #define SCS_CUDA_FLOAT CUDA_R_32F
 #endif
-
 #ifndef DLONG
 #define SCS_CUDA_INDEX CUDA_R_32I
 #else
 #define SCS_CUDA_INDEX CUDA_R_64I
 #endif
-
-#include "csparse.h"
-#include "linsys.h"
-#include <cuda_runtime.h>
-#include <cudss.h>
+#endif
 
 struct SCS_LIN_SYS_WORK {
   /* General problem dimensions */
@@ -30,7 +53,6 @@ struct SCS_LIN_SYS_WORK {
 
   /* CPU matrices and vectors */
   ScsMatrix *kkt; /* KKT matrix in CSR format */
-  scs_float *sol; /* solution to the KKT system */
 
   /* cuDSS handle and descriptors */
   cudssHandle_t handle;    /* cuDSS library handle */
@@ -47,6 +69,10 @@ struct SCS_LIN_SYS_WORK {
   scs_float *d_b;   /* device copy of right-hand side */
   scs_float *d_sol; /* device copy of solution */
 
+  /* Pinned host memory for faster H<->D transfers */
+  scs_float *h_b_pinned;   /* pinned host staging buffer for RHS */
+  scs_float *h_sol_pinned; /* pinned host staging buffer for solution */
+
   /* These are required for matrix updates */
   scs_int *diag_r_idxs; /* indices where R appears in the KKT matrix */
   scs_float *diag_p;    /* Diagonal values of P */

data/vendor/scs/linsys/gpu/indirect/private.c

@@ -66,7 +66,7 @@ static void set_preconditioner(ScsLinSysWork *p, const scs_float *diag_r) {
 }
 
 /* no need to update anything in this case */
-void scs_update_lin_sys_diag_r(ScsLinSysWork *p, const scs_float *diag_r) {
+scs_int scs_update_lin_sys_diag_r(ScsLinSysWork *p, const scs_float *diag_r) {
   scs_int i;
 
   /* R_x to gpu */
@@ -81,6 +81,7 @@ void scs_update_lin_sys_diag_r(ScsLinSysWork *p, const scs_float *diag_r) {
 
   /* set preconditioner M on gpu */
   set_preconditioner(p, diag_r);
+  return 0;
 }
 
 void scs_free_lin_sys_work(ScsLinSysWork *p) {
@@ -141,7 +142,7 @@ static void mat_vec(ScsLinSysWork *p, const scs_float *x, scs_float *y) {
   cusparseDnVecSetValues(p->dn_vec_n_p, (void *)y);
 
   /* y = x */
-  cudaMemcpy(y, x, p->n * sizeof(scs_float), cudaMemcpyHostToDevice);
+  cudaMemcpy(y, x, p->n * sizeof(scs_float), cudaMemcpyDeviceToDevice);
   /* y = R_x * x */
   scale_by_diag(p->cublas_handle, p->r_x_gpu, y, p->n);
 
@@ -430,6 +431,9 @@ static scs_int pcg(ScsLinSysWork *pr, const scs_float *s, scs_float *bg,
     ztr_prev = ztr;
     /* ztr = z'r */
     CUBLAS(dot)(cublas_handle, n, r, 1, z, 1, &ztr);
+    if (ztr_prev == 0.) {
+      break;
+    }
     beta = ztr / ztr_prev;
     /* p = beta * p, where beta = ztr / ztr_prev */
     CUBLAS(scal)(cublas_handle, n, &beta, p, 1);

data/vendor/scs/linsys/mkl/direct/private.c

@@ -5,25 +5,56 @@
 #define PARDISO_SOLVE (33)
 #define PARDISO_CLEANUP (-1)
 
-/* TODO: is it necessary to use pardiso_64 and MKL_Set_Interface_Layer ? */
 /*
+ * MKL interface layer constants. MKL has two integer interfaces:
+ *
+ *   LP64  (MKL_INTERFACE_LP64  = 0): BLAS/LAPACK use 32-bit integers (int).
+ *   ILP64 (MKL_INTERFACE_ILP64 = 1): BLAS/LAPACK use 64-bit integers (long long).
+ *
+ * These affect the standard BLAS/LAPACK symbols (dgemm, dpotrf, etc.).
+ * PARDISO has separate entry points for each integer width:
+ *
+ *   pardiso    — 32-bit integer indices (used when !DLONG)
+ *   pardiso_64 — 64-bit integer indices (used when DLONG)
+ *
+ * The pardiso/pardiso_64 choice is independent of the interface layer; each is
+ * a distinct symbol that always uses its own integer width regardless of what
+ * MKL_Set_Interface_Layer says.
+ *
+ * The BLAS integer width is controlled by the use_blas64 meson option:
+ *
+ *   use_blas64=false (default) -> links mkl-dynamic-lp64-*,  expects LP64
+ *   use_blas64=true            -> links mkl-dynamic-ilp64-*, expects ILP64
+ *
+ * See meson.build for the linkage logic. The MKL-specific initialization in
+ * src/scs.c uses BLAS64 to pick the right expected interface layer.
+ *
+ * PARDISO is independent: pardiso_64 always uses 64-bit ints regardless of
+ * the interface layer or BLAS64 setting.
+ */
 #define MKL_INTERFACE_LP64 0
 #define MKL_INTERFACE_ILP64 1
-*/
+
 #ifdef DLONG
 #define _PARDISO pardiso_64
 #else
 #define _PARDISO pardiso
 #endif
 
-/* Prototypes for Pardiso functions */
+/* Prototypes for Pardiso and MKL service functions. */
 void _PARDISO(void **pt, const scs_int *maxfct, const scs_int *mnum,
               const scs_int *mtype, const scs_int *phase, const scs_int *n,
               const scs_float *a, const scs_int *ia, const scs_int *ja,
               scs_int *perm, const scs_int *nrhs, scs_int *iparm,
               const scs_int *msglvl, scs_float *b, scs_float *x,
               scs_int *error);
-/* scs_int MKL_Set_Interface_Layer(scs_int); */
+/* BLAS64 requires DLONG for MKL builds: the interface layer (ILP64) set by
+ * MKL_Set_Interface_Layer must match the PARDISO entry point (pardiso_64).
+ * Without DLONG, pardiso (32-bit) is used but ILP64 makes its internal BLAS
+ * calls expect 64-bit integers, causing hangs or memory corruption. */
+#if defined(BLAS64) && !defined(DLONG)
+#error "MKL PARDISO requires DLONG when BLAS64 is set (pardiso_64 needs 64-bit ints)"
+#endif
 
 const char *scs_get_lin_sys_method() {
   return "sparse-direct-mkl-pardiso";
@@ -31,18 +62,21 @@ const char *scs_get_lin_sys_method() {
 
 void scs_free_lin_sys_work(ScsLinSysWork *p) {
   if (p) {
-    p->phase = PARDISO_CLEANUP;
-    _PARDISO(p->pt, &(p->maxfct), &(p->mnum), &(p->mtype), &(p->phase),
-             &(p->n_plus_m), SCS_NULL, p->kkt->p, p->kkt->i, SCS_NULL,
-             &(p->nrhs), p->iparm, &(p->msglvl), SCS_NULL, SCS_NULL,
-             &(p->error));
-    if (p->error != 0) {
-      scs_printf("Error during MKL Pardiso cleanup: %d", (int)p->error);
-    }
-    if (p->kkt)
+    /* Pardiso cleanup needs the KKT index arrays; on early allocation
+     * failures the workspace may be freed before the KKT matrix (or
+     * the factorization) ever existed, so gate the solver teardown on
+     * what was actually initialized. */
+    if (p->kkt) {
+      p->phase = PARDISO_CLEANUP;
+      _PARDISO(p->pt, &(p->maxfct), &(p->mnum), &(p->mtype), &(p->phase),
+               &(p->n_plus_m), SCS_NULL, p->kkt->p, p->kkt->i, SCS_NULL,
+               &(p->nrhs), p->iparm, &(p->msglvl), SCS_NULL, SCS_NULL,
+               &(p->error));
+      if (p->error != 0) {
+        scs_printf("Error during MKL Pardiso cleanup: %d", (int)p->error);
+      }
       SCS(cs_spfree)(p->kkt);
-    if (p->sol)
-      scs_free(p->sol);
+    }
     if (p->diag_r_idxs)
       scs_free(p->diag_r_idxs);
     if (p->diag_p)
@@ -55,24 +89,18 @@ ScsLinSysWork *scs_init_lin_sys_work(const ScsMatrix *A, const ScsMatrix *P,
                                      const scs_float *diag_r) {
   scs_int i;
   ScsLinSysWork *p = scs_calloc(1, sizeof(ScsLinSysWork));
-
-  /* TODO: is this necessary with pardiso_64? */
-  /* Set MKL interface layer */
-  /*
-#ifdef DLONG
-  MKL_Set_Interface_Layer(MKL_INTERFACE_ILP64);
-#else
-  MKL_Set_Interface_Layer(MKL_INTERFACE_LP64);
-#endif
-  */
+  if (!p)
+    return SCS_NULL;
   p->n = A->n;
   p->m = A->m;
   p->n_plus_m = p->n + p->m;
 
-  /* Even though we overwrite rhs with sol pardiso requires the memory */
-  p->sol = (scs_float *)scs_malloc(sizeof(scs_float) * p->n_plus_m);
   p->diag_r_idxs = (scs_int *)scs_calloc(p->n_plus_m, sizeof(scs_int));
   p->diag_p = (scs_float *)scs_calloc(p->n, sizeof(scs_float));
+  if (!p->diag_r_idxs || !p->diag_p) {
+    scs_free_lin_sys_work(p);
+    return SCS_NULL;
+  }
 
   /* MKL pardiso requires upper triangular CSR matrices. The KKT matrix stuffed
    * as CSC lower triangular is equivalent. Pass upper=0. */
@@ -101,7 +129,9 @@ ScsLinSysWork *scs_init_lin_sys_work(const ScsMatrix *A, const ScsMatrix *P,
   p->iparm[1] = 3;          /* Fill-in reordering from OpenMP */
   p->iparm[5] = 1;          /* Write solution into b */
   p->iparm[7] = 0;          /* Automatic iterative refinement calculation */
-  p->iparm[9] = 8;          /* Perturb the pivot elements with 1E-8 */
+  p->iparm[9] = 13;         /* Perturb the pivot elements with 1E-13 (default) */
+  p->iparm[23] = 1;         /* Two-level scheduling for parallel factorization */
+  p->iparm[24] = 1;         /* Parallel forward/backward solve */
   p->iparm[34] = 1;         /* Use C-style indexing for indices */
   /* p->iparm[36] = -80; */ /* Form block sparse matrices */
 
@@ -135,6 +165,7 @@ ScsLinSysWork *scs_init_lin_sys_work(const ScsMatrix *A, const ScsMatrix *P,
 
   if (p->iparm[21] < p->n) {
     scs_printf("KKT matrix has < n positive eigenvalues. P not PSD.");
+    scs_free_lin_sys_work(p);
     return SCS_NULL;
   }
 
@@ -148,7 +179,7 @@ scs_int scs_solve_lin_sys(ScsLinSysWork *p, scs_float *b, const scs_float *ws,
   p->phase = PARDISO_SOLVE;
   _PARDISO(p->pt, &(p->maxfct), &(p->mnum), &(p->mtype), &(p->phase),
            &(p->n_plus_m), p->kkt->x, p->kkt->p, p->kkt->i, SCS_NULL,
-           &(p->nrhs), p->iparm, &(p->msglvl), b, p->sol, &(p->error));
+           &(p->nrhs), p->iparm, &(p->msglvl), b, SCS_NULL, &(p->error));
   if (p->error != 0) {
     scs_printf("Error during linear system solution: %d", (int)p->error);
   }
@@ -156,7 +187,7 @@ scs_int scs_solve_lin_sys(ScsLinSysWork *p, scs_float *b, const scs_float *ws,
 }
 
 /* Update factorization when R changes */
-void scs_update_lin_sys_diag_r(ScsLinSysWork *p, const scs_float *diag_r) {
+scs_int scs_update_lin_sys_diag_r(ScsLinSysWork *p, const scs_float *diag_r) {
   scs_int i;
 
   for (i = 0; i < p->n; ++i) {
@@ -177,6 +208,7 @@ void scs_update_lin_sys_diag_r(ScsLinSysWork *p, const scs_float *diag_r) {
   if (p->error != 0) {
     scs_printf("Error in PARDISO factorization when updating: %d.\n",
                (int)p->error);
-    scs_free_lin_sys_work(p);
+    return (scs_int)p->error;
   }
+  return 0;
 }

data/vendor/scs/linsys/mkl/direct/private.h

@@ -10,7 +10,6 @@ extern "C" {
 
 struct SCS_LIN_SYS_WORK {
   ScsMatrix *kkt; /* Upper triangular KKT matrix (in CSR format) */
-  scs_float *sol; /* solution to the KKT system */
   scs_int n;      /* number of QP variables */
   scs_int m;      /* number of QP constraints */