Especificação dos Microprocessadores - Turma

Especificação dos Microprocessadores - Turma
2014/2
Prof. Juliano
Gerado randomicamente em 2014-10-30
Como se trata de uma 1a versão de sorteio, algumas combinações talvez sejam
muito difíceis, portanto:
• Negociações e correções dos requisitos podem ocorrer no semestre, mas só
até 48h antes dos prazos de entrega para o item negociado.
• A equipe poderá escolher uma especificação completa de um dos integrantes;
não pode misturar coisas da espec. de um aluno com a do outro.
• Se escolher qualquer item das alternativas opcionais que funcione ao final, a
equipe fica livre para escolher qualquer achievement e programa de
demonstração.
• Restrição única para codificação: a instrução 0 deverá ser NOP (não faz
nada).
Lista de Alunos:
Andre Lucas Zanellato
Andre Luis Reguim De Paulo
Caio De Freitas Almeida
Eli Teixeira Paula Junior
Eucyelle Kathe De Souza Pinto
Felipe Ukan Pereira
Gustavo Henrique Soares Dos Santos
Hudo Cim Assenco
Iuri Michelan Barcat
Iury Oliveira Mezari
Jociane Franzoni De Lima
Jose Guilherme Augustinho
Juliano Eloi
Leandro Alves Dos Santos
Lucas Edson Lopes Vieira
Lucas Eduardo Jastale Pinto
Lucas Penha De Moura
Lucas Zembrani Folle
Luisa Bonin De Oliveira
Luiz Gabriel Da Silva Conforto
Mayara Fernanda Gimenes De Souza
Renan Fernandes Teles
Rodrigo Longhi Guimaraes
Rodrigo Teixeira De Andrade
Stefany Aoto Rojas Ruiz
Vanessa Braganca Wrezinski
Vinicius Silva Mazzola
Vitor Hiroaki Yoshioka
Especificações Individuais
ALUNO: Andre Lucas Zanellato
máq_estados: [fetch, decode/execute, write-back]
Guia Máquina de Estados:
Fetch: busca da instrução na memória
Decode: decodificação da instrução pela Unidade de Controle e leitura dos
registradores
Execute: realização das contas pela ULA e leitura da RAM
Write-back: escrita do resultado no registrador e escrita na RAM
RAM (se houver): é onde deve ser feita a leitura ou escrita da RAM
NOTA: tanto o momento do incremento do PC quanto dos jumps e branches ficam à
escolha da equipe
operações_ULA: [min, add, sub]
min: Obtém o mínimo de dois valores
add: Soma dois valores
sub: Subtrai o 2o valor do 1o
largura_da_ULA_e_registradores: 6 bits
acumulador_ou_RISC: acumulador
acumulador: O acumulador é um registrador especial; ele sempre é uma das fontes
e sempre é o destino, para operações da ULA
instruções_RAM: ortogonal+delta
ortogonal+delta: Pode usar qualquer registrador existente para o endereço,
somado a uma constante
carga_constantes: instrução li, R0 = genérico
instrução li, R0 = genérico: Proibido usar um registrador fixo em zero; use uma
instrução especial li para carregar constantes
número_de_registradores: 12
branches_obrigatórios: blt
achievement_obrigatório: subrotinas e pilha
A validação pode ser apresentada sem isso funcionando, mas terá desconto
programa_demonstração: jogo da velha ou torres de hanoi
A validação só será aceita se o programa demonstração estiver funcionando; se
estiver muito difícil, converse com o professor
Alternativas Opcionais:
instruções podendo ocupar 1 ou 2 endereços desalinhados, pipeline 4 estágios, uso
de floats, "superescalar" multiciclo com duas ops ULA por clock sem dependência
de registradores, instruções vetoriais, interrrupções externas
Qualquer uma destas alternativas pode ser incluída no projeto; vale algum extra e
a liberdade de escolher qualquer achievement e qualquer programa demonstração
ALUNO: Andre Luis Reguim De Paulo
máq_estados: [fetch, decode/execute, write-back]
Guia Máquina de Estados:
Fetch: busca da instrução na memória
Decode: decodificação da instrução pela Unidade de Controle e leitura dos
registradores
Execute: realização das contas pela ULA e leitura da RAM
Write-back: escrita do resultado no registrador e escrita na RAM
RAM (se houver): é onde deve ser feita a leitura ou escrita da RAM
NOTA: tanto o momento do incremento do PC quanto dos jumps e branches ficam à
escolha da equipe
operações_ULA: [min, add, neg]
min: Obtém o mínimo de dois valores
add: Soma dois valores
neg: Negação: inverte o sinal do valor, em complemento de 2
largura_da_ULA_e_registradores: 7 bits
acumulador_ou_RISC: acumulador
acumulador: O acumulador é um registrador especial; ele sempre é uma das fontes
e sempre é o destino, para operações da ULA
instruções_RAM: ortogonal+delta
ortogonal+delta: Pode usar qualquer registrador existente para o endereço,
somado a uma constante
carga_constantes: instrução li, R0 = genérico
instrução li, R0 = genérico: Proibido usar um registrador fixo em zero; use uma
instrução especial li para carregar constantes
número_de_registradores: 16
branches_obrigatórios: salta se o sinal de R1 for negativo
achievement_obrigatório: leitura da ROM com delta (lw $r1,12($r2), p.ex.)
A validação pode ser apresentada sem isso funcionando, mas terá desconto
programa_demonstração: ordenação, seja bubble sort, inserção ou qualquer outro
A validação só será aceita se o programa demonstração estiver funcionando; se
estiver muito difícil, converse com o professor
Alternativas Opcionais:
instruções podendo ocupar 1 ou 2 endereços desalinhados, pipeline 4 estágios, uso
de floats, "superescalar" multiciclo com duas ops ULA por clock sem dependência
de registradores, instruções vetoriais, interrrupções externas
Qualquer uma destas alternativas pode ser incluída no projeto; vale algum extra e
a liberdade de escolher qualquer achievement e qualquer programa demonstração
ALUNO: Caio De Freitas Almeida
máq_estados: [fetch, decode, execute, RAM, write-back]
Guia Máquina de Estados:
Fetch: busca da instrução na memória
Decode: decodificação da instrução pela Unidade de Controle e leitura dos
registradores
Execute: realização das contas pela ULA e leitura da RAM
Write-back: escrita do resultado no registrador e escrita na RAM
RAM (se houver): é onde deve ser feita a leitura ou escrita da RAM
NOTA: tanto o momento do incremento do PC quanto dos jumps e branches ficam à
escolha da equipe
operações_ULA: [equ, add, sub]
equ: Resulta em 1 se o 1o valor é igual ao 2o, resulta 0 caso contrário
add: Soma dois valores
sub: Subtrai o 2o valor do 1o
largura_da_ULA_e_registradores: 16 bits
acumulador_ou_RISC: acumulador
acumulador: O acumulador é um registrador especial; ele sempre é uma das fontes
e sempre é o destino, para operações da ULA
instruções_RAM: sempre com R1
sempre com R1: Usa o registrador 1 para indicar o endereço da operação
carga_constantes: instrução li, R0 = genérico
instrução li, R0 = genérico: Proibido usar um registrador fixo em zero; use uma
instrução especial li para carregar constantes
número_de_registradores: 4
branches_obrigatórios: salta se R1=0 e R2=0
achievement_obrigatório: leitura da ROM com delta (lw $r1,12($r2), p.ex.)
A validação pode ser apresentada sem isso funcionando, mas terá desconto
programa_demonstração: ordenação, seja bubble sort, inserção ou qualquer outro
A validação só será aceita se o programa demonstração estiver funcionando; se
estiver muito difícil, converse com o professor
Alternativas Opcionais:
instruções podendo ocupar 1 ou 2 endereços desalinhados, pipeline 4 estágios, uso
de floats, "superescalar" multiciclo com duas ops ULA por clock sem dependência
de registradores, instruções vetoriais, interrrupções externas
Qualquer uma destas alternativas pode ser incluída no projeto; vale algum extra e
a liberdade de escolher qualquer achievement e qualquer programa demonstração
ALUNO: Eli Teixeira Paula Junior
máq_estados: [fetch/decode, execute, write-back]
Guia Máquina de Estados:
Fetch: busca da instrução na memória
Decode: decodificação da instrução pela Unidade de Controle e leitura dos
registradores
Execute: realização das contas pela ULA e leitura da RAM
Write-back: escrita do resultado no registrador e escrita na RAM
RAM (se houver): é onde deve ser feita a leitura ou escrita da RAM
NOTA: tanto o momento do incremento do PC quanto dos jumps e branches ficam à
escolha da equipe
operações_ULA: [inc, add, sub]
inc: Soma um ao valor
add: Soma dois valores
sub: Subtrai o 2o valor do 1o
largura_da_ULA_e_registradores: 16 bits
acumulador_ou_RISC: acumulador
acumulador: O acumulador é um registrador especial; ele sempre é uma das fontes
e sempre é o destino, para operações da ULA
instruções_RAM: ortogonal+delta
ortogonal+delta: Pode usar qualquer registrador existente para o endereço,
somado a uma constante
carga_constantes: sem li, R0 = constante zero
sem li, R0 = constante zero: O registrador zero é fixo na constante zero; use addi
com $zero, não pode haver instrução li direto
número_de_registradores: 16
branches_obrigatórios: salta se R1!=0 e R2!=0
achievement_obrigatório: geração de número pseudoaleatório (contador independente mais hash)
A validação pode ser apresentada sem isso funcionando, mas terá desconto
programa_demonstração: criptografia simples (p.ex., vigenere)
A validação só será aceita se o programa demonstração estiver funcionando; se
estiver muito difícil, converse com o professor
Alternativas Opcionais:
instruções podendo ocupar 1 ou 2 endereços desalinhados, pipeline 4 estágios, uso
de floats, "superescalar" multiciclo com duas ops ULA por clock sem dependência
de registradores, instruções vetoriais, interrrupções externas
Qualquer uma destas alternativas pode ser incluída no projeto; vale algum extra e
a liberdade de escolher qualquer achievement e qualquer programa demonstração
ALUNO: Eucyelle Kathe De Souza Pinto
máq_estados: [fetch, decode/execute, write-back]
Guia Máquina de Estados:
Fetch: busca da instrução na memória
Decode: decodificação da instrução pela Unidade de Controle e leitura dos
registradores
Execute: realização das contas pela ULA e leitura da RAM
Write-back: escrita do resultado no registrador e escrita na RAM
RAM (se houver): é onde deve ser feita a leitura ou escrita da RAM
NOTA: tanto o momento do incremento do PC quanto dos jumps e branches ficam à
escolha da equipe
operações_ULA: [par, add, neg]
par: Paridade par, resulta 1 se o valor tiver número ímpar de bits setados, 0 caso
contrário
add: Soma dois valores
neg: Negação: inverte o sinal do valor, em complemento de 2
largura_da_ULA_e_registradores: 5 bits
acumulador_ou_RISC: acumulador
acumulador: O acumulador é um registrador especial; ele sempre é uma das fontes
e sempre é o destino, para operações da ULA
instruções_RAM: ortogonal+delta
ortogonal+delta: Pode usar qualquer registrador existente para o endereço,
somado a uma constante
carga_constantes: instrução li, R0 = genérico
instrução li, R0 = genérico: Proibido usar um registrador fixo em zero; use uma
instrução especial li para carregar constantes
número_de_registradores: 4
branches_obrigatórios: bge
achievement_obrigatório: instruções em dois endereços: um para o opcode e outro para o operando
A validação pode ser apresentada sem isso funcionando, mas terá desconto
programa_demonstração: protocolo serial: gerar sinal RS232 8 bits, paridade par, 2 stop bits,
enviar o seu nome
A validação só será aceita se o programa demonstração estiver funcionando; se
estiver muito difícil, converse com o professor
Alternativas Opcionais:
instruções podendo ocupar 1 ou 2 endereços desalinhados, pipeline 4 estágios, uso
de floats, "superescalar" multiciclo com duas ops ULA por clock sem dependência
de registradores, instruções vetoriais, interrrupções externas
Qualquer uma destas alternativas pode ser incluída no projeto; vale algum extra e
a liberdade de escolher qualquer achievement e qualquer programa demonstração
ALUNO: Felipe Ukan Pereira
máq_estados: [fetch, decode, execute, write-back]
Guia Máquina de Estados:
Fetch: busca da instrução na memória
Decode: decodificação da instrução pela Unidade de Controle e leitura dos
registradores
Execute: realização das contas pela ULA e leitura da RAM
Write-back: escrita do resultado no registrador e escrita na RAM
RAM (se houver): é onde deve ser feita a leitura ou escrita da RAM
NOTA: tanto o momento do incremento do PC quanto dos jumps e branches ficam à
escolha da equipe
operações_ULA: [min, add, neg]
min: Obtém o mínimo de dois valores
add: Soma dois valores
neg: Negação: inverte o sinal do valor, em complemento de 2
largura_da_ULA_e_registradores: 16 bits
acumulador_ou_RISC: ortogonal
ortogonal: As operações da ULA podem ter quaisquer dos registradores existentes,
tanto como fonte como quanto destino
instruções_RAM: ortogonal+delta
ortogonal+delta: Pode usar qualquer registrador existente para o endereço,
somado a uma constante
carga_constantes: sem li, R0 = constante zero
sem li, R0 = constante zero: O registrador zero é fixo na constante zero; use addi
com $zero, não pode haver instrução li direto
número_de_registradores: 8
branches_obrigatórios: bgt
achievement_obrigatório: geração de número pseudoaleatório (contador independente mais hash)
A validação pode ser apresentada sem isso funcionando, mas terá desconto
programa_demonstração: jogo da velha ou torres de hanoi
A validação só será aceita se o programa demonstração estiver funcionando; se
estiver muito difícil, converse com o professor
Alternativas Opcionais:
instruções podendo ocupar 1 ou 2 endereços desalinhados, pipeline 4 estágios, uso
de floats, "superescalar" multiciclo com duas ops ULA por clock sem dependência
de registradores, instruções vetoriais, interrrupções externas
Qualquer uma destas alternativas pode ser incluída no projeto; vale algum extra e
a liberdade de escolher qualquer achievement e qualquer programa demonstração
ALUNO: Gustavo Henrique Soares Dos Santos
máq_estados: [fetch, decode, execute, RAM, write-back]
Guia Máquina de Estados:
Fetch: busca da instrução na memória
Decode: decodificação da instrução pela Unidade de Controle e leitura dos
registradores
Execute: realização das contas pela ULA e leitura da RAM
Write-back: escrita do resultado no registrador e escrita na RAM
RAM (se houver): é onde deve ser feita a leitura ou escrita da RAM
NOTA: tanto o momento do incremento do PC quanto dos jumps e branches ficam à
escolha da equipe
operações_ULA: [max, add, neg]
max: Obtém o máximo de dois valores
add: Soma dois valores
neg: Negação: inverte o sinal do valor, em complemento de 2
largura_da_ULA_e_registradores: 7 bits
acumulador_ou_RISC: acumulador
acumulador: O acumulador é um registrador especial; ele sempre é uma das fontes
e sempre é o destino, para operações da ULA
instruções_RAM: ortogonal+delta
ortogonal+delta: Pode usar qualquer registrador existente para o endereço,
somado a uma constante
carga_constantes: instrução li, R0 = genérico
instrução li, R0 = genérico: Proibido usar um registrador fixo em zero; use uma
instrução especial li para carregar constantes
número_de_registradores: 6
branches_obrigatórios: bgt
achievement_obrigatório: rep movsb: copia bloco de memória (exige máquina de estados
diferente!)
A validação pode ser apresentada sem isso funcionando, mas terá desconto
programa_demonstração: números primos (sugestão: crivo de erastótenes)
A validação só será aceita se o programa demonstração estiver funcionando; se
estiver muito difícil, converse com o professor
Alternativas Opcionais:
instruções podendo ocupar 1 ou 2 endereços desalinhados, pipeline 4 estágios, uso
de floats, "superescalar" multiciclo com duas ops ULA por clock sem dependência
de registradores, instruções vetoriais, interrrupções externas
Qualquer uma destas alternativas pode ser incluída no projeto; vale algum extra e
a liberdade de escolher qualquer achievement e qualquer programa demonstração
ALUNO: Hudo Cim Assenco
máq_estados: [fetch, decode, execute, RAM, write-back]
Guia Máquina de Estados:
Fetch: busca da instrução na memória
Decode: decodificação da instrução pela Unidade de Controle e leitura dos
registradores
Execute: realização das contas pela ULA e leitura da RAM
Write-back: escrita do resultado no registrador e escrita na RAM
RAM (se houver): é onde deve ser feita a leitura ou escrita da RAM
NOTA: tanto o momento do incremento do PC quanto dos jumps e branches ficam à
escolha da equipe
operações_ULA: [min, add, neg]
min: Obtém o mínimo de dois valores
add: Soma dois valores
neg: Negação: inverte o sinal do valor, em complemento de 2
largura_da_ULA_e_registradores: 5 bits
acumulador_ou_RISC: ortogonal
ortogonal: As operações da ULA podem ter quaisquer dos registradores existentes,
tanto como fonte como quanto destino
instruções_RAM: acumulador+delta
acumulador+delta: Usa sempre o acumulador somado a uma constante para
indicar o endereço da operação
carga_constantes: instrução li, R0 = genérico
instrução li, R0 = genérico: Proibido usar um registrador fixo em zero; use uma
instrução especial li para carregar constantes
número_de_registradores: 4
branches_obrigatórios: bge
achievement_obrigatório: leitura da ROM com delta (lw $r1,12($r2), p.ex.)
A validação pode ser apresentada sem isso funcionando, mas terá desconto
programa_demonstração: filtro digital com dados em RAM
A validação só será aceita se o programa demonstração estiver funcionando; se
estiver muito difícil, converse com o professor
Alternativas Opcionais:
instruções podendo ocupar 1 ou 2 endereços desalinhados, pipeline 4 estágios, uso
de floats, "superescalar" multiciclo com duas ops ULA por clock sem dependência
de registradores, instruções vetoriais, interrrupções externas
Qualquer uma destas alternativas pode ser incluída no projeto; vale algum extra e
a liberdade de escolher qualquer achievement e qualquer programa demonstração
ALUNO: Iuri Michelan Barcat
máq_estados: [fetch, decode, execute, RAM, write-back]
Guia Máquina de Estados:
Fetch: busca da instrução na memória
Decode: decodificação da instrução pela Unidade de Controle e leitura dos
registradores
Execute: realização das contas pela ULA e leitura da RAM
Write-back: escrita do resultado no registrador e escrita na RAM
RAM (se houver): é onde deve ser feita a leitura ou escrita da RAM
NOTA: tanto o momento do incremento do PC quanto dos jumps e branches ficam à
escolha da equipe
operações_ULA: [slt, add, neg]
slt: Resulta em 1 se o 1o valor é menor do que o 2o, resulta 0 caso contrário
add: Soma dois valores
neg: Negação: inverte o sinal do valor, em complemento de 2
largura_da_ULA_e_registradores: 5 bits
acumulador_ou_RISC: acumulador
acumulador: O acumulador é um registrador especial; ele sempre é uma das fontes
e sempre é o destino, para operações da ULA
instruções_RAM: sempre com R1
sempre com R1: Usa o registrador 1 para indicar o endereço da operação
carga_constantes: sem li, R0 = constante zero
sem li, R0 = constante zero: O registrador zero é fixo na constante zero; use addi
com $zero, não pode haver instrução li direto
número_de_registradores: 16
branches_obrigatórios: salta se o sinal de R1 for negativo
achievement_obrigatório: instrução MAC (x=x+c*y)
A validação pode ser apresentada sem isso funcionando, mas terá desconto
programa_demonstração: criptografia simples (p.ex., vigenere)
A validação só será aceita se o programa demonstração estiver funcionando; se
estiver muito difícil, converse com o professor
Alternativas Opcionais:
instruções podendo ocupar 1 ou 2 endereços desalinhados, pipeline 4 estágios, uso
de floats, "superescalar" multiciclo com duas ops ULA por clock sem dependência
de registradores, instruções vetoriais, interrrupções externas
Qualquer uma destas alternativas pode ser incluída no projeto; vale algum extra e
a liberdade de escolher qualquer achievement e qualquer programa demonstração
ALUNO: Iury Oliveira Mezari
máq_estados: [fetch, decode, execute, write-back]
Guia Máquina de Estados:
Fetch: busca da instrução na memória
Decode: decodificação da instrução pela Unidade de Controle e leitura dos
registradores
Execute: realização das contas pela ULA e leitura da RAM
Write-back: escrita do resultado no registrador e escrita na RAM
RAM (se houver): é onde deve ser feita a leitura ou escrita da RAM
NOTA: tanto o momento do incremento do PC quanto dos jumps e branches ficam à
escolha da equipe
operações_ULA: [par, add, neg]
par: Paridade par, resulta 1 se o valor tiver número ímpar de bits setados, 0 caso
contrário
add: Soma dois valores
neg: Negação: inverte o sinal do valor, em complemento de 2
largura_da_ULA_e_registradores: 7 bits
acumulador_ou_RISC: ortogonal
ortogonal: As operações da ULA podem ter quaisquer dos registradores existentes,
tanto como fonte como quanto destino
instruções_RAM: sempre com R1
sempre com R1: Usa o registrador 1 para indicar o endereço da operação
carga_constantes: instrução li, R0 = genérico
instrução li, R0 = genérico: Proibido usar um registrador fixo em zero; use uma
instrução especial li para carregar constantes
número_de_registradores: 16
branches_obrigatórios: salta se o sinal de R1 for negativo
achievement_obrigatório: raiz quadrada (usando tabela em ROM ou decodificador)
A validação pode ser apresentada sem isso funcionando, mas terá desconto
programa_demonstração: algoritmo de djikstra
A validação só será aceita se o programa demonstração estiver funcionando; se
estiver muito difícil, converse com o professor
Alternativas Opcionais:
instruções podendo ocupar 1 ou 2 endereços desalinhados, pipeline 4 estágios, uso
de floats, "superescalar" multiciclo com duas ops ULA por clock sem dependência
de registradores, instruções vetoriais, interrrupções externas
Qualquer uma destas alternativas pode ser incluída no projeto; vale algum extra e
a liberdade de escolher qualquer achievement e qualquer programa demonstração
ALUNO: Jociane Franzoni De Lima
máq_estados: [fetch, decode/execute, write-back]
Guia Máquina de Estados:
Fetch: busca da instrução na memória
Decode: decodificação da instrução pela Unidade de Controle e leitura dos
registradores
Execute: realização das contas pela ULA e leitura da RAM
Write-back: escrita do resultado no registrador e escrita na RAM
RAM (se houver): é onde deve ser feita a leitura ou escrita da RAM
NOTA: tanto o momento do incremento do PC quanto dos jumps e branches ficam à
escolha da equipe
operações_ULA: [inc, add, neg]
inc: Soma um ao valor
add: Soma dois valores
neg: Negação: inverte o sinal do valor, em complemento de 2
largura_da_ULA_e_registradores: 4 bits
acumulador_ou_RISC: ortogonal
ortogonal: As operações da ULA podem ter quaisquer dos registradores existentes,
tanto como fonte como quanto destino
instruções_RAM: acumulador+delta
acumulador+delta: Usa sempre o acumulador somado a uma constante para
indicar o endereço da operação
carga_constantes: sem li, R0 = constante zero
sem li, R0 = constante zero: O registrador zero é fixo na constante zero; use addi
com $zero, não pode haver instrução li direto
número_de_registradores: 16
branches_obrigatórios: bge
achievement_obrigatório: geração de número pseudoaleatório (contador independente mais hash)
A validação pode ser apresentada sem isso funcionando, mas terá desconto
programa_demonstração: jogo da velha ou torres de hanoi
A validação só será aceita se o programa demonstração estiver funcionando; se
estiver muito difícil, converse com o professor
Alternativas Opcionais:
instruções podendo ocupar 1 ou 2 endereços desalinhados, pipeline 4 estágios, uso
de floats, "superescalar" multiciclo com duas ops ULA por clock sem dependência
de registradores, instruções vetoriais, interrrupções externas
Qualquer uma destas alternativas pode ser incluída no projeto; vale algum extra e
a liberdade de escolher qualquer achievement e qualquer programa demonstração
ALUNO: Jose Guilherme Augustinho
máq_estados: [fetch, decode, execute, write-back]
Guia Máquina de Estados:
Fetch: busca da instrução na memória
Decode: decodificação da instrução pela Unidade de Controle e leitura dos
registradores
Execute: realização das contas pela ULA e leitura da RAM
Write-back: escrita do resultado no registrador e escrita na RAM
RAM (se houver): é onde deve ser feita a leitura ou escrita da RAM
NOTA: tanto o momento do incremento do PC quanto dos jumps e branches ficam à
escolha da equipe
operações_ULA: [inc, add, neg]
inc: Soma um ao valor
add: Soma dois valores
neg: Negação: inverte o sinal do valor, em complemento de 2
largura_da_ULA_e_registradores: 6 bits
acumulador_ou_RISC: acumulador
acumulador: O acumulador é um registrador especial; ele sempre é uma das fontes
e sempre é o destino, para operações da ULA
instruções_RAM: acumulador+delta
acumulador+delta: Usa sempre o acumulador somado a uma constante para
indicar o endereço da operação
carga_constantes: instrução li, R0 = genérico
instrução li, R0 = genérico: Proibido usar um registrador fixo em zero; use uma
instrução especial li para carregar constantes
número_de_registradores: 16
branches_obrigatórios: salta se R1=0 e R2=0
achievement_obrigatório: instrução MAC (x=x+c*y)
A validação pode ser apresentada sem isso funcionando, mas terá desconto
programa_demonstração: ordenação, seja bubble sort, inserção ou qualquer outro
A validação só será aceita se o programa demonstração estiver funcionando; se
estiver muito difícil, converse com o professor
Alternativas Opcionais:
instruções podendo ocupar 1 ou 2 endereços desalinhados, pipeline 4 estágios, uso
de floats, "superescalar" multiciclo com duas ops ULA por clock sem dependência
de registradores, instruções vetoriais, interrrupções externas
Qualquer uma destas alternativas pode ser incluída no projeto; vale algum extra e
a liberdade de escolher qualquer achievement e qualquer programa demonstração
ALUNO: Juliano Eloi
máq_estados: [fetch, decode/execute, write-back]
Guia Máquina de Estados:
Fetch: busca da instrução na memória
Decode: decodificação da instrução pela Unidade de Controle e leitura dos
registradores
Execute: realização das contas pela ULA e leitura da RAM
Write-back: escrita do resultado no registrador e escrita na RAM
RAM (se houver): é onde deve ser feita a leitura ou escrita da RAM
NOTA: tanto o momento do incremento do PC quanto dos jumps e branches ficam à
escolha da equipe
operações_ULA: [slt, add, neg]
slt: Resulta em 1 se o 1o valor é menor do que o 2o, resulta 0 caso contrário
add: Soma dois valores
neg: Negação: inverte o sinal do valor, em complemento de 2
largura_da_ULA_e_registradores: 4 bits
acumulador_ou_RISC: ortogonal
ortogonal: As operações da ULA podem ter quaisquer dos registradores existentes,
tanto como fonte como quanto destino
instruções_RAM: sempre com R1
sempre com R1: Usa o registrador 1 para indicar o endereço da operação
carga_constantes: sem li, R0 = constante zero
sem li, R0 = constante zero: O registrador zero é fixo na constante zero; use addi
com $zero, não pode haver instrução li direto
número_de_registradores: 4
branches_obrigatórios: salta se o sinal de R1 for negativo
achievement_obrigatório: leitura da ROM com delta (lw $r1,12($r2), p.ex.)
A validação pode ser apresentada sem isso funcionando, mas terá desconto
programa_demonstração: criptografia simples (p.ex., vigenere)
A validação só será aceita se o programa demonstração estiver funcionando; se
estiver muito difícil, converse com o professor
Alternativas Opcionais:
instruções podendo ocupar 1 ou 2 endereços desalinhados, pipeline 4 estágios, uso
de floats, "superescalar" multiciclo com duas ops ULA por clock sem dependência
de registradores, instruções vetoriais, interrrupções externas
Qualquer uma destas alternativas pode ser incluída no projeto; vale algum extra e
a liberdade de escolher qualquer achievement e qualquer programa demonstração
ALUNO: Leandro Alves Dos Santos
máq_estados: [fetch/decode, execute, write-back]
Guia Máquina de Estados:
Fetch: busca da instrução na memória
Decode: decodificação da instrução pela Unidade de Controle e leitura dos
registradores
Execute: realização das contas pela ULA e leitura da RAM
Write-back: escrita do resultado no registrador e escrita na RAM
RAM (se houver): é onde deve ser feita a leitura ou escrita da RAM
NOTA: tanto o momento do incremento do PC quanto dos jumps e branches ficam à
escolha da equipe
operações_ULA: [equ, add, sub]
equ: Resulta em 1 se o 1o valor é igual ao 2o, resulta 0 caso contrário
add: Soma dois valores
sub: Subtrai o 2o valor do 1o
largura_da_ULA_e_registradores: 5 bits
acumulador_ou_RISC: ortogonal
ortogonal: As operações da ULA podem ter quaisquer dos registradores existentes,
tanto como fonte como quanto destino
instruções_RAM: sempre com R1
sempre com R1: Usa o registrador 1 para indicar o endereço da operação
carga_constantes: sem li, R0 = constante zero
sem li, R0 = constante zero: O registrador zero é fixo na constante zero; use addi
com $zero, não pode haver instrução li direto
número_de_registradores: 8
branches_obrigatórios: bgt
achievement_obrigatório: instruções em dois endereços: um para o opcode e outro para o operando
A validação pode ser apresentada sem isso funcionando, mas terá desconto
programa_demonstração: protocolo serial: gerar sinal RS232 8 bits, paridade par, 2 stop bits,
enviar o seu nome
A validação só será aceita se o programa demonstração estiver funcionando; se
estiver muito difícil, converse com o professor
Alternativas Opcionais:
instruções podendo ocupar 1 ou 2 endereços desalinhados, pipeline 4 estágios, uso
de floats, "superescalar" multiciclo com duas ops ULA por clock sem dependência
de registradores, instruções vetoriais, interrrupções externas
Qualquer uma destas alternativas pode ser incluída no projeto; vale algum extra e
a liberdade de escolher qualquer achievement e qualquer programa demonstração
ALUNO: Lucas Edson Lopes Vieira
máq_estados: [fetch, decode/execute, write-back]
Guia Máquina de Estados:
Fetch: busca da instrução na memória
Decode: decodificação da instrução pela Unidade de Controle e leitura dos
registradores
Execute: realização das contas pela ULA e leitura da RAM
Write-back: escrita do resultado no registrador e escrita na RAM
RAM (se houver): é onde deve ser feita a leitura ou escrita da RAM
NOTA: tanto o momento do incremento do PC quanto dos jumps e branches ficam à
escolha da equipe
operações_ULA: [equ, add, sub]
equ: Resulta em 1 se o 1o valor é igual ao 2o, resulta 0 caso contrário
add: Soma dois valores
sub: Subtrai o 2o valor do 1o
largura_da_ULA_e_registradores: 8 bits
acumulador_ou_RISC: acumulador
acumulador: O acumulador é um registrador especial; ele sempre é uma das fontes
e sempre é o destino, para operações da ULA
instruções_RAM: acumulador+delta
acumulador+delta: Usa sempre o acumulador somado a uma constante para
indicar o endereço da operação
carga_constantes: instrução li, R0 = genérico
instrução li, R0 = genérico: Proibido usar um registrador fixo em zero; use uma
instrução especial li para carregar constantes
número_de_registradores: 12
branches_obrigatórios: blt
achievement_obrigatório: rep movsb: copia bloco de memória (exige máquina de estados
diferente!)
A validação pode ser apresentada sem isso funcionando, mas terá desconto
programa_demonstração: criptografia simples (p.ex., vigenere)
A validação só será aceita se o programa demonstração estiver funcionando; se
estiver muito difícil, converse com o professor
Alternativas Opcionais:
instruções podendo ocupar 1 ou 2 endereços desalinhados, pipeline 4 estágios, uso
de floats, "superescalar" multiciclo com duas ops ULA por clock sem dependência
de registradores, instruções vetoriais, interrrupções externas
Qualquer uma destas alternativas pode ser incluída no projeto; vale algum extra e
a liberdade de escolher qualquer achievement e qualquer programa demonstração
ALUNO: Lucas Eduardo Jastale Pinto
máq_estados: [fetch, decode, execute, RAM, write-back]
Guia Máquina de Estados:
Fetch: busca da instrução na memória
Decode: decodificação da instrução pela Unidade de Controle e leitura dos
registradores
Execute: realização das contas pela ULA e leitura da RAM
Write-back: escrita do resultado no registrador e escrita na RAM
RAM (se houver): é onde deve ser feita a leitura ou escrita da RAM
NOTA: tanto o momento do incremento do PC quanto dos jumps e branches ficam à
escolha da equipe
operações_ULA: [min, add, neg]
min: Obtém o mínimo de dois valores
add: Soma dois valores
neg: Negação: inverte o sinal do valor, em complemento de 2
largura_da_ULA_e_registradores: 4 bits
acumulador_ou_RISC: ortogonal
ortogonal: As operações da ULA podem ter quaisquer dos registradores existentes,
tanto como fonte como quanto destino
instruções_RAM: ortogonal+delta
ortogonal+delta: Pode usar qualquer registrador existente para o endereço,
somado a uma constante
carga_constantes: instrução li, R0 = genérico
instrução li, R0 = genérico: Proibido usar um registrador fixo em zero; use uma
instrução especial li para carregar constantes
número_de_registradores: 12
branches_obrigatórios: salta se o sinal de R1 for negativo
achievement_obrigatório: instrução MAC (x=x+c*y)
A validação pode ser apresentada sem isso funcionando, mas terá desconto
programa_demonstração: filtro digital com dados em RAM
A validação só será aceita se o programa demonstração estiver funcionando; se
estiver muito difícil, converse com o professor
Alternativas Opcionais:
instruções podendo ocupar 1 ou 2 endereços desalinhados, pipeline 4 estágios, uso
de floats, "superescalar" multiciclo com duas ops ULA por clock sem dependência
de registradores, instruções vetoriais, interrrupções externas
Qualquer uma destas alternativas pode ser incluída no projeto; vale algum extra e
a liberdade de escolher qualquer achievement e qualquer programa demonstração
ALUNO: Lucas Penha De Moura
máq_estados: [fetch/decode, execute, write-back]
Guia Máquina de Estados:
Fetch: busca da instrução na memória
Decode: decodificação da instrução pela Unidade de Controle e leitura dos
registradores
Execute: realização das contas pela ULA e leitura da RAM
Write-back: escrita do resultado no registrador e escrita na RAM
RAM (se houver): é onde deve ser feita a leitura ou escrita da RAM
NOTA: tanto o momento do incremento do PC quanto dos jumps e branches ficam à
escolha da equipe
operações_ULA: [equ, add, sub]
equ: Resulta em 1 se o 1o valor é igual ao 2o, resulta 0 caso contrário
add: Soma dois valores
sub: Subtrai o 2o valor do 1o
largura_da_ULA_e_registradores: 16 bits
acumulador_ou_RISC: acumulador
acumulador: O acumulador é um registrador especial; ele sempre é uma das fontes
e sempre é o destino, para operações da ULA
instruções_RAM: ortogonal+delta
ortogonal+delta: Pode usar qualquer registrador existente para o endereço,
somado a uma constante
carga_constantes: sem li, R0 = constante zero
sem li, R0 = constante zero: O registrador zero é fixo na constante zero; use addi
com $zero, não pode haver instrução li direto
número_de_registradores: 6
branches_obrigatórios: salta se R1=0 e R2=0
achievement_obrigatório: subrotinas e pilha
A validação pode ser apresentada sem isso funcionando, mas terá desconto
programa_demonstração: protocolo serial: gerar sinal RS232 8 bits, paridade par, 2 stop bits,
enviar o seu nome
A validação só será aceita se o programa demonstração estiver funcionando; se
estiver muito difícil, converse com o professor
Alternativas Opcionais:
instruções podendo ocupar 1 ou 2 endereços desalinhados, pipeline 4 estágios, uso
de floats, "superescalar" multiciclo com duas ops ULA por clock sem dependência
de registradores, instruções vetoriais, interrrupções externas
Qualquer uma destas alternativas pode ser incluída no projeto; vale algum extra e
a liberdade de escolher qualquer achievement e qualquer programa demonstração
ALUNO: Lucas Zembrani Folle
máq_estados: [fetch/decode, execute, write-back]
Guia Máquina de Estados:
Fetch: busca da instrução na memória
Decode: decodificação da instrução pela Unidade de Controle e leitura dos
registradores
Execute: realização das contas pela ULA e leitura da RAM
Write-back: escrita do resultado no registrador e escrita na RAM
RAM (se houver): é onde deve ser feita a leitura ou escrita da RAM
NOTA: tanto o momento do incremento do PC quanto dos jumps e branches ficam à
escolha da equipe
operações_ULA: [slt, add, neg]
slt: Resulta em 1 se o 1o valor é menor do que o 2o, resulta 0 caso contrário
add: Soma dois valores
neg: Negação: inverte o sinal do valor, em complemento de 2
largura_da_ULA_e_registradores: 7 bits
acumulador_ou_RISC: ortogonal
ortogonal: As operações da ULA podem ter quaisquer dos registradores existentes,
tanto como fonte como quanto destino
instruções_RAM: ortogonal
ortogonal: Pode usar qualquer registrador existente tanto para o endereço quanto
para o destino/dado
carga_constantes: instrução li, R0 = genérico
instrução li, R0 = genérico: Proibido usar um registrador fixo em zero; use uma
instrução especial li para carregar constantes
número_de_registradores: 6
branches_obrigatórios: ble
achievement_obrigatório: leitura da ROM com delta (lw $r1,12($r2), p.ex.)
A validação pode ser apresentada sem isso funcionando, mas terá desconto
programa_demonstração: criptografia simples (p.ex., vigenere)
A validação só será aceita se o programa demonstração estiver funcionando; se
estiver muito difícil, converse com o professor
Alternativas Opcionais:
instruções podendo ocupar 1 ou 2 endereços desalinhados, pipeline 4 estágios, uso
de floats, "superescalar" multiciclo com duas ops ULA por clock sem dependência
de registradores, instruções vetoriais, interrrupções externas
Qualquer uma destas alternativas pode ser incluída no projeto; vale algum extra e
a liberdade de escolher qualquer achievement e qualquer programa demonstração
ALUNO: Luisa Bonin De Oliveira
máq_estados: [fetch, decode, execute, write-back]
Guia Máquina de Estados:
Fetch: busca da instrução na memória
Decode: decodificação da instrução pela Unidade de Controle e leitura dos
registradores
Execute: realização das contas pela ULA e leitura da RAM
Write-back: escrita do resultado no registrador e escrita na RAM
RAM (se houver): é onde deve ser feita a leitura ou escrita da RAM
NOTA: tanto o momento do incremento do PC quanto dos jumps e branches ficam à
escolha da equipe
operações_ULA: [inc, add, neg]
inc: Soma um ao valor
add: Soma dois valores
neg: Negação: inverte o sinal do valor, em complemento de 2
largura_da_ULA_e_registradores: 4 bits
acumulador_ou_RISC: ortogonal
ortogonal: As operações da ULA podem ter quaisquer dos registradores existentes,
tanto como fonte como quanto destino
instruções_RAM: ortogonal
ortogonal: Pode usar qualquer registrador existente tanto para o endereço quanto
para o destino/dado
carga_constantes: sem li, R0 = constante zero
sem li, R0 = constante zero: O registrador zero é fixo na constante zero; use addi
com $zero, não pode haver instrução li direto
número_de_registradores: 4
branches_obrigatórios: bgt
achievement_obrigatório: instruções em dois endereços: um para o opcode e outro para o operando
A validação pode ser apresentada sem isso funcionando, mas terá desconto
programa_demonstração: jogo da velha ou torres de hanoi
A validação só será aceita se o programa demonstração estiver funcionando; se
estiver muito difícil, converse com o professor
Alternativas Opcionais:
instruções podendo ocupar 1 ou 2 endereços desalinhados, pipeline 4 estágios, uso
de floats, "superescalar" multiciclo com duas ops ULA por clock sem dependência
de registradores, instruções vetoriais, interrrupções externas
Qualquer uma destas alternativas pode ser incluída no projeto; vale algum extra e
a liberdade de escolher qualquer achievement e qualquer programa demonstração
ALUNO: Luiz Gabriel Da Silva Conforto
máq_estados: [fetch/decode, execute, write-back]
Guia Máquina de Estados:
Fetch: busca da instrução na memória
Decode: decodificação da instrução pela Unidade de Controle e leitura dos
registradores
Execute: realização das contas pela ULA e leitura da RAM
Write-back: escrita do resultado no registrador e escrita na RAM
RAM (se houver): é onde deve ser feita a leitura ou escrita da RAM
NOTA: tanto o momento do incremento do PC quanto dos jumps e branches ficam à
escolha da equipe
operações_ULA: [equ, add, neg]
equ: Resulta em 1 se o 1o valor é igual ao 2o, resulta 0 caso contrário
add: Soma dois valores
neg: Negação: inverte o sinal do valor, em complemento de 2
largura_da_ULA_e_registradores: 6 bits
acumulador_ou_RISC: acumulador
acumulador: O acumulador é um registrador especial; ele sempre é uma das fontes
e sempre é o destino, para operações da ULA
instruções_RAM: ortogonal+delta
ortogonal+delta: Pode usar qualquer registrador existente para o endereço,
somado a uma constante
carga_constantes: instrução li, R0 = genérico
instrução li, R0 = genérico: Proibido usar um registrador fixo em zero; use uma
instrução especial li para carregar constantes
número_de_registradores: 6
branches_obrigatórios: salta se R1=0 e R2=0
achievement_obrigatório: leitura da ROM com delta (lw $r1,12($r2), p.ex.)
A validação pode ser apresentada sem isso funcionando, mas terá desconto
programa_demonstração: algoritmo de djikstra
A validação só será aceita se o programa demonstração estiver funcionando; se
estiver muito difícil, converse com o professor
Alternativas Opcionais:
instruções podendo ocupar 1 ou 2 endereços desalinhados, pipeline 4 estágios, uso
de floats, "superescalar" multiciclo com duas ops ULA por clock sem dependência
de registradores, instruções vetoriais, interrrupções externas
Qualquer uma destas alternativas pode ser incluída no projeto; vale algum extra e
a liberdade de escolher qualquer achievement e qualquer programa demonstração
ALUNO: Mayara Fernanda Gimenes De Souza
máq_estados: [fetch, decode/execute, write-back]
Guia Máquina de Estados:
Fetch: busca da instrução na memória
Decode: decodificação da instrução pela Unidade de Controle e leitura dos
registradores
Execute: realização das contas pela ULA e leitura da RAM
Write-back: escrita do resultado no registrador e escrita na RAM
RAM (se houver): é onde deve ser feita a leitura ou escrita da RAM
NOTA: tanto o momento do incremento do PC quanto dos jumps e branches ficam à
escolha da equipe
operações_ULA: [dec, add, sub]
dec: Subtrai um do valor
add: Soma dois valores
sub: Subtrai o 2o valor do 1o
largura_da_ULA_e_registradores: 5 bits
acumulador_ou_RISC: acumulador
acumulador: O acumulador é um registrador especial; ele sempre é uma das fontes
e sempre é o destino, para operações da ULA
instruções_RAM: ortogonal+delta
ortogonal+delta: Pode usar qualquer registrador existente para o endereço,
somado a uma constante
carga_constantes: sem li, R0 = constante zero
sem li, R0 = constante zero: O registrador zero é fixo na constante zero; use addi
com $zero, não pode haver instrução li direto
número_de_registradores: 8
branches_obrigatórios: salta se R1=0 e R2=0
achievement_obrigatório: instrução MAC (x=x+c*y)
A validação pode ser apresentada sem isso funcionando, mas terá desconto
programa_demonstração: algoritmo de djikstra
A validação só será aceita se o programa demonstração estiver funcionando; se
estiver muito difícil, converse com o professor
Alternativas Opcionais:
instruções podendo ocupar 1 ou 2 endereços desalinhados, pipeline 4 estágios, uso
de floats, "superescalar" multiciclo com duas ops ULA por clock sem dependência
de registradores, instruções vetoriais, interrrupções externas
Qualquer uma destas alternativas pode ser incluída no projeto; vale algum extra e
a liberdade de escolher qualquer achievement e qualquer programa demonstração
ALUNO: Renan Fernandes Teles
máq_estados: [fetch, decode, execute, RAM, write-back]
Guia Máquina de Estados:
Fetch: busca da instrução na memória
Decode: decodificação da instrução pela Unidade de Controle e leitura dos
registradores
Execute: realização das contas pela ULA e leitura da RAM
Write-back: escrita do resultado no registrador e escrita na RAM
RAM (se houver): é onde deve ser feita a leitura ou escrita da RAM
NOTA: tanto o momento do incremento do PC quanto dos jumps e branches ficam à
escolha da equipe
operações_ULA: [sgt, add, sub]
sgt: Resulta em 1 se o 1o valor é maior do que o 2o, resulta 0 caso contrário
add: Soma dois valores
sub: Subtrai o 2o valor do 1o
largura_da_ULA_e_registradores: 7 bits
acumulador_ou_RISC: acumulador
acumulador: O acumulador é um registrador especial; ele sempre é uma das fontes
e sempre é o destino, para operações da ULA
instruções_RAM: ortogonal+delta
ortogonal+delta: Pode usar qualquer registrador existente para o endereço,
somado a uma constante
carga_constantes: instrução li, R0 = genérico
instrução li, R0 = genérico: Proibido usar um registrador fixo em zero; use uma
instrução especial li para carregar constantes
número_de_registradores: 16
branches_obrigatórios: bge
achievement_obrigatório: leitura da ROM com delta (lw $r1,12($r2), p.ex.)
A validação pode ser apresentada sem isso funcionando, mas terá desconto
programa_demonstração: filtro digital com dados em RAM
A validação só será aceita se o programa demonstração estiver funcionando; se
estiver muito difícil, converse com o professor
Alternativas Opcionais:
instruções podendo ocupar 1 ou 2 endereços desalinhados, pipeline 4 estágios, uso
de floats, "superescalar" multiciclo com duas ops ULA por clock sem dependência
de registradores, instruções vetoriais, interrrupções externas
Qualquer uma destas alternativas pode ser incluída no projeto; vale algum extra e
a liberdade de escolher qualquer achievement e qualquer programa demonstração
ALUNO: Rodrigo Longhi Guimaraes
máq_estados: [fetch, decode, execute, RAM, write-back]
Guia Máquina de Estados:
Fetch: busca da instrução na memória
Decode: decodificação da instrução pela Unidade de Controle e leitura dos
registradores
Execute: realização das contas pela ULA e leitura da RAM
Write-back: escrita do resultado no registrador e escrita na RAM
RAM (se houver): é onde deve ser feita a leitura ou escrita da RAM
NOTA: tanto o momento do incremento do PC quanto dos jumps e branches ficam à
escolha da equipe
operações_ULA: [equ, add, neg]
equ: Resulta em 1 se o 1o valor é igual ao 2o, resulta 0 caso contrário
add: Soma dois valores
neg: Negação: inverte o sinal do valor, em complemento de 2
largura_da_ULA_e_registradores: 4 bits
acumulador_ou_RISC: acumulador
acumulador: O acumulador é um registrador especial; ele sempre é uma das fontes
e sempre é o destino, para operações da ULA
instruções_RAM: ortogonal
ortogonal: Pode usar qualquer registrador existente tanto para o endereço quanto
para o destino/dado
carga_constantes: instrução li, R0 = genérico
instrução li, R0 = genérico: Proibido usar um registrador fixo em zero; use uma
instrução especial li para carregar constantes
número_de_registradores: 16
branches_obrigatórios: salta se o sinal de R1 for negativo
achievement_obrigatório: raiz quadrada (usando tabela em ROM ou decodificador)
A validação pode ser apresentada sem isso funcionando, mas terá desconto
programa_demonstração: filtro digital com dados em RAM
A validação só será aceita se o programa demonstração estiver funcionando; se
estiver muito difícil, converse com o professor
Alternativas Opcionais:
instruções podendo ocupar 1 ou 2 endereços desalinhados, pipeline 4 estágios, uso
de floats, "superescalar" multiciclo com duas ops ULA por clock sem dependência
de registradores, instruções vetoriais, interrrupções externas
Qualquer uma destas alternativas pode ser incluída no projeto; vale algum extra e
a liberdade de escolher qualquer achievement e qualquer programa demonstração
ALUNO: Rodrigo Teixeira De Andrade
máq_estados: [fetch, decode, execute, RAM, write-back]
Guia Máquina de Estados:
Fetch: busca da instrução na memória
Decode: decodificação da instrução pela Unidade de Controle e leitura dos
registradores
Execute: realização das contas pela ULA e leitura da RAM
Write-back: escrita do resultado no registrador e escrita na RAM
RAM (se houver): é onde deve ser feita a leitura ou escrita da RAM
NOTA: tanto o momento do incremento do PC quanto dos jumps e branches ficam à
escolha da equipe
operações_ULA: [sgt, add, sub]
sgt: Resulta em 1 se o 1o valor é maior do que o 2o, resulta 0 caso contrário
add: Soma dois valores
sub: Subtrai o 2o valor do 1o
largura_da_ULA_e_registradores: 6 bits
acumulador_ou_RISC: acumulador
acumulador: O acumulador é um registrador especial; ele sempre é uma das fontes
e sempre é o destino, para operações da ULA
instruções_RAM: ortogonal+delta
ortogonal+delta: Pode usar qualquer registrador existente para o endereço,
somado a uma constante
carga_constantes: instrução li, R0 = genérico
instrução li, R0 = genérico: Proibido usar um registrador fixo em zero; use uma
instrução especial li para carregar constantes
número_de_registradores: 16
branches_obrigatórios: bge
achievement_obrigatório: instrução MAC (x=x+c*y)
A validação pode ser apresentada sem isso funcionando, mas terá desconto
programa_demonstração: números primos (sugestão: crivo de erastótenes)
A validação só será aceita se o programa demonstração estiver funcionando; se
estiver muito difícil, converse com o professor
Alternativas Opcionais:
instruções podendo ocupar 1 ou 2 endereços desalinhados, pipeline 4 estágios, uso
de floats, "superescalar" multiciclo com duas ops ULA por clock sem dependência
de registradores, instruções vetoriais, interrrupções externas
Qualquer uma destas alternativas pode ser incluída no projeto; vale algum extra e
a liberdade de escolher qualquer achievement e qualquer programa demonstração
ALUNO: Stefany Aoto Rojas Ruiz
máq_estados: [fetch/decode, execute, write-back]
Guia Máquina de Estados:
Fetch: busca da instrução na memória
Decode: decodificação da instrução pela Unidade de Controle e leitura dos
registradores
Execute: realização das contas pela ULA e leitura da RAM
Write-back: escrita do resultado no registrador e escrita na RAM
RAM (se houver): é onde deve ser feita a leitura ou escrita da RAM
NOTA: tanto o momento do incremento do PC quanto dos jumps e branches ficam à
escolha da equipe
operações_ULA: [min, add, sub]
min: Obtém o mínimo de dois valores
add: Soma dois valores
sub: Subtrai o 2o valor do 1o
largura_da_ULA_e_registradores: 5 bits
acumulador_ou_RISC: acumulador
acumulador: O acumulador é um registrador especial; ele sempre é uma das fontes
e sempre é o destino, para operações da ULA
instruções_RAM: ortogonal
ortogonal: Pode usar qualquer registrador existente tanto para o endereço quanto
para o destino/dado
carga_constantes: sem li, R0 = constante zero
sem li, R0 = constante zero: O registrador zero é fixo na constante zero; use addi
com $zero, não pode haver instrução li direto
número_de_registradores: 8
branches_obrigatórios: salta se o sinal de R1 for negativo
achievement_obrigatório: rep movsb: copia bloco de memória (exige máquina de estados
diferente!)
A validação pode ser apresentada sem isso funcionando, mas terá desconto
programa_demonstração: algoritmo de djikstra
A validação só será aceita se o programa demonstração estiver funcionando; se
estiver muito difícil, converse com o professor
Alternativas Opcionais:
instruções podendo ocupar 1 ou 2 endereços desalinhados, pipeline 4 estágios, uso
de floats, "superescalar" multiciclo com duas ops ULA por clock sem dependência
de registradores, instruções vetoriais, interrrupções externas
Qualquer uma destas alternativas pode ser incluída no projeto; vale algum extra e
a liberdade de escolher qualquer achievement e qualquer programa demonstração
ALUNO: Vanessa Braganca Wrezinski
máq_estados: [fetch, decode, execute, write-back]
Guia Máquina de Estados:
Fetch: busca da instrução na memória
Decode: decodificação da instrução pela Unidade de Controle e leitura dos
registradores
Execute: realização das contas pela ULA e leitura da RAM
Write-back: escrita do resultado no registrador e escrita na RAM
RAM (se houver): é onde deve ser feita a leitura ou escrita da RAM
NOTA: tanto o momento do incremento do PC quanto dos jumps e branches ficam à
escolha da equipe
operações_ULA: [par, add, neg]
par: Paridade par, resulta 1 se o valor tiver número ímpar de bits setados, 0 caso
contrário
add: Soma dois valores
neg: Negação: inverte o sinal do valor, em complemento de 2
largura_da_ULA_e_registradores: 6 bits
acumulador_ou_RISC: ortogonal
ortogonal: As operações da ULA podem ter quaisquer dos registradores existentes,
tanto como fonte como quanto destino
instruções_RAM: sempre com R1
sempre com R1: Usa o registrador 1 para indicar o endereço da operação
carga_constantes: instrução li, R0 = genérico
instrução li, R0 = genérico: Proibido usar um registrador fixo em zero; use uma
instrução especial li para carregar constantes
número_de_registradores: 6
branches_obrigatórios: salta se o sinal de R1 for negativo
achievement_obrigatório: geração de número pseudoaleatório (contador independente mais hash)
A validação pode ser apresentada sem isso funcionando, mas terá desconto
programa_demonstração: protocolo serial: gerar sinal RS232 8 bits, paridade par, 2 stop bits,
enviar o seu nome
A validação só será aceita se o programa demonstração estiver funcionando; se
estiver muito difícil, converse com o professor
Alternativas Opcionais:
instruções podendo ocupar 1 ou 2 endereços desalinhados, pipeline 4 estágios, uso
de floats, "superescalar" multiciclo com duas ops ULA por clock sem dependência
de registradores, instruções vetoriais, interrrupções externas
Qualquer uma destas alternativas pode ser incluída no projeto; vale algum extra e
a liberdade de escolher qualquer achievement e qualquer programa demonstração
ALUNO: Vinicius Silva Mazzola
máq_estados: [fetch/decode, execute, write-back]
Guia Máquina de Estados:
Fetch: busca da instrução na memória
Decode: decodificação da instrução pela Unidade de Controle e leitura dos
registradores
Execute: realização das contas pela ULA e leitura da RAM
Write-back: escrita do resultado no registrador e escrita na RAM
RAM (se houver): é onde deve ser feita a leitura ou escrita da RAM
NOTA: tanto o momento do incremento do PC quanto dos jumps e branches ficam à
escolha da equipe
operações_ULA: [par, add, sub]
par: Paridade par, resulta 1 se o valor tiver número ímpar de bits setados, 0 caso
contrário
add: Soma dois valores
sub: Subtrai o 2o valor do 1o
largura_da_ULA_e_registradores: 4 bits
acumulador_ou_RISC: ortogonal
ortogonal: As operações da ULA podem ter quaisquer dos registradores existentes,
tanto como fonte como quanto destino
instruções_RAM: sempre com R1
sempre com R1: Usa o registrador 1 para indicar o endereço da operação
carga_constantes: instrução li, R0 = genérico
instrução li, R0 = genérico: Proibido usar um registrador fixo em zero; use uma
instrução especial li para carregar constantes
número_de_registradores: 6
branches_obrigatórios: salta se o sinal de R1 for negativo
achievement_obrigatório: raiz quadrada (usando tabela em ROM ou decodificador)
A validação pode ser apresentada sem isso funcionando, mas terá desconto
programa_demonstração: filtro digital com dados em RAM
A validação só será aceita se o programa demonstração estiver funcionando; se
estiver muito difícil, converse com o professor
Alternativas Opcionais:
instruções podendo ocupar 1 ou 2 endereços desalinhados, pipeline 4 estágios, uso
de floats, "superescalar" multiciclo com duas ops ULA por clock sem dependência
de registradores, instruções vetoriais, interrrupções externas
Qualquer uma destas alternativas pode ser incluída no projeto; vale algum extra e
a liberdade de escolher qualquer achievement e qualquer programa demonstração
ALUNO: Vitor Hiroaki Yoshioka
máq_estados: [fetch/decode, execute, write-back]
Guia Máquina de Estados:
Fetch: busca da instrução na memória
Decode: decodificação da instrução pela Unidade de Controle e leitura dos
registradores
Execute: realização das contas pela ULA e leitura da RAM
Write-back: escrita do resultado no registrador e escrita na RAM
RAM (se houver): é onde deve ser feita a leitura ou escrita da RAM
NOTA: tanto o momento do incremento do PC quanto dos jumps e branches ficam à
escolha da equipe
operações_ULA: [inc, add, sub]
inc: Soma um ao valor
add: Soma dois valores
sub: Subtrai o 2o valor do 1o
largura_da_ULA_e_registradores: 4 bits
acumulador_ou_RISC: acumulador
acumulador: O acumulador é um registrador especial; ele sempre é uma das fontes
e sempre é o destino, para operações da ULA
instruções_RAM: sempre com R1
sempre com R1: Usa o registrador 1 para indicar o endereço da operação
carga_constantes: instrução li, R0 = genérico
instrução li, R0 = genérico: Proibido usar um registrador fixo em zero; use uma
instrução especial li para carregar constantes
número_de_registradores: 8
branches_obrigatórios: bgt
achievement_obrigatório: instruções em dois endereços: um para o opcode e outro para o operando
A validação pode ser apresentada sem isso funcionando, mas terá desconto
programa_demonstração: criptografia simples (p.ex., vigenere)
A validação só será aceita se o programa demonstração estiver funcionando; se
estiver muito difícil, converse com o professor
Alternativas Opcionais:
instruções podendo ocupar 1 ou 2 endereços desalinhados, pipeline 4 estágios, uso
de floats, "superescalar" multiciclo com duas ops ULA por clock sem dependência
de registradores, instruções vetoriais, interrrupções externas
Qualquer uma destas alternativas pode ser incluída no projeto; vale algum extra e
a liberdade de escolher qualquer achievement e qualquer programa demonstração
Last updated 2014-10-30 12:25:25 BRST