casadi 3.6.7__cp37-none-win_amd64.whl → 3.7.0__cp37-none-win_amd64.whl

casadi/include/highs/pdlp/cupdlp/cupdlp_utils.c

@@ -2,16 +2,16 @@
 // Created by chuwen on 23-11-26.
 //
 
-#include "cupdlp_utils.h"
+#include "pdlp/cupdlp/cupdlp_utils.h"
 
 #include <limits.h>
 #include <stdio.h>
 
 #include <time.h>
 
-#include "cupdlp_cs.h"
-#include "cupdlp_linalg.h"
-#include "glbopts.h"
+#include "pdlp/cupdlp/cupdlp_cs.h"
+#include "pdlp/cupdlp/cupdlp_linalg.h"
+#include "pdlp/cupdlp/glbopts.h"
 
 #ifndef CUPDLP_CPU
 
@@ -44,7 +44,23 @@ cupdlp_int csc_clear(CUPDLPcsc *csc) {
     if (csc->colMatElem) {
       CUPDLP_FREE_VEC(csc->colMatElem);
     }
-    CUPDLP_FREE_VEC(csc);
+      cupdlp_free(csc);
+  }
+  return 0;
+}
+
+cupdlp_int csc_clear_host(CUPDLPcsc *csc) {
+  if (csc) {
+    if (csc->colMatBeg) {
+      cupdlp_free(csc->colMatBeg);
+    }
+    if (csc->colMatIdx) {
+      cupdlp_free(csc->colMatIdx);
+    }
+    if (csc->colMatElem) {
+      cupdlp_free(csc->colMatElem);
+    }
+    cupdlp_free(csc);
   }
   return 0;
 }
@@ -65,7 +81,7 @@ cupdlp_int csr_clear(CUPDLPcsr *csr) {
     if (csr->rowMatElem) {
       CUPDLP_FREE_VEC(csr->rowMatElem);
     }
-    CUPDLP_FREE_VEC(csr);
+    cupdlp_free(csr);
   }
   return 0;
 }
@@ -132,7 +148,7 @@ void problem_clear(CUPDLPproblem *problem) {
     if (problem->hasUpper) {
       CUPDLP_FREE_VEC(problem->hasUpper);
     }
-    CUPDLP_FREE_VEC(problem);
+    cupdlp_free(problem);
   }
 }
 
@@ -158,21 +174,21 @@ cupdlp_int vec_clear(CUPDLPvec *vec) {
 
 void iterates_clear(CUPDLPiterates *iterates) {
   if (iterates) {
-    if (iterates->x) {
-      // CUPDLP_FREE_VEC(iterates->x);
-      vec_clear(iterates->x);
+    if (iterates->x[0]) {
+      // CUPDLP_FREE_VEC(iterates->x[0]);
+      vec_clear(iterates->x[0]);
     }
-    if (iterates->y) {
-      // CUPDLP_FREE_VEC(iterates->y);
-      vec_clear(iterates->y);
+    if (iterates->x[1]) {
+      // CUPDLP_FREE_VEC(iterates->x[1]);
+      vec_clear(iterates->x[1]);
     }
-    if (iterates->xUpdate) {
-      // CUPDLP_FREE_VEC(iterates->xUpdate);
-      vec_clear(iterates->xUpdate);
+    if (iterates->y[0]) {
+      // CUPDLP_FREE_VEC(iterates->y[0]);
+      vec_clear(iterates->y[0]);
     }
-    if (iterates->yUpdate) {
-      // CUPDLP_FREE_VEC(iterates->yUpdate);
-      vec_clear(iterates->yUpdate);
+    if (iterates->y[1]) {
+      // CUPDLP_FREE_VEC(iterates->y[1]);
+      vec_clear(iterates->y[1]);
     }
     if (iterates->xSum) {
       CUPDLP_FREE_VEC(iterates->xSum);
@@ -194,31 +210,31 @@ void iterates_clear(CUPDLPiterates *iterates) {
     if (iterates->yLastRestart) {
       CUPDLP_FREE_VEC(iterates->yLastRestart);
     }
-    if (iterates->ax) {
-      // CUPDLP_FREE_VEC(iterates->ax);
-      vec_clear(iterates->ax);
+    if (iterates->ax[0]) {
+      // CUPDLP_FREE_VEC(iterates->ax[0]);
+      vec_clear(iterates->ax[0]);
     }
-    if (iterates->axUpdate) {
-      // CUPDLP_FREE_VEC(iterates->axUpdate);
-      vec_clear(iterates->axUpdate);
+    if (iterates->ax[1]) {
+      // CUPDLP_FREE_VEC(iterates->ax[1]);
+      vec_clear(iterates->ax[1]);
     }
     if (iterates->axAverage) {
       // CUPDLP_FREE_VEC(iterates->axAverage);
       vec_clear(iterates->axAverage);
     }
-    if (iterates->aty) {
-      // CUPDLP_FREE_VEC(iterates->aty);
-      vec_clear(iterates->aty);
+    if (iterates->aty[0]) {
+      // CUPDLP_FREE_VEC(iterates->aty[0]);
+      vec_clear(iterates->aty[0]);
     }
-    if (iterates->atyUpdate) {
-      // CUPDLP_FREE_VEC(iterates->atyUpdate);
-      vec_clear(iterates->atyUpdate);
+    if (iterates->aty[1]) {
+      // CUPDLP_FREE_VEC(iterates->aty[1]);
+      vec_clear(iterates->aty[1]);
     }
     if (iterates->atyAverage) {
       // CUPDLP_FREE_VEC(iterates->atyAverage);
       vec_clear(iterates->atyAverage);
     }
-    CUPDLP_FREE_VEC(iterates);
+    cupdlp_free(iterates);
   }
 }
 
@@ -278,7 +294,7 @@ void resobj_clear(CUPDLPresobj *resobj) {
     // if (resobj->dualInfeasBound) {
     //   CUPDLP_FREE_VEC(resobj->dualInfeasBound);
     // }
-    CUPDLP_FREE_VEC(resobj);
+    cupdlp_free(resobj);
   }
 }
 
@@ -288,11 +304,13 @@ void stepsize_clear(CUPDLPstepsize *stepsize) {
   }
 }
 
-void timers_clear(CUPDLPtimers *timers) {
+void timers_clear(int log_level, CUPDLPtimers *timers) {
 #ifndef CUPDLP_CPU
-  cupdlp_printf("%20s %e\n", "Free Device memory", timers->FreeDeviceMemTime);
+if (log_level)
+  cupdlp_printf("%20s %e\n\n", "Free Device memory", timers->FreeDeviceMemTime);
 #endif
 
+
   if (timers) {
     cupdlp_free(timers);
   }
@@ -301,12 +319,10 @@ void timers_clear(CUPDLPtimers *timers) {
 void scaling_clear(CUPDLPscaling *scaling) {
   if (scaling) {
     if (scaling->colScale) {
-      // cupdlp_free(scaling->colScale);
-      CUPDLP_FREE_VEC(scaling->colScale);  // now on gpu
+      cupdlp_free(scaling->colScale);
     }
     if (scaling->rowScale) {
-      // cupdlp_free(scaling->rowScale);
-      CUPDLP_FREE_VEC(scaling->rowScale);  // now on gpu
+      cupdlp_free(scaling->rowScale);
     }
     cupdlp_free(scaling);
   }
@@ -321,63 +337,80 @@ cupdlp_int PDHG_Clear(CUPDLPwork *w) {
   CUPDLPtimers *timers = w->timers;
   CUPDLPscaling *scaling = w->scaling;
 
-  if (w) {
-    cupdlp_float begin = getTimeStamp();
+
+  cupdlp_float begin = getTimeStamp();
 #ifndef CUPDLP_CPU
 
-    // CUDAmv *MV = w->MV;
-    // if (MV)
-    // {
-    //     cupdlp_float begin = getTimeStamp();
-    //     cuda_free_mv(MV);
-    //     timers->FreeDeviceMemTime += getTimeStamp() - begin;
-    // }
-    CHECK_CUBLAS(cublasDestroy(w->cublashandle))
-    CHECK_CUSPARSE(cusparseDestroy(w->cusparsehandle))
-    CHECK_CUDA(cudaFree(w->dBuffer))
-    if (w->buffer2) CUPDLP_FREE_VEC(w->buffer2);
-    if (w->buffer3) CUPDLP_FREE_VEC(w->buffer3);
+  // CUDAmv *MV = w->MV;
+  // if (MV)
+  // {
+  //     cupdlp_float begin = getTimeStamp();
+  //     cuda_free_mv(MV);
+  //     timers->FreeDeviceMemTime += getTimeStamp() - begin;
+  // }
+  CHECK_CUBLAS(cublasDestroy(w->cublashandle))
+  CHECK_CUSPARSE(cusparseDestroy(w->cusparsehandle))
+  CHECK_CUDA(cudaFree(w->dBuffer_csc_ATy))
+  CHECK_CUDA(cudaFree(w->dBuffer_csr_Ax))
+  if (w->buffer2) CUPDLP_FREE_VEC(w->buffer2);
+  if (w->buffer3) CUPDLP_FREE_VEC(w->buffer3);
 #endif
-    if (w->colScale) CUPDLP_FREE_VEC(w->colScale);
-    if (w->rowScale) CUPDLP_FREE_VEC(w->rowScale);
+  if (w->colScale) CUPDLP_FREE_VEC(w->colScale);
+  if (w->rowScale) CUPDLP_FREE_VEC(w->rowScale);
 
-    if (w->buffer) {
-      // CUPDLP_FREE_VEC(w->buffer);
-      vec_clear(w->buffer);
-    }
+  if (w->buffer) {
+    // CUPDLP_FREE_VEC(w->buffer);
+    vec_clear(w->buffer);
+  }
 
-    if (problem) {
-      // problem_clear(problem);
-      problem = cupdlp_NULL;
-    }
+  if (w->buffer2 != NULL) {
+    // CUPDLP_FREE_VEC(w->buffer);
+    free(w->buffer2);
+  }
 
-    if (iterates) {
-      iterates_clear(iterates);
-    }
+  if (w->buffer3) {
+    // CUPDLP_FREE_VEC(w->buffer);
+    free(w->buffer3);
+  }
 
-    if (resobj) {
-      resobj_clear(resobj);
-    }
+  if (problem) {
+    // problem_clear(problem);
+    problem = cupdlp_NULL;
+  }
+
+  if (iterates) {
+    iterates_clear(iterates);
+  }
+
+  if (resobj) {
+    resobj_clear(resobj);
+  }
 
 #ifndef CUPDLP_CPU
-    timers->FreeDeviceMemTime += getTimeStamp() - begin;
+  timers->FreeDeviceMemTime += getTimeStamp() - begin;
 #endif
 
-    if (settings) {
-      settings_clear(settings);
-    }
-    if (stepsize) {
-      stepsize_clear(stepsize);
-    }
-    if (timers) {
-      timers_clear(timers);
-    }
-    if (scaling) {
-      // scaling_clear(scaling);
-      scaling = cupdlp_NULL;
-    }
-    cupdlp_free(w);
+  if (settings) {
+    settings_clear(settings);
+  }
+  if (stepsize) {
+    stepsize_clear(stepsize);
+  }
+  if (timers) {
+  timers_clear(w->settings->nLogLevel, timers);
   }
+  if (scaling) {
+    // scaling_clear(scaling);
+    // if (scaling->colScale) {
+    //    cupdlp_free(scaling->colScale);
+    // }
+    // if (scaling->rowScale) {
+    //    cupdlp_free(scaling->rowScale);
+    // }
+    // cupdlp_free(scaling);
+    scaling = cupdlp_NULL;
+  }
+  cupdlp_free(w);
 
   return 0;
 }
@@ -421,7 +454,7 @@ void PDHG_PrintPDHGParam(CUPDLPwork *w) {
   cupdlp_printf("\n");
 }
 
-void PDHG_PrintHugeCUPDHG() {
+void PDHG_PrintHugeCUPDHG(void) {
   cupdlp_printf("\n");
   cupdlp_printf("  ____ _   _ ____  ____  _     ____\n");
   cupdlp_printf(" / ___| | | |  _ \\|  _ \\| |   |  _ \\\n");
@@ -431,7 +464,7 @@ void PDHG_PrintHugeCUPDHG() {
   cupdlp_printf("\n");
 }
 
-void PDHG_PrintUserParamHelper() {
+void PDHG_PrintUserParamHelper(void) {
   PDHG_PrintHugeCUPDHG();
 
   cupdlp_printf("CUPDHG User Parameters:\n");
@@ -602,14 +635,14 @@ cupdlp_retcode getUserParam(int argc, char **argv,
     }
   }
 
-  if (argc>0) {
-    if (strcmp(argv[argc - 1], "-h") == 0) {
-      PDHG_PrintUserParamHelper();
+  // if (argc>0) {
+  //   if (strcmp(argv[argc - 1], "-h") == 0) {
+  //     PDHG_PrintUserParamHelper();
       
-      retcode = RETCODE_FAILED;
-      goto exit_cleanup;
-    }
-  }
+  //     retcode = RETCODE_FAILED;
+  //     goto exit_cleanup;
+  //   }
+  // }
 
 exit_cleanup:
   return retcode;
@@ -807,33 +840,52 @@ cupdlp_retcode resobj_Alloc(CUPDLPresobj *resobj, CUPDLPproblem *problem,
                             cupdlp_int ncols, cupdlp_int nrows) {
   cupdlp_retcode retcode = RETCODE_OK;
 
-  CUPDLP_INIT_ZERO_DOUBLE_VEC(resobj->primalResidual, nrows);
-  CUPDLP_INIT_ZERO_DOUBLE_VEC(resobj->dualResidual, ncols);
-  CUPDLP_INIT_ZERO_DOUBLE_VEC(resobj->primalResidualAverage, nrows);
-  CUPDLP_INIT_ZERO_DOUBLE_VEC(resobj->dualResidualAverage, ncols);
-  CUPDLP_INIT_ZERO_DOUBLE_VEC(resobj->dSlackPos, ncols);
-  CUPDLP_INIT_ZERO_DOUBLE_VEC(resobj->dSlackNeg, ncols);
-  CUPDLP_INIT_ZERO_DOUBLE_VEC(resobj->dSlackPosAverage, ncols);
-  CUPDLP_INIT_ZERO_DOUBLE_VEC(resobj->dSlackNegAverage, ncols);
-  CUPDLP_INIT_ZERO_DOUBLE_VEC(resobj->dLowerFiltered, ncols);
-  CUPDLP_INIT_ZERO_DOUBLE_VEC(resobj->dUpperFiltered, ncols);
-
-  CUPDLP_INIT_ZERO_DOUBLE_VEC(resobj->primalInfeasRay, ncols);
-  CUPDLP_INIT_ZERO_DOUBLE_VEC(resobj->primalInfeasConstr, nrows);
-  CUPDLP_INIT_ZERO_DOUBLE_VEC(resobj->primalInfeasBound, ncols);
-  CUPDLP_INIT_ZERO_DOUBLE_VEC(resobj->dualInfeasRay, nrows);
-  CUPDLP_INIT_ZERO_DOUBLE_VEC(resobj->dualInfeasLbRay, ncols);
-  CUPDLP_INIT_ZERO_DOUBLE_VEC(resobj->dualInfeasUbRay, ncols);
-  CUPDLP_INIT_ZERO_DOUBLE_VEC(resobj->dualInfeasConstr, ncols);
-  // CUPDLP_INIT_DOUBLE_ZERO_VEC(resobj->dualInfeasBound, nrows);
+#if !defined(CUPDLP_CPU) && USE_KERNELS
+  resobj->primalResidual = NULL;
+  resobj->dualResidual = NULL;
+  resobj->primalResidualAverage = NULL;
+  resobj->dualResidualAverage = NULL;
+#else
+
+  cupdlp_init_zero_vec_double(resobj->primalResidual, nrows);
+  cupdlp_init_zero_vec_double(resobj->dualResidual, ncols);
+  cupdlp_init_zero_vec_double(resobj->primalResidualAverage, nrows);
+  cupdlp_init_zero_vec_double(resobj->dualResidualAverage, ncols);
+
+#endif
+
+  cupdlp_init_zero_vec_double(resobj->dSlackPos, ncols);
+  cupdlp_init_zero_vec_double(resobj->dSlackNeg, ncols);
+  cupdlp_init_zero_vec_double(resobj->dSlackPosAverage, ncols);
+  cupdlp_init_zero_vec_double(resobj->dSlackNegAverage, ncols);
+  cupdlp_init_zero_vec_double(resobj->dLowerFiltered, ncols);
+  cupdlp_init_zero_vec_double(resobj->dUpperFiltered, ncols);
+
+#if !defined(CUPDLP_CPU) && USE_KERNELS
+  resobj->primalInfeasRay = NULL;
+  resobj->primalInfeasConstr = NULL;
+  resobj->primalInfeasBound = NULL;
+  resobj->dualInfeasRay = NULL;
+  resobj->dualInfeasLbRay = NULL;
+  resobj->dualInfeasUbRay = NULL;
+#else
+
+  cupdlp_init_zero_vec_double(resobj->primalInfeasRay, ncols);
+  cupdlp_init_zero_vec_double(resobj->primalInfeasConstr, nrows);
+  cupdlp_init_zero_vec_double(resobj->primalInfeasBound, ncols);
+  cupdlp_init_zero_vec_double(resobj->dualInfeasRay, nrows);
+  cupdlp_init_zero_vec_double(resobj->dualInfeasLbRay, ncols);
+  cupdlp_init_zero_vec_double(resobj->dualInfeasUbRay, ncols);
+#endif
 
-  // need to translate to cuda type
-  // for (int i = 0; i < ncols; i++)
-  // {
-  //     resobj->dLowerFiltered[i] = problem->lower[i] > -INFINITY ?
-  //     problem->lower[i] : 0.0; resobj->dUpperFiltered[i] = problem->upper[i]
-  //     < +INFINITY ? problem->upper[i] : 0.0;
-  // }
+
+#if !defined(CUPDLP_CPU) && USE_KERNELS
+  resobj->dualInfeasConstr = NULL;
+#else
+  cupdlp_init_zero_vec_double(resobj->dualInfeasConstr, ncols);
+#endif
+
+  // CUPDLP_INIT_DOUBLE_ZERO_VEC(resobj->dualInfeasBound, nrows);
 
   cupdlp_filterlb(resobj->dLowerFiltered, problem->lower, -INFINITY, ncols);
   cupdlp_filterub(resobj->dUpperFiltered, problem->upper, +INFINITY, ncols);
@@ -891,35 +943,35 @@ cupdlp_retcode iterates_Alloc(CUPDLPiterates *iterates, cupdlp_int ncols,
   iterates->nCols = ncols;
   iterates->nRows = nrows;
 
-  CUPDLP_INIT_ZERO_DOUBLE_VEC(iterates->xSum, ncols);
-  CUPDLP_INIT_ZERO_DOUBLE_VEC(iterates->ySum, nrows);
-  CUPDLP_INIT_ZERO_DOUBLE_VEC(iterates->xLastRestart, ncols);
-  CUPDLP_INIT_ZERO_DOUBLE_VEC(iterates->yLastRestart, nrows);
+  cupdlp_init_zero_vec_double(iterates->xSum, ncols);
+  cupdlp_init_zero_vec_double(iterates->ySum, nrows);
+  cupdlp_init_zero_vec_double(iterates->xLastRestart, ncols);
+  cupdlp_init_zero_vec_double(iterates->yLastRestart, nrows);
 
-  CUPDLP_INIT_CUPDLP_VEC(iterates->x, 1);
-  CUPDLP_INIT_CUPDLP_VEC(iterates->xUpdate, 1);
+  CUPDLP_INIT_CUPDLP_VEC(iterates->x[0], 1);
+  CUPDLP_INIT_CUPDLP_VEC(iterates->x[1], 1);
   CUPDLP_INIT_CUPDLP_VEC(iterates->xAverage, 1);
-  CUPDLP_INIT_CUPDLP_VEC(iterates->y, 1);
-  CUPDLP_INIT_CUPDLP_VEC(iterates->yUpdate, 1);
+  CUPDLP_INIT_CUPDLP_VEC(iterates->y[0], 1);
+  CUPDLP_INIT_CUPDLP_VEC(iterates->y[1], 1);
   CUPDLP_INIT_CUPDLP_VEC(iterates->yAverage, 1);
-  CUPDLP_INIT_CUPDLP_VEC(iterates->ax, 1);
-  CUPDLP_INIT_CUPDLP_VEC(iterates->axUpdate, 1);
+  CUPDLP_INIT_CUPDLP_VEC(iterates->ax[0], 1);
+  CUPDLP_INIT_CUPDLP_VEC(iterates->ax[1], 1);
   CUPDLP_INIT_CUPDLP_VEC(iterates->axAverage, 1);
-  CUPDLP_INIT_CUPDLP_VEC(iterates->aty, 1);
-  CUPDLP_INIT_CUPDLP_VEC(iterates->atyUpdate, 1);
+  CUPDLP_INIT_CUPDLP_VEC(iterates->aty[0], 1);
+  CUPDLP_INIT_CUPDLP_VEC(iterates->aty[1], 1);
   CUPDLP_INIT_CUPDLP_VEC(iterates->atyAverage, 1);
 
-  CUPDLP_CALL(vec_Alloc(iterates->x, ncols));
-  CUPDLP_CALL(vec_Alloc(iterates->xUpdate, ncols));
+  CUPDLP_CALL(vec_Alloc(iterates->x[0], ncols));
+  CUPDLP_CALL(vec_Alloc(iterates->x[1], ncols));
   CUPDLP_CALL(vec_Alloc(iterates->xAverage, ncols));
-  CUPDLP_CALL(vec_Alloc(iterates->y, nrows));
-  CUPDLP_CALL(vec_Alloc(iterates->yUpdate, nrows));
+  CUPDLP_CALL(vec_Alloc(iterates->y[0], nrows));
+  CUPDLP_CALL(vec_Alloc(iterates->y[1], nrows));
   CUPDLP_CALL(vec_Alloc(iterates->yAverage, nrows));
-  CUPDLP_CALL(vec_Alloc(iterates->ax, nrows));
-  CUPDLP_CALL(vec_Alloc(iterates->axUpdate, nrows));
+  CUPDLP_CALL(vec_Alloc(iterates->ax[0], nrows));
+  CUPDLP_CALL(vec_Alloc(iterates->ax[1], nrows));
   CUPDLP_CALL(vec_Alloc(iterates->axAverage, nrows));
-  CUPDLP_CALL(vec_Alloc(iterates->aty, ncols));
-  CUPDLP_CALL(vec_Alloc(iterates->atyUpdate, ncols));
+  CUPDLP_CALL(vec_Alloc(iterates->aty[0], ncols));
+  CUPDLP_CALL(vec_Alloc(iterates->aty[1], ncols));
   CUPDLP_CALL(vec_Alloc(iterates->atyAverage, ncols));
 
   // initialization
@@ -1003,11 +1055,11 @@ exit_cleanup:
 
 cupdlp_retcode vec_Alloc(CUPDLPvec *vec, cupdlp_int n) {
   cupdlp_retcode retcode = RETCODE_OK;
-  CUPDLP_INIT_ZERO_DOUBLE_VEC(vec->data, n);
+  cupdlp_init_zero_vec_double(vec->data, n);
   vec->len = n;
 #ifndef CUPDLP_CPU
   CHECK_CUSPARSE(
-      cusparseCreateDnVec(&vec->cuda_vec, n, vec->data, CudaComputeType));
+      cusparseCreateDnVec(&vec->cuda_vec, n, vec->data, CudaComputeType))
 #endif
 
 exit_cleanup:
@@ -1029,14 +1081,20 @@ cupdlp_retcode PDHG_Alloc(CUPDLPwork *w) {
   // buffer
   CUPDLP_INIT_CUPDLP_VEC(w->buffer, 1);
   CUPDLP_CALL(vec_Alloc(w->buffer, w->problem->data->nRows));
-  CUPDLP_INIT_ZERO_DOUBLE_VEC(w->buffer2,
-                       MAX(w->problem->data->nCols, w->problem->data->nRows));
-  CUPDLP_INIT_ZERO_DOUBLE_VEC(w->buffer3,
-                       MAX(w->problem->data->nCols, w->problem->data->nRows));
+
+
+  cupdlp_init_zero_vec_double(w->buffer2,
+                       MAX(2048, MAX(w->problem->data->nCols, w->problem->data->nRows)));
+#if defined(CUPDLP_CPU) || !(USE_KERNELS) || (CUPDLP_DUMP_LINESEARCH_STATS && CUPDLP_DEBUG)
+  cupdlp_init_zero_vec_double(w->buffer3,
+                       MAX(2048, MAX(w->problem->data->nCols, w->problem->data->nRows)));
+#else
+  w->buffer3 = NULL;
+#endif
 
   // for scaling
-  CUPDLP_INIT_ZERO_DOUBLE_VEC(w->colScale, w->problem->data->nCols);
-  CUPDLP_INIT_ZERO_DOUBLE_VEC(w->rowScale, w->problem->data->nRows);
+  cupdlp_init_zero_vec_double(w->colScale, w->problem->data->nCols);
+  cupdlp_init_zero_vec_double(w->rowScale, w->problem->data->nRows);
 
   CUPDLP_CALL(settings_Alloc(w->settings));
   CUPDLP_CALL(resobj_Alloc(w->resobj, w->problem, w->problem->data->nCols,
@@ -1048,12 +1106,12 @@ cupdlp_retcode PDHG_Alloc(CUPDLPwork *w) {
 #ifndef CUPDLP_CPU
   //   CHECK_CUSPARSE(cusparseCreate(&w->cusparsehandle));
   //   CHECK_CUBLAS(cublasCreate(&w->cublashandle));
-  cuda_alloc_MVbuffer(
+  CUPDLP_CALL(cuda_alloc_MVbuffer(
       //   w->problem->data->matrix_format,
       w->cusparsehandle, w->problem->data->csc_matrix->cuda_csc,
-      w->iterates->x->cuda_vec, w->iterates->ax->cuda_vec,
-      w->problem->data->csr_matrix->cuda_csr, w->iterates->y->cuda_vec,
-      w->iterates->aty->cuda_vec, &w->dBuffer);
+      w->iterates->x[0]->cuda_vec, w->iterates->ax[0]->cuda_vec,
+      w->problem->data->csr_matrix->cuda_csr, w->iterates->y[0]->cuda_vec,
+      w->iterates->aty[0]->cuda_vec, &w->dBuffer_csc_ATy, &w->dBuffer_csr_Ax))
   w->timers->AllocMem_CopyMatToDeviceTime += getTimeStamp() - begin;
 #endif
 
@@ -1077,14 +1135,30 @@ exit_cleanup:
 void PDHG_Destroy(CUPDLPwork **w) {
   if (w && *w) {
     PDHG_Clear(*w);
-#ifndef CUPDLP_CPU
-    cudaDeviceReset();
-#endif
   }
 }
 
 void PDHG_Init_Data(CUPDLPwork *work) {}
 
+// double my_clock(void) {
+
+// #ifdef CUPDLP_TIMER
+
+// #if defined(_WIN32) || defined(_WIN64)
+//   return (double)clock() / CLOCKS_PER_SEC;
+// #else
+//   struct timeval t;
+//   gettimeofday(&t, NULL);
+//   return (1e-06 * t.tv_usec + t.tv_sec);
+// #endif
+
+// #else
+//   return 0;
+// #endif
+
+// }
+
+
 double my_clock(void) {
 #ifdef CUPDLP_TIMER
   // struct timeval t;
@@ -1308,6 +1382,7 @@ exit_cleanup:
 
 cupdlp_retcode csc_create(CUPDLPcsc **csc) {
   cupdlp_retcode retcode = RETCODE_OK;
+
   CUPDLP_INIT_CSC_MATRIX(*csc, 1);
 
 exit_cleanup:
@@ -1318,7 +1393,7 @@ cupdlp_retcode dense_alloc_matrix(CUPDLPdense *dense, cupdlp_int nRows,
                                   cupdlp_int nCols, void *src,
                                   CUPDLP_MATRIX_FORMAT src_matrix_format) {
   cupdlp_retcode retcode = RETCODE_OK;
-  CUPDLP_INIT_ZERO_DOUBLE_VEC(dense->data, nRows * nCols);
+  cupdlp_init_zero_vec_double(dense->data, nRows * nCols);
 
   switch (src_matrix_format) {
     case DENSE:
@@ -1356,9 +1431,9 @@ cupdlp_retcode csr_alloc_matrix(CUPDLPcsr *csr, cupdlp_int nRows,
       break;
   }
   // todo make sure this is right
-  CUPDLP_INIT_ZERO_INT_VEC(csr->rowMatBeg, nRows + 1);
-  CUPDLP_INIT_ZERO_INT_VEC(csr->rowMatIdx, nnz);
-  CUPDLP_INIT_ZERO_DOUBLE_VEC(csr->rowMatElem, nnz);
+  cupdlp_init_zero_vec_int(csr->rowMatBeg, nRows + 1);
+  cupdlp_init_zero_vec_int(csr->rowMatIdx, nnz);
+  cupdlp_init_zero_vec_double(csr->rowMatElem, nnz);
 
   switch (src_matrix_format) {
     case DENSE:
@@ -1395,9 +1470,10 @@ cupdlp_retcode csc_alloc_matrix(CUPDLPcsc *csc, cupdlp_int nRows,
     default:
       break;
   }
-  CUPDLP_INIT_ZERO_INT_VEC(csc->colMatBeg, nCols + 1);
-  CUPDLP_INIT_ZERO_INT_VEC(csc->colMatIdx, nnz);
-  CUPDLP_INIT_ZERO_DOUBLE_VEC(csc->colMatElem, nnz);
+
+  cupdlp_init_zero_vec_int(csc->colMatBeg, nCols + 1);
+  cupdlp_init_zero_vec_int(csc->colMatIdx, nnz);
+  cupdlp_init_zero_vec_double(csc->colMatElem, nnz);
 
   switch (src_matrix_format) {
     case DENSE:
@@ -1422,7 +1498,7 @@ cupdlp_retcode dense_alloc(CUPDLPdense *dense, cupdlp_int nRows,
   dense->nRows = nRows;
   dense->nCols = nCols;
   dense->data = cupdlp_NULL;
-  CUPDLP_INIT_ZERO_DOUBLE_VEC(dense->data, nRows * nCols);
+  cupdlp_init_zero_vec_double(dense->data, nRows * nCols);
 
   CUPDLP_COPY_VEC(dense->data, val, cupdlp_float, nRows * nCols);
 exit_cleanup:
@@ -1440,9 +1516,9 @@ cupdlp_retcode csr_alloc(CUPDLPcsr *csr, cupdlp_int nRows, cupdlp_int nCols,
   csr->rowMatIdx = cupdlp_NULL;
   csr->rowMatElem = cupdlp_NULL;
 
-  CUPDLP_INIT_ZERO_INT_VEC(csr->rowMatBeg, nRows + 1);
-  CUPDLP_INIT_ZERO_INT_VEC(csr->rowMatIdx, nnz);
-  CUPDLP_INIT_ZERO_DOUBLE_VEC(csr->rowMatElem, nnz);
+  cupdlp_init_zero_vec_int(csr->rowMatBeg, nRows + 1);
+  cupdlp_init_zero_vec_int(csr->rowMatIdx, nnz);
+  cupdlp_init_zero_vec_double(csr->rowMatElem, nnz);
 
   CUPDLP_COPY_VEC(csr->rowMatBeg, row_ptr, cupdlp_int, nRows + 1);
   CUPDLP_COPY_VEC(csr->rowMatIdx, col_ind, cupdlp_int, nnz);
@@ -1461,9 +1537,9 @@ cupdlp_retcode csc_alloc(CUPDLPcsc *csc, cupdlp_int nRows, cupdlp_int nCols,
   csc->colMatBeg = cupdlp_NULL;
   csc->colMatIdx = cupdlp_NULL;
   csc->colMatElem = cupdlp_NULL;
-  CUPDLP_INIT_ZERO_INT_VEC(csc->colMatBeg, nCols + 1);
-  CUPDLP_INIT_ZERO_INT_VEC(csc->colMatIdx, nnz);
-  CUPDLP_INIT_ZERO_DOUBLE_VEC(csc->colMatElem, nnz);
+  cupdlp_init_zero_vec_int(csc->colMatBeg, nCols + 1);
+  cupdlp_init_zero_vec_int(csc->colMatIdx, nnz);
+  cupdlp_init_zero_vec_double(csc->colMatElem, nnz);
 
   CUPDLP_COPY_VEC(csc->colMatBeg, col_ptr, cupdlp_int, nCols + 1);
   CUPDLP_COPY_VEC(csc->colMatIdx, row_ind, cupdlp_int, nnz);
@@ -1497,12 +1573,17 @@ void PDHG_Dump_Stats(CUPDLPwork *w) {
   cupdlp_printf("------------------------------------------------\n");
   cupdlp_printf("Iteration % 3d\n", w->timers->nIter);
 #if CUPDLP_DUMP_ITERATES
-  vecPrint("x", iterates->x->data, nCols);
-  vecPrint("y", iterates->y->data, nRows);
+  cupdlp_int iter = w->timers->nIter;
+  CUPDLPvec *x = iterates->x[iter % 2];
+  CUPDLPvec *y = iterates->y[iter % 2];
+  CUPDLPvec *aty = iterates->aty[iter % 2];
+
+  vecPrint("x", x->data, nCols);
+  vecPrint("y", y->data, nRows);
   vecPrint("xSum", iterates->xSum, nCols);
   vecPrint("ySum", iterates->ySum, nRows);
-  vecPrint("Ax ", iterates->ax->data, nRows);
-  vecPrint("A'y", iterates->aty->data, nCols);
+  vecPrint("Ax ", ax->data, nRows);
+  vecPrint("A'y", aty->data, nCols);
   vecPrint("xLastRestart", iterates->xLastRestart, nCols);
   vecPrint("yLastRestart", iterates->yLastRestart, nRows);
 #endif