Organização de Computadores - Aula 06 - Conjunto de Instruções do MIPS

00:22:22
https://www.youtube.com/watch?v=VYSy21RwNIc

Ringkasan

TLDRA aula aborda o conjunto de instruções do MIPS, destacando suas características e princípios de design. O MIPS, um exemplo didático de arquitetura RISC, é popular em dispositivos embarcados. Com 32 registradores de 32 bits, o MIPS adota um modelo de instruções que favorece simplicidade e regularidade, facilitando a decodificação e o desempenho do processador. Os registradores incluem um que sempre contém zero, evitando acessos desnecessários à memória. A memória é endereçada por byte, com palavras alinhadas, e as instruções são categorizadas em tipo R, I e J, cada uma com suas particularidades para operações e desvios.

Takeaways

  • 💻 O MIPS é um exemplo didático de arquitetura RISC.
  • 📊 O MIPS possui 32 registradores de 32 bits.
  • ⚡ Instruções simples favorecem a eficiência do hardware.
  • 📈 O registrador zero sempre contém o valor zero.
  • 📝 A memória é endereçada por byte e deve estar alinhada.
  • 🔄 Instruções de salto permitem desvios na execução.
  • 📥 A instrução de imediato otimiza o uso de constantes pequenas.
  • 📐 O formato das instruções é regular e consistente.
  • 🔍 Existem três tipos principais de instruções: R, I e J.
  • ♻️ O MIPS é amplamente utilizado em dispositivos embarcados.

Garis waktu

  • 00:00:00 - 00:05:00

    Aula de número seis sobre organização de computadores, focando no conjunto de instruções do MIPS. O MIPS é um processador didático utilizado em ambientes embarcados como roteadores e impressoras. A aula explora a arquitetura que favorece o aprender, destacando as características de simplicidade e regularidade no design do MIPS, que é um exemplo de arquitetura RISC com instruções aritméticas uniformes.

  • 00:05:00 - 00:10:00

    Os princípios de projeto do MIPS incluem: (1) a simplicidade das instruções acelera a decodificação e melhora desempenho, (2) um menor número de registradores aumenta a rapidez de acesso e eficiência, e (3) a utilização de registradores para operações Lógicos/Aritméticos. O MIPS possui 32 registradores de 32 bits numerados, onde registros especiais como $t (temporários) e $s (salváveis) são utilizados para armazenar valores de maneira eficiente.

  • 00:10:00 - 00:15:00

    A arquitetura MIPS preconiza o uso de um registrador zero que contém constantemente o valor zero, evitando acessos desnecessários à memória. A memória é endereçada por byte, onde palavras de 32 bits (4 bytes) devem estar alinhadas. O acesso a dados se dá através de endereços múltiplos de quatro, e a arquitetura MIPS organiza dados na memória com a configuração Big Endian.

  • 00:15:00 - 00:22:22

    Além de instruções aritméticas, MIPS suporta instruções do tipo I e J, possibilitando operações com constantes e desvios incondicionais. As instruções aritméticas determinam uma estrutura regular de operação, enquanto instruções de desvio e saltos trazem dinâmica ao fluxo de execução dentro do protocolo MIPS, permitindo uma programação mais eficaz.

Tampilkan lebih banyak

Peta Pikiran

Video Tanya Jawab

  • O que é o MIPS?

    MIPS é um tipo de processador RISC utilizado em ambientes embarcados, como roteadores e impressoras.

  • Quais são os princípios de design do MIPS?

    Os princípios incluem simplicidade das instruções, velocidade no acesso a registradores, otimização de operações comuns e um bom compromisso entre recursos e regularidade.

  • Quantos registradores o MIPS possui?

    O MIPS possui 32 registradores de 32 bits.

  • Como funciona o acessamento de memória no MIPS?

    A memória no MIPS é endereçada por byte e as palavras devem estar alinhadas corretamente.

  • O que significa 'big endian'?

    No modo 'big endian', o byte mais significativo é armazenado no endereço mais baixo da memória.

  • Quais são os tipos de instruções no MIPS?

    Os tipos de instruções incluem tipo R (com registradores), tipo I (com imediato) e tipo J (saltos ou desvios incondicionais).

Lihat lebih banyak ringkasan video

Dapatkan akses instan ke ringkasan video YouTube gratis yang didukung oleh AI!
Teks
pt
Gulir Otomatis:
  • 00:00:11
    [Música]
  • 00:00:20
    Olá hoje nós temos a aula de número seis
  • 00:00:23
    da disciplina de organização de
  • 00:00:25
    computadores então nós já conversamos
  • 00:00:27
    sobre as características gerais do
  • 00:00:29
    computador sobre a organização interna
  • 00:00:31
    sobre a arquitetura do conjunto de
  • 00:00:33
    instruções E hoje nós vamos conversar
  • 00:00:36
    sobre o conjunto de instruções do mips
  • 00:00:39
    Então nós vamos exemplificar os
  • 00:00:40
    conceitos que nós vimos de arquitetura
  • 00:00:42
    de conjunto de instruções para um
  • 00:00:45
    computador para um processador
  • 00:00:46
    específico bom que processador é esse é
  • 00:00:49
    o mips o mips é um exemplo didático né
  • 00:00:53
    ele aparece em diversos livros textos
  • 00:00:55
    aparec aí nos livros textos que a gente
  • 00:00:57
    um dos livros textos que a gente
  • 00:00:58
    considera do rnc do pato
  • 00:01:00
    ah justamente porque um dos autores eh
  • 00:01:04
    do livro é autor do mips né Ah ele é um
  • 00:01:07
    processador Ah que está à venda ele tem
  • 00:01:10
    uma fatia de mercado no de ambientes
  • 00:01:12
    embarcados é usado em roteadores em
  • 00:01:16
    equipamentos de rede de armazenamento
  • 00:01:18
    impressoras né é um equipamento é um
  • 00:01:20
    dispositivo que tá em produção e que é
  • 00:01:22
    utilizado por que que a gente escolheu
  • 00:01:24
    seguir além de ser porque ele tá no
  • 00:01:26
    livro texto o mips tem características
  • 00:01:28
    de uma arquitetura Risk né então ele tem
  • 00:01:31
    a características de formatos de
  • 00:01:33
    instrução que facilitam o processo de
  • 00:01:36
    aprendizado eles conseguem cobrir todos
  • 00:01:38
    os elementos que a gente quer cobrir de
  • 00:01:40
    Arquitetura do conjunto de instruções e
  • 00:01:43
    os típicos os valores as características
  • 00:01:46
    desse conjunto de instruções é típico
  • 00:01:48
    dos conjuntos de instruções modernos
  • 00:01:50
    então a gente consegue cobrir as
  • 00:01:52
    características e discutir essas
  • 00:01:54
    características todas utilizando mips
  • 00:01:56
    como
  • 00:01:57
    referência bom o mips ele segue quatro
  • 00:02:01
    princípios de projeto que vão ser ah
  • 00:02:04
    relacionados às decisões que foram
  • 00:02:06
    tomados e as características dessa
  • 00:02:08
    arquitetura desse conjunto de instruções
  • 00:02:10
    primeiro princípio de projeto diz que a
  • 00:02:13
    simplicidade favorece a
  • 00:02:15
    regularidade ou seja quanto mais simples
  • 00:02:18
    as minhas instruções quanto mais regular
  • 00:02:21
    essas instruções forem né mais fácil é a
  • 00:02:24
    decodificação mais simples vai ser o
  • 00:02:26
    hardware que vai implementar essa
  • 00:02:28
    decodificação e Ass ent ação das
  • 00:02:30
    instruções então a simplicidade das
  • 00:02:33
    instruções das que a gente defini vai
  • 00:02:36
    favorecer a simplicidade do hardware e
  • 00:02:38
    vai levar a um melhor desempenho desse
  • 00:02:40
    processador bom o que que isso quer
  • 00:02:43
    dizer nesse primeiro momento que todas
  • 00:02:45
    as operações aritméticas tem a mesma
  • 00:02:47
    forma eu vou ter três operandos um
  • 00:02:50
    destino e dois operandos origem da onde
  • 00:02:53
    eu vou pegar os dados então todas as
  • 00:02:55
    instruções são do tipo Ed a b c onde a a
  • 00:03:00
    recebe os valores de b + c se eu quiser
  • 00:03:03
    fazer a soma de fazer a receber o valor
  • 00:03:07
    de a + b eu vou ter que explicitamente
  • 00:03:09
    escrever é a a e b né Então Eu repito na
  • 00:03:14
    instrução Eu ainda posso utilizar um
  • 00:03:17
    mesmo valor Mas a questão aqui é com
  • 00:03:19
    relação ao formato da instrução eu
  • 00:03:22
    preciso Obrigatoriamente incluir três
  • 00:03:25
    operandos e isso simplifica o processo a
  • 00:03:28
    decodificação dessa instru
  • 00:03:30
    e isso favorece a o desempenho a
  • 00:03:33
    implementação desse
  • 00:03:35
    processador segundo princípio de projeto
  • 00:03:38
    menor é mais rápido e aqui a gente tá
  • 00:03:41
    pensando em dois aspectos primeiro
  • 00:03:44
    acessar o registrador que tipicamente
  • 00:03:47
    são muito menor em termos de a
  • 00:03:49
    capacidade de armazenamento é muito
  • 00:03:51
    menor do que a memória principal né
  • 00:03:54
    acessar um registrador vai ter um menor
  • 00:03:56
    tempo de acesso ele é muito mais rápido
  • 00:03:58
    né quanto menor o meu conjunto de
  • 00:04:01
    registradores se eu tiver 32 ou 16 ao
  • 00:04:04
    invés de ter 128 256 o gerenciamento
  • 00:04:07
    desses registradores o acesso a esses
  • 00:04:09
    registradores também vai ter um tempo de
  • 00:04:11
    acesso mais rápido tá então Esse
  • 00:04:14
    princípio ele trata do de usar
  • 00:04:16
    registradores como operandos dessa
  • 00:04:18
    característica que a gente tem no mips
  • 00:04:20
    de manipular os registradores para as
  • 00:04:22
    operações Lógico aritméticas né então
  • 00:04:26
    ele tem 32 registradores de 32 bits
  • 00:04:29
    então mips que a gente tá vendo aqui
  • 00:04:30
    como exemplo é o mips de 32 bits cuja
  • 00:04:33
    palavra tem 32 bits o formato de
  • 00:04:35
    instrução tem 32 bits e nós temos 32
  • 00:04:39
    registradores também que vão ser
  • 00:04:41
    numerados de 0 a
  • 00:04:45
    31 bom esses registradores eles têm do
  • 00:04:49
    ponto de vista de linguagem assemble do
  • 00:04:51
    mips alguns nomes especiais para
  • 00:04:53
    facilitar a nossa manipulação primeiros
  • 00:04:56
    deles a gente vai ter os registradores
  • 00:04:58
    de dólar T zer é dólar T9 são
  • 00:05:01
    registradores que a gente pode utilizar
  • 00:05:02
    para armazenar valores no nosso código
  • 00:05:05
    na nossa implementação no assemble do
  • 00:05:08
    mips além de dólar t0 a dólar T9 a gente
  • 00:05:11
    tem o dólar s0 a dólar s7 então nós
  • 00:05:14
    temos um total aqui de 18 registradores
  • 00:05:17
    que a gente pode manipular nos Nossos
  • 00:05:20
    programas em assemble do mips tá Ah
  • 00:05:23
    esses registradores têm esses nomes t e
  • 00:05:26
    s né porque eles estão Associados a
  • 00:05:28
    valores temp horários e valores que T
  • 00:05:32
    que ser salvas o que que isso quer dizer
  • 00:05:34
    nós vamos discutir mais paraa frente o
  • 00:05:36
    que que acontece com uma chamada de
  • 00:05:38
    função ou uma chamada de procedimento
  • 00:05:40
    para tratar uma interrupção então Caso
  • 00:05:42
    haja uma mudança nesse fluxo de quem tá
  • 00:05:45
    executando né O que tá nos variáveis nos
  • 00:05:48
    valores temporários ninguém tem
  • 00:05:50
    obrigação de salvar e o programa tem que
  • 00:05:52
    saber que ele corre o risco de perder
  • 00:05:54
    por outro lado o que tá num valor e num
  • 00:05:56
    registrador do tipo S requer que quem
  • 00:06:00
    for utilizar esse registrador do tipo S
  • 00:06:02
    salve o valor desse registrador e após o
  • 00:06:05
    uso restaure o valor original Então isso
  • 00:06:08
    é uma característica da arquitetura do
  • 00:06:10
    conjunto de instruções que os programas
  • 00:06:12
    têm que seguir bom mas aqui a gente tem
  • 00:06:15
    18 registradores e eu falei que tinha 32
  • 00:06:18
    e esses outros registradores esses
  • 00:06:21
    outros registradores eles têm alguns
  • 00:06:22
    propósitos específicos pro mips a gente
  • 00:06:25
    vai tratar de vários deles ao longo das
  • 00:06:27
    várias instruções que a gente for
  • 00:06:29
    explorando e o primeiro que eu quero
  • 00:06:30
    destacar aqui é o registrador zero que é
  • 00:06:33
    chamado de dólar zero bom quando a gente
  • 00:06:36
    pensa nas nossas programas em C ou em
  • 00:06:38
    Java a gente faz muitas vezes atribuição
  • 00:06:41
    de zero vou fazer um loop primeiro lá
  • 00:06:44
    meu primeiro valor tipicamente e ig zer
  • 00:06:46
    vou incrementar esse valor muitas vezes
  • 00:06:49
    vou checar uma condição tô comparando
  • 00:06:50
    ser igual a zero maior que zero menor
  • 00:06:52
    que zero então nós utilizamos muito o
  • 00:06:54
    valor zero nas nossas na nossa linguagem
  • 00:06:57
    nos Nossos programas Então como esse é
  • 00:07:00
    um valor muito utilizado foi decidido
  • 00:07:02
    que esse registrador zero vai ter a
  • 00:07:05
    constante zero né que esse é um
  • 00:07:07
    registrador que eu não pode ser
  • 00:07:08
    sobrescrito então eu já tenho num
  • 00:07:10
    registrador esse valor que eu quero
  • 00:07:12
    utilizar Por que que isso é importante
  • 00:07:14
    porque isso evita que eu precise toda
  • 00:07:17
    vez que eu vou fazer um programa que eu
  • 00:07:18
    vou usar zero e a gente eu desafio vocês
  • 00:07:21
    aí a verificarem os códigos de vocês que
  • 00:07:24
    vocês escreveram nas várias disciplinas
  • 00:07:26
    e nos vários programas que vocês tiveram
  • 00:07:28
    que escrever se se vocês quantas vezes
  • 00:07:30
    vocês usaram esse valor zero essa
  • 00:07:32
    constante zero então o fato de eu não
  • 00:07:34
    precisar acessar uma posição de memória
  • 00:07:37
    para buscar esse valor zero já faz com
  • 00:07:39
    que eu tenha um ganho de desempenho
  • 00:07:40
    então justamente por causa desse uso é
  • 00:07:43
    que a gente tem aqui essa decisão de
  • 00:07:45
    projeto de que eu tenho um registrador
  • 00:07:46
    com esse valor um outro uso interessante
  • 00:07:50
    também é para fazer movimentação do
  • 00:07:51
    conteúdo de registradores se por algum
  • 00:07:54
    motivo eu quero movimentar né Eu quero
  • 00:07:57
    deslocar o que tá em S1 para T2
  • 00:08:00
    basta eu somar o valor de S1 com zero
  • 00:08:02
    que eu já tenho esse deslocamento
  • 00:08:03
    garantido então o mips não tem uma
  • 00:08:06
    instrução de movimentação mas o fato de
  • 00:08:08
    eu ter esse registrador zero permite que
  • 00:08:10
    eu crie ess que eu use essa instrução de
  • 00:08:13
    movimentação através da instrução de
  • 00:08:16
    audição bom outro aspecto importante é
  • 00:08:18
    falar de memória né Onde estão os nossos
  • 00:08:21
    dados principais como é que funciona a
  • 00:08:23
    memória no caso do mips Bom primeiro
  • 00:08:25
    aspecto importante a memória endereçada
  • 00:08:27
    por byte né apesar da minha palavra ter
  • 00:08:30
    32 bits quer dizer que eu tenho 4 bytes
  • 00:08:33
    por palavra eu vou fazer o endereçamento
  • 00:08:35
    por byte isso é importante porque eu
  • 00:08:37
    posso acessar byte na memória eu posso
  • 00:08:39
    acessar meia palavra 16 bits ou eu posso
  • 00:08:42
    acessar minha palavra toda os 32 bits
  • 00:08:44
    então é importante ter essa
  • 00:08:45
    flexibilidade no modo de
  • 00:08:47
    endereçamento só que as palavras tê que
  • 00:08:50
    estar escritas na memória de maneira
  • 00:08:52
    alinhada ou seja sempre do bit zero até
  • 00:08:56
    o bit 31 sempre alinhado ocupando uma
  • 00:08:59
    lha linha toda se eu tiver um valor
  • 00:09:01
    menor eu vou por exemplo um byte eu eu
  • 00:09:04
    não posso colocar esse byte entre duas
  • 00:09:06
    linhas ele precisa tá el precisa tá
  • 00:09:08
    colocado na posição correta se for o
  • 00:09:10
    caso eu tenho que complementar isso com
  • 00:09:12
    zeros fazer essa extensão tá isso quer
  • 00:09:15
    dizer o quê se a memória é alinhada
  • 00:09:17
    endereçada por byte que quando eu for
  • 00:09:19
    buscar minha instrução na memória e a
  • 00:09:21
    instrução sempre tem uma palavra toda
  • 00:09:23
    que eu vou ter que fazer com que os meus
  • 00:09:25
    endereços sejam múltiplos de quatro a
  • 00:09:27
    minha primeira instrução por exemplo vai
  • 00:09:29
    tá no endereço x a instrução seguinte
  • 00:09:32
    vai estar em x + 4 porque eu quero
  • 00:09:34
    deslocar uma linha toda tá então é
  • 00:09:37
    importante lembrar dessa questão que os
  • 00:09:39
    endereços têm que ser múltiplos de
  • 00:09:40
    quatro na hora de fazer busca de
  • 00:09:42
    instruções na hora de fazer busca de
  • 00:09:44
    palavras para poder gerar o código em
  • 00:09:45
    assemble correto e uma observação
  • 00:09:49
    interessante aqui a gente tem a duas
  • 00:09:52
    maneiras de organizar as memóri os dados
  • 00:09:55
    na memória né que é o que a gente chama
  • 00:09:57
    de ess em inglês o caso do mips ele é
  • 00:09:59
    big endian o que isso quer dizer que o
  • 00:10:01
    byte mais
  • 00:10:03
    significativo está no endereço menos
  • 00:10:05
    significativo da palavra Então o bte que
  • 00:10:08
    tá no endereço zero é o bte TR tá isso
  • 00:10:11
    aqui é importante Principalmente quando
  • 00:10:12
    a gente vai escrevendo código em
  • 00:10:14
    assembly for fazer a manipulação de
  • 00:10:17
    endereços de memória Mas se por outro
  • 00:10:19
    lado a gente tiver o compilador o
  • 00:10:21
    montador trabalhando PR a gente isso não
  • 00:10:24
    vai ser tão relevante mas é importante
  • 00:10:26
    lembrar dessas diferenças com relação
  • 00:10:28
    aos vários
  • 00:10:30
    sistemas bom então vamos ver aqui um
  • 00:10:33
    exemplo de acessar a memória então se eu
  • 00:10:35
    tiver esse código em c g = h + a de8 né
  • 00:10:40
    eu posso mapear G por exemplo no
  • 00:10:42
    registrador S1 h no registrador S2 e o
  • 00:10:46
    endereço base de A ou seja zero vai tá
  • 00:10:49
    em S3 como é que eu faço para
  • 00:10:52
    implementar essa operação Primeira coisa
  • 00:10:54
    eu preciso buscar esse valor na memória
  • 00:10:56
    eu preciso buscar a de8 na posição de
  • 00:10:58
    memória
  • 00:10:59
    Ou seja eu vou precisar considerar o meu
  • 00:11:02
    endereço base S3 e deslocar essas oito
  • 00:11:06
    posições Lembrando que na verdade como o
  • 00:11:09
    endereço é em byte eu vou ter que
  • 00:11:11
    multiplicar isso por quatro né então por
  • 00:11:13
    isso que a instrução de load ela coloca
  • 00:11:16
    aqui o meu endereço base S3 e aqui o
  • 00:11:19
    deslocamento ou seja esse 32 é o número
  • 00:11:22
    de iterações que eu vou ter que deslocar
  • 00:11:25
    com relação a multiplicar por quatro
  • 00:11:28
    porque é o número de de bytes que eu
  • 00:11:29
    tenho na minha palavra e t0 é o meu
  • 00:11:32
    destino para essa informação uma vez que
  • 00:11:34
    eu tenho o valor de a de 8 em t0 eu
  • 00:11:37
    posso fazer a soma com o valor que eu
  • 00:11:39
    tinha em S2 que equivale a h e armazenar
  • 00:11:43
    em G tá então aqui é o exemplo que a
  • 00:11:46
    gente tem do acesso à
  • 00:11:50
    memória Desculpa bom terceiro princípio
  • 00:11:53
    de projeto fazer o caso comum mais
  • 00:11:56
    rápido ele decorre justamente da lei de
  • 00:11:58
    andal que a gente discutiu lá no começo
  • 00:12:00
    do curso né eu tenho que procurar
  • 00:12:02
    otimizar aquilo que a gente usa mais bom
  • 00:12:05
    além do zero que a gente usa bastante
  • 00:12:06
    nos nossos códigos a gente também
  • 00:12:09
    costuma fazer bastante incremento de um
  • 00:12:11
    em um por exemplo nos casos dos Loops a
  • 00:12:14
    gente usa bastante informação ah somas
  • 00:12:18
    ou subtrações de valores pequenos né e
  • 00:12:21
    valores pequenos aqui são valores por
  • 00:12:23
    exemplo que eu poderia armazenar em 8
  • 00:12:24
    bits em 16 bits né ah e justamente
  • 00:12:27
    pensando nessas caracter
  • 00:12:29
    nesse caso comum que é o uso de
  • 00:12:31
    constantes pequenas né é que a gente tem
  • 00:12:34
    as um outro tipo de instrução que
  • 00:12:37
    permite que eu tenha uma um operando que
  • 00:12:40
    não está armazenado no registrador mas
  • 00:12:42
    que tá escrito na própria instrução tá
  • 00:12:45
    Ah e como essas constantes são pequenas
  • 00:12:48
    eu posso pegar então e colocar essas
  • 00:12:50
    constantes em 16 bits tá então por
  • 00:12:53
    exemplo nessa instrução de soma com uma
  • 00:12:56
    constante é a instrução do tipo e de i e
  • 00:12:58
    de imediato eu estou somando o conteúdo
  • 00:13:01
    do registrador S3 com o valor 4 com a
  • 00:13:04
    constante 4 e armazenando em S3 tá isso
  • 00:13:08
    também é útil para fazer as instruções
  • 00:13:12
    para evitar com que eu faça um load de
  • 00:13:14
    uma constante da mesma forma que eu não
  • 00:13:16
    gostaria de fazer o load do valor zero
  • 00:13:18
    eu também não gostaria de ter que fazer
  • 00:13:19
    load de valores pequenos por exemplo
  • 00:13:21
    daquele um que toda hora eu tô somando
  • 00:13:23
    lá no meu loop no meu for Ah não existe
  • 00:13:26
    constante negativa desculpa não existe
  • 00:13:29
    subtração de constantes as instruções
  • 00:13:32
    com imediato são só as instruções de
  • 00:13:34
    adição Então eu preciso fazer aqui se eu
  • 00:13:37
    quiser uma subtração colocar um valor
  • 00:13:39
    negativo
  • 00:13:42
    Tá bom então a gente falou de dois tipos
  • 00:13:46
    de instrução até agora instruções como
  • 00:13:48
    as instruções aritméticas que tem três
  • 00:13:50
    registradores e essa instrução i isso
  • 00:13:52
    traz a gente para discutir os formatos
  • 00:13:54
    de instruções que a gente tem no mips tá
  • 00:13:57
    então a gente já falou das instru com
  • 00:13:59
    registrador que aparece aqui os
  • 00:14:01
    registradores e dessa instrução que
  • 00:14:03
    aparece a constante aqui que é essa
  • 00:14:05
    instrução com o imediato Então vamos
  • 00:14:07
    conversar um pouquinho sobre esses tipos
  • 00:14:09
    de instrução primeiro instrução do tipo
  • 00:14:11
    R que são as instruções com
  • 00:14:13
    registradores como operamos eu tenho o
  • 00:14:15
    meu opcode se bits que vão Identificar
  • 00:14:18
    qual que é a operação Qual que é a
  • 00:14:20
    instrução que tá sendo executada aí eu
  • 00:14:23
    vou ter dois registradores com operandos
  • 00:14:25
    rs e RT como eu tenho 32 Ades no mips eu
  • 00:14:30
    preciso de 5 bits para contar esses 32
  • 00:14:32
    registradores exatamente o que eu tenho
  • 00:14:34
    aqui 5 bits para RS 5 bits para RT E aí
  • 00:14:37
    eu vou ter RD que é o meu registrador
  • 00:14:39
    destino mais 5 bits para RD bom isso
  • 00:14:42
    ainda me sobra 11 bits nessa minha
  • 00:14:44
    instrução de 32 bits ah Existem algumas
  • 00:14:47
    instruções de shift de deslocamento que
  • 00:14:51
    eu vou usar esse campo aqui Shift amount
  • 00:14:54
    para justamente passar esse valor de
  • 00:14:56
    deslocamento né se eu tenho 32 bit é
  • 00:14:59
    razoável que eu só vai fazer
  • 00:15:00
    deslocamento de até 32 posições né não
  • 00:15:03
    não preciso mais do que 5 bits para
  • 00:15:05
    representar esse valor e finalmente meus
  • 00:15:08
    últimos se bits aqui na instrução do
  • 00:15:10
    tipo R é função se eu só tenho 6 bits de
  • 00:15:14
    opcode eu teri 2 à se 64 valores
  • 00:15:17
    possíveis de instrução para poder
  • 00:15:19
    executar e nesse meu conjunto de
  • 00:15:22
    instruções bom não é um valor tão grande
  • 00:15:25
    né eu tenho soma
  • 00:15:26
    subtração os as unidades as operações
  • 00:15:29
    lógicas load tort são uma série de
  • 00:15:31
    instruções a maneira de estender esse
  • 00:15:33
    número de instruções é usar esse campo
  • 00:15:36
    de função vamos ver um exemplo aqui por
  • 00:15:39
    exemplo nessa instrução de soma onde eu
  • 00:15:41
    quero somar t0 S1 e S2 eu vou usar um
  • 00:15:44
    valor especial para representar que é
  • 00:15:46
    uma instrução aritmética aqui no opcode
  • 00:15:49
    por exemplo o valor
  • 00:15:51
    00 e eu vou usar o campo de função para
  • 00:15:55
    especificar que a minha instrução
  • 00:15:57
    aritmética que tá dentro de 00 equivale
  • 00:16:01
    ao valor 32 ou em decimal ou um 00 aqui
  • 00:16:05
    em binário tá então essa combinação do
  • 00:16:09
    campo de upcode com função é que vai
  • 00:16:11
    permitir que eu reconheça a minha função
  • 00:16:13
    de adição bom dois registradores
  • 00:16:16
    operandos S1 e S2 olhando na tabela de
  • 00:16:20
    referência do mips né que a gente tem
  • 00:16:23
    disponível que a gente tem acesso a
  • 00:16:24
    gente vai ver que isso equivale aos
  • 00:16:26
    registradores 17 e 18 o meu destino t0
  • 00:16:30
    equivale ao registrador de número o
  • 00:16:32
    então com isso eu sou capaz de construir
  • 00:16:35
    a minha instrução bom Como é que o
  • 00:16:38
    processador vai entender isso para poder
  • 00:16:39
    executar eu preciso transformar o que tá
  • 00:16:41
    em decimal que é conveniente para nós
  • 00:16:43
    humanos entendermos em binário uma vez
  • 00:16:47
    que eu tenho instrução em binário eu
  • 00:16:48
    empaco os meus 32 bits aqui em base do E
  • 00:16:51
    é isso que o processador vai usar para
  • 00:16:54
    ler da memória e para poder saber como
  • 00:16:56
    executar essa instrução
  • 00:16:59
    bom observando agora a instrução do tipo
  • 00:17:01
    I ela continua com os mesmos seis bits
  • 00:17:04
    up code a gente tem aqui regularidade no
  • 00:17:06
    formato de instrução e eu vou ter dois
  • 00:17:09
    registradores aqui RS RT cada um 5 bits
  • 00:17:12
    e depois eu tenho 16 bits do campo de
  • 00:17:15
    imediato Tá então vamos conversar um
  • 00:17:18
    pouquinho sobre esses campos bom a gente
  • 00:17:20
    tem dois tipos aqui iniciais que a gente
  • 00:17:23
    vai falar de instruções do tipo I
  • 00:17:25
    Primeiro as instruções aritméticas se eu
  • 00:17:27
    tenho uma instrução aritmética esse meu
  • 00:17:29
    campo de imediato é uma constante aquela
  • 00:17:31
    constante que pode ser positiva ou
  • 00:17:33
    negativa né se a gente lembrar lá das
  • 00:17:35
    aulas de lógica digital de aritmética
  • 00:17:37
    binária se eu tenho 16 bits essa
  • 00:17:40
    constante pode ir de -2 até elevado a 15
  • 00:17:44
    até + 2 elevado 15 - 1 que é uma um é
  • 00:17:48
    uma constante pequena mas ainda assim é
  • 00:17:50
    um espaço razoável de valores pra gente
  • 00:17:52
    considerar como constante tá bom se for
  • 00:17:55
    uma instrução de load que eu quero
  • 00:17:57
    buscar um dado na memó memória eu vou
  • 00:17:59
    usar esse valor para ajudar a compor o
  • 00:18:02
    meu endereço tá então por isso que esses
  • 00:18:05
    esse imediato também pode ser entendido
  • 00:18:07
    como endereço esses 16 bits de endereço
  • 00:18:10
    ele vai ser somado ao meu endereço base
  • 00:18:13
    que está em RS ou seja nesse registrador
  • 00:18:16
    Então nesse registrador RS eu vou ter um
  • 00:18:17
    endereço de 32 bits eu vou pegar esses
  • 00:18:20
    16 bits aqui de endereço vou precisar
  • 00:18:22
    fazer a extensão de sinal ou seja a se
  • 00:18:25
    ele é um
  • 00:18:26
    endereço ele é um endereço ou seja não
  • 00:18:28
    tem um conceito de positivo e negativo
  • 00:18:29
    vou precisar adicionar bit zero a esses
  • 00:18:32
    16 bits para que ele tenha 32 bits vou
  • 00:18:34
    somar com o meu endereço base e com isso
  • 00:18:36
    eu vou poder acessar uma determinada
  • 00:18:38
    posição de memória no caso de uma
  • 00:18:40
    instrução de load onde eu tô pegando um
  • 00:18:42
    dado da memória para trazer pro
  • 00:18:44
    processador eu vou armazenar essa
  • 00:18:46
    informação em
  • 00:18:48
    RT então justamente o que a gente tem
  • 00:18:51
    aqui é o quarto princípio de projeto que
  • 00:18:54
    ele vai falar que um bom projeto né de
  • 00:18:57
    um computador implica em compr
  • 00:18:59
    eu gostaria de ter uma faixa de endereço
  • 00:19:01
    Grande para acessar memória muito mais
  • 00:19:04
    do que só somar 16 bits eu gostaria de
  • 00:19:06
    ter uma possibilidade muito grande de
  • 00:19:07
    constante mas por outro lado é
  • 00:19:09
    importante que eu tenha regularidade no
  • 00:19:12
    meu formato de instrução que eu respeite
  • 00:19:13
    os meus 32 bits e que eu ten uma
  • 00:19:15
    estrutura muito próxima então por isso
  • 00:19:18
    eu não mexi os projetistas não mexeram
  • 00:19:20
    nessa parte da instrução então o
  • 00:19:22
    compromisso aqui foi ter só 16 bits de
  • 00:19:25
    constante ou endereço
  • 00:19:30
    o outro tipo de instrução que também usa
  • 00:19:32
    o tipo I são as instruções de desvio né
  • 00:19:35
    Essas instruções de desvio comparam dois
  • 00:19:37
    registradores rs e RT se for se a
  • 00:19:41
    condição for verdade eu vou desviar pro
  • 00:19:45
    endereço que tá implicado no naqueles 16
  • 00:19:48
    bits naquele valor tá então Aqueles 16
  • 00:19:51
    bits que eu tenho no campo de imediato
  • 00:19:53
    vão ser transformados num endereço de
  • 00:19:55
    instrução eles vão ser somados ao meu
  • 00:19:57
    endereço base da instrução e vão dar um
  • 00:19:59
    novo fluxo pra minha execução a gente
  • 00:20:02
    tem dois tipos de instrução de desvio
  • 00:20:04
    aqui o bran equal e o Branch not equal
  • 00:20:08
    ou seja desvio se for igual desvio se
  • 00:20:11
    for diferente então a gente simplifica
  • 00:20:14
    no caso do projeto do mips Ele eles
  • 00:20:17
    optaram por ter simplesmente dois tipos
  • 00:20:20
    de codificação dois tipos de desvio e
  • 00:20:23
    fazer com que a gente faça as
  • 00:20:24
    comparações separadas para chegar nesse
  • 00:20:27
    tipo de
  • 00:20:30
    e finalmente o nosso último tipo de
  • 00:20:32
    instrução é o tipo J terceiro e último
  • 00:20:34
    tipo mantém os mesmos 32 bits e mantém 6
  • 00:20:38
    bits de opcode O que que a gente tem na
  • 00:20:40
    instrução de tipo J são os saltos ou os
  • 00:20:44
    desvios incondicionais são instruções
  • 00:20:46
    que vão desviar de qualquer forma a
  • 00:20:48
    gente tem aqui as instruções de jump ou
  • 00:20:51
    Jump and link tá o que que essas
  • 00:20:53
    instruções fazem elas vão mudar para um
  • 00:20:55
    outro endereço de qualquer forma bom meu
  • 00:20:58
    endereço tem 32 bits mas aqui eu só
  • 00:21:00
    tenho 26 bits então a decisão do projeto
  • 00:21:03
    aqui dos projetistas Foi criar um outro
  • 00:21:05
    modulo de endereçamento onde eu vou
  • 00:21:08
    combinar os bits mais significativos do
  • 00:21:10
    meu registrador contador de instrução
  • 00:21:13
    para concatenar com o endereço que tá
  • 00:21:15
    nesses 26 bits Lembrando que o endereço
  • 00:21:19
    é por byte tá então aqui eu tô apontando
  • 00:21:22
    o endereço por byte eu preciso
  • 00:21:24
    multiplicar por quatro para alinhar com
  • 00:21:26
    a forma de endereçamento que a gente tem
  • 00:21:27
    no mips
  • 00:21:30
    então com isso a gente viu as
  • 00:21:32
    características principais do conjunto
  • 00:21:34
    de instruções do mips que estão
  • 00:21:36
    descritas aí no Capítulo do do livro do
  • 00:21:38
    renes do Patterson
  • 00:21:55
    [Música]
  • 00:21:58
    C
  • 00:22:09
    [Música]
Tags
  • MIPS
  • arquitetura RISC
  • conjunto de instruções
  • registradores
  • memória
  • endereço
  • instruções
  • desvios
  • programação
  • hardware