Merge pull request #131 from bknueven/issue3

adding function for set_instance retries

Author: DLWoodruff

doc/src/scenario_creator.rst

@@ -53,7 +53,7 @@ assumed to be equally likely.
 EF Supplement List
 ------------------
 
-The function ``attach_root_node`` takes an optional argument ``nonant_ef_supple_list`` (that is passed through to the ``ScenarioNode`` constructor). This is a list similar to the nonanticipate Var list. These variables will not be given
+The function ``attach_root_node`` takes an optional argument ``nonant_ef_suppl_list`` (that is passed through to the ``ScenarioNode`` constructor). This is a list similar to the nonanticipate Var list. These variables will not be given
 multipliers by algorithms such as PH, but will be given non-anticipativity
 constraints when an EF is formed, either to solve the EF or when bundles are
 formed. For some problems, with the appropriate solver, adding redundant nonanticipativity constraints

examples/afew.py

@@ -43,6 +43,10 @@ def do_one(dirname, progname, np, argstring):
        "3 --bundles-per-rank=0 --max-iterations=50 "
        "--default-rho=1 --with-display-convergence-detail "
        "--solver-name={} --no-fwph --use-norm-rho-updater".format(solver_name))
+do_one("farmer", "farmer_lshapedhub.py", 2,
+       "3 --bundles-per-rank=0 --max-iterations=50 "
+       "--solver-name={} --rel-gap=0.0 "
+       "--no-fwph --max-solver-threads=1".format(solver_name))
 do_one("sizes",
        "sizes_cylinders.py",
        4,

mpisppy/opt/lshaped.py

@@ -12,6 +12,7 @@
 from pyomo.core.plugins.transform.discrete_vars import RelaxIntegerVars
 from mpisppy.utils.sputils import find_active_objective
 from mpisppy.utils.lshaped_cuts import LShapedCutGenerator
+from mpisppy.spopt import set_instance_retry
 from pyomo.core import (
     Objective, SOSConstraint, Constraint, Var
 )
@@ -456,7 +457,7 @@ def create_subproblem(self, scenario_name):
                     opt.options[k] = v
 
             if sputils.is_persistent(opt):
-                opt.set_instance(instance)
+                set_instance_retry(instance, opt, scenario_name)
                 res = opt.solve(tee=False)
             else:
                 res = opt.solve(instance, tee=False)
@@ -578,7 +579,7 @@ def lshaped_algorithm(self, converger=None):
 
             is_persistent = sputils.is_persistent(opt)
             if is_persistent:
-                opt.set_instance(m)
+                set_instance_retry(m, opt, "root")
 
         t = time.time()
         res, t1, t2 = None, None, None

mpisppy/spopt.py

@@ -767,36 +767,7 @@ def _create_solvers(self):
                 if dtiming:
                     set_instance_start_time = time.time()
 
-                # this loop is required to address the sitution where license
-                # token servers become temporarily over-subscribed / non-responsive
-                # when large numbers of ranks are in use.
-
-                # these parameters should eventually be promoted to a non-PH
-                # general class / location. even better, the entire retry
-                # logic can be encapsulated in a sputils.py function.
-                MAX_ACQUIRE_LICENSE_RETRY_ATTEMPTS = 5
-                LICENSE_RETRY_SLEEP_TIME = 2 # in seconds
-        
-                num_retry_attempts = 0
-                while True:
-                    try:
-                        s._solver_plugin.set_instance(s)
-                        if num_retry_attempts > 0:
-                            print("Acquired solver license (call to set_instance() for scenario=%s) after %d retry attempts" % (sname, num_retry_attempts))
-                        break
-                    # pyomo presently has no general way to trap a license acquisition
-                    # error - so we're stuck with trapping on "any" exception. not ideal.
-                    except:
-                        if num_retry_attempts == 0:
-                            print("Failed to acquire solver license (call to set_instance() for scenario=%s) after first attempt" % (sname))
-                        else:
-                            print("Failed to acquire solver license (call to set_instance() for scenario=%s) after %d retry attempts" % (sname, num_retry_attempts))
-                        if num_retry_attempts == MAX_ACQUIRE_LICENSE_RETRY_ATTEMPTS:
-                            raise RuntimeError("Failed to acquire solver license - call to set_instance() for scenario=%s failed after %d retry attempts" % (sname, num_retry_attempts))
-                        else:
-                            print("Sleeping for %d seconds before re-attempting" % LICENSE_RETRY_SLEEP_TIME)
-                            time.sleep(LICENSE_RETRY_SLEEP_TIME)
-                            num_retry_attempts += 1
+                set_instance_retry(s, s._solver_plugin, sname)
 
                 if dtiming:
                     set_instance_time = time.time() - set_instance_start_time
@@ -816,3 +787,38 @@ def _create_solvers(self):
                 for scen_name in s.scen_list:
                     scen = self.local_scenarios[scen_name]
                     scen._solver_plugin = s._solver_plugin
+
+
+# these parameters should eventually be promoted to a non-PH
+# general class / location. even better, the entire retry
+# logic can be encapsulated in a sputils.py function.
+MAX_ACQUIRE_LICENSE_RETRY_ATTEMPTS = 5
+LICENSE_RETRY_SLEEP_TIME = 2 # in seconds
+
+def set_instance_retry(subproblem, solver_plugin, subproblem_name):
+
+    sname = subproblem_name
+    # this loop is required to address the sitution where license
+    # token servers become temporarily over-subscribed / non-responsive
+    # when large numbers of ranks are in use.
+
+    num_retry_attempts = 0
+    while True:
+        try:
+            solver_plugin.set_instance(subproblem)
+            if num_retry_attempts > 0:
+                print("Acquired solver license (call to set_instance() for scenario=%s) after %d retry attempts" % (sname, num_retry_attempts))
+            break
+        # pyomo presently has no general way to trap a license acquisition
+        # error - so we're stuck with trapping on "any" exception. not ideal.
+        except:
+            if num_retry_attempts == 0:
+                print("Failed to acquire solver license (call to set_instance() for scenario=%s) after first attempt" % (sname))
+            else:
+                print("Failed to acquire solver license (call to set_instance() for scenario=%s) after %d retry attempts" % (sname, num_retry_attempts))
+            if num_retry_attempts == MAX_ACQUIRE_LICENSE_RETRY_ATTEMPTS:
+                raise RuntimeError("Failed to acquire solver license - call to set_instance() for scenario=%s failed after %d retry attempts" % (sname, num_retry_attempts))
+            else:
+                print("Sleeping for %d seconds before re-attempting" % LICENSE_RETRY_SLEEP_TIME)
+                time.sleep(LICENSE_RETRY_SLEEP_TIME)
+                num_retry_attempts += 1

mpisppy/utils/lshaped_cuts.py

@@ -5,6 +5,8 @@
 from pyomo.solvers.plugins.solvers.persistent_solver import PersistentSolver
 import pyomo.contrib.benders.benders_cuts as bc
 
+from mpisppy.spopt import set_instance_retry
+
 try:
     from mpi4py import MPI
 
@@ -77,7 +79,7 @@ def add_subproblem(self, subproblem_fn, subproblem_fn_kwargs, root_eta, subprobl
                 subproblem_solver = pe.SolverFactory(subproblem_solver)
             self.subproblem_solvers.append(subproblem_solver)
             if isinstance(subproblem_solver, PersistentSolver):
-                subproblem_solver.set_instance(subproblem)
+                set_instance_retry(subproblem, subproblem_solver, subproblem_fn_kwargs['scenario_name'])
             if subproblem_solver_options:
                 for k,v in subproblem_solver_options.items():
                     subproblem_solver.options[k] = v