I would like to create a system with servers which need time to set-up before being ready to serve. A server is set up whenever there is a customer arriving to the queue, and the the earlier coming customer will seize the server which is ON earlier, like below.
- Customer 1 arrives and requests a server.
- Server 1 is SETUP in t1 secs.
- Customer 2 arrives and requests a server.
- Server 2 is SETUP in t2 secs.
- Server 2 is ON.
- Customer 1 occupies Server 2.
This process has been successfully simulated thanks to the great answer here: Simulating a system of resource with set-up/switch-on times using Simpy
I would like to add another policy to the system. When a customer leaves the system, he checks if there is any other customer who is waiting to be served. If so, he keeps the server remaining ON, otherwise, he turns off the server immediatelty.
- Customer 1 completes the service and leaves the system.
- Server 2 remains ON.
Customer 2 sees that Server 2 is ON before Server 1, and sees that no one else is waiting, so he turns off Server 1.
- Customer 2 occupies Server 2.
- Server 1 (still in SETUP mode) is turned off.
So, 7),8),9),10) happen at the same time, and the occurence of Event 7) triggers the Interuption of the ealier Event 2) in 10).
Is it possible to manage such kind of Interruption in the Server_Management() class?
"""
Simulation of a dynamic server pool
Server pool starts empty and servers are added as needed, but there is a delay
simulating start up time before the server is available to fulfill a resource request
Programmer: Matt
Wrote original version
Programmer: Michael R. Gibbs
Added server check for dynamicaly adding servers
Fixed return of resorces to pool
"""
import simpy
LAM = 8 #arival rate of jobs
MU = 2 #service rate
ALPHA = 12 #set up rate
NUM_SERVERS = 3
MAX_NUM_JOB = 10000000000
UNTIL = 5
num_current_jobs = 0 #global variable which record the number of jobs present in the system
def generate_interarrival():
return np.random.exponential(1/LAM)
def generate_service():
return np.random.exponential(1/MU)
def switch_on():
return np.random.exponential(1/ALPHA)
class Generate_Job():
def arriving_job(env, servers):
global num_current_jobs, num_server_on, leaving_time_list
for i in range(MAX_NUM_JOB):
job = Job(name="Job%01d" % (i))
yield env.timeout(generate_interarrival())
print('{0:.5f}'.format(env.now), job.name, "arrives")
num_current_jobs +=1
env.process(job.handling(env,servers))
class Server_Management():
def check_servers_arriving(env, servers):
global num_current_jobs
"""
Checks the server pool to see if the pool has any avalable servers
if not then add a server, (there will be a delay before added server becomes available)
Call this without a yield so it does not block if a server is added
"""
print('{0:.5f}'.format(env.now), "checking #OFF servers:",max(0,NUM_SERVERS-num_current_jobs+1))
if num_current_jobs <= NUM_SERVERS:
# will need another server
switch_on_time = switch_on()
print('{0:.5f}'.format(env.now), "adding a server at " + '{0:.5f}'.format(env.now + switch_on_time) + " --")
yield env.timeout(switch_on_time) #switch on time
yield servers.put(1)
print('{0:.5f}'.format(env.now), "added a server--")
def check_servers_leaving(env, servers):
global num_current_jobs
"""
Checks the queue to see if there is any customer is waiting
"""
print('{0:.5f}'.format(env.now), "checking queue length:",max(0,num_current_jobs-NUM_SERVERS))
if num_current_jobs >= NUM_SERVERS: #if there is any waiting customer
yield servers.put(1) #Keep the computer remain ON
print('{0:.5f}'.format(env.now), "computer remains ON--")
class Room: # A room containing servers (resource)
def __init__(self, env):
self.computer = simpy.Container(env, capacity = NUM_SERVERS, init = 0)
class Job(object):
def __init__(self,name):
self.name = name
def handling(self, env, servers):
global num_current_jobs, num_server_on, job_list
# added a check to see if a resource pool needs another server.
env.process(Server_Management.check_servers_arriving(env,servers.computer))
print('{0:.5f}'.format(env.now), self.name, "requesting a server--")
with servers.computer.get(1) as req:
yield req
print('{0:.5f}'.format(env.now), self.name, "occupies a server--")
yield env.timeout(generate_service()) #service time
print('{0:.5f}'.format(env.now), self.name, "leaves")
num_current_jobs -= 1
# added a check to see if a resource pool needs another server.
env.process(Server_Management.check_servers_leaving(env,servers.computer))
np.random.seed(0)
env = simpy.Environment()
servers = Room(env)
env.process(Generate_Job.arriving_job(env, servers))
env.run(until = UNTIL)
