back to extra space

Author: filikat

highs/ipm/hipo/auxiliary/Auxiliary.cpp

@@ -208,15 +208,6 @@ Int64 getDiagStart(Int n, Int k, Int nb, Int n_blocks,
   return result;
 }
 
-Int64 sizeAtLeastOne(Int64 size) {
-  // When resizing vectors on windows, if the size is 0, there can be problems
-  // later on accessing the entry at address 0. So always allocate at least one
-  // byte.
-
-  if (0 == size) ++size;
-  return size;
-}
-
 Clock::Clock() { start(); }
 void Clock::start() { t0 = std::chrono::high_resolution_clock::now(); }
 double Clock::stop() const {

highs/ipm/hipo/auxiliary/Auxiliary.h

@@ -28,7 +28,6 @@ void processEdge(Int j, Int i, const std::vector<Int>& first,
                  std::vector<Int>& prevleaf, std::vector<Int>& ancestor);
 Int64 getDiagStart(Int n, Int k, Int nb, Int n_blocks,
                    std::vector<Int64>& start, bool triang = false);
-Int64 sizeAtLeastOne(Int64 size);
 
 template <typename T>
 void counts2Ptr(std::vector<T>& ptr, std::vector<T>& w) {

highs/ipm/hipo/factorhighs/CliqueStack.cpp

@@ -3,17 +3,15 @@
 #include <cassert>
 #include <cstring>
 
-#include "ipm/hipo/auxiliary/Auxiliary.h"
-
 namespace hipo {
 
 void CliqueStack::init(Int64 stack_size) {
-  stack_size = sizeAtLeastOne(stack_size);
-
-  stack_.resize(stack_size, 0.0);
   top_ = 0;
   workspace_ = nullptr;
   worksize_ = 0;
+  empty_ = false;
+
+  stack_.resize(stack_size, 0.0);
 }
 
 double* CliqueStack::setup(Int64 clique_size, bool& reallocation) {
@@ -22,23 +20,25 @@ double* CliqueStack::setup(Int64 clique_size, bool& reallocation) {
   assert(!workspace_ && !worksize_);
   reallocation = false;
 
-  // This should not trigger reallocation, because the resize in init is done
-  // with the maximum possible size of the stack.
-  if (top_ + clique_size > stack_.size()) {
-    reallocation = true;
-    stack_.resize(top_ + clique_size, 0.0);
-  }
+  if (stack_.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 > stack_.size()) {
+      reallocation = true;
+      stack_.resize(top_ + clique_size, 0.0);
+    }
 
-  workspace_ = &stack_[top_];
-  worksize_ = clique_size;
+    workspace_ = &stack_[top_];
+    worksize_ = clique_size;
 
-  // initialize workspace to zero
-  std::memset(workspace_, 0, worksize_ * sizeof(double));
+    // initialize workspace to zero
+    std::memset(workspace_, 0, worksize_ * sizeof(double));
+  }
 
   return workspace_;
 }
 
-bool CliqueStack::empty() const { return stack_.empty(); }
+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
@@ -63,14 +63,16 @@ void CliqueStack::popChild() {
 void CliqueStack::pushWork(Int sn) {
   // Put the content of the workspace at the top of the stack
 
-  // stack_[top_] has lower address than workspace, so no need to resize.
-  // workspace_ and stack_[top_] do not overlap, so use memcpy
-  std::memcpy(&stack_[top_], workspace_, worksize_ * sizeof(double));
+  if (stack_.size() > 0) {
+    // stack_[top_] has lower address than workspace, so no need to resize.
+    // workspace_ and stack_[top_] do not overlap, so use memcpy
+    std::memcpy(&stack_[top_], workspace_, worksize_ * sizeof(double));
 
-  top_ += worksize_;
+    top_ += worksize_;
 
-  // keep track of supernodes pushed
-  sn_pushed_.push({sn, worksize_});
+    // keep track of supernodes pushed
+    sn_pushed_.push({sn, worksize_});
+  }
 
   worksize_ = 0;
   workspace_ = nullptr;

highs/ipm/hipo/factorhighs/CliqueStack.h

@@ -33,6 +33,7 @@ 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_{};

highs/ipm/hipo/factorhighs/FormatHandler.h

@@ -88,6 +88,8 @@ class FormatHandler {
   virtual void extremeEntries() {}
 };
 
+const Int64 extra_space_frontal = 1;
+
 }  // namespace hipo
 
 #endif

highs/ipm/hipo/factorhighs/HybridHybridFormatHandler.cpp

@@ -25,18 +25,19 @@ void HybridHybridFormatHandler::initFrontal() {
   const Int n_blocks = (sn_size_ - 1) / nb_ + 1;
   diag_start_.resize(n_blocks);
   Int64 frontal_size = getDiagStart(ldf_, sn_size_, nb_, n_blocks, diag_start_);
-  frontal_size = sizeAtLeastOne(frontal_size);
+  frontal_size += extra_space_frontal;
   frontal_.resize(frontal_size);
   std::memset(frontal_.data(), 0, frontal_size * sizeof(double));
 
+  // NB: extra_space_frontal is not strictly needed. However, it removes some
+  // weird problem on windows in debug. Who knows what's happening...
+
   // frontal_ is actually allocated just the first time, then the memory is
   // reused from the previous factorisations and just initialised.
 }
 
 void HybridHybridFormatHandler::initClique() {
-  Int64 clique_size = S_->cliqueSize(sn_);
-  clique_size = sizeAtLeastOne(clique_size);
-  clique_.resize(clique_size);
+  clique_.resize(S_->cliqueSize(sn_));
   clique_ptr_ = clique_.data();
 }
 

highs/ipm/hipo/factorhighs/HybridSolveHandler.cpp

@@ -145,7 +145,7 @@ void HybridSolveHandler::backwardSolve(std::vector<double>& x) const {
 
     // index to access snColumns[sn]
     // initialised with the total number of entries of snColumns[sn]
-    Int64 SnCol_ind = sn_columns_[sn].size();
+    Int64 SnCol_ind = sn_columns_[sn].size() - extra_space_frontal;
 
     // go through blocks of columns for this supernode in reverse order
     for (Int j = n_blocks - 1; j >= 0; --j) {