[Utilities] add with_cache_type to instantiate (#2097)

This is useful when creating optimizers which do not support the
incremental interface, or which only partially implement it.

This change is motivated by some recent examples in which it was
necessary for the user to hard-code the caching logic to work-around
the lack of deletion in a solver, and the caching logic is confusing
to even advanced users. See:

 * https://discourse.julialang.org/t/jump-scip-error/93958
 * jump-dev/MultiObjectiveAlgorithms.jl#46

Author: odow

src/instantiate.jl

@@ -125,36 +125,68 @@ end
 """
     instantiate(
         optimizer_constructor,
-        with_bridge_type::Union{Nothing, Type} = nothing,
+        with_cache_type::Union{Nothing,Type} = nothing,
+        with_bridge_type::Union{Nothing,Type} = nothing,
     )
 
-Creates an instance of optimizer by either:
+Create an instance of an optimizer by either:
+
  * calling `optimizer_constructor.optimizer_constructor()` and setting the
    parameters in `optimizer_constructor.params` if `optimizer_constructor` is a
    [`OptimizerWithAttributes`](@ref)
 *  calling `optimizer_constructor()` if `optimizer_constructor` is callable.
 
-If `with_bridge_type` is not `nothing`, it enables all the bridges defined in
-the MathOptInterface.Bridges submodule with coefficient type `with_bridge_type`.
+## with_cache_type
+
+If `with_cache_type` is not `nothing`, then the optimizer is wrapped in a
+[`Utilities.CachingOptimizer`](@ref) to store a cache of the model. This is most
+useful if the optimizer you are constructing does not support the incremental
+interface (see [`supports_incremental_interface`](@ref)).
+
+## with_bridge_type
+
+If `with_bridge_type` is not `nothing`, the optimizer is wrapped in a
+[`Bridges.full_bridge_optimizer`](@ref), enabling all the bridges defined in
+the MOI.Bridges submodule with coefficient type `with_bridge_type`.
+
+In addition, if the optimizer created by `optimizer_constructor` does not
+support the incremental interface (see [`supports_incremental_interface`](@ref)),
+then, irrespective of `with_cache_type`, the optimizer is wrapped in a
+[`Utilities.CachingOptimizer`](@ref) to store a cache of the bridged model.
 
-If the optimizer created by `optimizer_constructor` does not support loading the
-problem incrementally (see [`supports_incremental_interface`](@ref)), then a
-[`Utilities.CachingOptimizer`](@ref) is added to store a cache of the bridged
-model.
+If `with_cache_type` and `with_bridge_type` are both not `nothing`, then they
+must be the same type.
 """
 function instantiate(
     (@nospecialize optimizer_constructor);
     with_bridge_type::Union{Nothing,Type} = nothing,
+    with_cache_type::Union{Nothing,Type} = nothing,
 )
+    if with_bridge_type !== nothing && with_cache_type !== nothing
+        if with_bridge_type != with_cache_type
+            error(
+                "If both provided, `with_bridge_type` and `with_cache_type` " *
+                "must be the same type. Got " *
+                "`with_bridge_type = $with_bridge_type` and " *
+                "`with_cache_type = $with_cache_type`",
+            )
+        end
+    end
     optimizer = _instantiate_and_check(optimizer_constructor)
     if with_bridge_type === nothing
-        return optimizer
-    end
-    if !supports_incremental_interface(optimizer)
-        cache = default_cache(optimizer, with_bridge_type)
-        optimizer = Utilities.CachingOptimizer(cache, optimizer)
+        if with_cache_type === nothing
+            return optimizer
+        end
+        cache = default_cache(optimizer, with_cache_type)
+        return Utilities.CachingOptimizer(cache, optimizer)
+    else
+        if with_cache_type !== nothing ||
+           !supports_incremental_interface(optimizer)
+            cache = default_cache(optimizer, with_bridge_type)
+            optimizer = Utilities.CachingOptimizer(cache, optimizer)
+        end
+        return Bridges.full_bridge_optimizer(optimizer, with_bridge_type)
     end
-    return Bridges.full_bridge_optimizer(optimizer, with_bridge_type)
 end
 
 """

test/instantiate.jl

@@ -9,8 +9,20 @@ module TestInstantiate
 using Test
 import MathOptInterface as MOI
 
+function runtests()
+    for name in names(@__MODULE__; all = true)
+        if startswith("$name", "test_")
+            @testset "$(name)" begin
+                getfield(@__MODULE__, name)()
+            end
+        end
+    end
+end
+
 struct DummyOptimizer <: MOI.AbstractOptimizer end
+
 MOI.is_empty(::DummyOptimizer) = true
+
 function MOI.default_cache(::DummyOptimizer, ::Type{T}) where {T}
     return MOI.Utilities.Model{T}()
 end
@@ -110,14 +122,48 @@ function test_get_set_Optimizer_with_attributes()
     return
 end
 
-function runtests()
-    for name in names(@__MODULE__; all = true)
-        if startswith("$name", "test_")
-            @testset "$(name)" begin
-                getfield(@__MODULE__, name)()
-            end
+function test_instantiate_with_cache_type()
+    function f(::Type{T}) where {T}
+        return MOI.Utilities.MockOptimizer(
+            MOI.Utilities.UniversalFallback(MOI.Utilities.Model{T}()),
+        )
+    end
+    function inner_type(::Type{T}) where {T}
+        return MOI.Utilities.UniversalFallback{MOI.Utilities.Model{T}}
+    end
+    function mock_type(::Type{T}) where {T}
+        return MOI.Utilities.MockOptimizer{inner_type(T),Float64}
+    end
+    for T in (Int, Float64)
+        mock, inner = mock_type(T), inner_type(T)
+        # Check with no arguments provided
+        model = MOI.instantiate(() -> f(T))
+        @test typeof(model) == mock
+        # Check with only with_bridge_type
+        model = MOI.instantiate(() -> f(T); with_bridge_type = T)
+        @test typeof(model) == MOI.Bridges.LazyBridgeOptimizer{mock}
+        # Check with only with_cache_type
+        model = MOI.instantiate(() -> f(T); with_cache_type = T)
+        @test typeof(model) == MOI.Utilities.CachingOptimizer{mock,inner}
+        # Check with both with_cache_type and with_bridge_type
+        model = MOI.instantiate(; with_cache_type = T, with_bridge_type = T) do
+            return f(T)
         end
+        @test typeof(model) == MOI.Bridges.LazyBridgeOptimizer{
+            MOI.Utilities.CachingOptimizer{mock,inner},
+        }
     end
+    @test_throws(
+        ErrorException(
+            "If both provided, `with_bridge_type` and `with_cache_type` must " *
+            "be the same type. Got `with_bridge_type = $Float64` and " *
+            "`with_cache_type = $Int`",
+        ),
+        MOI.instantiate(; with_cache_type = Int, with_bridge_type = Float64) do
+            return f(Int)
+        end
+    )
+    return
 end
 
 end