Rename Coroutine to Process

Author: BenLauwens

benchmark/coroutines_MM1.jl benchmark/processes_MM1.jlbenchmark/coroutines_MM1.jl renamed to benchmark/processes_MM1.jl

@@ -4,7 +4,7 @@ using ResumableFunctions, SimJulia, Distributions, BenchmarkTools
   while true
     dt = rand(Exponential(1 / lambd))
     @yield Timeout(sim, dt)
-    @coroutine customer(sim, server, mu)
+    @process customer(sim, server, mu)
   end
 end
 
@@ -18,7 +18,7 @@ end
 function test_mm1(n::Float64)
   sim = Simulation()
   server = Resource(sim)
-  @coroutine exp_source(sim, 1.0, server, 1.1)
+  @process exp_source(sim, 1.0, server, 1.1)
   run(sim, n)
 end
 

benchmark/coroutines_fibonnaci.jl benchmark/processes_fibonnaci.jlbenchmark/coroutines_fibonnaci.jl renamed to benchmark/processes_fibonnaci.jl

@@ -11,7 +11,7 @@ end
 
 function run_test()
   sim = Simulation()
-  @coroutine fibonnaci(sim)
+  @process fibonnaci(sim)
   run(sim, 10)
 end
 

examples/Ross_Simulation_7.7_A_repair_problem.ipynb

@@ -29,7 +29,9 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "metadata": {},
+   "metadata": {
+    "collapsed": true
+   },
    "outputs": [],
    "source": [
     "Pkg.update()\n",
@@ -46,7 +48,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 1,
+   "execution_count": null,
    "metadata": {
     "collapsed": true
    },
@@ -66,8 +68,10 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 2,
-   "metadata": {},
+   "execution_count": null,
+   "metadata": {
+    "collapsed": true
+   },
    "outputs": [],
    "source": [
     "const RUNS = 5\n",
@@ -91,22 +95,11 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 3,
+   "execution_count": null,
    "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "machine (generic function with 1 method)"
-      ]
-     },
-     "execution_count": 3,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
+   "outputs": [],
    "source": [
-    "@resumable function machine(sim::Simulation, repair_facility::Resource, spares::Store{Coroutine})\n",
+    "@resumable function machine(sim::Simulation, repair_facility::Resource, spares::Store{Process})\n",
     "    while true\n",
     "        try\n",
     "            @yield Timeout(sim, Inf)\n",
@@ -141,32 +134,21 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 4,
+   "execution_count": null,
    "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "start_sim (generic function with 1 method)"
-      ]
-     },
-     "execution_count": 4,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
+   "outputs": [],
    "source": [
-    "@resumable function start_sim(sim::Simulation, repair_facility::Resource, spares::Store{Coroutine})\n",
-    "    procs = Coroutine[]\n",
+    "@resumable function start_sim(sim::Simulation, repair_facility::Resource, spares::Store{Process})\n",
+    "    procs = Process[]\n",
     "    for i=1:N\n",
-    "        push!(procs, @coroutine machine(sim, repair_facility, spares))\n",
+    "        push!(procs, @process machine(sim, repair_facility, spares))\n",
     "    end\n",
     "    @yield Timeout(sim, 0.0)\n",
     "    for proc in procs\n",
     "        interrupt(proc)\n",
     "    end\n",
     "    for i=1:S\n",
-    "        @yield Put(spares, @coroutine machine(sim, repair_facility, spares))\n",
+    "        @yield Put(spares, @process machine(sim, repair_facility, spares))\n",
     "    end\n",
     "end"
    ]
@@ -180,7 +162,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 5,
+   "execution_count": null,
    "metadata": {},
    "outputs": [
     {
@@ -198,8 +180,8 @@
     "function sim_repair()\n",
     "    sim = Simulation()\n",
     "    repair_facility = Resource(sim)\n",
-    "    spares = Store{Coroutine}(sim)\n",
-    "    @coroutine start_sim(sim, repair_facility, spares)\n",
+    "    spares = Store{Process}(sim)\n",
+    "    @process start_sim(sim, repair_facility, spares)\n",
     "    msg = run(sim)\n",
     "    stop_time = now(sim)\n",
     "    println(\"At time $stop_time: $msg\")\n",
@@ -239,24 +221,6 @@
     "end\n",
     "println(sum(results)/RUNS)"
    ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "collapsed": true
-   },
-   "outputs": [],
-   "source": []
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "collapsed": true
-   },
-   "outputs": [],
-   "source": []
   }
  ],
  "metadata": {

src/SimJulia.jl

@@ -12,28 +12,22 @@ module SimJulia
   import Base.run, Base.now, Base.isless, Base.show, Base.interrupt, Base.yield
   import Base.(&), Base.(|)
 
-  export AbstractEvent
-  export value, state, environment
-  export Event, Timeout
-  export succeed, fail, @callback, remove_callback
-  export Operator
-  export (&), (|)
-  export Simulation
-  export run, now, active_process
+  export AbstractEvent, value, state, environment
+  export Event, Timeout, succeed, fail, @callback, remove_callback
+  export Operator, (&), (|)
+  export Simulation, run, now, active_process
   export nowDatetime
-  export OldProcess, @oldprocess
-  export yield, interrupt
-  export Coroutine, @coroutine
-  export Container, Resource, Store
-  export Put, Get, Request, Release, cancel, request, @request
+  export OldProcess, @oldprocess, yield
+  export Process, @process, interrupt
+  export Container, Resource, Store, Put, Get, Request, Release, cancel, request, @request
 
   include("base.jl")
   include("events.jl")
   include("operators.jl")
   include("simulations.jl")
   include("utils/time.jl")
   include("old/processes.jl")
-  include("coroutines.jl")
+  include("processes.jl")
   include("resources/base.jl")
   include("resources/containers.jl")
   include("resources/stores.jl")

src/coroutines.jl src/processes.jlsrc/coroutines.jl renamed to src/processes.jl

@@ -1,9 +1,9 @@
-mutable struct Coroutine <: DiscreteProcess
+mutable struct Process <: DiscreteProcess
   bev :: BaseEvent
   fsm :: ResumableFunctions.FiniteStateMachineIterator
   target :: AbstractEvent
   resume :: Function
-  function Coroutine(func::Function, env::Environment, args::Any...)
+  function Process(func::Function, env::Environment, args::Any...)
     cor = new()
     cor.bev = BaseEvent(env)
     cor.fsm = func(env, args...)
@@ -13,14 +13,14 @@ mutable struct Coroutine <: DiscreteProcess
   end
 end
 
-macro coroutine(expr)
+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)]
-  :(Coroutine($(func), $(args...)))
+  :(Process($(func), $(args...)))
 end
 
-function execute(ev::AbstractEvent, proc::Coroutine)
+function execute(ev::AbstractEvent, proc::Process)
   try
     env = environment(ev)
     set_active_process(env, proc)
@@ -37,7 +37,7 @@ function execute(ev::AbstractEvent, proc::Coroutine)
   end
 end
 
-function interrupt(proc::Coroutine, cause::Any=nothing)
+function interrupt(proc::Process, cause::Any=nothing)
   if !done(proc.fsm)
     remove_callback(proc.resume, proc.target)
     proc.target = Timeout(environment(proc); priority=typemax(Int8), value=InterruptException(proc, cause))

test/coroutines.jl test/processes.jltest/coroutines.jl renamed to test/processes.jl

@@ -23,7 +23,7 @@ end
   end
 end
 
-@resumable function test_interrupter(sim::Simulation, proc::Coroutine)
+@resumable function test_interrupter(sim::Simulation, proc::Process)
   @yield Timeout(sim, 2)
   interrupt(proc)
 end
@@ -41,28 +41,28 @@ end
 end
 
 sim = Simulation()
-@coroutine fibonnaci(sim)
+@process fibonnaci(sim)
 run(sim, 10)
 
 sim = Simulation()
-@coroutine test_process(sim, succeed(Event(sim)))
+@process test_process(sim, succeed(Event(sim)))
 run(sim)
 
 sim = Simulation()
-@coroutine test_process_exception(sim, Timeout(sim, 1, value=TestException()))
+@process test_process_exception(sim, Timeout(sim, 1, value=TestException()))
 try
   run(sim)
 catch exc
   println("$exc has been thrown")
 end
 
 sim = Simulation()
-@coroutine test_process_exception(sim, Timeout(sim, value=TestException()))
+@process test_process_exception(sim, Timeout(sim, value=TestException()))
 run(sim)
 
 sim = Simulation()
-proc = @coroutine test_interrupted(sim)
-@coroutine test_interrupter(sim, proc)
+proc = @process test_interrupted(sim)
+@process test_interrupter(sim, proc)
 try
   run(sim)
 catch exc

test/containers.jl test/resources/containers.jltest/containers.jl renamed to test/resources/containers.jl

@@ -12,14 +12,14 @@ end
 
 @resumable function generate(sim::Simulation, res::Resource)
   for i in 1:10
-    @coroutine client(sim, res, i, 10-i)
+    @process client(sim, res, i, 10-i)
     @yield Timeout(sim, 0.5*rand())
   end
 end
 
 sim = Simulation()
 res = Resource(sim, 2; level=1)
-@coroutine generate(sim, res)
+@process generate(sim, res)
 run(sim)
 
 @resumable function my_consumer(sim::Simulation, con::Container)
@@ -53,8 +53,8 @@ end
 
 sim = Simulation()
 con = Container(sim, 10.0; level=5.0)
-@coroutine my_consumer(sim, con)
-@coroutine my_producer(sim, con)
+@process my_consumer(sim, con)
+@process my_producer(sim, con)
 run(sim)
 
 function source(sim::Simulation, server::Resource)

test/stores.jl test/resources/stores.jltest/stores.jl renamed to test/resources/stores.jl

@@ -25,6 +25,6 @@ end
 
 sim = Simulation()
 sto = Store{StoreObject}(sim)
-@coroutine my_consumer(sim, sto)
-@coroutine my_producer(sim, sto)
+@process my_consumer(sim, sto)
+@process my_producer(sim, sto)
 run(sim)

test/runtests.jl

@@ -7,9 +7,9 @@ for test_file in [
   "simulations.jl",
   "utils/time.jl",
   "old/processes.jl",
-  "coroutines.jl",
-  "containers.jl",
-  "stores.jl",
+  "processes.jl",
+  "resources/containers.jl",
+  "resources/stores.jl",
   ]
   include(testpath(test_file))
 end

test/utils/time.jl

@@ -1,14 +1,15 @@
 using SimJulia
+using ResumableFunctions
 using Base.Dates
 
-function datetimetest(sim::Simulation)
+@resumable function datetimetest(sim::Simulation)
   println(nowDatetime(sim))
-  yield(Timeout(sim, Day(2)))
+  @yield Timeout(sim, Day(2))
   println(nowDatetime(sim))
 end
 
 datetime = now()
 sim = Simulation(datetime)
-@oldprocess datetimetest(sim)
+@process datetimetest(sim)
 run(sim, datetime+Month(3))
 println(nowDatetime(sim))