def simular(simulacion: Simulacion) -> Tuple[Simulacion, List]:
print("Comenzando simulacion ...")
print(f"CANTIDAD DE TAREAS ANTES DE FILTRO: {len(simulacion.tareas)}",
True)
#SOLO SE SIMULA LO QUE ESTA DENTRO DEL RANGO DE TIEMPO
simulacion.tareas = list(
filter(lambda t: t.tiempo_creacion < simulacion.tiempo_fin,
simulacion.tareas))
print(f"CANTIDAD DE TAREAS DESPUES DE FILTRO: {len(simulacion.tareas)}",
True)
eventos = crear_eventos_llegada(simulacion.tareas)
procesados = 0
total = len(eventos)
while (simulacion.tiempo_sistema < simulacion.tiempo_fin):
# for _ in tqdm_gui(range(2*total)):
# time.sleep(0.001)
evento = eventos.pop(0) if len(eventos) > 0 else None
if evento is None:
break
procesados += 1
simulacion.tiempo_sistema = evento.tiempo
nuevos_eventos = simulacion.resolver(evento)
eventos = insertar_eventos(eventos, nuevos_eventos)
if procesados % ceil(0.1 * total) == 0:
print(f"PROCESADOS {procesados} EVENTOS")
print(f"TIEMPO FINAL: {simulacion.tiempo_sistema}", True)
print(f"PROCESADOS {procesados} EVENTOS", True)
# with open("realizadas.json","w+") as f:
# json.dump([t.get_dict() for t in simulacion.tareas_finalizadas],f)
# with open("sin_terminar.json","w+") as f:
# json.dump([t.get_dict() for t in simulacion.tareas_asignadas],f)
# with open("tareas.json","w+") as f:
# json.dump([t.get_dict() for t in simulacion.tareas],f)
return simulacion, simulacion.resultado_metricas()
def arrancar_simulacion(executor, cluster_env_var='', optimize=False):
start_time = time.time()
with open('conf.json') as conf:
conf = json.load(conf)
conf_sub = pd.json_normalize(conf['submarino'], sep='.').to_dict(orient='records')[0]
conf_sim = pd.json_normalize(conf['simulacion'], sep='.').to_dict(orient='records')[0]
normalizar_conf(conf_sub)
normalizar_conf(conf_sim)
if optimize:
optimize(conf_sub, conf_sim, executor)
else:
futures, sims = [], []
sub_comb = list(gen_combinations(conf_sub))
for i in range(len(su3b_comb)):
sims.append(Simulacion(sub_comb[i], conf_sim, cluster_env_var=cluster_env_var, uid=i))
i+=1
for s in sims:
futures.append(executor.submit(run_sim, s))
results = []
with tqdm(total=i) as pbar:
for future in concurrent.futures.as_completed(futures):
res = future.result()
shutil.rmtree(f"sim_{res[0]['id']}")
results += res
pbar.update(1)
with open('res.json', 'w') as res_file:
json.dump(results, res_file)
print("--- %s seconds ---" % (time.time() - start_time))
def realizar_simulacion(
tareas_file_path: str = None) -> Tuple[Simulacion, List]:
lista_tareas = cargar_tareas(tareas_file_path)
if not lista_tareas:
lista_tareas = tareas_random(
configuracion.configuracion().tiempo_fin_simulacion)
admin_junior = crear_administrador(
PefilProgramador.Junior,
configuracion.configuracion().cantidad_juniors)
admin_ssr = crear_administrador(
PefilProgramador.Semisenior,
configuracion.configuracion().cantidad_semiseniors)
admin_sr = crear_administrador(
PefilProgramador.Senior,
configuracion.configuracion().cantidad_seniors)
administradores = [admin_junior, admin_ssr, admin_sr]
administradores = list(
filter(lambda a: a.programadores > 0, administradores))
data = Simulacion(configuracion.configuracion(), lista_tareas,
administradores)
return simular(data)
def worker_welch(t, k, seeds, i):
numpy.random.seed(seeds[i])
if k == 0:
sim = Simulacion()
elif k == 1:
sim = simUnaCola.SimulacionUnaCola()
elif k == 2:
sim = simInsp.SimulacionInsp()
elif k == 3:
sim = simUnaColaInsp.SimulacionUnaColaInsp()
elif k == 4:
sim = sim2mec.Simulacion2mec()
else:
sim = simUnaCola2Mec.SimulacionUnaCola2mec()
sim.start(t)
print(i)
return sim.reportes_por_mes
def simular(simulacion:Simulacion)->List[Metrica]:
lista_tareas = simulacion.tareas
while(len(lista_tareas)>0):
tareas_procesar = []
if(hay_una_llegada(lista_tareas,tiempo_sistema)):
while(hay_una_llegada(lista_tareas,tiempo_sistema)):
tareas_procesar.append(lista_tareas.pop(0))
tareas_sin_asignar = asignar(tareas_procesar)
lista_tareas = tareas_sin_asignar + lista_tareas
simulacion.finalizar_tareas()
simulacion.incrementar_tiempo_sistema()
return simulacion.metricas()
def comenzar(self):
self.ingreso.close()
auto = False
if self.ingreso.boton_manual.isChecked():
tipo_simulacion = "Manual"
self.velocimetro.deleteLater()
self.label_10.deleteLater()
else:
tipo_simulacion = "Automatica"
self.boton.deleteLater()
self.label.setText("Velocidad")
auto = True
tasa_llegada = self.ingreso.tasa_llegada.value()
tiempo_max = self.ingreso.tiempo_max.value()
self.label_tiempo_max.setText(str(tiempo_max))
self.simulacion = Simulacion(self, tiempo_max, tasa_llegada,
tipo_simulacion)
self.show()
if auto:
self.simulacion.run()
else:
self.boton.clicked.connect(self.simulacion.run)
def Simulacion(self, widget=None, event=None):
"""Función que permite abrir la simulación del algoritmo seleccionado."""
if self.n>10:
self.n=10
gtk.gdk.threads_init()
win = ventana()
semaforo = Semaphore(1)
if self.listaalgoritmo.get_active_text() == 'FCFS':
win.set_title('Simulación del Algoritmo FCFS')
for x in xrange(self.n):
hilo = Simulacion(win.label, win.label1, win.label3, win.label5, self.n, x, self.t_e, semaforo)
hilo.start()
if self.listaalgoritmo.get_active_text() == 'SJF':
win.set_title('Simulación del Algoritmo SJF')
for x in xrange(self.n):
hilo = Simulacion(win.label, win.label1, win.label3, win.label5, 10, x, self.t_e1, semaforo)
hilo.start()
win.show()
class Ventana(ventana_principal[0], ventana_principal[1]):
def __init__(self):
super().__init__()
self.setupUi(self)
self.setup()
def setup(self):
self.cajas = [self.caja_1, self.caja_2, self.caja_3]
self.clientes = []
self.labels_eventos = []
self.scroll_content = self.scrollAreaWidgetContent.layout()
self.ingreso = VentanaIngreso()
self.ingreso.boton_comenzar.clicked.connect(self.comenzar)
self.ingreso.boton_manual.clicked.connect(self.activar_boton)
self.ingreso.boton_auto.clicked.connect(self.activar_boton)
self.velocimetro.valueChanged.connect(self.cambiar_velocidad)
def activar_boton(self):
self.ingreso.boton_comenzar.setEnabled(True)
def comenzar(self):
self.ingreso.close()
auto = False
if self.ingreso.boton_manual.isChecked():
tipo_simulacion = "Manual"
self.velocimetro.deleteLater()
self.label_10.deleteLater()
else:
tipo_simulacion = "Automatica"
self.boton.deleteLater()
self.label.setText("Velocidad")
auto = True
tasa_llegada = self.ingreso.tasa_llegada.value()
tiempo_max = self.ingreso.tiempo_max.value()
self.label_tiempo_max.setText(str(tiempo_max))
self.simulacion = Simulacion(self, tiempo_max, tasa_llegada,
tipo_simulacion)
self.show()
if auto:
self.simulacion.run()
else:
self.boton.clicked.connect(self.simulacion.run)
def cambiar_velocidad(self):
self.simulacion.cambiar_velocidad(self.velocimetro.value())
def act_tiempo(self, tiempo):
self.label_tiempo_actual.setText(tiempo)
def act_prox_evento(self, evento):
pass
def agregar_evento(self, evento, tiempo):
for label in self.labels_eventos:
label.setStyleSheet("")
self.evento_actual.setText(evento)
label = QLabel("[{}] ".format(tiempo) + evento, self)
label.setStyleSheet("background-color: rgb(51, 138, 187);")
self.labels_eventos.append(label)
self.scroll_content.insertWidget(0, label)
def agregar_nuevo_cliente(self, label_cliente):
self.espera.addWidget(label_cliente)
def agregar_cliente_cola(self, label_cliente, caja):
self.espera.removeWidget(label_cliente)
self.cajas[caja].insertWidget(0, label_cliente)
def agregar_cliente_mesas(self, label_cliente, caja):
self.cajas[caja].removeWidget(label_cliente)
self.mesas.addWidget(label_cliente)
def sacar_cliente(self, label_cliente):
self.mesas.removeWidget(label_cliente)
label_cliente.deleteLater()
def terminar_simulacion(self, tipo_simulacion):
if tipo_simulacion == "Manual":
self.boton.setEnabled(False)
mensaje = QMessageBox()
mensaje.setText("Termino de la simulación")
mensaje.setWindowTitle("DES")
boton = QPushButton("Ver estadísticas")
boton.clicked.connect(self.mostrar_estadisticas)
mensaje.addButton(boton, QMessageBox.YesRole)
mensaje.exec_()
def mostrar_estadisticas(self):
self.ventana_estadis = VentanaEstadisticas()
layout = self.ventana_estadis.verticalWidget.layout()
estadisticas = self.simulacion.generar_estadisticas()
for text, valor in estadisticas:
label = QLabel(text + str(valor), self.ventana_estadis)
label.setAlignment(Qt.AlignCenter)
layout.addWidget(label)
def closeEvent(self, CloseEvent):
sys.exit()
super(ventana_principal[1], self).closeEvent(CloseEvent)
from swapity_swaps import swapity_swap
import time
from random import shuffle
if __name__ == "__main__":
t1 = time.time()
grafo = Graph()
grafo.cargar_base("datos_nodos_new.csv")
grafo.cargar_gondolas("distr_gondolas.csv")
######################## PARAMETROS DE LA SIMULACION ###########################
clientes_iniciales = 30
limite_boletas = 200
iteraciones_por_config = 2
veces_que_busca_mejora = 20
#################################################################################
simulacion = Simulacion(grafo)
estadisticas_prom = dict()
swaps_hechos = []
estadisticas_prom["utilidad_supermercado"] = 0
estadisticas_prom["probabilidad_total"] = 0
estadisticas_prom["utilidad_espontanea"] = 0
estadisticas_prom["numero_medio_compras_espontaneas"] = 0
estadisticas_prom["top_productos_espontaneos"] = 0
estadisticas_prom["distancia_media_recorrida"] = 0
########################################################################################################################
# print("ESTADISTICAS INICIALES")
for i in range(1):
estadisticas_iniciales = simulacion.run(clientes_iniciales,
limite_boletas)
for estadistica in estadisticas_iniciales.items():
from simulacion import Simulacion
import gui
sim = Simulacion(10000, "pezoa", "humanos", 0.01, "2:2:2", "rodolfo",
"muertos vivientes", 0.01, "2:2:2")
gui.set_size(1024, 680)
gui.run(sim.tick)
tasa_invocacion_1=obtener_tasa_heroe()
print("\nPor favor ingrese los parámetros del ejercito 2")
dios_2=obtener_dios(dios_1)
raza_2=obtener_raza(raza_1)
intervalo_2=obtener_intervalo()
tasa_invocacion_2=obtener_tasa_heroe()
sim=Simulacion(tiempo_simulacion,dios_1,raza_1,tasa_invocacion_1,intervalo_1,dios_2,raza_2,tasa_invocacion_2,intervalo_2)
gui.set_size(1024, 680)
gui.run(sim.tick)