コード例 #1
0
ファイル: test.py プロジェクト: juansca/myProcess
    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)
コード例 #2
0
ファイル: test.py プロジェクト: juansca/myProcess
    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')
コード例 #3
0
ファイル: test.py プロジェクト: juansca/myProcess
    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')
コード例 #4
0
ファイル: cliente.py プロジェクト: fywer/basex
    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
コード例 #5
0
ファイル: test.py プロジェクト: juansca/myProcess
    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')
コード例 #6
0
ファイル: cpu.py プロジェクト: vmgabriel/planning-queue
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))
コード例 #7
0
ファイル: test.py プロジェクト: juansca/myProcess
    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)
コード例 #8
0
 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
コード例 #9
0
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
コード例 #10
0
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)


コード例 #11
0
        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):