ORGANIZAÇÃO E ARQUITETURA DE COMPUTADORES I …max.santana/material/aoc-i/Aula04-AOC-I.pdf · •RS é o registrador do primeiro operando de origem. •RT é o registrador do segundo

ORGANIZAÇÃO E ARQUITETURA DE COMPUTADORES I

AULA 04: ASPECTO BÁSICO DO PROJETO DE UMA

CPU SIMPLES E LINGUAGEM DE MONTAGEM

Prof. Max Santana Rolemberg Farias [email protected]

Colegiado de Engenharia de Computação

QUAIS OS COMPONENTES DE UMA CPU?

COMPONENTES DE UMA CPU

• Barramento

• Unidade de Controle

• Banco de registradores

• Unidade Lógica e Aritmética (ULA)

• Contador de Programa (PC)

• Registrador de Instrução (IR)

• Memória

COMPONENTES BÁSICOS DE UMA CPU

Pro

cessad

or

ARQUITETURA DE UMA CPU SIMPLES VISÃO ABSTRATA

Busca - Decodifica - Executa

Clock

• Controller (Unidade de controle)

– Responsável por controlar as operações do datapath.

• Datapath (Caminho de dados)

– Um conjunto de registradores • Os registradores alimentam as duas entrada da ULA.

– A ULA • A saída da ULA é conectada a um dos registradores.

– O barramento

DETALHE DO PROCESSADOR

• As memórias são endereçadas por byte (8 bits).

• Contudo as memórias são vistas como uma sequência de palavras de 32 bits. – Por isso os endereços de palavras devem ser múltiplos de 4.

• Existem dois tipos de sistemas para numeração dos bytes dentro da memória: – Big endian: Byte mais significante tem menor endereço da palavra.

– Little endian: Byte mais significante tem o maior endereço.

DETALHAMENTO MEMÓRIA

Valor da palavra (hexadecimal): 6151CE94

DETALHAMENTO MEMÓRIA BIG ENDIAN VS LITTLE ENDIAN

O QUE MAIS É PRECISO PARA PROJETAR UMA CPU?

• Definir o conjunto de registradores – Poucos registradores (menos significa mais rápido). – Mais de 32 registradores exigiria:

• Um ciclo de clock maior. • Formato de instruções maiores, para comportar mais bits de endereçamento.

• Definir os tipos e os formatos das instruções

– Instruções de tamanho fixo. – Poucos formatos de instruções. – Mais de três operandos por instruções exigiria um projeto de hardware mais complicado – Número reduzido de modo de endereçamento

• Definir o repertório de instruções

– Repertório de instruções limitados

PROJETO DE UMA CPU SIMPLES

Registradores Número Uso

$zero 0 Valor constante igual a zero.

$at 1 Assembler temporário.

$v0 - $v1 2 - 3 Retorno de função.

$a0 - $a3 4 - 7 Argumento de função.

$t0 - $t7 8 - 15 Variáveis temporárias, que não precisam ser salvas.

$s0 - $s7 16 – 23 Variáveis salvas por uma função chamada.

$t8 - $t9 24 - 25 Mais variáveis temporárias.

$k0 - $k1 26 - 27 Temporários para o sistema operacional

$gp 28 Apontador global.

$sp 29 Apontador de pilha.

$fp 30 Apontador de quadro.

$ra 31 Endereço de retorno.

PROJETO DE UMA CPU SIMPLES REGISTRADORES

Registradores Número Uso

$zero 0 Valor constante igual a zero.

$at 1 Assembler temporário.

$v0 - $v1 2 - 3 Retorno de função.

$a0 - $a3 4 - 7 Argumento de função.

$t0 - $t7 8 - 15 Variáveis temporárias, que não precisam ser salvas.

$s0 - $s7 16 – 23 Variáveis salvas por uma função chamada.

$t8 - $t9 24 - 25 Mais variáveis temporárias.

$k0 - $k1 26 - 27 Temporários para o sistema operacional

$gp 28 Apontador global.

$sp 29 Apontador de pilha.

$fp 30 Apontador de quadro.

$ra 31 Endereço de retorno.

• As instruções do programa assembly devem ser traduzidas em números binários para que a máquina as execute.

• Existem 3 tipos de instruções e formato (todos com 32 bits): – Instruções de processamento: Lógicas e Aritméticas. – Instruções de transferência de dados. – Instruções de decisão e controle: Desvio de fluxo.

– Formato R

– Formato I

– Formato J

PROJETO DE UMA CPU SIMPLES INSTRUÇÕES: TIPOS E FORMATOS

• OP é sempre zero para o formato R.

• RS é o registrador do primeiro operando de origem.

• RT é o registrador do segundo operando de origem.

• RD é o registrador que recebe o resultado da operação.

• SHAMT é a quantidade de deslocamento (shift amount).

• FUNCT especifica qual a operação a ser executada.

PROJETO DE UMA CPU SIMPLES INSTRUÇÕES: FORMATO R (REGISTRADOR)

• OP especifica qual operação a ser executada.

• RS é o registrador do operando de origem.

• RT é o registrador que recebe o resultado da operação.

• IMM é o endereço de memória ou constante numérica.

PROJETO DE UMA CPU SIMPLES INSTRUÇÕES: FORMATO I (IMEDIATO)

• OP especifica qual operação a ser executada.

• ADDR é o local da memória (endereço) a saltar, onde estão as próximas instruções a serem executadas.

PROJETO DE UMA CPU SIMPLES INSTRUÇÕES: FORMATO J (JUMP)

Instruções de processamento: Lógicas e aritméticas

PROJETO DE UMA CPU SIMPLES REPERTÓRIO INSTRUÇÕES

Instruções Descrição

ADD RD RS RT RD <- RS + RT

ADDI RT RS IMM RT <- RS + IMM

SUB RD RS RT RD <- RS – RT

AND RD RS RT RD <- RS AND RT

OR RD RS RT RD <- RS OR RT

ORI RT RS IMM RT <- RS OR IMM

XOR RD RS RT RD <- RS XOR RT

SLL* RD RT SHAMT RT <- RT << SHAMT

LUI RT IMM RT <- IMM << 16 * SLL de i bits é multiplicar por 2i.

Instruções de transferência de dados



LW RT OFFSET(RS) RT <- memória[OFFSET + RS]

SW RT OFFSET(RS) memória[OFFSET +RS] <- RT

OFFSET é em bytes

Instruções de decisão e controle: Desvio de fluxo

• Alteram o fluxo de controle do programa. • Alteram a próxima instrução a ser executada.

• Instruções para salto condicional

– Branch on equal (BEQ). – Branch on not equal (BNE). – Set on less than (SLT). – Set on less than immediate (SLTI).

• Instruções para salto incondicional

– Jump (J).


Instruções de decisão e controle: Desvio de fluxo



BEQ RS RT OFFSET Desvia se RS igual RT

BNE RS RT OFFSET Desvia se RS diferente de RT

SLT RD RS RT RD <- (RS < RT) ? 1 : 0

SLTI RT RS IMM RT <- (RS < IMM) ? 1 : 0

J OFFSET Desvio para OFFSET.

COMO ESCREVER UM PROGRAMA PARA ESSA CPU SIMPLES?

• Sintaxe de instruções em assembly

– Label: Opcional, identifica o bloco do programa.

– Op-code: Instrução, identificado por um Mnemônico.

– Operandos: Registradores ou memória.

– Comentários: Opcional, tudo que vem depois de #.

LINGUAGEM DE MONTAGEM ASSEMBLY

Adição


Linguagem de Alto Nível Linguagem de Montagem

a = b + c;

a = a + 4;

b = a – 12;

add $s0 $s1 $s2

addi $s0 $s0 4

addi $s1 $s0 -12

As variáveis a, b e c estão armazenadas, respectivamente, nos registradores $s0, $s1 e $s2.

Subtração



a = b - c;

sub $s0 $s1 $s2

As variáveis a, b e c estão armazenadas, respectivamente, nos registradores $s0, $s1 e $s2.

Operações Aritméticas Complexas



a = b + c - d;

sub $t0 $s2 $s3 # t0 = c – d

add $s0 $s1 $t0 # a = b + t0

As variáveis a, b, c e d estão armazenadas, respectivamente, nos registradores $s0, $s1, $s2 e $s3

Tomada de decisão



if (i == j)

f = g + h;

f = f – i;

0x00002000 bne $s3 $s4 0x00002008

0x00002004 add $s0 $s1 $s2

0x00002008 sub $s0 $s0 $s3

As variáveis f, g, h, i e j estão armazenadas, respectivamente, nos registradores $s0, $s1, $s2, $s3 e $s4

Tomada de decisão



if (i == j)

f = g + h;

else

f = f – i;

0x00002000 bne $s3 $s4 0x0000200C

0x00002004 add $s0 $s1 $s2

0x00002008 j 0x00002010

0x0000200C sub $s0 $s0 $s3

0x00002010 ...

As variáveis f, g, h, i e j estão armazenadas, respectivamente, nos registradores $s0, $s1, $s2, $s3 e $s4

Tomada de decisão



if (amount == 20)

fee = 2;

else if (amount == 50)

fee = 3;

else if (amount == 100)

fee = 5;

else

fee = 0;

0x00002000 addi $t0 $zero 20 0x00002004 bne $s0 $t0 0x00002010

0x00002008 add $s1 $zero 2

0x0000200C j 0x00002034

0x00002010 addi $t0 $zero 50 0x00002014 bne $s0 $t0 0x00002020

0x00002018 add $s1 $zero 3

0x0000201C j 0x00002034

0x00002020 addi $t0 $zero 100 0x00002024 bne $s0 100 0x00002030

0x00002028 add $s1 $zero 5

0x0000202C j 0x00002034

0x00002030 add $s1 $zero $zero

0x00002034 ..

As variáveis amount e fee estão armazenadas, respectivamente, nos registradores $s0, e $s1

Tomada de decisão



switch (amount) {

case 20: fee = 2;

break;

case 50: fee = 3;

break;

case 100: fee = 5;

break;

default: fee = 0;

}

0x00002000 addi $t0 $zero 20 # case 20

0x00002004 bne $s0 $t0 0x00002010

0x00002008 addi $s1 $zero 2 #

0x0000200C j 0x00002034

0x00002010 addi $t0 $zero 50 #case 50

0x00002014 bne $s0 $t0 0x00002020

0x00002018 addi $s1 $zero 3 #

0x0000201C j 0x00002034

0x00002020 addi $t0 $zero 100 #case 100

0x00002024 bne $s0 $t0 0x00002030

0x00002028 addi $s1 $zero 5 #

0x0000202C j 0x00002034

0x00002030 add $s1 $zero $zero #

0x00002034 ...

As variáveis amount e fee estão armazenadas, respectivamente, nos registradores $s0, e $s1

Repetição



int pow = 1;

int x = 0;

while (pow != 128) {

pow = pow * 2;

x = x + 1;

}

0x00002000 addi $s0 $zero 1 #pow=1

0x00002004 addi $s1 $zero 0 #x=0

0x00002008 addi $t0 $zero 128

0x0000200C beq $s0 $to 0x0000201C

0x00002010 sll $s0 $s0 1 #pow=pow*2

0x00002014 addi $s1 $s1 1 #x=x+1

0x00002018 j 0x0000200C

0x0000201C ...

As variáveis pow e x estão armazenadas, respectivamente, nos registradores $s0 e $s1

Repetição



int sum = 0;

for (i = 0; i != 10; i = i + 1) {

sum = sum + i;

}

0x00002000 add $s1 $zero $zero

0x00002004 addi $s0 $zero 0

0x00002008 addi $t0 $zero 10

0x0000200C beq $s0 $to 0x0000201C

0x00002010 add $s1 #s1 #s0

0x00002014 addi $s0 $s0 1

0x00002018 j 0x0000200C

0x0000201C ...

As variáveis i e sum estão armazenadas, respectivamente, nos registradores $s0 e $s1

Array



int array[5];

array[0] = array[0] * 8;

array[1] = array[1] * 8;

0x00002000 lui $s0 0x1000

0x00002004 ori $s0 $s0 0x7000 #s0=0x10007000

0x00002008 lw $t1 0($s0) #t1=array[0]

0x0000200C sll $t1 $t1 3 #t1=t1*8

0x00002010 sw $t1 0($s0) #array[0]=t1

0x00002014 lw $t1 4($s0) #t1=array[1]

0x00002018 sll $t1 $t1 3 #t1=t1*8

0x0000201C sw $t1 0($s0) #array[0]=t1

O endereço base do array é armazenado no registrador $s0.

Array



int i;

int array[5];

for(i = 0; i < 1000; i = i + 1)

array[i] = array[i] * 8;

0x00002000 lui $s0 0x23B8

0x00002004 ori $s0 $s0 0xF000 #s0=0x23B8F000

0x00002008 addi $s1 $zero 0 #i=0

0x0000200C addi $t2 $zero 1000 #t2=1000

0x00002010 slt $t0 $s1 $t2 #i<1000

0x00002014 beq $t0 $zero 0x0002034

0x00002018 sll $t0 $s1 2 #t0=i*4 (offset)

0x0000201C add $t0 $t0 $s0 #endereço do array[i]

0x00002020 lw $t1 0($t0) #t1=array[i]

0x00002024 sll $t1 $t1 3 #t1=array[i]*8

0x00002028 sw $t1 0($t0) #array[i]=array[i]*8

0x0000202C addi $s1 $s1 1 #i=i+1

0x00002030 j 0x0002010

0x00002034 ...

O endereço base do array é armazenado em $s0 e a variável i em $s1.

COMO AS INSTRUÇÕES SÃO REPRESENTADA NA CPU?

REPRESENTAÇÃO DAS INSTRUÇÕES DO FORMATO REGISTRADOR (R)

Assembly Opcode RS RT RD Shamt Funct Linguagem de Máquina

add $s0 $s1 $s2 0x0 17 18 16 0x0 0x20 0000 0010 0011 0010 1000 0000 0010 0000 (0x02328020)

sub $s0 $s1 $s2 0x0 17 18 16 0x0 0x22 0000 0010 0011 0010 1000 0000 0010 0010 (0x02328022)

and $s3 $s1 $s2 0x0 19 18 16 0x0 0x24 0000 0010 0111 0010 1000 0000 0010 0100 (0x02728024)

or $t0 $t1 $t2 0x0 9 10 8 0x0 0x15 0000 0001 0010 1010 0100 0000 0010 0101 (0x012A4025)

xor $t0 $t1 $t2 0x0 9 10 8 0x0 0x26 0000 0001 0010 1010 0100 0000 0010 0110 (0x012A4026)

sll $s0 $s0 1 0x0 0 16 16 0x1 0x0 0000 0000 0001 0000 1000 0000 0100 0000 (0x00108040)

slt $t0 $s1 $t2 0x0 17 10 8 0x0 0x2A 0000 0010 0010 1010 0100 0000 0010 1010 (0x022A402A)

REPRESENTAÇÃO DAS INSTRUÇÕES DO FORMATO IMEDIATO (I)

Assembly Opcode RS RT IMM Linguagem de Máquina

addI $t0 $zero 1000 0x8 0 8 0x03E8 0010 0000 00001000 1000 0000 0010 0000 (0x20088020)

ori $s0 $s0 0xF000 0xD 16 16 0xF000 0011 0110 0001 0000 1000 0000 0010 0010 (0x36108022)

lui $s0 0x23B8 0xF 0 16 ox23B8 0011 1100 0001 0000 1000 0000 0010 0100 (0x3C108024)

sltI $t0 $t1 1000 0xA 9 8 ox03E8 0010 1001 0010 1000 0100 0000 0010 0101 (0x29284025)

REPRESENTAÇÃO DAS INSTRUÇÕES DO FORMATO JUMP (J)

Assembly Opcode IMM Linguagem de Máquina

j 0x200C 0x2 0x200C 0000 1000 0000 0000 0010 0000 0000 1100 (0x0800200C)

Documents

ORGANIZAÇÃO E ARQUITETURA DE COMPUTADORES I …max.santana/material/aoc-i/Aula04-AOC-I.pdf · •RS é o registrador do primeiro operando de origem. •RT é o registrador do segundo