scs 0.3.1 → 0.3.2

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

@@ -15,19 +15,20 @@ struct SCS_LIN_SYS_WORK {
   scs_int n, m; /* linear system dimensions */
   /* reporting */
   scs_int tot_cg_its;
+  scs_float *M; /* preconditioner on cpu */
   /* ALL BELOW HOSTED ON THE GPU */
-  scs_float *p;      /* cg iterate, n  */
-  scs_float *r;      /* cg residual, n */
-  scs_float *Gp;     /* G * p, n */
-  scs_float *bg;     /* b, n */
-  scs_float *tmp_m;  /* m, used in mat_vec */
-  scs_float *z;      /* preconditioned */
-  scs_float *M;      /* preconditioner */
+  scs_float *p;       /* cg iterate, n  */
+  scs_float *r;       /* cg residual, n */
+  scs_float *Gp;      /* G * p, n */
+  scs_float *bg;      /* b, n */
+  scs_float *tmp_m;   /* m, used in mat_vec */
+  scs_float *z;       /* preconditioned */
+  scs_float *M_gpu;   /* preconditioner */
   const ScsMatrix *A; /* does *not* own this memory */
   const ScsMatrix *P; /* does *not* own this memory */
-  ScsGpuMatrix *Ag;  /* A matrix on GPU */
-  ScsGpuMatrix *Agt; /* A trans matrix on GPU */
-  ScsGpuMatrix *Pg;  /* P matrix on GPU */
+  ScsGpuMatrix *Ag;   /* A matrix on GPU */
+  ScsGpuMatrix *Agt;  /* A trans matrix on GPU */
+  ScsGpuMatrix *Pg;   /* P matrix on GPU */
   /* CUDA */
   cublasHandle_t cublas_handle;
   cusparseHandle_t cusparse_handle;
@@ -39,9 +40,9 @@ struct SCS_LIN_SYS_WORK {
   cusparseDnVecDescr_t dn_vec_n_p; /* Dense vector of length n */
 
   /* rho terms */
-  scs_float rho_x;
-  scs_float *inv_rho_y_vec;     /* inverse rho_y_vec */
-  scs_float *inv_rho_y_vec_gpu; /* inverse rho_y_vec on GPU */
+  scs_float *r_x_gpu;
+  scs_float *inv_r_y;     /* inverse R_y */
+  scs_float *inv_r_y_gpu; /* inverse R_y on GPU */
 };
 
 #ifdef __cplusplus

data/vendor/scs/linsys/scs_matrix.c

@@ -18,11 +18,11 @@ scs_int SCS(copy_matrix)(ScsMatrix **dstp, const ScsMatrix *src) {
   A->n = src->n;
   A->m = src->m;
   /* A values, size: NNZ A */
-  A->x = (scs_float *)scs_malloc(sizeof(scs_float) * Anz);
+  A->x = (scs_float *)scs_calloc(Anz, sizeof(scs_float));
   /* A row index, size: NNZ A */
-  A->i = (scs_int *)scs_malloc(sizeof(scs_int) * Anz);
+  A->i = (scs_int *)scs_calloc(Anz, sizeof(scs_int));
   /* A column pointer, size: n+1 */
-  A->p = (scs_int *)scs_malloc(sizeof(scs_int) * (src->n + 1));
+  A->p = (scs_int *)scs_calloc(src->n + 1, sizeof(scs_int));
   if (!A->x || !A->i || !A->p) {
     return 0;
   }
@@ -108,9 +108,8 @@ static inline scs_float apply_limit(scs_float x) {
 
 static void compute_ruiz_mats(ScsMatrix *P, ScsMatrix *A, scs_float *b,
                               scs_float *c, scs_float *Dt, scs_float *Et,
-                              scs_float *s, scs_int *boundaries,
-                              scs_int cone_boundaries_len) {
-  scs_int i, j, kk, count, delta;
+                              scs_float *s, ScsConeWork *cone) {
+  scs_int i, j, kk;
   scs_float wrk;
 
   /****************************  D  ****************************/
@@ -129,16 +128,9 @@ static void compute_ruiz_mats(ScsMatrix *P, ScsMatrix *A, scs_float *b,
   }
 
   /* accumulate D across each cone  */
-  count = boundaries[0];
-  for (i = 1; i < cone_boundaries_len; ++i) {
-    delta = boundaries[i];
-    wrk = SCS(norm_inf)(&(Dt[count]), delta);
-    for (j = count; j < count + delta; ++j) {
-      Dt[j] = wrk;
-    }
-    count += delta;
-  }
+  SCS(enforce_cone_boundaries)(cone, Dt, &SCS(norm_inf));
 
+  /* invert temporary vec to form D */
   for (i = 0; i < A->m; ++i) {
     Dt[i] = SAFEDIV_POS(1.0, SQRTF(apply_limit(Dt[i])));
   }
@@ -182,9 +174,8 @@ static void compute_ruiz_mats(ScsMatrix *P, ScsMatrix *A, scs_float *b,
 
 static void compute_l2_mats(ScsMatrix *P, ScsMatrix *A, scs_float *b,
                             scs_float *c, scs_float *Dt, scs_float *Et,
-                            scs_float *s, scs_int *boundaries,
-                            scs_int cone_boundaries_len) {
-  scs_int i, j, kk, count, delta;
+                            scs_float *s, ScsConeWork *cone) {
+  scs_int i, j, kk;
   scs_float wrk, norm_c, norm_b;
 
   /****************************  D  ****************************/
@@ -206,19 +197,7 @@ static void compute_l2_mats(ScsMatrix *P, ScsMatrix *A, scs_float *b,
   }
 
   /* accumulate D across each cone  */
-  count = boundaries[0];
-  for (i = 1; i < cone_boundaries_len; ++i) {
-    delta = boundaries[i];
-    wrk = 0.;
-    for (j = count; j < count + delta; ++j) {
-      wrk += Dt[j];
-    }
-    wrk /= delta;
-    for (j = count; j < count + delta; ++j) {
-      Dt[j] = wrk;
-    }
-    count += delta;
-  }
+  SCS(enforce_cone_boundaries)(cone, Dt, &SCS(mean));
 
   for (i = 0; i < A->m; ++i) {
     Dt[i] = SAFEDIV_POS(1.0, SQRTF(apply_limit(Dt[i])));
@@ -265,7 +244,7 @@ static void compute_l2_mats(ScsMatrix *P, ScsMatrix *A, scs_float *b,
 
 static void rescale(ScsMatrix *P, ScsMatrix *A, scs_float *b, scs_float *c,
                     scs_float *Dt, scs_float *Et, scs_float s, ScsScaling *scal,
-                    scs_int *boundaries, scs_int cone_boundaries_len) {
+                    ScsConeWork *cone) {
   scs_int i, j;
   /* scale the rows of A with D */
   for (i = 0; i < A->n; ++i) {
@@ -352,15 +331,15 @@ static void rescale(ScsMatrix *P, ScsMatrix *A, scs_float *b, scs_float *c,
  * The main complication is that D has to respect cone boundaries.
  *
  */
-void SCS(normalize)(ScsMatrix *P, ScsMatrix *A, scs_float *b, scs_float *c,
-                    ScsScaling *scal, scs_int *cone_boundaries,
-                    scs_int cone_boundaries_len) {
+ScsScaling *SCS(normalize_a_p)(ScsMatrix *P, ScsMatrix *A, scs_float *b,
+                               scs_float *c, ScsConeWork *cone) {
   scs_int i;
   scs_float s;
-  scs_float *Dt = (scs_float *)scs_malloc(A->m * sizeof(scs_float));
-  scs_float *Et = (scs_float *)scs_malloc(A->n * sizeof(scs_float));
-  scal->D = (scs_float *)scs_malloc(A->m * sizeof(scs_float));
-  scal->E = (scs_float *)scs_malloc(A->n * sizeof(scs_float));
+  ScsScaling *scal = (ScsScaling *)scs_calloc(1, sizeof(ScsScaling));
+  scs_float *Dt = (scs_float *)scs_calloc(A->m, sizeof(scs_float));
+  scs_float *Et = (scs_float *)scs_calloc(A->n, sizeof(scs_float));
+  scal->D = (scs_float *)scs_calloc(A->m, sizeof(scs_float));
+  scal->E = (scs_float *)scs_calloc(A->n, sizeof(scs_float));
 
 #if VERBOSITY > 5
   SCS(timer) normalize_timer;
@@ -369,23 +348,23 @@ void SCS(normalize)(ScsMatrix *P, ScsMatrix *A, scs_float *b, scs_float *c,
 #endif
 
   /* init D, E */
+  scal->m = A->m;
   for (i = 0; i < A->m; ++i) {
     scal->D[i] = 1.;
   }
+  scal->n = A->n;
   for (i = 0; i < A->n; ++i) {
     scal->E[i] = 1.;
   }
   scal->primal_scale = 1.;
   scal->dual_scale = 1.;
   for (i = 0; i < NUM_RUIZ_PASSES; ++i) {
-    compute_ruiz_mats(P, A, b, c, Dt, Et, &s, cone_boundaries,
-                      cone_boundaries_len);
-    rescale(P, A, b, c, Dt, Et, s, scal, cone_boundaries, cone_boundaries_len);
+    compute_ruiz_mats(P, A, b, c, Dt, Et, &s, cone);
+    rescale(P, A, b, c, Dt, Et, s, scal, cone);
   }
   for (i = 0; i < NUM_L2_PASSES; ++i) {
-    compute_l2_mats(P, A, b, c, Dt, Et, &s, cone_boundaries,
-                    cone_boundaries_len);
-    rescale(P, A, b, c, Dt, Et, s, scal, cone_boundaries, cone_boundaries_len);
+    compute_l2_mats(P, A, b, c, Dt, Et, &s, cone);
+    rescale(P, A, b, c, Dt, Et, s, scal, cone);
   }
   scs_free(Dt);
   scs_free(Et);
@@ -404,9 +383,10 @@ void SCS(normalize)(ScsMatrix *P, ScsMatrix *A, scs_float *b, scs_float *c,
   scs_printf("norm D %g\n", SCS(norm_inf)(scal->D, A->m));
   scs_printf("norm E %g\n", SCS(norm_inf)(scal->E, A->n));
 #endif
+  return scal;
 }
 
-void SCS(un_normalize)(ScsMatrix *A, ScsMatrix *P, const ScsScaling *scal) {
+void SCS(un_normalize_a_p)(ScsMatrix *A, ScsMatrix *P, const ScsScaling *scal) {
   scs_int i, j;
   scs_float *D = scal->D;
   scs_float *E = scal->E;

data/vendor/scs/linsys/scs_matrix.h

@@ -7,17 +7,17 @@ extern "C" {
 
 #include "glbopts.h"
 #include "scs.h"
+#include "scs_work.h"
 
 /* Normalization routines, used if d->NORMALIZE is true */
 /* normalizes A matrix, sets scal->E and scal->D diagonal scaling matrices,
  * A -> D*A*E. D and E must be all positive entries, D must satisfy cone
  * boundaries */
-void SCS(normalize)(ScsMatrix *P, ScsMatrix *A, scs_float *b, scs_float *c,
-                    ScsScaling *scal, scs_int *cone_boundaries,
-                    scs_int cone_boundaries_len);
+ScsScaling *SCS(normalize_a_p)(ScsMatrix *P, ScsMatrix *A, scs_float *b,
+                               scs_float *c, ScsConeWork *cone);
 
 /* unnormalizes A matrix, unnormalizes by w->D and w->E */
-void SCS(un_normalize)(ScsMatrix *A, ScsMatrix *P, const ScsScaling *scal);
+void SCS(un_normalize_a_p)(ScsMatrix *A, ScsMatrix *P, const ScsScaling *scal);
 
 /* to free the memory allocated in a ScsMatrix (called on A and P at finish) */
 void SCS(free_scs_matrix)(ScsMatrix *A);

data/vendor/scs/scs.mk

@@ -145,7 +145,7 @@ endif
 USE_LAPACK = 1
 ifneq ($(USE_LAPACK), 0)
   # edit these for your setup:
-  BLASLDFLAGS = -lblas -llapack #-lgfortran
+  BLASLDFLAGS = -llapack -lblas # -lgfortran
   LDFLAGS += $(BLASLDFLAGS)
   OPT_FLAGS += -DUSE_LAPACK
 

data/vendor/scs/src/aa.c

@@ -96,6 +96,10 @@ aa_float toc(const char *str, timer *t) {
 
 #endif
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
 /* BLAS functions used */
 aa_float BLAS(nrm2)(blas_int *n, aa_float *x, blas_int *incx);
 void BLAS(axpy)(blas_int *n, aa_float *a, const aa_float *x, blas_int *incx,
@@ -113,6 +117,10 @@ void BLAS(gemm)(const char *transa, const char *transb, blas_int *m,
 void BLAS(scal)(const blas_int *n, const aa_float *a, aa_float *x,
                 const blas_int *incx);
 
+#ifdef __cplusplus
+}
+#endif
+
 /* This file uses Anderson acceleration to improve the convergence of
  * a fixed point mapping.
  * At each iteration we need to solve a (small) linear system, we
@@ -276,17 +284,18 @@ static void update_accel_params(const aa_float *x, const aa_float *f, AaWork *a,
 /* f = (1-relaxation) * \sum_i a_i x_i + relaxation * \sum_i a_i f_i */
 static void relax(aa_float *f, AaWork *a, aa_int len) {
   TIME_TIC
-  /* x_work = x - S * work */
+  /* x_work = x initially */
   blas_int bdim = (blas_int)(a->dim), one = 1, blen = (blas_int)len;
   aa_float onef = 1.0, neg_onef = -1.0;
   aa_float one_m_relaxation = 1. - a->relaxation;
+  /* x_work = x - S * work */
   BLAS(gemv)
   ("NoTrans", &bdim, &blen, &neg_onef, a->S, &bdim, a->work, &one, &onef,
    a->x_work, &one);
   /* f = relaxation * f */
-  BLAS(scal)(&blen, &a->relaxation, f, &one);
+  BLAS(scal)(&bdim, &a->relaxation, f, &one);
   /* f += (1 - relaxation) * x_work */
-  BLAS(axpy)(&blen, &one_m_relaxation, a->x_work, &one, f, &one);
+  BLAS(axpy)(&bdim, &one_m_relaxation, a->x_work, &one, f, &one);
   TIME_TOC
 }
 
@@ -352,7 +361,7 @@ AaWork *aa_init(aa_int dim, aa_int mem, aa_int type1, aa_float regularization,
   AaWork *a = (AaWork *)calloc(1, sizeof(AaWork));
   if (!a) {
     printf("Failed to allocate memory for AA.\n");
-    return (void *)0;
+    return (AaWork *)0;
   }
   a->type1 = type1;
   a->iter = 0;