Improved information for small subtrees

Author: filikat

highs/ipm/hipo/factorhighs/Analyse.cpp

@@ -1569,19 +1569,27 @@ void Analyse::generateParallelLayer(Int threads) {
   // generate info about small subtrees
   smallSubtreesInfo_.resize(smallSubtrees_.size());
   Int index = 0;
+  double small_ops_current{};
+  smallSubtreesStart_.push_back(0);
   for (auto it = smallSubtrees_.begin(); it != smallSubtrees_.end(); ++it) {
     Int node = *it;
 
     smallSubtreesInfo_[index].start = first_desc[node];
     smallSubtreesInfo_[index].end = node + 1;
 
     // no stack needed for small subtrees
-    smallSubtreesInfo_[index].stack = -1;
+    smallSubtreesInfo_[index].stack = stack_subtree_parallel_[node];
 
-    smallSubtreesInfo_[index].ops_fraction = subtree_ops[node] / total_ops;
+    // divide small subtrees in groups of up to 5% ops, to be spawned together
+    small_ops_current += subtree_ops[node] / total_ops;
+    if (small_ops_current > 0.05) {
+      smallSubtreesStart_.push_back(index + 1);
+      small_ops_current = 0.0;
+    }
 
     ++index;
   }
+  if (small_ops_current > 0) smallSubtreesStart_.push_back(index);
 }
 
 Int Analyse::run(Symbolic& S) {
@@ -1721,6 +1729,7 @@ Int Analyse::run(Symbolic& S) {
   S.smallSubtreesInfo_ = std::move(smallSubtreesInfo_);
   S.aboveLayer_ = std::move(aboveLayer_);
   S.smallSubtrees_ = std::move(smallSubtrees_);
+  S.smallSubtreesStart_ = std::move(smallSubtreesStart_);
 
 #if HIPO_TIMING_LEVEL >= 1
   data_.sumTime(kTimeAnalyse, clock_total.stop());

highs/ipm/hipo/factorhighs/Analyse.h

@@ -82,6 +82,8 @@ class Analyse {
   std::map<Int, Int> layerIndex_;
   std::vector<SubtreeInfo> layerSubtreesInfo_, smallSubtreesInfo_;
   std::set<Int> aboveLayer_, smallSubtrees_;
+  std::vector<Int> smallSubtreesStart_;
+
   std::vector<int64_t> stack_subtree_serial_;
   std::vector<int64_t> stack_subtree_parallel_;
   int64_t serial_stack_size_, parallel_stack_size_;

highs/ipm/hipo/factorhighs/Factorise.cpp

@@ -363,30 +363,13 @@ bool Factorise::run(Numeric& num) {
     }
 
     // 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) {
-      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;
+    for (Int i = 1; i < S_.smallSubtreesStart().size(); ++i) {
       highs::parallel::spawn([=]() {
-        processSmallSubtrees(small_start, S_.smallSubtrees().size());
+        processSmallSubtrees(S_.smallSubtreesStart()[i - 1],
+                             S_.smallSubtreesStart()[i]);
       });
+      ++small_spawned;
     }
 
     // wait for subtrees to complete

highs/ipm/hipo/factorhighs/Symbolic.cpp

@@ -53,6 +53,9 @@ const SubtreeInfo& Symbolic::smallSubtreeInfo(Int i) const {
 const std::set<Int>& Symbolic::aboveLayer() const { return aboveLayer_; }
 const std::set<Int>& Symbolic::smallSubtrees() const { return smallSubtrees_; }
 const std::map<Int, Int>& Symbolic::layerIndex() const { return layerIndex_; }
+const std::vector<Int>& Symbolic::smallSubtreesStart() const {
+  return smallSubtreesStart_;
+}
 
 std::string memoryString(double mem) {
   std::stringstream ss;

highs/ipm/hipo/factorhighs/Symbolic.h

@@ -12,10 +12,9 @@ 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
-  double ops_fraction;  // fraction of operations in subtree
+  Int start;      // first node in subtree
+  Int end;        // first node not in subtree
+  int64_t stack;  // minimum stack size
 };
 
 // Symbolic factorisation object
@@ -123,6 +122,12 @@ class Symbolic {
   // layer
   std::set<Int> smallSubtrees_;
 
+  // Information about how to divide small subtrees among threads.
+  // A task is created that processes the subtrees numbered
+  // smallSubtreesStart[i] to smallSubtreesStart[i+1]. These subtrees have a
+  // total number of operations between 5% and 6% of the total operations.
+  std::vector<Int> smallSubtreesStart_;
+
   // Information about number of entries
   int64_t serial_stack_size_, parallel_stack_size_, factors_total_entries_;
   int64_t root_stack_entries_;
@@ -162,6 +167,7 @@ class Symbolic {
   const std::set<Int>& aboveLayer() const;
   const std::set<Int>& smallSubtrees() const;
   const std::map<Int, Int>& layerIndex() const;
+  const std::vector<Int>& smallSubtreesStart() const;
 
   void print(const Log& log, bool verbose = false) const;
 };