lpsolver 0.1.0 → 0.2.0

data/ext/lpsolver-highs/highs/ipm/hipo/factorhighs/Analyse.h

@@ -0,0 +1,122 @@
+#ifndef FACTORHIGHS_ANALYSE_H
+#define FACTORHIGHS_ANALYSE_H
+
+#include <algorithm>
+#include <vector>
+
+#include "DataCollector.h"
+#include "Symbolic.h"
+#include "ipm/hipo/auxiliary/IntConfig.h"
+#include "ipm/hipo/auxiliary/Log.h"
+
+namespace hipo {
+
+// Class to perform the analyse phase of the factorisation.
+// The final symbolic factorisation is stored in an object of type Symbolic.
+class Analyse {
+  bool ready_ = false;
+
+  // Matrix to be factorised, stored in upper and lower triangular format
+  std::vector<Int> rows_upper_{};
+  std::vector<Int> ptr_upper_{};
+  std::vector<Int> rows_lower_{};
+  std::vector<Int> ptr_lower_{};
+
+  // info about matrix and factor
+  Int n_{};
+  Int nz_{};
+  Int64 nz_factor_{};
+  double dense_ops_{};
+  double dense_ops_norelax_{};
+  double sparse_ops_{};
+  double critical_ops_{};
+  std::vector<Int> signs_{};
+
+  // Permutation and inverse permutation
+  std::vector<Int> perm_{};
+  std::vector<Int> iperm_{};
+
+  // Elimination tree
+  std::vector<Int> parent_{};
+
+  // postorder of the elimination tree
+  std::vector<Int> postorder_{};
+
+  // number of entries in each column of L
+  std::vector<Int> col_count_{};
+
+  // sparsity pattern of supernodes of L
+  std::vector<Int> rows_sn_{};
+  std::vector<Int64> ptr_sn_{};
+
+  std::vector<Int> sn_indices_{};
+
+  // fundamental supernodes information
+  Int sn_count_{};
+  Int64 artificial_nz_{};
+  std::vector<Int> sn_belong_{};
+  std::vector<Int> sn_start_{};
+  std::vector<Int> sn_parent_{};
+
+  // temporary storage for relaxing supernodes
+  std::vector<Int64> fake_nz_{};
+  std::vector<Int> merged_into_{};
+  Int merged_sn_{};
+
+  // relative indices of original columns wrt L columns
+  std::vector<Int> relind_cols_{};
+
+  // relative indices of clique wrt parent
+  std::vector<std::vector<Int>> relind_clique_{};
+
+  // information about consecutive indices in relindClique
+  std::vector<std::vector<Int>> consecutive_sums_{};
+
+  // estimate of maximum storage
+  double serial_storage_{};
+
+  Int64 max_stack_size_{};
+
+  std::vector<std::vector<Int64>> clique_block_start_{};
+
+  // block size
+  Int nb_{};
+
+  const Log* log_;
+  DataCollector& data_;
+
+  // Functions to perform analyse phase
+  void permute(const std::vector<Int>& iperm);
+  void eTree();
+  void postorder();
+  void colCount();
+  void fundamentalSupernodes();
+  void relaxSupernodes();
+  void relaxSnMaxNz(double& flops, double& spops);
+  double doRelaxSnMaxNz(double& flops, double& spops, Int64 max_artificial_nz);
+  void afterRelaxSn();
+  void relaxSnNetOps(double& flops, double& spops);
+  void snPattern();
+  void relativeIndCols();
+  void relativeIndClique();
+  void reorderChildren();
+  void computeStorage(Int fr, Int sz, Int64& fr_entries,
+                      Int64& cl_entries) const;
+  void computeCriticalPath();
+  void computeBlockStart();
+  void computeStackSize();
+  Int checkOverflow() const;
+
+ public:
+  // Constructor: matrix must be in lower triangular format
+  Analyse(const std::vector<Int>& rows, const std::vector<Int>& ptr,
+          const std::vector<Int>& signs, Int nb, const Log* log,
+          DataCollector& data, const std::vector<Int>& perm);
+
+  // Run analyse phase and save the result in Symbolic object S
+  Int run(Symbolic& S);
+};
+
+}  // namespace hipo
+
+#endif

data/ext/lpsolver-highs/highs/ipm/hipo/factorhighs/CallAndTimeBlas.cpp

@@ -0,0 +1,114 @@
+#include "CallAndTimeBlas.h"
+
+#include "DataCollector.h"
+#include "DenseFact.h"
+#include "FactorHiGHSSettings.h"
+#include "Timing.h"
+#include "ipm/hipo/auxiliary/Auxiliary.h"
+#include "ipm/hipo/auxiliary/mycblas.h"
+
+namespace hipo {
+
+// macros to interface with CBlas
+#define TRANS(x) (x) == 'N' ? CblasNoTrans : CblasTrans
+#define UPLO(x) (x) == 'U' ? CblasUpper : CblasLower
+#define DIAG(x) (x) == 'N' ? CblasNonUnit : CblasUnit
+#define SIDE(x) (x) == 'L' ? CblasLeft : CblasRight
+
+// level 1
+
+void callAndTime_daxpy(Int n, double da, const double* dx, Int incx, double* dy,
+                       Int incy, DataCollector& data) {
+  HIPO_CLOCK_CREATE;
+  cblas_daxpy(n, da, dx, incx, dy, incy);
+  HIPO_CLOCK_STOP(3, data, kTimeBlas_axpy);
+}
+
+void callAndTime_dcopy(Int n, const double* dx, Int incx, double* dy, Int incy,
+                       DataCollector& data) {
+  HIPO_CLOCK_CREATE;
+  cblas_dcopy(n, dx, incx, dy, incy);
+  HIPO_CLOCK_STOP(3, data, kTimeBlas_copy);
+}
+
+void callAndTime_dscal(Int n, const double da, double* dx, Int incx,
+                       DataCollector& data) {
+  HIPO_CLOCK_CREATE;
+  cblas_dscal(n, da, dx, incx);
+  HIPO_CLOCK_STOP(3, data, kTimeBlas_scal);
+}
+
+void callAndTime_dswap(Int n, double* dx, Int incx, double* dy, Int incy,
+                       DataCollector& data) {
+  HIPO_CLOCK_CREATE;
+  cblas_dswap(n, dx, incx, dy, incy);
+  HIPO_CLOCK_STOP(3, data, kTimeBlas_swap);
+}
+
+// level 2
+
+void callAndTime_dgemv(char trans, Int m, Int n, double alpha, const double* A,
+                       Int lda, const double* x, Int incx, double beta,
+                       double* y, Int incy, DataCollector& data) {
+  HIPO_CLOCK_CREATE;
+  cblas_dgemv(CblasColMajor, TRANS(trans), m, n, alpha, A, lda, x, incx, beta,
+              y, incy);
+  HIPO_CLOCK_STOP(3, data, kTimeBlas_gemv);
+}
+
+void callAndTime_dtpsv(char uplo, char trans, char diag, Int n,
+                       const double* ap, double* x, Int incx,
+                       DataCollector& data) {
+  HIPO_CLOCK_CREATE;
+  cblas_dtpsv(CblasColMajor, UPLO(uplo), TRANS(trans), DIAG(diag), n, ap, x,
+              incx);
+  HIPO_CLOCK_STOP(3, data, kTimeBlas_tpsv);
+}
+
+void callAndTime_dtrsv(char uplo, char trans, char diag, Int n, const double* A,
+                       Int lda, double* x, Int incx, DataCollector& data) {
+  HIPO_CLOCK_CREATE;
+  cblas_dtrsv(CblasColMajor, UPLO(uplo), TRANS(trans), DIAG(diag), n, A, lda, x,
+              incx);
+  HIPO_CLOCK_STOP(3, data, kTimeBlas_trsv);
+}
+
+void callAndTime_dger(Int m, Int n, double alpha, const double* x, Int incx,
+                      const double* y, Int incy, double* A, Int lda,
+                      DataCollector& data) {
+  HIPO_CLOCK_CREATE;
+  cblas_dger(CblasColMajor, m, n, alpha, x, incx, y, incy, A, lda);
+  HIPO_CLOCK_STOP(3, data, kTimeBlas_ger);
+}
+
+// level 3
+
+void callAndTime_dgemm(char transa, char transb, Int m, Int n, Int k,
+                       double alpha, const double* A, Int lda, const double* B,
+                       Int ldb, double beta, double* C, Int ldc,
+                       DataCollector& data) {
+  HIPO_CLOCK_CREATE;
+  cblas_dgemm(CblasColMajor, TRANS(transa), TRANS(transb), m, n, k, alpha, A,
+              lda, B, ldb, beta, C, ldc);
+  HIPO_CLOCK_STOP(3, data, kTimeBlas_gemm);
+}
+
+void callAndTime_dsyrk(char uplo, char trans, Int n, Int k, double alpha,
+                       const double* A, Int lda, double beta, double* C,
+                       Int ldc, DataCollector& data) {
+  HIPO_CLOCK_CREATE;
+  cblas_dsyrk(CblasColMajor, UPLO(uplo), TRANS(trans), n, k, alpha, A, lda,
+              beta, C, ldc);
+  HIPO_CLOCK_STOP(3, data, kTimeBlas_syrk);
+}
+
+void callAndTime_dtrsm(char side, char uplo, char trans, char diag, Int m,
+                       Int n, double alpha, const double* A, Int lda, double* B,
+                       Int ldb, DataCollector& data) {
+  HIPO_CLOCK_CREATE;
+  cblas_dtrsm(CblasColMajor, SIDE(side), UPLO(uplo), TRANS(trans), DIAG(diag),
+              m, n, alpha, A, lda, B, ldb);
+  HIPO_CLOCK_STOP(3, data, kTimeBlas_trsm);
+}
+
+}  // namespace hipo

data/ext/lpsolver-highs/highs/ipm/hipo/factorhighs/CallAndTimeBlas.h

@@ -0,0 +1,46 @@
+#ifndef FACTORHIGHS_CALL_AND_TIME_BLAS_H
+#define FACTORHIGHS_CALL_AND_TIME_BLAS_H
+
+#include "DataCollector.h"
+#include "ipm/hipo/auxiliary/IntConfig.h"
+
+namespace hipo {
+
+// level 1
+void callAndTime_daxpy(Int n, double da, const double* dx, Int incx, double* dy,
+                       Int incy, DataCollector& data);
+void callAndTime_dcopy(Int n, const double* dx, Int incx, double* dy, Int incy,
+                       DataCollector& data);
+void callAndTime_dscal(Int n, const double da, double* dx, Int incx,
+                       DataCollector& data);
+void callAndTime_dswap(Int n, double* dx, Int incx, double* dy, Int incy,
+                       DataCollector& data);
+
+// level 2
+void callAndTime_dgemv(char trans, Int m, Int n, double alpha, const double* A,
+                       Int lda, const double* x, Int incx, double beta,
+                       double* y, Int incy, DataCollector& data);
+void callAndTime_dtpsv(char uplo, char trans, char diag, Int n,
+                       const double* ap, double* x, Int incx,
+                       DataCollector& data);
+void callAndTime_dtrsv(char uplo, char trans, char diag, Int n, const double* A,
+                       Int lda, double* x, Int incx, DataCollector& data);
+void callAndTime_dger(Int m, Int n, double alpha, const double* x, Int incx,
+                      const double* y, Int incy, double* A, Int lda,
+                      DataCollector& data);
+
+// level 3
+void callAndTime_dgemm(char transa, char transb, Int m, Int n, Int k,
+                       double alpha, const double* A, Int lda, const double* B,
+                       Int ldb, double beta, double* C, Int ldc,
+                       DataCollector& data);
+void callAndTime_dsyrk(char uplo, char trans, Int n, Int k, double alpha,
+                       const double* a, Int lda, double beta, double* c,
+                       Int ldc, DataCollector& data);
+void callAndTime_dtrsm(char side, char uplo, char trans, char diag, Int m,
+                       Int n, double alpha, const double* a, Int lda, double* b,
+                       Int ldb, DataCollector& data);
+
+}  // namespace hipo
+
+#endif

data/ext/lpsolver-highs/highs/ipm/hipo/factorhighs/CliqueStack.cpp

@@ -0,0 +1,82 @@
+#include "CliqueStack.h"
+
+#include <cassert>
+#include <cstring>
+
+namespace hipo {
+
+void CliqueStack::init(Int64 stack_size) {
+  top_ = 0;
+  workspace_ = nullptr;
+  worksize_ = 0;
+  empty_ = false;
+
+  stack_.resize(stack_size, 0.0);
+}
+
+double* CliqueStack::setup(Int64 clique_size, bool& reallocation) {
+  // Clear workspace
+
+  assert(!workspace_ && !worksize_);
+  reallocation = false;
+
+  if (clique_size > 0) {
+    // This should not trigger reallocation, because the resize in init is done
+    // with the maximum possible size of the stack.
+    if (top_ + clique_size > static_cast<Int64>(stack_.size())) {
+      reallocation = true;
+      stack_.resize(top_ + clique_size, 0.0);
+    }
+
+    // accessing stack[top] is valid only if the clique is not empty,
+    // otherwise it may be out of bounds.
+    workspace_ = &stack_[top_];
+    worksize_ = clique_size;
+
+    // initialize workspace to zero
+    std::memset(workspace_, 0, worksize_ * sizeof(double));
+  }
+
+  return workspace_;
+}
+
+bool CliqueStack::empty() const { return empty_; }
+
+const double* CliqueStack::getChild(Int& child_sn) const {
+  // Get the top of the stack, in terms of supernode ID of the child and pointer
+  // to its data.
+
+  child_sn = sn_pushed_.top().first;
+  Int64 child_size = sn_pushed_.top().second;
+  const double* child = &stack_[top_ - child_size];
+
+  return child;
+}
+
+void CliqueStack::popChild() {
+  // Remove top child from the stack
+
+  Int64 child_size = sn_pushed_.top().second;
+  sn_pushed_.pop();
+
+  top_ -= child_size;
+}
+
+void CliqueStack::pushWork(Int sn) {
+  // Put the content of the workspace at the top of the stack
+
+  if (worksize_ > 0) {
+    // stack_[top_] has lower address than workspace, so no need to resize.
+    std::memmove(&stack_[top_], workspace_, worksize_ * sizeof(double));
+
+    top_ += worksize_;
+
+    // keep track of supernodes pushed
+    sn_pushed_.push({sn, worksize_});
+  }
+
+  worksize_ = 0;
+  workspace_ = nullptr;
+}
+
+}  // namespace hipo

data/ext/lpsolver-highs/highs/ipm/hipo/factorhighs/CliqueStack.h

@@ -0,0 +1,83 @@
+#ifndef FACTORHIGHS_CLIQUE_STACK_H
+#define FACTORHIGHS_CLIQUE_STACK_H
+
+#include <stack>
+#include <vector>
+
+#include "ipm/hipo/auxiliary/IntConfig.h"
+
+// Class to manage the stack of cliques when processing the elimination tree in
+// serial.
+//
+// The stack is used as follows:
+// - use init to initialize the stack, providing the max stack size. If the
+//   parameter is correct, there will be no reallocation of stack during its
+//   operation.
+// - use setup, with the size of the clique that is being computed, to
+//   initialize enough elements in the workspace. This also returns a pointer to
+//   write the new clique. The workspace is simply a chunk of space at the top
+//   of the stack where the new clique is being computed before being pushed in
+//   the right position.
+// - use getChild to obtain information about the child clique that is at the
+//   top of the stack. This also returns a pointer to read the data of the child
+//   clique.
+// - use popChild when the top child clique is no longer needed, to move on to
+//   the next one.
+// - use pushWork, with the ID of supernode that is being processed, when all
+//   children clique have been assembled, the dense factorization is completed,
+//   and the clique in the workspace is ready to be pushed onto the stack.
+
+namespace hipo {
+
+class CliqueStack {
+  std::vector<double> stack_;
+  double* workspace_;
+  Int64 worksize_;
+  bool empty_ = true;
+
+  // pairs (sn, size) of supernodes that got pushed
+  std::stack<std::pair<Int, Int64>> sn_pushed_{};
+
+  Int64 top_{};
+
+ public:
+  void init(Int64 size);
+  double* setup(Int64 clique_size, bool& reallocation);
+  const double* getChild(Int& child_sn) const;
+  void popChild();
+  void pushWork(Int sn);
+  bool empty() const;
+};
+
+}  // namespace hipo
+
+// Example: sn 7 has children 5,6 and the stack looks like this:
+//
+// | - - - | - - - - - - - | - | - - - - - - - ...
+// |   4   |       5       | 6 | t
+// | - - - | - - - - - - - | - | - - - - - - - ...
+//
+// where t points to the top of the stack.
+// The information about the supernodes pushed (in sn_pushed_) is:
+// (sn 4, size 7), (sn 5, size 15), (sn 6, size 3)
+//
+// The workspace starts at t and fits in the stack.
+// The clique of sn 7 is constructed in the workspace. After a child clique is
+// assembled, it is popped from the stack, by moving t back. After all children
+// are assembled and the dense factorization is done, the stack looks like this:
+//
+// | - - - | - - - - - - - - - | - - - - - - - - - - - | - - ...
+// |   4   | t      free       |           7           |
+// | - - - | - - - - - - - - - | - - - - - - - - - - - | - - ...
+//
+// The clique 7 can then be pushed onto the stack by copying it at position t.
+// At the end, the stack looks like this:
+//
+// | - - - | - - - - - - - - - - - | - - - - - ...
+// |   4   |           7           | t
+// | - - - | - - - - - - - - - - - | - - - - - ...
+//
+// The information in sn_pushed_ is:
+// (sn 4, size 7), (sn 7, size 23)
+
+#endif