ORGANIZAÇÃO E ARQUITETURA DE COMPUTADORES I

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 max.santana@univasf.edu.br Colegiado de Engenharia de Computação

QUAIS OS COMPONENTES DE UMA CPU?

COMPONENTES DE UMA CPU

COMPONENTES BÁSICOS DE UMA CPU Barramento Unidade de Controle Banco de registradores Unidade Lógica e Aritmética (ULA) Contador de Programa (PC) Processador Registrador de Instrução (IR) Memória

ARQUITETURA DE UMA CPU SIMPLES VISÃO ABSTRATA Clock Busca - Decodifica - Executa

DETALHE DO PROCESSADOR 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

DETALHAMENTO MEMÓRIA 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 BIG ENDIAN VS LITTLE ENDIAN Valor da palavra (hexadecimal): 6151CE94

O QUE MAIS É PRECISO PARA PROJETAR UMA CPU?

PROJETO DE UMA CPU SIMPLES 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 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 INSTRUÇÕES: TIPOS E FORMATOS 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: FORMATO R (REGISTRADOR) 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 I (IMEDIATO) 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 J (JUMP) 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 REPERTÓRIO INSTRUÇÕES Instruções de processamento: Lógicas e aritméticas 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 2 i.

PROJETO DE UMA CPU SIMPLES REPERTÓRIO INSTRUÇÕES Instruções de transferência de dados Instruções LW RT OFFSET(RS) SW RT OFFSET(RS) Descrição RT <- memória[offset + RS] memória[offset +RS] <- RT OFFSET é em bytes

PROJETO DE UMA CPU SIMPLES REPERTÓRIO INSTRUÇÕES 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).

PROJETO DE UMA CPU SIMPLES REPERTÓRIO INSTRUÇÕES Instruções de decisão e controle: Desvio de fluxo Instruções Descrição 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?

LINGUAGEM DE MONTAGEM ASSEMBLY 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 As variáveis a, b e c estão armazenadas, respectivamente, nos registradores $s0, $s1 e $s2. Linguagem de Alto Nível a = b + c; a = a + 4; b = a 12; Linguagem de Montagem add $s0 $s1 $s2 addi $s0 $s0 4 addi $s1 $s0-12

LINGUAGEM DE MONTAGEM ASSEMBLY Subtração As variáveis a, b e c estão armazenadas, respectivamente, nos registradores $s0, $s1 e $s2. Linguagem de Alto Nível Linguagem de Montagem a = b - c; sub $s0 $s1 $s2

LINGUAGEM DE MONTAGEM ASSEMBLY Operações Aritméticas Complexas As variáveis a, b, c e d estão armazenadas, respectivamente, nos registradores $s0, $s1, $s2 e $s3 Linguagem de Alto Nível a = b + c - d; Linguagem de Montagem sub $t0 $s2 $s3 # t0 = c d add $s0 $s1 $t0 # a = b + t0

LINGUAGEM DE MONTAGEM ASSEMBLY Tomada de decisão As variáveis f, g, h, i e j estão armazenadas, respectivamente, nos registradores $s0, $s1, $s2, $s3 e $s4 if (i == j) f = g + h; f = f i; Linguagem de Alto Nível Linguagem de Montagem 0x00002000 bne $s3 $s4 0x00002008 0x00002004 add $s0 $s1 $s2 0x00002008 sub $s0 $s0 $s3

LINGUAGEM DE MONTAGEM ASSEMBLY Tomada de decisão As variáveis f, g, h, i e j estão armazenadas, respectivamente, nos registradores $s0, $s1, $s2, $s3 e $s4 if (i == j) f = g + h; else f = f i; Linguagem de Alto Nível Linguagem de Montagem 0x00002000 bne $s3 $s4 0x0000200C 0x00002004 add $s0 $s1 $s2 0x00002008 j 0x00002010 0x0000200C sub $s0 $s0 $s3 0x00002010...

LINGUAGEM DE MONTAGEM ASSEMBLY Tomada de decisão As variáveis amount e fee estão armazenadas, respectivamente, nos registradores $s0, e $s1 Linguagem de Alto Nível Linguagem de Montagem 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..

LINGUAGEM DE MONTAGEM ASSEMBLY Tomada de decisão As variáveis amount e fee estão armazenadas, respectivamente, nos registradores $s0, e $s1 Linguagem de Alto Nível switch (amount) { case 20: fee = 2; break; case 50: fee = 3; break; case 100: fee = 5; break; default: fee = 0; } Linguagem de Montagem 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...

LINGUAGEM DE MONTAGEM ASSEMBLY Repetição As variáveis pow e x estão armazenadas, respectivamente, nos registradores $s0 e $s1 int pow = 1; int x = 0; Linguagem de Alto Nível while (pow!= 128) { pow = pow * 2; x = x + 1; } Linguagem de Montagem 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...

LINGUAGEM DE MONTAGEM ASSEMBLY Repetição As variáveis i e sum estão armazenadas, respectivamente, nos registradores $s0 e $s1 Linguagem de Alto Nível int sum = 0; for (i = 0; i!= 10; i = i + 1) { sum = sum + i; } Linguagem de Montagem 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...

LINGUAGEM DE MONTAGEM ASSEMBLY Array O endereço base do array é armazenado no registrador $s0. Linguagem de Alto Nível int array[5]; array[0] = array[0] * 8; array[1] = array[1] * 8; Linguagem de Montagem 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

LINGUAGEM DE MONTAGEM ASSEMBLY Array O endereço base do array é armazenado em $s0 e a variável i em $s1. Linguagem de Alto Nível int i; int array[5]; for(i = 0; i < 1000; i = i + 1) array[i] = array[i] * 8; Linguagem de Montagem 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...

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)