Small subtrees divided among threads

Author: filikat

highs/ipm/hipo/factorhighs/Analyse.cpp

@@ -1323,6 +1323,9 @@ void Analyse::generateParallelLayer(Int threads) {
   // percentage of total ops below which a subtree is considered small
   const double small_thresh_coeff = 0.01;
 
+  std::vector<double> subtree_ops(sn_count_, 0.0);
+  double total_ops = dense_ops_;
+
   if (threads > 1) {
     std::stringstream log_stream;
     log_stream << "Searching parallel layer\n";
@@ -1331,8 +1334,6 @@ void Analyse::generateParallelLayer(Int threads) {
     std::vector<Int> head, next;
     childrenLinkedList(sn_parent_, head, next);
 
-    double total_ops = dense_ops_;
-
     // compute number of operations for each supernode
     std::vector<double> sn_ops(sn_count_);
     for (Int sn = 0; sn < sn_count_; ++sn) {
@@ -1357,7 +1358,6 @@ void Analyse::generateParallelLayer(Int threads) {
     }
 
     // compute number of operations to process each subtree
-    std::vector<double> subtree_ops(sn_count_, 0.0);
     for (Int sn = 0; sn < sn_count_; ++sn) {
       subtree_ops[sn] += sn_ops[sn];
       if (sn_parent_[sn] != -1) {
@@ -1578,6 +1578,8 @@ void Analyse::generateParallelLayer(Int threads) {
     // no stack needed for small subtrees
     smallSubtreesInfo_[index].stack = -1;
 
+    smallSubtreesInfo_[index].ops_fraction = subtree_ops[node] / total_ops;
+
     ++index;
   }
 }

highs/ipm/hipo/factorhighs/Factorise.cpp

@@ -330,6 +330,14 @@ void Factorise::processSupernodes(Int start, Int end) {
   }
 }
 
+void Factorise::processSmallSubtrees(Int i, Int j) {
+  for (Int tree = i; tree < j; ++tree) {
+    Int start = S_.smallSubtreeInfo(tree).start;
+    Int end = S_.smallSubtreeInfo(tree).end;
+    processSupernodes(start, end);
+  }
+}
+
 bool Factorise::run(Numeric& num) {
 #if HIPO_TIMING_LEVEL >= 1
   Clock clock;
@@ -354,16 +362,36 @@ bool Factorise::run(Numeric& num) {
       highs::parallel::spawn([=]() { processSupernodes(start, end); });
     }
 
-    // wait for subtrees in the layer to complete
-    for (Int i = 0; i < S_.layerIndex().size(); ++i) {
-      highs::parallel::sync();
-    }
-
     // process small subtrees
+    // They are grouped together and spawned when a group has more than 5% of
+    // total operations
+    Int small_start{};
+    double small_ops_current{};
+    Int small_spawned{};
     for (Int i = 0; i < S_.smallSubtrees().size(); ++i) {
-      Int start = S_.smallSubtreeInfo(i).start;
-      Int end = S_.smallSubtreeInfo(i).end;
-      processSupernodes(start, end);
+      small_ops_current += S_.smallSubtreeInfo(i).ops_fraction;
+
+      if (small_ops_current > 0.05) {
+        // spawn start to current
+        highs::parallel::spawn(
+            [=]() { processSmallSubtrees(small_start, i + 1); });
+
+        small_start = i + 1;
+        small_ops_current = 0.0;
+        ++small_spawned;
+      }
+    }
+    if (small_ops_current > 0) {
+      // spawn start to end
+      ++small_spawned;
+      highs::parallel::spawn([=]() {
+        processSmallSubtrees(small_start, S_.smallSubtrees().size());
+      });
+    }
+
+    // wait for subtrees to complete
+    for (Int i = 0; i < S_.layerIndex().size() + small_spawned; ++i) {
+      highs::parallel::sync();
     }
 
     // process nodes above layer

highs/ipm/hipo/factorhighs/Factorise.h

@@ -66,6 +66,7 @@ class Factorise {
   void permute(const std::vector<Int>& iperm);
   void processSupernode(Int sn);
   void processSupernodes(Int start, Int end);
+  void processSmallSubtrees(Int start, Int end);
 
  public:
   Factorise(const Symbolic& S, const std::vector<Int>& rowsA,

highs/ipm/hipo/factorhighs/Symbolic.h

@@ -12,9 +12,10 @@ namespace hipo {
 
 // info about subtrees in the parallel layer
 struct SubtreeInfo {
-  Int start;      // first node in subtree
-  Int end;        // first node not in subtree
-  int64_t stack;  // minimum stack size
+  Int start;            // first node in subtree
+  Int end;              // first node not in subtree
+  int64_t stack;        // minimum stack size
+  double ops_fraction;  // fraction of operations in subtree
 };
 
 // Symbolic factorisation object