Replace Process with OldProcess

BenLauwens · BenLauwens · commit 37408cc9f4e9 · 2017-09-14T12:37:54.000+02:00
diff --git a/README.md b/README.md
@@ -27,11 +27,25 @@ julia> Pkg.add("SimJulia")
 [![](https://img.shields.io/badge/docs-stable-blue.svg)](https://BenLauwens.github.io/SimJulia.jl/stable)
 [![](https://img.shields.io/badge/docs-latest-blue.svg)](https://BenLauwens.github.io/SimJulia.jl/latest)
 
+## License
+
+[![License](http://img.shields.io/badge/license-MIT-brightgreen.svg?style=flat)](LICENSE.md)
+
+## Authors
+
+* Ben Lauwens, Royal Military Academy, Brussels, Belgium.
+
+## Contributing
+
+* To discuss problems or feature requests, file an issue. For bugs, please include as much information as possible, including operating system, julia version, and version of the dependencies: `DataStructures` and `ResumableFunctions`.
+* To contribute, make a pull request. Contributions should include tests for any new features/bug fixes.
 
 ## Release Notes
 
-* 2017: v0.5 does no longer integrate a continuous time solver. A continuous time solver based on the standalone [QSS](https://sourceforge.net/projects/qssengine/) solver using SimJulia as its discrete event engine can be found in the repository [QuantizedStateSystems](https://github.com/BenLauwens/QuantizedStateSystems.jl.git):
-  * Documentation is automated with [Documenter.jl](https://github.com/JuliaDocs/Documenter.jl).
+* 2017: v0.5
+  * The old way of making processes is deprecated in favor of the semi-coroutine approach as implemented in [ResumableFunctions](https://github.com/BenLauwens/ResumableFunctions.jl.git). The `@process` macro replaces the `@coroutine` macro. The old `@process` macro is temporarily renamed `@oldprocess` and will be removed when the infrastructure supporting the `produce` and the `consume` functions are no longer available in Julia. (DONE)
+  * This version no longer integrates a continuous time solver. A continuous simulation framework based on [DISCO](http://www.akira.ruc.dk/~keld/research/DISCO/) and inspired by the standalone [QSS](https://sourceforge.net/projects/qssengine/) solver using SimJulia as its discrete-event engine can be found in the repository [QuantizedStateSystems](https://github.com/BenLauwens/QuantizedStateSystems.jl.git) (WIP):
+  * Documentation is automated with [Documenter.jl](https://github.com/JuliaDocs/Documenter.jl) (WIP).
 * 2017: v0.4.1, the `resumable` and `yield` macro are put in a seperate package [ResumableFunctions](https://github.com/BenLauwens/ResumableFunctions.jl.git): 
   * Users have to take into account the following syntax change: `@yield return arg` is replaced by `@yield arg`.
 * 2017: v0.4 only supports Julia v0.6 and above. It is a complete rewrite: more julian and less pythonic. The discrete event features are on par with v0.3 (SimPy v3) and following features are added:
@@ -95,15 +109,4 @@ julia> Pkg.add("SimJulia")
 
 ## Todo
 
-* Transparent output processing.
-* Automatically running a large number of simulations (over a parameter space) on a cluster to do simulation based optimisation.
-
-
-## Authors
-
-* Ben Lauwens, Royal Military Academy, Brussels, Belgium.
-
-
-## License
-
-[![License](http://img.shields.io/badge/license-MIT-brightgreen.svg?style=flat)](LICENSE.md)
+* Transparent statistics gathering for resources.
diff --git a/benchmark/old_processes_MM1.jl b/benchmark/old_processes_MM1.jl
@@ -4,7 +4,7 @@ function exp_source(sim::Simulation, lambd::Float64, server::Resource, mu::Float
   while true
     dt = rand(Exponential(1/lambd))
     yield(Timeout(sim, dt))
-    @process customer(sim, server, mu)
+    @oldprocess customer(sim, server, mu)
   end
 end
 
@@ -26,7 +26,7 @@ end
 function test_mm1(n::Float64)
   sim = Simulation()
   server = Resource(sim)
-  @process exp_source(sim, 1.0, server, 1.1)
+  @oldprocess exp_source(sim, 1.0, server, 1.1)
   run(sim, n)
 end
 
diff --git a/benchmark/old_processes_fibonnaci.jl b/benchmark/old_processes_fibonnaci.jl
@@ -11,7 +11,7 @@ end
 
 function run_test()
   sim = Simulation()
-  @process fibonnaci(sim)
+  @oldprocess fibonnaci(sim)
   run(sim, 10)
 end
 
diff --git a/docs/make.jl b/docs/make.jl
@@ -7,7 +7,8 @@ makedocs(
   format   = :html,
   sitename = "SimJulia.jl",
   pages    = [
-    "Home" => "index.md",
+    "Overview" => "index.md",
+    "Manual" => "manual.md",
   ]
 )
 
diff --git a/docs/src/index.md b/docs/src/index.md
@@ -1,3 +1,3 @@
 # Overview
 
-SimJulia is a discrete event process oriented simulation framework written in [Julia](http://julialang.org/) inspired by the Python library [SimPy](https://simpy.readthedocs.io/).
+SimJulia is a discrete-event process-oriented simulation framework written in [Julia](http://julialang.org/) inspired by the Python library [SimPy](https://simpy.readthedocs.io/). Its preferred process dispatcher is based on semi-coroutines scheduling as implemented in [ResumableFunctions](git@github.com:BenLauwens/ResumableFunctions.jl.git). A `Process` in SimJulia is defined by a `@resumable function` yielding `Events`. SimJulia also provides three types of shared resources to model limited capacity congestion points: `Resources`, `Containers` and `Stores`. The API is modeled after the SimPy API but using some specific Julia semantics.
diff --git a/docs/src/manual.md b/docs/src/manual.md
@@ -0,0 +1,2 @@
+# Manual
+
diff --git a/src/SimJulia.jl b/src/SimJulia.jl
@@ -21,7 +21,7 @@ module SimJulia
   export Simulation
   export run, now, active_process
   export nowDatetime
-  export Process, @process
+  export OldProcess, @oldprocess
   export yield, interrupt
   export Coroutine, @coroutine
   export Container, Resource, Store
@@ -32,8 +32,7 @@ module SimJulia
   include("operators.jl")
   include("simulations.jl")
   include("utils/time.jl")
-  include("tasks/base.jl")
-  include("processes.jl")
+  include("old/processes.jl")
   include("coroutines.jl")
   include("resources/base.jl")
   include("resources/containers.jl")
diff --git a/src/old/processes.jl b/src/old/processes.jl
@@ -1,9 +1,25 @@
-mutable struct Process <: DiscreteProcess
+function produce(v)
+  ct = current_task()
+  consumer = ct.consumers
+  ct.consumers = nothing
+  Base.schedule_and_wait(consumer, v)
+  return consumer.result
+end
+
+function consume(producer::Task, values...)
+  istaskdone(producer) && return producer.value
+  ct = current_task()
+  ct.result = length(values)==1 ? values[1] : values
+  producer.consumers = ct
+  Base.schedule_and_wait(producer)
+end
+
+mutable struct OldProcess <: DiscreteProcess
   bev :: BaseEvent
   task :: Task
   target :: AbstractEvent
   resume :: Function
-  function Process(func::Function, env::Environment, args::Any...)
+  function OldProcess(func::Function, env::Environment, args::Any...)
     proc = new()
     proc.bev = BaseEvent(env)
     proc.task = @task func(env, args...)
@@ -13,11 +29,11 @@ mutable struct Process <: DiscreteProcess
   end
 end
 
-macro process(expr)
+macro oldprocess(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...)))
+  :(OldProcess($(func), $(args...)))
 end
 
 function yield(target::AbstractEvent)
@@ -30,7 +46,7 @@ function yield(target::AbstractEvent)
   return ret
 end
 
-function execute(ev::AbstractEvent, proc::Process)
+function execute(ev::AbstractEvent, proc::OldProcess)
   try
     env = environment(ev)
     set_active_process(env, proc)
@@ -42,7 +58,7 @@ function execute(ev::AbstractEvent, proc::Process)
   end
 end
 
-function interrupt(proc::Process, cause::Any=nothing)
+function interrupt(proc::OldProcess, cause::Any=nothing)
   if !istaskdone(proc.task)
     remove_callback(proc.resume, proc.target)
     proc.target = Timeout(environment(proc); priority=typemax(Int8), value=InterruptException(proc, cause))
diff --git a/src/tasks/base.jl b/src/tasks/base.jl
diff --git a/test/containers.jl b/test/containers.jl
@@ -62,7 +62,7 @@ function source(sim::Simulation, server::Resource)
   while true
     i += 1
     yield(Timeout(sim, rand()))
-    @process customer(sim, server, i)
+    @oldprocess customer(sim, server, i)
   end
 end
 
@@ -80,5 +80,5 @@ end
 
 sim = Simulation()
 server = Resource(sim)
-@process source(sim, server)
+@oldprocess source(sim, server)
 run(sim, 10.0)
diff --git a/test/old/processes.jl b/test/old/processes.jl
@@ -23,7 +23,7 @@ function test_process_exception(sim::Simulation, ev::AbstractEvent)
   end
 end
 
-function test_interrupter(sim::Simulation, proc::Process)
+function test_interrupter(sim::Simulation, proc::OldProcess)
   yield(Timeout(sim, 2))
   interrupt(proc)
 end
@@ -41,30 +41,51 @@ function test_interrupted(sim::Simulation)
 end
 
 sim = Simulation()
-@process fibonnaci(sim)
+@oldprocess fibonnaci(sim)
 run(sim, 10)
 
 sim = Simulation()
-@process test_process(sim, succeed(Event(sim)))
+@oldprocess test_process(sim, succeed(Event(sim)))
 run(sim)
 
 sim = Simulation()
-@process test_process_exception(sim, Timeout(sim, 1, value=TestException()))
+@oldprocess test_process_exception(sim, Timeout(sim, 1, value=TestException()))
 try
   run(sim)
 catch exc
   println("$exc has been thrown")
 end
 
 sim = Simulation()
-@process test_process_exception(sim, Timeout(sim, value=TestException()))
+@oldprocess test_process_exception(sim, Timeout(sim, value=TestException()))
 run(sim)
 
 sim = Simulation()
-proc = @process test_interrupted(sim)
-@process test_interrupter(sim, proc)
+proc = @oldprocess test_interrupted(sim)
+@oldprocess test_interrupter(sim, proc)
 try
   run(sim)
 catch exc
   println("$exc has been thrown")
 end
+
+function fibonnaci(sim::Simulation)
+  a = 0.0
+  b = 1.0
+  for i = 1:10
+    println("Fibonnaci value equals ", a, " at time ", now(sim))
+    yield(Timeout(sim, 1.0))
+    a, b = b, a+b
+  end
+  a
+end
+
+function wait_for_process(sim::Simulation, process::OldProcess)
+  val = yield(process)
+  println("Fibonnaci ended with ", val, " at time ", now(sim))
+end
+
+sim = Simulation()
+fib = @oldprocess fibonnaci(sim)
+wait = @oldprocess wait_for_process(sim, fib)
+run(sim)
diff --git a/test/operators.jl b/test/operators.jl
diff --git a/test/runtests.jl b/test/runtests.jl
@@ -3,11 +3,10 @@ testpath(f) = joinpath(dirname(@__FILE__), f)
 for test_file in [
   "base.jl",
   "events.jl",
-  "utils/operators.jl",
+  "operators.jl",
   "simulations.jl",
   "utils/time.jl",
-  "tasks/base.jl",
-  "processes.jl",
+  "old/processes.jl",
   "coroutines.jl",
   "containers.jl",
   "stores.jl",
diff --git a/test/tasks/base.jl b/test/tasks/base.jl
diff --git a/test/utils/time.jl b/test/utils/time.jl
@@ -9,6 +9,6 @@ end
 
 datetime = now()
 sim = Simulation(datetime)
-@process datetimetest(sim)
+@oldprocess datetimetest(sim)
 run(sim, datetime+Month(3))
 println(nowDatetime(sim))

Original file line number	Diff line number	Diff line change
`@@ -7,7 +7,8 @@ makedocs(`
`7`	`7`	`format = :html,`
`8`	`8`	`sitename = "SimJulia.jl",`
`9`	`9`	`pages = [`
`10`		`- "Home" => "index.md",`
	`10`	`+ "Overview" => "index.md",`
	`11`	`+ "Manual" => "manual.md",`
`11`	`12`	`]`
`12`	`13`	`)`
`13`	`14`
Original file line number	Diff line number	Diff line change
`@@ -1,3 +1,3 @@`
`1`	`1`	`# Overview`
`2`	`2`
`3`		`-SimJulia is a discrete event process oriented simulation framework written in [Julia](http://julialang.org/) inspired by the Python library [SimPy](https://simpy.readthedocs.io/).`
	`3`	+SimJulia is a discrete-event process-oriented simulation framework written in [Julia](http://julialang.org/) inspired by the Python library [SimPy](https://simpy.readthedocs.io/). Its preferred process dispatcher is based on semi-coroutines scheduling as implemented in [ResumableFunctions](git@github.com:BenLauwens/ResumableFunctions.jl.git). A `Process` in SimJulia is defined by a `@resumable function` yielding `Events`. SimJulia also provides three types of shared resources to model limited capacity congestion points: `Resources`, `Containers` and `Stores`. The API is modeled after the SimPy API but using some specific Julia semantics.