Add Option To Kill CBC if it Hangs

pulp/apis/coin_api.py

@@ -24,13 +24,14 @@
 # TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
 # SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE."""
 
-from .core import LpSolver_CMD, LpSolver, subprocess, PulpSolverError, clock, log
+from .core import LpSolver_CMD, LpSolver, subprocess, PulpSolverError, PulpTimeoutError, clock, log
 from .core import cbc_path, pulp_cbc_path, coinMP_path, devnull, operating_system
 import os
 from .. import constants
 from tempfile import mktemp
 import ctypes
 import warnings
+from threading import Timer
 
 
 class COIN_CMD(LpSolver_CMD):
@@ -64,6 +65,7 @@ def __init__(
         timeMode="elapsed",
         mip_start=False,
         maxNodes=None,
+        killOnTimeLimit=False,
     ):
         """
         :param bool mip: if False, assume LP even if integer variables
@@ -85,6 +87,7 @@ def __init__(
         :param str timeMode: "elapsed": count wall-time to timeLimit; "cpu": count cpu-time
         :param bool mip_start: deprecated for warmStart
         :param int maxNodes: max number of nodes during branching. Stops the solving when reached.
+        :param bool killOnTimeLimit: If the solver takes more than 10 seconds than the time limit to stop, kill it and raise an error.
         """
 
         if fracGap is not None:
@@ -127,6 +130,7 @@ def __init__(
             logPath=logPath,
             timeMode=timeMode,
             maxNodes=maxNodes,
+            killOnTimeLimit=killOnTimeLimit,
         )
 
     def copy(self):
@@ -203,13 +207,33 @@ def solve_CBC(self, lp, use_mps=True):
             )
         else:
             cbc = subprocess.Popen(args, stdout=pipe, stderr=pipe, stdin=devnull)
-        if cbc.wait() != 0:
-            if pipe:
-                pipe.close()
-            raise PulpSolverError(
-                "Pulp: Error while trying to execute, use msg=True for more details"
-                + self.path
-            )
+
+        # Optionally implement a timeout that kills the process if it takes too long
+        timer = None
+        if self.optionsDict.get('killOnTimeLimit', False) and self.timeLimit is not None:
+            # Give the solver a buffer above the time limit before we kill it
+            # since it's better for the solver to timeout gracefully
+            buffer_time = 10 
+            timer = Timer(self.timeLimit + buffer_time, cbc.kill)
+            timer.start()
+
+        try:
+            exit_code = cbc.wait()
+            if exit_code != 0:
+                if pipe:
+                    pipe.close()
+                if exit_code == -9 and timer is not None:
+                    raise PulpTimeoutError(
+                        f"Pulp: CBC Solver timed out after {self.timeLimit} seconds"
+                    )
+                else:
+                    raise PulpSolverError(
+                        f"Pulp: Error while trying to execute, use msg=True for more details {self.path}"
+                    )
+        finally:
+            if timer is not None:
+                timer.cancel()
+
         if pipe:
             pipe.close()
         if not os.path.exists(tmpSol):
@@ -392,6 +416,7 @@ def __init__(
             logPath=None,
             mip_start=False,
             timeMode="elapsed",
+            killOnTimeLimit=False,
         ):
             if path is not None:
                 raise PulpSolverError("Use COIN_CMD if you want to set a path")
@@ -416,6 +441,7 @@ def __init__(
                 logPath=logPath,
                 mip_start=mip_start,
                 timeMode=timeMode,
+                killOnTimeLimit=killOnTimeLimit
             )
 
 

pulp/apis/core.py

@@ -71,6 +71,12 @@ class PulpSolverError(const.PulpError):
 
     pass
 
+class PulpTimeoutError(PulpSolverError):
+    """
+    Exception that's raised when we have to kill a solver due to time limit
+    """
+    pass
+
 
 # import configuration information
 def initialize(filename, operating_system="linux", arch="64"):
@@ -210,7 +216,7 @@ def __init__(
         self.timeLimit = timeLimit
 
         # here we will store all other relevant information including:
-        # gapRel, gapAbs, maxMemory, maxNodes, threads, logPath, timeMode
+        # gapRel, gapAbs, maxMemory, maxNodes, threads, logPath, timeMode, killOnTimeLimit
         self.optionsDict = {k: v for k, v in kwargs.items() if v is not None}
 
     def available(self):