casadi 3.6.7__cp39-none-macosx_11_0_arm64.whl → 3.7.0__cp39-none-macosx_11_0_arm64.whl

casadi/include/highs/parallel/HighsTaskExecutor.h

@@ -30,9 +30,11 @@ class HighsTaskExecutor {
  public:
   using cache_aligned = highs::cache_aligned;
   struct ExecutorHandle {
-    cache_aligned::shared_ptr<HighsTaskExecutor> ptr{nullptr};
+    HighsTaskExecutor* ptr{nullptr};
+    bool isMain{false};
 
-    ~ExecutorHandle();
+    void dispose();
+    ~ExecutorHandle() { dispose(); }
   };
 
  private:
@@ -52,12 +54,15 @@ class HighsTaskExecutor {
   }
 #endif
 
-  std::vector<cache_aligned::unique_ptr<HighsSplitDeque>> workerDeques;
+  std::atomic<int> referenceCount;
+  std::atomic<bool> hasStopped{false};
+
   cache_aligned::shared_ptr<HighsSplitDeque::WorkerBunk> workerBunk;
-  std::atomic<ExecutorHandle*> mainWorkerHandle;
+  std::vector<cache_aligned::unique_ptr<HighsSplitDeque>> workerDeques;
+  std::vector<std::thread> workerThreads;
 
   HighsTask* random_steal_loop(HighsSplitDeque* localDeque) {
-    const int numWorkers = workerDeques.size();
+    const int numWorkers = static_cast<int>(workerDeques.size());
 
     int numTries = 16 * (numWorkers - 1);
 
@@ -85,38 +90,32 @@ class HighsTaskExecutor {
     return nullptr;
   }
 
-  void run_worker(int workerId) {
-    // spin until the global executor pointer is set up
-    ExecutorHandle* executor;
-    // Following yields warning C4706: assignment within conditional
-    // expression when building libhighs on Windows (/W4):
-    //
-    //    while (!(executor = mainWorkerHandle.load(std::memory_order_acquire)))
-    //      HighsSpinMutex::yieldProcessor();
-    while (true) {
-      executor = mainWorkerHandle.load(std::memory_order_acquire);
-      if (executor != nullptr) break;
-      HighsSpinMutex::yieldProcessor();
-    }
-    // now acquire a reference count of the global executor
-    threadLocalExecutorHandle() = *executor;
-    HighsSplitDeque* localDeque = workerDeques[workerId].get();
-    threadLocalWorkerDeque() = localDeque;
-    HighsTask* currentTask = workerBunk->waitForNewTask(localDeque);
-    while (currentTask != nullptr) {
-      localDeque->runStolenTask(currentTask);
-
-      currentTask = random_steal_loop(localDeque);
-      if (currentTask != nullptr) continue;
-
-      currentTask = workerBunk->waitForNewTask(localDeque);
+  static void run_worker(int workerId, HighsTaskExecutor* ptr) {
+    auto& executorHandle = threadLocalExecutorHandle();
+    executorHandle.ptr = ptr;
+
+    if (!ptr->hasStopped) {
+      HighsSplitDeque* localDeque = ptr->workerDeques[workerId].get();
+      threadLocalWorkerDeque() = localDeque;
+
+      HighsTask* currentTask = ptr->workerBunk->waitForNewTask(localDeque);
+      while (currentTask != nullptr) {
+        localDeque->runStolenTask(currentTask);
+
+        currentTask = ptr->random_steal_loop(localDeque);
+        if (currentTask != nullptr) continue;
+
+        currentTask = ptr->workerBunk->waitForNewTask(localDeque);
+      }
     }
+
+    executorHandle.dispose();
   }
 
  public:
   HighsTaskExecutor(int numThreads) {
     assert(numThreads > 0);
-    mainWorkerHandle.store(nullptr, std::memory_order_relaxed);
+
     workerDeques.resize(numThreads);
     workerBunk = cache_aligned::make_shared<HighsSplitDeque::WorkerBunk>();
     for (int i = 0; i < numThreads; ++i)
@@ -124,8 +123,35 @@ class HighsTaskExecutor {
           workerBunk, workerDeques.data(), i, numThreads);
 
     threadLocalWorkerDeque() = workerDeques[0].get();
-    for (int i = 1; i < numThreads; ++i)
-      std::thread([&](int id) { run_worker(id); }, i).detach();
+    workerThreads.reserve(numThreads - 1);
+    referenceCount.store(numThreads);
+
+    for (int i = 1, numThreads = static_cast<int>(workerDeques.size());
+         i < numThreads; ++i) {
+      workerThreads.emplace_back(&HighsTaskExecutor::run_worker, i, this);
+    }
+  }
+
+  void stopWorkerThreads(bool blocking = false) {
+    // Check if stop has been called already.
+    auto& executorHandle = threadLocalExecutorHandle();
+    if (executorHandle.ptr == nullptr || hasStopped.exchange(true)) return;
+
+    // now inject the null task as termination signal to every worker
+    for (auto& workerDeque : workerDeques) {
+      workerDeque->injectTaskAndNotify(nullptr);
+    }
+
+    // only block if called on main thread, otherwise deadlock may occur
+    if (blocking && executorHandle.isMain) {
+      for (auto& workerThread : workerThreads) {
+        workerThread.join();
+      }
+    } else {
+      for (auto& workerThread : workerThreads) {
+        workerThread.detach();
+      }
+    }
   }
 
   static HighsSplitDeque* getThisWorkerDeque() {
@@ -138,34 +164,21 @@ class HighsTaskExecutor {
 
   static void initialize(int numThreads) {
     auto& executorHandle = threadLocalExecutorHandle();
-    if (!executorHandle.ptr) {
-      executorHandle.ptr =
-          cache_aligned::make_shared<HighsTaskExecutor>(numThreads);
-      executorHandle.ptr->mainWorkerHandle.store(&executorHandle,
-                                                 std::memory_order_release);
+    if (executorHandle.ptr == nullptr) {
+      executorHandle.isMain = true;
+      executorHandle.ptr = new (cache_aligned::alloc(sizeof(HighsTaskExecutor)))
+          HighsTaskExecutor(numThreads);
     }
   }
 
+  // can be called on main or worker threads
+  // blocking ignored unless called on main thread
   static void shutdown(bool blocking = false) {
     auto& executorHandle = threadLocalExecutorHandle();
-    if (executorHandle.ptr) {
-      // first spin until every worker has acquired its executor reference
-      while (executorHandle.ptr.use_count() !=
-             (long)executorHandle.ptr->workerDeques.size())
-        HighsSpinMutex::yieldProcessor();
-      // set the active flag to false first with release ordering
-      executorHandle.ptr->mainWorkerHandle.store(nullptr,
-                                                 std::memory_order_release);
-      // now inject the null task as termination signal to every worker
-      for (auto& workerDeque : executorHandle.ptr->workerDeques)
-        workerDeque->injectTaskAndNotify(nullptr);
-      // finally release the global executor reference
-      if (blocking) {
-        while (executorHandle.ptr.use_count() != 1)
-          HighsSpinMutex::yieldProcessor();
-      }
 
-      executorHandle.ptr.reset();
+    if (executorHandle.ptr != nullptr) {
+      executorHandle.ptr->stopWorkerThreads(blocking);
+      executorHandle.dispose();
     }
   }
 

casadi/include/highs/pdlp/CupdlpWrapper.h

@@ -2,9 +2,6 @@
 /*                                                                       */
 /*    This file is part of the HiGHS linear optimization suite           */
 /*                                                                       */
-/*    Written and engineered 2008-2024 by Julian Hall, Ivet Galabova,    */
-/*    Leona Gottwald and Michael Feldmeier                               */
-/*                                                                       */
 /*    Available as open-source under the MIT License                     */
 /*                                                                       */
 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
@@ -20,6 +17,19 @@
 #include "lp_data/HighsSolution.h"
 #include "pdlp/cupdlp/cupdlp.h"
 
+#ifdef CUPDLP_GPU
+#include <cuda_runtime.h>
+#endif
+
+// #define CUPDLP_CPP_INIT(var, type, size)                                \
+//   {                                                                     \
+//     (var) = (type *)malloc((size) * sizeof(type));                      \
+//     if ((var) == NULL) {                                                \
+//       retcode = 1;                                                      \
+//       goto exit_cleanup;                                                \
+//     }                                                                   \
+//   }
+
 typedef enum CONSTRAINT_TYPE { EQ = 0, LEQ, GEQ, BOUND } constraint_type;
 
 #define cupdlp_init_int(var, size) \
@@ -37,15 +47,16 @@ typedef enum CONSTRAINT_TYPE { EQ = 0, LEQ, GEQ, BOUND } constraint_type;
 #define cupdlp_init_data(var, size) \
   { (var) = (CUPDLPdata*)malloc((size) * sizeof(CUPDLPdata)); }
 
+#ifdef CUPDLP_CPU
+
 #define cupdlp_init_vec_double(var, size) \
   { (var) = (double*)malloc((size) * sizeof(double)); }
 
-#define cupdlp_init_zero_vec_double(var, size) \
-  { (var) = (double*)calloc(size, sizeof(double)); }
-
 #define cupdlp_copy_vec(dst, src, type, size) \
   memcpy(dst, src, sizeof(type) * (size))
 
+#endif
+
 //#define cupdlp_init_csc_cpu(var, size)	\
 //   {\
 //     (var) = (CUPDLPcsc*)malloc((size) * sizeof(CUPDLPcsc));\
@@ -86,7 +97,7 @@ int formulateLP_highs(const HighsLp& lp, double** cost, int* nCols, int* nRows,
                       double** csc_val, double** rhs, double** lower,
                       double** upper, double* offset, double* sign_origin,
                       int* nCols_origin, int** constraint_new_idx,
-                      int* constraint_type);
+                      int** constraint_type);
 
 cupdlp_int getCupdlpLogLevel(const HighsOptions& options);
 

casadi/include/highs/pdlp/cupdlp/cupdlp_cs.h

@@ -1,7 +1,7 @@
 #ifndef CUPDLP_CS_H
 #define CUPDLP_CS_H
 
-#include "cupdlp_defs.h"
+#include "pdlp/cupdlp/cupdlp_defs.h"
 
 /* sparse matrix in column-oriented form used in reading mps*/
 typedef struct cupdlp_cs_sparse {
@@ -20,7 +20,7 @@ double cupdlp_dcs_norm(const cupdlp_dcs *A);
 int cupdlp_dcs_print(const cupdlp_dcs *A, int brief);
 
 /* utilities */
-void *_dcs_calloc(int n, size_t size);
+void *cupdlp_dcs_calloc(int n, size_t size);
 void *cupdlp_dcs_free(void *p);
 void *cupdlp_dcs_realloc(void *p, int n, size_t size, int *ok);
 cupdlp_dcs *cupdlp_dcs_spalloc(int m, int n, int nzmax, int values, int t);
@@ -31,7 +31,6 @@ void *cupdlp_dcs_malloc(int n, size_t size);
 /* utilities */
 double cupdlp_dcs_cumsum(int *p, int *c, int n);
 cupdlp_dcs *cupdlp_dcs_done(cupdlp_dcs *C, void *w, void *x, int ok);
-int *cupdlp_dcs_idone(int *p, cupdlp_dcs *C, void *w, int ok);
 cupdlp_dcs *cupdlp_dcs_transpose(const cupdlp_dcs *A, int values);
 
 #define IS_CSC(A) (A && (A->nz == -1))

casadi/include/highs/pdlp/cupdlp/cupdlp_defs.h

@@ -1,14 +1,18 @@
 #ifndef CUPDLP_H_GUARD
 #define CUPDLP_H_GUARD
 
-#define CUPDLP_CPU
-#define CUPDLP_DEBUG (0)
+// The below already defined in CMake.
+// #define CUPDLP_CPU
+// #define CUPDLP_DEBUG (1)
 #define CUPDLP_TIMER
 
-#ifndef CUPDLP_CPU
+#include "HConfig.h"
+
+#ifdef CUPDLP_GPU
 #include "cuda/cupdlp_cuda_kernels.cuh"
 #include "cuda/cupdlp_cudalinalg.cuh"
 #endif
+
 #ifdef __cplusplus
 extern "C" {
 #endif
@@ -326,8 +330,12 @@ struct CUPDLP_ITERATES {
   cupdlp_float *xLastRestart;
   cupdlp_float *yLastRestart;
 
-  CUPDLPvec *x, *xUpdate, *xAverage, *y, *yUpdate, *yAverage, *ax, *axUpdate,
-      *axAverage, *aty, *atyUpdate, *atyAverage;
+  CUPDLPvec *x[2]; // in iteration k, x^k stored in x[k % 2], x^{k+1} created in x[k + 1 % 2]
+  CUPDLPvec *y[2];
+  CUPDLPvec *ax[2];
+  CUPDLPvec *aty[2];
+  CUPDLPvec *xAverage, *yAverage, *axAverage, *atyAverage;
+
 };
 
 struct CUPDLP_STEPSIZE {
@@ -411,7 +419,9 @@ struct CUPDLP_WORK {
 #ifndef CUPDLP_CPU
   // CUDAmv *MV;
   cusparseHandle_t cusparsehandle;
-  void *dBuffer;
+  void *dBuffer_csc_ATy;
+  void *dBuffer_csr_Ax;
+
   // cusparseDnVecDescr_t vecbuffer;
   cublasHandle_t cublashandle;
 #endif

casadi/include/highs/pdlp/cupdlp/cupdlp_linalg.h

@@ -3,6 +3,7 @@
 
 #include "cupdlp_defs.h"
 #include "cupdlp_utils.h"
+
 #ifndef CUPDLP_CPU
 #include "cuda/cupdlp_cudalinalg.cuh"
 #endif
@@ -162,11 +163,11 @@ void cupdlp_projPos(cupdlp_float *x, const cupdlp_int len);
 /* xout = min(x, 0) */
 void cupdlp_projNeg(cupdlp_float *x, const cupdlp_int len);
 
-void cupdlp_haslb(cupdlp_float *haslb, const cupdlp_float *lb,
-                  const cupdlp_float bound, const cupdlp_int len);
+// void cupdlp_haslb(cupdlp_float *haslb, const cupdlp_float *lb,
+//                   const cupdlp_float bound, const cupdlp_int len);
 
-void cupdlp_hasub(cupdlp_float *hasub, const cupdlp_float *ub,
-                  const cupdlp_float bound, const cupdlp_int len);
+// void cupdlp_hasub(cupdlp_float *hasub, const cupdlp_float *ub,
+//                   const cupdlp_float bound, const cupdlp_int len);
 
 void cupdlp_filterlb(cupdlp_float *x, const cupdlp_float *lb,
                      const cupdlp_float bound, const cupdlp_int len);
@@ -180,4 +181,9 @@ void cupdlp_initvec(cupdlp_float *x, const cupdlp_float val,
 void cupdlp_compute_interaction_and_movement(CUPDLPwork *w,
                                              cupdlp_float *dMovement,
                                              cupdlp_float *dIteraction);
+
+// WIP
+// double get_fabs_value(double* vec, int index);
+// double get_fabs_value(double* vec, int index, int N);
+
 #endif  // CUPDLP_CUPDLP_LINALG_H

casadi/include/highs/pdlp/cupdlp/cupdlp_proj.h

@@ -5,12 +5,12 @@
 #ifndef CUPDLP_CUPDLP_PROJ_H
 #define CUPDLP_CUPDLP_PROJ_H
 
-#include "cupdlp_defs.h"
-#include "glbopts.h"
+#include "pdlp/cupdlp/cupdlp_defs.h"
+#include "pdlp/cupdlp/glbopts.h"
 
 void PDHG_Project_Bounds(CUPDLPwork *work, double *r);
 
-void PDHG_Project_Row_Duals(CUPDLPwork *work, double *r);
+// void PDHG_Project_Row_Duals(CUPDLPwork *work, double *r);
 
 void PDHG_Restart_Iterate(CUPDLPwork *pdhg);
 

casadi/include/highs/pdlp/cupdlp/cupdlp_restart.h

@@ -5,13 +5,13 @@
 #ifndef CUPDLP_CUPDLP_RESTART_H
 #define CUPDLP_CUPDLP_RESTART_H
 
-#include "cupdlp_defs.h"
-#include "cupdlp_linalg.h"
-#include "cupdlp_proj.h"
+#include "pdlp/cupdlp/cupdlp_defs.h"
+#include "pdlp/cupdlp/cupdlp_linalg.h"
+#include "pdlp/cupdlp/cupdlp_proj.h"
 // #include "cupdlp_scaling.h"
-#include "cupdlp_step.h"
-#include "cupdlp_utils.h"
-#include "glbopts.h"
+#include "pdlp/cupdlp/cupdlp_step.h"
+#include "pdlp/cupdlp/cupdlp_utils.h"
+#include "pdlp/cupdlp/glbopts.h"
 
 typedef enum {
   PDHG_NO_RESTART = 0,

casadi/include/highs/pdlp/cupdlp/cupdlp_scaling.h

@@ -0,0 +1,26 @@
+//
+// Created by LJS on 23-11-30.
+//
+
+#ifndef CUPDLP_SCALING_H
+#define CUPDLP_SCALING_H
+
+#include "cupdlp_defs.h"
+#include "glbopts.h"
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+cupdlp_retcode PDHG_Scale_Data(cupdlp_int log_level, CUPDLPcsc* csc,
+                               cupdlp_int ifScaling, CUPDLPscaling* scaling,
+                               cupdlp_float* cost, cupdlp_float* lower,
+                               cupdlp_float* upper, cupdlp_float* rhs);
+
+cupdlp_retcode Init_Scaling(cupdlp_int log_level, CUPDLPscaling* scaling,
+                            cupdlp_int ncols, cupdlp_int nrows,
+                            cupdlp_float* cost, cupdlp_float* rhs);
+
+#ifdef __cplusplus
+}
+#endif
+#endif  // CUPDLP_CUPDLP_SCALING_H

casadi/include/highs/pdlp/cupdlp/cupdlp_solver.h

@@ -5,8 +5,8 @@
 #ifndef CUPDLP_CUPDLP_SOLVER_H
 #define CUPDLP_CUPDLP_SOLVER_H
 
-#include "cupdlp_defs.h"
-#include "glbopts.h"
+#include "pdlp/cupdlp/cupdlp_defs.h"
+#include "pdlp/cupdlp/glbopts.h"
 
 #ifdef __cplusplus
 extern "C" {
@@ -20,16 +20,16 @@ extern "C" {
     }                                                            \
   }
 
-void PDHG_Compute_Primal_Feasibility(CUPDLPwork *work, double *primalResidual,
-                                     const double *ax, const double *x,
-                                     double *dPrimalFeasibility,
-                                     double *dPrimalObj);
+void PDHG_Compute_Primal_Feasibility(CUPDLPwork *work, cupdlp_float *primalResidual,
+                                     const cupdlp_float *ax, const cupdlp_float *x,
+                                     cupdlp_float *dPrimalFeasibility,
+                                     cupdlp_float *dPrimalObj);
 
-void PDHG_Compute_Dual_Feasibility(CUPDLPwork *work, double *dualResidual,
-                                   const double *aty, const double *x,
-                                   const double *y, double *dDualFeasibility,
-                                   double *dDualObj, double *dComplementarity,
-                                   double *dSlackPos, double *dSlackNeg);
+void PDHG_Compute_Dual_Feasibility(CUPDLPwork *work, cupdlp_float *dualResidual,
+                                   const cupdlp_float *aty, const cupdlp_float *x,
+                                   const cupdlp_float *y, cupdlp_float *dDualFeasibility,
+                                   cupdlp_float *dDualObj, cupdlp_float *dComplementarity,
+                                   cupdlp_float *dSlackPos, cupdlp_float *dSlackNeg);
 
 void PDHG_Compute_Residuals(CUPDLPwork *work);
 

casadi/include/highs/pdlp/cupdlp/cupdlp_step.h

@@ -5,9 +5,9 @@
 #ifndef CUPDLP_CUPDLP_STEP_H
 #define CUPDLP_CUPDLP_STEP_H
 
-#include "cupdlp_defs.h"
+#include "pdlp/cupdlp/cupdlp_defs.h"
 // #include "cupdlp_scaling.h"
-#include "glbopts.h"
+#include "pdlp/cupdlp/glbopts.h"
 
 cupdlp_retcode PDHG_Power_Method(CUPDLPwork *work, double *lambda);
 
@@ -27,7 +27,11 @@ void PDHG_Update_Average(CUPDLPwork *work);
 
 cupdlp_retcode PDHG_Update_Iterate(CUPDLPwork *pdhg);
 
-void PDHG_primalGradientStep(CUPDLPwork *work, cupdlp_float dPrimalStepSize);
-void PDHG_dualGradientStep(CUPDLPwork *work, cupdlp_float dDualStepSize);
+void PDHG_primalGradientStep(CUPDLPwork *work, CUPDLPvec *xUpdate,
+                             const CUPDLPvec *x, const CUPDLPvec *ATy,
+                             cupdlp_float dPrimalStepSize);
+void PDHG_dualGradientStep(CUPDLPwork *work, CUPDLPvec *yUpdate,
+                           const CUPDLPvec *y, const CUPDLPvec *Ax,
+                           const CUPDLPvec *AxUpdate, cupdlp_float dDualStepSize);
 
 #endif  // CUPDLP_CUPDLP_STEP_H