Merge remote-tracking branch 'origin/v10-minor'

scip-ci · scip-ci · commit 321caa5fb464 · 2025-09-12T18:53:17.000+02:00
diff --git a/CHANGELOG b/CHANGELOG
@@ -417,6 +417,7 @@ Fixed bugs
 - fixed stopping when there is a candidate with a change in the LP bound for both children in strong branching of branch_fullstrong
 - fixed detection of sinks in varbound detection from cumulative constraints
 - fixed memory allocation when adding strong SBCs for enclosing orbit of symmetric subgroups (disabled by default)
+- free paths of branch-and-bound tree iteratively instead of recursively to avoid stack overflow
 
 Build system
 ------------
diff --git a/src/lpiexact/lpiexact_spx.cpp b/src/lpiexact/lpiexact_spx.cpp
@@ -85,15 +85,15 @@
 #endif
 
 #ifndef SOPLEX_WITH_GMP
-#error "SOPLEX_WITH_GMP not defined: SoPlex must be build with GMP to be used with LPIEX=spx"
+#error "SOPLEX_WITH_GMP not defined: SoPlex must be build with GMP to be used with LPSEXACT=spx"
 #endif
 
 #ifndef SOPLEX_WITH_MPFR
-#error "SOPLEX_WITH_MPFR not defined: SoPlex must be build with MPFR to be used with LPIEX=spx"
+#error "SOPLEX_WITH_MPFR not defined: SoPlex must be build with MPFR to be used with LPSEXACT=spx"
 #endif
 
 #ifndef SOPLEX_WITH_BOOST
-#error "SOPLEX_WITH_BOOST not defined: SoPlex must be build with BOOST to be used with LPIEX=spx"
+#error "SOPLEX_WITH_BOOST not defined: SoPlex must be build with BOOST to be used with LPSEXACT=spx"
 #endif
 
 /* reset the SCIP_DEBUG define to its original SCIP value */
diff --git a/src/scip/stat.c b/src/scip/stat.c
@@ -177,7 +177,7 @@ SCIP_RETCODE SCIPstatFree(
    return SCIP_OKAY;
 }
 
-/** diables the collection of any statistic for a variable */
+/** disables the collection of any statistic for a variable */
 void SCIPstatDisableVarHistory(
    SCIP_STAT*            stat                /**< problem statistics data */
    )
diff --git a/src/scip/stat.h b/src/scip/stat.h
@@ -66,7 +66,7 @@ SCIP_RETCODE SCIPstatFree(
    BMS_BLKMEM*           blkmem              /**< block memory */
    );
 
-/** diables the collection of any statistic for a variable */
+/** disables the collection of any statistic for a variable */
 void SCIPstatDisableVarHistory(
    SCIP_STAT*            stat                /**< problem statistics data */
    );
diff --git a/src/scip/tree.c b/src/scip/tree.c
@@ -849,42 +849,37 @@ SCIP_RETCODE nodeAssignParent(
    return SCIP_OKAY;
 }
 
-/** decreases number of children of the parent, frees it if no children are left */
+/** frees node memory, decreases number of children of the parent, and replaces node with parent if no children left */
 static
 SCIP_RETCODE nodeReleaseParent(
-   SCIP_NODE*            node,               /**< child node */
+   SCIP_NODE**           node,               /**< child node */
    BMS_BLKMEM*           blkmem,             /**< block memory buffer */
    SCIP_SET*             set,                /**< global SCIP settings */
-   SCIP_STAT*            stat,               /**< problem statistics */
-   SCIP_EVENTQUEUE*      eventqueue,         /**< event queue */
-   SCIP_EVENTFILTER*     eventfilter,        /**< global event filter */
-   SCIP_TREE*            tree,               /**< branch and bound tree */
-   SCIP_LP*              lp                  /**< current LP data */
+   SCIP_TREE*            tree                /**< branch and bound tree */
    )
 {
    SCIP_NODE* parent;
+   SCIP_Bool freeParent = FALSE;
 
-   assert(node != NULL);
-   assert(blkmem != NULL);
    assert(tree != NULL);
+   assert(node != NULL);
+   assert(*node != NULL);
 
    SCIPsetDebugMsg(set, "releasing parent-child relationship of node #%" SCIP_LONGINT_FORMAT " at depth %d of type %d with parent #%" SCIP_LONGINT_FORMAT " of type %d\n",
-      SCIPnodeGetNumber(node), SCIPnodeGetDepth(node), SCIPnodeGetType(node),
-      node->parent != NULL ? SCIPnodeGetNumber(node->parent) : -1,
-      node->parent != NULL ? (int)SCIPnodeGetType(node->parent) : -1);
-   parent = node->parent;
+      SCIPnodeGetNumber(*node), SCIPnodeGetDepth(*node), SCIPnodeGetType(*node),
+      (*node)->parent != NULL ? SCIPnodeGetNumber((*node)->parent) : -1,
+      (*node)->parent != NULL ? (int)SCIPnodeGetType((*node)->parent) : -1);
+   parent = (*node)->parent;
    if( parent != NULL )
    {
-      SCIP_Bool freeParent = FALSE;
-
       switch( SCIPnodeGetType(parent) )
       {
       case SCIP_NODETYPE_FOCUSNODE:
          assert(parent->active);
-         assert(SCIPnodeGetType(node) == SCIP_NODETYPE_CHILD || SCIPnodeGetType(node) == SCIP_NODETYPE_PROBINGNODE
-            || SCIPnodeGetType(node) == SCIP_NODETYPE_LEAF);
-         if( SCIPnodeGetType(node) == SCIP_NODETYPE_CHILD )
-            treeRemoveChild(tree, node);
+         assert(SCIPnodeGetType(*node) == SCIP_NODETYPE_CHILD || SCIPnodeGetType(*node) == SCIP_NODETYPE_PROBINGNODE
+            || SCIPnodeGetType(*node) == SCIP_NODETYPE_LEAF);
+         if( SCIPnodeGetType(*node) == SCIP_NODETYPE_CHILD )
+            treeRemoveChild(tree, *node);
          /* don't kill the focus node at this point => freeParent = FALSE */
          break;
       case SCIP_NODETYPE_PROBINGNODE:
@@ -931,23 +926,18 @@ SCIP_RETCODE nodeReleaseParent(
           * we don't want to free the refocused node, because we first have to convert it back to its original
           * type (where it possibly has children) => freeParent = FALSE
           */
-         assert(SCIPnodeGetType(node) == SCIP_NODETYPE_PROBINGNODE);
+         assert(SCIPnodeGetType(*node) == SCIP_NODETYPE_PROBINGNODE);
          assert(!SCIPtreeProbing(tree));
          break;
       default:
          SCIPerrorMessage("unknown node type %d\n", SCIPnodeGetType(parent));
          return SCIP_INVALIDDATA;
       }
 
-      /* free parent if it is not on the current active path */
-      if( freeParent && !parent->active )
-      {
-         SCIP_CALL( SCIPnodeFree(&node->parent, blkmem, set, stat, eventqueue, eventfilter, tree, lp) );
-      }
       /* update the effective root depth if active parent has children and neither reoptimization nor certificate
        * printing is enabled
        */
-      else if( freeParent == !parent->active && !set->reopt_enable && !SCIPisCertified(set->scip) )
+      if( !freeParent && parent->active && !set->reopt_enable && !SCIPisCertified(set->scip) )
       {
          SCIP_Bool singleChild = FALSE;
          int focusdepth = SCIPtreeGetFocusDepth(tree);
@@ -1005,13 +995,19 @@ SCIP_RETCODE nodeReleaseParent(
 
             SCIPsetDebugMsg(set,
                "unlinked node #%" SCIP_LONGINT_FORMAT " in depth %d -> new effective root depth: %d\n",
-               SCIPnodeGetNumber(node), SCIPnodeGetDepth(node), tree->updatedeffectiverootdepth);
+               SCIPnodeGetNumber(*node), SCIPnodeGetDepth(*node), tree->updatedeffectiverootdepth);
          }
 
          assert(!singleChild || tree->updatedeffectiverootdepth == SCIPtreeGetFocusDepth(tree));
       }
    }
 
+   BMSfreeBlockMemory(blkmem, node);
+
+   /* free parent iteratively if it is not on the current active path */
+   if( freeParent && !parent->active )
+      *node = parent;
+
    return SCIP_OKAY;
 }
 
@@ -1115,7 +1111,7 @@ SCIP_Bool SCIPtreeWasNodeLastBranchParent(
    return FALSE;
 }
 
-/** frees node */
+/** frees node and inactive path iteratively */
 SCIP_RETCODE SCIPnodeFree(
    SCIP_NODE**           node,               /**< node data */
    BMS_BLKMEM*           blkmem,             /**< block memory buffer */
@@ -1129,130 +1125,132 @@ SCIP_RETCODE SCIPnodeFree(
 {
    SCIP_Bool isroot;
 
+   assert(tree != NULL);
    assert(node != NULL);
    assert(*node != NULL);
-   assert(!(*node)->active);
-   assert(blkmem != NULL);
-   assert(tree != NULL);
-
-   SCIPsetDebugMsg(set, "free node #%" SCIP_LONGINT_FORMAT " at depth %d of type %d\n", SCIPnodeGetNumber(*node), SCIPnodeGetDepth(*node), SCIPnodeGetType(*node));
-
-   /* if certificate is active, unsplit current node and free the memory in hashmap of certificate */
-   SCIP_CALL( SCIPcertificatePrintUnsplitting(set, stat->certificate, *node) );
-
-   /* check lower bound w.r.t. debugging solution */
-   SCIP_CALL( SCIPdebugCheckGlobalLowerbound(blkmem, set) );
 
-   if( SCIPnodeGetType(*node) != SCIP_NODETYPE_PROBINGNODE )
+   do
    {
-      SCIP_EVENT event;
+      assert(!(*node)->active);
 
-      /* trigger a node deletion event */
-      SCIP_CALL( SCIPeventChgType(&event, SCIP_EVENTTYPE_NODEDELETE) );
-      SCIP_CALL( SCIPeventChgNode(&event, *node) );
-      SCIP_CALL( SCIPeventProcess(&event, set, NULL, NULL, NULL, eventfilter) );
-   }
+      SCIPsetDebugMsg(set, "free node #%" SCIP_LONGINT_FORMAT " at depth %d of type %d\n", SCIPnodeGetNumber(*node), SCIPnodeGetDepth(*node), SCIPnodeGetType(*node));
 
-   /* inform solution debugger, that the node has been freed */
-   SCIP_CALL( SCIPdebugRemoveNode(blkmem, set, *node) );
+      /* if certificate is active, unsplit current node and free the memory in hashmap of certificate */
+      SCIP_CALL( SCIPcertificatePrintUnsplitting(set, stat->certificate, *node) );
 
-   /* check, if the node to be freed is the root node */
-   isroot = (SCIPnodeGetDepth(*node) == 0);
+      /* check lower bound w.r.t. debugging solution */
+      SCIP_CALL( SCIPdebugCheckGlobalLowerbound(blkmem, set) );
 
-   /* free nodetype specific data, and release no longer needed LPI states */
-   switch( SCIPnodeGetType(*node) )
-   {
-   case SCIP_NODETYPE_FOCUSNODE:
-      assert(tree->focusnode == *node);
-      assert(!SCIPtreeProbing(tree));
-      SCIPerrorMessage("cannot free focus node - has to be converted into a dead end first\n");
-      return SCIP_INVALIDDATA;
-   case SCIP_NODETYPE_PROBINGNODE:
-      assert(SCIPtreeProbing(tree));
-      assert(SCIPnodeGetDepth(tree->probingroot) <= SCIPnodeGetDepth(*node));
-      assert(SCIPnodeGetDepth(*node) > 0);
-      SCIP_CALL( probingnodeFree(&((*node)->data.probingnode), blkmem, lp) );
-      break;
-   case SCIP_NODETYPE_SIBLING:
-      assert((*node)->data.sibling.arraypos >= 0);
-      assert((*node)->data.sibling.arraypos < tree->nsiblings);
-      assert(tree->siblings[(*node)->data.sibling.arraypos] == *node);
-      if( tree->focuslpstatefork != NULL )
+      if( SCIPnodeGetType(*node) != SCIP_NODETYPE_PROBINGNODE )
       {
-         assert(SCIPnodeGetType(tree->focuslpstatefork) == SCIP_NODETYPE_FORK
-            || SCIPnodeGetType(tree->focuslpstatefork) == SCIP_NODETYPE_SUBROOT);
-         SCIP_CALL( SCIPnodeReleaseLPIState(tree->focuslpstatefork, blkmem, lp) );
-      }
-      treeRemoveSibling(tree, *node);
-      break;
-   case SCIP_NODETYPE_CHILD:
-      assert((*node)->data.child.arraypos >= 0);
-      assert((*node)->data.child.arraypos < tree->nchildren);
-      assert(tree->children[(*node)->data.child.arraypos] == *node);
-      /* The children capture the LPI state at the moment, where the focus node is
-       * converted into a junction, pseudofork, fork, or subroot, and a new node is focused.
-       * At the same time, they become siblings or leaves, such that freeing a child
-       * of the focus node doesn't require to release the LPI state;
-       * we don't need to call treeRemoveChild(), because this is done in nodeReleaseParent()
-       */
-      break;
-   case SCIP_NODETYPE_LEAF:
-      if( (*node)->data.leaf.lpstatefork != NULL )
-      {
-         SCIP_CALL( SCIPnodeReleaseLPIState((*node)->data.leaf.lpstatefork, blkmem, lp) );
+         SCIP_EVENT event;
+
+         /* trigger a node deletion event */
+         SCIP_CALL( SCIPeventChgType(&event, SCIP_EVENTTYPE_NODEDELETE) );
+         SCIP_CALL( SCIPeventChgNode(&event, *node) );
+         SCIP_CALL( SCIPeventProcess(&event, set, NULL, NULL, NULL, eventfilter) );
       }
-      break;
-   case SCIP_NODETYPE_DEADEND:
-   case SCIP_NODETYPE_JUNCTION:
-      break;
-   case SCIP_NODETYPE_PSEUDOFORK:
-      SCIP_CALL( pseudoforkFree(&((*node)->data.pseudofork), blkmem, set, lp) );
-      break;
-   case SCIP_NODETYPE_FORK:
 
-      /* release special root LPI state capture which is used to keep the root LPI state over the whole solving
-       * process
-       */
-      if( isroot )
+      /* inform solution debugger, that the node has been freed */
+      SCIP_CALL( SCIPdebugRemoveNode(blkmem, set, *node) );
+
+      /* check, if the node to be freed is the root node */
+      isroot = (SCIPnodeGetDepth(*node) == 0);
+
+      /* free nodetype specific data, and release no longer needed LPI states */
+      switch( SCIPnodeGetType(*node) )
       {
-         SCIP_CALL( SCIPnodeReleaseLPIState(*node, blkmem, lp) );
+         case SCIP_NODETYPE_FOCUSNODE:
+            assert(tree->focusnode == *node);
+            assert(!SCIPtreeProbing(tree));
+            SCIPerrorMessage("cannot free focus node - has to be converted into a dead end first\n");
+            return SCIP_INVALIDDATA;
+         case SCIP_NODETYPE_PROBINGNODE:
+            assert(SCIPtreeProbing(tree));
+            assert(SCIPnodeGetDepth(tree->probingroot) <= SCIPnodeGetDepth(*node));
+            assert(SCIPnodeGetDepth(*node) > 0);
+            SCIP_CALL( probingnodeFree(&((*node)->data.probingnode), blkmem, lp) );
+            break;
+         case SCIP_NODETYPE_SIBLING:
+            assert((*node)->data.sibling.arraypos >= 0);
+            assert((*node)->data.sibling.arraypos < tree->nsiblings);
+            assert(tree->siblings[(*node)->data.sibling.arraypos] == *node);
+            if( tree->focuslpstatefork != NULL )
+            {
+               assert(SCIPnodeGetType(tree->focuslpstatefork) == SCIP_NODETYPE_FORK
+                  || SCIPnodeGetType(tree->focuslpstatefork) == SCIP_NODETYPE_SUBROOT);
+               SCIP_CALL( SCIPnodeReleaseLPIState(tree->focuslpstatefork, blkmem, lp) );
+            }
+            treeRemoveSibling(tree, *node);
+            break;
+         case SCIP_NODETYPE_CHILD:
+            assert((*node)->data.child.arraypos >= 0);
+            assert((*node)->data.child.arraypos < tree->nchildren);
+            assert(tree->children[(*node)->data.child.arraypos] == *node);
+            /* The children capture the LPI state at the moment, where the focus node is
+             * converted into a junction, pseudofork, fork, or subroot, and a new node is focused.
+             * At the same time, they become siblings or leaves, such that freeing a child
+             * of the focus node doesn't require to release the LPI state;
+             * we don't need to call treeRemoveChild(), because this is done in nodeReleaseParent()
+             */
+            break;
+         case SCIP_NODETYPE_LEAF:
+            if( (*node)->data.leaf.lpstatefork != NULL )
+            {
+               SCIP_CALL( SCIPnodeReleaseLPIState((*node)->data.leaf.lpstatefork, blkmem, lp) );
+            }
+            break;
+         case SCIP_NODETYPE_DEADEND:
+         case SCIP_NODETYPE_JUNCTION:
+            break;
+         case SCIP_NODETYPE_PSEUDOFORK:
+            SCIP_CALL( pseudoforkFree(&((*node)->data.pseudofork), blkmem, set, lp) );
+            break;
+         case SCIP_NODETYPE_FORK:
+            /* release special root LPI state capture which is used to keep the root LPI state over the whole solving
+             * process
+             */
+            if( isroot )
+            {
+               SCIP_CALL( SCIPnodeReleaseLPIState(*node, blkmem, lp) );
+            }
+            SCIP_CALL( forkFree(&((*node)->data.fork), blkmem, set, lp) );
+            break;
+         case SCIP_NODETYPE_SUBROOT:
+            SCIP_CALL( subrootFree(&((*node)->data.subroot), blkmem, set, lp) );
+            break;
+         case SCIP_NODETYPE_REFOCUSNODE:
+            SCIPerrorMessage("cannot free node as long it is refocused\n");
+            return SCIP_INVALIDDATA;
+         default:
+            SCIPerrorMessage("unknown node type %d\n", SCIPnodeGetType(*node));
+            return SCIP_INVALIDDATA;
       }
-      SCIP_CALL( forkFree(&((*node)->data.fork), blkmem, set, lp) );
-      break;
-   case SCIP_NODETYPE_SUBROOT:
-      SCIP_CALL( subrootFree(&((*node)->data.subroot), blkmem, set, lp) );
-      break;
-   case SCIP_NODETYPE_REFOCUSNODE:
-      SCIPerrorMessage("cannot free node as long it is refocused\n");
-      return SCIP_INVALIDDATA;
-   default:
-      SCIPerrorMessage("unknown node type %d\n", SCIPnodeGetType(*node));
-      return SCIP_INVALIDDATA;
-   }
 
-   /* free common data */
-   SCIP_CALL( SCIPconssetchgFree(&(*node)->conssetchg, blkmem, set) );
-   SCIP_CALL( SCIPdomchgFree(&(*node)->domchg, blkmem, set, eventqueue, lp) );
-   SCIP_CALL( nodeReleaseParent(*node, blkmem, set, stat, eventqueue, eventfilter, tree, lp) );
+      /* free common data */
+      SCIP_CALL( SCIPconssetchgFree(&(*node)->conssetchg, blkmem, set) );
+      SCIP_CALL( SCIPdomchgFree(&(*node)->domchg, blkmem, set, eventqueue, lp) );
 
-   /* check, if the node is the current probing root */
-   if( *node == tree->probingroot )
-   {
-      assert(SCIPnodeGetType(*node) == SCIP_NODETYPE_PROBINGNODE);
-      tree->probingroot = NULL;
-   }
+      /* check, if the node is the current probing root */
+      if( *node == tree->probingroot )
+      {
+         assert(SCIPnodeGetType(*node) == SCIP_NODETYPE_PROBINGNODE);
+         tree->probingroot = NULL;
+      }
 
-   if( set->exact_enable )
-      SCIPrationalFreeBlock(blkmem, &(*node)->lowerboundexact);
+      if( set->exact_enable )
+         SCIPrationalFreeBlock(blkmem, &(*node)->lowerboundexact);
 
-   BMSfreeBlockMemory(blkmem, node);
+      /* delete the tree's root node pointer, if the freed node was the root */
+      if( isroot )
+         tree->root = NULL;
 
-   /* delete the tree's root node pointer, if the freed node was the root */
-   if( isroot )
-      tree->root = NULL;
+      SCIP_CALL( nodeReleaseParent(node, blkmem, set, tree) );
+   }
+   while( *node != NULL );
 
    return SCIP_OKAY;
-}
+} /*lint !e715*/
 
 /** cuts off node and whole sub tree from branch and bound tree
  *
diff --git a/src/scip/tree.h b/src/scip/tree.h

Original file line number	Diff line number	Diff line change
`@@ -177,7 +177,7 @@ SCIP_RETCODE SCIPstatFree(`
`177`	`177`	`return SCIP_OKAY;`
`178`	`178`	`}`
`179`	`179`
`180`		`-/** diables the collection of any statistic for a variable */`
	`180`	`+/** disables the collection of any statistic for a variable */`
`181`	`181`	`void SCIPstatDisableVarHistory(`
`182`	`182`	`SCIP_STAT* stat /*< problem statistics data /`
`183`	`183`	`)`