lpsolver 0.1.0 → 0.2.0

data/ext/lpsolver-highs/highs/model/HighsModel.h

@@ -0,0 +1,42 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+/*                                                                       */
+/*    This file is part of the HiGHS linear optimization suite           */
+/*                                                                       */
+/*    Available as open-source under the MIT License                     */
+/*                                                                       */
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+/**@file model/HighsModel.h
+ * @brief
+ */
+#ifndef MODEL_HIGHS_MODEL_H_
+#define MODEL_HIGHS_MODEL_H_
+
+#include <vector>
+
+#include "lp_data/HighsLp.h"
+#include "model/HighsHessian.h"
+
+class HighsModel;
+
+class HighsModel {
+ public:
+  HighsLp lp_;
+  HighsHessian hessian_;
+  bool operator==(const HighsModel& model) const;
+  bool equalButForNames(const HighsModel& model) const;
+  bool isQp() const { return (this->hessian_.dim_ != 0); }
+  bool isMip() const { return this->lp_.isMip(); }
+  bool isEmpty() const {
+    return (this->lp_.num_col_ == 0 && this->lp_.num_row_ == 0);
+  }
+  bool needsMods(const double infinite_cost) const {
+    return this->lp_.needsMods(infinite_cost);
+  }
+  bool hasMods() const { return this->lp_.hasMods(); }
+  void clear();
+  double objectiveValue(const std::vector<double>& solution) const;
+  void objectiveGradient(const std::vector<double>& solution,
+                         std::vector<double>& gradient) const;
+};
+
+#endif

data/ext/lpsolver-highs/highs/parallel/HighsBinarySemaphore.h

@@ -0,0 +1,108 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+/*                                                                       */
+/*    This file is part of the HiGHS linear optimization suite           */
+/*                                                                       */
+/*    Available as open-source under the MIT License                     */
+/*                                                                       */
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+
+#ifndef HIGHS_BINARY_SEMAPHORE_H_
+#define HIGHS_BINARY_SEMAPHORE_H_
+
+#include <atomic>
+#include <chrono>
+#include <condition_variable>
+#include <mutex>
+#include <thread>
+
+#include "parallel/HighsCacheAlign.h"
+#include "parallel/HighsSchedulerConstants.h"
+#include "parallel/HighsSpinMutex.h"
+
+class HighsBinarySemaphore {
+  struct Data {
+    std::atomic<int> count;
+    alignas(64) std::mutex mutex;
+    std::condition_variable condvar;
+
+    Data(int init) : count(init) {}
+  };
+
+  highs::cache_aligned::unique_ptr<Data> data_;
+
+ public:
+  HighsBinarySemaphore(bool init = false)
+      : data_(highs::cache_aligned::make_unique<Data>(init)) {}
+
+  void release() {
+    int prev = data_->count.exchange(1, std::memory_order_release);
+    if (prev < 0) {
+      std::unique_lock<std::mutex> lg{data_->mutex};
+      data_->condvar.notify_one();
+    }
+  }
+
+  bool try_acquire() {
+    int expected = 1;
+    return data_->count.compare_exchange_weak(
+        expected, 0, std::memory_order_acquire, std::memory_order_relaxed);
+  }
+
+  void acquire() {
+    if (try_acquire()) return;
+
+    auto tStart = std::chrono::high_resolution_clock::now();
+    int spinIters = 10;
+    while (true) {
+      for (int i = 0; i < spinIters; ++i) {
+        if (data_->count.load(std::memory_order_acquire) == 1) {
+          if (try_acquire()) return;
+        }
+        HighsSpinMutex::yieldProcessor();
+      }
+
+      auto numMicroSecs =
+          std::chrono::duration_cast<std::chrono::microseconds>(
+              std::chrono::high_resolution_clock::now() - tStart)
+              .count();
+
+      if (numMicroSecs < HighsSchedulerConstants::kMicroSecsBeforeSleep)
+        spinIters *= 2;
+      else
+        break;
+    }
+
+    std::unique_lock<std::mutex> lg{data_->mutex};
+    int prev = data_->count.exchange(-1, std::memory_order_relaxed);
+    if (prev == 1) {
+      data_->count.store(0, std::memory_order_relaxed);
+      return;
+    }
+
+    do {
+      data_->condvar.wait(lg);
+    } while (data_->count.load(std::memory_order_acquire) != 1);
+
+    data_->count.store(0, std::memory_order_relaxed);
+  }
+
+  std::unique_lock<std::mutex> lockMutexForAcquire() {
+    return std::unique_lock<std::mutex>{data_->mutex};
+  }
+
+  void acquire(std::unique_lock<std::mutex> lockGuard) {
+    int prev = data_->count.exchange(-1, std::memory_order_relaxed);
+    if (prev == 1) {
+      data_->count.store(0, std::memory_order_relaxed);
+      return;
+    }
+
+    do {
+      data_->condvar.wait(lockGuard);
+    } while (data_->count.load(std::memory_order_relaxed) != 1);
+
+    data_->count.store(0, std::memory_order_relaxed);
+  }
+};
+
+#endif

data/ext/lpsolver-highs/highs/parallel/HighsCacheAlign.h

@@ -0,0 +1,82 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+/*                                                                       */
+/*    This file is part of the HiGHS linear optimization suite           */
+/*                                                                       */
+/*    Available as open-source under the MIT License                     */
+/*                                                                       */
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+#ifndef HIGHS_CACHE_ALIGN_H_
+#define HIGHS_CACHE_ALIGN_H_
+
+#include <cstddef>
+#include <cstdint>
+#include <cstring>
+#include <memory>
+
+namespace highs {
+
+struct cache_aligned {
+  static constexpr std::size_t alignment() { return 64; }
+
+  static void* alloc(std::size_t size) {
+    using std::uintptr_t;
+
+    uintptr_t ptr =
+        reinterpret_cast<uintptr_t>(::operator new(size + alignment()));
+
+    char* aligned_ptr = reinterpret_cast<char*>((ptr | (alignment() - 1)) + 1);
+    std::memcpy(aligned_ptr - sizeof(uintptr_t), &ptr, sizeof(uintptr_t));
+    return reinterpret_cast<void*>(aligned_ptr);
+  }
+
+  static void free(void* aligned_ptr) {
+    using std::uintptr_t;
+
+    if (aligned_ptr) {
+      void* freeptr;
+      std::memcpy(&freeptr,
+                  reinterpret_cast<char*>(aligned_ptr) - sizeof(uintptr_t),
+                  sizeof(uintptr_t));
+      ::operator delete(freeptr);
+    }
+  }
+
+  template <typename T>
+  struct Deleter {
+    void operator()(T* ptr) const {
+      ptr->~T();
+      free(ptr);
+    }
+  };
+
+  template <typename T>
+  struct Deleter<T[]> {
+    void operator()(T* ptr) const { free(ptr); }
+  };
+
+  template <typename T>
+  using unique_ptr = std::unique_ptr<T, Deleter<T>>;
+
+  template <typename T>
+  using shared_ptr = std::shared_ptr<T>;
+
+  template <typename T, typename... Args>
+  static shared_ptr<T> make_shared(Args&&... args) {
+    return shared_ptr<T>(new (alloc(sizeof(T))) T(std::forward<Args>(args)...),
+                         Deleter<T>());
+  }
+
+  template <typename T, typename... Args>
+  static unique_ptr<T> make_unique(Args&&... args) {
+    return unique_ptr<T>(new (alloc(sizeof(T))) T(std::forward<Args>(args)...));
+  }
+
+  template <typename T, typename... Args>
+  static unique_ptr<T[]> make_unique_array(std::size_t N) {
+    return unique_ptr<T[]>(static_cast<T*>(alloc(sizeof(T) * N)));
+  }
+};
+
+}  // namespace highs
+
+#endif

data/ext/lpsolver-highs/highs/parallel/HighsCombinable.h

@@ -0,0 +1,116 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+/*                                                                       */
+/*    This file is part of the HiGHS linear optimization suite           */
+/*                                                                       */
+/*    Available as open-source under the MIT License                     */
+/*                                                                       */
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+
+#ifndef HIGHS_COMBINABLE_H_
+#define HIGHS_COMBINABLE_H_
+
+#include <functional>
+
+#include "parallel/HighsCacheAlign.h"
+#include "parallel/HighsTaskExecutor.h"
+
+template <typename T, typename FConstruct_ = std::function<T(void)>>
+class HighsCombinable {
+  FConstruct_ construct_;
+  struct PaddedData {
+    alignas(highs::cache_aligned::alignment()) bool initialized_;
+    T data_;
+  };
+  int numThreads;
+  highs::cache_aligned::unique_ptr<PaddedData[]> threadCopies_;
+
+ public:
+  HighsCombinable()
+      : construct_([]() { return T(); }),
+        numThreads(HighsTaskExecutor::getNumWorkerThreads()),
+        threadCopies_(
+            highs::cache_aligned::make_unique_array<PaddedData>(numThreads)) {
+    for (int i = 0; i < numThreads; ++i) threadCopies_[i].initialized_ = false;
+  }
+
+  template <typename FConstruct>
+  HighsCombinable(FConstruct&& fConstruct)
+      : construct_(std::forward<FConstruct>(fConstruct)),
+        numThreads(HighsTaskExecutor::getNumWorkerThreads()),
+        threadCopies_(
+            highs::cache_aligned::make_unique_array<PaddedData>(numThreads)) {
+    for (int i = 0; i < numThreads; ++i) threadCopies_[i].initialized_ = false;
+  }
+
+  HighsCombinable<T, FConstruct_>& operator=(
+      HighsCombinable<T, FConstruct_>&&) = default;
+  HighsCombinable(HighsCombinable<T, FConstruct_>&&) = default;
+
+  void clear() {
+    for (int i = 0; i < numThreads; ++i) {
+      if (threadCopies_[i].initialized_) {
+        threadCopies_[i].initialized_ = false;
+        threadCopies_[i].data_.~T();
+      }
+    }
+  }
+
+  T& local() {
+    int threadId = HighsTaskExecutor::getThisWorkerDeque()->getOwnerId();
+    if (!threadCopies_[threadId].initialized_) {
+      threadCopies_[threadId].initialized_ = true;
+      new (&threadCopies_[threadId].data_) T(construct_());
+    }
+
+    return threadCopies_[threadId].data_;
+  }
+
+  const T& local() const {
+    int threadId = HighsTaskExecutor::getThisWorkerDeque()->getOwnerId();
+    if (!threadCopies_[threadId].initialized_) {
+      threadCopies_[threadId].initialized_ = true;
+      new (&threadCopies_[threadId].data_) T(construct_());
+    }
+
+    return threadCopies_[threadId].data_;
+  }
+
+  template <typename FCombine>
+  void combine_each(FCombine&& combine) {
+    for (int i = 0; i < numThreads; ++i)
+      if (threadCopies_[i].initialized_) combine(threadCopies_[i].data_);
+  }
+
+  template <typename FCombine>
+  T combine(FCombine&& combine) {
+    T combined;
+    int i;
+    for (i = 0; i < numThreads; ++i) {
+      if (threadCopies_[i].initialized_) {
+        combined = std::move(threadCopies_[i].data_);
+        break;
+      }
+    }
+
+    for (++i; i < numThreads; ++i) {
+      if (threadCopies_[i].initialized_) {
+        combined =
+            combine(std::move(combined), std::move(threadCopies_[i].data_));
+        break;
+      }
+    }
+
+    return combined;
+  }
+
+  ~HighsCombinable() {
+    if (threadCopies_) clear();
+  }
+};
+
+template <typename U, typename FConstruct>
+HighsCombinable<U, FConstruct> makeHighsCombinable(FConstruct&& fconstruct) {
+  return HighsCombinable<U, FConstruct>(std::forward<FConstruct>(fconstruct));
+}
+
+#endif

data/ext/lpsolver-highs/highs/parallel/HighsMutex.h

@@ -0,0 +1,124 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+/*                                                                       */
+/*    This file is part of the HiGHS linear optimization suite           */
+/*                                                                       */
+/*    Available as open-source under the MIT License                     */
+/*                                                                       */
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+
+#ifndef HIGHS_MUTEX_H_
+#define HIGHS_MUTEX_H_
+
+#include "parallel/HighsSpinMutex.h"
+#include "parallel/HighsTaskExecutor.h"
+
+class HighsMutex {
+  std::atomic<unsigned int> state{0u};
+  enum Constants { kNumSpinTries = 10 };
+
+ public:
+  bool try_lock() {
+    unsigned int uncontendedState = 0;
+    return state.compare_exchange_weak(uncontendedState, 1,
+                                       std::memory_order_acquire,
+                                       std::memory_order_relaxed);
+  }
+
+  void lock() {
+    // First try to acquire the lock directly to have a fast path for
+    // uncontended access
+    if (try_lock()) return;
+
+    // Now spin a few times to check if the lock becomes available
+    for (int i = 0; i < kNumSpinTries; ++i) {
+      if (state.load(std::memory_order_relaxed) == 0) {
+        if (try_lock()) return;
+      }
+
+      HighsSpinMutex::yieldProcessor();
+    }
+
+    // Lock is still not available, so now start a loop where we yield
+    // to the scheduler after each time we observe the lock as unavailable
+    // so that we can see if there are other tasks and then check
+    // the lock again. We do so for some microseconds which we measure starting
+    // from now.
+    HighsSplitDeque* thisDeque = HighsTaskExecutor::getThisWorkerDeque();
+    auto tStart = std::chrono::high_resolution_clock::now();
+
+    while (true) {
+      int numTries = kNumSpinTries;
+
+      for (int i = 0; i < numTries; ++i) {
+        if (state.load(std::memory_order_relaxed) == 0) {
+          if (try_lock()) return;
+        }
+        thisDeque->yield();
+      }
+
+      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;
+    }
+
+    // The lock is still not available, now we will try to set ourselves as the
+    // next worker to acquire the lock and start wait until we are
+    // notified by the current worker holding the lock.
+    unsigned int ownerId = (thisDeque->getOwnerId() + 1) << 1;
+    unsigned int s = state.load(std::memory_order_relaxed);
+    while (true) {
+      // as long as we observe that the lock is available we try to lock it, so
+      // that we are guaranteed to have a locked state stored within s.
+      while (s == 0)
+        if (state.compare_exchange_weak(s, 1, std::memory_order_acquire,
+                                        std::memory_order_relaxed))
+          return;
+
+      if (s & 1u) {
+        if (state.compare_exchange_weak(s, ownerId | 1,
+                                        std::memory_order_release,
+                                        std::memory_order_relaxed))
+          break;
+      } else {
+        // if we observe that the semaphore is unlocked but has its state not
+        // equal to zero it means another worker has just been notified to take
+        // the lock, but not yet taken it. Before we can set ourselves as the
+        // next worker we need to wait for its state to be in locked state.
+        HighsSpinMutex::yieldProcessor();
+        s = state.load(std::memory_order_relaxed);
+      }
+    }
+
+    // once we are here we have successfully set ourselves as the next worker
+    // and once the previous worker released the lock we will be notified. Hence
+    // we wait until a notify and then are free to acquire the lock
+    // unconditionally.
+    thisDeque->wait();
+
+    // set the state to have its locked bit set and store the previous next
+    // worker as the new next worker. As we only get here when the compare
+    // exchange in the loop above succeeds with s having its locked bit set we
+    // can simply store back s.
+    state.store(s, std::memory_order_relaxed);
+  }
+
+  void unlock() {
+    unsigned int prevState = state.fetch_add(
+        std::numeric_limits<unsigned int>::max(), std::memory_order_release);
+
+    if (prevState != 1) {
+      unsigned int notifyWorkerId = (prevState >> 1) - 1;
+      HighsTaskExecutor::getThisWorkerDeque()
+          ->getWorkerById(notifyWorkerId)
+          ->notify();
+    }
+  }
+};
+
+#endif

data/ext/lpsolver-highs/highs/parallel/HighsParallel.h

@@ -0,0 +1,128 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+/*                                                                       */
+/*    This file is part of the HiGHS linear optimization suite           */
+/*                                                                       */
+/*    Available as open-source under the MIT License                     */
+/*                                                                       */
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+#ifndef HIGHS_PARALLEL_H_
+#define HIGHS_PARALLEL_H_
+
+#include "parallel/HighsMutex.h"
+#include "parallel/HighsTaskExecutor.h"
+
+namespace highs {
+
+namespace parallel {
+
+using mutex = HighsMutex;
+
+inline void initialize_scheduler(int numThreads = 0) {
+  if (numThreads == 0) {
+#ifdef HIGHS_NO_DEFAULT_THREADS
+    numThreads = 1;
+#else
+    numThreads = (std::thread::hardware_concurrency() + 1) / 2;
+#endif
+  }
+  HighsTaskExecutor::initialize(numThreads);
+}
+
+inline int num_threads() {
+  return HighsTaskExecutor::getThisWorkerDeque()->getNumWorkers();
+}
+
+inline int thread_num() {
+  return HighsTaskExecutor::getThisWorkerDeque()->getOwnerId();
+}
+
+template <typename F>
+void spawn(HighsSplitDeque* localDeque, F&& f) {
+  localDeque->push(std::forward<F>(f));
+}
+
+template <typename F>
+void spawn(F&& f) {
+  spawn(HighsTaskExecutor::getThisWorkerDeque(), std::forward<F>(f));
+}
+
+inline void sync(HighsSplitDeque* localDeque) {
+  std::pair<HighsSplitDeque::Status, HighsTask*> popResult = localDeque->pop();
+  switch (popResult.first) {
+    case HighsSplitDeque::Status::kEmpty:
+      assert(false);
+      // fall through
+    case HighsSplitDeque::Status::kOverflown:
+      // when the local deque is overflown the task has been executed during
+      // spawn already
+      break;
+    case HighsSplitDeque::Status::kStolen:
+      HighsTaskExecutor::sync_stolen_task(localDeque, popResult.second);
+      break;
+    case HighsSplitDeque::Status::kWork:
+      popResult.second->run();
+  }
+}
+
+inline void sync() { sync(HighsTaskExecutor::getThisWorkerDeque()); }
+class TaskGroup {
+  HighsSplitDeque* workerDeque;
+  int dequeHead;
+
+ public:
+  TaskGroup() {
+    workerDeque = HighsTaskExecutor::getThisWorkerDeque();
+    dequeHead = workerDeque->getCurrentHead();
+  }
+
+  template <typename F>
+  void spawn(F&& f) const {
+    highs::parallel::spawn(workerDeque, std::forward<F>(f));
+  }
+
+  void sync() const {
+    assert(workerDeque->getCurrentHead() > dequeHead);
+    highs::parallel::sync(workerDeque);
+  }
+
+  void taskWait() const {
+    while (workerDeque->getCurrentHead() > dequeHead)
+      highs::parallel::sync(workerDeque);
+  }
+
+  void cancel() {
+    for (int i = dequeHead; i < workerDeque->getCurrentHead(); ++i)
+      workerDeque->cancelTask(i);
+  }
+
+  ~TaskGroup() {
+    cancel();
+    taskWait();
+  }
+};
+
+template <typename F>
+void for_each(HighsInt start, HighsInt end, F&& f, HighsInt grainSize = 1) {
+  if (end - start <= grainSize) {
+    f(start, end);
+  } else {
+    TaskGroup tg;
+
+    do {
+      HighsInt split = (start + end) >> 1;
+      tg.spawn([split, end, grainSize, &f]() {
+        for_each(split, end, f, grainSize);
+      });
+      end = split;
+    } while (end - start > grainSize);
+
+    f(start, end);
+    tg.taskWait();
+  }
+}
+
+}  // namespace parallel
+
+}  // namespace highs
+
+#endif

data/ext/lpsolver-highs/highs/parallel/HighsRaceTimer.h

@@ -0,0 +1,38 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+/*                                                                       */
+/*    This file is part of the HiGHS linear optimization suite           */
+/*                                                                       */
+/*    Available as open-source under the MIT License                     */
+/*                                                                       */
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+
+#ifndef HIGHS_RACE_TIMER_H_
+#define HIGHS_RACE_TIMER_H_
+
+#include <atomic>
+#include <limits>
+
+template <typename T>
+class HighsRaceTimer {
+  std::atomic<T> limit;
+
+ public:
+  HighsRaceTimer() : limit(std::numeric_limits<T>::max()) {}
+
+  void decreaseLimit(T newLimit) {
+    T current = limit.load(std::memory_order_relaxed);
+
+    while (current > newLimit) {
+      if (limit.compare_exchange_weak(current, newLimit,
+                                      std::memory_order_relaxed,
+                                      std::memory_order_relaxed))
+        break;
+    }
+  }
+
+  bool limitReached(const T currentTime) const {
+    return currentTime > limit.load(std::memory_order_relaxed);
+  }
+};
+
+#endif

data/ext/lpsolver-highs/highs/parallel/HighsSchedulerConstants.h

@@ -0,0 +1,19 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+/*                                                                       */
+/*    This file is part of the HiGHS linear optimization suite           */
+/*                                                                       */
+/*    Available as open-source under the MIT License                     */
+/*                                                                       */
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+#ifndef HIGHS_SCHEDULER_CONSTANTS_H_
+#define HIGHS_SCHEDULER_CONSTANTS_H_
+
+struct HighsSchedulerConstants {
+  enum Constants {
+    kNumTryFac = 16,
+    kMicroSecsBeforeSleep = 5000,
+    kMicroSecsBeforeGlobalSync = 1000,
+  };
+};
+
+#endif