deprecate ConcurrentSim.requests in favor of Base.lock

Author: Krastanov

benchmark/old_processes_MM1.jl

@@ -9,14 +9,14 @@ function exp_source(sim::Simulation, lambd::Float64, server::Resource, mu::Float
 end
 
 function customer(sim::Simulation, server::Resource, mu::Float64)
-  yield(request(server))
+  yield(lock(server))
   dt = rand(Exponential(1/mu))
   yield(timeout(sim, dt))
   yield(release(server))
 end
 
 function customer2(sim::Simulation, server::Resource, mu::Float64)
-  request(server) do req
+  lock(server) do req
     yield(req)
     dt = rand(Exponential(1/mu))
     yield(timeout(sim, dt))

benchmark/processes_MM1.jl

@@ -9,7 +9,7 @@ using ResumableFunctions, ConcurrentSim, Distributions, BenchmarkTools
 end
 
 @resumable function customer(sim::Simulation, server::Resource, mu::Float64)
-  @yield request(server)
+  @yield lock(server)
   dt = rand(Exponential(1 / mu))
   @yield timeout(sim, dt)
   @yield release(server)

docs/src/examples/mmc.md

@@ -22,7 +22,7 @@ service_dist = Exponential(1 / mu) # service time distribution
 @resumable function customer(env::Environment, server::Resource, id::Integer, t_a::Float64, d_s::Distribution)
     @yield timeout(env, t_a) # customer arrives
     println("Customer $id arrived: ", now(env))
-    @yield request(server) # customer starts service
+    @yield lock(server) # customer starts service
     println("Customer $id entered service: ", now(env))
     @yield timeout(env, rand(d_s)) # server is busy
     @yield release(server) # customer exits service

docs/src/examples/ross.md

@@ -44,7 +44,7 @@ const G = Exponential(MU)
         else
             throw(StopSimulation("No more spares!"))
         end
-        @yield request(repair_facility)
+        @yield lock(repair_facility)
         @yield timeout(env, rand(rng, G))
         @yield release(repair_facility)
         @yield put!(spares, active_process(env))

docs/src/guides/environments.md

@@ -112,7 +112,7 @@ julia> isnothing(active_process(sim))
 true
 ```
 
-An exemplary use case for this is the resource system: If a process function calls `request` to request a `Resource`, the resource determines the requesting process via `active_process`.
+An exemplary use case for this is the resource system: If a process function calls `lock` to request a `Resource`, the resource determines the requesting process via `active_process`.
 
 ## Miscellaneous
 

docs/src/tutorial.md

@@ -291,7 +291,7 @@ In this section, we’ll briefly introduce ConcurrentSim’s `Resource` class.
 
 We’ll slightly modify our electric vehicle process `car` that we introduced in the last sections.
 
-The car will now drive to a battery charging station (BCS) and request one of its two charging spots. If both of these spots are currently in use, it waits until one of them becomes available again. It then starts charging its battery and leaves the station afterwards:
+The car will now drive to a battery charging station (BCS) and request (lock) one of its two charging spots. If both of these spots are currently in use, it waits until one of them becomes available again. It then starts charging its battery and leaves the station afterwards:
 
 ```jldoctest
 julia> using ResumableFunctions
@@ -301,7 +301,7 @@ julia> using ConcurrentSim
 julia> @resumable function car(env::Environment, name::Int, bcs::Resource, driving_time::Number, charge_duration::Number)
          @yield timeout(sim, driving_time)
          println(name, " arriving at ", now(env))
-         @yield request(bcs)
+         @yield lock(bcs)
          println(name, " starting to charge at ", now(env))
          @yield timeout(sim, charge_duration)
          println(name, " leaving the bcs at ", now(env))
@@ -310,7 +310,7 @@ julia> @resumable function car(env::Environment, name::Int, bcs::Resource, drivi
 car (generic function with 1 method)
 ```
 
-The resource’s `request` function generates an event that lets you wait until the resource becomes available again. If you are resumed, you “own” the resource until you release it.
+The resource’s `lock` function generates an event that lets you wait until the resource becomes available again. If you are resumed, you “own” the resource until you release it.
 
 You are responsible to call `release` once you are done using the resource. When you release a resource, the next waiting process is resumed and now “owns” one of the resource’s slots. The basic `Resource` sorts waiting processes in a FIFO (first in—first out) way.
 
@@ -324,7 +324,7 @@ DocTestSetup = quote
   @resumable function car(env::Environment, name::Int, bcs::Resource, driving_time::Number, charge_duration::Number)
     @yield timeout(sim, driving_time)
     println(name, " arriving at ", now(env))
-    @yield request(bcs)
+    @yield lock(bcs)
     println(name, " starting to charge at ", now(env))
     @yield timeout(sim, charge_duration)
     println(name, " leaving the bcs at ", now(env))
@@ -351,7 +351,7 @@ DocTestSetup = quote
   @resumable function car(env::Environment, name::Int, bcs::Resource, driving_time::Number, charge_duration::Number)
     @yield timeout(sim, driving_time)
     println(name, " arriving at ", now(env))
-    @yield request(bcs)
+    @yield lock(bcs)
     println(name, " starting to charge at ", now(env))
     @yield timeout(sim, charge_duration)
     println(name, " leaving the bcs at ", now(env))
@@ -393,7 +393,7 @@ DocTestSetup = quote
   @resumable function car(env::Environment, name::Int, bcs::Resource, driving_time::Number, charge_duration::Number)
     @yield timeout(sim, driving_time)
     println(name, " arriving at ", now(env))
-    @yield request(bcs)
+    @yield lock(bcs)
     println(name, " starting to charge at ", now(env))
     @yield timeout(sim, charge_duration)
     println(name, " leaving the bcs at ", now(env))

src/ConcurrentSim.jl

@@ -17,7 +17,7 @@ module ConcurrentSim
   export @resumable, @yield
   export AbstractProcess, Simulation, run, now, active_process, StopSimulation
   export Process, @process, interrupt
-  export Container, Resource, Store, put!, get, request, release, cancel
+  export Container, Resource, Store, put!, get, release, cancel
   export nowDatetime
 
   include("base.jl")

src/deprecated.jl

@@ -1 +1,2 @@
 Base.@deprecate put(args...) put!(args...)
+Base.@deprecate request(args...; kwargs...) lock(args...; kwargs...)

src/resources/containers.jl

@@ -30,7 +30,7 @@ function put!(con::Container{N}, amount::N; priority::Int=0) where N<:Real
   put_ev
 end
 
-request(res::Resource; priority::Int=0) = put!(res, 1; priority=priority)
+lock(res::Resource; priority::Int=0) = put!(res, 1; priority=priority)
 
 function get(con::Container{N}, amount::N; priority::Int=0) where N<:Real
   get_ev = Get(con.env)
@@ -65,7 +65,7 @@ Returns `true` if the Container is not empty, similarly to the meaning of `isrea
 julia> sim = Simulation(); res = Resource(sim); isready(res)
 false
 
-julia> request(res); isready(res)
+julia> lock(res); isready(res)
 true
 ```
 """
@@ -80,14 +80,13 @@ Returns `true` if the store is full, similarly to the meaning of `islocked` for
 julia> sim = Simulation(); res = Resource(sim, 2); islocked(res)
 false
 
-julia> request(res); islocked(res)
+julia> lock(res); islocked(res)
 false
 
-julia> request(res); islocked(res)
+julia> lock(res); islocked(res)
 true
 ```
 """
 islocked(c::Container) = c.level==c.capacity
 
 unlock(c::Container) = release(c)
-lock(c::Container) = request(c)

test/runtests.jl

@@ -32,6 +32,7 @@ println("Starting tests with $(Threads.nthreads()) threads out of `Sys.CPU_THREA
 @doset "simulations"
 @doset "processes"
 @doset "resources_containers"
+@doset "resources_containers_deprecated"
 @doset "resources_stores"
 @doset "utils_time"
 VERSION >= v"1.9" && @doset "doctests"