use ResumableFunctions

Author: BenLauwens

REQUIRE

@@ -1,3 +1,4 @@
 julia 0.6
 DataStructures
+ResumableFunctions
 TaylorSeries

src/SimJulia.jl

@@ -7,6 +7,7 @@ module SimJulia
 
   using DataStructures
   using Base.Dates
+  using ResumableFunctions
   using TaylorSeries
 
   import Base.run, Base.now, Base.isless, Base.show, Base.interrupt, Base.yield, Base.length
@@ -24,7 +25,6 @@ module SimJulia
   export nowDatetime
   export Process, @process
   export yield, interrupt
-  export FiniteStateMachine, @resumable, @yield
   export Coroutine, @coroutine
   export Container, Resource, Store
   export Put, Get, Request, Release, cancel, capacity, request, @request
@@ -41,9 +41,6 @@ module SimJulia
   include("utils/time.jl")
   include("tasks/base.jl")
   include("processes.jl")
-  include("finitestatemachines/utils.jl")
-  include("finitestatemachines/transforms.jl")
-  include("finitestatemachines/macros.jl")
   include("coroutines.jl")
   include("resources/base.jl")
   include("resources/containers.jl")

src/coroutines.jl

@@ -1,6 +1,6 @@
 mutable struct Coroutine <: DiscreteProcess
   bev :: BaseEvent
-  fsm :: FiniteStateMachine
+  fsm :: ResumableFunctions.FiniteStateMachineIterator
   target :: AbstractEvent
   resume :: Function
   function Coroutine(func::Function, env::Environment, args::Any...)
@@ -26,7 +26,7 @@ function execute(ev::AbstractEvent, proc::Coroutine)
     set_active_process(env, proc)
     target = proc.fsm(value(ev))
     reset_active_process(env)
-    if iscoroutinedone(proc.fsm)
+    if done(proc.fsm)
       schedule(proc; value=target)
     else
       proc.target = state(target) == triggered ? Timeout(env; value=value(target)) : target
@@ -38,7 +38,7 @@ function execute(ev::AbstractEvent, proc::Coroutine)
 end
 
 function interrupt(proc::Coroutine, cause::Any=nothing)
-  if !iscoroutinedone(proc.fsm)
+  if !done(proc.fsm)
     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/finitestatemachines/macros.jl

@@ -23,6 +23,27 @@ function number_parameters(ex, n::Int, p::Symbol)
   n
 end
 
+function getArguments(expr) :: Vector{Symbol}
+  args = Symbol[]
+  kws = Symbol[]
+  params = Symbol[]
+  expr_args = expr.args[1].head == :call ? expr.args[1].args : expr.args[1].args[1].args
+  for arg in expr_args
+    if isa(arg, Symbol)
+      push!(args, arg)
+    elseif arg.head == Symbol("::")
+      push!(args, arg.args[1])
+    elseif arg.head == :kw
+      isa(arg.args[1], Symbol) ? push!(kws, arg.args[1]) : push!(kws, arg.args[1].args[1])
+    elseif arg.head == :parameters
+      for arg2 in arg.args
+        isa(arg2.args[1], Symbol) ? push!(params, arg2.args[1]) : push!(params, arg2.args[1].args[1])
+      end
+    end
+  end
+  [args; kws; params]
+end
+
 macro model(expr::Expr)
   expr.head != :function && error("Expression is not a function definition!")
   args = getArguments(expr)

src/finitestatemachines/transforms.jl

@@ -1,25 +1,25 @@
-using SimJulia, Distributions, BenchmarkTools
+using ResumableFunctions, SimJulia, Distributions, BenchmarkTools
 
 @resumable function exp_source(sim::Simulation, lambd::Float64, server::Resource, mu::Float64)
   while true
     dt = rand(Exponential(1 / lambd))
-    @yield return Timeout(sim, dt)
+    @yield Timeout(sim, dt)
     @coroutine customer2(sim, server, mu)
   end
 end
 
 @resumable function customer(sim::Simulation, server::Resource, mu::Float64)
-  @yield return Request(server)
+  @yield Request(server)
   dt = rand(Exponential(1 / mu))
-  @yield return Timeout(sim, dt)
-  @yield return Release(server)
+  @yield Timeout(sim, dt)
+  @yield Release(server)
 end
 
 @resumable function customer2(sim::Simulation, server::Resource, mu::Float64)
   @request server req begin
-    @yield return req
+    @yield req
     dt = rand(Exponential(1 / mu))
-    @yield return Timeout(sim, dt)
+    @yield Timeout(sim, dt)
   end
 end
 

src/finitestatemachines/utils.jl

@@ -1,10 +1,10 @@
-using SimJulia, BenchmarkTools
+using ResumableFunctions, SimJulia, BenchmarkTools
 
 @resumable function fibonnaci(sim::Simulation)
   a = 0.0
   b = 1.0
   while true
-    @yield return Timeout(sim, 1)
+    @yield Timeout(sim, 1)
     a, b = b, a+b
   end
 end

src/odes/macros.jl

@@ -1,21 +1,21 @@
+workspace()
+
 using SimJulia
+using ResumableFunctions
 
-@resumable function client(sim::Simulation, res::Resource, i::Int, priority::Int)
+@resumable function client(sim::Simulation, res::Resource, i::Int, prior::Int)
   println("$(now(sim)), client $i is waiting")
-  @yield return Request(res, priority=priority)
+  @yield Request(res, priority=prior)
   println("$(now(sim)), client $i is being served")
-  @yield return Timeout(sim, rand())
+  @yield Timeout(sim, rand())
   println("$(now(sim)), client $i has been served")
-  @yield return Release(res)
+  @yield Release(res)
 end
 
 @resumable function generate(sim::Simulation, res::Resource)
-  i = 1
-  while true
+  for i in 1:10
     @coroutine client(sim, res, i, 10-i)
-    @yield return Timeout(sim, 0.5*rand())
-    i == 10 && break
-    i += 1
+    @yield Timeout(sim, 0.5*rand())
   end
 end
 
@@ -25,38 +25,30 @@ res = Resource(sim, 2; level=1)
 run(sim)
 
 @resumable function my_consumer(sim::Simulation, con::Container)
-  i = 1
-  while true
+  for i in 1:10
     amount = 3*rand()
     println("$(now(sim)), consumer is demanding $amount")
-    @yield return Timeout(sim, 1.0*rand())
+    @yield Timeout(sim, 1.0*rand())
     get_ev = Get(con, amount)
-    val = @yield return get_ev | Timeout(sim, rand())
+    val = @yield get_ev | Timeout(sim, rand())
     if val[get_ev].state == SimJulia.triggered
-      level = con.level
-      println("$(now(sim)), consumer is being served, level is $level")
-      @yield return Timeout(sim, 5.0*rand())
+      println("$(now(sim)), consumer is being served, level is ", con.level)
+      @yield Timeout(sim, 5.0*rand())
     else
       println("$(now(sim)), consumer has timed out")
       cancel(con, get_ev)
     end
-    i == 10 && break
-    i += 1
   end
 end
 
 @resumable function my_producer(sim::Simulation, con::Container)
-  i = 1
-  while true
+  for i in 1:10
     amount = 2*rand()
     println("$(now(sim)), producer is offering $amount")
-    @yield return Timeout(sim, 1.0*rand())
-    @yield return Put(con, amount)
-    level = con.level
-    println("$(now(sim)), producer is being served, level is $level")
-    @yield return Timeout(sim, 5.0*rand())
-    i == 10 && break
-    i += 1
+    @yield Timeout(sim, 1.0*rand())
+    @yield Put(con, amount)
+    println("$(now(sim)), producer is being served, level is ", con.level)
+    @yield Timeout(sim, 5.0*rand())
   end
 end