def test_ej_combinado_no_listo(self):
"""
Calculamos 20/4 + (4 * 3) + 1. Reutilizamos el proceso de suma, sin
antes resetearlo.
"""
proceso_padre = Proceso(proc_id=1)
f_suma = funciones_ponderadas['suma']
proceso_suma = Proceso(proc_id=2, **f_suma)
f_prod = funciones_ponderadas['prod']
proceso_prod = Proceso(proc_id=3, **f_prod)
f_div = funciones_ponderadas['div']
proceso_div = Proceso(proc_id=4, **f_div)
mi_prod = proceso_padre.enviar_pedido((4, 3), proceso_prod, 8)
suma_parc = proceso_padre.enviar_pedido((mi_prod, 1), proceso_suma, 5)
mi_div = proceso_padre.enviar_pedido((20, 4), proceso_div, 8)
try:
ret = proceso_padre.enviar_pedido((mi_div, suma_parc),
proceso_suma, 5)
self.assertTrue(False)
except ProcesoNoListo:
self.assertTrue(True)
def test_termino_suma(self):
"""
Calculamos normalmente 1 + 3
"""
proceso_padre = Proceso(proc_id=1)
f_suma = funciones_ponderadas['suma']
proceso_suma = Proceso(proc_id=2, **f_suma)
result = proceso_padre.enviar_pedido((1, 3), proceso_suma, 5)
self.assertEqual(result, 4)
self.assertEqual(proceso_suma.ya_use, proceso_suma.rafaga)
self.assertEqual(proceso_suma.estado, 'terminado')
def test_reset_div(self):
"""
Calculamos 3 / 1. Y reseteamos
"""
proceso_padre = Proceso(proc_id=1)
f_div = funciones_ponderadas['div']
proceso_div = Proceso(proc_id=2, **f_div)
result = proceso_padre.enviar_pedido((3, 1), proceso_div, 8)
self.assertEqual(result, 3)
self.assertEqual(proceso_div.ya_use, proceso_div.rafaga)
self.assertEqual(proceso_div.estado, 'terminado')
proceso_div.reset()
self.assertEqual(proceso_div.ya_use, 0)
self.assertEqual(proceso_div.estado, 'listo')
def __init__(self, nodo, puerto):
socket.socket.__init__(self)
self.sock = (nodo, puerto)
try:
self.connect(self.sock)
while True:
nickname = input("INGRESA UN NICKNAME: ")
if len(nickname) < 1:
pass
else:
break
self.nickname = nickname
self.send(nickname.encode())
Proceso(self).start()
except Exception as e:
sys.stderr.write(str(e) + '\n')
return
while True:
try:
request = input("@{0}: ".format(self.nickname))
self.send(request.encode())
except Exception as e:
sys.stderr.write(str(e) + '\n')
break
def test_no_termino_prod(self):
"""
Calculamos 4 * 2. Se ejecuta el proceso un rato, no termina, y despues
se vuelve a ejecutar y efectivamente termina.
"""
proceso_padre = Proceso(proc_id=1)
f_prod = funciones_ponderadas['prod']
proceso_prod = Proceso(proc_id=2, **f_prod)
result = proceso_padre.enviar_pedido((4, 2), proceso_prod, 5)
self.assertEqual(result, None)
self.assertEqual(proceso_prod.ya_use + 3, proceso_prod.rafaga)
self.assertEqual(proceso_prod.estado, 'listo')
result = proceso_padre.enviar_pedido((4, 2), proceso_prod, 3)
self.assertEqual(result, 8)
self.assertEqual(proceso_prod.ya_use, proceso_prod.rafaga)
self.assertEqual(proceso_prod.estado, 'terminado')
class Cpu:
def __init__(self):
self.mensaje_inicio()
# Bloque de control de proceso
self.listo = Nodo()
self.ejecucion = Nodo()
self.bloqueado = Nodo()
self.suspendido_listo = Nodo()
self.suspendido_bloqueado = Nodo()
print("------------------------")
print("Iniciando Sesion")
# Carga de Procesos Prioritarios Basicos
crear_procesos_nuevos("Alta", "root", 3)
print("-------------------------")
def cargar(self):
pass
def procesos(self):
pass
def carga_kernel(self):
def mensaje_inicio(self):
print ("---------------------")
print ("Bienvenido al Kernel")
print ("---------------------")
print ("Iniciando bloque de control de proceso")
def crear_procesos_nuevos(self, prioridad, usuario, cant):
for i in range(0:cant):
if (prioridad == 'Alta'):
self.listo = self.listo.agregar(Proceso(random(1.1, 999999.89), "proceso-" + i, 7500, prioridad, 'comando - proceos - service', usuario))
if (prioridad == 'Media'):
self.listo = self.listo.agregar(Proceso(random(1.1, 999999.99), "proceso-medio-"+i, 3400, prioridad, 'comm- proceso - service - medio', usuario))
if (prioridad == "Baja"):
self.listo = self.listo.agregar(Proceso(random(1.1, 999999.99), "Proceso-Bajo-"+i, 1200, prioridad, "systemctl start service basic", usuario))
def test_ej_combinado(self):
"""
Calculamos 20/4 + (4 * 3) + 1
"""
proceso_padre = Proceso(proc_id=1)
f_suma = funciones_ponderadas['suma']
proceso_suma = Proceso(proc_id=2, **f_suma)
f_prod = funciones_ponderadas['prod']
proceso_prod = Proceso(proc_id=3, **f_prod)
f_div = funciones_ponderadas['div']
proceso_div = Proceso(proc_id=4, **f_div)
mi_prod = proceso_padre.enviar_pedido((4, 3), proceso_prod, 8)
suma_parc = proceso_padre.enviar_pedido((mi_prod, 1), proceso_suma, 5)
mi_div = proceso_padre.enviar_pedido((20, 4), proceso_div, 8)
proceso_suma.reset()
ret = proceso_padre.enviar_pedido((mi_div, suma_parc), proceso_suma, 5)
self.assertEqual(ret, 18)
def leer(self, path):
tanda = []
archivo = open(path, "r")
for trabajo in archivo.readlines():
data = trabajo.split(";")
proceso = Proceso(
nombre=data[0],
arribo=int(re.sub("\s+","", data[1])),
tiempoTotal=int(re.sub("\s+","", data[2])),
tamaño=int(re.sub("\s+","", data[3]))
)
tanda.append(proceso)
archivo.close()
return tanda
def simular(tanda, tamañoMemoria: int, estrategia, tiempoSelecion: int,
tiempoCarga: int, tiempoLiberacion: int):
# SIMULAR
simular = True
memoria = Memoria(tamañoMemoria)
admin = AdminMemoria(memoria, estrategia, tiempoSelecion, tiempoCarga,
tiempoLiberacion)
# Estadistica
logs = []
tandaOriginal = []
indiceFragmantacion = 0
countFragamntacion = True
tiemposRetorno = []
tiempoMedioRetorno = 0
# Contador
T = 0
# Ordenar tanda por tiempo de Arribo
procesos = sorted(tanda, key=lambda proceso: proceso.arribo)
txtIntro = "######################################################" + '\n'
logs.append(txtIntro)
print(txtIntro)
txtIntro = "################# SIMULADOR #######################" + '\n'
logs.append(txtIntro)
print(txtIntro)
txtIntro = "######### ADMINISTRADOR DE MEMORIA ################" + '\n'
logs.append(txtIntro)
print(txtIntro)
txtIntro = "######################################################" + '\n'
logs.append(txtIntro)
print(txtIntro)
txtTandaT = ('TANDA DE TRABAJO' + '\n')
logs.append(txtTandaT)
print(txtTandaT)
for proceso in procesos:
logs.append(str(proceso))
print(proceso)
tandaOriginal.append(proceso)
txt = 'INICIAR SIMULACION\nT: 0 --> Inicializar Memoria\n'
logs.append(txt)
print(txt)
txt = imprimirMemoria(admin.memoria)
logs.append(txt)
print(txt)
T += 1
admin.tiempo()
while (simular):
if ((len(procesos) != 0) or (len(admin.memoria.particiones) > 1)):
# LIBERACION (Mientras existan procesos a liberar)
estado = admin.liberacion()
while (estado['exito']):
Tliberacion = T
for i in range(tiempoLiberacion):
txt = ('T: ' + str(Tliberacion) +
': --> Trabajando... ' + ' MemLib.: ' +
str(admin.memoria.libre) + '\n')
logs.append(txt)
print(txt)
Tliberacion += 1
admin.tiempo()
if (countFragamntacion):
indiceFragmantacion += admin.memoria.libre
# Resta al indice la memoria contada como libre
# en el ultimo ciclo.
if (countFragamntacion):
indiceFragmantacion -= estado['proceso'].tamaño
T += tiempoLiberacion
txt = ('--- LIBERACION COMPLETADA ---\n')
logs.append(txt)
print(txt)
tiemposRetorno.append({
'proceso': estado['proceso'].nombre,
'arribo': estado['proceso'].arribo,
'tiempoRetorno': T - 1
})
admin.arribos = True #Permite nuevos arrivos
estado = admin.liberacion()
txt = (imprimirMemoria(admin.memoria))
logs.append(txt)
print(txt)
# SELECCION
if (len(procesos) != 0):
proceso = procesos[0]
# Verifica que esten permitidos los arribos y sea el turno del proceso
if ((admin.arribos) and (proceso.arribo <= T)):
Tseleccion = T
for i in range(tiempoSelecion):
txt = ('T: ' + str(Tseleccion) +
': --> SELECCIONANDO PARTICION AL PROCESO: ' +
str(proceso) + ' MemLib: ' +
str(admin.memoria.libre) + '\n')
logs.append(txt)
print(txt)
Tseleccion += 1
admin.tiempo()
if (countFragamntacion):
indiceFragmantacion += admin.memoria.libre
T += tiempoSelecion
# ASIGNACION
procesoAsig = Proceso(proceso.nombre, proceso.arribo,
proceso.tiempoTotal + tiempoCarga,
proceso.tamaño)
memoriaLibreAsignacion = admin.memoria.libre
if (admin.arriboProceso(procesoAsig)):
Tasignacion = T
for i in range(tiempoCarga):
txt = ('T: ' + str(Tasignacion) +
': --> CARGANDO PROCESO: ' +
str(proceso.nombre) + ' MemLib: ' +
str(memoriaLibreAsignacion) + '\n')
logs.append(txt)
print(txt)
Tasignacion += 1
admin.tiempo()
# Verifica | Si no es el ultimo proceso en arribar cuanta IndFrag / Detiene la cuenta.
indiceFragmantacion += memoriaLibreAsignacion
T += tiempoCarga
txt = imprimirMemoria(admin.memoria)
logs.append(txt)
print(txt)
procesos.pop(0)
if (len(procesos) == 0):
countFragamntacion = False
else:
if (proceso.tamaño > admin.memoria.tamaño):
txt = ('T: ' + str(T) + ': --> EL PROCESO: ' +
str(proceso.nombre) +
' EXEDE EL TAMAÑO DE LA MEMORIA' + '\n')
logs.append(txt)
print(txt)
procesos.pop(0)
else:
txt = ('T: ' + str(T) + ': --> Sin Arribos\n')
logs.append(txt)
print(txt)
# TIEMPO
T += 1
admin.tiempo()
if (countFragamntacion):
indiceFragmantacion += admin.memoria.libre
else:
txt = ('T: ' + str(T) +
': --> Sin Arribos - Tanda Completada' + '\n')
logs.append(txt)
print(txt)
# TIEMPO
T += 1
admin.tiempo()
tetx = imprimirMemoria(admin.memoria)
logs.append(txt)
print(txt)
else:
simular = False
txtFin = "######################################################" + '\n'
logs.append(txtFin)
print(txtFin)
txtFin = "################# RESULTADO #######################" + '\n'
logs.append(txtFin)
print(txtFin)
txtFin = "######################################################" + '\n'
logs.append(txtFin)
print(txtFin)
txtEstrageia = ('ESTRATEGIA: ' + admin.estrategia + '\n')
logs.append(txtEstrageia)
print(txtEstrageia)
txtFragmentacion = ('FRAGMENTACION EXTERNA: ' + str(indiceFragmantacion) +
'\n')
logs.append(txtFragmentacion)
print(txtFragmentacion)
txtTiempoRetorno = ('TIEMPO DE RETORNO | PROCESOS | ' + '\n')
logs.append(txtTiempoRetorno)
print(txtTiempoRetorno)
for dato in tiemposRetorno:
tiempoRetorno = dato['tiempoRetorno'] - dato['arribo']
txtTR = ('| ' + str(dato['proceso']) + ' |' + ' Arribo: ' +
str(dato['arribo']) + ' Retorno: ' +
str(dato['tiempoRetorno']) + ' Tiempo Retorno: ' +
str(tiempoRetorno) + '\n')
logs.append(txtTR)
print(txtTR)
tiempoMedioRetorno += tiempoRetorno
# len(tiemposRetorno) retorn la cantidad de procesos
tMedioRetorno = 0
try:
tMedioRetorno = tiempoMedioRetorno / len(tiemposRetorno)
except ZeroDivisionError:
pass
tiempoRetornoTanda = 0
try:
tiempoRetornoTanda = tiemposRetorno.pop()['tiempoRetorno']
except IndexError:
pass
txtTiempoMedioRetorno = ('TIEMPO MEDIO DE RETORNO: ' + str(tMedioRetorno) +
'\n')
logs.append(txtTiempoMedioRetorno)
print(txtTiempoMedioRetorno)
txtTiempoRetornoTanda = ('TIEMPO DE RETORNO DE LA TANDA: ' +
str(tiempoRetornoTanda) + '\n')
logs.append(txtTiempoRetornoTanda)
print(txtTiempoRetornoTanda)
return logs
import json
import algo.srtf as srtf
import algo.rr as rr
from proceso import Proceso
from flask import Flask
p1 = Proceso(0, 7, "p1")
p2 = Proceso(2, 4, "p2")
p3 = Proceso(4, 1, "p3")
p4 = Proceso(5, 4, "p4")
procesos = [p1, p2, p3, p4]
gantt = srtf.SRTF(*[p1, p2, p3, p4])
#gantt2 = rr.RR(2, *[p1, p2, p3, p4])
i=0
result = gantt.srtf()
print(result)
# print("Tiempo de espera individuales: ")
for proceso in procesos:
print(f"Proceso: {proceso.nombre} - Espero: {proceso.wait}")
print("Total de tiempo en espera: ", gantt.total_wait_time())
print("Tiempo de espera promedio: ", gantt.total_wait_time()/gantt.count_processes)
print('-- Desde: ' + str(posBase) + ' Hasta: ' + str(posTope))
# RECALCULAR TAMAÑO DE LA NUEVA PARTICION LIBRE
newPartUnif = Particion(tamaño=memoriaTotal, libre=True)
self.memoria.insertarEntre(newPartUnif, posBase, posTope)
pass
if __name__ == "__main__":
import random
M = Memoria(256)
# AdmMem = AdminMemoria(M,'first-fit',15,2,2)
AdmMem = AdminMemoria(M, 'next-fit', 15, 2, 2)
for i in range(6):
P = Proceso(nombre='P-' + str(i),
arribo=random.randrange(60) + 1,
tiempoTotal=random.randrange(50) + 1,
tamaño=random.randrange(10) + 35)
AdmMem.arriboProceso(P)
print('NUEVA TANDA')
imprimirMemoria(AdmMem.memoria)
# AdmMem.eliminarProceso(0)
AdmMem.eliminarProceso(1)
AdmMem.eliminarProceso(3)
# imprimirMemoria(AdmMem.memoria)
# imprimirMemoria(AdmMem.memoria)
AdmMem.eliminarProceso(2)
imprimirMemoria(AdmMem.memoria)
for i in range(1):