lpsolver 0.1.0 → 0.2.0

data/ext/lpsolver-highs/highs/pdlp/cupdlp/cuda/cupdlp_cuda_kernels.cu

@@ -0,0 +1,338 @@
+#include "cupdlp_cuda_kernels.cuh"
+
+
+
+__global__ void element_primal_feas_kernel(cupdlp_float *z,
+                                           const cupdlp_float *ax,
+                                           const cupdlp_float *rhs,
+                                           const cupdlp_float *rowScale,
+                                           int ifScaled,
+                                           int nEqs, int nRows) {
+  for (int i = blockDim.x * blockIdx.x + threadIdx.x; i < nRows; i += gridDim.x * blockDim.x) {
+    cupdlp_float tmp = ax[i] - rhs[i];
+    if (i >= nEqs) tmp = min(tmp, 0.0);
+    z[i] = tmp * (ifScaled ? rowScale[i] : 1.0);
+  }
+}
+
+__global__ void element_dual_feas_kernel_1(cupdlp_float *z,
+                                           const cupdlp_float *aty,
+                                           const cupdlp_float *cost,
+                                           int nCols) {
+  for (int i = blockDim.x * blockIdx.x + threadIdx.x; i < nCols; i += gridDim.x * blockDim.x) {
+    z[i] = cost[i] - aty[i];
+  }
+}
+
+__global__ void element_dual_feas_kernel_2(cupdlp_float *z,
+                                           const cupdlp_float *dualResidual,
+                                           const cupdlp_float *hasLower,
+                                           int nCols) {
+  for (int i = blockDim.x * blockIdx.x + threadIdx.x; i < nCols; i += gridDim.x * blockDim.x) {
+    z[i] = max(dualResidual[i], 0.0) * hasLower[i];
+  }
+}
+
+__global__ void element_dual_feas_kernel_3(cupdlp_float *z,
+                                           const cupdlp_float *dualResidual,
+                                           const cupdlp_float *hasUpper,
+                                           int nCols) {
+  for (int i = blockDim.x * blockIdx.x + threadIdx.x; i < nCols; i += gridDim.x * blockDim.x) {
+    z[i] = -min(dualResidual[i], 0.0) * hasUpper[i];
+  }
+}
+
+__global__ void element_primal_infeas_kernel(cupdlp_float *z, const cupdlp_float *aty,
+                                             const cupdlp_float *dSlackPos,
+                                             const cupdlp_float *dSlackNeg,
+                                             const cupdlp_float *colScale,
+                                             cupdlp_float alpha, int ifScaled, int nCols) {
+  for (int i = blockDim.x * blockIdx.x + threadIdx.x; i < nCols; i += gridDim.x * blockDim.x) {
+    z[i] = alpha * (aty[i] + dSlackPos[i] - dSlackNeg[i]) * (ifScaled ? colScale[i] : 1.0);
+  }
+}
+
+__global__ void element_dual_infeas_kernel_lb(cupdlp_float *z,
+                                              const cupdlp_float *x,
+                                              const cupdlp_float *hasLower,
+                                              const cupdlp_float *colScale,
+                                              cupdlp_float alpha, int ifScaled, int nCols) {
+  for (int i = blockDim.x * blockIdx.x + threadIdx.x; i < nCols; i += gridDim.x * blockDim.x) {
+    z[i] = min(alpha * x[i], 0.0) * hasLower[i] / (ifScaled ? colScale[i] : 1.0);
+  }
+}
+
+__global__ void element_dual_infeas_kernel_ub(cupdlp_float *z,
+                                              const cupdlp_float *x,
+                                              const cupdlp_float *hasUpper,
+                                              const cupdlp_float *colScale,
+                                              cupdlp_float alpha, int ifScaled, int nCols) {
+  for (int i = blockDim.x * blockIdx.x + threadIdx.x; i < nCols; i += gridDim.x * blockDim.x) {
+    z[i] = max(alpha * x[i], 0.0) * hasUpper[i] / (ifScaled ? colScale[i] : 1.0);
+  }
+}
+
+__global__ void element_dual_infeas_kernel_constr(cupdlp_float *z,
+                                                  const cupdlp_float *ax,
+                                                  const cupdlp_float *rowScale,
+                                                  cupdlp_float alpha, int ifScaled,
+                                                  int nEqs, int nRows) {
+  for (int i = blockDim.x * blockIdx.x + threadIdx.x; i < nRows; i += gridDim.x * blockDim.x) {
+    cupdlp_float tmp = alpha * ax[i];
+    if (i >= nEqs) tmp = min(tmp, 0.0);
+    z[i] = tmp * (ifScaled ? rowScale[i] : 1.0);
+  }
+}
+
+__global__ void element_wise_dot_kernel(cupdlp_float *x, const cupdlp_float *y, int n) {
+  for (int i = blockDim.x * blockIdx.x + threadIdx.x; i < n; i += gridDim.x * blockDim.x) {
+    x[i] *= y[i];
+  }
+}
+
+__global__ void element_wise_div_kernel(cupdlp_float *x, const cupdlp_float *y, int n) {
+  for (int i = blockDim.x * blockIdx.x + threadIdx.x; i < n; i += gridDim.x * blockDim.x) {
+    x[i] /= y[i];
+  }
+}
+
+__global__ void element_wise_projlb_kernel(cupdlp_float *x,
+                                           const cupdlp_float *lb, int n) {
+  for (int i = blockDim.x * blockIdx.x + threadIdx.x; i < n; i += gridDim.x * blockDim.x) {
+    x[i] = max(x[i], lb[i]);
+  }
+}
+
+__global__ void element_wise_projub_kernel(cupdlp_float *x,
+                                           const cupdlp_float *ub, int n) {
+  for (int i = blockDim.x * blockIdx.x + threadIdx.x; i < n; i += gridDim.x * blockDim.x) {
+    x[i] = min(x[i], ub[i]);
+  }
+}
+
+__global__ void element_wise_projSamelb_kernel(cupdlp_float *x,
+                                               cupdlp_float lb, int n) {
+  for (int i = blockDim.x * blockIdx.x + threadIdx.x; i < n; i += gridDim.x * blockDim.x) {
+    x[i] = max(x[i], lb);
+  }
+}
+
+__global__ void element_wise_projSameub_kernel(cupdlp_float *x,
+                                               cupdlp_float ub, int n) {
+  for (int i = blockDim.x * blockIdx.x + threadIdx.x; i < n; i += gridDim.x * blockDim.x) {
+    x[i] = min(x[i], ub);
+  }
+}
+
+__global__ void element_wise_initHaslb_kernel(cupdlp_float *haslb,
+                                              const cupdlp_float *lb,
+                                              cupdlp_float bound, int n) {
+  for (int i = blockDim.x * blockIdx.x + threadIdx.x; i < n; i += gridDim.x * blockDim.x) {
+    haslb[i] = lb[i] > bound ? 1.0 : 0.0;
+  }
+}
+
+__global__ void element_wise_initHasub_kernel(cupdlp_float *hasub,
+                                              const cupdlp_float *ub,
+                                              cupdlp_float bound, int n) {
+  for (int i = blockDim.x * blockIdx.x + threadIdx.x; i < n; i += gridDim.x * blockDim.x) {
+    hasub[i] = ub[i] < bound ? 1.0 : 0.0;
+  }
+}
+
+__global__ void element_wise_filterlb_kernel(cupdlp_float *x,
+                                             const cupdlp_float *lb,
+                                             cupdlp_float bound, int n) {
+  for (int i = blockDim.x * blockIdx.x + threadIdx.x; i < n; i += gridDim.x * blockDim.x) {
+    x[i] = lb[i] > bound ? lb[i] : 0.0;
+  }
+}
+
+__global__ void element_wise_filterub_kernel(cupdlp_float *x,
+                                             const cupdlp_float *ub,
+                                             cupdlp_float bound, int n) {
+  for (int i = blockDim.x * blockIdx.x + threadIdx.x; i < n; i += gridDim.x * blockDim.x) {
+    x[i] = ub[i] < bound ? ub[i] : 0.0;
+  }
+}
+
+__global__ void init_cuda_vec_kernel(cupdlp_float *x, cupdlp_float val, int n) {
+  for (int i = blockDim.x * blockIdx.x + threadIdx.x; i < n; i += gridDim.x * blockDim.x) {
+    x[i] = val;
+  }
+}
+
+// xUpdate = proj(x - dPrimalStep * (cost - ATy))
+__global__ void primal_grad_step_kernel(cupdlp_float *__restrict__ xUpdate,
+                                        const cupdlp_float * __restrict__ x,
+                                        const cupdlp_float * __restrict__ cost,
+                                        const cupdlp_float * __restrict__ ATy,
+                                        const cupdlp_float * __restrict__ lb,
+                                        const cupdlp_float * __restrict__ ub,
+                                        cupdlp_float dPrimalStep, int nCols) {
+  for (int i = blockDim.x * blockIdx.x + threadIdx.x; i < nCols; i += gridDim.x * blockDim.x) {
+    xUpdate[i] = min(max(cupdlp_fma_rn(dPrimalStep, ATy[i] - cost[i], x[i]), lb[i]), ub[i]);
+  }
+}
+
+// yUpdate = proj(y + dDualStep * (b - 2 AxUpdate + Ax))
+__global__ void dual_grad_step_kernel(cupdlp_float * __restrict__ yUpdate,
+                                      const cupdlp_float * __restrict__ y,
+                                      const cupdlp_float * __restrict__ b,
+                                      const cupdlp_float * __restrict__ Ax,
+                                      const cupdlp_float * __restrict__ AxUpdate,
+                                      cupdlp_float dDualStep, int nRows, int nEqs) {
+  for (int i = blockDim.x * blockIdx.x + threadIdx.x; i < nRows; i += gridDim.x * blockDim.x) {
+    cupdlp_float upd = cupdlp_fma_rn(dDualStep, b[i] - 2 * AxUpdate[i] + Ax[i], y[i]);
+    yUpdate[i] = i >= nEqs ? max(upd, 0.0) : upd;
+  }
+}
+
+/*
+// z = x - y
+__global__ void naive_sub_kernel(cupdlp_float *z, const cupdlp_float *x,
+                                 const cupdlp_float *y, int n) {
+  for (int i = blockDim.x * blockIdx.x + threadIdx.x; i < n; i += gridDim.x * blockDim.x) {
+    z[i] = x[i] - y[i];
+  }
+}
+*/
+
+
+#define QUARTER_WARP_REDUCE_2(val1, val2) { \
+  val1 += __shfl_down_sync(0xFFFFFFFF, val1, 4); \
+  val2 += __shfl_down_sync(0xFFFFFFFF, val2, 4); \
+  val1 += __shfl_down_sync(0xFFFFFFFF, val1, 2); \
+  val2 += __shfl_down_sync(0xFFFFFFFF, val2, 2); \
+  val1 += __shfl_down_sync(0xFFFFFFFF, val1, 1); \
+  val2 += __shfl_down_sync(0xFFFFFFFF, val2, 1); \
+}
+
+#define FULL_WARP_REDUCE_2(val1, val2) { \
+  val1 += __shfl_down_sync(0xFFFFFFFF, val1, 16); \
+  val2 += __shfl_down_sync(0xFFFFFFFF, val2, 16); \
+  val1 += __shfl_down_sync(0xFFFFFFFF, val1, 8); \
+  val2 += __shfl_down_sync(0xFFFFFFFF, val2, 8); \
+  val1 += __shfl_down_sync(0xFFFFFFFF, val1, 4); \
+  val2 += __shfl_down_sync(0xFFFFFFFF, val2, 4); \
+  val1 += __shfl_down_sync(0xFFFFFFFF, val1, 2); \
+  val2 += __shfl_down_sync(0xFFFFFFFF, val2, 2); \
+  val1 += __shfl_down_sync(0xFFFFFFFF, val1, 1); \
+  val2 += __shfl_down_sync(0xFFFFFFFF, val2, 1); \
+}
+
+// assumes block size = 256, warp size = 32
+__global__ void movement_1_kernel(cupdlp_float * __restrict__ res_x, cupdlp_float * __restrict__ res_y,
+                                  const cupdlp_float * __restrict__ xUpdate, const cupdlp_float * __restrict__ x,
+                                  const cupdlp_float * __restrict__ atyUpdate, const cupdlp_float * __restrict__ aty,
+                                  int nCols) {
+
+  __shared__ cupdlp_float shared_x[32];
+  __shared__ cupdlp_float shared_y[32];
+  cupdlp_float val_x = 0.0;
+  cupdlp_float val_y = 0.0;
+  for (int i = blockDim.x * blockIdx.x + threadIdx.x; i < nCols; i += blockDim.x * gridDim.x) {
+      cupdlp_float dx = xUpdate[i] - x[i];
+      cupdlp_float day = atyUpdate[i] - aty[i];
+      val_x = cupdlp_fma_rn(dx, dx, val_x);
+      val_y = cupdlp_fma_rn(day, dx, val_y);
+  }
+
+  int lane = threadIdx.x % 32;
+  int wid = threadIdx.x / 32;
+
+  FULL_WARP_REDUCE_2(val_x, val_y)
+  if (lane == 0) {
+    shared_x[wid] = val_x;
+    shared_y[wid] = val_y;
+  }
+  __syncthreads();
+
+  if (wid == 0) {
+    val_x = (threadIdx.x < blockDim.x / 32) ? shared_x[lane] : 0.0;
+    val_y = (threadIdx.x < blockDim.x / 32) ? shared_y[lane] : 0.0;
+    QUARTER_WARP_REDUCE_2(val_x, val_y)
+    if (threadIdx.x == 0) {
+      res_x[blockIdx.x] = val_x;
+      res_y[blockIdx.x] = val_y;
+    }
+  }
+}
+
+#define QUARTER_WARP_REDUCE(val) { \
+  val += __shfl_down_sync(0xFFFFFFFF, val, 4); \
+  val += __shfl_down_sync(0xFFFFFFFF, val, 2); \
+  val += __shfl_down_sync(0xFFFFFFFF, val, 1); \
+}
+
+#define HALF_WARP_REDUCE(val) { \
+  val += __shfl_down_sync(0xFFFFFFFF, val, 8); \
+  val += __shfl_down_sync(0xFFFFFFFF, val, 4); \
+  val += __shfl_down_sync(0xFFFFFFFF, val, 2); \
+  val += __shfl_down_sync(0xFFFFFFFF, val, 1); \
+}
+
+#define FULL_WARP_REDUCE(val) { \
+  val += __shfl_down_sync(0xFFFFFFFF, val, 16); \
+  val += __shfl_down_sync(0xFFFFFFFF, val, 8); \
+  val += __shfl_down_sync(0xFFFFFFFF, val, 4); \
+  val += __shfl_down_sync(0xFFFFFFFF, val, 2); \
+  val += __shfl_down_sync(0xFFFFFFFF, val, 1); \
+}
+
+// assumes: block size = 256, warp size = 32
+__global__ void movement_2_kernel(cupdlp_float * __restrict__ res,
+                                  const cupdlp_float * __restrict__ yUpdate, const cupdlp_float * __restrict__ y,
+                                  int nRows) {
+
+  __shared__ cupdlp_float shared[32];
+  cupdlp_float val = 0.0;
+  for (int i = blockDim.x * blockIdx.x + threadIdx.x; i < nRows; i += blockDim.x * gridDim.x) {
+      cupdlp_float d = yUpdate[i] - y[i];
+      val = cupdlp_fma_rn(d, d, val);
+  }
+
+  int lane = threadIdx.x % 32;
+  int wid = threadIdx.x / 32;
+
+  FULL_WARP_REDUCE(val)
+  if (lane == 0) {
+    shared[wid] = val;
+  }
+  __syncthreads();
+
+  if (wid == 0) {
+    val = (threadIdx.x < blockDim.x / 32) ? shared[lane] : 0.0;
+    QUARTER_WARP_REDUCE(val)
+    if (threadIdx.x == 0) {
+      res[blockIdx.x] = val;
+    }
+  }
+}
+
+// assumes: block size = 512, warp size = 32
+__global__ void sum_kernel(cupdlp_float * __restrict__ res, const cupdlp_float * __restrict__ x, int n) {
+
+  __shared__ cupdlp_float shared[32];
+  cupdlp_float val = 0.0;
+  for (int i = blockDim.x * blockIdx.x + threadIdx.x; i < n; i += blockDim.x * gridDim.x) {
+      val += x[i];
+  }
+
+  int lane = threadIdx.x % 32;
+  int wid = threadIdx.x / 32;
+
+  FULL_WARP_REDUCE(val)
+  if (lane == 0) {
+    shared[wid] = val;
+  }
+  __syncthreads();
+
+  if (wid == 0) {
+    val = (threadIdx.x < blockDim.x / 32) ? shared[lane] : 0.0;
+    HALF_WARP_REDUCE(val)
+    if (threadIdx.x == 0) {
+      res[blockIdx.x] = val;
+    }
+  }
+}

data/ext/lpsolver-highs/highs/pdlp/cupdlp/cuda/cupdlp_cuda_kernels.cuh

@@ -0,0 +1,319 @@
+#ifndef CUPDLP_CUDA_KERNALS_H
+#define CUPDLP_CUDA_KERNALS_H
+
+#include <stdio.h>
+#include <stdlib.h>  /* EXIT_FAILURE */
+#include <cublas_v2.h>
+#include <cusparse.h>
+#include <cuda_runtime.h>
+
+//#define CUPDLP_BLOCK_SIZE 512
+
+#ifndef SFLOAT
+
+#ifdef DLONG
+typedef long long cupdlp_int;
+#else
+typedef int cupdlp_int;
+#endif
+typedef double cupdlp_float;
+#define CudaComputeType CUDA_R_64F
+#define cupdlp_fma_rn __fma_rn
+
+#else
+
+typedef float cupdlp_float;
+#define CudaComputeType CUDA_R_32F
+#define cupdlp_fma_rn __fmaf_rn
+
+#endif
+
+static inline cudaError_t check_cuda_call(cudaError_t status,
+                                          const char *filename, int line)
+{
+  if (status != cudaSuccess) {
+    printf("CUDA API failed at line %d of %s with error: %s (%d)\n",
+      line, filename, cudaGetErrorString(status), status);
+  }
+  return status;
+}
+
+static inline cusparseStatus_t check_cusparse_call(cusparseStatus_t status,
+                                                   const char *filename, int line)
+{
+  if (status != CUSPARSE_STATUS_SUCCESS) {
+    printf("CUSPARSE API failed at line %d of %s with error: %s (%d)\n",
+      line, filename, cusparseGetErrorString(status), status);
+  }
+  return status;
+}
+
+static inline cublasStatus_t check_cublas_call(cublasStatus_t status,
+                                               const char *filename, int line)
+{
+  if (status != CUBLAS_STATUS_SUCCESS) {
+    printf("CUBLAS API failed at line %d of %s with error: %s (%d)\n",
+      line, filename, cublasGetStatusString(status), status);
+  }
+  return status;
+}
+
+static inline cudaError_t check_cuda_last(const char *filename, int line)
+{
+  cudaError_t status = cudaGetLastError();
+  if (status != cudaSuccess) {
+    printf("CUDA API failed at line %d of %s with error: %s (%d)\n",
+      line, filename, cudaGetErrorString(status), status);
+  }
+  return status;
+}
+
+#define CHECK_CUDA(res) \
+  { if (check_cuda_call(res, __FILE__, __LINE__) != cudaSuccess) \
+      return EXIT_FAILURE; }
+#define CHECK_CUDA_STRICT(res) \
+  { if (check_cuda_call(res, __FILE__, __LINE__) != cudaSuccess) \
+      exit(EXIT_FAILURE); }
+#define CHECK_CUDA_IGNORE(res) \
+  { check_cuda_call(res, __FILE__, __LINE__); }
+
+#define CHECK_CUSPARSE(res) \
+  { if (check_cusparse_call(res, __FILE__, __LINE__) != CUSPARSE_STATUS_SUCCESS) \
+      return EXIT_FAILURE; }
+#define CHECK_CUSPARSE_STRICT(res) \
+  { if (check_cusparse_call(res, __FILE__, __LINE__) != CUSPARSE_STATUS_SUCCESS) \
+      exit(EXIT_FAILURE); }
+#define CHECK_CUSPARSE_IGNORE(res) \
+  { check_cusparse_call(res, __FILE__, __LINE__); }
+
+#define CHECK_CUBLAS(res) \
+  { if (check_cublas_call(res, __FILE__, __LINE__) != CUBLAS_STATUS_SUCCESS) \
+      return EXIT_FAILURE; }
+#define CHECK_CUBLAS_STRICT(res) \
+  { if (check_cublas_call(res, __FILE__, __LINE__) != CUBLAS_STATUS_SUCCESS) \
+      exit(EXIT_FAILURE); }
+#define CHECK_CUBLAS_IGNORE(res) \
+  { check_cublas_call(res, __FILE__, __LINE__); }
+
+#define CHECK_CUDA_LAST() check_cuda_last(__FILE__, __LINE__)
+
+
+#define CUPDLP_FREE_VEC(x) \
+  { check_cuda_call(cudaFree(x), __FILE__, __LINE__); x = cupdlp_NULL; }
+
+#define CUPDLP_COPY_VEC(dst, src, type, size) \
+  check_cuda_call( \
+    cudaMemcpy(dst, src, sizeof(type) * (size), cudaMemcpyDefault), \
+    __FILE__, __LINE__)
+
+#define CUPDLP_ZERO_VEC(var, type, size) \
+  check_cuda_call( \
+    cudaMemset(var, 0, sizeof(type) * (size)), __FILE__, __LINE__)
+
+#define CUPDLP_INIT_VEC(var, size)                                             \
+  {                                                                            \
+    cudaError_t status = cudaMalloc((void **)&var, (size) * sizeof(__typeof__(*var))); \
+    check_cuda_call(status, __FILE__, __LINE__);                               \
+    if (status != cudaSuccess) goto exit_cleanup;                              \
+  }
+
+#define CUPDLP_INIT_ZERO_VEC(var, size)                                         \
+  {                                                                            \
+    cudaError_t status = cudaMalloc((void **)&var, (size) * sizeof(__typeof__(*var))); \
+    check_cuda_call(status, __FILE__, __LINE__);                               \
+    if (status != cudaSuccess) goto exit_cleanup;                              \
+    status = cudaMemset(var, 0, (size) * sizeof(__typeof__(*var)));            \
+    if (status != cudaSuccess) goto exit_cleanup;                              \
+  }
+
+// IG 
+
+
+#define cupdlp_init_vec_int(var, size)                                   \
+  {                                                                      \
+    cudaError_t status = cudaMalloc((void**)&var, (size) * sizeof(int)); \
+    if (status != cudaSuccess) {                                         \
+      printf("CUDA API failed at line %d of %s with error: %s (%d)\n",   \
+             __LINE__, __FILE__, cudaGetErrorString(status), status);    \
+      goto exit_cleanup;                                                 \
+    }                                                                    \
+  }
+
+#define cupdlp_init_vec_double(var, size)                                   \
+  {                                                                         \
+    cudaError_t status = cudaMalloc((void**)&var, (size) * sizeof(double)); \
+    if (status != cudaSuccess) {                                            \
+      printf("CUDA API failed at line %d of %s with error: %s (%d)\n",      \
+             __LINE__, __FILE__, cudaGetErrorString(status), status);       \
+      goto exit_cleanup;                                                    \
+    }                                                                       \
+  }
+
+#define cupdlp_init_zero_vec_int(var, size)                              \
+  {                                                                      \
+    cudaError_t status = cudaMalloc((void**)&var, (size) * sizeof(int)); \
+    if (status != cudaSuccess) {                                         \
+      printf("CUDA API failed at line %d of %s with error: %s (%d)\n",   \
+             __LINE__, __FILE__, cudaGetErrorString(status), status);    \
+      goto exit_cleanup;                                                 \
+    }                                                                    \
+    status = cudaMemset(var, 0, (size) * sizeof(int));                   \
+    if (status != cudaSuccess) {                                         \
+      printf("CUDA API failed at line %d of %s with error: %s (%d)\n",   \
+             __LINE__, __FILE__, cudaGetErrorString(status), status);    \
+      goto exit_cleanup;                                                 \
+    }                                                                    \
+  }
+#define cupdlp_init_zero_vec_double(var, size)                              \
+  {                                                                         \
+    cudaError_t status = cudaMalloc((void**)&var, (size) * sizeof(double)); \
+    if (status != cudaSuccess) {                                            \
+      printf("CUDA API failed at line %d of %s with error: %s (%d)\n",      \
+             __LINE__, __FILE__, cudaGetErrorString(status), status);       \
+      goto exit_cleanup;                                                    \
+    }                                                                       \
+    status = cudaMemset(var, 0, (size) * sizeof(double));                   \
+    if (status != cudaSuccess) {                                            \
+      printf("CUDA API failed at line %d of %s with error: %s (%d)\n",      \
+             __LINE__, __FILE__, cudaGetErrorString(status), status);       \
+      goto exit_cleanup;                                                    \
+    }                                                                       \
+  }
+
+#define get_gpu_vec(vec_ptr, index, result, success)       \
+  {                                                                \
+    cublasStatus_t stat =                                          \
+      cublasGetVector(N, sizeof(*vec_ptr), vec_ptr, 1, result, 1); \
+    if (stat != CUBLAS_STATUS_SUCCESS) {                           \
+      printf("data upload failed");                                \
+      *success = 0;                                                 \
+    } else {                                                       \
+      *success = 1;                                                 \
+    }                                                              \
+  }
+
+#define get_gpu_vec_element(vec_ptr, index, result, success)       \
+  {                                                                \
+    cublasStatus_t stat =                                          \
+        cublasGetVector(1, sizeof(double), vec_ptr, 1, result, 1); \
+    if (stat != CUBLAS_STATUS_SUCCESS) {                           \
+      printf("data upload failed");                                \
+      *success = 0;                                                 \
+    } else {                                                       \
+      *success = 1;                                                 \
+    }                                                              \
+  }
+
+__global__ void element_primal_feas_kernel(cupdlp_float *z,
+                                           const cupdlp_float *ax,
+                                           const cupdlp_float *rhs,
+                                           const cupdlp_float *rowScale,
+                                           int ifScaled,
+                                           int nEqs, int nRows);
+
+__global__ void element_dual_feas_kernel_1(cupdlp_float *z,
+                                           const cupdlp_float *aty,
+                                           const cupdlp_float *cost,
+                                           int nCols);
+
+__global__ void element_dual_feas_kernel_2(cupdlp_float *z,
+                                           const cupdlp_float *dualResidual,
+                                           const cupdlp_float *hasLower,
+                                           int nCols);
+
+__global__ void element_dual_feas_kernel_3(cupdlp_float *z,
+                                           const cupdlp_float *dualResidual,
+                                           const cupdlp_float *hasUpper,
+                                           int nCols);
+
+__global__ void element_primal_infeas_kernel(cupdlp_float *z, const cupdlp_float *aty,
+                                             const cupdlp_float *dSlackPos,
+                                             const cupdlp_float *dSlackNeg,
+                                             const cupdlp_float *colScale,
+                                             cupdlp_float alpha, int ifScaled, int nCols);
+
+__global__ void element_dual_infeas_kernel_lb(cupdlp_float *z,
+                                              const cupdlp_float *x,
+                                              const cupdlp_float *hasLower,
+                                              const cupdlp_float *colScale,
+                                              cupdlp_float alpha, int ifScaled, int nCols);
+
+__global__ void element_dual_infeas_kernel_ub(cupdlp_float *z,
+                                              const cupdlp_float *x,
+                                              const cupdlp_float *hasUpper,
+                                              const cupdlp_float *colScale,
+                                              cupdlp_float alpha, int ifScaled, int nCols);
+
+__global__ void element_dual_infeas_kernel_constr(cupdlp_float *z,
+                                                  const cupdlp_float *ax,
+                                                  const cupdlp_float *rowScale,
+                                                  cupdlp_float alpha, int ifScaled,
+                                                  int nEqs, int nRows);
+
+__global__ void element_wise_dot_kernel(cupdlp_float *x, const cupdlp_float *y, int n);
+
+__global__ void element_wise_div_kernel(cupdlp_float *x, const cupdlp_float *y, int n);
+
+__global__ void element_wise_projlb_kernel(cupdlp_float *x,
+                                           const cupdlp_float *lb, int n);
+
+__global__ void element_wise_projub_kernel(cupdlp_float *x,
+                                           const cupdlp_float *ub, int n);
+
+__global__ void element_wise_projSamelb_kernel(cupdlp_float *x,
+                                               cupdlp_float lb, int n);
+
+__global__ void element_wise_projSameub_kernel(cupdlp_float *x,
+                                               cupdlp_float ub, int n);
+
+__global__ void element_wise_initHaslb_kernel(cupdlp_float *haslb,
+                                              const cupdlp_float *lb,
+                                              cupdlp_float bound, int n);
+
+__global__ void element_wise_initHasub_kernel(cupdlp_float *hasub,
+                                              const cupdlp_float *ub,
+                                              cupdlp_float bound, int n);
+
+__global__ void element_wise_filterlb_kernel(cupdlp_float *x,
+                                             const cupdlp_float *lb,
+                                             cupdlp_float bound, int n);
+
+__global__ void element_wise_filterub_kernel(cupdlp_float *x,
+                                             const cupdlp_float *ub,
+                                             cupdlp_float bound, int n);
+
+__global__ void init_cuda_vec_kernel(cupdlp_float *x, cupdlp_float val, int n);
+
+__global__ void primal_grad_step_kernel(cupdlp_float * __restrict__ xUpdate,
+                                        const cupdlp_float * __restrict__ x,
+                                        const cupdlp_float * __restrict__ cost,
+                                        const cupdlp_float * __restrict__ ATy,
+                                        const cupdlp_float * __restrict__ lb,
+                                        const cupdlp_float * __restrict__ ub,
+                                        cupdlp_float dPrimalStep, int nCols);
+
+__global__ void dual_grad_step_kernel(cupdlp_float * __restrict__ yUpdate,
+                                      const cupdlp_float * __restrict__ y,
+                                      const cupdlp_float * __restrict__ b,
+                                      const cupdlp_float * __restrict__ Ax,
+                                      const cupdlp_float * __restrict__ AxUpdate,
+                                      cupdlp_float dDualStep, int nRows, int nEqs);
+
+/*
+__global__ void naive_sub_kernel(cupdlp_float *z, const cupdlp_float *x,
+                                 const cupdlp_float *y, int n);
+*/
+
+
+__global__ void movement_1_kernel(cupdlp_float * __restrict__ res_x, cupdlp_float * __restrict__ res_y,
+                                  const cupdlp_float * __restrict__ xUpdate, const cupdlp_float * __restrict__ x,
+                                  const cupdlp_float * __restrict__ atyUpdate, const cupdlp_float * __restrict__ aty,
+                                  int nCols);
+
+__global__ void movement_2_kernel(cupdlp_float * __restrict__ res,
+                                  const cupdlp_float * __restrict__ yUpdate, const cupdlp_float * __restrict__ y,
+                                  int nRows);
+
+__global__ void sum_kernel(cupdlp_float * __restrict__ res, const cupdlp_float * __restrict__ x, int n);
+
+#endif