Priority as number

src/base.jl

@@ -63,7 +63,7 @@ function remove_callback(cb::Function, ev::AbstractEvent)
   i != 0 && deleteat!(ev.bev.callbacks, i)
 end
 
-function schedule(ev::AbstractEvent, delay::Number=zero(Float64); priority::Int=0, value::Any=nothing)
+function schedule(ev::AbstractEvent, delay::Number=0; priority::Number=0, value::Any=nothing)
   state(ev) === processed && throw(EventProcessed(ev))
   env = environment(ev)
   bev = ev.bev

src/events.jl

@@ -5,12 +5,12 @@ struct Event <: AbstractEvent
   end
 end
 
-function succeed(ev::Event; priority::Int=0, value::Any=nothing) :: Event
+function succeed(ev::Event; priority::Number=0, value::Any=nothing) :: Event
   state(ev) !== idle && throw(EventNotIdle(ev))
   schedule(ev; priority=priority, value=value)
 end
 
-function fail(ev::Event, exc::Exception; priority::Int=0) :: Event
+function fail(ev::Event, exc::Exception; priority::Number=0) :: Event
   succeed(ev; priority=priority, value=exc)
 end
 
@@ -21,10 +21,10 @@ struct Timeout <: AbstractEvent
   end
 end
 
-function timeout(env::Environment, delay::Number=0; priority::Int=0, value::Any=nothing)
+function timeout(env::Environment, delay::Number=0; priority::Number=0, value::Any=nothing)
   schedule(Timeout(env), delay; priority=priority, value=value)
 end
 
-function run(env::Environment, until::Number=typemax(Float64))
+function run(env::Environment, until::Number=Inf)
   run(env, timeout(env, until-now(env)))
 end

src/operators.jl

@@ -32,7 +32,7 @@ function check(ev::AbstractEvent, op::Operator, event_state_values::Dict{Abstrac
     end
   elseif state(op) === scheduled
     if isa(val, Exception)
-      schedule(op; priority=typemax(Int), value=val)
+      schedule(op; priority=Inf, value=val)
     else
       event_state_values[ev] = StateValue(state(ev), val)
     end

src/processes.jl

@@ -57,9 +57,9 @@ end
 function interrupt(proc::Process, cause::Any=nothing)
   env = environment(proc)
   if proc.fsmi._state !== 0xff
-    proc.target isa Initialize && schedule(proc.target; priority=typemax(Int))
-    target = schedule(Interrupt(env); priority=typemax(Int), value=InterruptException(active_process(env), cause))
+    proc.target isa Initialize && schedule(proc.target; priority=Inf)
+    target = schedule(Interrupt(env); priority=Inf, value=InterruptException(active_process(env), cause))
     @callback execute_interrupt(target, proc)
   end
-  timeout(env; priority=typemax(Int))
+  timeout(env; priority=Inf)
 end

src/resources/containers.jl

@@ -1,5 +1,5 @@
-struct ContainerKey{N<:Real} <: ResourceKey
-  priority :: Int
+struct ContainerKey{T<:Number, N<:Real} <: ResourceKey
+  priority :: T
   id :: UInt
   amount :: N
 end
@@ -22,25 +22,25 @@ end
 
 const Resource = Container{Int}
 
-function put(con::Container{N}, amount::N; priority::Int=0) where N<:Real
+function put(con::Container{N}, amount::N; priority::Number=0) where N<:Real
   put_ev = Put(con.env)
   con.put_queue[put_ev] = ContainerKey(priority, con.seid+=one(UInt), amount)
   @callback trigger_get(put_ev, con)
   trigger_put(put_ev, con)
   put_ev
 end
 
-request(res::Resource; priority::Int=0) = put(res, 1; priority=priority)
+request(res::Resource; priority::Number=0) = put(res, 1; priority=priority)
 
-function get(con::Container{N}, amount::N; priority::Int=0) where N<:Real
+function get(con::Container{N}, amount::N; priority::Number=0) where N<:Real
   get_ev = Get(con.env)
   con.get_queue[get_ev] = ContainerKey(priority, con.seid+=one(UInt), amount)
   @callback trigger_put(get_ev, con)
   trigger_get(get_ev, con)
   get_ev
 end
 
-release(res::Resource; priority::Int=0) = get(res, 1; priority=priority)
+release(res::Resource; priority::Number=0) = get(res, 1; priority=priority)
 
 function do_put(con::Container{N}, put_ev::Put, key::ContainerKey{N}) where N<:Real
   con.level + key.amount > con.capacity && return false

src/resources/stores.jl

@@ -1,12 +1,11 @@
-struct StorePutKey{T} <: ResourceKey
-  priority :: Int
+struct StorePutKey{N<:Number, T} <: ResourceKey
+  priority :: N
   id :: UInt
   item :: T
-  StorePutKey{T}(priority, id, item) where T = new(priority, id, item)
 end
 
-struct StoreGetKey <: ResourceKey
-  priority :: Int
+struct StoreGetKey{N<:Number} <: ResourceKey
+  priority :: N
   id :: UInt
   filter :: Function
 end
@@ -24,7 +23,7 @@ mutable struct Store{T} <: AbstractResource
   end
 end
 
-function put(sto::Store{T}, item::T; priority::Int=0) where T
+function put(sto::Store{T}, item::T; priority::Number=0) where T
   put_ev = Put(sto.env)
   sto.put_queue[put_ev] = StorePutKey{T}(priority, sto.seid+=one(UInt), item)
   @callback trigger_get(put_ev, sto)
@@ -34,7 +33,7 @@ end
 
 get_any_item(::T) where T = true
 
-function get(sto::Store{T}, filter::Function=get_any_item; priority::Int=0) where T
+function get(sto::Store{T}, filter::Function=get_any_item; priority::Number=0) where T
   get_ev = Get(sto.env)
   sto.get_queue[get_ev] = StoreGetKey(priority, sto.seid+=one(UInt), filter)
   @callback trigger_put(get_ev, sto)

src/simulations.jl

@@ -8,9 +8,9 @@ end
 
 struct EmptySchedule <: Exception end
 
-struct EventKey
+struct EventKey{N<:Number}
   time :: Float64
-  priority :: Int
+  priority :: N
   id :: UInt
 end
 

src/utils/time.jl

@@ -6,7 +6,7 @@ function run(env::Environment, until::DateTime)
   run(env, Dates.datetime2epochms(until))
 end
 
-function timeout(env::Environment, delay::Period; priority::Int=0, value::Any=nothing)
+function timeout(env::Environment, delay::Period; priority::Number=0, value::Any=nothing)
   time = now(env)
   del = Dates.datetime2epochms(Dates.epochms2datetime(time)+delay)-time
   timeout(env, del; priority=priority, value=value)

test/test_resources_containers.jl

@@ -1,7 +1,7 @@
 using ConcurrentSim
 using ResumableFunctions
 
-@resumable function client(sim::Simulation, res::Resource, i::Int, priority::Int)
+@resumable function client(sim::Simulation, res::Resource, i::Int, priority::Number)
   println("$(now(sim)), client $i is waiting")
   @yield request(res, priority=priority)
   println("$(now(sim)), client $i is being served")