Use splitting only if reduction is large

Author: filikat

highs/ipm/hipo/factorhighs/Analyse.cpp

@@ -1492,7 +1492,14 @@ Int Analyse::run(Symbolic& S) {
   S.relind_clique_ = std::move(relind_clique_);
   S.consecutive_sums_ = std::move(consecutive_sums_);
   S.clique_block_start_ = std::move(clique_block_start_);
-  S.tree_splitting_ = std::move(tree_splitting_);
+
+  // use the tree splitting only if it achieves a good relative reduction of the
+  // number of tasks
+  if (sn_count_ - tree_splitting_.tasks() > sn_count_ * kTaskReductionThresh) {
+    S.tree_splitting_ = std::move(tree_splitting_);
+    S.use_splitting_ = true;
+  } else
+    S.use_splitting_ = false;
 
   HIPO_CLOCK_STOP(1, data_, kTimeAnalyse);
 

highs/ipm/hipo/factorhighs/FactorHiGHSSettings.h

@@ -51,8 +51,9 @@ const double kDynamicDiagCoeff = 1e-24;
 const Int kMetisSeed = 42;
 
 // tree splitting
-const double kSmallThreshCoeff = 0.001;
+const double kSmallThreshCoeff = 0.001;  // 0.1%
 const double kSpopsWeightSplitting = 30.0;
+const double kTaskReductionThresh = 0.8;  // 80%
 
 struct Regul {
   double primal{};

highs/ipm/hipo/factorhighs/Factorise.cpp

@@ -378,37 +378,47 @@ void Factorise::spawn(Int sn, const TaskGroupSpecial& tg, bool do_spawn) {
   // immediately. This avoids the overhead of spawning a task if a supernode has
   // a single child.
 
-  const NodeData* data = S_.treeSplitting().find(sn);
+  if (S_.useSplitting()) {
+    const NodeData* data = S_.treeSplitting().find(sn);
 
-  if (!data) {
-    // sn is head of small subtree, but not the first subtree in the group.
-    // It is processed in another task.
-    return;
-  }
+    if (!data) {
+      // sn is head of small subtree, but not the first subtree in the group.
+      // It is processed in another task.
+      return;
+    }
 
-  if (data->type == NodeType::single) {
-    // sn is single node; run only that
-    auto f = [this, sn]() { processSupernode(sn, true); };
+    if (data->type == NodeType::single) {
+      // sn is single node; run only that
+      auto f = [this, sn]() { processSupernode(sn, true); };
 
-    if (do_spawn)
-      tg.spawn(std::move(f));
-    else
-      f();
+      if (do_spawn)
+        tg.spawn(std::move(f));
+      else
+        f();
 
-  } else {
-    // sn is head of the first subtree in a group of small subtrees; run all
-    // of them
-
-    auto f = [this, data]() {
-      for (Int i = 0; i < data->group.size(); ++i) {
-        Int st_head = data->group[i];
-        Int start = data->firstdesc[i];
-        Int end = st_head + 1;
-        for (Int sn = start; sn < end; ++sn) {
-          processSupernode(sn, false);
+    } else {
+      // sn is head of the first subtree in a group of small subtrees; run all
+      // of them
+
+      auto f = [this, data]() {
+        for (Int i = 0; i < data->group.size(); ++i) {
+          Int st_head = data->group[i];
+          Int start = data->firstdesc[i];
+          Int end = st_head + 1;
+          for (Int sn = start; sn < end; ++sn) {
+            processSupernode(sn, false);
+          }
         }
-      }
-    };
+      };
+
+      if (do_spawn)
+        tg.spawn(std::move(f));
+      else
+        f();
+    }
+
+  } else {
+    auto f = [this, sn]() { processSupernode(sn, true); };
 
     if (do_spawn)
       tg.spawn(std::move(f));
@@ -420,7 +430,12 @@ void Factorise::spawn(Int sn, const TaskGroupSpecial& tg, bool do_spawn) {
 void Factorise::sync(Int sn, const TaskGroupSpecial& tg) {
   // If spawn(sn,tg) created a task, then sync it.
   // This happens only if sn is found in the treeSplitting data structure.
-  if (S_.treeSplitting().belong(sn)) tg.sync();
+
+  if (S_.useSplitting()) {
+    if (S_.treeSplitting().belong(sn)) tg.sync();
+  } else {
+    tg.sync();
+  }
 }
 
 bool Factorise::run(Numeric& num) {

highs/ipm/hipo/factorhighs/Symbolic.cpp

@@ -6,7 +6,7 @@
 #include "ipm/hipo/auxiliary/Log.h"
 
 namespace hipo {
-  
+
 void Symbolic::setParallel(bool par_tree, bool par_node) {
   parallel_tree_ = par_tree;
   parallel_node_ = par_node;
@@ -39,6 +39,7 @@ Int64 Symbolic::maxStackSize() const { return max_stack_size_; }
 bool Symbolic::parTree() const { return parallel_tree_; }
 bool Symbolic::parNode() const { return parallel_node_; }
 double Symbolic::storage() const { return serial_storage_; }
+bool Symbolic::useSplitting() const { return use_splitting_; }
 
 const std::vector<Int64>& Symbolic::ptr() const { return ptr_; }
 const std::vector<Int>& Symbolic::iperm() const { return iperm_; }
@@ -78,7 +79,8 @@ void Symbolic::print(const Log& log, bool verbose) const {
     log_stream << textline("Max tree speedup:") << fix(flops_ / critops_, 0, 2)
                << '\n';
     log_stream << textline("Number of tasks:")
-               << integer(tree_splitting_.tasks()) << '\n';
+               << integer(use_splitting_ ? tree_splitting_.tasks() : sn_)
+               << '\n';
     log_stream << textline("Artificial nz:") << sci(artificial_nz_, 0, 1)
                << '\n';
     log_stream << textline("Artificial ops:") << sci(artificial_ops_, 0, 1)

highs/ipm/hipo/factorhighs/Symbolic.h

@@ -4,9 +4,9 @@
 #include <map>
 #include <vector>
 
+#include "TreeSplitting.h"
 #include "ipm/hipo/auxiliary/IntConfig.h"
 #include "ipm/hipo/auxiliary/Log.h"
-#include "TreeSplitting.h"
 
 namespace hipo {
 
@@ -102,6 +102,7 @@ class Symbolic {
   std::string ordering;
 
   TreeSplitting tree_splitting_;
+  bool use_splitting_ = false;
 
   friend class Analyse;
 
@@ -130,6 +131,7 @@ class Symbolic {
   bool parTree() const;
   bool parNode() const;
   double storage() const;
+  bool useSplitting() const;
   const std::vector<Int64>& ptr() const;
   const std::vector<Int>& iperm() const;
   const std::vector<Int>& snParent() const;