Avoid too many map look-ups

Author: filikat

highs/ipm/hipo/factorhighs/Analyse.cpp

@@ -1274,6 +1274,8 @@ void Analyse::findTreeSplitting() {
   std::vector<Int> head, next;
   childrenLinkedList(sn_parent_, head, next);
 
+  is_in_tree_splitting_.assign(sn_count_, false);
+
   // Divide the tree into single nodes and subtrees, such that each subtree has
   // at most small_thresh operations overall. Group subtrees together, so that
   // groups have 1-2% operations.
@@ -1282,6 +1284,7 @@ void Analyse::findTreeSplitting() {
     if (subtree_ops[sn] > small_thresh) {
       // sn is a single node
       auto res_insert = tree_splitting_.insert({sn, {}});
+      is_in_tree_splitting_[sn] = true;
       res_insert.first->second.type = NodeType::single;
 
       // The children of this sn are either single nodes or head of subtrees.
@@ -1298,6 +1301,7 @@ void Analyse::findTreeSplitting() {
         if (is_small) {
           if (!current_nodedata) {
             auto res_insert = tree_splitting_.insert({child, {}});
+            is_in_tree_splitting_[child] = true;
             current_nodedata = &res_insert.first->second;
             current_nodedata->type = NodeType::subtree;
             current_ops = 0.0;
@@ -1316,6 +1320,7 @@ void Analyse::findTreeSplitting() {
     } else if (sn_parent_[sn] == -1) {
       // sn is small root: single task with whole subtree
       auto res_insert = tree_splitting_.insert({sn, {}});
+      is_in_tree_splitting_[sn] = true;
       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]);
@@ -1457,6 +1462,7 @@ Int Analyse::run(Symbolic& S) {
   S.consecutive_sums_ = std::move(consecutive_sums_);
   S.clique_block_start_ = std::move(clique_block_start_);
   S.tree_splitting_ = std::move(tree_splitting_);
+  S.is_in_tree_splitting_ = std::move(is_in_tree_splitting_);
 
 #if HIPO_TIMING_LEVEL >= 1
   data_.sumTime(kTimeAnalyse, clock_total.stop());

highs/ipm/hipo/factorhighs/Analyse.h

@@ -78,6 +78,7 @@ class Analyse {
   std::vector<std::vector<Int>> clique_block_start_{};
 
   std::map<Int, NodeData> tree_splitting_;
+  std::vector<bool> is_in_tree_splitting_;
 
   // block size
   Int nb_{};

highs/ipm/hipo/factorhighs/FactorHiGHSSettings.h

@@ -52,7 +52,7 @@ const Int kMaxRefinementIter = 3;
 const double kRefinementTolerance = 1e-12;
 
 // tree splitting
-const double kSmallSubtreesCoeff = 0.01; // 1%
+const double kSmallSubtreesCoeff = 0.001; // 0.1%
 const double kSpopsWeightSplitting = 30.0;
 
 // metis

highs/ipm/hipo/factorhighs/Factorise.cpp

@@ -384,31 +384,32 @@ void Factorise::spawnNode(Int sn, const TaskGroupSpecial& tg, bool do_spawn) {
   // immediately. This avoids the overhead of spawning a task if a supernode has
   // a single child.
 
-  auto it = S_.treeSplitting().find(sn);
-
-  if (it == S_.treeSplitting().end()) {
+  if (!S_.isInTreeSplitting(sn)) {
     // sn is head of small subtree, but not the first subtree in the group.
     // It will be processed in another task.
     return;
   }
 
+  // only search the map if sn is inside
+  auto it = S_.treeSplitting().find(sn);
+
   if (it->second.type == NodeType::single) {
     // sn is single node; spawn only that
 
-    auto lambda = [this, sn]() { processSupernode(sn, true); };
+    auto f = [this, sn]() { processSupernode(sn, true); };
 
     if (do_spawn)
-      tg.spawn(std::move(lambda));
+      tg.spawn(std::move(f));
     else
-      lambda();
+      f();
 
   } else {
     // sn is head of the first subtree in a group of small subtrees; spawn all
     // of them
 
     const NodeData* nd_ptr = &(it->second);
 
-    auto lambda = [this, nd_ptr]() {
+    auto f = [this, nd_ptr]() {
       for (Int i = 0; i < nd_ptr->group.size(); ++i) {
         Int st_head = nd_ptr->group[i];
         Int start = nd_ptr->firstdesc[i];
@@ -420,18 +421,17 @@ void Factorise::spawnNode(Int sn, const TaskGroupSpecial& tg, bool do_spawn) {
     };
 
     if (do_spawn)
-      tg.spawn(std::move(lambda));
+      tg.spawn(std::move(f));
     else
-      lambda();
+      f();
   }
 }
 
 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();
+  if (S_.isInTreeSplitting(sn)) tg.sync();
 }
 
 bool Factorise::run(Numeric& num) {

highs/ipm/hipo/factorhighs/Symbolic.cpp

@@ -53,6 +53,9 @@ const std::vector<Int>& Symbolic::pivotSign() const { return pivot_sign_; }
 const std::map<Int, NodeData>& Symbolic::treeSplitting() const {
   return tree_splitting_;
 }
+bool Symbolic::isInTreeSplitting(Int sn) const {
+  return is_in_tree_splitting_[sn];
+}
 
 Int Symbolic::snRoots() const {
   Int roots = 0;

highs/ipm/hipo/factorhighs/Symbolic.h

@@ -114,6 +114,10 @@ class Symbolic {
   //    data.firstdesc[i] <= j <= data.group[i].
   std::map<Int, NodeData> tree_splitting_;
 
+  // For each supernode, is_in_tree_splitting_[sn] is true if sn is found in the
+  // tree_splitting_ data structure. Avoids too many lookups into the map.
+  std::vector<bool> is_in_tree_splitting_;
+
   friend class Analyse;
 
  public:
@@ -149,6 +153,7 @@ class Symbolic {
   const std::vector<Int>& snStart() const;
   const std::vector<Int>& pivotSign() const;
   const std::map<Int, NodeData>& treeSplitting() const;
+  bool isInTreeSplitting(Int sn) const;
 
   void print(const Log& log, bool verbose = false) const;
 };