Store based on Dict

Author: BenLauwens

src/base.jl

@@ -27,7 +27,7 @@ function show(io::IO, ev::AbstractEvent)
 end
 
 function show(io::IO, env::Environment)
-  if env.active_proc == nothing
+  if env.active_proc === nothing
     print(io, "$(typeof(env)) time: $(now(env)) active_process: nothing")
   else
     print(io, "$(typeof(env)) time: $(now(env)) active_process: $(env.active_proc)")
@@ -47,14 +47,14 @@ function state(ev::AbstractEvent) :: EVENT_STATE
 end
 
 function append_callback(func::Function, ev::AbstractEvent, args::Any...) :: Function
-  ev.bev.state == processed && throw(EventProcessed(ev))
+  ev.bev.state === processed && throw(EventProcessed(ev))
   cb = ()->func(ev, args...)
   push!(ev.bev.callbacks, cb)
   cb
 end
 
 macro callback(expr::Expr)
-  expr.head != :call && error("Expression is not a function call!")
+  expr.head !== :call && error("Expression is not a function call!")
   esc(:(SimJulia.append_callback($(expr.args...))))
 end
 
@@ -64,7 +64,7 @@ function remove_callback(cb::Function, ev::AbstractEvent)
 end
 
 function schedule(ev::AbstractEvent, delay::Number=zero(Float64); priority::Int=0, value::Any=nothing)
-  state(ev) == processed && throw(EventProcessed(ev))
+  state(ev) === processed && throw(EventProcessed(ev))
   env = environment(ev)
   bev = ev.bev
   bev.value = value

src/events.jl

@@ -6,7 +6,7 @@ struct Event <: AbstractEvent
 end
 
 function succeed(ev::Event; priority::Int=0, value::Any=nothing) :: Event
-  state(ev) != idle && throw(EventNotIdle(ev))
+  state(ev) !== idle && throw(EventNotIdle(ev))
   schedule(ev; priority=priority, value=value)
 end
 

src/operators.jl

@@ -23,14 +23,14 @@ end
 
 function check(ev::AbstractEvent, op::Operator, event_state_values::Dict{AbstractEvent, StateValue})
   val = value(ev)
-  if state(op) == idle
+  if state(op) === idle
     if isa(val, Exception)
       schedule(op; value=val)
     else
       event_state_values[ev] = StateValue(state(ev), val)
       op.eval(collect(values(event_state_values))) && schedule(op; value=event_state_values)
     end
-  elseif state(op) == scheduled
+  elseif state(op) === scheduled
     if isa(val, Exception)
       schedule(op; priority=typemax(Int), value=val)
     else
@@ -40,11 +40,11 @@ function check(ev::AbstractEvent, op::Operator, event_state_values::Dict{Abstrac
 end
 
 function eval_and(state_values::Vector{StateValue})
-  all(map((sv)->sv.state == processed, state_values))
+  all(map((sv)->sv.state === processed, state_values))
 end
 
 function eval_or(state_values::Vector{StateValue})
-  any(map((sv)->sv.state == processed, state_values))
+  any(map((sv)->sv.state === processed, state_values))
 end
 
 function (&)(ev1::AbstractEvent, ev2::AbstractEvent)

src/processes.jl

@@ -21,7 +21,7 @@ mutable struct Process <: DiscreteProcess
 end
 
 macro process(expr)
-  expr.head != :call && error("Expression is not a function call!")
+  expr.head !== :call && error("Expression is not a function call!")
   esc(:(Process($(expr.args...))))
 end
 
@@ -31,7 +31,7 @@ function execute(ev::AbstractEvent, proc::Process)
     set_active_process(env, proc)
     target = proc.fsmi(value(ev))
     reset_active_process(env)
-    if proc.fsmi._state == 0xff
+    if proc.fsmi._state === 0xff
       schedule(proc; value=target)
     else
       proc.target = state(target) == processed ? timeout(env; value=value(target)) : target
@@ -56,7 +56,7 @@ end
 
 function interrupt(proc::Process, cause::Any=nothing)
   env = environment(proc)
-  if proc.fsmi._state != 0xff
+  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))
     @callback execute_interrupt(target, proc)

src/resources/base.jl

@@ -23,15 +23,15 @@ struct Get <: ResourceEvent
 end
 
 function isless(a::ResourceKey, b::ResourceKey)
-  (a.priority < b.priority) || (a.priority == b.priority && a.id < b.id)
+  (a.priority < b.priority) || (a.priority === b.priority && a.id < b.id)
 end
 
 function trigger_put(put_ev::ResourceEvent, res::AbstractResource)
   queue = DataStructures.PriorityQueue(res.put_queue)
   while length(queue) > 0
     (put_ev, key) = DataStructures.peek(queue)
     proceed = do_put(res, put_ev, key)
-    state(put_ev) == scheduled && DataStructures.dequeue!(res.put_queue, put_ev)
+    state(put_ev) === scheduled && DataStructures.dequeue!(res.put_queue, put_ev)
     proceed ? DataStructures.dequeue!(queue) : break
   end
 end
@@ -41,7 +41,7 @@ function trigger_get(get_ev::ResourceEvent, res::AbstractResource)
   while length(queue) > 0
     (get_ev, key) = DataStructures.peek(queue)
     proceed = do_get(res, get_ev, key)
-    state(get_ev) == scheduled && DataStructures.dequeue!(res.get_queue, get_ev)
+    state(get_ev) === scheduled && DataStructures.dequeue!(res.get_queue, get_ev)
     proceed ? DataStructures.dequeue!(queue) : break
   end
 end

src/resources/stores.jl

@@ -14,12 +14,13 @@ end
 mutable struct Store{T} <: AbstractResource
   env :: Environment
   capacity :: UInt
-  items :: Set{T}
+  load :: UInt
+  items :: Dict{T, UInt}
   seid :: UInt
   put_queue :: DataStructures.PriorityQueue{Put, StorePutKey{T}}
   get_queue :: DataStructures.PriorityQueue{Get, StoreGetKey}
   function Store{T}(env::Environment; capacity::UInt=typemax(UInt)) where {T}
-    new(env, capacity, Set{T}(), zero(UInt), DataStructures.PriorityQueue{Put, StorePutKey{T}}(), DataStructures.PriorityQueue{Get, StoreGetKey}())
+    new(env, capacity, zero(UInt), Dict{T, UInt}(), zero(UInt), DataStructures.PriorityQueue{Put, StorePutKey{T}}(), DataStructures.PriorityQueue{Get, StoreGetKey}())
   end
 end
 
@@ -42,17 +43,23 @@ function get(sto::Store{T}, filter::Function=get_any_item; priority::Int=0) wher
 end
 
 function do_put(sto::Store{T}, put_ev::Put, key::StorePutKey{T}) where {T}
-  if length(sto.items) < sto.capacity
-    push!(sto.items, key.item)
+  if sto.load < sto.capacity
+    sto.load += one(UInt)
+    sto.items[key.item] = get!(sto.items, key.item, zero(UInt)) + one(UInt)
     schedule(put_ev)
   end
   false
 end
 
 function do_get(sto::Store{T}, get_ev::Get, key::StoreGetKey) where {T}
-  for item in sto.items
+  for (item, number) in sto.items
     if key.filter(item)
-      delete!(sto.items, item)
+      sto.load -= one(UInt)
+      if number === one(UInt)
+        delete!(sto.items, item)
+      else
+        sto.items[item] = number - one(UInt)
+      end
       schedule(get_ev; value=item)
       break
     end

src/simulations.jl

@@ -15,7 +15,7 @@ struct EventKey
 end
 
 function isless(a::EventKey, b::EventKey) :: Bool
-  (a.time < b.time) || (a.time == b.time && a.priority > b.priority) || (a.time == b.time && a.priority == b.priority && a.id < b.id)
+  (a.time < b.time) || (a.time === b.time && a.priority > b.priority) || (a.time === b.time && a.priority === b.priority && a.id < b.id)
 end
 
 mutable struct Simulation <: Environment