Some cleanup

Author: BenLauwens

docs/src/examples/ross.md

@@ -46,10 +46,16 @@ end
 
 @resumable function start_sim(env::Environment, repair_facility::Resource, spares::Store{Process})
     procs = Process[]
-    for i in 1:N push!(procs, @process machine(env, repair_facility, spares)) end
+    for i in 1:N 
+        push!(procs, @process machine(env, repair_facility, spares)) 
+    end
     @yield Timeout(env)
-    for proc in procs interrupt(proc) end
-    for i in 1:S @yield Put(spares, @process machine(env, repair_facility, spares)) end
+    for proc in procs 
+        interrupt(proc)
+    end
+    for i in 1:S 
+        @yield Put(spares, @process machine(env, repair_facility, spares)) 
+    end
 end
 
 function sim_repair()

src/base.jl

@@ -1,7 +1,7 @@
 abstract type AbstractEvent end
 abstract type Environment end
 
-@enum EVENT_STATE idle=0 scheduled=1 processed=2
+@enum EVENT_STATE idle=0 scheduled=1 triggered=2 processed=3
 
 struct EventProcessed <: Exception
   ev :: AbstractEvent
@@ -66,6 +66,7 @@ function schedule(ev::AbstractEvent, delay::Number=zero(Float64); priority::Int8
   bev.value = value
   env.heap[bev] = EventKey(now(env) + delay, priority, env.sid+=one(UInt))
   bev.state = scheduled
+  ev
 end
 
 struct StopSimulation <: Exception

src/events.jl

@@ -6,10 +6,8 @@ struct Event <: AbstractEvent
 end
 
 function succeed(ev::Event; priority::Int8=zero(Int8), value::Any=nothing) :: Event
-  sta = state(ev)
-  (sta == scheduled || sta == processed) && throw(EventNotIdle(ev))
+  state(ev) != idle && throw(EventNotIdle(ev))
   schedule(ev; priority=priority, value=value)
-  ev
 end
 
 function fail(ev::Event, exc::Exception; priority::Int8=zero(Int8)) :: Event
@@ -19,9 +17,7 @@ end
 struct Timeout <: AbstractEvent
   bev :: BaseEvent
   function Timeout(env::Environment, delay::Number=0; priority::Int8=zero(Int8), value::Any=nothing)
-    ev = new(BaseEvent(env))
-    schedule(ev, delay; priority=priority, value=value)
-    ev
+    schedule(new(BaseEvent(env)), delay; priority=priority, value=value)
   end
 end
 

src/operators.jl

@@ -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 >= triggered, state_values))
 end
 
 function eval_or(state_values::Vector{StateValue})
-  any(map((sv)->sv.state == processed, state_values))
+  any(map((sv)->sv.state >= triggered, state_values))
 end
 
 function (&)(ev1::AbstractEvent, ev2::AbstractEvent)

src/processes.jl

@@ -1,12 +1,12 @@
 mutable struct Process <: DiscreteProcess
   bev :: BaseEvent
-  fsm :: ResumableFunctions.FiniteStateMachineIterator
+  fsmi :: ResumableFunctions.FiniteStateMachineIterator
   target :: AbstractEvent
   resume :: Function
   function Process(func::Function, env::Environment, args::Any...)
     cor = new()
     cor.bev = BaseEvent(env)
-    cor.fsm = func(env, args...)
+    cor.fsmi = func(env, args...)
     cor.target = Timeout(env)
     cor.resume = @callback execute(cor.target, cor)
     cor
@@ -15,18 +15,16 @@ end
 
 macro process(expr)
   expr.head != :call && error("Expression is not a function call!")
-  func = esc(expr.args[1])
-  args = [esc(expr.args[n]) for n in 2:length(expr.args)]
-  :(Process($(func), $(args...)))
+  esc(:(Process($(expr.args...))))
 end
 
 function execute(ev::AbstractEvent, proc::Process)
   try
     env = environment(ev)
     set_active_process(env, proc)
-    target = proc.fsm(value(ev))
+    target = proc.fsmi(value(ev))
     reset_active_process(env)
-    if done(proc.fsm)
+    if done(proc.fsmi)
       schedule(proc; value=target)
     else
       proc.target = state(target) == processed ? Timeout(env; value=value(target)) : target
@@ -38,7 +36,7 @@ function execute(ev::AbstractEvent, proc::Process)
 end
 
 function interrupt(proc::Process, cause::Any=nothing)
-  if !done(proc.fsm)
+  if !done(proc.fsmi)
     remove_callback(proc.resume, proc.target)
     proc.target = Timeout(environment(proc); priority=typemax(Int8), value=InterruptException(proc, cause))
     proc.resume = @callback execute(proc.target, proc)

src/resources/stores.jl

@@ -28,27 +28,25 @@ function Put(sto::Store{T}, item::T; priority::Int=0) where T
   sto.put_queue[put_ev] = StorePutKey{T}(priority, sto.seid+=one(UInt), item)
   @callback trigger_get(put_ev, sto)
   trigger_put(put_ev, sto)
-  return put_ev
+  put_ev
 end
 
-function get_any_item(::T) where T
-  return true
-end
+get_any_item(::T) where T = true
 
 function Get(sto::Store{T}, filter::Function=get_any_item; priority::Int=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)
   trigger_get(get_ev, sto)
-  return get_ev
+  get_ev
 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)
     schedule(put_ev)
   end
-  return false
+  false
 end
 
 function do_get(sto::Store{T}, get_ev::Get, key::StoreGetKey) where {T}
@@ -59,5 +57,5 @@ function do_get(sto::Store{T}, get_ev::Get, key::StoreGetKey) where {T}
       break
     end
   end
-  return true
+  true
 end

src/simulations.jl

@@ -34,10 +34,12 @@ function step(sim::Simulation)
   (bev, key) = DataStructures.peek(sim.heap)
   DataStructures.dequeue!(sim.heap)
   sim.time = key.time
-  bev.state = processed
+  bev.state = triggered
   for callback in bev.callbacks
     callback()
   end
+  bev.state = processed
+  nothing
 end
 
 function now(sim::Simulation)