casadi 3.6.7__cp313-none-macosx_10_13_x86_64.macosx_10_13_intel.whl

casadi/include/highs/parallel/HighsTask.h

@@ -0,0 +1,175 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+/*                                                                       */
+/*    This file is part of the HiGHS linear optimization suite           */
+/*                                                                       */
+/*    Written and engineered 2008-2021 at the University of Edinburgh    */
+/*                                                                       */
+/*    Available as open-source under the MIT License                     */
+/*                                                                       */
+/*    Authors: Julian Hall, Ivet Galabova, Qi Huangfu, Leona Gottwald    */
+/*    and Michael Feldmeier                                              */
+/*                                                                       */
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+#ifndef HIGHS_TASK_H_
+#define HIGHS_TASK_H_
+
+#include <atomic>
+#include <cassert>
+#include <cstring>
+#include <type_traits>
+
+#include "parallel/HighsSpinMutex.h"
+
+class HighsSplitDeque;
+
+class HighsTask {
+  friend class HighsSplitDeque;
+
+ public:
+  enum Constants {
+    kMaxTaskSize = 64,
+  };
+
+  class Interrupt {};
+
+ private:
+  static constexpr uint64_t kFinishedFlag = 1;
+  static constexpr uint64_t kCancelFlag = 2;
+  static constexpr uint64_t kPtrMask = ~(kFinishedFlag | kCancelFlag);
+  struct Metadata {
+    std::atomic<uintptr_t> stealer;
+  };
+
+  class CallableBase {
+   public:
+    virtual void operator()() = 0;
+  };
+
+  template <typename F>
+  class Callable : public CallableBase {
+    F functor;
+
+   public:
+    Callable(F&& functor) : functor(std::forward<F>(functor)) {}
+
+    virtual void operator()() override {
+      F callFunctor = std::move(functor);
+      callFunctor();
+    }
+  };
+
+  char taskData[kMaxTaskSize - sizeof(Metadata)];
+  Metadata metadata;
+
+  CallableBase& getCallable() {
+    union {
+      CallableBase* callablePtr;
+      char* storagePtr;
+    } u;
+
+    u.storagePtr = this->taskData;
+    return *u.callablePtr;
+  }
+
+  HighsSplitDeque* markAsFinished(HighsSplitDeque* stealer) {
+    uintptr_t state =
+        metadata.stealer.exchange(kFinishedFlag, std::memory_order_release);
+    HighsSplitDeque* waitingOwner =
+        reinterpret_cast<HighsSplitDeque*>(state & kPtrMask);
+    if (waitingOwner != stealer) return waitingOwner;
+
+    return nullptr;
+  }
+
+  /// run task as stealer and return the owner's split deque if the owner is
+  /// waiting and needs to be signaled
+  HighsSplitDeque* run(HighsSplitDeque* stealer) {
+    uintptr_t state = metadata.stealer.fetch_or(
+        reinterpret_cast<uintptr_t>(stealer), std::memory_order_acquire);
+    if (state == 0) getCallable()();
+
+    return markAsFinished(stealer);
+  }
+
+ public:
+  /// initialize the task with given callable type. Task is considered
+  /// unfinished after setTaskData
+  template <typename F>
+  void setTaskData(F&& f) {
+    static_assert(sizeof(F) <= sizeof(taskData),
+                  "given task type exceeds maximum size allowed for deque\n");
+    static_assert(std::is_trivially_destructible<F>::value,
+                  "given task type must be trivially destructible\n");
+    metadata.stealer.store(0, std::memory_order_relaxed);
+
+    new (taskData) Callable<F>(std::forward<F>(f));
+
+    assert(static_cast<CallableBase*>(reinterpret_cast<Callable<F>*>(
+               taskData)) == reinterpret_cast<CallableBase*>(taskData));
+  }
+
+  void cancel() {
+    metadata.stealer.fetch_or(kCancelFlag, std::memory_order_release);
+  }
+
+  /// run task as owner, if not cancelled
+  void run() {
+    if (metadata.stealer.load(std::memory_order_relaxed) == 0) getCallable()();
+  }
+
+  /// request notification of the owner when the task is finished.
+  /// Should be called while the owner holds its wait mutex
+  /// and only after getStealerIfUnfinished() has been called.
+  /// Returns true if the notification was set and false if it was not set
+  /// because the task was finished in the meantime.
+  bool requestNotifyWhenFinished(HighsSplitDeque* owner,
+                                 HighsSplitDeque* stealer) {
+    uintptr_t xormask = reinterpret_cast<uintptr_t>(owner) ^
+                        reinterpret_cast<uintptr_t>(stealer);
+    uintptr_t state =
+        metadata.stealer.fetch_xor(xormask, std::memory_order_relaxed);
+
+    assert(stealer != nullptr);
+
+    return (state & kFinishedFlag) == 0;
+  }
+
+  /// check if task is finished
+  bool isFinished() const {
+    uintptr_t state = metadata.stealer.load(std::memory_order_acquire);
+    return state & kFinishedFlag;
+  }
+
+  /// check if task is cancelled
+  bool isCancelled() const {
+    uintptr_t state = metadata.stealer.load(std::memory_order_relaxed);
+    return state & kCancelFlag;
+  }
+
+  /// get the stealer of a stolen task, or nullptr if the stealer finished
+  /// executing the task. Spin waits for the stealer to have started executing
+  /// the task if necessary.
+  HighsSplitDeque* getStealerIfUnfinished(bool* cancelled = nullptr) {
+    uintptr_t state = metadata.stealer.load(std::memory_order_acquire);
+    if (state & kFinishedFlag)
+      return nullptr;
+    else {
+      while ((state & ~kCancelFlag) == 0) {
+        // the task has been stolen, but the stealer has not yet started
+        // executing the task in this case, yield and check again in a spin
+        // loop until the stealer executes the task and becomes visible to
+        // this thread
+        HighsSpinMutex::yieldProcessor();
+        state = metadata.stealer.load(std::memory_order_acquire);
+      }
+    }
+
+    if (state & kFinishedFlag) return nullptr;
+
+    if (cancelled) *cancelled = state & kCancelFlag;
+
+    return reinterpret_cast<HighsSplitDeque*>(state & kPtrMask);
+  }
+};
+
+#endif

casadi/include/highs/parallel/HighsTaskExecutor.h

@@ -0,0 +1,209 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+/*                                                                       */
+/*    This file is part of the HiGHS linear optimization suite           */
+/*                                                                       */
+/*    Written and engineered 2008-2021 at the University of Edinburgh    */
+/*                                                                       */
+/*    Available as open-source under the MIT License                     */
+/*                                                                       */
+/*    Authors: Julian Hall, Ivet Galabova, Qi Huangfu, Leona Gottwald    */
+/*    and Michael Feldmeier                                              */
+/*                                                                       */
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+#ifndef HIGHS_TASKEXECUTOR_H_
+#define HIGHS_TASKEXECUTOR_H_
+
+#include <cassert>
+#include <chrono>
+#include <condition_variable>
+#include <memory>
+#include <thread>
+#include <vector>
+
+#include "parallel/HighsCacheAlign.h"
+#include "parallel/HighsSchedulerConstants.h"
+#include "parallel/HighsSplitDeque.h"
+#include "util/HighsInt.h"
+#include "util/HighsRandom.h"
+
+class HighsTaskExecutor {
+ public:
+  using cache_aligned = highs::cache_aligned;
+  struct ExecutorHandle {
+    cache_aligned::shared_ptr<HighsTaskExecutor> ptr{nullptr};
+
+    ~ExecutorHandle();
+  };
+
+ private:
+#ifdef _WIN32
+  static HighsSplitDeque*& threadLocalWorkerDeque();
+  static ExecutorHandle& threadLocalExecutorHandle();
+#else
+  static thread_local HighsSplitDeque* threadLocalWorkerDequePtr;
+  static thread_local ExecutorHandle globalExecutorHandle;
+
+  static HighsSplitDeque*& threadLocalWorkerDeque() {
+    return threadLocalWorkerDequePtr;
+  }
+
+  static ExecutorHandle& threadLocalExecutorHandle() {
+    return globalExecutorHandle;
+  }
+#endif
+
+  std::vector<cache_aligned::unique_ptr<HighsSplitDeque>> workerDeques;
+  cache_aligned::shared_ptr<HighsSplitDeque::WorkerBunk> workerBunk;
+  std::atomic<ExecutorHandle*> mainWorkerHandle;
+
+  HighsTask* random_steal_loop(HighsSplitDeque* localDeque) {
+    const int numWorkers = workerDeques.size();
+
+    int numTries = 16 * (numWorkers - 1);
+
+    auto tStart = std::chrono::high_resolution_clock::now();
+
+    while (true) {
+      for (int s = 0; s < numTries; ++s) {
+        HighsTask* task = localDeque->randomSteal();
+        if (task) return task;
+      }
+
+      if (!workerBunk->haveJobs.load(std::memory_order_relaxed)) break;
+
+      auto numMicroSecs =
+          std::chrono::duration_cast<std::chrono::microseconds>(
+              std::chrono::high_resolution_clock::now() - tStart)
+              .count();
+
+      if (numMicroSecs < HighsSchedulerConstants::kMicroSecsBeforeGlobalSync)
+        numTries *= 2;
+      else
+        break;
+    }
+
+    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);
+    }
+  }
+
+ 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)
+      workerDeques[i] = cache_aligned::make_unique<HighsSplitDeque>(
+          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();
+  }
+
+  static HighsSplitDeque* getThisWorkerDeque() {
+    return threadLocalWorkerDeque();
+  }
+
+  static int getNumWorkerThreads() {
+    return threadLocalWorkerDeque()->getNumWorkers();
+  }
+
+  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);
+    }
+  }
+
+  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();
+    }
+  }
+
+  static void sync_stolen_task(HighsSplitDeque* localDeque,
+                               HighsTask* stolenTask) {
+    HighsSplitDeque* stealer;
+    if (!localDeque->leapfrogStolenTask(stolenTask, stealer)) {
+      const int numWorkers = localDeque->getNumWorkers();
+      int numTries = HighsSchedulerConstants::kNumTryFac * (numWorkers - 1);
+
+      auto tStart = std::chrono::high_resolution_clock::now();
+
+      while (true) {
+        for (int s = 0; s < numTries; ++s) {
+          if (stolenTask->isFinished()) {
+            localDeque->popStolen();
+            return;
+          }
+          localDeque->yield();
+        }
+
+        auto numMicroSecs =
+            std::chrono::duration_cast<std::chrono::microseconds>(
+                std::chrono::high_resolution_clock::now() - tStart)
+                .count();
+
+        if (numMicroSecs < HighsSchedulerConstants::kMicroSecsBeforeSleep)
+          numTries *= 2;
+        else
+          break;
+      }
+
+      if (!stolenTask->isFinished())
+        localDeque->waitForTaskToFinish(stolenTask, stealer);
+    }
+
+    localDeque->popStolen();
+  }
+};
+
+#endif

casadi/include/highs/pdlp/CupdlpWrapper.h

@@ -0,0 +1,93 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+/*                                                                       */
+/*    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                     */
+/*                                                                       */
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+/**@file pdlp/CupdlpWrapper.h
+ * @brief
+ */
+#ifndef PDLP_CUPDLP_WRAPPER_H_
+#define PDLP_CUPDLP_WRAPPER_H_
+
+#include <algorithm>
+#include <cassert>
+
+#include "lp_data/HighsSolution.h"
+#include "pdlp/cupdlp/cupdlp.h"
+
+typedef enum CONSTRAINT_TYPE { EQ = 0, LEQ, GEQ, BOUND } constraint_type;
+
+#define cupdlp_init_int(var, size) \
+  { (var) = (int*)malloc((size) * sizeof(int)); }
+
+#define cupdlp_init_double(var, size) \
+  { (var) = (double*)malloc((size) * sizeof(double)); }
+
+#define cupdlp_init_work(var, size) \
+  { (var) = (CUPDLPwork*)malloc((size) * sizeof(CUPDLPwork)); }
+
+#define cupdlp_init_problem(var, size) \
+  { (var) = (CUPDLPproblem*)malloc((size) * sizeof(CUPDLPproblem)); }
+
+#define cupdlp_init_data(var, size) \
+  { (var) = (CUPDLPdata*)malloc((size) * sizeof(CUPDLPdata)); }
+
+#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))
+
+//#define cupdlp_init_csc_cpu(var, size)	\
+//   {\
+//     (var) = (CUPDLPcsc*)malloc((size) * sizeof(CUPDLPcsc));\
+//   }
+
+cupdlp_retcode problem_create(CUPDLPproblem** prob);
+// cupdlp_retcode csc_create(CUPDLPcsc **csc_cpu);
+
+cupdlp_retcode problem_alloc(
+    CUPDLPproblem* prob, cupdlp_int nRows, cupdlp_int nCols, cupdlp_int nEqs,
+    cupdlp_float* cost, cupdlp_float offset, cupdlp_float sign_origin,
+    void* matrix, CUPDLP_MATRIX_FORMAT src_matrix_format,
+    CUPDLP_MATRIX_FORMAT dst_matrix_format, cupdlp_float* rhs,
+    cupdlp_float* lower, cupdlp_float* upper, cupdlp_float* alloc_matrix_time,
+    cupdlp_float* copy_vec_time);
+
+cupdlp_retcode data_alloc(CUPDLPdata* data, cupdlp_int nRows, cupdlp_int nCols,
+                          void* matrix, CUPDLP_MATRIX_FORMAT src_matrix_format,
+                          CUPDLP_MATRIX_FORMAT dst_matrix_format);
+
+double infNorm(double* x, cupdlp_int n);
+
+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);
+
+HighsStatus solveLpCupdlp(HighsLpSolverObject& solver_object);
+
+HighsStatus solveLpCupdlp(const HighsOptions& options, HighsTimer& timer,
+                          const HighsLp& lp, HighsBasis& highs_basis,
+                          HighsSolution& highs_solution,
+                          HighsModelStatus& model_status, HighsInfo& highs_info,
+                          HighsCallback& callback);
+int formulateLP_highs(const HighsLp& lp, double** cost, int* nCols, int* nRows,
+                      int* nnz, int* nEqs, int** csc_beg, int** csc_idx,
+                      double** csc_val, double** rhs, double** lower,
+                      double** upper, double* offset, double* sign_origin,
+                      int* nCols_origin, int** constraint_new_idx,
+                      int* constraint_type);
+
+cupdlp_int getCupdlpLogLevel(const HighsOptions& options);
+
+#endif

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

@@ -0,0 +1,41 @@
+#ifndef CUPDLP_CS_H
+#define CUPDLP_CS_H
+
+#include "cupdlp_defs.h"
+
+/* sparse matrix in column-oriented form used in reading mps*/
+typedef struct cupdlp_cs_sparse {
+  int nzmax;
+  int m;     /* number of rows */
+  int n;     /* number of columns */
+  int *p;    /* column pointers (size n+1) or col indices (size nzmax) */
+  int *i;    /* row indices, size nzmax */
+  double *x; /* numerical values, size nzmax */
+  int nz;    /* # of entries in triplet matrix, -1 for compressed-col */
+} cupdlp_dcs;
+
+int cupdlp_dcs_entry(cupdlp_dcs *T, int i, int j, double x);
+cupdlp_dcs *cupdlp_dcs_compress(const cupdlp_dcs *T);
+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_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);
+cupdlp_dcs *cupdlp_dcs_spfree(cupdlp_dcs *A);
+int cupdlp_dcs_sprealloc(cupdlp_dcs *A, int nzmax);
+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))
+#define IS_TRIPLET(A) (A && (A->nz >= 0))
+/*--------------------------------------------------------------------------*/
+
+#endif