Sistemas Processadores e Periféricos Aula 6 - Revisão

Sistemas Processadores e Periféricos Aula 6 - Revisão Prof. Frank Sill Torres DELT Escola de Engenharia UFMG Adaptado a partir dos Slides de Organização de Computadores 2006/02 do professor Leandro Galvão DCC/UFAM - galvao@dcc.ufam.edu.br 1

Implementação de Instruções no Processador Arquitetura tipo Ciclo Único Cada instrução é executada em um 1 ciclo de clock Ciclo de clock deve ser longo o suficiente para executar a instrução mais longa Desvantagem: velocidade global limitada à velocidade da instrução mais lenta T clock T add T srl T div 2

Implementação de Instruções no Processador Arquitetura tipo Multi-ciclo Quebra o ciclo de execução em vários passos Executa cada passo em um ciclo de clock Vantagem: cada instrução usa apenas o número de ciclos que ela necessita T clock T add T srl T div 3

Implementação de ciclo único :: Tipo R 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 IR op rs rt rd shamt funct Dados de escrita 5 5 5 Banco de Registradores RegWrite Dados de leitura

Implementação de ciclo único :: Tipo R + Load/Store + Desvios OrigPC PC 4 Read address Add Instruction Memória de instruções $t0 = $t1 Rs Rt Rd M U X Read register 1 Read register 2 RegDst RegWrite Read data 1 Write register Read data 2 Write Banco de dataregistradores 16 Sign 32 extend Shift left 2 OrigALU M U X Add ALU result 4 opalu Zero ALU ALU result M U X MemWrite Address Memória de Write dados data MemRead Read data MemtoReg M U X beq $t0,$t1,label

Implementação de ciclo único :: Unidade de controle principal Instruction [25 0] Shift Jump address [31 0] left 2 26 28 PC+4 [31 28] 0 M ux 1 M ux 4 Add Instruction [31 26] Control RegDst Jump Branch MemRead MemtoReg ALUOp MemWrite OrigALU RegWrite Shift left 2 Add ALU result 1 0 PC Read address Instruction memory Instruction [31 0] Instruction [25 21] Instruction [20 16] Instruction [15 11] 0 M ux 1 Read register 1 Read register 2 Registers Write register Write data Read data 1 Read data 2 0 M ux 1 Zero ALU ALU result Address Write data Data memory Read data 1 M ux 0 Instruction [15 0] 16 Sign 32 extend ALU control Instruction [5 0]

Implementação de ciclo único :: Unidade de controle principal Entrada opcode na unidade de controle Saídas da unidade de controle Opcode 0 h 23 h 2B h 4 h Nome R Lw Sw Beq Bit31 0 1 1 0 Bit30 0 0 0 0 Bit29 0 0 1 0 Bit28 0 0 0 1 Bit27 0 1 1 0 Bit26 0 1 1 0 RegDst 0 1 X X OrigALU 1 0 0 1 MemtoReg 0 1 X X RegWrite 1 1 0 0 MemRead 0 1 0 0 MemWrite 0 0 1 0 Branch 0 0 0 1 ALUop1 1 0 0 0 ALUop0 0 0 0 1 7

Implementação de multi-ciclo :: Inclusão de MUX e registradores 0 1 M ux PC 0 M ux Addres s Ins truction [25 21] Read register 1 0 M ux 2 1 Write data Me mory MemDa ta Ins truction [20 16] Ins truction [15 0] Ins truction regis ter Ins truction [15 0] Ins truction [15 11] 0 M u x 1 0 M ux Read register 2 Registers Write register Write data Read data 1 Read data 2 A B 4 1 0 1 M ux 2 3 Zero ALU ALU result ALUOut Me mory data register 1 16 Sign extend 32 Shift le ft 2 8

Sistemas Processadores e Periféricos Aula 7 - Via de Dados e Controle II (cap. 5) Prof. Frank Sill Torres DELT Escola de Engenharia UFMG Adaptado a partir dos Slides de Organização de Computadores 2006/02 do professor Leandro Galvão DCC/UFAM - galvao@dcc.ufam.edu.br 9

Dividindo Instruções em Estágios :: Linhas de controle As unidades de estado visíveis ao programador (PC, memória, banco de registradores) e IR precisarão de sinais de controle de escrita Memória precisará de um sinal de leitura 10

Dividindo Instruções em Estágios :: Linhas de controle PC 0 M u x 1 Address Write data Memory MemData Instruction [25 21] Instruction [20 16] Instruction [15 0] Instruction register Instruction [15 0] Memory data register PCWriteCond PCWrite IorD MemRead MemWrite MemtoReg IRWrite Instruction [15 11] Outputs Control Op [5 0] 0 M u x 1 0 M u x 1 PCSource ALUOp ALUSrcB OrigALUB OrigALUA ALUSrcA RegDst 16 RegWrite Instruction [25 0] 26 Shift 28 left 2 Instruction [31-26] PC [31-28] Read register 1 Read register 2 Registers Write register Write data Sign extend Read data 1 Read data 2 32 Shift left 2 A B 4 0 M u x 1 0 1 M u 2 x 3 ALU control Zero ALU ALU result Jump address [31-0] ALUOut 0 1 2 M u x Instruction [5 0] 11

Dividindo Instruções em Estágios :: Linhas de controle Sinal de Controle RegDst Efeito quando inativo (zero) O registrador de destino é indicado no campo Rt (bits 20:16) Efeito quando ativo (um) O registrador de destino é indicado no campo Rd (bits 15:11) RegWrite Nenhum O registrador destino é escrito com o valor da entrada Write data OrigALUA Primeiro operando da ALU é o PC MemRead Nenhum MemWrite Nenhum Primeiro operando da ALU vem do registrador A O conteúdo da posição de memória endereçada é colocado nas saídas O conteúdo da posição de memória endereçada é reescrito 12

Dividindo Instruções em Estágios :: Linhas de controle Sinal de Controle MemtoReg IouD Efeito quando inativo (zero) O valor a escrever no registrador vem de ALUOut PC é usado para fornecer o endereço para a unidade de memória Efeito quando ativo (um) O valor a escrever no registrador é lido da memória de dados ALUOut é usado para fornecer endereço para unidade de memória IR Write Nenhum Saída da memória é escrita no IR WritePC WritePCCond Nenhum Nenhum PC é escrito; a origem é controlada por OrigPC PC é escrito se a saída Zero da ALU também estiver ativa 13

Dividindo Instruções em Estágios :: Linhas de controle Sinal de Controle Valor (binário) Efeito ALUOp 00 ALU realiza adição 01 ALU realiza subtração 10 Campo funct determina operação da ALU 00 Segunda entrada da ALU vem do registrador B 01 Segunda entrada da ALU é a constante 4 OrigALUB 10 11 Segunda entrada da ALU são os 16 bits menos significativos de IR com sinal estendido Segunda entrada da ALU são os 16 bits menos significativos de IR com sinal estendido, deslocados de 2 bits para a esquerda

Dividindo Instruções em Estágios :: Linhas de controle Sinal de Controle Valor (binário) Efeito 00 Saída da ALU (PC + 4) é escrita em PC PCSource 01 ALUOut é escrito em PC (desvios) 10 Endereço de destino do jump, deslocado de 2 bits à esquerda e concatenado com os 4 bits mais significativos de de PC + 4 é escrito em PC 15

Estágio 1 Instruction Fetch (IF) Usa o registrador Program Counter (PC) para ler a instrução da memória e armazená-la no Registrador de Instrução (IR) Incrementa PC em 4 e coloca o resultado de volta em PC IR = *PC; // IR = valor que esta // armazenado no endereço // que o PC indica PC = PC + 4; 16

Estágio 1: IF IR = *PC PC = PC + 4 I R Instruction I 5 5 5 Operation PC PC + 4 MemWrite ADDR Memory WD MemRead RD M DR RN1 RN2 WN Registers WD RegWrite RD1 RD2 A B 4 3 ALU Zero ALU OUT Carga de Instrução 17

Estágio 2 Instruction Decode (ID) Lê os campos correspondentes aos registradores rs e rt, independentemente do tipo de instrução Os valores lidos são colocados nos registradores temporários A e B Computa o endereço de desvio, considerando que a instrução possa ser um branch A = Reg[IR[25-21]]; B = Reg[IR[20-16]]; ALUOut = PC + (sign-extend(ir[15-0]) << 2); 18

Estágio 2 Instruction Decode (ID) A = Reg[IR[25-21]]; (A = Reg[rs]) B = Reg[IR[20-15]]; (B = Reg[rt]) ALUOut = (PC + sign-extend(ir[15-0]) << 2) PC PC + 4 MemWrite ADDR Memory WD MemRead RD I R M DR Instruction I 5 5 5 RN1 RN2 WN Registers WD RegWrite RD1 RD2 Reg[rs] A B Reg[rt] Operation 3 ALU Zero Branch Target Address ALU OUT Decodificação de Instrução e Carga de Registrador 19

Estágio 3 Execution (EX) A ALU executará uma das quatro funções abaixo, dependendo do tipo da instrução: Referência à memória (para load/store): ALUOut = A + sign-extend(ir[15-0]); Tipo R ALUOut = A op B; Branch: if (A==B) PC = ALUOut; Jump: PC = PC[31-28] concat (IR(25-0) << 2) 20

Estágio 3:EX Instruções de acesso à memória ALUOut = A + sign-extend(ir[15-0]); PC PC + 4 MemWrite ADDR Memory WD MemRead RD I R M D R Instruction I 5 5 5 RN1 RN2 WN Registers WD RegWrite RD1 RD2 Reg[rs] A B Reg[rt] Operation 3 ALU Zero Mem. Address ALU OUT 21

Estágio 3: EX Instrucões tipo R ALUOut = A op B PC PC + 4 MemWrite ADDR Memory WD MemRead RD I R M DR Instruction I 5 5 5 RN1 RN2 WN Registers WD RegWrite RD1 RD2 Reg[rs] A B Reg[rt] Operation 3 ALU Zero R-Type Result ALU OUT 22

Estágio 3: EX Branch if (A == B) PC = ALUOut; PC Branch Target Address MemWrite ADDR Memory WD MemRead RD I R M D R Instruction I 5 5 5 RN1 RN2 WN Registers WD RegWrite RD1 RD2 Reg[rs] A B Reg[rt] Operation 3 ALU Zero Branch Target Address ALU OUT 23

Estágio 3: EX Jump PC = PC[31-28] concat (IR[25-0] << 2) PC Jump Address MemWrite ADDR Memory WD MemRead RD I R M D R Instruction I 5 5 5 RN1 RN2 WN Registers WD RegWrite RD1 RD2 Reg[rs] A B Reg[rt] Operation 3 ALU Zero Branch Target Address ALU OUT 24

Estágio 4 Acesso à memória (MEM) Instruções de acesso à memória: Load: Dados são lidos na memória e escritos no registrador de dados da memória (MDR) MDR = Memory[ALUOut]; Store: Dados são escritos na memória Memory[ALUOut] = B; Instruções do tipo R: A saída da ALU é escrita no registrador de destino Reg[IR[15-11]] = ALUOut; 25

Estágio 4: MEM Leitura de memória (lw) MDR = Memory[ALUOut]; PC PC + 4 MemWrite ADDR Memory WD MemRead RD I R M DR Mem. Data Instruction I WD 5 5 RN1 RN2 WN RD1 Registers RegWrite 5 RD2 Reg[rs] A B Reg[rt] Operation 3 ALU Zero Mem. Address ALU OUT 26

Estágio 4: MEM Escrita de memória (sw) Memory[ALUOut] = B; PC PC + 4 MemWrite ADDR Memory WD MemRead RD I R M DR Instruction I 5 5 5 RN1 RN2 WN Registers WD RegWrite RD1 RD2 Reg[rs] A B Reg[rt] Operation 3 ALU Zero ALU OUT 27

Estágio 4: MEM Instruções de Tipo R Reg[IR[15:11]] = ALUOUT PC PC + 4 MemWrite ADDR Memory WD MemRead RD I R M D R Instruction I 5 5 5 RN1 RN2 WN Registers WD RegWrite RD1 RD2 Reg[rs] A B Reg[rt] Operation 3 ALU Zero R-Type Result ALU OUT 28

Estágio 5 Write Back (WB) Depende do tipo de instrução Load: Escrita no registrador: Reg[IR[20-16]]= MDR; Estágio final 29

Estágio 5: WB Finalização de leitura de memória (lw) Reg[IR[20-16]] = MDR; PC PC + 4 MemWrite ADDR Memory WD MemRead RD I R M DR Mem. Data Instruction I WD 5 5 RN1 RN2 WN RD1 Registers RegWrite 5 RD2 Reg[rs] A B Reg[rt] Operation 3 ALU Zero Mem. Address ALU OUT 30

Resumo Multi-ciclo Estágio Ação Tipo R Action Memória Ação Branch Ação Jump Carga de Instrução (IF) IR = Memory[PC] PC = PC + 4 Decodificação Instrução A = Reg [IR[25-21]] Carga de Registrador B = Reg [IR[20-16]] (ID) ALUOut = PC + (sign-extend (IR[15-0]) << 2) Execução (EX) ALUOut = A op B ALUOut = A + sign-extend if (A ==B) then PC = PC [31-28] II Computo de Endereço (IR[15-0]) PC = ALUOut (IR[25-0]<<2) Finalização branch/jump Acesso à memória Reg [IR[15-11]] = Load: MDR = Memory[ALUOut] Finalização tipo R (MEM) ALUOut or Store: Memory [ALUOut] = B Finalização Leitura Mem. (WB) Tipo de instrução Load: Reg[IR[20-16]] = MDR 31

Resumo Multi-ciclo Instruções MIPS levam de 3 a 5 etapas de execução As duas primeiras etapas (IF e ID) são comuns a todas instruções As células vazias na tabela indicam que a classe de instruções representada pela coluna leva menos ciclos No hardware multi-ciclo, esses ciclos não ficam ociosos, pois uma instrução é executada logo após a anterior 32

Implementando Controle Os valores dos sinais de controle são dependentes de: Quais funções estão sendo executadas Quais estágios estão ocorrendo Baseado nos sinais de controle especificados, duas abordagens podem ser usadas para gerar os sinais de controle: 1) Especificar um máquina de estados finitos graficamente 2) Usar microprogramação 33

Máquina de Estados Finitos (FSM) Finite State Machine (FSM) Um conjunto de estados Uma função que computa o próximo estado Determinada pelo estado atual e pela entrada Uma função de saída Determinada pelo estado corrente e possivelmente pela entrada No nosso caso, usaremos uma máquina de Moore A função de saída é usada somente pelo estado corrente 34

Máquinas de Estados Finitos (FSM) Estado atual Função para o próximo estado Próximo estado Entradas Clock Função de saída Saídas 35

Máquinas de Estados Finitos (FSM) :: Visão Geral Início Busca/decodificação da instrução e busca dos registradores Instruções de acesso à memória Instruções tipo R Instruções de branch Instruções de jump 36

Máquinas de Estados Finitos (FSM) :: Visão Geral Fig. 5.32 Start 0 MemRe ad OrigALUA= 0 Io rd = 0 IR Write OrigALUB = 01 ALUOp = 00 PCWrite PCSource = 00 Instruction fetch Instruction decode/ Register fetch 1 OrigALUA = 0 OrigALUB = 11 ALUOp = 00 (Op = 'JMP') Me m ory re fe re nce FS M (Figure 5.33) R-type FSM (Figure 5.34) Branch FSM (Figure 5.35 ) Jump FSM (Figure 5.36 ) Busca de instrução e decodificação são identicos para todas as instruções Sinais gerados são mostrados dentro dos círculos dos estados 37

FSM Acesso à Memória Fig. 5.33 2 3 From state 1 OrigALUA =1 OrigALUB =10 ALUO p = 00 (Op = 'LW') (O p = 'LW ') o r (O p = 'S W ') Me m o ry a ddre s s c o m puta tio n Me mo ry access 5 Me mory access Me m Re a d Io rd = 1 Mem Write Io rd = 1 4 Write-backstep RegWrite MemtoReg = 1 RegDst = 0 To state 0 (Figure 5.32) 38

FSM Instruções Tipo R Fig. 5.34 6 From state 1 (Op = R-type ) Execution OrigALUA=1 OrigALUB=00 ALUOp = 10 7 RegDst = 1 RegWrite Me mtore g = 0 R-type completion To state 0 (Figure 5.32) 39

FSM Instruções Branch Fig. 5.35 From state 1 (Op = 'BEQ') 8 OrigALUA =1 OrigALUB=00 ALUOp = 01 PCWriteCond PCSource = 01 Branch comple tion To state 0 (Figure 5.32) 40

FSM Instruções Jump Fig. 5.36 From state 1 (Op = 'J ') 9 Jump comple tion PCWrite PCSource = 10 To state 0 (Figure 5.32) 41

FSM Controle Start IF Instruction fetch 0 MemRe ad OrigALUA=0 Io rd = 0 IR Write OrigALUB =01 ALUO p = 00 PCWrite PCSource = 00 ID In s truc tion de cod e / re gis ter fe tch 1 OrigALUA =0 OrigALUB =11 ALUO p = 00 Fig. 5.38 EX 2 Me mory addres s computation OrigALUA =1 OrigALUB =10 ALUOp = 00 6 Execution OrigALUA =1 OrigALUB =00 ALUO p = 10 8 Bra nch completion OrigALUA =1 OrigALUB =00 ALUO p = 01 PCWriteCond PCSource = 01 9 (Op = 'J') Jump completion PCWrite PCSource = 10 MEM 3 (Op = 'LW') Me m R e a d IorD = 1 Me mory access 5 MemWrite Io rd = 1 Me mory access 7 RegDst = 1 RegWrite Me mtore g = 0 R-type comple tion WB 4 RegDst=0 RegWrite MemtoReg = 1 Write-back step 42

FSM Implementação PCWrite PCWriteCond IorD MemRead Entradas Estado corrente Bits de Opcode da instrução Control logic Outputs MemWrite IRWrite MemtoReg PCSource ALUOp OrigALUB ALUSrcB OrigALUA ALUSrcA RegWrite RegDst Saídas Próximo estado Sinais a serem gerados para o estado corrente Op5 Op4 Op3 Op2 Op1 Instruction register opcode field Inputs Op0 S3 S2 S1 S0 State register NS3 NS2 NS1 NS0 4 bits de estado p/ gerar 10 estados 43

FSM Implementação usando PLA PLA (Programmable Logic Array) Formato básico de uma PLA 44

FSM Implementação usando PLA Exemplo da implementação de um função lógica em uma PLA 45

FSM Implementação usando PLA OR dos AND AND dos Opcodes e Estado Corrente 46

FSM Implementação usando ROM ROM (Read Only Memory) Valores das posições de memória são fixos Vantagem: Ser capaz de implementar qualquer função lógica com o seu número de entradas Uma ROM pode ser usada para implementar uma tabela verdade Com m bits, é possível endereçar 2 m entradas das ROM A saída da ROM são os bits armazenados na entrada endereçada m ROM n 47

FSM Implementação usando ROM Quantos entradas? 6 Bits para opcode, 4 bits para estado = 10 linhas de endereço ( i.e. 2 10 = 1024 endereços diferentes) Quantos saídas? 16 saídas de controle de via dos dados 4 bits para o estado 20 saídas Tamanho do ROM é 2 10 x 20 = 20k bits Devastador, porque para muitos entradas as saídas são as mesmas 48

FSM Implementação PLA vs. ROM Melhoramento do tamanho de ROM: Os 4 bits do estado geram as 16 bits de saída de controle (= 2 4 x 16 Bits) 10 Bits para definir o novo estado ( = 2 10 x 4 Bits) = 4.3k Bits de ROM PLA é bem menor Pode compartilhar os termos-produto Só precisa de entradas que produzem saídas ativa Tamanho: (10x16) + (20x16) = 480 células de PLA 49

Exemplo: CPI em uma CPU multi-ciclo Assuma um mix de instruções com: Instrução % No. de ciclos Load 22 5 Store 11 4 Tipo R 49 4 Branch 16 3 Jump 2 3 Qual CPI (ciclos de clock por instrução), assumindo que cada estágio toma um ciclo de clock? 50

Exemplo: CPI em uma CPU multi-ciclo Solução: CPI total N N CPI instr, i i i 1 N Ninstr, i N instr, total N i 1 instr, total CPI i 0,22 5 0,11 4 0,49 4 0,16 3 0,02 3 4,04

Pipeline (capítulo 6) Adaptado a partir dos Slides de Organização de Computadores 2006/02 do professores Leandro Galvão (DCC/UFAM galvao@dcc.ufam.edu.br) 52 e o Ricardo de Oliveira Duarte (DELT/UFMG)

Exemplo da Lavanderia 4 pessoas (A, B, C, D) possuem sacolas de roupa para lavar, secar e dobrar A B C D Lavar leva 30 minutos Secar leva 40 minutos Dobrar leva 20 minutos 53

Exemplo da Lavanderia 6 7 8 9 10 11 Meia-noite Tempo T a r e f a s A B C D 30 40 20 30 40 20 30 40 20 30 40 20 Lavanderia sequencial leva 6 horas para terminar Se eles conhecessem computação, quanto tempo levaria? 54

Exemplo da Lavanderia 6 7 8 9 10 11 Meia-noite Tempo T a r e f a s A B C 30 40 40 40 40 40 D Lavanderia com pipelining leva 3,5 horas 55

Pipeline :: Definição Pipeline é uma técnica de implementação de processadores que permite a sobreposição temporal de diversas fases de execução de instruções Em outras palavras, o hardware processa mais de uma instrução de cada vez, sem esperar que uma instrução termine antes de começar a outra 56

Pipeline :: Características Pipeline não melhora a latência de uma única tarefa, mas melhora o throughput de todo trabalho Tempo de execução de uma tarefa é o mesmo, com ou sem pipelining Ganho começa a existir apartirda segunda tarefa Taxa de inserção de tarefas é limitada pela tarefa mais lenta Pipeline explora o paralelismo entre as instruções em um fluxo de instruções sequenciais É uma técnica invisível ao programador, ao contrário de técnicas de multiprocessadores 57

Ganho de desempenho com Pipelining Supondo: N instruções K estágios de duração T Tempo de execução sem pipelining: N K T N K Tempo de execução com pipelining: K T + (N 1) T N K T 58

Ganho de desempenho com Pipelining Ganho de desempenho: NKT 1 KT ( N 1) T 1 N 1 N NK No limite (Número de instruções N ): Ganho K (número de estágios) 59

Ganho de desempenho com Pipelining :: Monociclo Multiciclo Pipeline T clock Pipeline 1 2 3 4 5 6 Multiciclo 1 2 3 4 5 6 Monociclo 1 2 3 4 5 6 Tempo de execução (T exec ) 60

Ganho de desempenho com Pipelining Contudo: Estágios não são perfeitamente balanceados para durarem a mesma quantidade de tempo T Cada estágio possui um overhead de tempo em decorrência do pipelining Portanto: O tempo de execução de cada estágio no processador com pipeline será maior que no computador sem pipeline O ganho será um pouco menor que o número K de estágios 61

Processador RISC de cinco estágios Cinco estágios de execução de cada instrução: IF Busca (fetch) da instrução ID Decodificação da instrução EX Execução ou cálculo do endereço efetivo MEM Acesso à memória ou desvio WB Atualização dos registradores (write back) Cada fase de uma instrução é processada por um estágio, em um ciclo de clock Uma nova instrução é iniciada a cada ciclo Ciclo de clock Instrução 1 2 3 4 5 6 7 8 9 i IF ID EX MEM WB i+1 IF ID EX MEM WB i+2 IF ID EX MEM WB i+3 IF ID EX MEM WB i+4 IF ID EX MEM WB 62

Processador RISC de cinco estágios Durante um mesmo ciclo de clock, temos de garantir que não ocorram duas operações com os mesmos componentes do caminho de dados: Utiliza se uma memória cache de dados (DM) separada da memória cache de instruções (IM) O banco de registradores é utilizado duas vezes: Estágio ID para leitura, na 2ª. metade do ciclo de clock Estágio WB para escrita, na 1ª. metade do ciclo de clock 63

Processador RISC de cinco estágios PC é incrementado e armazenado a cada ciclo, durante a fase IF Como tratar desvios? Registradores são inseridos entre cada estágio do pipeline para: Garantir que operações em diferentes estágios do pipeline não interfiram uma nas outras Carregar resultados intermediários entre estágios não adjacentes Tais registradores recebem nomes especiais, que é a junção dos nomes dos estágios que interfaceiam: IF/ID ID/EX EX/MEM MEM/WB 64

Processador RISC de cinco estágios IF/ID ID/EX EX/MEM MEM/WB 65

Execução de um load em pipeline (IF) 66

Execução de um load em pipeline (ID) 67

Execução de um load em pipeline (EX) 68

Execução de um load em pipeline (MEM) 69

Execução de um load em pipeline (WB) 70

Execução de um load em pipeline :: correção O número do registrador a ser escrito somente é utilizado no estágio WB 71

O que vocês aprenderam hoje? Controle da arquitetura tipo multi-ciclo Linhas de controle Estágios Máquinas de estados Finitos (FSM) Cálculo do CPI Básicos da arquitetura tipo pipeline 72

Questão Defina todos os passos necessários para as instruções seguintes quando eles forem executados em uma arquitetura MIPS multi ciclo: j label3 lw $s3, 12($t0), beq $t2, $t4, $t1, sub $s1, $s2, $s3. j label3 lw $s3, 12($t0) beq $t2, $t4, $t1 sub $s1, $s2, $s3 IF, ID, EX IF, ID, EX, MEM, WB IF, ID, EX IF, ID, EX, MEM 73