¿Simpy admite la distribución de recursos dinámicos optimizada a través de múltiples nodos?

Answer

1. 

   davy.ai

   May 31, 2023 at 5:42 pm

   Para hacer que la asignación de recursos sea dinámica en Simpy, podemos usar la clase Container para representar la disponibilidad de recursos en cada nodo. Luego, podemos modificar la función items para verificar la disponibilidad de recursos en cada nodo utilizando los objetos Container y asignarlos en consecuencia. Para minimizar el tiempo promedio total de procesamiento de un elemento a través del nodo 0 seguido del nodo 1, podemos usar una heurística simple que prioriza la asignación de recursos en el nodo 0 siempre que sea posible. El código modificado es el siguiente:

   import numpy as np
   import simpy
   
   def interarrival():
       return(np.random.exponential(20))
   
   def servicetime():
       return(np.random.exponential(60))
   
   def servicing(env, servers_1, node_0_res, node_1_res):
       i = 0
       while(True):
           i = i+1
           yield env.timeout(interarrival())
           print("El cliente "+str(i)+" llegó al proceso en el "+str(env.now))
           estado = 0
           env.process(items(env, i, servers_array, node_0_res, node_1_res, estado))
   
   def items(env, id_cliente, servers_array, node_0_res, node_1_res, estado):
       # Verificar la disponibilidad de recursos en cada nodo
       if estado == 0:
           if node_0_res.level >= 1:
               node_0_res.get(1)
               res_node = 0
           elif node_1_res.level >= 1:
               node_1_res.get(1)
               res_node = 1
           else:
               # Si no hay recursos disponibles, esperar hasta que uno esté disponible
               yield node_0_res.get(1) | node_1_res.get(1)
               if node_0_res.level >= 1:
                   node_0_res.get(1)
                   res_node = 0
               else:
                   node_1_res.get(1)
                   res_node = 1
       else:
           node_1_res.get(1)
           res_node = 1
   
       with servers_array[estado].request() as request:
           yield request
           t_arrival = env.now
           print("El cliente "+str(id_cliente)+" llegó al "+str(estado)+" en el "+str(t_arrival))
           yield env.timeout(servicetime())
           t_depart = env.now
           print("El cliente "+str(id_cliente)+" se fue desde el "+str(estado)+" en el "+str(t_depart))
           if (estado == 1):
               node_1_res.put(1)
               print("El cliente sale")
           else:
               estado = 1
               env.process(items(env, id_cliente, servers_array, node_0_res, node_1_res, estado))
               node_0_res.put(1)
   
   env = simpy.Environment()
   node_0_res = simpy.Container(env, capacity=5, init=5)
   node_1_res = simpy.Container(env, capacity=7, init=7)
   servers_array = []
   servers_array.append(simpy.Resource(env, capacity = 1))
   servers_array.append(simpy.Resource(env, capacity = 1))
   env.process(servicing(env, servers_array, node_0_res, node_1_res))
   env.run(until=2880)
   

   En este código modificado, creamos dos objetos Container que representan la disponibilidad de recursos en cada nodo (node_0_res y node_1_res). Luego, modificamos la función items para verificar la disponibilidad de recursos en cada nodo y asignarlos en consecuencia. Primero verificamos si el estado actual es el nodo 0, y si es así, primero intentamos asignar un recurso en el nodo 0 si hay uno disponible, de lo contrario, asignamos un recurso en el nodo 1 si hay uno disponible. Si no hay recursos disponibles en ninguno de los nodos, esperamos hasta que uno esté disponible. Si el estado actual es el nodo 1, siempre asignamos un recurso en el nodo 1.

   Para implementar la heurística que prioriza la asignación de recursos en el nodo 0, simplemente devolvemos el recurso a node_0_res después de que un cliente haya terminado el procesamiento en el nodo 0. Esto asegura que si hay clientes esperando en ambos nodos, los recursos se asignarán primero al nodo 0.

   En general, este código modificado programa dinámicamente los recursos disponibles en los nodos 0 y 1 para minimizar el tiempo promedio total de procesamiento de un elemento a través del sistema.

Comments are closed.