This module contains all Resource like resources.
These resources can be used by a limited number of processes at a time (e.g., a gas station with a limited number of fuel pumps). Processes request these resources to become a user (or to own them) and have to release them once they are done (e.g., vehicles arrive at the gas station, use a fuel-pump, if one is available, and leave when they are done).
Requesting a resources is modeled as “putting a process’ token into the resources” and releasing a resources correspondingly as “getting a process’ token out of the resource”. Thus, calling request()/release() is equivalent to calling put()/get(). Note, that releasing a resource will always succeed immediately, no matter if a process is actually using a resource or not.
Beside Resource, there are a PriorityResource, were processes can define a request priority, and a PreemptiveResource whose resource users can be preempted by other processes with a higher priority.
A resource has a limited number of slots that can be requested by a process.
If all slots are taken, requesters are put into a queue. If a process releases a slot, the next process is popped from the queue and gets one slot.
The env parameter is the Environment instance the resource is bound to.
The capacity defines the number of slots and must be a positive integer.
Queue/list of pending Request events that represent processes waiting to use the resource.
Maximum capacity of the resource.
Number of users currently using the resource.
This class works like Resource, but requests are sorted by priority.
The queue is kept sorted by priority in ascending order (a lower value for priority results in a higher priority), so more important request will get the resource earlier.
The type to be used for the put_queue.
alias of SortedQueue
Create a new PriorityRequest event.
alias of PriorityRequest
This resource mostly works like Resource, but users of the resource can be preempted by higher prioritized requests.
Furthermore, the queue of requests is also sorted by priority.
If a less important request is preempted, the process of that request will receive an Interrupt with a Preempted instance as cause.
The preempting simpy.events.Process.
The simulation time at which the preempted process started to use the resource.
Request access on the resource. The event is triggered once access is granted.
If the maximum capacity of users is not reached, the requesting process obtains the resource immediately. If the maximum capacity is reached, the requesting process waits until another process releases the resource.
The request is automatically released when the request was created within a with statement.
Releases the access privilege to resource granted by request. This event is triggered immediately.
If there’s another process waiting for the resource, resume it.
If the request was made in a with statement (e.g., with res.request() as req:), this method is automatically called when the with block is left.
Request the resource with a given priority. If the resource supports preemption and preempted is true other processes with access to the resource may be preempted (see PreemptiveResource for details).
This event type inherits Request and adds some additional attributes needed by PriorityResource and PreemptiveResource
The priority of this request. A smaller number means higher priority.
Indicates whether the request should preempt a resource user or not (this flag is not taken into account by PriorityResource).
The time at which the request was made.
Key for sorting events. Consists of the priority (lower value is more important), the time at witch the request was made (earlier requests are more important) and finally the preemption flag (preempt requests are more important).
Queue that sorts events by their key attribute.
Maximum length of the queue.
Append item to the queue and keep the queue sorted.
Raise a RuntimeError if the queue is full.