lpsolver 0.1.0 → 0.2.0

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

@@ -0,0 +1,326 @@
+#include "DataCollector.h"
+
+#include "FactorHiGHSSettings.h"
+#include "ipm/hipo/auxiliary/Log.h"
+
+namespace hipo {
+
+// Functions to manage DataCollector
+
+DataCollector::DataCollector() {
+  times_.resize(kTimeSize);
+  blas_calls_.resize(kTimeBlasEnd - kTimeBlasStart + 1);
+}
+void DataCollector::append() {
+  // add an empty IterData object to the record
+  iter_data_record_.push_back(IterData());
+}
+IterData& DataCollector::back() {
+  // access most recent record of data
+  if (iter_data_record_.empty()) append();
+  return iter_data_record_.back();
+}
+
+//
+// Data-collecting functions
+//
+
+void DataCollector::sumTime(TimeItems i, double t) {
+#if HIPO_TIMING_LEVEL > 0
+  // Keep track of times and blas calls.
+  std::lock_guard<std::mutex> lock(mutex_);
+  times_[i] += t;
+#if HIPO_TIMING_LEVEL >= 3
+  if (i >= kTimeBlasStart && i <= kTimeBlasEnd)
+    ++blas_calls_[i - kTimeBlasStart];
+#endif
+#endif
+}
+void DataCollector::setExtremeEntries(double minD, double maxD, double minoffD,
+                                      double maxoffD) {
+#ifdef HIPO_COLLECT_EXPENSIVE_DATA
+  // Store max and min entries of D and L.
+  std::lock_guard<std::mutex> lock(mutex_);
+  back().minD = std::min(back().minD, minD);
+  back().maxD = std::max(back().maxD, maxD);
+  back().minL = std::min(back().minL, minoffD);
+  back().maxL = std::max(back().maxL, maxoffD);
+#endif
+}
+void DataCollector::countRegPiv() {
+#ifdef HIPO_COLLECT_EXPENSIVE_DATA
+  // Increase the number of dynamically regularised pivots.
+  std::lock_guard<std::mutex> lock(mutex_);
+  ++back().n_reg_piv;
+#endif
+}
+void DataCollector::countSwap() {
+#ifdef HIPO_COLLECT_EXPENSIVE_DATA
+  std::lock_guard<std::mutex> lock(mutex_);
+  ++back().n_swap;
+#endif
+}
+void DataCollector::count2x2() {
+#ifdef HIPO_COLLECT_EXPENSIVE_DATA
+  std::lock_guard<std::mutex> lock(mutex_);
+  ++back().n_2x2;
+#endif
+}
+void DataCollector::setWrongSign(double p) {
+#ifdef HIPO_COLLECT_EXPENSIVE_DATA
+  std::lock_guard<std::mutex> lock(mutex_);
+  ++back().n_wrong_sign;
+  back().max_wrong_sign = std::max(back().max_wrong_sign, std::abs(p));
+#endif
+}
+void DataCollector::setMaxReg(double new_reg) {
+#ifdef HIPO_COLLECT_EXPENSIVE_DATA
+  // Keep track of maximum regularisation used.
+  std::lock_guard<std::mutex> lock(mutex_);
+  back().max_reg = std::max(back().max_reg, new_reg);
+#endif
+}
+
+void DataCollector::setNorms(double norm1, double maxdiag) {
+#ifdef HIPO_COLLECT_EXPENSIVE_DATA
+  std::lock_guard<std::mutex> lock(mutex_);
+  back().M_norm1 = norm1;
+  back().M_maxdiag = maxdiag;
+#endif
+}
+
+//
+// Printing
+//
+
+void DataCollector::printTimes(const Log& log) const {
+#if HIPO_TIMING_LEVEL >= 1
+
+  std::stringstream log_stream;
+
+  log_stream << "----------------------------------------------------\n";
+  log_stream << "Analyse time            \t" << fix(times_[kTimeAnalyse], 8, 4)
+             << '\n';
+
+#if HIPO_TIMING_LEVEL >= 2
+
+  log_stream << "\tTree:                   "
+             << fix(times_[kTimeAnalyseTree], 8, 4) << " ("
+             << fix(times_[kTimeAnalyseTree] / times_[kTimeAnalyse] * 100, 4, 1)
+             << "%)\n";
+  log_stream << "\tCounts:                 "
+             << fix(times_[kTimeAnalyseCount], 8, 4) << " ("
+             << fix(times_[kTimeAnalyseCount] / times_[kTimeAnalyse] * 100, 4,
+                    1)
+             << "%)\n";
+  log_stream << "\tSupernodes:             "
+             << fix(times_[kTimeAnalyseSn], 8, 4) << " ("
+             << fix(times_[kTimeAnalyseSn] / times_[kTimeAnalyse] * 100, 4, 1)
+             << "%)\n";
+  log_stream << "\tReorder:                "
+             << fix(times_[kTimeAnalyseReorder], 8, 4) << " ("
+             << fix(times_[kTimeAnalyseReorder] / times_[kTimeAnalyse] * 100, 4,
+                    1)
+             << "%)\n";
+  log_stream << "\tSn sparsity pattern:    "
+             << fix(times_[kTimeAnalysePattern], 8, 4) << " ("
+             << fix(times_[kTimeAnalysePattern] / times_[kTimeAnalyse] * 100, 4,
+                    1)
+             << "%)\n";
+  log_stream << "\tRelative indices:       "
+             << fix(times_[kTimeAnalyseRelInd], 8, 4) << " ("
+             << fix(times_[kTimeAnalyseRelInd] / times_[kTimeAnalyse] * 100, 4,
+                    1)
+             << "%)\n";
+#endif
+
+  log_stream << "----------------------------------------------------\n";
+  log_stream << "Factorise time          \t"
+             << fix(times_[kTimeFactorise], 8, 4) << "\n";
+
+#if HIPO_TIMING_LEVEL >= 2
+  log_stream << "\tPrepare fact:           "
+             << fix(times_[kTimeFactorisePrepare], 8, 4) << " ("
+             << fix(times_[kTimeFactorisePrepare] / times_[kTimeFactorise] *
+                        100,
+                    4, 1)
+             << "%)\n";
+  log_stream << "\tAssemble original:      "
+             << fix(times_[kTimeFactoriseAssembleOriginal], 8, 4) << " ("
+             << fix(times_[kTimeFactoriseAssembleOriginal] /
+                        times_[kTimeFactorise] * 100,
+                    4, 1)
+             << "%)\n";
+  log_stream << "\tAssemble children in F: "
+             << fix(times_[kTimeFactoriseAssembleChildrenFrontal], 8, 4) << " ("
+             << fix(times_[kTimeFactoriseAssembleChildrenFrontal] /
+                        times_[kTimeFactorise] * 100,
+                    4, 1)
+             << "%)\n";
+  log_stream << "\tAssemble children in C: "
+             << fix(times_[kTimeFactoriseAssembleChildrenClique], 8, 4) << " ("
+             << fix(times_[kTimeFactoriseAssembleChildrenClique] /
+                        times_[kTimeFactorise] * 100,
+                    4, 1)
+             << "%)\n";
+  log_stream << "\tDense factorisation:    "
+             << fix(times_[kTimeFactoriseDenseFact], 8, 4) << " ("
+             << fix(times_[kTimeFactoriseDenseFact] / times_[kTimeFactorise] *
+                        100,
+                    4, 1)
+             << "%)\n";
+
+  log_stream << "\tTerminate:              "
+             << fix(times_[kTimeFactoriseTerminate], 8, 4) << " ("
+             << fix(times_[kTimeFactoriseTerminate] / times_[kTimeFactorise] *
+                        100,
+                    4, 1)
+             << "%)\n";
+
+  log_stream << "\t\tmain:           " << fix(times_[kTimeDenseFact_main], 8, 4)
+             << "\n";
+  log_stream << "\t\tSchur:          "
+             << fix(times_[kTimeDenseFact_schur], 8, 4) << "\n";
+  log_stream << "\t\tkernel:         "
+             << fix(times_[kTimeDenseFact_kernel], 8, 4) << "\n";
+  log_stream << "\t\tconvert:        "
+             << fix(times_[kTimeDenseFact_convert], 8, 4) << "\n";
+  log_stream << "\t\tpivoting:       "
+             << fix(times_[kTimeDenseFact_pivoting], 8, 4) << "\n";
+#endif
+
+  log_stream << "----------------------------------------------------\n";
+  log_stream << "Solve time              \t" << fix(times_[kTimeSolve], 8, 4)
+             << "\n";
+
+#if HIPO_TIMING_LEVEL >= 2
+  log_stream << "\tPrepare solve:          "
+             << fix(times_[kTimeSolvePrepare], 8, 4) << " ("
+             << fix(times_[kTimeSolvePrepare] / times_[kTimeSolve] * 100, 4, 1)
+             << "%)\n";
+  log_stream << "\tSolve:                  "
+             << fix(times_[kTimeSolveSolve], 8, 4) << " ("
+             << fix(times_[kTimeSolveSolve] / times_[kTimeSolve] * 100, 4, 1)
+             << "%)\n";
+  log_stream << "\t\tdense:          "
+             << fix(times_[kTimeSolveSolve_dense], 8, 4) << "\n";
+  log_stream << "\t\tsparse:         "
+             << fix(times_[kTimeSolveSolve_sparse], 8, 4) << "\n";
+  log_stream << "\t\tswap:           "
+             << fix(times_[kTimeSolveSolve_swap], 8, 4) << "\n";
+#endif
+  log_stream << "----------------------------------------------------\n";
+
+#if HIPO_TIMING_LEVEL >= 3
+
+  double total_blas_time =
+      times_[kTimeBlas_copy] + times_[kTimeBlas_axpy] + times_[kTimeBlas_scal] +
+      times_[kTimeBlas_swap] + times_[kTimeBlas_gemv] + times_[kTimeBlas_trsv] +
+      times_[kTimeBlas_tpsv] + times_[kTimeBlas_ger] + times_[kTimeBlas_trsm] +
+      times_[kTimeBlas_syrk] + times_[kTimeBlas_gemm];
+
+  log_stream << "BLAS time               \t" << fix(total_blas_time, 8, 4)
+             << '\n';
+  log_stream << "\tcopy:           \t" << fix(times_[kTimeBlas_copy], 8, 4)
+             << " ("
+             << fix(times_[kTimeBlas_copy] / total_blas_time * 100, 4, 1)
+             << "%) in "
+             << integer(blas_calls_[kTimeBlas_copy - kTimeBlasStart], 10)
+             << " calls\n";
+  log_stream << "\taxpy:           \t" << fix(times_[kTimeBlas_axpy], 8, 4)
+             << " ("
+             << fix(times_[kTimeBlas_axpy] / total_blas_time * 100, 4, 1)
+             << "%) in "
+             << integer(blas_calls_[kTimeBlas_axpy - kTimeBlasStart], 10)
+             << " calls\n";
+  log_stream << "\tscal:           \t" << fix(times_[kTimeBlas_scal], 8, 4)
+             << " ("
+             << fix(times_[kTimeBlas_scal] / total_blas_time * 100, 4, 1)
+             << "%) in "
+             << integer(blas_calls_[kTimeBlas_scal - kTimeBlasStart], 10)
+             << " calls\n";
+  log_stream << "\tswap:           \t" << fix(times_[kTimeBlas_swap], 8, 4)
+             << " ("
+             << fix(times_[kTimeBlas_swap] / total_blas_time * 100, 4, 1)
+             << "%) in "
+             << integer(blas_calls_[kTimeBlas_swap - kTimeBlasStart], 10)
+             << " calls\n";
+  log_stream << "\tgemv:           \t" << fix(times_[kTimeBlas_gemv], 8, 4)
+             << " ("
+             << fix(times_[kTimeBlas_gemv] / total_blas_time * 100, 4, 1)
+             << "%) in "
+             << integer(blas_calls_[kTimeBlas_gemv - kTimeBlasStart], 10)
+             << " calls\n";
+  log_stream << "\ttrsv:           \t" << fix(times_[kTimeBlas_trsv], 8, 4)
+             << " ("
+             << fix(times_[kTimeBlas_trsv] / total_blas_time * 100, 4, 1)
+             << "%) in "
+             << integer(blas_calls_[kTimeBlas_trsv - kTimeBlasStart], 10)
+             << " calls\n";
+  log_stream << "\ttpsv:           \t" << fix(times_[kTimeBlas_tpsv], 8, 4)
+             << " ("
+             << fix(times_[kTimeBlas_tpsv] / total_blas_time * 100, 4, 1)
+             << "%) in "
+             << integer(blas_calls_[kTimeBlas_tpsv - kTimeBlasStart], 10)
+             << " calls\n";
+  log_stream << "\tger:            \t" << fix(times_[kTimeBlas_ger], 8, 4)
+             << " (" << fix(times_[kTimeBlas_ger] / total_blas_time * 100, 4, 1)
+             << "%) in "
+             << integer(blas_calls_[kTimeBlas_ger - kTimeBlasStart], 10)
+             << " calls\n";
+  log_stream << "\ttrsm:           \t" << fix(times_[kTimeBlas_trsm], 8, 4)
+             << " ("
+             << fix(times_[kTimeBlas_trsm] / total_blas_time * 100, 4, 1)
+             << "%) in "
+             << integer(blas_calls_[kTimeBlas_trsm - kTimeBlasStart], 10)
+             << " calls\n";
+  log_stream << "\tsyrk:           \t" << fix(times_[kTimeBlas_syrk], 8, 4)
+             << " ("
+             << fix(times_[kTimeBlas_syrk] / total_blas_time * 100, 4, 1)
+             << "%) in "
+             << integer(blas_calls_[kTimeBlas_syrk - kTimeBlasStart], 10)
+             << " calls\n";
+  log_stream << "\tgemm:           \t" << fix(times_[kTimeBlas_gemm], 8, 4)
+             << " ("
+             << fix(times_[kTimeBlas_gemm] / total_blas_time * 100, 4, 1)
+             << "%) in "
+             << integer(blas_calls_[kTimeBlas_gemm - kTimeBlasStart], 10)
+             << " calls\n";
+  log_stream << "----------------------------------------------------\n";
+#endif
+
+  log.print(log_stream);
+#endif
+}
+
+void DataCollector::printIter(const Log& log) const {
+#ifdef HIPO_COLLECT_EXPENSIVE_DATA
+
+  std::stringstream log_stream;
+
+  log_stream << "\niter |   min D     max D     min L     max L  |"
+                "    reg   swap    2x2    ws | "
+                " max_reg   max_ws    norm1     maxdiag|\n";
+
+  for (Int i = 0; i < iter_data_record_.size(); ++i) {
+    const IterData& iter = iter_data_record_[i];
+
+    log_stream << integer(i, 3) << "  |";
+    log_stream << sci(iter.minD, 9, 1) << " ";
+    log_stream << sci(iter.maxD, 9, 1) << " ";
+    log_stream << sci(iter.minL, 9, 1) << " ";
+    log_stream << sci(iter.maxL, 9, 1) << " |";
+    log_stream << integer(iter.n_reg_piv, 6) << " ";
+    log_stream << integer(iter.n_swap, 6) << " ";
+    log_stream << integer(iter.n_2x2, 6) << " ";
+    log_stream << integer(iter.n_wrong_sign, 6) << " |";
+    log_stream << sci(iter.max_reg, 9, 1) << " ";
+    log_stream << sci(iter.max_wrong_sign, 9, 1) << " ";
+    log_stream << sci(iter.M_norm1, 9, 1) << " ";
+    log_stream << sci(iter.M_maxdiag, 9, 1) << "|\n";
+  }
+  log.print(log_stream);
+#endif
+}
+
+}  // namespace hipo

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

@@ -0,0 +1,86 @@
+#ifndef FACTORHIGHS_DATA_COLLECTOR_H
+#define FACTORHIGHS_DATA_COLLECTOR_H
+
+#include <atomic>
+#include <limits>
+#include <mutex>
+#include <vector>
+
+#include "FactorHiGHSSettings.h"
+#include "Timing.h"
+#include "ipm/hipo/auxiliary/IntConfig.h"
+#include "ipm/hipo/auxiliary/Log.h"
+
+namespace hipo {
+
+struct IterData {
+// data of one factorisation
+#ifdef HIPO_COLLECT_EXPENSIVE_DATA
+  double minD = kHighsInf;
+  double maxD = 0.0;
+  double minL = kHighsInf;
+  double maxL = 0.0;
+  double max_reg = 0.0;
+  Int n_reg_piv = 0;
+  Int n_swap = 0;
+  Int n_2x2 = 0;
+  Int n_wrong_sign = 0;
+  double max_wrong_sign = 0.0;
+  double M_norm1;
+  double M_maxdiag;
+#endif
+};
+
+// DataCollector is used to collect debug data during the factorisations.
+//
+// Expensive data related to the factorisation is only collected if
+// HIPO_COLLECT_EXPENSIVE_DATA is defined.
+//
+// HIPO_COLLECT_EXPENSIVE_DATA is selected at compile time, because some data is
+// collected many times, during many steps of the factorisation, using locks; if
+// HIPO_COLLECT_EXPENSIVE_DATA is off at compile time, then there is no
+// performance hit, since the functions are empty and are completely ignored by
+// the compiler.
+//
+// Times are only collected if HIPO_TIMING_LEVEL is defined at compile time, for
+// the same reason.
+//
+// All functions that collect data have a mutex, so that concurrent data
+// collection is possible. However, data collection should be used only for
+// debugging.
+//
+
+class DataCollector {
+  // Record of times and BLAS calls
+  std::vector<double> times_{};
+  std::vector<Int> blas_calls_{};
+
+  // record of data of ipm iterations
+  std::vector<IterData> iter_data_record_{};
+
+  // Mutex for concurrent access
+  std::mutex mutex_;
+
+ public:
+  DataCollector();
+
+  IterData& back();
+  void append();
+
+  void sumTime(TimeItems i, double t);
+  void countRegPiv();
+  void countSwap();
+  void count2x2();
+  void setWrongSign(double p);
+  void setMaxReg(double new_reg);
+  void setExtremeEntries(double minD, double maxD, double minoffD,
+                         double maxoffD);
+  void setNorms(double norm1, double maxdiag);
+
+  void printTimes(const Log& log) const;
+  void printIter(const Log& log) const;
+};
+
+}  // namespace hipo
+
+#endif

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

@@ -0,0 +1,48 @@
+#ifndef FACTORHIGHS_DENSE_FACT_H
+#define FACTORHIGHS_DENSE_FACT_H
+
+#include "DataCollector.h"
+#include "FactorHiGHSSettings.h"
+#include "ipm/hipo/auxiliary/IntConfig.h"
+
+namespace hipo {
+
+/*
+  Names:
+  denseFact:
+  - K : factorisation kernel for diagonal blocks
+  - F : blocked factorisation in full format
+  - FP: blocked factorisation in format FP
+  - FH : blocked factorisation in "hybrid formats"
+
+  Formats used:
+  - F : Full format
+  - P : lower Packed format
+  - FP: lower Packed format with Full diagonal blocks
+  - H : lower-blocked-Hybrid format
+  - FH: lower-blocked-Hybrid format with Full diagonal blocks
+
+  F, P do not use blocks. FP, H, FH use blocks.
+  Blocks are always blocks of columns.
+  F, P store by columns.
+  FP stores by columns within the blocks. H, FH store by rows within the blocks.
+  See report for more details.
+*/
+
+// dense factorisation kernel
+Int denseFactK(char uplo, Int n, double* A, Int lda, Int* pivot_sign,
+               double thresh, const Regul& regul, double* totalreg, Int* swaps,
+               double* pivot_2x2, DataCollector& data);
+
+// dense partial factorisation, in "hybrid formats"
+Int denseFactFH(char format, Int n, Int k, Int nb, double* A, double* B,
+                const Int* pivot_sign, double thresh, const Regul& regul,
+                double* totalreg, Int* swaps, double* pivot_2x2, bool parnode,
+                DataCollector& data);
+
+// function to convert A from lower packed, to lower-blocked-hybrid format
+Int denseFactFP2FH(double* A, Int nrow, Int ncol, Int nb, DataCollector& data);
+
+}  // namespace hipo
+
+#endif