1. model optimize without gil

2.  model addOrigVarsConssObjectiveFrom
3.  add some Solution methods

Author: Light1Lee

CHANGELOG.md

@@ -17,8 +17,9 @@
 - Added additional tests to test_nodesel, test_heur, and test_strong_branching
 - Migrated documentation to Readthedocs
 - `attachEventHandlerCallback` method to Model for a more ergonomic way to attach event handlers
-- Added optimalNogil, getSolOrigin, retransform, copyModel, solveFirstInterruptOthers
-- Added SCIPsolve nogil, SCIPretransformSol, SCIPtranslateSubSol, SCIPsolGetOrigin, SCIPcopyOrigProb, SCIPcopyOrigVars, SCIPcopyOrigConss, SCIPhashmapCreate, SCIPhashmapFree
+- Added Model method: optimizeNogil, addOrigVarsConssObjectiveFrom
+- Added Solution method: getSolOrigin, retransform, translate
+- Added SCIP.pxd: SCIP_SOLORIGIN, SCIPcopyOrigVars, SCIPcopyOrigConss, SCIPsolve nogil, SCIPretransformSol, SCIPtranslateSubSol, SCIPsolGetOrigin, SCIPhashmapCreate, SCIPhashmapFree
 - Added additional tests to test_multi_threads, test_solution, and test_copy
 ### Fixed
 - Fixed too strict getObjVal, getVal check

src/pyscipopt/scip.pxd

@@ -543,7 +543,6 @@ cdef extern from "scip/scip.h":
                               SCIP_Bool             threadsafe,
                               SCIP_Bool             passmessagehdlr,
                               SCIP_Bool*            valid)
-    SCIP_RETCODE SCIPcopyOrigProb(SCIP* sourcescip, SCIP* targetscip, SCIP_HASHMAP* varmap, SCIP_HASHMAP* consmap, const char* name )
     SCIP_RETCODE SCIPcopyOrigVars(SCIP* sourcescip, SCIP* targetscip, SCIP_HASHMAP* varmap, SCIP_HASHMAP* consmap, SCIP_VAR** fixedvars, SCIP_Real* fixedvals, int nfixedvars )
     SCIP_RETCODE SCIPcopyOrigConss(SCIP* sourcescip, SCIP* targetscip, SCIP_HASHMAP* varmap, SCIP_HASHMAP* consmap, SCIP_Bool enablepricing, SCIP_Bool* valid)
     SCIP_RETCODE SCIPmessagehdlrCreate(SCIP_MESSAGEHDLR **messagehdlr,

src/pyscipopt/scip.pxi

@@ -15,10 +15,9 @@ from libc.stdlib cimport malloc, free
 from libc.stdio cimport fdopen, fclose
 from posix.stdio cimport fileno
 
-from collections.abc import Iterable, Sequence
+from collections.abc import Iterable
 from itertools import repeat
 from dataclasses import dataclass
-from concurrent.futures import ThreadPoolExecutor, as_completed
 
 include "expr.pxi"
 include "lp.pxi"
@@ -1034,6 +1033,27 @@ cdef class Solution:
         """ retransforms solution to original problem space """
         PY_SCIP_CALL(SCIPretransformSol(self.scip, self.sol))
 
+    def translate(self, Model target):
+        """
+        translate solution to a target model solution
+
+        Parameters
+        ----------
+        target : Model
+
+        Returns
+        -------
+        targetSol: Solution
+        """
+        if self.getSolOrigin() != SCIP_SOLORIGIN_ORIGINAL:
+            PY_SCIP_CALL(SCIPretransformSol(self.scip, self.sol))
+        cdef Solution targetSol = Solution.create(target._scip, NULL)
+        cdef SCIP_VAR** source_vars = SCIPgetOrigVars(self.scip)
+        
+        PY_SCIP_CALL(SCIPtranslateSubSol(target._scip, self.scip, self.sol, NULL, source_vars, &(targetSol.sol)))
+        return targetSol
+
+
 cdef class BoundChange:
     """Bound change."""
 
@@ -2074,38 +2094,28 @@ cdef class Model:
         n = str_conversion(problemName)
         PY_SCIP_CALL(SCIPcreateProbBasic(self._scip, n))
 
-    def copyModel(self, problemName='copy_model'):
+    def addOrigVarsConssObjectiveFrom(self, Model source):
         """
-        Create a copy of the model/problem.
+        add original variables and constraints from source model.
 
         Parameters
         ----------
-        problemName : str, optional
-            name of model or problem (Default value = 'model')
-
+        source : Model
+            source model copy original variables and constraints to target(self) model
         """
-        cdef Model cpy
         cdef SCIP_Bool valid
         cdef SCIP_HASHMAP* localvarmap
         cdef SCIP_HASHMAP* localconsmap
 
-        cpy = Model(createscip=False)
-        PY_SCIP_CALL(SCIPcreate(&cpy._scip))
-        cpy._bestSol = None
-        cpy.includeDefaultPlugins()
-        # cpy._bestSol = <Solution> model._bestSol
-        cname = str_conversion(problemName)
+        PY_SCIP_CALL( SCIPhashmapCreate(&localvarmap, SCIPblkmem(self._scip), SCIPgetNVars(source._scip)) )
+        PY_SCIP_CALL( SCIPhashmapCreate(&localconsmap, SCIPblkmem(self._scip), SCIPgetNConss(source._scip)) )
 
-        PY_SCIP_CALL( SCIPhashmapCreate(&localvarmap, SCIPblkmem(cpy._scip), SCIPgetNVars(self._scip)) )
-        PY_SCIP_CALL( SCIPhashmapCreate(&localconsmap, SCIPblkmem(cpy._scip), SCIPgetNConss(self._scip)) )
-
-        PY_SCIP_CALL(SCIPcopyOrigProb(self._scip, cpy._scip, localvarmap, localconsmap, cname))
-        PY_SCIP_CALL(SCIPcopyOrigVars(self._scip, cpy._scip, localvarmap, localconsmap, NULL, NULL, 0))
-        PY_SCIP_CALL(SCIPcopyOrigConss(self._scip, cpy._scip, localvarmap, localconsmap, False, &valid))
+        PY_SCIP_CALL(SCIPcopyOrigVars(source._scip, self._scip, localvarmap, localconsmap, NULL, NULL, 0))
+        PY_SCIP_CALL(SCIPcopyOrigConss(source._scip, self._scip, localvarmap, localconsmap, False, &valid))
+        PY_SCIP_CALL(SCIPsetObjsense(self._scip, SCIPgetObjsense(source._scip)))
 
         SCIPhashmapFree(&localvarmap)
         SCIPhashmapFree(&localconsmap)
-        return cpy
 
     def freeProb(self):
         """Frees problem and solution process data."""
@@ -6227,36 +6237,6 @@ cdef class Model:
         PY_SCIP_CALL(rc)
         self._bestSol = Solution.create(self._scip, SCIPgetBestSol(self._scip))
 
-    @staticmethod
-    def solveFirstInterruptOthers(executor: ThreadPoolExecutor, models: Sequence[Model]) -> Tuple[int, Model]:
-        """
-        Solve models return the first solved model and interrupt other models.
-        
-        Parameters
-        ----------
-        executor : ThreadPoolExecutor
-        models: Sequence[Model]
-
-        Returns
-        -------
-        first_seq : int
-            returns the index of the first resolved model from models
-        models[first_idx] : Model
-            returns the first resolved model 
-        """
-        futures = [executor.submit(Model.optimizeNogil, model) for model in models]
-        interrupt_callback = lambda model: model.interruptSolve()
-        for future in as_completed(futures):
-            first_future = future
-            break
-        for idx, furture_to_cancel in enumerate(futures):
-            if furture_to_cancel != first_future:
-                interrupt_callback(models[idx])
-                furture_to_cancel.cancel()
-            else:
-                first_idx = idx
-        return first_idx, models[first_idx]
-
     def solveConcurrent(self):
         """Transforms, presolves, and solves problem using additional solvers which emphasize on
         finding solutions.
@@ -8121,23 +8101,6 @@ cdef class Model:
             PY_SCIP_CALL(SCIPaddSol(self._scip, solution.sol, &stored))
         return stored
 
-    def addCopyModelSol(self, Solution solution):
-        if solution.getSolOrigin() != SCIP_SOLORIGIN_ORIGINAL:
-            PY_SCIP_CALL(SCIPretransformSol(solution.scip, solution.sol))
-        cdef Solution newsol = Solution.create(self._scip, NULL)
-        cdef SCIP_VAR** subvars = SCIPgetOrigVars(solution.scip)
-        SCIPtranslateSubSol(self._scip, solution.scip, solution.sol, NULL, subvars, &(newsol.sol))
-        self.addSol(newsol, free=True)
-
-    def addCopyModelBestSol(self, Model cpy_model):
-        solution = cpy_model.getBestSol()
-        self.addCopyModelSol(solution)
-        
-    def addCopyModelSols(self, Model cpy_model):
-        solutions = cpy_model.getSols()
-        for solution in solutions:
-            self.addCopyModelSol(solution)
-
     def freeSol(self, Solution solution):
         """
         Free given solution

tests/test_copy.py

@@ -1,7 +1,6 @@
 from pyscipopt import Model
 from helpers.utils import random_mip_1
 
-
 def test_copy():
     # create solver instance
     s = Model()
@@ -22,47 +21,21 @@ def test_copy():
     assert s.getObjVal() == s2.getObjVal()
 
 
-def test_copyModel():
-    ori_model = random_mip_1(disable_sepa=False, disable_huer=False, disable_presolve=False, node_lim=2000, small=False) 
-    cpy_model = ori_model.copyModel()
-    sub_model = Model(sourceModel=ori_model)
-    
-    assert len(ori_model.getParams()) == len(cpy_model.getParams()) > len(sub_model.getParams())
-    assert ori_model.getNVars() == cpy_model.getNVars()
-    assert ori_model.getNConss() == cpy_model.getNConss()
-
-    ori_model.optimize()
-    cpy_model.optimize()
-    assert ori_model.getStatus() == cpy_model.getStatus() == "optimal"
-    assert ori_model.getObjVal() == cpy_model.getObjVal()
-
-
-def test_addCopyModelSol_BestSol_Sols():
-    ori_model = random_mip_1(disable_sepa=False, disable_huer=False, disable_presolve=False, node_lim=2000, small=False)
-    cpy_model0 = ori_model.copyModel()
-    cpy_model1 = ori_model.copyModel()
-    cpy_model2 = ori_model.copyModel()
-    
-    ori_model.optimize()
-    solution = ori_model.getBestSol()
+def test_addOrigVarsConssObjectiveFrom():
+    m = Model()
+    x = m.addVar("x", vtype = 'B')
+    y = m.addVar("y", vtype = 'B')
+    m.addCons(x + y >= 1)
+    m.addCons(x + y <= 2)
+    m.setObjective(x + y, 'maximize')
 
-    cpy_model0.addCopyModelSol(solution)
-    cpy_model1.addCopyModelBestSol(ori_model)
-    cpy_model2.addCopyModelSols(ori_model)
+    m1 = Model()
+    m1.addOrigVarsConssObjectiveFrom(m)
 
-    assert cpy_model0.getNSols() == 1
-    assert cpy_model1.getNSols() == 1
-    assert cpy_model2.getNSols() == ori_model.getNSols() >= 1
+    m.optimize()
+    m1.optimize()
 
-    cpy_model0.optimize()
-    cpy_model1.optimize()
-    cpy_model2.optimize()
+    assert m.getNVars(transformed=False) == m1.getNVars(transformed=False)
+    assert m.getNConss(transformed=False) == m1.getNConss(transformed=False)
+    assert m.getObjVal() == m1.getObjVal() == 2 
 
-    assert ori_model.getStatus() == "optimal"
-    assert cpy_model0.getStatus() == "optimal"
-    assert cpy_model1.getStatus() == "optimal"
-    assert cpy_model2.getStatus() == "optimal"
-    assert abs(ori_model.getObjVal() - cpy_model0.getObjVal()) < 1e-6
-    assert abs(ori_model.getObjVal() - cpy_model1.getObjVal()) < 1e-6
-    assert abs(ori_model.getObjVal() - cpy_model2.getObjVal()) < 1e-6
-    

tests/test_multi_threads.py renamed to tests/test_nogil.py

@@ -7,7 +7,7 @@
 
 def test_optimalNogil():
     ori_model = random_mip_1(disable_sepa=False, disable_huer=False, disable_presolve=False, node_lim=2000, small=True) 
-    models = [ori_model.copyModel() for _ in range(N_Threads)]
+    models = [Model(sourceModel=ori_model) for _ in range(N_Threads)]
     for i in range(N_Threads):
         models[i].setParam("randomization/permutationseed", i)
 
@@ -21,16 +21,3 @@ def test_optimalNogil():
             assert model.getStatus() == "optimal"    
             assert abs(ori_model.getObjVal() - model.getObjVal()) < 1e-6
 
-
-def test_solveFirstInterruptOthers():
-    ori_model = random_mip_1(disable_sepa=False, disable_huer=False, disable_presolve=False, node_lim=2000, small=True) 
-    models = [ori_model.copyModel() for _ in range(N_Threads)]
-    for i in range(N_Threads):
-        models[i].setParam("randomization/permutationseed", i)
-
-    ori_model.optimize()
-    
-    with ThreadPoolExecutor(max_workers=N_Threads) as executor:
-        seq, fast_model = Model.solveFirstInterruptOthers(executor=executor, models=models) #
-        assert fast_model.getStatus() == "optimal"
-        assert abs(ori_model.getObjVal() - fast_model.getObjVal()) < 1e-6

tests/test_solution.py

@@ -206,3 +206,16 @@ def test_getSolOrigin_retrasform():
     sol.retransform()
     assert sol.getSolOrigin() == SCIP_SOLORIGIN.ORIGINAL
 
+
+def test_translate():
+    m = random_mip_1(disable_sepa=False, disable_huer=False, disable_presolve=False, small=True)
+    m.optimize()
+    sol = m.getBestSol()
+
+    m1 = random_mip_1(disable_sepa=False, disable_huer=False, disable_presolve=False, small=True)
+    sol1 = sol.translate(m1)
+    assert m1.addSol(sol1) == True
+    assert m1.getNSols() == 1
+    m1.optimize()
+    assert m.getObjVal() == m1.getObjVal()
+