def enviar_sinal(self):
if self.registradores["CI"] != -1:
# neste ponto vai buscar no cache, caso nao tenha, vai buscar na memoria( continua o processo normal)
cacheresult = self.cache.get(self.registradores["CI"])
if cacheresult is not None:
# cacheresult sera uma tupla com proximo ci[0] e a informacao guardada[1]
self.registradores["CI"] = cacheresult[0]
self.dado = cacheresult[1]
self.passo = Cpu.PASSO_PROCESSAMENTO
else:
sinalram = Consts.get_vetor_conexao(Consts.CPU, Consts.RAM,
self.registradores["CI"],
self.tipoSinal)
self.barramento.enviar_sinal(sinalram)
if self.tipoSinal == Consts.T_L_INSTRUCAO:
sinalentrada = Consts.get_vetor_conexao(
Consts.CPU, Consts.ENTRADA, self.registradores["CI"],
self.tipoSinal)
self.barramento.enviar_sinal(sinalentrada)
self.passo = Cpu.PASSO_ENDERECO_DADO
self.log.write_line('cpu => sinal enviado')
def processar_sinal(self, sinal):
if sinal[Consts.T_ORIGEM] == Consts.CPU and sinal[
Consts.T_TIPO] == Consts.T_L_INSTRUCAO:
code = self.bufferReader.get_line().byte_array
# enviar pra memoria
sinal = Consts.get_vetor_conexao(Consts.ENTRADA, Consts.RAM,
sinal[Consts.T_DADOS],
Consts.T_E_INSTRUCAO)
self.barramento.enviar_sinal(sinal)
self.log.write_line('entrada => sinal enviado')
# esperar confirmacao da memoria
while not self.endereco:
self.log.write_line("entrada => esperando endereco")
pass
self.endereco = None
dado = Consts.get_vetor_conexao(Consts.ENTRADA, Consts.RAM, code,
None)
self.barramento.enviar_dado(dado)
else:
Consts.running = False
raise Exception("sinal invalido")
def enviar_endereco_dado_cpu(self, posmem, tipo):
proximoendereco = self.proximo_endereco(posmem)
endereco = Consts.get_vetor_conexao(Consts.RAM, Consts.CPU,
proximoendereco, tipo)
self.barramento.enviar_endereco(endereco)
instrucao = self.ler_instrucao(posmem)
dado = Consts.get_vetor_conexao(Consts.RAM, Consts.CPU, instrucao,
tipo)
self.barramento.enviar_dado(dado)
def tratar_sinal_cpu(self, sinal):
tipo = sinal[Consts.T_TIPO]
if tipo == Consts.T_L_INSTRUCAO:
# deve continuar rodando a memoria, porem deve esperar a entrada enviar dados para poder agir
self.esperando_entrada = True
elif tipo == Consts.T_RL_INSTRUCAO:
# if tipo == Consts.T_L_INSTRUCAO:
# # pego na entrada e ponho na posicao do ci e fico esperando via loop
# self.get_instrucao_entrada(sinal[Consts.T_DADOS])
self.enviar_endereco_dado_cpu(sinal[Consts.T_DADOS], tipo)
elif tipo == Consts.T_L_VALOR:
endereco = sinal[Consts.T_DADOS]
endereco += self.code_slice
if self.tamanho - 1 < endereco:
raise MemoryError("Posicao de memoria inexistente")
if self.tamanho - 1 < endereco:
if (self.tamanho_total_valores + self.code_slice) < endereco:
raise MemoryError("Posicao de memoria " +
str(endereco - self.code_slice) +
" inexistente")
dado = Consts.get_vetor_conexao(Consts.RAM, Consts.CPU, 0,
tipo)
else:
dado = Consts.get_vetor_conexao(Consts.RAM, Consts.CPU,
self.memoria[endereco], tipo)
self.barramento.enviar_dado(dado)
elif tipo == Consts.T_E_VALOR:
endereco = sinal[Consts.T_DADOS]
endereco += self.code_slice
if self.tamanho - 1 < endereco:
if (self.tamanho_total_valores + self.code_slice) < endereco:
Consts.running = False
raise MemoryError("Posicao de memoria " +
str(endereco - self.code_slice) +
" inexistente")
else:
self.memoria[endereco] = sinal[Consts.T_EVALOR_POS]
else:
raise Exception("sinal invalido")
def __init__(self, barramento, tamanho, log=LogNone()):
super(Memoria, self).__init__(name="Memoria")
self.log = log
self.tamanho_informado = tamanho
if tamanho > 35:
MemoryError("limite de memoria excedido (32GB ou 32*2**30)")
if tamanho < Consts.MEMORIA_X_MIN:
tamanho = Consts.MEMORIA_X_MIN
log.write_line(
'tamanho de memoria muito pequeno, o tamanho minimo foi escolhido'
)
elif tamanho > Consts.MEMORIA_X_MAX:
tamanho = Consts.MEMORIA_X_MAX
# log.write_line('tamanho de memoria muito grande, o tamanho maximo foi escolhido')
self.tamanho = 32 * (2**tamanho)
codeslice = Consts.get_memoria_code_sliced(self.tamanho)
self.code_slice = codeslice - (codeslice % Consts.CODE_SIZE)
self.tamanho_total_valores = (
32 * (2**self.tamanho_informado)) - self.code_slice
self.memoria = [0 for i in range(self.tamanho)]
self.sinais = Queue()
self.dado = None
self.barramento = barramento
self.esperando_entrada = False
def atualizar(self, pos, valor):
if not isinstance(valor, type(())):
sinal = Consts.get_vetor_conexao(Consts.CPU,
Consts.RAM,
-pos,
Consts.T_E_VALOR,
len=Consts.T_EVLENGTH)
sinal[Consts.T_EVALOR_POS] = valor
self.barramento.enviar_sinal(sinal)
def get_valor_da_memoria(self, dado):
# verificar cache antes
cacheresult = self.cache.get(dado)
self.dado = None
if cacheresult is not None:
return cacheresult
else:
sinal = Consts.get_vetor_conexao(Consts.CPU, Consts.RAM, -dado,
Consts.T_L_VALOR)
self.barramento.enviar_sinal(sinal)
while self.dado is None:
# self.log.write_line("cpu => esperando dado")
pass
self.cache.add(dado, self.dado[Consts.T_DADOS])
return self.dado[Consts.T_DADOS]
def get_instrucao_entrada(self, sinal):
pos = sinal[Consts.T_DADOS]
endereco = Consts.get_vetor_conexao(Consts.RAM, Consts.ENTRADA, pos,
Consts.T_E_INSTRUCAO)
self.barramento.enviar_endereco(endereco)
self.log.write_line('memoria => sinal enviado')
while self.dado is None:
# self.log.write_line("memoria =>> esperando dado")
pass
self.escrever_instrucao(pos, self.dado[Consts.T_DADOS])
self.dado = None
if self.esperando_entrada:
self.esperando_entrada = False
self.enviar_endereco_dado_cpu(pos, Consts.T_L_INSTRUCAO)
def processar(self, instrucao):
if instrucao[0] == Consts.INSTRUCOES["end"].codigo:
self.cache.atualizar_todos()
Consts.running = False
self.registradores["CI"] = -1
self.barramento.exibir_dados()
elif instrucao[0] == Consts.INSTRUCOES["inc"].codigo:
val = instrucao[1]
if self.is_registrador(val):
self.registradores[chr(int(-val))] += 1
elif self.is_pos_memoria(val):
valor = self.get_valor(val)
self.enviar_valor_memoria(val, valor + 1)
else:
Consts.running = False
raise ValueError(
val +
" precisa ser posicao de memoria ou um registrador para a operacao 'inc'"
)
elif instrucao[0] == Consts.INSTRUCOES["dec"].codigo:
val = instrucao[1]
if self.is_registrador(val):
self.registradores[chr(int(-val))] -= 1
elif self.is_pos_memoria(val):
valor = self.get_valor(val)
self.enviar_valor_memoria(val, valor - 1)
else:
Consts.running = False
raise ValueError(
val +
" precisa ser posicao de memoria ou um registrador para a operacao 'dec'"
)
elif instrucao[0] == Consts.INSTRUCOES["add"].codigo:
val = self.get_valor(instrucao[1]) + self.get_valor(instrucao[2])
if self.is_registrador(instrucao[1]):
self.registradores[chr(int(-instrucao[1]))] = val
elif self.is_pos_memoria(instrucao[1]):
self.enviar_valor_memoria(instrucao[1], val)
elif instrucao[0] == Consts.INSTRUCOES["mov"].codigo:
pointer = bool(instrucao[1])
val = self.get_valor(instrucao[3])
if not pointer and self.is_registrador(instrucao[2]):
self.registradores[chr(int(-instrucao[2]))] = val
elif pointer or self.is_pos_memoria(instrucao[2]):
if pointer:
if not self.is_registrador(instrucao[2]):
Consts.running = False
raise SyntaxError(
"Ponteiros devem ser acompanhados de um registrador"
)
self.enviar_valor_memoria(
-self.registradores[chr(int(-instrucao[2]))], val)
else:
self.enviar_valor_memoria(instrucao[2], val)
elif instrucao[0] == Consts.INSTRUCOES["imul"].codigo:
val = self.get_valor(instrucao[3]) * self.get_valor(instrucao[2])
if self.is_registrador(instrucao[1]):
self.registradores[chr(int(-instrucao[1]))] = val
elif self.is_pos_memoria(instrucao[1]):
self.enviar_valor_memoria(instrucao[1], val)
elif instrucao[0] == Consts.INSTRUCOES["label"].codigo:
if not self.existe_label(instrucao[1]):
self.loops.append(Loop(self.registradores["CI"], instrucao[1]))
else:
Consts.running = False
raise Exception("a label " + str(instrucao[1]) + " ja existe")
elif instrucao[0] == Consts.INSTRUCOES["condicao"].codigo:
val1 = self.get_valor(instrucao[1])
val2 = self.get_valor(instrucao[3])
condicao = eval(
str(val1) + Consts.get_condicao_string(instrucao[2]) +
str(val2))
if condicao:
self.go_to_loop(instrucao[4])
else:
self.go_to_loop(instrucao[5])
else:
Consts.running = False
raise Exception("instrucao invalida codigo:" + str(instrucao[0]))
self.log.write_line(str(self.registradores))