Change calling conventions for events

Author: BenLauwens

README.md

@@ -56,7 +56,7 @@ julia> Pkg.add("SimJulia")
 
     function datetimetest(sim::Simulation)
       println(nowDatetime(sim))
-      yield(Timeout(sim, Day(2)))
+      yield(timeout(sim, Day(2)))
       println(nowDatetime(sim))
     end
 
@@ -73,7 +73,7 @@ julia> Pkg.add("SimJulia")
         b = 1.0
         while true
           println(now(sim), ": ", a)
-          yield(Timeout(sim, 1))
+          yield(timeout(sim, 1))
           a, b = b, a+b
         end
       end
@@ -91,7 +91,7 @@ julia> Pkg.add("SimJulia")
         b = 1.0
         while true
           println(now(sim), ": ", a)
-          @yield Timeout(sim, 1)
+          @yield timeout(sim, 1)
           a, b = b, a+b
         end
       end

benchmark/old_processes_MM1.jl

@@ -3,23 +3,23 @@ using SimJulia, Distributions, BenchmarkTools
 function exp_source(sim::Simulation, lambd::Float64, server::Resource, mu::Float64)
   while true
     dt = rand(Exponential(1/lambd))
-    yield(Timeout(sim, dt))
+    yield(timeout(sim, dt))
     @oldprocess customer(sim, server, mu)
   end
 end
 
 function customer(sim::Simulation, server::Resource, mu::Float64)
-  yield(Request(server))
+  yield(request(server))
   dt = rand(Exponential(1/mu))
-  yield(Timeout(sim, dt))
-  yield(Release(server))
+  yield(timeout(sim, dt))
+  yield(release(server))
 end
 
 function customer2(sim::Simulation, server::Resource, mu::Float64)
   request(server) do req
     yield(req)
     dt = rand(Exponential(1/mu))
-    yield(Timeout(sim, dt))
+    yield(timeout(sim, dt))
   end
 end
 

benchmark/old_processes_fibonnaci.jl

@@ -4,7 +4,7 @@ function fibonnaci(sim::Simulation)
   a = 0.0
   b = 1.0
   while true
-    yield(Timeout(sim, 1))
+    yield(timeout(sim, 1))
     a, b = b, a+b
   end
 end

benchmark/processes_MM1.jl

@@ -3,16 +3,16 @@ 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 Timeout(sim, dt)
+    @yield timeout(sim, dt)
     @process customer(sim, server, mu)
   end
 end
 
 @resumable function customer(sim::Simulation, server::Resource, mu::Float64)
-  @yield Request(server)
+  @yield request(server)
   dt = rand(Exponential(1 / mu))
-  @yield Timeout(sim, dt)
-  @yield Release(server)
+  @yield timeout(sim, dt)
+  @yield release(server)
 end
 
 function test_mm1(n::Float64)

benchmark/processes_fibonnaci.jl

@@ -4,7 +4,7 @@ using ResumableFunctions, SimJulia, BenchmarkTools
   a = 0.0
   b = 1.0
   while true
-    @yield Timeout(sim, 1)
+    @yield timeout(sim, 1)
     a, b = b, a+b
   end
 end

docs/src/examples/ross.md

@@ -32,19 +32,19 @@ const G = Exponential(MU)
 
 @resumable function machine(env::Environment, repair_facility::Resource, spares::Store{Process})
     while true
-        try @yield Timeout(env, Inf) end
-        @yield Timeout(env, rand(F))
-        get_spare = Get(spares)
-        @yield get_spare | Timeout(env)
+        try @yield timeout(env, Inf) end
+        @yield timeout(env, rand(F))
+        get_spare = get(spares)
+        @yield get_spare | timeout(env)
         if state(get_spare) != SimJulia.idle 
             @yield interrupt(value(get_spare))
         else
             throw(SimJulia.StopSimulation("No more spares!"))
         end
-        @yield Request(repair_facility)
-        @yield Timeout(env, rand(G))
-        @yield Release(repair_facility)
-        @yield Put(spares, active_process(env))
+        @yield request(repair_facility)
+        @yield timeout(env, rand(G))
+        @yield release(repair_facility)
+        @yield put(spares, active_process(env))
     end
 end
 
@@ -53,12 +53,12 @@ end
     for i in 1:N 
         push!(procs, @process machine(env, repair_facility, spares)) 
     end
-    @yield Timeout(env)
+    @yield timeout(env)
     for proc in procs 
         @yield interrupt(proc)
     end
     for i in 1:S 
-        @yield Put(spares, @process machine(env, repair_facility, spares)) 
+        @yield put(spares, @process machine(env, repair_facility, spares)) 
     end
 end
 

docs/src/guides/basics.md

@@ -21,7 +21,7 @@ using ResumableFunctions
 using SimJulia
 
 @resumable function example(env::Environment)
-  event = Timeout(env, 1, value=42)
+  event = timeout(env, 1, value=42)
   value = @yield event
   println("now=", now(env), ", value=", value)
 end
@@ -35,11 +35,11 @@ run(sim)
 now=1.0, value=42
 ```
 
-The `example` process function above first creates a `Timeout` event. It passes the environment, a delay, and a value to it. The `Timeout` schedules itself at `now + delay` (that’s why the environment is required); other event types usually schedule themselves at the current simulation time.
+The `example` process function above first creates a `timeout` event. It passes the environment, a delay, and a value to it. The `timeout` schedules itself at `now + delay` (that’s why the environment is required); other event types usually schedule themselves at the current simulation time.
 
-The process function then yields the event and thus gets suspended. It is resumed, when SimJulia processes the `Timeout` event. The process function also receives the event’s value (42) – this is, however, optional, so `@yield event` would have been okay if the you were not interested in the value or if the event had no value at all.
+The process function then yields the event and thus gets suspended. It is resumed, when SimJulia processes the `timeout` event. The process function also receives the event’s value (42) – this is, however, optional, so `@yield event` would have been okay if the you were not interested in the value or if the event had no value at all.
 
-Finally, the process function prints the current simulation time (that is accessible via the `now` function) and the `Timeout`’s value.
+Finally, the process function prints the current simulation time (that is accessible via the `now` function) and the `timeout`’s value.
 
 If all required process functions are defined, you can instantiate all objects for your simulation. In most cases, you start by creating an instance of `Environment`, e.g. a `Simulation`, because you’ll need to pass it around a lot when creating everything else.
 

docs/src/guides/environments.md

@@ -30,7 +30,7 @@ end
 
 - Instead of passing a number as second argument to `run`, you can also pass any event to it. `run` will then return when the event has been processed.
 
-  Assuming that the current time is 0, `run(env, Timeout(env, 5))` is equivalent to `run(env, 5)`.
+  Assuming that the current time is 0, `run(env, timeout(env, 5))` is equivalent to `run(env, 5)`.
 
   You can also pass other types of events (remember, that a `Process` is an event, too):
 
@@ -39,7 +39,7 @@ using ResumableFunctions
 using SimJulia
 
 @resumable function my_process(env::Environment)
-  @yield Timeout(env, 1)
+  @yield timeout(env, 1)
   "Monty Python's Flying Circus"
 end
 
@@ -63,14 +63,14 @@ end
 
 ## State access
 
-The environment allows you to get the current simulation time via the function `now`. The simulation time is a number without unit and is increased via `Timeout` events.
+The environment allows you to get the current simulation time via the function `now`. The simulation time is a number without unit and is increased via `timeout` events.
 
 By default, the simulation starts at time 0, but you can pass an `initial_time` to the `Simulation` constructor to use something else.
 
 Note
 
 !!! note
-    Although the simulation time is technically unitless, you can pretend that it is, for example, in milliseconds and use it like a timestamp returned by `Base.Dates.datetime2epochm` to calculate a date or the day of the week. The `Simulation` constructor and the `run` function accept as argument a `Base.Dates.DateTime` and the `Timeout` constructor a `Base.Dates.Delay`. Together with the convenience function `nowDateTime` a simulation can transparantly schedule its events in seconds, minutes, hours, days, ...
+    Although the simulation time is technically unitless, you can pretend that it is, for example, in milliseconds and use it like a timestamp returned by `Base.Dates.datetime2epochm` to calculate a date or the day of the week. The `Simulation` constructor and the `run` function accept as argument a `Base.Dates.DateTime` and the `timeout` constructor a `Base.Dates.Delay`. Together with the convenience function `nowDateTime` a simulation can transparantly schedule its events in seconds, minutes, hours, days, ...
 
 The function `active_process` is comparable to `Base.Libc.getpid` and returns the current active `Process`. If no process is active, a `NullException` is thrown. A process is active when its process function is being executed. It becomes inactive (or suspended) when it yields an event.
 
@@ -90,7 +90,7 @@ julia> @resumable function my_proc(env::Environment)
          while true
            println(active_process(env))
            subfunc(env)
-           @yield Timeout(env, 1)
+           @yield timeout(env, 1)
          end
        end
 my_proc (generic function with 1 method)
@@ -122,7 +122,7 @@ A generator function can have a return value:
 
 ```julia
 @resumable function my_proc(env::Environment)
-  @yield Timeout(sim, 1)
+  @yield timeout(sim, 1)
   150
 end
 ```

docs/src/guides/events.md

@@ -3,7 +3,7 @@
 SimJulia includes an extensive set of event types for various purposes. All of them are descendants of `AbstractEvent`. Here the following events are discussed:
 
 - `Event`
-- `Timeout`
+- `timeout`
 - `Operator`
 
 The guide to resources describes the various resource events.

docs/src/index.md

@@ -16,7 +16,7 @@ julia> using SimJulia
 julia> @resumable function clock(sim::Simulation, name::String, tick::Float64)
          while true
            println(name, " ", now(sim))
-           @yield Timeout(sim, tick)
+           @yield timeout(sim, tick)
          end
        end
 clock (generic function with 1 method)