Dev

Project.toml

@@ -1,7 +1,7 @@
 name = "LocalSearchSolvers"
 uuid = "2b10edaa-728d-4283-ac71-07e312d6ccf3"
 authors = ["Jean-Francois Baffier"]
-version = "0.4.7"
+version = "0.4.8"
 
 [deps]
 CompositionalNetworks = "4b67e4b5-442d-4ef5-b760-3f5df3a57537"

src/options.jl

@@ -5,11 +5,6 @@ const print_levels = Dict(
     :verbose => 3
 )
 
-# # Tabu times
-# get!(s, :tabu_time, length_vars(s) ÷ 2) # 10?
-# get!(s, :local_tabu, setting(s, :tabu_time) ÷ 2)
-# get!(s, :δ_tabu, setting(s, :tabu_time) - setting(s, :local_tabu))# 20-30
-
 """
     Options()
 # Arguments:
@@ -36,28 +31,28 @@ set_time_limit_sec(model, 5.0)
 mutable struct Options
     dynamic::Bool
     info_path::String
-    iteration::Union{Int, Float64}
+    iteration::Tuple{Bool, Union{Int, Float64}}
     print_level::Symbol
     process_threads_map::Dict{Int, Int}
     solutions::Int
     specialize::Bool
     tabu_time::Int
     tabu_local::Int
     tabu_delta::Float64
-    time_limit::Float64 # seconds
+    time_limit::Tuple{Bool, Float64} # seconds
 
     function Options(;
             dynamic = false,
             info_path = "",
-            iteration = 10000,
+            iteration = (false, 100),
             print_level = :minimal,
             process_threads_map = Dict{Int, Int}(1 => typemax(0)),
             solutions = 1,
             specialize = !dynamic,
             tabu_time = 0,
             tabu_local = 0,
             tabu_delta = 0.0,
-            time_limit = 60 # seconds
+            time_limit = (false, 1.0) # seconds
     )
         ds_str = "The model types are specialized to the starting domains, constraints," *
                  " and objectives types. Dynamic elements that add a new type will raise an error!"
@@ -69,20 +64,33 @@ mutable struct Options
 
         itertime_str = "Both iteration and time limits are disabled. " *
                        "Optimization runs will run infinitely."
-        iteration == Inf && time_limit == Inf && @warn itertime_str
+
+        new_iteration = if iteration isa Tuple{Bool, Union{Int, Float64}}
+            iteration
+        else
+            iteration = (false, iteration)
+        end
+
+        new_time_limit = if time_limit isa Tuple{Bool, Float64}
+            time_limit
+        else
+            time_limit = (false, time_limit)
+        end
+
+        new_iteration[2] == Inf && new_time_limit[2] == Inf && @warn itertime_str
 
         new(
             dynamic,
             info_path,
-            iteration,
+            new_iteration,
             print_level,
             process_threads_map,
             solutions,
             specialize,
             tabu_time,
             tabu_local,
             tabu_delta,
-            time_limit
+            new_time_limit
         )
     end
 end
@@ -137,6 +145,9 @@ _iteration(options) = options.iteration
 DOCSTRING
 """
 _iteration!(options, iterations) = options.iteration = iterations
+function _iteration!(options, iterations::Union{Int, Float64})
+    options.iteration = (false, iterations)
+end
 
 """
     _print_level(options) = begin
@@ -266,7 +277,8 @@ _time_limit(options) = options.time_limit
 
 DOCSTRING
 """
-_time_limit!(options, time) = options.time_limit = time
+_time_limit!(options, time::Tuple{Bool, Float64}) = options.time_limit = time
+_time_limit!(options, time::Float64) = options.time_limit = (false, time)
 
 function set_option!(options, name, value)
     eval(Symbol("_" * name * "!"))(options, value)

src/solvers/lead.jl

@@ -18,7 +18,7 @@ end
 function solver(
         mlid, model, options, pool, rc_report, rc_sol, rc_stop, strats, ::Val{:lead})
     l_options = deepcopy(options)
-    set_option!(options, "print_level", :silent)
+    set_option!(l_options, "print_level", :silent)
     ss = Vector{_SubSolver}()
     return LeadSolver(
         mlid, model, l_options, pool, rc_report, rc_sol, rc_stop, state(), strats, ss)

src/solvers/main.jl

@@ -71,21 +71,26 @@ function _init!(s::MainSolver)
 end
 
 function stop_while_loop(s::MainSolver, ::Atomic{Bool}, iter, start_time)
-    remote_limit = isready(s.rc_stop) # Add ! when MainSolver is passive
-    iter_limit = iter < get_option(s, "iteration")
-    time_limit = time() - start_time < get_option(s, "time_limit")
-    if !remote_limit
+    @debug "debug stop" iter (time()-start_time)
+    if !isready(s.rc_stop)
         s.status = :solution_limit
         return false
     end
-    if !iter_limit
+
+    iter_sat = get_option(s, "iteration")[1] && has_solution(s)
+    iter_limit = iter > get_option(s, "iteration")[2]
+    if (iter_sat && iter_limit) || iter_limit
         s.status = :iteration_limit
         return false
     end
-    if !time_limit
+
+    time_sat = get_option(s, "time_limit")[1] && has_solution(s)
+    time_limit = time() - start_time > get_option(s, "time_limit")[2]
+    if (time_sat && time_limit) || time_limit
         s.status = :time_limit
         return false
     end
+
     return true
 end
 

src/solvers/sub.jl

@@ -21,7 +21,7 @@ end
 function solver(mlid, model, options, pool, ::RemoteChannel,
         ::RemoteChannel, ::RemoteChannel, strats, ::Val{:sub})
     sub_options = deepcopy(options)
-    set_option!(options, "print_level", :silent)
+    set_option!(sub_options, "print_level", :silent)
     return _SubSolver(mlid, model, sub_options, pool, state(), strats)
 end