Restore the optimizer LOA displaces; refuse to re-solve its result cache

Author: dnguyen227

src/datatypes.jl

@@ -739,9 +739,9 @@ mutable struct GDPData{M <: JuMP.AbstractModel, V <: JuMP.AbstractVariableRef, C
     # Solution data
     solution_method::Union{Nothing, AbstractSolutionMethod}
     ready_to_optimize::Bool
-    # Real solver stashed by an LOA solve so a later reformulation
-    # re-solve can replace the injected solution optimizer.
-    loa_solver::Any
+    # The optimizer an LOA solve displaced (it solves the NLP in place),
+    # stashed so a later reformulation re-solve can put it back.
+    displaced_optimizer::Any
 
     # Default constructor
     function GDPData{M, V, C}() where {M <: JuMP.AbstractModel, V <: JuMP.AbstractVariableRef, C}

src/loa.jl

@@ -42,7 +42,8 @@ function _optimize_hook(model::JuMP.AbstractModel, method::LOA; kwargs...)
     master = _build_loa_master(problem, method)
     _relax_binaries(problem)
     nlp = problem.nlp
-    JuMP.set_optimizer(nlp, method.nlp_optimizer)
+    displaced_optimizer = _install_nlp_optimizer(nlp, method.nlp_optimizer,
+        gdp_data(model).displaced_optimizer)
     JuMP.set_silent(nlp)
     t_start = time()
     overall_deadline = t_start + method.time_limit
@@ -181,7 +182,8 @@ function _optimize_hook(model::JuMP.AbstractModel, method::LOA; kwargs...)
     end
     outcome = (results = feasible_results, status = status,
         raw_status = message, bound = bound,
-        solve_time = time() - t_start, solver_name = solver)
+        solve_time = time() - t_start, solver_name = solver,
+        displaced_optimizer = displaced_optimizer)
     # Injection is not a reformulation; a later method must rebuild.
     _set_solution_method(model, method)
     _set_ready_to_optimize(model, false)
@@ -402,6 +404,50 @@ function _restore_binaries(problem::_LOAProblem)
     return
 end
 
+################################################################################
+#                         OPTIMIZER HANDOVER
+################################################################################
+# Install the NLP solver, returning the optimizer it displaces. LOA
+# solves the NLP on the model itself, so that one is the user's own. A
+# re-solve displaces the last run's cache instead, so `previous` (the
+# optimizer already stashed) carries through untouched.
+function _install_nlp_optimizer(
+    nlp::JuMP.AbstractModel,
+    nlp_optimizer,
+    previous
+    )
+    backend = JuMP.backend(nlp)
+    displaced = if backend isa _MOI.Utilities.CachingOptimizer &&
+            backend.optimizer !== nothing
+        JuMP.unsafe_backend(nlp)
+    else
+        nothing
+    end
+    JuMP.set_optimizer(nlp, nlp_optimizer)
+    return displaced isa _LOAResultCache ? previous : displaced
+end
+
+# Model types without a MOI backend of their own never carry a cache.
+function _has_loa_cache(model::JuMP.GenericModel)
+    backend = JuMP.backend(model)
+    return backend isa _MOI.Utilities.CachingOptimizer &&
+        backend.optimizer isa _LOAResultCache
+end
+_has_loa_cache(::JuMP.AbstractModel) = false
+
+# Restore the displaced optimizer, emptied so the re-solve copies the
+# model in. Without one, drop the cache rather than serve its results.
+function _restore_displaced_optimizer(model::JuMP.AbstractModel)
+    displaced = gdp_data(model).displaced_optimizer
+    if displaced === nothing
+        _MOI.Utilities.drop_optimizer(JuMP.backend(model))
+    else
+        _MOI.empty!(displaced)
+        JuMP.set_optimizer(model, () -> displaced)
+    end
+    return
+end
+
 ################################################################################
 #                         MASTER CONSTRUCTION
 ################################################################################
@@ -602,12 +648,18 @@ end
 #                       LOA RESULT CACHE (MOI LAYER)
 ################################################################################
 # `_LOAResultCache` delegates the MOI interface to its inner mock. Only
-# `SolverName` (the mock hardcodes "Mock") and the bound attributes (a
+# `SolverName` (the mock hardcodes "Mock"), the bound attributes (a
 # raw `KeyError` from the mock's generic storage when the master
-# produced no bound) are intercepted.
+# produced no bound), and `optimize!` are intercepted.
 _MOI.is_empty(cache::_LOAResultCache) = _MOI.is_empty(cache.mock)
 _MOI.empty!(cache::_LOAResultCache) = _MOI.empty!(cache.mock)
-_MOI.optimize!(cache::_LOAResultCache) = _MOI.optimize!(cache.mock)
+# "Solving" the cache would clear JuMP's dirty flag and serve the stored
+# results again, so an edited model would report a stale point as fresh.
+function _MOI.optimize!(cache::_LOAResultCache)
+    return error("This model holds the results of an LOA solve and " *
+        "cannot be re-solved directly (`ignore_optimize_hook = true`). " *
+        "Call `optimize!(model, gdp_method = ...)` to rebuild and solve.")
+end
 _MOI.copy_to(cache::_LOAResultCache, src::_MOI.ModelLike) =
     _MOI.copy_to(cache.mock, src)
 _MOI.add_variable(cache::_LOAResultCache) = _MOI.add_variable(cache.mock)
@@ -817,7 +869,7 @@ function _load_solution(
     _MOI.Utilities.drop_optimizer(JuMP.backend(problem.nlp))
     _restore_binaries(problem)
     _inject_solution(problem.nlp, problem, outcome)
-    gdp_data(model).loa_solver = method.nlp_optimizer
+    gdp_data(model).displaced_optimizer = outcome.displaced_optimizer
     return
 end
 

src/model.jl

@@ -55,17 +55,10 @@ function _optimize_hook(
     method::AbstractReformulationMethod;
     kwargs...
     )
-    # A prior LOA solve left an injected solution optimizer in the slot;
-    # swap the real solver back before a genuine re-solve, but only if the
-    # user has not already set their own optimizer since.
-    solver = gdp_data(model).loa_solver
-    if solver !== nothing
-        backend = JuMP.backend(model)
-        backend isa _MOI.Utilities.CachingOptimizer &&
-            backend.optimizer isa _LOAResultCache &&
-            JuMP.set_optimizer(model, solver)
-        gdp_data(model).loa_solver = nothing
-    end
+    # A prior LOA solve left its result cache in the slot; put the
+    # optimizer it displaced back, unless the user has since set another.
+    _has_loa_cache(model) && _restore_displaced_optimizer(model)
+    gdp_data(model).displaced_optimizer = nothing
     if !_ready_to_optimize(model) || _solution_method(model) != method
         reformulate_model(model, method)
     end

test/constraints/loa.jl

@@ -369,6 +369,101 @@ function test_loa_restores_prior_time_limit()
     @test objective_value(model) ≈ 7.0 atol = 1e-4
 end
 
+function test_loa_restores_displaced_optimizer()
+    # LOA solves the NLP on the model itself, so it displaces the
+    # model's own optimizer. A later reformulation solve must get that
+    # optimizer back, not LOA's NLP solver.
+    model = GDPModel(HiGHS.Optimizer)
+    set_silent(model)
+    set_optimizer_attribute(model, "mip_rel_gap", 0.25)
+    @variable(model, 0 <= x <= 10)
+    @variable(model, Y[1:2], Logical)
+    @constraint(model, x <= 3, Disjunct(Y[1]))
+    @constraint(model, x <= 7, Disjunct(Y[2]))
+    @disjunction(model, Y)
+    @objective(model, Max, x)
+    displaced = JuMP.unsafe_backend(model)
+
+    optimize!(model, gdp_method = LOA(HiGHS.Optimizer))
+    @test DP.gdp_data(model).displaced_optimizer === displaced
+
+    # The reformulation solve restores it, attributes intact.
+    optimize!(model, gdp_method = BigM())
+    @test JuMP.unsafe_backend(model) === displaced
+    @test get_optimizer_attribute(model, "mip_rel_gap") == 0.25
+    @test DP.gdp_data(model).displaced_optimizer === nothing
+    @test termination_status(model) == MOI.OPTIMAL
+    @test objective_value(model) ≈ 7.0 atol = 1e-4
+end
+
+function test_loa_repeated_solve_keeps_displaced_optimizer()
+    # A second LOA solve displaces the first one's result cache, not the
+    # model's own optimizer. The stash must still hold the latter.
+    model = GDPModel(HiGHS.Optimizer)
+    set_silent(model)
+    @variable(model, 0 <= x <= 10)
+    @variable(model, Y[1:2], Logical)
+    @constraint(model, x <= 3, Disjunct(Y[1]))
+    @constraint(model, x <= 7, Disjunct(Y[2]))
+    @disjunction(model, Y)
+    @objective(model, Max, x)
+    displaced = JuMP.unsafe_backend(model)
+
+    optimize!(model, gdp_method = LOA(HiGHS.Optimizer))
+    optimize!(model, gdp_method = LOA(HiGHS.Optimizer))
+    @test DP.gdp_data(model).displaced_optimizer === displaced
+
+    optimize!(model, gdp_method = BigM())
+    @test JuMP.unsafe_backend(model) === displaced
+    @test termination_status(model) == MOI.OPTIMAL
+    @test objective_value(model) ≈ 7.0 atol = 1e-4
+end
+
+function test_loa_no_optimizer_to_restore()
+    # With no optimizer to put back, the result cache must be dropped
+    # rather than left to serve its stored results as a fresh solve.
+    model = GDPModel()
+    @variable(model, 0 <= x <= 10)
+    @variable(model, Y[1:2], Logical)
+    @constraint(model, x <= 3, Disjunct(Y[1]))
+    @constraint(model, x <= 7, Disjunct(Y[2]))
+    @disjunction(model, Y)
+    @objective(model, Max, x)
+
+    optimize!(model, gdp_method = LOA(HiGHS.Optimizer))
+    @test DP.gdp_data(model).displaced_optimizer === nothing
+    @test objective_value(model) ≈ 7.0 atol = 1e-4
+
+    @test_throws JuMP.NoOptimizer optimize!(model, gdp_method = BigM())
+    set_optimizer(model, HiGHS.Optimizer)
+    set_silent(model)
+    optimize!(model, gdp_method = BigM())
+    @test objective_value(model) ≈ 7.0 atol = 1e-4
+end
+
+function test_loa_cache_refuses_direct_solve()
+    # `ignore_optimize_hook = true` would "solve" the result cache and
+    # clear JuMP's dirty flag, reporting a stale point as freshly
+    # solved. It must error instead.
+    model = GDPModel(HiGHS.Optimizer)
+    set_silent(model)
+    @variable(model, 0 <= x <= 10)
+    @variable(model, Y[1:2], Logical)
+    @constraint(model, x <= 3, Disjunct(Y[1]))
+    @constraint(model, x <= 7, Disjunct(Y[2]))
+    @disjunction(model, Y)
+    @objective(model, Max, x)
+    optimize!(model, gdp_method = LOA(HiGHS.Optimizer))
+    @test_throws ErrorException optimize!(model;
+        ignore_optimize_hook = true)
+
+    # Still true once the model has been edited underneath the cache.
+    @constraint(model, x <= 1)
+    @test !has_values(model)
+    @test_throws ErrorException optimize!(model;
+        ignore_optimize_hook = true)
+end
+
 function test_loa_limit_hit_report()
     # Stop the main loop on `max_iter = 1` after the master has produced
     # a bound: the report must label the run "limit hit" (not converged),
@@ -901,6 +996,10 @@ end
     test_loa_nonlinear_equality_disjunct()
     test_loa_nonlinear_interval_disjunct()
     test_loa_restores_prior_time_limit()
+    test_loa_restores_displaced_optimizer()
+    test_loa_repeated_solve_keeps_displaced_optimizer()
+    test_loa_no_optimizer_to_restore()
+    test_loa_cache_refuses_direct_solve()
     test_loa_limit_hit_report()
     test_loa_complement_indicator_nonlinear_disjunct()
     test_loa_nlpf_infeasible_disjunct()