def genera_lista_procesos():
lista = []
p1 = Proceso(0, 3, "A")
p2 = Proceso(1, 5, "B")
p3 = Proceso(3, 2, "C")
p4 = Proceso(9, 5, "D")
p5 = Proceso(12, 5, "E")
lista.append(p1)
lista.append(p2)
lista.append(p3)
lista.append(p4)
lista.append(p5)
return lista
def asignarProceso(self, proceso):
self.ocupado = True
self.memoriaAsignada = proceso.obtMemoria()
self.procesosEmpilados.append(proceso)
proceso.enlazarProcesador(self)
# Agregar subprocesos (si los hay)
if proceso.obtSubprocesos() != 0:
# Impresion de empilacion
print(self.STR_SUBP_EMPILAR % (
self.simulador.obtTiempo(), # Tiempo
proceso.obtSubprocesos(), # No. de subprocesos
proceso.obtNombre(), # Nombre del proceso
self.id)) # Numero de procesador
for i in range(proceso.obtSubprocesos()):
self.procesosEmpilados.append(
# Hereda los atributos del proceso padre
Proceso(
proceso.obtNombre() + '-' + str(i),
proceso.obtPrioridad(), # Prioridad
0, # No usa memoria
proceso.obtDuracion(), # Duracion
0, # No tiene subprocesos
self)) # Procesador asociado
def leerEntrada(self, nombreEntrada):
try:
for line in open(nombreEntrada):
args = line.split()
if args[0] != 'proceso':
raise ValueError('Error de sintaxis en archivo de entrada')
if len(args) != 6:
raise ValueError('Numero incorrecto de parametros')
self.colaProcesos.agregar(
Proceso(
args[1], # Nombre
args[2], # Prioridad
args[3], # Memoria
args[4], # Duracion
args[5], # Subprocesos
None)) # Procesador
except IOError:
raise IOError('No se encuentra el archivo %s' % nombreEntrada)
from Proceso import Proceso
if __name__ == '__main__':
# Leido de las imagenes
imagen_1 = Convertido.leido_de_iamgen("images/iron.jpg")
imagen_2 = Convertido2.leido_de_iamgen("images/albert.jpg")
# Conversion de las imagenes
imagen_1_convertida = Convertido.imagen_a_escala_de_grises(imagen_1)
imagen_2_convertida = Convertido2.imagen_laplaciana(imagen_2)
# Guardado de las imagenes
Convertido.guardar_imagen(imagen_1_convertida, "ironconvertida")
Convertido2.guardar_imagen(imagen_2_convertida, "albertconvertido")
# MENSAJES PARA PODER VER LAS VENTANAS
print("EL PROYECTO CORRIO MUY BIEN CHAMO")
print("Cierrra la ventana para ver la imagen procesada")
print("el primero es a blanco y negro ")
print("el segundo a laplaciano degradado")
# Mostrar en ventana las imagenes
Proceso.mostrar_imagen_en_ventana(nombre_de_la_ventana="original iron",
imagen_a_mostrar=imagen_1)
Convertido.mostrar_imagen_en_ventana(nombre_de_la_ventana="blanco y negro",
imagen_a_mostrar=imagen_1_convertida)
Proceso.mostrar_imagen_en_ventana(nombre_de_la_ventana="original albert",
imagen_a_mostrar=imagen_2)
Convertido.mostrar_imagen_en_ventana(nombre_de_la_ventana="laplaciano",
imagen_a_mostrar=imagen_2_convertida)
if __name__ == '__main__':
if (len(sys.argv) > 1):
trabajo = sys.argv[1]
else:
trabajo = './ejemplos/prueba.txt'
f = open(trabajo,'r')
lista = f.readlines()
Nrorecursos = int( lista[0])
Nroprocesos = int( lista[1])
#creo una lista con todos los procesos a ejeceutar
Procesos = []
for i in range(2, Nroprocesos + 2):
k = lista[i].split(" ")
Procesos.append(Proceso(Nrorecursos, k))
'''for p in Procesos:
print(p.EstadoProceso())'''
#obtenemos todos los recursos Disponibles
RecursosDisponibles = []
for e in lista[len(lista) - 1].split(" "):
RecursosDisponibles.append(int(e))
banquero = Banquero(Nroprocesos, Nrorecursos, Procesos,RecursosDisponibles)
class Main:
tBloqueo = 15
cambioContexto = 15
quantum = 3000
#Aqui se pone el numero de micros que se van a utlizar
print("Cuantos micros vas a usar perro loco?")
micros = input()
despachador = Despachador()
#Crear micros que el usuario da
for i in range(0, int(micros)):
i = Micro(0, True, str(i))
despachador.micros.append(i)
#Procesos que el usuario da
oscar = Proceso("A", 300, 1500, 2)
manuel = Proceso("B", 100, 1500, 2)
gio = Proceso("C", 500, 1500, 3)
diego = Proceso("D", 700, 1500, 4)
despachador.procesos_a_ejecutar.append(oscar)
despachador.procesos_a_ejecutar.append(manuel)
despachador.procesos_a_ejecutar.append(gio)
despachador.procesos_a_ejecutar.append(diego)
def pasar_procesos_a_micros(despachador, quantum, tBloqueo,
cambioContexto):
for procesos in despachador.procesos_a_ejecutar:
print("Para proceso ", procesos.nombre)
#Crear funcion 1 que regrese menor_desp
menor = []
for menor_despachador in despachador.micros:
menor.append((len(menor_despachador.procesos_ejecucion),
menor_despachador.procesos_ejecucion,
menor_despachador.nombre))
menor_desp = min(menor)
#Crear funcion 2
for entrada_proceso in despachador.micros:
if (entrada_proceso.nombre == menor_desp[2]):
entrada_proceso.procesos_ejecucion.append(
despachador.procesos_a_ejecutar[0])
#despachador.procesos_a_ejecutar.pop(0)
#metodos que calculan valores de los procesos dentro de los micros
despachador.determinar_tiempo_vencimiento_quantum(
entrada_proceso.procesos_ejecucion[0], quantum,
cambioContexto)
despachador.determinar_tiempo_cambio_contexto(
entrada_proceso.procesos_ejecucion[0], cambioContexto)
despachador.determinar_tiempo_bloqueo(
entrada_proceso.procesos_ejecucion[0], tBloqueo)
despachador.determinar_tiempo_inicial(
entrada_proceso.procesos_ejecucion[0],
despachador.micros)
despachador.determinar_tiempo_total(
entrada_proceso.procesos_ejecucion[0])
despachador.determinar_tiempo_final(
entrada_proceso.procesos_ejecucion[0],
despachador.micros)
despachador.determinar_tiempo_ejecucion_micro(
entrada_proceso, entrada_proceso.procesos_ejecucion[0])
else:
pass
pasar_procesos_a_micros(despachador, quantum, tBloqueo, cambioContexto)
for el in despachador.micros:
print("El micro", el.nombre)
for al in el.procesos_ejecucion:
print(al.nombre)
def detect_failures(da: Proceso, mec: Proceso, start: int,
end: int) -> (int, int):
""" To detect anomaly states on each process using a Random Forest
model.
Arguments:
da : ProcessDA object
mec : ProcessMEC object
start : initial position to detect errors
end : final position to detect errors
"""
assert isinstance(da, Proceso), 'DA must be a Proceso object'
assert isinstance(mec, Proceso), 'MEC must be a Proceso object'
assert isinstance(start, int), 'start must be an integer'
assert isinstance(end, int), 'end must be an integer'
n_correct_da = n_correct_mec = n_total_da = n_total_mec = 0
da_acc = mec_acc = 0
da_tn = da_fp = da_fn = da_tp = 0
mec_tn = mec_fp = mec_fn = mec_tp = 0
# Get the chunk of data in the range [start, end]
da_inputs, da_targets = da.get_batch_data(start, end)
mec_inputs, mec_targets = mec.get_batch_data(start, end)
# Call Random Forest model
predict = clasificar_estado(da_inputs, mec_inputs)
# Update limits for onto vars
if not predict[0].any():
da.update_limits(da_inputs)
if not predict[1].any():
mec.update_limits(mec_inputs)
# Calculate accuracy
n_correct_da += (da_targets == predict[0]).sum()
n_correct_mec += (mec_targets == predict[1]).sum()
n_total_da += da_targets.shape[0]
n_total_mec += mec_targets.shape[0]
da_acc = n_correct_da / n_total_da
mec_acc = n_correct_mec / n_total_mec
da_tn, da_fp, da_fn, da_tp = confusion_matrix(predict[0],
da_targets,
labels=[0, 1]).ravel()
mec_tn, mec_fp, mec_fn, mec_tp = confusion_matrix(predict[1],
mec_targets,
labels=[0,
1]).ravel()
print('-' * 20)
print(f'Accuracy | da: {da_acc:.3f},\
mec: {mec_acc:.3f}')
print(f'Normal state| da: {da_tn}({(da_tn/n_total_da)*100:.3f}%), \
mec: {mec_tn}({(mec_tn/n_total_mec)*100:.3f}%) ')
print(f'Failures detected| da: {da_tp}({(da_tp/n_total_da)*100:.3f}%),\
mec: {mec_tp}({(mec_tp/n_total_mec)*100:.3f}%) ')
print(f'Failures missed: | da: {da_fn}({(da_fn/n_total_da)*100:.3f}%),\
mec: {mec_fn}({(mec_fn/n_total_mec)*100:.3f}%) ')
print(f'False positives: | da: {da_fp}({(da_fp/n_total_da)*100:.3f}%),\
mec: {mec_fp}({(mec_fp/n_total_mec)*100:.3f}%) ')
print('-' * 20)
print()
return da_acc, mec_acc
def crearProceso(self, tamano):
procesoNuevo = Proceso(self.pidContador, tamano, time.time())
self.cpu.anadirProceso(procesoNuevo)
if self.cpu.colaListos[0].pid == procesoNuevo.pid:
self.cargarPagina()
self.pidContador = self.pidContador + 1