# Resources¶

SimJulia implements three types of resources that can be used to synchronize processes or to model congestion points:

• Resource: shared resources supporting priorities and preemption.
• Container: resource for sharing homogeneous matter between processes, either continuous or discrete.
• Store: shared resources for storing a possibly unlimited amount of objects supporting requests for specific objects.

## AbstractResource¶

abstract AbstractResource

All resource types are derived from the abstract type AbstractResource. Common functions to all types of resources can be found in resources\base.jl. These are also meant to support the implementation of custom resource types.

capacity(res::AbstractResource)

Returns the capacity of the resource.

## ResourceEvent¶

abstract ResourceEvent <: AbstractEvent

All events related to resources are derived from the abstract type ResourceEvent.

abstract PutEvent <: ResourceEvent

Abstract event for requesting to put something into the resource.

cancel(ev::PutEvent)

Cancel the put request ev.

This method has to be called if the put request must be aborted, for example if a process needs to handle an exception like an Interruption.

abstract GetEvent <: ResourceEvent

Generic event for requesting to get something from the resource.

cancel(ev::GetEvent)

Cancel this get request ev.

This method has to be called if the get request must be aborted, for example if a process needs to handle an exception like an Interruption.

## Resource¶

Resource <: AbstractResource

Shared resources supporting priorities and preemption.

These resources can be used to limit the number of processes using them concurrently. A process needs to request the usage right to a resource. Once the usage right is not needed anymore it has to be released. A gas station can be modelled as a resource with a limited amount of fuel-pumps. Vehicles arrive at the gas station and request to use a fuel-pump. If all fuel-pumps are in use, the vehicle needs to wait until one of the users has finished refueling and releases its fuel-pump.

These resources can be used by a limited number of processes at a time. Processes request these resources to become a user and have to release them once they are done. For example, a gas station with a limited number of fuel pumps can be modeled with a Resource. Arriving vehicles request a fuel-pump. Once one is available they refuel. When they are done, the release the fuel-pump and leave the gas station.

Requesting a resource is modelled as “putting a process’ token into the resources” and releasing a resources correspondingly as “getting a process’ token out of the resource”. Note, that releasing a resource will always succeed immediately, no matter if a process is actually using a resource or not.

Resource(env::AbstractEnvironment, capacity::Int=1) → Resource

Resource with capacity of usage slots that can be requested by processes. If all slots are taken, requests are enqueued. Once a usage request is released, a pending request will be triggered. The env argument is the AbstractEnvironment instance the resource is bound to.

count(res::Resource) → Int

Returns the number of users currently using res.

## ResourcePut¶

ResourcePut <: PutEvent

Subtype of PutEvent for requesting to put something in a Resource.

Put(res::Resource, priority::Int=0, preempt::Bool=false) → ResourcePut
Request(res::Resource, priority::Int=0, preempt::Bool=false) → ResourcePut

Request usage of the Resource with a given priority. The event is triggered once access is granted.

If the maximum capacity of users has not yet been reached, the request is triggered immediately. If the maximum capacity has been reached, the request is triggered once an earlier usage request on the resource is released. If preempt is true other usage requests of the resource may be preempted.

## ResourceGet¶

ResourceGet <: GetEvent

Subtype of GetEvent for requesting to get something from a Resource.

Get(res::Resource) → ResourceGet
Release(res::Resource) → ResourceGet

Releases the usage of resource by the active process. This event is triggered immediately.

## Preempted¶

Preempted

Cause of a preemption Interruption containing information about the preemption.

by(pre::Preempted) → Process

Returns the preempting Process.

usage_since(pre::Preempted) → Float64

Returns the simulation time at which the preempted process started to use the resource.

## Container¶

Container{T<:Number} <: AbstractResource

Resource for sharing homogeneous matter between processes, either continuous (like water) or discrete (like apples).

A Container can be used to model the fuel tank of a gasoline station. Tankers increase and refuelled cars decrease the amount of gas in the station’s fuel tanks.

Container{T}(env::Environment, capacity::T=typemax(T), level::T=zero(T)) → Container{T}

Resource containing up to capacity of matter which may either be continuous (like water) or discrete (like apples). It supports requests to put or get matter into/from the container.

The env argument is the AbstractEnvironment instance the container is bound to.

The capacity defines the size of the container.The initial amount of matter is specified by level and defaults to zero(T).

level(cont::Container) → T

Returns the current amount of the matter in the container.

## ContainerPut¶

ContainerPut <: PutEvent

Subtype of PutEvent for requesting to put something in a Container.

Put{T<:Number}(cont::Container{T}, amount::T, priority::Int=0) → ContainerPut

Request to put amount of matter into the container with a given priority. The request will be triggered once there is enough space in the container available.

## ContainerGet¶

ContainerGet <: GetEvent

Subtype of GetEvent for requesting to get something from a Container.

Get{T<:Number}(cont::Container{T}, amount::T, priority::Int=0) → ContainerGet

Request to get amount of matter from the container with a given priority. The request will be triggered once there is enough matter available in the container.

## Store¶

Store{T} <: AbstractResource

Shared resources for storing a possibly unlimited amount of objects supporting requests for specific objects.

The Store operates in a FIFO (first-in, first-out) order. Objects are retrieved from the store in the order they were put in. The get requests can be customized by a filter to only retrieve objects matching a given criterion.

Store{T}(env::Environment, capacity::Int=typemax(Int)) → Store{T}

Resource with capacity slots for storing arbitrary objects. By default, the capacity is unlimited and objects are put and retrieved from the store in a first-in first-out order.

The env argument is the AbstractEnvironment instance the store is bound to.

## StorePut¶

StorePut{T} <: PutEvent

Subtype of PutEvent for requesting to put something in a Store.

Put{T}(sto::Store{T}, item::T, priority::Int=0) → StorePut

Request to put item into the store with a given priority. The request is triggered once there is space for the item in the store.

## StoreGet¶

StoreGet <: GetEvent

Subtype of GetEvent for requesting to get something from a Store.

Get{T}(sto::Store{T}, filter::Function=(item::T) → true, priority::Int=0)

Request to get an item from the store matching the filter with a priority. The request is triggered once there is such an item available in the store.

filter is a function receiving one item. It should return true for items matching the filter criterion. The default function returns true for all items