Changes to FormatHandler::terminate

Author: filikat

highs/ipm/hipo/factorhighs/Factorise.cpp

@@ -200,8 +200,9 @@ void Factorise::processSupernode(Int sn) {
 
   // initialise the format handler
   // this also allocates space for the frontal matrix and schur complement
-  std::unique_ptr<FormatHandler> FH(
-      new HybridHybridFormatHandler(S_, sn, regul_, data_, sn_columns_[sn]));
+  std::unique_ptr<FormatHandler> FH(new HybridHybridFormatHandler(
+      S_, sn, regul_, sn_columns_[sn], schur_contribution_[sn], swaps_[sn],
+      pivot_2x2_[sn], data_));
 
 #if HIPO_TIMING_LEVEL >= 2
   data_.sumTime(kTimeFactorisePrepare, clock.stop());
@@ -344,8 +345,7 @@ void Factorise::processSupernode(Int sn) {
   FH->extremeEntries();
 
   // terminate the format handler
-  FH->terminate(schur_contribution_[sn], total_reg_, swaps_[sn],
-                pivot_2x2_[sn]);
+  FH->terminate(total_reg_);
 #if HIPO_TIMING_LEVEL >= 2
   data_.sumTime(kTimeFactoriseTerminate, clock.stop());
 #endif

highs/ipm/hipo/factorhighs/FormatHandler.cpp

@@ -7,33 +7,27 @@
 namespace hipo {
 
 FormatHandler::FormatHandler(const Symbolic& S, Int sn, const Regul& regul,
-                             std::vector<double>& frontal)
+                             std::vector<double>& frontal,
+                             std::vector<double>& clique,
+                             std::vector<Int>& swaps,
+                             std::vector<double>& pivot_2x2)
     : S_{&S},
       regul_{regul},
       sn_{sn},
       nb_{S_->blockSize()},
       sn_size_{S_->snStart(sn_ + 1) - S_->snStart(sn_)},
       ldf_{S_->ptr(sn_ + 1) - S_->ptr(sn_)},
       ldc_{ldf_ - sn_size_},
-      frontal_{frontal} {
-  local_reg_.resize(sn_size_);
-  swaps_.resize(sn_size_);
-  pivot_2x2_.resize(sn_size_);
+      frontal_{frontal},
+      clique_{clique},
+      swaps_{swaps},
+      pivot_2x2_{pivot_2x2} {
+  local_reg_.assign(sn_size_, 0.0);
+  swaps_.assign(sn_size_, 0);
+  pivot_2x2_.assign(sn_size_, 0.0);
 }
 
-void FormatHandler::terminate(std::vector<double>& clique,
-                              std::vector<double>& total_reg,
-                              std::vector<Int>& swaps,
-                              std::vector<double>& pivot_2x2) {
-  // Move local copies of data into their final position.
-  // In this way, the shared objects sn_columns_ and schur_contribution_ are
-  // accessed only here, while a local copy is used for the assembly and dense
-  // factorisation. This should avoid the problem of false sharing.
-
-  clique = std::move(clique_);
-  swaps = std::move(swaps_);
-  pivot_2x2 = std::move(pivot_2x2_);
-
+void FormatHandler::terminate(std::vector<double>& total_reg) {
   // Move local regularisation into total regularisation.
   for (Int i = 0; i < sn_size_; ++i)
     total_reg[S_->snStart(sn_) + i] = local_reg_[i];

highs/ipm/hipo/factorhighs/FormatHandler.h

@@ -49,16 +49,16 @@ class FormatHandler {
 
   // local copies to be moved at the end
   std::vector<double>& frontal_;
-  std::vector<double> clique_{};
+  std::vector<double>& clique_;
   std::vector<double> local_reg_{};
-  std::vector<Int> swaps_{};
-  std::vector<double> pivot_2x2_{};
+  std::vector<Int>& swaps_;
+  std::vector<double>& pivot_2x2_;
 
  public:
   FormatHandler(const Symbolic& S, Int sn, const Regul& regul,
-                std::vector<double>& frontal);
-  void terminate(std::vector<double>& clique, std::vector<double>& total_reg,
-                 std::vector<Int>& swaps, std::vector<double>& pivot_2x2);
+                std::vector<double>& frontal, std::vector<double>& clique,
+                std::vector<Int>& swaps, std::vector<double>& pivot_2x2);
+  void terminate(std::vector<double>& total_reg);
 
   // avoid copies
   FormatHandler(const FormatHandler&) = delete;

highs/ipm/hipo/factorhighs/HybridHybridFormatHandler.cpp

@@ -8,9 +8,11 @@
 namespace hipo {
 
 HybridHybridFormatHandler::HybridHybridFormatHandler(
-    const Symbolic& S, Int sn, const Regul& regul, DataCollector& data,
-    std::vector<double>& frontal)
-    : FormatHandler(S, sn, regul, frontal), data_{data} {
+    const Symbolic& S, Int sn, const Regul& regul, std::vector<double>& frontal,
+    std::vector<double>& clique, std::vector<Int>& swaps,
+    std::vector<double>& pivot_2x2, DataCollector& data)
+    : FormatHandler(S, sn, regul, frontal, clique, swaps, pivot_2x2),
+      data_{data} {
   // initialise frontal and clique
   initFrontal();
   initClique();
@@ -28,7 +30,7 @@ void HybridHybridFormatHandler::initFrontal() {
 }
 
 void HybridHybridFormatHandler::initClique() {
-  clique_.resize(S_->cliqueSize(sn_));
+  clique_.assign(S_->cliqueSize(sn_), 0.0);
 }
 
 void HybridHybridFormatHandler::assembleFrontal(Int i, Int j, double val) {

highs/ipm/hipo/factorhighs/HybridHybridFormatHandler.h

@@ -23,7 +23,11 @@ class HybridHybridFormatHandler : public FormatHandler {
 
  public:
   HybridHybridFormatHandler(const Symbolic& S, Int sn, const Regul& regul,
-                            DataCollector& data, std::vector<double>& frontal);
+                            std::vector<double>& frontal,
+                            std::vector<double>& clique,
+                            std::vector<Int>& swaps,
+                            std::vector<double>& pivot_2x2,
+                            DataCollector& data);
 };
 
 }  // namespace hipo