Merge branch 'stateful'

Author: BenLauwens

.travis.yml

@@ -3,7 +3,6 @@ os:
     - linux
     - osx
 julia:
-    - 0.5
     - nightly
 notifications:
     email: false

README.md

@@ -38,17 +38,21 @@ julia> Pkg.add("SimJulia")
 #### Release Notes
 
 * Version 0.4 is a complete rewrite: more julian and less pythonic.
-* Only supports Julia v0.5 and above.
+* Only supports Julia v0.6 and above.
 * Scheduling is based on TimeType and Period.
 * The discrete event features are on par with version 0.3. (STABLE)
+* Two ways of making `Processes` are provided:
+  - using the existing concept of `Tasks`: previous behaviour
+  - using a novel finite-statemachine approach: a lot faster but less transparent for the end user
 * The continuous time simulation is based on a quantized state system solver. (EXPERIMENTAL)
 * Documentation is automated with [Documenter.jl](https://github.com/JuliaDocs/Documenter.jl).
 
 
 #### Todo
 
-* Integration of stiff ODE.
+* Transparent output processing.
 * Extension to PDE by method of lines Integration.
+* Automatically running a large number of simulations (over a parameter space) on a cluster to do simulation based optimisations.
 
 
 #### Authors

REQUIRE

@@ -1,3 +1,2 @@
-julia 0.5
+julia 0.6
 DataStructures
-Compat

appveyor.yml

@@ -1,7 +1,5 @@
 environment:
   matrix:
-    - JULIAVERSION: "julialang/bin/winnt/x86/0.5/julia-0.5-latest-win32.exe"
-    - JULIAVERSION: "julialang/bin/winnt/x64/0.5/julia-0.5-latest-win64.exe"
     - JULIAVERSION: "julianightlies/bin/winnt/x86/julia-latest-win32.exe"
     - JULIAVERSION: "julianightlies/bin/winnt/x64/julia-latest-win64.exe"
 

src/SimJulia.jl

@@ -17,19 +17,26 @@ module SimJulia
   export succeed, fail
   export Operator
   export (&), (|)
+  export FiniteStateMachine, @stateful, @yield
+  export Coroutine, @Coroutine
   export Process, @Process
-  export yield, interrupt
+  export interrupt
   export Simulation, StopSimulation
   export run, now, active_process
   export Container, Resource, Store
-  export Put, Get, Request, Release, cancel, capacity
+  export Put, Get, Request, Release, cancel, capacity, @Request
 
   include("base.jl")
   include("events.jl")
   include("operators.jl")
-  include("process.jl")
   include("time.jl")
   include("simulation.jl")
+  include("finitestatemachines/utils.jl")
+  include("finitestatemachines/transforms.jl")
+  include("finitestatemachines/macro.jl")
+  include("coroutines.jl")
+  include("tasks/base.jl")
+  include("processes.jl")
   include("resources/base.jl")
   include("resources/containers.jl")
   include("resources/stores.jl")

src/base.jl

@@ -1,6 +1,4 @@
-using Compat
-
-@compat abstract type Environment end
+abstract type Environment end
 
 """
 The parent type for all events.
@@ -17,46 +15,34 @@ Once the events is scheduled, it has a value.
 
 An event has also a list of callbacks. A callback can be any function as long as it accepts an instance of a subtype of `AbstractEvent` as its first argument. Once an event gets triggered, all callbacks will be invoked. Callbacks can do further processing with the value it has produced.
 """
-@compat abstract type AbstractEvent{E<:Environment} end
+abstract type AbstractEvent{E<:Environment} end
 
 @enum EVENT_STATE idle=0 scheduled=1 triggered=2
 
-immutable EventTriggered{E<:Environment} <: Exception
+struct EventTriggered{E<:Environment} <: Exception
   ev :: AbstractEvent{E}
 end
 
-immutable EventNotIdle{E<:Environment} <: Exception
+struct EventNotIdle{E<:Environment} <: Exception
   ev :: AbstractEvent{E}
 end
 
-type BaseEvent{E<:Environment}
+mutable struct BaseEvent{E<:Environment}
   env :: E
   id :: UInt
   cid :: UInt
   callbacks :: DataStructures.PriorityQueue{Function, UInt}
   state :: EVENT_STATE
   value :: Any
-  function BaseEvent(env::E)
+  function BaseEvent{E}(env::E) where E<:Environment
     new(env, env.eid+=one(UInt), zero(UInt), DataStructures.PriorityQueue(Function, UInt), idle, nothing)
   end
 end
 
-function BaseEvent{E<:Environment}(env::E) :: BaseEvent
+function BaseEvent{E<:Environment}(env::E)
   BaseEvent{E}(env)
 end
 
-  # type BaseEvent{E<:Environment}
-  #   env :: E
-  #   id :: UInt
-  #   cid :: UInt
-  #   callbacks :: DataStructures.PriorityQueue{Function, UInt}
-  #   state :: EVENT_STATE
-  #   value :: Any
-  #   function BaseEvent{E}(env::E) where E<:Environment
-  #     new(env, env.eid+=one(UInt), zero(UInt), DataStructures.PriorityQueue(Function, UInt), idle, nothing)
-  #   end
-  # end
-
 function show(io::IO, ev::AbstractEvent)
   print(io, "$(typeof(ev)) $(ev.bev.id)")
 end

src/coroutines.jl

@@ -0,0 +1,84 @@
+"""
+A `Coroutine` is an abstraction for an event yielding function, i.e. a process function.
+
+The process function can suspend its execution by yielding an instance of `AbstractEvent`. The `Environment` will take care of resuming the process function with the value of that event once it has happened. The exception of failed events is also thrown into the process function.
+
+A `Coroutine` is a subtype of `AbstractEvent`. It is triggered, once the process functions returns or raises an exception. The value of the process is the return value of the process function or the exception, respectively.
+
+**Signature**:
+
+Coroutine{E<:Environment} <: AbstractEvent{E}
+
+**Fields**:
+
+- bev :: BaseEvent{E}
+- task :: Task
+- target :: AbstractEvent{E}
+- resume :: Function
+
+**Constructor**:
+
+Coroutine{E<:Environment}(func::Function, env::E, args::Any...)
+"""
+type Coroutine{E<:Environment} <: AbstractProcess{E}
+  bev :: BaseEvent{E}
+  fsm :: FiniteStateMachine
+  target :: AbstractEvent{E}
+  resume :: Function
+  function Coroutine{E}(func::Function, env::E, args::Any...) where E<:Environment
+    proc = new()
+    proc.bev = BaseEvent(env)
+    proc.fsm = func(env, args...)
+    proc.target = Timeout(env)
+    proc.resume = append_callback(execute, proc.target, proc)
+    return proc
+  end
+end
+
+function Coroutine{E<:Environment}(func::Function, env::E, args::Any...)
+  Coroutine{E}(func, env, args...)
+end
+
+"""
+Creates a `Coroutine` with process function `func` having a required argument `env`, i.e. an instance of a subtype of `Environment`, and a variable number of arguments `args...`.
+
+**Signature**:
+
+@Coroutine func(env, args...)
+"""
+macro Coroutine(ex)
+  if ex.head == :call
+    func = esc(ex.args[1])
+    args = [esc(ex.args[n]) for n in 2:length(ex.args)]
+    return :(Coroutine($(func), $(args...)))
+  end
+end
+
+function execute{E<:Environment}(ev::AbstractEvent{E}, proc::Coroutine{E})
+  try
+    env = environment(ev)
+    set_active_process(env, proc)
+    target = proc.fsm(value(ev))
+    if iscoroutinedone(proc.fsm)
+      schedule(proc.bev, value=target)
+    else
+      if state(target) == triggered
+        proc.target = Timeout(env, value=value(target))
+      else
+        proc.target = target
+      end
+      proc.resume = append_callback(execute, proc.target, proc)
+    end
+    set_active_process(env)
+  catch exc
+    rethrow(exc)
+  end
+end
+
+function interrupt(proc::Coroutine, cause::Any=nothing)
+  if !iscoroutinedone(proc.fsm)
+    remove_callback(proc.resume, proc.target)
+    proc.target = Timeout(environment(proc), priority=true, value=InterruptException(proc, cause))
+    proc.resume = append_callback(execute, proc.target, proc)
+  end
+end

src/events.jl

@@ -1,11 +1,11 @@
-type Event{E<:Environment} <: AbstractEvent{E}
+struct Event{E<:Environment} <: AbstractEvent{E}
   bev :: BaseEvent{E}
-  function Event(env::E)
+  function Event{E}(env::E) where E<:Environment
     new(BaseEvent(env))
   end
 end
 
-function Event{E<:Environment}(env::E) :: Event{E}
+function Event{E<:Environment}(env::E)
   Event{E}(env)
 end
 
@@ -41,9 +41,9 @@ Timeout{E<:Environment} <: AbstractEvent{E}
 - Timeout{E<:Environment}(env::E, delay::Number=0; priority::Bool=false, value::Any=nothing)
 """
 
-type Timeout{E<:Environment} <: AbstractEvent{E}
+struct Timeout{E<:Environment} <: AbstractEvent{E}
   bev :: BaseEvent{E}
-  function Timeout(env::E, delay::Union{Period, Number}, priority::Bool, value::Any)
+  function Timeout{E}(env::E, delay::Union{Period, Number}, priority::Bool, value::Any) where E<:Environment
     ev = new(BaseEvent(env))
     schedule(ev.bev, delay, priority=priority, value=value)
     return ev

src/finitestatemachines/macro.jl

@@ -0,0 +1,54 @@
+macro yield(val)
+  :($(esc(val)))
+end
+
+abstract type FiniteStateMachine end
+
+iscoroutinedone(fsm::FiniteStateMachine) = fsm._state == 0xff
+
+macro stateful(expr::Expr)
+  expr.head != :function && error("Not a function definition!")
+  args = getArguments(expr)
+  func_name = shift!(args)
+  type_name = gensym()
+  slots = getSlots(expr, func_name)
+  type_expr = :(
+    type $type_name <: FiniteStateMachine
+      _state :: UInt8
+      $((:($slotname :: $(slottype == Union{} ? Any : :($slottype))) for (slotname, slottype) in slots)...)
+      function $type_name($((:($arg::$(slots[:($arg)])) for arg in args)...))
+        fsm = new()
+        fsm._state = 0x00
+        $((:(fsm.$arg = $arg) for arg in args)...)
+        fsm
+      end
+    end
+  )
+  new_expr = deepcopy(expr.args[2])
+  transformVars!(new_expr, keys(slots))
+  n = transformYield!(new_expr)
+  func_expr = :(
+    function (_fsm::$type_name)(_ret::Any=nothing)
+      _fsm._state == 0x00 && @goto _STATE_0
+      $((:(_fsm._state == $i && @goto $(Symbol("_STATE_",:($i)))) for i in 0x01:n)...)
+      error("Iterator has stopped!")
+      @label _STATE_0
+      _fsm._state = 0xff
+      $((:($arg) for arg in new_expr.args)...)
+    end
+  )
+  if expr.args[1].head == Symbol("::")
+    func_expr.args[1] = Expr(Symbol("::"), func_expr.args[1], expr.args[1].args[2])
+  end
+  call_expr = deepcopy(expr)
+  if call_expr.args[1].head == Symbol("::")
+    call_expr.args[1] = call_expr.args[1].args[1]
+  end
+  call_expr.head = Symbol("=")
+  call_expr.args[2] = :($type_name($((:($arg) for arg in args)...)))
+  esc(quote
+    $type_expr
+    $func_expr
+    $call_expr
+  end)
+end

src/finitestatemachines/transforms.jl

@@ -0,0 +1,79 @@
+function transformVars!(expr::Expr, symbols::Base.KeyIterator{Dict{Symbol,Type}})
+  for i in 1:length(expr.args)
+    if expr.head == :kw && i == 1
+
+    elseif expr.head == Symbol(".") && i == 2
+      
+    elseif isa(expr.args[i], Symbol) && in(expr.args[i], symbols)
+      expr.args[i] = :(_fsm.$(expr.args[i]))
+    elseif isa(expr.args[i], Expr)
+      transformVars!(expr.args[i], symbols)
+    end
+  end
+end
+
+function transformTry!(expr::Expr, n::UInt8=0x00, super::Expr=:(), line_no::Int=0, super_try::Expr=:(), line_try::Int=0) :: UInt8
+  for (i, arg) in enumerate(expr.args)
+    if isa(arg, Expr)
+      if arg.head == :line
+        line_no = i+1
+        super = expr
+      elseif arg.head == :macrocall && arg.args[1] == Symbol("@yield")
+        n += one(UInt8)
+        if expr == super
+          expr.args[i] = :(isa(_ret, Exception) && throw(_ret))
+        else
+          expr.args[i] = :(_ret)
+          insert!(super.args, line_no+1, :(isa(_ret, Exception) && throw(_ret)))
+        end
+        insert!(super.args, line_no, :(_fsm._state = 0xff))
+        insert!(super.args, line_no, arg.args[2])
+        insert!(super.args, line_no, :(_fsm._state = $n))
+        insert!(super_try.args, line_try, :(@label $(Symbol("_STATE_",:($n)))))
+        insert!(super_try.args, line_try, deepcopy(super_try.args[line_try+1]))
+        for j in length(super_try.args[line_try].args[1].args):-1:line_no+2
+          deleteat!(super_try.args[line_try].args[1].args, j)
+        end
+        for j in 1:line_no+1
+          deleteat!(super_try.args[line_try+2].args[1].args, 1)
+        end
+        break
+      else
+        m = transformTry!(arg, n, super, line_no, super_try, line_try)
+        if m > n
+          n=m
+          break
+        end
+      end
+    end
+  end
+  n
+end
+
+function transformYield!(expr::Expr, n::UInt8=0x00, super::Expr=:(), line_no::Int=0) :: UInt8
+  for (i, arg) in enumerate(expr.args)
+    if isa(arg, Expr)
+      if arg.head == :try
+        n = transformTry!(arg.args[1], n, super, line_no, expr, i)
+        println("hi")
+      elseif arg.head == :line
+        line_no = i+1
+        super = expr
+      elseif arg.head == :macrocall && arg.args[1] == Symbol("@yield")
+        n += one(UInt8)
+        if expr == super
+          expr.args[i] = :(_fsm._state = 0xff)
+        else
+          expr.args[i] = :(_ret)
+          insert!(super.args, line_no, :(_fsm._state = 0xff))
+        end
+        insert!(super.args, line_no, :(@label $(Symbol("_STATE_",:($n)))))
+        insert!(super.args, line_no, arg.args[2])
+        insert!(super.args, line_no, :(_fsm._state = $n))
+      else
+        n = transformYield!(arg, n, super, line_no)
+      end
+    end
+  end
+  n
+end