scs 0.4.0 → 0.4.1

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

@@ -9,15 +9,15 @@ extern "C" {
 #include "external/amd/amd.h"
 #include "external/qdldl/qdldl.h"
 #include "glbopts.h"
-#include "scs.h"
+#include "linsys.h"
 #include "scs_matrix.h"
 
 struct SCS_LIN_SYS_WORK {
-  scs_int m, n;    /* linear system dimensions */
-  csc *kkt, *L;    /* KKT, and factorization matrix L resp. */
-  scs_float *Dinv; /* inverse diagonal matrix of factorization */
-  scs_int *perm;   /* permutation of KKT matrix for factorization */
-  scs_float *bp;   /* workspace memory for solves */
+  scs_int m, n;       /* linear system dimensions */
+  ScsMatrix *kkt, *L; /* KKT, and factorization matrix L resp. */
+  scs_float *Dinv;    /* inverse diagonal matrix of factorization */
+  scs_int *perm;      /* permutation of KKT matrix for factorization */
+  scs_float *bp;      /* workspace memory for solves */
   scs_int *diag_r_idxs;
   scs_int factorizations;
   /* ldl factorization workspace */

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

@@ -1,22 +1,9 @@
 #include "private.h"
-#include "linsys.h"
-#include "util.h"
-#include <limits.h>
 
-const char *SCS(get_lin_sys_method)() {
-  return "sparse-indirect";
+const char *scs_get_lin_sys_method() {
+  return "sparse-indirect-scs";
 }
 
-/*
-char *SCS(get_lin_sys_summary)(ScsLinSysWork *p, const ScsInfo *info) {
-  char *str = (char *)scs_malloc(sizeof(char) * 128);
-  sprintf(str, "lin-sys: avg cg its: %2.2f\n",
-          (scs_float)p->tot_cg_its / (info->iter + 1));
-  p->tot_cg_its = 0;
-  return str;
-}
-*/
-
 /* Not possible to do this on the fly due to M_ii += a_i' (R_y)^-1 a_i */
 /* set M = inv ( diag ( R_x + P + A' R_y^{-1} A ) ) */
 static void set_preconditioner(ScsLinSysWork *p) {
@@ -97,7 +84,7 @@ static void transpose(const ScsMatrix *A, ScsLinSysWork *p) {
 #endif
 }
 
-void SCS(free_lin_sys_work)(ScsLinSysWork *p) {
+void scs_free_lin_sys_work(ScsLinSysWork *p) {
   if (p) {
     scs_free(p->p);
     scs_free(p->r);
@@ -162,13 +149,13 @@ static void apply_pre_conditioner(scs_float *z, scs_float *r, scs_int n,
 }
 
 /* no need to update anything in this case */
-void SCS(update_lin_sys_diag_r)(ScsLinSysWork *p, const scs_float *diag_r) {
+void scs_update_lin_sys_diag_r(ScsLinSysWork *p, const scs_float *diag_r) {
   p->diag_r = diag_r; /* this isn't needed but do it to be safe */
   set_preconditioner(p);
 }
 
-ScsLinSysWork *SCS(init_lin_sys_work)(const ScsMatrix *A, const ScsMatrix *P,
-                                      const scs_float *diag_r) {
+ScsLinSysWork *scs_init_lin_sys_work(const ScsMatrix *A, const ScsMatrix *P,
+                                     const scs_float *diag_r) {
   ScsLinSysWork *p = (ScsLinSysWork *)scs_calloc(1, sizeof(ScsLinSysWork));
   p->A = A;
   p->P = P;
@@ -198,7 +185,7 @@ ScsLinSysWork *SCS(init_lin_sys_work)(const ScsMatrix *A, const ScsMatrix *P,
   p->tot_cg_its = 0;
   if (!p->p || !p->r || !p->Gp || !p->tmp || !p->At || !p->At->i || !p->At->p ||
       !p->At->x) {
-    SCS(free_lin_sys_work)(p);
+    scs_free_lin_sys_work(p);
     return SCS_NULL;
   }
   return p;
@@ -288,8 +275,8 @@ static scs_int pcg(ScsLinSysWork *pr, const scs_float *s, scs_float *b,
  * y = R_y^{-1} (Ax - ry)
  *
  */
-scs_int SCS(solve_lin_sys)(ScsLinSysWork *p, scs_float *b, const scs_float *s,
-                           scs_float tol) {
+scs_int scs_solve_lin_sys(ScsLinSysWork *p, scs_float *b, const scs_float *s,
+                          scs_float tol) {
   scs_int cg_its, max_iters;
 
   if (tol <= 0.) {

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

@@ -5,11 +5,13 @@
 extern "C" {
 #endif
 
+#include "csparse.h"
 #include "glbopts.h"
 #include "linalg.h"
-#include "scs.h"
+#include "linsys.h"
 #include "scs_matrix.h"
-#include <math.h>
+#include "util.h" /* timer */
+#include <string.h>
 
 struct SCS_LIN_SYS_WORK {
   scs_int n, m; /* linear system dimensions */

data/vendor/scs/linsys/csparse.c

@@ -2,39 +2,37 @@
 
 #include "csparse.h"
 
-csc *SCS(cs_spalloc)(scs_int m, scs_int n, scs_int nzmax, scs_int values,
-                     scs_int triplet) {
-  csc *A = (csc *)scs_calloc(1, sizeof(csc)); /* allocate the csc struct */
+ScsMatrix *SCS(cs_spalloc)(scs_int m, scs_int n, scs_int nzmax, scs_int values,
+                           scs_int triplet) {
+  ScsMatrix *A = (ScsMatrix *)scs_calloc(1, sizeof(ScsMatrix));
   if (!A) {
     return SCS_NULL;
   }         /* out of memory */
   A->m = m; /* define dimensions and nzmax */
   A->n = n;
-  A->nzmax = nzmax = MAX(nzmax, 1);
-  A->nz = triplet ? 0 : -1; /* allocate triplet or comp.col */
   A->p = (scs_int *)scs_calloc((triplet ? nzmax : n + 1), sizeof(scs_int));
   A->i = (scs_int *)scs_calloc(nzmax, sizeof(scs_int));
   A->x = values ? (scs_float *)scs_calloc(nzmax, sizeof(scs_float)) : SCS_NULL;
   return (!A->p || !A->i || (values && !A->x)) ? SCS(cs_spfree)(A) : A;
 }
 
-csc *SCS(cs_done)(csc *C, void *w, void *x, scs_int ok) {
+ScsMatrix *SCS(cs_done)(ScsMatrix *C, void *w, void *x, scs_int ok) {
   scs_free(w); /* free workspace */
   scs_free(x);
   return ok ? C : SCS(cs_spfree)(C); /* return result if OK, else free it */
 }
 
 /* C = compressed-column form of a triplet matrix T */
-csc *SCS(cs_compress)(const csc *T, scs_int *idx_mapping) {
-  scs_int m, n, nz, p, k, *Cp, *Ci, *w, *Ti, *Tj;
+ScsMatrix *SCS(cs_compress)(const ScsMatrix *T, scs_int nz,
+                            scs_int *idx_mapping) {
+  scs_int m, n, p, k, *Cp, *Ci, *w, *Ti, *Tj;
   scs_float *Cx, *Tx;
-  csc *C;
+  ScsMatrix *C;
   m = T->m;
   n = T->n;
   Ti = T->i;
   Tj = T->p;
   Tx = T->x;
-  nz = T->nz;
   C = SCS(cs_spalloc)(m, n, nz, Tx != SCS_NULL, 0); /* allocate result */
   w = (scs_int *)scs_calloc(n, sizeof(scs_int));    /* get workspace */
   if (!C || !w) {
@@ -75,7 +73,7 @@ scs_float SCS(cumsum)(scs_int *p, scs_int *c, scs_int n) {
   return nz2; /* return sum (c [0..n-1]) */
 }
 
-csc *SCS(cs_spfree)(csc *A) {
+ScsMatrix *SCS(cs_spfree)(ScsMatrix *A) {
   if (!A) {
     return SCS_NULL;
   } /* do nothing if A already SCS_NULL */
@@ -83,5 +81,135 @@ csc *SCS(cs_spfree)(csc *A) {
   scs_free(A->i);
   scs_free(A->x);
   scs_free(A);
-  return (csc *)SCS_NULL; /* free the csc struct and return SCS_NULL */
+  /* free the ScsMatrix struct and return SCS_NULL */
+  return (ScsMatrix *)SCS_NULL;
+}
+
+/* Build the KKT matrix */
+ScsMatrix *SCS(form_kkt)(const ScsMatrix *A, const ScsMatrix *P,
+                         scs_float *diag_p, const scs_float *diag_r,
+                         scs_int *diag_r_idxs, scs_int upper) {
+  /*
+   * Forms column compressed KKT matrix assumes column compressed A,P matrices.
+   * Only upper OR lower triangular part is stuffed, depending on `upper` flag.
+   *
+   * Forms upper/lower triangular part of [(R_x + P)  A'; A -R_y]
+   * Shapes: P : n x n, A: m x n.
+   *
+   * Output: `diag_p` will contain values of P diagonal upon completion,
+   * and `diag_r_idxs` will contain the indices corresponding to the entries
+   * in the returned matrix corresponding to the entries of R.
+   *
+   */
+  scs_int h, i, j, count;
+  ScsMatrix *Kcsc, *K;
+  scs_int n = A->n;
+  scs_int m = A->m;
+  scs_int Anz = A->p[n];
+  scs_int Knzmax;
+  scs_int *idx_mapping;
+  if (P) {
+    /* Upper bound P + I triangular component NNZs as Pnz + n */
+    Knzmax = n + m + Anz + P->p[n];
+  } else {
+    Knzmax = n + m + Anz;
+  }
+  K = SCS(cs_spalloc)(m + n, m + n, Knzmax, 1, 1);
+
+#if VERBOSITY > 0
+  scs_printf("forming kkt\n");
+#endif
+  /* Here we generate a triplet matrix and then compress to CSC */
+  if (!K) {
+    return SCS_NULL;
+  }
+
+  count = 0; /* element counter */
+  if (P) {
+    /* R_x + P in top left */
+    for (j = 0; j < n; j++) { /* cols */
+      diag_p[j] = 0.;
+      /* empty column, add diagonal  */
+      if (P->p[j] == P->p[j + 1]) {
+        K->i[count] = j;
+        K->p[count] = j;
+        K->x[count] = diag_r[j];
+        diag_r_idxs[j] = count; /* store the indices where diag_r occurs */
+        count++;
+      }
+      for (h = P->p[j]; h < P->p[j + 1]; h++) {
+        i = P->i[h]; /* row */
+        if (i > j) { /* only upper triangular needed */
+          break;
+        }
+        if (upper) {
+          K->i[count] = i;
+          K->p[count] = j;
+        } else { /* lower triangular */
+          /* P is passed in upper triangular, need to flip that here */
+          K->i[count] = j; /* col -> row */
+          K->p[count] = i; /* row -> col */
+        }
+        K->x[count] = P->x[h];
+        if (i == j) {
+          /* P has diagonal element */
+          diag_p[j] = P->x[h];
+          K->x[count] += diag_r[j];
+          diag_r_idxs[j] = count; /* store the indices where diag_r occurs */
+        }
+        count++;
+        /* reached the end without adding diagonal, do it now */
+        if ((i < j) && (h + 1 == P->p[j + 1] || P->i[h + 1] > j)) {
+          K->i[count] = j;
+          K->p[count] = j;
+          K->x[count] = diag_r[j];
+          diag_r_idxs[j] = count; /* store the indices where diag_r occurs */
+          count++;
+        }
+      }
+    }
+  } else {
+    /* R_x in top left */
+    for (j = 0; j < n; j++) {
+      diag_p[j] = 0.;
+      K->i[count] = j;
+      K->p[count] = j;
+      K->x[count] = diag_r[j];
+      diag_r_idxs[j] = count; /* store the indices where diag_r occurs */
+      count++;
+    }
+  }
+
+  /* A in bottom left or A^T top right */
+  for (j = 0; j < n; j++) { /* column */
+    for (h = A->p[j]; h < A->p[j + 1]; h++) {
+      if (upper) {
+        K->p[count] = A->i[h] + n; /* column */
+        K->i[count] = j;           /*row */
+      } else {                     /* lower triangular */
+        K->p[count] = j;           /* column */
+        K->i[count] = A->i[h] + n; /* row */
+      }
+      K->x[count] = A->x[h];
+      count++;
+    }
+  }
+
+  /* -R_y at bottom right */
+  for (j = 0; j < m; j++) {
+    K->i[count] = j + n;
+    K->p[count] = j + n;
+    K->x[count] = -diag_r[j + n];
+    diag_r_idxs[j + n] = count; /* store the indices where diag_r occurs */
+    count++;
+  }
+
+  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]];
+  }
+  SCS(cs_spfree)(K);
+  scs_free(idx_mapping);
+  return Kcsc;
 }

data/vendor/scs/linsys/csparse.h

@@ -10,24 +10,17 @@ extern "C" {
 #include "glbopts.h"
 #include "scs.h"
 
-/* matrix in compressed-column or triplet form */
-typedef struct SPARSE_MATRIX {
-  scs_int nzmax; /* maximum number of entries */
-  scs_int m;     /* number of rows */
-  scs_int n;     /* number of columns */
-  scs_int *p;    /* column pointers (size n+1) or col indices (size nzmax) */
-  scs_int *i;    /* row indices, size nzmax */
-  scs_float *x;  /* numerical values, size nzmax */
-  scs_int nz;    /* # of entries in triplet matrix, -1 for compressed-col */
-} csc;
-
-csc *SCS(cs_spalloc)(scs_int m, scs_int n, scs_int nzmax, scs_int values,
-                     scs_int triplet);
-csc *SCS(cs_done)(csc *C, void *w, void *x, scs_int ok);
-csc *SCS(cs_compress)(const csc *T, scs_int *idx_mapping);
+ScsMatrix *SCS(cs_spalloc)(scs_int m, scs_int n, scs_int nzmax, scs_int values,
+                           scs_int triplet);
+ScsMatrix *SCS(cs_done)(ScsMatrix *C, void *w, void *x, scs_int ok);
+ScsMatrix *SCS(cs_compress)(const ScsMatrix *T, scs_int nz,
+                            scs_int *idx_mapping);
+ScsMatrix *SCS(cs_spfree)(ScsMatrix *A);
 scs_float SCS(cumsum)(scs_int *p, scs_int *c, scs_int n);
-csc *SCS(cs_spfree)(csc *A);
-
+/* Forms KKT matrix */
+ScsMatrix *SCS(form_kkt)(const ScsMatrix *A, const ScsMatrix *P,
+                         scs_float *diag_p, const scs_float *diag_r,
+                         scs_int *diag_r_idxs, scs_int upper);
 #ifdef __cplusplus
 }
 #endif

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

@@ -19,13 +19,13 @@ void SCS(accum_by_atrans_gpu)(const ScsGpuMatrix *Ag,
     if (*buffer != SCS_NULL) {
       cudaFree(*buffer);
     }
-    cudaMalloc(buffer, *buffer_size);
+    cudaMalloc(buffer, new_buffer_size);
     *buffer_size = new_buffer_size;
   }
 
   CUSPARSE_GEN(SpMV)
   (cusparse_handle, CUSPARSE_OPERATION_NON_TRANSPOSE, &onef, Ag->descr, x,
-   &onef, y, SCS_CUDA_FLOAT, SCS_CSRMV_ALG, buffer);
+   &onef, y, SCS_CUDA_FLOAT, SCS_CSRMV_ALG, *buffer);
 }
 
 /* this is slow, use trans routine if possible */
@@ -48,13 +48,13 @@ void SCS(accum_by_a_gpu)(const ScsGpuMatrix *Ag, const cusparseDnVecDescr_t x,
     if (*buffer != SCS_NULL) {
       cudaFree(*buffer);
     }
-    cudaMalloc(buffer, *buffer_size);
+    cudaMalloc(buffer, new_buffer_size);
     *buffer_size = new_buffer_size;
   }
 
   CUSPARSE_GEN(SpMV)
   (cusparse_handle, CUSPARSE_OPERATION_TRANSPOSE, &onef, Ag->descr, x, &onef, y,
-   SCS_CUDA_FLOAT, SCS_CSRMV_ALG, buffer);
+   SCS_CUDA_FLOAT, SCS_CSRMV_ALG, *buffer);
 }
 
 /* This assumes that P has been made full (ie not triangular) and uses the

data/vendor/scs/linsys/gpu/gpu.h

@@ -74,7 +74,7 @@ extern "C" {
 #define SCS_CUSPARSE_INDEX CUSPARSE_INDEX_64I
 #endif
 
-#define SCS_CSRMV_ALG CUSPARSE_CSRMV_ALG1
+#define SCS_CSRMV_ALG CUSPARSE_SPMV_CSR_ALG1
 #define SCS_CSR2CSC_ALG CUSPARSE_CSR2CSC_ALG1
 
 /*

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

@@ -21,20 +21,10 @@ static scs_float cg_gpu_norm(cublasHandle_t cublas_handle, scs_float *r,
   return nrm;
 }
 
-const char *SCS(get_lin_sys_method)() {
+const char *scs_get_lin_sys_method() {
   return "sparse-indirect GPU";
 }
 
-/*
-char *SCS(get_lin_sys_summary)(ScsLinSysWork *p, const ScsInfo *info) {
-  char *str = (char *)scs_malloc(sizeof(char) * 128);
-  sprintf(str, "lin-sys: avg cg its: %2.2f\n",
-          (scs_float)p->tot_cg_its / (info->iter + 1));
-  p->tot_cg_its = 0;
-  return str;
-}
-*/
-
 /* Not possible to do this on the fly due to M_ii += a_i' (R_y)^-1 a_i */
 /* set M = inv ( diag ( R_x + P + A' R_y^{-1} A ) ) */
 static void set_preconditioner(ScsLinSysWork *p, const scs_float *diag_r) {
@@ -76,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) {
+void scs_update_lin_sys_diag_r(ScsLinSysWork *p, const scs_float *diag_r) {
   scs_int i;
 
   /* R_x to gpu */
@@ -93,7 +83,7 @@ void SCS(update_lin_sys_diag_r)(ScsLinSysWork *p, const scs_float *diag_r) {
   set_preconditioner(p, diag_r);
 }
 
-void SCS(free_lin_sys_work)(ScsLinSysWork *p) {
+void scs_free_lin_sys_work(ScsLinSysWork *p) {
   if (p) {
     scs_free(p->M);
     scs_free(p->inv_r_y);
@@ -182,13 +172,13 @@ static void mat_vec(ScsLinSysWork *p, const scs_float *x, scs_float *y) {
 }
 
 /* P comes in upper triangular, expand to full
- * First compute triplet version of full matrix, then compress to csc
+ * First compute triplet version of full matrix, then compress to CSC
  * */
-static csc *fill_p_matrix(const ScsMatrix *P) {
+static ScsMatrix *fill_p_matrix(const ScsMatrix *P) {
   scs_int i, j, k, kk;
   scs_int Pnzmax = 2 * P->p[P->n]; /* upper bound */
-  csc *P_tmp = SCS(cs_spalloc)(P->n, P->n, Pnzmax, 1, 1);
-  csc *P_full;
+  ScsMatrix *P_tmp = SCS(cs_spalloc)(P->n, P->n, Pnzmax, 1, 1);
+  ScsMatrix *P_full;
   kk = 0;
   for (j = 0; j < P->n; j++) { /* cols */
     for (k = P->p[j]; k < P->p[j + 1]; k++) {
@@ -209,16 +199,15 @@ static csc *fill_p_matrix(const ScsMatrix *P) {
       kk++;
     }
   }
-  P_tmp->nz = kk; /* set number of nonzeros */
-  P_full = SCS(cs_compress)(P_tmp, SCS_NULL);
+  P_full = SCS(cs_compress)(P_tmp, kk, SCS_NULL);
   SCS(cs_spfree)(P_tmp);
   return P_full;
 }
 
-ScsLinSysWork *SCS(init_lin_sys_work)(const ScsMatrix *A, const ScsMatrix *P,
-                                      const scs_float *diag_r) {
+ScsLinSysWork *scs_init_lin_sys_work(const ScsMatrix *A, const ScsMatrix *P,
+                                     const scs_float *diag_r) {
   cudaError_t err;
-  csc *P_full;
+  ScsMatrix *P_full;
   ScsLinSysWork *p = SCS_NULL;
   ScsGpuMatrix *Ag = SCS_NULL;
   ScsGpuMatrix *Pg = SCS_NULL;
@@ -324,7 +313,7 @@ ScsLinSysWork *SCS(init_lin_sys_work)(const ScsMatrix *A, const ScsMatrix *P,
   cusparseCreateDnVec(&p->dn_vec_m, Ag->m, p->tmp_m, SCS_CUDA_FLOAT);
 
   /* Form preconditioner and copy R_x, 1/R_y to gpu */
-  SCS(update_lin_sys_diag_r)(p, diag_r);
+  scs_update_lin_sys_diag_r(p, diag_r);
 
 #if GPU_TRANSPOSE_MAT > 0
   p->Agt = (ScsGpuMatrix *)scs_malloc(sizeof(ScsGpuMatrix));
@@ -367,7 +356,7 @@ ScsLinSysWork *SCS(init_lin_sys_work)(const ScsMatrix *A, const ScsMatrix *P,
   if (err != cudaSuccess) {
     printf("%s:%d:%s\nERROR_CUDA (*): %s\n", __FILE__, __LINE__, __func__,
            cudaGetErrorString(err));
-    SCS(free_lin_sys_work)(p);
+    scs_free_lin_sys_work(p);
     return SCS_NULL;
   }
   return p;
@@ -466,8 +455,8 @@ static scs_int pcg(ScsLinSysWork *pr, const scs_float *s, scs_float *bg,
  * y = R_y^{-1} (Ax - ry)
  *
  */
-scs_int SCS(solve_lin_sys)(ScsLinSysWork *p, scs_float *b, const scs_float *s,
-                           scs_float tol) {
+scs_int scs_solve_lin_sys(ScsLinSysWork *p, scs_float *b, const scs_float *s,
+                          scs_float tol) {
   scs_int cg_its, max_iters;
   scs_float neg_onef = -1.0;
 

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

@@ -0,0 +1,182 @@
+#include "private.h"
+
+#define PARDISO_SYMBOLIC (11)
+#define PARDISO_NUMERIC (22)
+#define PARDISO_SOLVE (33)
+#define PARDISO_CLEANUP (-1)
+
+/* TODO: is it necessary to use pardiso_64 and MKL_Set_Interface_Layer ? */
+/*
+#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 */
+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); */
+
+const char *scs_get_lin_sys_method() {
+  return "sparse-direct-mkl-pardiso";
+}
+
+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)
+      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)
+      scs_free(p->diag_p);
+    scs_free(p);
+  }
+}
+
+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
+  */
+  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));
+
+  /* MKL pardiso requires upper triangular CSR matrices. The KKT matrix stuffed
+   * as CSC lower triangular is equivalent. Pass upper=0. */
+  p->kkt = SCS(form_kkt)(A, P, p->diag_p, diag_r, p->diag_r_idxs, 0);
+  if (!(p->kkt)) {
+    scs_printf("Error in forming KKT matrix");
+    scs_free_lin_sys_work(p);
+    return SCS_NULL;
+  }
+
+  for (i = 0; i < 64; i++) {
+    p->iparm[i] = 0; /* Setup Pardiso control parameters */
+    p->pt[i] = 0;    /* Initialize the internal solver memory pointer */
+  }
+
+  /* Set Pardiso variables */
+  p->mtype = -2;         /* Real symmetric indefinite matrix */
+  p->nrhs = 1;           /* Number of right hand sides */
+  p->maxfct = 1;         /* Maximum number of numerical factorizations */
+  p->mnum = 1;           /* Which factorization to use */
+  p->error = 0;          /* Initialize error flag */
+  p->msglvl = VERBOSITY; /* Printing information */
+
+  /* For all iparm vars see MKL documentation */
+  p->iparm[0] = 1;          /* Parsido must inspect iparm */
+  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[34] = 1;         /* Use C-style indexing for indices */
+  /* p->iparm[36] = -80; */ /* Form block sparse matrices */
+
+#ifdef SFLOAT
+  p->iparm[27] = 1; /* 1 is single precision, 0 is double */
+#endif
+
+  /* Permutation and symbolic factorization */
+  scs_int phase = PARDISO_SYMBOLIC;
+  _PARDISO(p->pt, &(p->maxfct), &(p->mnum), &(p->mtype), &phase, &(p->n_plus_m),
+           p->kkt->x, 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 symbolic factorization: %d", (int)p->error);
+    scs_free_lin_sys_work(p);
+    return SCS_NULL;
+  }
+
+  /* Numerical factorization */
+  p->phase = PARDISO_NUMERIC;
+  _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), SCS_NULL, SCS_NULL, &(p->error));
+
+  if (p->error) {
+    scs_printf("Error during numerical factorization: %d", (int)p->error);
+    scs_free_lin_sys_work(p);
+    return SCS_NULL;
+  }
+
+  if (p->iparm[21] < p->n) {
+    scs_printf("KKT matrix has < n positive eigenvalues. P not PSD.");
+    return SCS_NULL;
+  }
+
+  return p;
+}
+
+/* Returns solution to linear system Ax = b with solution stored in b */
+scs_int scs_solve_lin_sys(ScsLinSysWork *p, scs_float *b, const scs_float *ws,
+                          scs_float tol) {
+  /* Back substitution and iterative refinement */
+  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));
+  if (p->error != 0) {
+    scs_printf("Error during linear system solution: %d", (int)p->error);
+  }
+  return p->error;
+}
+
+/* Update factorization when R changes */
+void scs_update_lin_sys_diag_r(ScsLinSysWork *p, const scs_float *diag_r) {
+  scs_int i;
+
+  for (i = 0; i < p->n; ++i) {
+    /* top left is R_x + P, bottom right is -R_y */
+    p->kkt->x[p->diag_r_idxs[i]] = p->diag_p[i] + diag_r[i];
+  }
+  for (i = p->n; i < p->n + p->m; ++i) {
+    /* top left is R_x + P, bottom right is -R_y */
+    p->kkt->x[p->diag_r_idxs[i]] = -diag_r[i];
+  }
+
+  /* Perform numerical factorization */
+  p->phase = PARDISO_NUMERIC;
+  _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), SCS_NULL, SCS_NULL, &(p->error));
+
+  if (p->error != 0) {
+    scs_printf("Error in PARDISO factorization when updating: %d.\n",
+               (int)p->error);
+    scs_free_lin_sys_work(p);
+  }
+}