sábado, setembro 04, 2010

Aula 3 Projeto Lógico de Computadores

Estamos seguindo fielmente o capítulo 2 de Patterson e Hennesy, e vocês já podem começar a usar o simulador Mars e ou SPIM. O Mars você obtém da Internet ou

Mars.jar

Eu extraí o arquivo, criando uma pasta Mars. Para rodar o simulador, eu entro na pasta pela linha de comando:

cd Mars (cuidado com a maiúscula)

e depois digito:

java Mars

O spim você instala normalmente.

O Livro, desculpem pelo tamanho:

Computer Organization and Design 4thEd. Patterson and Hennessy

A aula


2.1 Introdução

  • Para trabalhar com computadores devemos entender sua linguagem.
  • A linguagem de um computador é o conjunto de instruções que ele entende (instruction set).
  • Vamos trabalhar com um conjunto de instruções  real, da família de processadores MIPS.
  • Mips é RISC, ou seja, é um computador que entende um conjunto reduzido de instruções (reduced instruction set computation)
  • Temos também CISC, conjunto complexo de instruções
  • Desde o início da computação moderna, sabia-se que um conjunto reduzido de instruções  seria capaz de realizar qualquer computação
Conceito de Programa Armazenado:
  • Vamos representar os dados por números no computador.
  • Vamos representar as instruções por números no computador.
Por que MIPS ?

  • É usado em sistemas embarcados
  • É RISC
  • É parecido com ARM
  • Temos Simuladores (Mars, SPIM).

2.2 Operações de Hardware do Computador
  • Todo computador deve ser capaz de realizar operações aritméticas básicas.


    • Ex: (todos os exemplos no MIPS)
    • add a,b,c


      • adicionar "b" e "c" e colocar em "a"


  • Operações aritméticas no MIPS: Uma operação por vez, três operandos.


    • Ex: Somar "b", "c", "d" e "e" em "a"


      • add a,b,c
      • add a,a,d
      • add a,a,e
O MIPS tem 32 registradores e 2^30 palavras de memória (2 elevado na trinta, ou seja, 1 Giga palavras na memória). e isto leva ao princípio de Design 1.

Simplicidade favorece a regularidade

Ou seja, operações simples, que são sempre iguais, são mais fáceis de implementar em Hardware.

  • Ex: Linguagem C

    • a = b + c;
    • d = a - e;

  • Qual é o código assembly correspondente ? Ou seja, qual seria o código gerado por um compilador a partir deste código C ?

    •  add a,b,c
    • sub d,a,e

      • Operação sub, de subtração

  • Ex: Linguagem C

    • f = (g + h) - (i + j);

  • Qual é o código de montagem (assembly) gerado ?

    • add t0, g, h
    • add t1, i, j
    • sub f, t0, t1

2.3 Operandos do Hardware do Computador

Operandos aritméticos
  • Os operandos das operações aritméticas devem estar armazenados nos registradores da CPU
  • Tamanho de um registrador no MIPS: 32 bits
  • Grupos de 32 bits = palavra (word)
Por que 32 registradores ?

Resposta 1)
  • Príncipio de Design 2
Menor é mais rápido

Ou seja, menos registradores, significa Hardware mais simples e mais rápido. O ciclo de relógio pode ser menor com menos registradores.

Resposta 2)

  • Tamanho de instruções e endereçamento (seção 2.5)
Convenção para escrita de registradores: Símbolo $, seguido de dois caracteres

  • Ex: Escreva usando os registradores

    •  f = (g+h) - (i+j);

  • Resposta:

    • add $t0, $s1, $s2
    • add $t1, $s3, $s4
    • sub $s0, $t0, $t1

Operandos de memória

As linguagens de programação tem , em geral:
  • variáveis
  • vetores
  • estruturas
Como guardar estes tipos complexos nos registradores, para realizar operações neles ?
  • Registradores: São poucos, com pouco espaço
  • Memória: Muita!
Temos que ser capazes de transferir dados da memória para os registradores, e vice-versa
  • Instruções de transferência de dados
Para acessar uma palavra na memória, a instrução deve fornecer um endereço.


E endereço do terceiro elemento é 8, e o seu valor é 10 (memory[2])
  • Instruções load word(lw) e store word(sw)
  • Carregar da memória (lw) e guardar na memória (sw)
  • A primeira das instruções traz da memória e coloca num registrador
  • A segunda instrução pega o valor de um registrador e coloca na memória
Formato da instrução
  • Nome da instrução (lw) seguido do registrador onde colocaremos o valor, e depois uma constante e mais um registrador contendo um endereço
  • Ex: Linguagem C
    • A é um vetor com 100 palavras (A[100]), cujo endereço inicial está armazenado em $s3
    • g e h são duas variáveis: {g,h} --> {$s1, $s2}
    • g = h + A[8];
  • Qual é o código de montagem correspondente ?
    • Carregar da memória o valor num registrador temporário
    • lw $t0, 32($s3)
      • lw é a instrução para carregar da memória no registrador
      • $t0 é o nome do registrador
      • Qual é o endereço de memória ? 32($s3)
      • $s3 é o endereço inicial do vetor (por exemplo, endereço 80)
      • 32 significa o deslocamento (em bytes) em relação a posição inicial (por exemplo, 80 + 32 = 112)
      • Por que 32 ? 32 = 8 * 4. O primeiro elemento de A está em 80. O segundo está 4 bytes adiante, ou seja, 84, o terceiro em 88, e assim por diante. Logo, o elemento A[8] esta na posição $s3 + 8 * 4.
      • No MIPS, existe restrição de alinhamento de memória, ou seja, todas as palavras devem inciar em posições de memória que são múltiplos de 4.
    • $s3 é chamado de endereço base (registrador base)
    • 32 = 8 * 4 é chamado de deslocamento (offset)
    • Após carregar em $t0 o valor de A[8], somar com h e colocar em g
      • $s1 = $s2 + $t0
A operação oposta de load word é store word, que pega o valor em um registrador e coloca num endereço de memória

  • Ex: Linguagem C
    • h --> $s2
    • endereço inicial de A --> $s3
    • A[12] = h + A[8];
  • Resposta
    • Carregar A[8]
      • lw $t0, 32($s3)
    • Somar com h e guardar num local temporário
      • add $t0, $s2, $t0
    • Guardar na memória, no elemento 12 do vetor A.
      • sw $t0, 48($s3)
      • Guardar o valor de $t0 no endereço $s3 + 48, ou seja, no elemento 12 de A (12*4)

Nenhum comentário: