Switch off tree parallelism if depth of recursion is too large

Author: filikat

highs/ipm/hipo/auxiliary/Auxiliary.cpp

@@ -208,6 +208,26 @@ Int64 getDiagStart(Int n, Int k, Int nb, Int n_blocks,
   return result;
 }
 
+Int maxDepthTree(const std::vector<Int>& parent) {
+  Int max_depth = 0;
+  std::vector<Int> depth(parent.size(), -1);
+  for (Int i = 0; i < parent.size(); ++i) {
+    Int node = i;
+    Int value = 1;
+    while (node != -1) {
+      if (value > depth[node]) {
+        depth[node] = value;
+      } else
+        break;
+
+      ++value;
+      node = parent[node];
+    }
+    if (parent[i] == -1) max_depth = std::max(max_depth, depth[i]);
+  }
+  return max_depth;
+}
+
 Clock::Clock() { start(); }
 void Clock::start() { t0 = std::chrono::high_resolution_clock::now(); }
 double Clock::stop() const {

highs/ipm/hipo/auxiliary/Auxiliary.h

@@ -28,6 +28,7 @@ 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);
+Int maxDepthTree(const std::vector<Int>& parent);
 
 template <typename T>
 void counts2Ptr(std::vector<T>& ptr, std::vector<T>& w) {

highs/ipm/hipo/factorhighs/Analyse.cpp

@@ -1349,6 +1349,7 @@ Int Analyse::run(Symbolic& S) {
   S.block_size_ = nb_;
   S.max_stack_size_ = max_stack_size_;
   S.ordering = ordering_;
+  S.tree_depth_ = maxDepthTree(sn_parent_);
 
   // compute largest supernode
   std::vector<Int> sn_size(sn_start_.begin() + 1, sn_start_.end());

highs/ipm/hipo/factorhighs/Symbolic.cpp

@@ -41,6 +41,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_; }
+Int Symbolic::depth() const { return tree_depth_; }
 
 const std::vector<Int64>& Symbolic::ptr() const { return ptr_; }
 const std::vector<Int>& Symbolic::iperm() const { return iperm_; }
@@ -78,6 +79,7 @@ void Symbolic::print(const Log& log, bool verbose) const {
     log_stream << textline("Critical ops:") << sci(critops_, 0, 1) << '\n';
     log_stream << textline("Max tree speedup:") << fix(flops_ / critops_, 0, 2)
                << '\n';
+    log_stream << textline("Tree depth:") << integer(tree_depth_, 0) << '\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

@@ -96,7 +96,7 @@ class Symbolic {
   std::vector<std::vector<Int64>> clique_block_start_{};
 
   Int64 max_stack_size_{};
-
+  Int tree_depth_{};
   std::string ordering;
 
   friend class Analyse;
@@ -124,6 +124,7 @@ class Symbolic {
   Int64 cliqueBlockStart(Int sn, Int bl) const;
   Int64 cliqueSize(Int sn) const;
   Int64 maxStackSize() const;
+  Int depth() const;
   bool parTree() const;
   bool parNode() const;
   double storage() const;

highs/ipm/hipo/ipm/FactorHiGHSSolver.cpp

@@ -711,6 +711,9 @@ void FactorHiGHSSolver::setParallel() {
         parallel_tree = false;
       }
 
+      // switch off tree parallelism if depth of recursion is too large
+      if (S_.depth() > kMaxTreeDepth) parallel_tree = false;
+
       if (parallel_tree && parallel_node) {
         options_.parallel = kOptionParallelOn;
         log_stream << "Full preferred\n";

highs/ipm/hipo/ipm/Parameters.h

@@ -34,6 +34,7 @@ const double kSmallSnThresh = 3.0;
 const Int kMinNumberSn = 10;
 const double kLargeStorageGB = 20.0;
 const double kLargeFillin = 50.0;
+const double kMaxTreeDepth = 1000;
 
 // parameters for choice of ordering
 const double kFlopsOrderingThresh = 1.2;