Add MOA.AllowInnerInterrupt to support interrupting an inner solve (#188)

Co-authored-by: sandyspiers <sandy.spiers@gmail.com>

Author: odow

README.md

@@ -82,6 +82,7 @@ Each algorithm supports only a subset of the attributes. Consult the algorithm's
 docstring for details on which attributes it supports, and how it uses them in
 the solution process.
 
+ * `MOA.AllowInnerInterrupt()`
  * `MOA.EpsilonConstraintStep()`
  * `MOA.LexicographicAllPermutations()`
  * `MOA.ObjectiveAbsoluteTolerance(index::Int)`

src/MultiObjectiveAlgorithms.jl

@@ -195,6 +195,7 @@ mutable struct Optimizer <: MOI.AbstractOptimizer
     termination_status::MOI.TerminationStatusCode
     silent::Bool
     time_limit_sec::Union{Nothing,Float64}
+    allow_inner_interrupt::Bool
     start_time::Float64
     solve_time::Float64
     ideal_point::Vector{Float64}
@@ -217,6 +218,7 @@ mutable struct Optimizer <: MOI.AbstractOptimizer
             MOI.OPTIMIZE_NOT_CALLED,
             false,
             nothing,
+            false,
             NaN,
             NaN,
             Float64[],
@@ -311,6 +313,34 @@ function MOI.set(model::Optimizer, ::MOI.TimeLimitSec, ::Nothing)
     return
 end
 
+### AllowInnerInterrupt
+
+"""
+    AllowInnerInterrupt() <: MOI.AbstractOptimizerAttribute
+
+An optimizer attribute that controls whether the SIGINT (`[CTRL]+[C]`) are
+enabled during the solve of the inner optimization problems.
+
+By default, this attribute is set to `false`.
+
+!!! warning
+    This attribute should be used with caution. It is safe to set to `true` only
+    if the inner optimization has native support for safely interrupting a call
+    to `optimize!`. It is undefined behavior if you set this attribute to `true`
+    and you interrupt a solver that does not have support for safely
+    interrupting a solve.
+"""
+struct AllowInnerInterrupt <: MOI.AbstractOptimizerAttribute end
+
+MOI.supports(::Optimizer, ::AllowInnerInterrupt) = true
+
+MOI.get(model::Optimizer, ::AllowInnerInterrupt) = model.allow_inner_interrupt
+
+function MOI.set(model::Optimizer, ::AllowInnerInterrupt, value::Bool)
+    model.allow_inner_interrupt = value
+    return
+end
+
 ### SolveTimeSec
 
 function MOI.get(model::Optimizer, ::MOI.SolveTimeSec)
@@ -701,6 +731,13 @@ function MOI.delete(model::Optimizer, ci::MOI.ConstraintIndex)
     return
 end
 
+function _call_with_sigint_if(f::Function, enable_sigint::Bool)
+    if enable_sigint
+        return reenable_sigint(f)
+    end
+    return f()
+end
+
 """
     optimize_inner!(model::Optimizer)
 
@@ -715,7 +752,18 @@ packages.
 """
 function optimize_inner!(model::Optimizer)
     start_time = time()
-    MOI.optimize!(model.inner)
+    # If AllowInnerInterrupt=true, there are two cases that can happen:
+    #
+    # 1. the interrupt is gracefully caught by the inner optimizer, in which
+    #    case no error is thrown. The interrupt is handled by the regular
+    #    termination status check, just as it would for any other problematic
+    #    solve.
+    #
+    # 2. the interrupt is not gracefully caught, and an InterruptException is
+    #    thrown. Bad user. They shouldn't have set AllowInnerInterrupt.
+    _call_with_sigint_if(MOI.get(model, AllowInnerInterrupt())) do
+        return MOI.optimize!(model.inner)
+    end
     model.solve_time_inner += time() - start_time
     model.subproblem_count += 1
     return

test/test_model.jl

@@ -297,6 +297,29 @@ function test_printing_silent_inner()
     return
 end
 
+function test_AllowInnerInterrupt()
+    model = MOA.Optimizer(HiGHS.Optimizer)
+    @test MOI.supports(model, MOA.AllowInnerInterrupt())
+    @test MOI.get(model, MOA.AllowInnerInterrupt()) == false
+    MOI.set(model, MOA.AllowInnerInterrupt(), true)
+    @test MOI.get(model, MOA.AllowInnerInterrupt()) == true
+    MOI.set(model, MOA.AllowInnerInterrupt(), false)
+    @test MOI.get(model, MOA.AllowInnerInterrupt()) == false
+    return
+end
+
+function test_call_with_sigint_if()
+    @test_throws(
+        ErrorException, # sigatomic error
+        MOA._call_with_sigint_if(() -> throw(InterruptException()), true),
+    )
+    @test_throws(
+        InterruptException,
+        MOA._call_with_sigint_if(() -> throw(InterruptException()), false),
+    )
+    return
+end
+
 end  # module
 
 TestModel.run_tests()