def __init__(self):
self.constante_entero = []
self.constante_flotante = []
self.constante_str = []
self.apuntador = Pila()
self.globales = Memoria()
self.main = Memoria()
self.alcanceActual = 0
self.funciones = dict()
def __init__(self):
print('\n\t\t\t🔵🔵🔵 Iniciando o Processo Gerenciador! 🔵🔵🔵\n')
self.idProcesso = 0
self.tempo = 0
self.tempoCPU = 0
self.estadoExec = 0
self.CPU = CPU()
self.estadoPronto = []
self.estadoBloqueado = []
self.tabelaProcesso = TabelaProcessos()
self.memoriaPrimaria = Memoria(5)
self.memoriaSecundaria = Memoria(0)
self.memoriaVirtual = Memoria(0)
self.tempoAlocNos = 0
self.numAlocNos = 0
self.alocFeitas = 0
self.alocNegadas = 0
# Definição da opção de escalonamento
print('Como você gostaria que os processos fossem escalonados?')
print('➡️ H - Escalonar por prioridade mais alta')
print('➡️ X - Escalonar por número de instruções')
while(True):
self.modoDeEscalonamento = input('📌 Escolha uma opção: ').upper()
if self.modoDeEscalonamento == 'H' or self.modoDeEscalonamento == 'X':
break
else:
print('❌ Erro! Entrada inválida\n')
print('\n')
# Definição da opção de impressão
print('Como você gostaria de imprimir o estado do sistema?')
print('➡️ D - Impressão detalhada')
print('➡️ S - Impressão simplificada')
while(True):
self.modoDeImpressao = input('📌 Escolha uma opção: ').upper()
if self.modoDeImpressao == 'D' or self.modoDeImpressao == 'S':
break
else:
print('❌ Erro! Entrada inválida\n')
print('\n')
self.criarProcessoSimulado(
eProcessoInicial = True
)
print('🔵Gerenciador🔵 criou um 🟡Simulado🟡')
def __init__(self, funcionGlobal="", funcionLocal=""):
self.funcionGlobal = funcionGlobal
self.funcionLocal = funcionLocal
#Inicializa dir funcion
self.dirFuncion = DirFuncion()
#Inicializa cubo semantico
self.cuboSemantico = CuboSemantico()
#Inicializa memoria
self.memoria = Memoria()
#Variables temporales
self.variablesTemp = []
self.nombresParametros = []
self.tiposParametros = []
self.tiposArgumentos = []
self.pilaOperandos = []
self.pilaTipos = []
self.pilaOperadores = []
self.cuadruplos = []
#Para los saltos tipo gotoF y gotoV
self.saltos = []
#Para los de regreso
self.regresa = []
#Empieza contador de cuadruplos
self.numCuadruplo = 1
#Sirve para ver si una funcion puede tener return o no
self.tieneReturn = False
#Sirve para crear el diccionario de arreglos
self.arreglos = {}
#Mete el arreglo para poder hacer su cuadruplo
self.stackArreglos = []
def setFunciones(self, strP, enteroP, floatP, boolP, enteroPT, floatPT,
pointerP):
#crea memoria para la nueva funcion, modifica la memoria y la agrega al diccionario de funciones
funcion = Memoria()
funcion.setMemoria(int(strP), int(enteroP), int(floatP), int(boolP),
int(enteroPT), int(floatPT), int(pointerP))
self.funciones[self.alcanceActual + 1] = funcion
def __init__(self, info, player):
self.nombre = info['name']
self.posicion = info['position']
self.game_name = info['game']['name']
self.player = player
# Inicializo los juegos dependiendo del objeto
if self.game_name == 'Adivinanzas':
self.game = Adivinanza(info['game'], player)
elif self.game_name == 'sopa_letras':
self.game = Sopita(info['game'], player)
elif self.game_name == 'Preguntas sobre python':
self.game = PreguntaPython(info['game'], player)
elif self.game_name == 'ahorcado':
self.game = Ahorcado(info['game'], player)
elif self.game_name == 'Preguntas matemáticas':
self.game = PregMate(info['game'], player)
elif self.game_name == 'Criptograma':
self.game = Criptograma(info['game'], player)
elif self.game_name == 'Encuentra la lógica y resuelve':
self.game = LogicaE(info['game'], player)
elif self.game_name == 'Quizizz Cultura Unimetana':
self.game = Quizizz(info['game'], player)
elif self.game_name == 'memoria con emojis':
self.game = Memoria(info['game'], player)
elif self.game_name == 'Lógica Booleana':
self.game = LogicaB(info['game'], player)
elif self.game_name == 'Juego Libre':
self.game = Pipes(info['game'], player)
elif self.game_name == 'Palabra mezclada':
self.game = PalabrasMezcladas(info['game'], player)
elif self.game_name == 'escoge un número entre':
self.game = EscogeNumero(info['game'], player)
def ERA():
# Crea un espacio en memoria donde guarda las variables locales y temporales de la funcion llamada
funcionLlamada['funcion'] = self.dirFunciones.RegresaFuncion(
dirOperandoIzquierdo)
funcionLlamada['memoria'] = Memoria()
self.parametroActual = 0
self.MemoriaLocal(funcionLlamada)
self.MemoriaTemporal(funcionLlamada)
self.cantInstruccionesActuales += 1
def __init__(self):
self.programa = None
self.memoria = Memoria()
self.estrella = None
self.screen = None
self.turtle_activa = False
self.pila_contextos = []
def main():
filaEntrada = inicilizarEntrada('entrada.txt')
processosNovos = {'tempoReal': [], 'usuario': []}
processosProntos = []
processosProntosSuspenso = []
processosBloqueados = []
processosBloqueadosSuspenso = [] # Não ta sendo passado pra nenhuma função
processosExecutando = []
processosFinalizados = []
so = SO()
memoria = Memoria()
gerenciaIO = GerenciaIO()
totalProcessos = len(filaEntrada)
while len(processosFinalizados) != totalProcessos:
# Escalonador de longo prazo
while len(filaEntrada) > 0 and filaEntrada[0].tempoChegada == so.tempoSistema: # Isso vai dar certo?
if filaEntrada[0].prioridade == 0:
processosNovos['tempoReal'].append(filaEntrada.pop(0))
else:
processosNovos['usuario'].append(filaEntrada.pop(0))
escalona_lp(so.gerenciadorIO, processosProntos, processosProntosSuspenso, processosBloqueados, processosBloqueadosSuspenso, processosNovos, memoria)
# Escalonador de médio prazo (acho que não vai ser chamado explicitamente, só indiremantente pro swap)
if (len(processosProntos) == 0 and len(processosProntosSuspenso) > 0) or (len(processosBloqueados) == 0 and len(processosBloqueadosSuspenso) > 0):
escalonador_mp_ativa(gerenciaIO, processosProntos,processosProntosSuspenso,processosBloqueados, processosBloqueadosSuspenso, memoria)
# Escalonador de curto prazo
rodadaDeEscalonadorCurto(so.tempoSistema, memoria, so.gerenciadorIO, processosBloqueados, processosProntos,
processosExecutando, processosFinalizados, so.cpus)
#moveBloqueadoParaExecutando(processosBloqueadosSuspenso,processosProntosSuspenso)
# Espera um enter para entrar no próximo loop
os.system('cls' if os.name == 'nt' else 'clear')
so.imprimeSO()
memoria.imprimeMemoria()
imprimeFilas(processosProntos, processosProntosSuspenso, processosBloqueados, processosBloqueadosSuspenso, processosFinalizados)
so.passagemDeTempo()
input()
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
# -*- coding: utf-8 -*-
from memoria import Memoria
from processo import Processo
from disco import Disco
from menu import menu
if __name__ == "__main__":
menu()
mem = Memoria()
disco = Disco()
processo = Processo(escrita=True)
processo2 = Processo(escrita=True)
processo3 = Processo(escrita=True)
processo4 = Processo(escrita=False)
mem.init_Mem()
disco.init_Disco()
if mem.mapear_processo(processo):
print("[+] O processo 1 foi mapeado para a memória")
if mem.mapear_processo(processo2):
print("[+] O processo 2 foi mapeado para a memória")
if mem.unmmap_processo(processo, disco):
print("[+] O processo 1 foi desmapeado da memória")
if mem.mapear_processo(processo3):
print("[+] O processo 3 foi mapeado para a memória")
def __init__(self):
self.program = None
self.memoria = Memoria()
self.pila_contextos = []
def run():
global memoria_global, param_stack, memorias, llamadas, pila_returns, this_func
#añadiendo ctes y apuntadores a memoria.
save_ctes()
tracker = 0
while tracker < len(dir_quadruples):
#print("contador " + str(tracker))
curr_quad = dir_quadruples[tracker]
instr = curr_quad[0]
el2 = curr_quad[1]
el3 = curr_quad[2]
el4 = curr_quad[3]
if instr == 'Goto':
tracker = el4
elif instr == 'print':
if (el4 >= top_limit_cte):
aux = get_value(el4)
else:
aux = el4
print(get_value(aux))
tracker += 1
elif instr == 'read':
# agregar el leer variable
aux = input()
if (el4 >= top_limit_cte):
aux1 = get_value(el4)
else:
aux1 = el4
set_value(aux1, aux)
tracker += 1
elif instr == '+' or instr == '-' or instr == '*' or instr == '/' or instr == '<' or instr == '<=' or instr == '>' or instr == '>=' or instr == '==' or instr == '<>' or instr == '&' or instr == '|':
if (el2 >= top_limit_cte):
aux1 = get_value(el2)
else:
aux1 = el2
if (el3 >= top_limit_cte):
aux2 = get_value(el3)
else:
aux2 = el3
p1 = getParam(aux1)
p2 = getParam(aux2)
value = calculate(p1, instr, p2)
set_value(el4, value)
tracker += 1
elif instr == '=':
if (el2 >= top_limit_cte):
aux1 = get_value(el2)
else:
aux1 = el2
aux1 = get_value(aux1)
if (el4 >= top_limit_cte):
aux = get_value(el4)
else:
aux = el4
set_value(aux, aux1)
tracker += 1
elif instr == 'ENDFUNC':
#liberar memoria actual
#recuperar dir ret
#regresar a la mem anterior
if (not memorias.isEmpty()):
memorias.pop()
tracker = llamadas.pop()
elif instr == 'GotoF':
evaluar = getParam(el2)
if (evaluar == False):
tracker = el4
else:
tracker += 1
elif instr == 'ERA':
#Allocates memory
#aux = Memoria()
#memorias.push(aux)
tracker += 1
elif instr == 'PARAM':
#aux = Memoria()
#aux = memorias.pop()
val = get_value(el2)
#memorias.push(aux)
#set_value(el4, val)
param_stack.push(val)
param_stack.push(el4)
tracker += 1
elif instr == 'GOSUB':
aux = Memoria()
memorias.push(aux)
#if(not param_stack.isEmpty()):
this_func.push(el2)
while (not param_stack.isEmpty()):
set_value(param_stack.pop(), param_stack.pop())
llamadas.push(tracker + 1)
tracker = el4
elif instr == 'RETURN':
aux_val = get_value(el4)
memorias.pop()
tracker = llamadas.pop()
if isinstance(this_func.peek(), str):
this_func.pop()
set_value(this_func.pop(), aux_val)
elif instr == 'VERIFY':
if getParam(el2) < getParam(el4):
tracker += 1
else:
print('Error en el acceso a un arreglo, fuera de dimension')
sys.exit()
else:
#lets hope this does not get called
print('error en cuadruplos')
sys.exit()
from stack import Stack
from memoria import Memoria
import sys
import six
#Inicializacion de directorio de funciones, los cuadruplos a leer
dir_func = {}
dir_quadruples = {}
#Stack para saber desde donde se llama una funcion y de los niveles de memoria.
llamadas = Stack()
memorias = Stack()
#Memoria global
memoria_global = Memoria()
#Stack usada para manejo de funciones
this_func = Stack()
param_stack = Stack()
#memory ranges
#global 0 - 9999
top_limit_global = 10000
#local 10000- 19999
top_limit_local = 20000
#constants 20000- 29999
top_limit_cte = 30000
#pointers 30000-+++
if ((posDer <= (len(particiones) - 1))
and (particiones[posDer].libre)):
memoriaTotal += particiones[posDer].tamaño
posTope = posDer
posDer += 1
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)
from memoria import Memoria
LETRAS = set(ascii_uppercase)
parser = argparse.ArgumentParser()
parser.add_argument("unidades",
help="Unidades de memoria que tiene el sistema",
type=int,
nargs='?',
default=30)
args = parser.parse_args()
print('Simulación de asignación y liberación de procesos en memoria.')
print('Tamaño: %i unidades.' % args.unidades)
operacion = -1
mem = Memoria(args.unidades)
while not operacion == 2:
print('\nEstado actual: \n\t', end='')
mem.imprime_mem()
operacion = int(
input('Operación a realizar (0 : asignar, 1 : liberar, 2: salir): '))
if (operacion == 0):
lista_procesos = sorted(
LETRAS -
set(mem.procesosEnMemoria)) # Quitamos las letras que ya usamos
proceso = lista_procesos[0]
u_requeridas = int(input('Nuevo proceso (%s): ' % proceso))
mem.asignar(proceso, u_requeridas)
elif (operacion == 1):
strpem = ''.join(
mem.procesosEnMemoria) # Cadena de procesos en memoria
