how to specify preemption = true when requesting a resource about concurrentsim.jl HOT 7 CLOSED

"""
  put(sto::Store{T}, item::T, preempt::Bool=false,
        filter::Function=get_any_item) where T
Put an `item` in a `Store` and allow for preemption using `filter` to select
  which item to remove from the `Store` when preempting.
This method requires that T be a mutable struct with the fields:
- `:priority::Int`: Integer specifying the priority of that `item` (the more
  negative, the higher the priority).
- `:process::Process`: Storage `Process` for the `item`. Used to know which
  `Process` to interrupt when preempting.
"""
function put(sto::Store{T}, item::T, preempt::Bool=false, filter::Function=get_any_item) where T
    @assert :priority in fieldnames(T) "Preemption requires that the item being stored have :priority as one of its fields."
    @assert :process in fieldnames(T) && item.process isa Process "Preemption requires that the item being stored have `:process` as one of its fields."
    if preempt && !isempty(sto.items) && item.priority < maximum([itm.priority for itm in sto.items]) #if the new item priority is higher than the priority of at least one of the items in the store, preempt
        #remove item from store
        stoitems = [itm for itm in sto.items] #original items in sto
        get(sto, filter) #get item from store
        pitem = setdiff(stoitems, [itm for itm in sto.items])[1] #find removed item
        proc = pitem.process #process to interrupt
        interrupt(proc, item) #interrupt process on removed item identify item causing the preemption
    end
    #put new item into the queue
    put(sto, item, priority = item.priority)
end

using ResumableFunctions, SimJulia

#Define Job (item) to send to the queue (Store)
abstract type AbstractJob end
mutable struct Job <: AbstractJob
    id::Int
    arrival::Number
    priority::Int
    start_service::Number
    time_in_service::Number
    process::Union{Missing, SimJulia.Process}
    size::Number
end

#define a function to serve jobs that arrive at a queue and allow preemption
@resumable function serve(env, server, job)
    @yield timeout(env, job.arrival) #job arrives
    println("job $(job.id) enters queue at t = $(now(env))")
    while true
        try
            @yield put(server, job, true) #add job to queue, allow preemption
            println("Starting service on job $(job.id) at t = $(now(env)).")
            job.start_service = now(env) #save time service started on job
            @yield timeout(env, job.size - job.time_in_service) #service duration excludes any time already spent in service (if preempted)
            println("Service complete on job $(job.id) at t = $(now(env)).")
            job.time_in_service = now(env) - job.start_service #update time in serice
            get(server, x -> x.id == job.id) #remove job from queue
            break
        catch exc
            pre = exc.cause #find cause of preemption
            job.time_in_service = now(env) - job.start_service #update time in service
            println("Service on job $(job.id) interrupted (preempted) by job $(pre.id) at t = $(now(env)).")
        end
    end
end

#create simulation
sim = Simulation() #simulation object
server = Store{Job}(sim, capacity = UInt(1)) #server that processes jobs
#add 3 jobs with priorities -1, 0, -2 arriving at times 0, 1, 2
job1 = Job(1,0,-1,0,0,missing,3) 
job2 = Job(2,1,0,0,0,missing,3)
job3 = Job(3,2,-2,0,0,missing,3)

#create and store service processes
job1.process = @process serve(sim, server, job1)
job2.process = @process serve(sim, server, job2)
job3.process = @process serve(sim, server, job3)

#run simulation
run(sim)

#output
#=
job 1 enters queue at t = 0.0
Starting service on job 1 at t = 0.0.
job 2 enters queue at t = 1.0
job 3 enters queue at t = 2.0
Service on job 1 interrupted (preempted) by job 3 at t = 2.0.
Starting service on job 3 at t = 2.0.
Service complete on job 3 at t = 5.0.
Starting service on job 1 at t = 5.0.
Service complete on job 1 at t = 6.0.
Starting service on job 2 at t = 6.0.
Service complete on job 2 at t = 9.0.
=#