用SIMPY模拟具有启动/接通时间的资源系统 [英] Simulating a system of resource with set-up/switch-on times using Simpy

问题描述

我想创建一个带有服务器的系统，这些服务器在准备好提供服务之前需要时间进行设置。由于服务器数量随时间变化，我认为容器资源可能会起作用。每当有客户到达队列时，就设置服务器，先来的客户将抢占较早开机的服务器，如下图所示。

1. 客户%1到达并请求服务器。
2. 服务器%1的设置时间为T1秒。
3. 客户%2到达并请求服务器。
4. 服务器2的设置时间为%2秒。
5. 服务器2已打开。
6. 客户%1占用服务器%2。

我想知道如何才能使上述过程真正起作用。如果我将事件安排如下，每个循环似乎都在yield req之后停滞(不是yield req将此请求放入队列，然后在yield servers.server.put(1)打开就绪的服务器后立即完成请求？)

with servers.computer.get(1) as req: 
      yield req                       
      yield env.timeout(switch_on())    #switch on time
      yield servers.server.put(1) 

"""0.09948 Job0 arrives
0.25648 Job1 arrives
0.37188 Job2 arrives
0.47028 Job3 arrives
0.53916 Job4 arrives
0.66893 Job5 arrives
"""

如果我按如下方式更改顺序，则无论服务器的打开顺序如何，客户-我肯定会占用服务器-I。

with servers.computer.get(1) as req: 
      yield env.timeout(switch_on())    #switch on time
      yield servers.server.put(1)
      yield req 

以下是完整代码。

import simpy

LAM = 8  #arival rate of jobs
MU = 2  #service rate
ALPHA = 12  #set up rate
NUM_SERVERS = 5
MAX_NUM_JOB = 10000000000
UNTIL = 10

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")

            env.process(job.handling(env,servers))

class Room:                             # A room containing servers (resource)
    def __init__(self, env):
        self.computer = simpy.Container(env, capacity = 10000, init = 0)


class Job(object):
    def __init__(self,name):
        self.name = name

    def handling(self, env, servers):
        with servers.computer.get(1) as req: 
            yield req                       
            yield env.timeout(switch_on())    #switch on time
            yield servers.server.put(1)            
            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")


np.random.seed(0)
env = simpy.Environment()
servers  = Room(env)
env.process(Generate_Job.arriving_job(env, servers))
env.run(until = UNTIL) 

推荐答案

需要更改两项

您的资源池一开始就是空的，这意味着您对资源的第一个请求将永远等待，并且永远无法访问添加了资源的代码。

我在请求之前添加了一个复选标记，该复选标记将在需要时添加资源。由于在添加资源时存在延迟，因此资源请求在资源&启动时仍将等待。如果因为另一个添加而添加资源，或者如果另一个作业完成并在添加新资源之前另一个作业完成并返回资源，则不要调用此检查，否则请求将等待添加新资源，并且请求将丢失。

此外，容器不会在"；with"；语句的末尾返回资源，只有资源才会这样做。

这里是固定的代码，让我知道你的想法

"""
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
import numpy as np

LAM = 8  #arival rate of jobs
MU = 2  #service rate
ALPHA = 12  #set up rate
NUM_SERVERS = 5
MAX_NUM_JOB = 10000000000
UNTIL = 10

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)

def check_servers(env, servers):
    """
    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 server pool", "requests:",len(servers.get_queue), "servers:", servers.level)
    
    if len(servers.get_queue) >= servers.level:
        # will need another server
        d = switch_on()
        print('{0:.5f}'.format(env.now), "adding a server at " + '{0:.5f}'.format(env.now + d) + " --")
        yield env.timeout(d)    #switch on time
        yield servers.put(1)      
        print('{0:.5f}'.format(env.now), "added a server--")

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")

            env.process(job.handling(env,servers))

class Room:                             # A room containing servers (resource)
    def __init__(self, env):
        self.computer = simpy.Container(env, capacity = 10000, init = 0)


class Job(object):
    def __init__(self,name):
        self.name = name

    def handling(self, env, servers):

        # added a check to see if a resource pool needs another server.
        env.process(check_servers(env,servers.computer))
        print('{0:.5f}'.format(env.now), self.name, "requesting a server--") 

        with servers.computer.get(1) as req: 
            
            yield req 
            # if the queue is empty then the req is never filled and the next lines are never called
            # need to do this before the rescource requests
            #                       
            # yield env.timeout(switch_on())    #switch on time
            # yield servers.server.put(1)            
            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")

            # containers do not return a resouce at the end of a "with"
            # added a put
            yield servers.computer.put(1)


np.random.seed(0)
env = simpy.Environment()
servers  = Room(env)
env.process(Generate_Job.arriving_job(env, servers))
env.run(until = UNTIL) 

这篇关于用SIMPY模拟具有启动/接通时间的资源系统的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！