Groups of small subtrees

Author: filikat

highs/ipm/hipo/factorhighs/Analyse.cpp

@@ -1293,13 +1293,10 @@ void Analyse::computeBlockStart() {
 
 void Analyse::findTreeSplitting() {
   // Split the tree into single nodes and subtrees.
-  // The subtrees have at most 1% of total operations.
+  // The subtrees have at most 1% of total operations. They are group together
+  // so that each group of subtrees has between 1% and 2% of total operations.
   // The tree is parallelised by creating a task for each single node and a task
-  // for each subtree.
-
-  // linked lists of children
-  std::vector<Int> head, next;
-  childrenLinkedList(sn_parent_, head, next);
+  // for each group of subtrees.
 
   // compute number of operations for each supernode
   std::vector<double> sn_ops(sn_count_);
@@ -1337,23 +1334,65 @@ void Analyse::findTreeSplitting() {
   std::vector<Int> first_desc;
   firstDescendant(sn_parent_, first_desc);
 
+  // linked lists of children
+  std::vector<Int> head, next;
+  childrenLinkedList(sn_parent_, head, next);
+
   // Divide the tree into single nodes and subtrees, such that each subtree has
-  // at most small_thresh operations overall.
+  // at most small_thresh operations overall. Group subtrees together, so that
+  // groups have 1-2% operations.
   const double small_thresh = kSmallSubtreesCoeff * total_ops;
   for (Int sn = 0; sn < sn_count_; ++sn) {
     if (subtree_ops[sn] > small_thresh) {
       // sn is a single node
-      tree_splitting_.insert({sn, {NodeType::single, -1}});
+      auto res_insert = tree_splitting_.insert({sn, {}});
+      res_insert.first->second.type = NodeType::single;
+
+      // The children of this sn are either single nodes or head of subtrees.
+      // Divide the head of subtrees in groups, so that each group has 1% to 2%
+      // of total operations. Each group corresponds to one task executed in
+      // parallel.
 
-    } else if (sn_parent_[sn] == -1 ||
-               subtree_ops[sn_parent_[sn]] > small_thresh) {
-      // sn is head of a subtree
-      tree_splitting_.insert({sn, {NodeType::subtree, first_desc[sn]}});
+      double current_ops = 0.0;
+      NodeData* current_nodedata = nullptr;
+      Int child = head[sn];
+      while (child != -1) {
+        bool is_small = subtree_ops[child] <= small_thresh;
+
+        if (is_small) {
+          if (!current_nodedata) {
+            auto res_insert = tree_splitting_.insert({child, {}});
+            current_nodedata = &res_insert.first->second;
+            current_nodedata->type = NodeType::subtree;
+            current_ops = 0.0;
+          }
+
+          current_ops += subtree_ops[child];
+          current_nodedata->group.push_back(child);
+          current_nodedata->firstdesc.push_back(first_desc[child]);
+
+          if (current_ops > small_thresh) current_nodedata = nullptr;
+        }
 
+        child = next[child];
+      }
+
+    } else if (sn_parent_[sn] == -1) {
+      // sn is small root: single task with whole subtree
+      auto res_insert = tree_splitting_.insert({sn, {}});
+      res_insert.first->second.type = NodeType::subtree;
+      res_insert.first->second.group.push_back(sn);
+      res_insert.first->second.firstdesc.push_back(first_desc[sn]);
+    }
+    /*
+    else if (subtree_ops[sn_parent_[sn]] > small_thresh) {
+      // sn is head of a subtree, processed as part of a group of subtrees
+      continue;
     } else {
       // sn is part of a subtree, but not the head
       continue;
     }
+    */
   }
 }
 

highs/ipm/hipo/factorhighs/Factorise.cpp

@@ -199,14 +199,14 @@ void Factorise::processSupernode(Int sn, bool parallelise) {
     // spawn children of this supernode in reverse order
     Int child_to_spawn = first_child_reverse_[sn];
     while (child_to_spawn != -1) {
-      if (spawnNode(child_to_spawn, tg)) return;
+      spawnNode(child_to_spawn, tg);
 
       child_to_spawn = next_child_reverse_[child_to_spawn];
     }
 
     // wait for first child to finish, before starting the parent (if there is a
     // first child)
-    if (first_child_reverse_[sn] != -1) tg.sync();
+    if (first_child_[sn] != -1) syncNode(first_child_[sn], tg);
   }
 
 #if HIPO_TIMING_LEVEL >= 2
@@ -262,7 +262,7 @@ void Factorise::processSupernode(Int sn, bool parallelise) {
 
     if (parallelise) {
       // sync with spawned child, apart from the first one
-      if (child_sn != first_child_[sn]) tg.sync();
+      if (child_sn != first_child_[sn]) syncNode(child_sn, tg);
 
       if (flag_stop_) return;
 
@@ -373,31 +373,42 @@ void Factorise::processSupernode(Int sn, bool parallelise) {
 #endif
 }
 
-bool Factorise::spawnNode(Int sn, const TaskGroupSpecial& tg) {
+void Factorise::spawnNode(Int sn, const TaskGroupSpecial& tg) {
   auto it = S_.treeSplitting().find(sn);
 
   if (it == S_.treeSplitting().end()) {
-    log_->printDevInfo("Missing supernode from tree splitting\n");
-    flag_stop_ = true;
-    return true;
+    // sn is head of small subtree, but not the first subtree in the group.
+    // It will be processed in another task.
+    return;
   }
 
   if (it->second.type == NodeType::single) {
-    // sn is single node, spawn only that
-    tg.spawn([=]() { processSupernode(sn, true); });
+    // sn is single node; spawn only that
+    tg.spawn([this, sn]() { processSupernode(sn, true); });
 
   } else {
-    // sn is subtree, spawn the whole subtree
-    Int start = it->second.first;
-    Int end = sn + 1;
-    tg.spawn([=]() {
-      for (Int sn = start; sn < end; ++sn) {
-        processSupernode(sn, false);
+    // sn is head of the first subtree in a group of small subtrees; spawn all
+    // of them
+
+    tg.spawn([this, it]() {
+      for (Int i = 0; i < it->second.group.size(); ++i) {
+        Int st_head = it->second.group[i];
+        Int start = it->second.firstdesc[i];
+        Int end = st_head + 1;
+        for (Int sn = start; sn < end; ++sn) {
+          processSupernode(sn, false);
+        }
       }
     });
   }
+}
 
-  return false;
+void Factorise::syncNode(Int sn, const TaskGroupSpecial& tg) {
+  // If spawnNode(sn,tg) created a task, then sync it.
+  // This happens only if sn is found in the treeSplitting data structure.
+
+  auto it = S_.treeSplitting().find(sn);
+  if (it != S_.treeSplitting().end()) tg.sync();
 }
 
 bool Factorise::run(Numeric& num) {
@@ -421,9 +432,7 @@ bool Factorise::run(Numeric& num) {
   if (S_.parTree()) {
     // spawn tasks for root supernodes
     for (Int sn = 0; sn < S_.sn(); ++sn) {
-      if (S_.snParent(sn) == -1) {
-        if (spawnNode(sn, tg)) return true;
-      }
+      if (S_.snParent(sn) == -1) spawnNode(sn, tg);
     }
 
     // sync tasks for root supernodes

highs/ipm/hipo/factorhighs/Factorise.h

@@ -75,7 +75,8 @@ class Factorise {
  public:
   void permute(const std::vector<Int>& iperm);
   void processSupernode(Int sn, bool parallelise);
-  bool spawnNode(Int sn, const TaskGroupSpecial& tg);
+  void spawnNode(Int sn, const TaskGroupSpecial& tg);
+  void syncNode(Int sn, const TaskGroupSpecial& tg);
 
  public:
   Factorise(const Symbolic& S, const std::vector<Int>& rowsA,

highs/ipm/hipo/factorhighs/Symbolic.h

@@ -12,7 +12,8 @@ namespace hipo {
 enum NodeType { single, subtree };
 struct NodeData {
   NodeType type;
-  Int first;
+  std::vector<Int> firstdesc;
+  std::vector<Int> group;
 };
 
 // Symbolic factorisation object
@@ -101,6 +102,13 @@ class Symbolic {
   // Starting position of diagonal blocks for hybrid formats
   std::vector<std::vector<Int>> clique_block_start_{};
 
+  // Information to split the elimination tree. Each entry in tree_splitting_
+  // correspond to a task that is executed in parallel.
+  // tree_splitting_ contains pairs (sn, data):
+  // - If data.type is single, then the task processes only the supernode sn.
+  // - If data.type is subtree, then the task processes each subtree rooted at
+  //    data.group[i]. Each subtree requires processing supernodes j,
+  //    data.firstdesc[i] <= j <= data.group[i].
   std::map<Int, NodeData> tree_splitting_;
 
   friend class Analyse;