Toshiba TC86R4400MC-200 9636YJA
O MIPS é o nome de uma arquitetura de processadores baseados no uso de registradores. As suas instruções tem à disposição um conjunto de 32 registradores para realizar as operações.
Processadores MIPS são do tipo RISC (Reduced Instruction Set Computer - ou seja, Computadores com Conjunto de Instruções Reduzidas). Isso significa que existe um conjunto bastante pequeno de instruções que o processador sabe fazer. Combinando este pequeno número, podemos criar todas as demais operações.
Os processadores MIPS são usados em sistemas embarcados, como portoes residenciais e roteadores, Originalmente, o MIPS foi projetado para computação de uso geral. Durante as décadas de 1980 e 1990, os processadores MIPS para computadores pessoais, estações de trabalho e servidores foram usados por muitas empresas.
Historicamente, os consoles de videogame como Nintendo 64, Sony PlayStation, PlayStation 2 e PlayStation Portable usavam processadores MIPS.
processador Sony CXD9615GB 'Emotion Engine' usado no ps2 e baseado no processador MIPS R5900
- A simplicidade favorece a regularidade.
- O menor é (quase sempre) mais rápido.
- Um bom projeto demanda compromissos.
- O caso comum DEVE ser mais rápido.
Também conhecida como argumento de Amdahl, é usada para encontrar a máxima melhora esperada para um sistema em geral quando apenas uma única parte do mesmo é melhorada. Isto é frequentemente usado em computação paralela para prever o máximo speedup teórico usando múltiplos processadores. A lei possui o nome do Arquiteto computacional Gene Amdahl, e foi apresentada a AFIPS na Conferência Conjunta de Informática na primavera de 1967.
Speedup pode ser definido como a relação entre o tempo gasto para executar uma tarefa com um único processador e o tempo gasto com N processadores, ou seja, Speedup é a Medida do ganho em tempo.
A arquitetura Misp tem o propósito de ser leve rápida e optimizar as instruções que são mais usadas durante a execução.
ou seja é muito melhor tornar uma instrução que é usada 90% do tempo 10% mais rápida do que fazer com que uma instrução usada em 10% das vezes torne-se 90% mais rápida.
As instruções seguem a forma "instrução" "registrador final", "primeiro", "segundo"
seguindo essa lógica se usarmos
add $t0, $t1, $t2estamos somando $t2 a $t1 e armazenando o resultado em $t0
Instrução de adição
add $r1, $r2, $r3Instrução de subtração
sub $r1, $r2, $r3Instrução AND bit a bit
and $r1, $r2, $r3Instrução OR bit a bit
or $r1, $r2, $r3 Essa instrução é usada para carregar valores dentro de um vetor.
(estrutura de 4 bytes)
lw $r1, 4($r2)(estrutura de 2 bytes)
lh $r1, 6($r3)(estrutura de 16 bytes)
lb $r1, 16($r2)As instruções Branch são usadas para controle de fluxo como "if" ou "for".
para entender melhor os mnemônicos basta pensar na sua abreviação
- beq -> branch if equals ==
- bne -> branch if not a equals !=
- bgt -> branch if greater than >
- bge -> branch if greater or equals >=
- blt -> branch if less than <
- ble -> branch if less or equals <=
para usar essas instruções é necessário usar label, rótulos no código que define um destino.
junto da instrução "j", jump, essa instrução vai para o rótulo sem a necessidade de uma condição.
.data
msg1:.asciiz"\nthen"
msg2:.asciiz"\nelse"
.text
main:
#branch beq, bne, bgt, bge, blt, ble
# branch op1, op2, label
li $t1, 2
li $t2, 2
beq $t0, $t2, then: # essa condição verifica se $t0 é igual a $t2 se sim vai para "then:"
j else # caso contrário a instrução segue em diante e pula para else.
then:
li $v0, 4
la $a0, msg1
syscall
j end
else:
li $v0, 4
la $a0, msg2
syscall
end:No exemplo acima os rotolo else são destino da branch beq
Instrução de comparação de $r2 e $r3, a diferença aqui é que a comparação não pula para um rótulo e sim armazena 0 ou 1 no registrador $r1.
slt $r1, $r2, $r3A arquitetura misp reconhece 3 tipos de instruções.
- As Instruções Tipo R
- As Instruções Tipo I
- As Instruções Tipo J
| Tipo | formato (bits) | |||||
|---|---|---|---|---|---|---|
| R | opcode (6) | rs (5) | rt (5) | rd (5) | shamt (5) | funct (6) |
| I | opcode (6) | rs (5) | rt (5) | immediate (16) | ||
| J | opcode (6) | address (26) | ||||
A linguagem Assembly de uma máquina costuma ser um reflexo direto de como são implementadas as instruções de um determinado processador. Entretanto, nem todas as instruções que temos à disposição quando programamos em Assembly são instruções verdadeiras para o processador. Algumas delas são na verdade pseudo-instruções.
Pseudo-instruções costumam ser substituídas pelo montador ao gerar instruções para o computador na forma de Lingüagem de Máquina. Pseudo-Instruções são na verdade combinações de mais de uma instrução.
move $r1, $r2 Ela é na verdade implementada da seguinte forma addu $r1, $r0, $r2
Ou seja adiciona 0 ao registrador e coloca o resultado no destino.
Quando queremos chamar uma função, as seguintes etapas devem ser cumpridas:
- O programa principal deve colocar os parâmetros da função em um local que ela possa acessar.
- O programa principal deve ceder o controle para a função.
- A função deve coletar todos os parâmetros deixados pelo programa principal.
- A função deve executar a tarefa desejada.
- A função deve armazenar seus resultados em um lugar em que o programa principal possa acessar.
- A função deve retornar o fluxo do código para o ponto imediatamente após ser chamada.
Para que estes requisitos sejam cumpridos, as seguintes convenções fora criadas:
- Os registradores $r4, $r5, $r6 e $r7 seriam usados para armazenar parâmetros de funções. Por causa desta funcionalidade, tais registradores podem ser chamados pelos seus "apelidos": $a0, $a1, $a2 e $a3.
- Os registradores $r2 e $r3 seriam usados para as funções armazenarem seus valores de retorno para o programa principal. Por isso, eles costumam ser chamados de $v0 e $v1.
Além dos registradores convencionados acima, o registrador $r31 também tem um papel importante. Ele sempre armazena o endereço de retorno para o qual a última função chamada deve retornar. Por ter uma função tão importante, este registrador é mais conhecido pelo apelido $ra.
instrução jal ou jump and link é usado da seguinte forma, jal endereço
instrução jr ou jump register é usado da seguinte forma, jr $ra
como exemplo vamos usar a seguinte função em C
int example(int a, int b){
int f;
f = a + b;
return f;
}em misp fica da seguinte forma
example:
add $v0, $a0, $a1
jr $ra