path do IPS IPS Implementação Vamos examinar uma implementação que inclui um subconjunto de instruções do IPS Instruções de leitura (load lw) e de escrita (store sw) Instruções aritméticas e lógicas add, sub, and, or, slt Instruções de salto se igual (beq) e de salto incondicional (j) 1
IPS Implementação (cont.) Os conceitos usados para a implementação deste subconjunto de Instruções do IPS SÃO OS ESOS QUE SÃO USADOS POR U ELEVADO CONJUNTO DE PROCESSADORES Usados em computadores Desktops, Servers, Laptops, em sistemas embebidos com processador de uso geral (general purpose) e processadores específicos (specific processors) Path IPS (simplificado) 4 PC ress Registers ALU ress 2
IPS Implementação (cont.) Para todas as instruções os dois primeiros passos são iguais: 1. Envia o PC (Program Counter) para a memória que contêm o programa e efectua dessa memória a busca instrução (fetch) 2. Efectua a leitura de um ou dois registos, usando o campo das instruções para seleccionar os registos a ler. Para a instrução Load (lw), apenas é necessário ler um registo, mas as outras instruções requerem a leitura de dois registos. IPS Implementação (cont.) Após estes dois estados ciclo de execução de uma instrução, as acções necessárias para completar a execução depende da classe das instruções: - Acesso emória - Lógicas e Aritméticas - Saltos No entanto as acções são quase todas as mesmas independente do opcode 3
Sequência de execução de Instruções no IPS 1. Leitura do código da instrução ( Fetch) IF 2. Descodificação da instrução ( Decoder) ID 3. Execução da instrução (Execution) EXE 4. Acesso à memória de dados (emory) E 5. Escrita de resultados em registos ( Back) WB Path do IPS Adress In Out Out (Step 4,5) Adress In Out PC INSTRUCTION CACHE REGISTERS ALU DATA CACHE Step 1 Step 2 Step 3 (Step 4) 4
Utilização da ALU EXE (step 3) esmos instruções de classes diferentes apresentam algumas semelhanças Excepto as instruções de salto todas usam a ALU após a leitura dos registos, para: emory reference usam a ALU para o calculo de endereço Arithmetic logical usam a ALU para a execução da operação Branches usam a ALU para a comparação SIPLICIDADE e REGURALIDADE das instruções Simplifica a implementação efectuando a execução da maior parte das instruções de um modo semelhante 5
STEP 4,5 E, WB Após a ALU, as acções necessárias para completar as diversas classes de instruções varia, assim: emory reference precisam de aceder à memória para ler dados (load) ou escrever dados (store) Arithmetic logical precisa de escrever o resultado de volta no registo Branches dependendo do valor da comparação pode ser preciso mudar o endereço da próxima instrução, caso contrário o PC deve ser incrementado de 4 4 PC ress Registers ALU ress 6
Path IPS (Abstract View) R1 4 PC ress Registers ALU ress Path IPS (Abstract View) R2 4 PC ress Registers ALU ress 7
Diapositivo 13 R1 1. em várias partes os dados de entrada de uma unidade funcional podem vir de dois lados, nestes casos não se podem simplesmete liogar as linhas mas devem ser adicionado um multiplexer que permita a corecta selecção de entrada 2. Varias das unidades podem ser controladas dependendo do tipo de instrução Rui arcelino; 18-02-2006 Diapositivo 14 R2 1. em várias partes os dados de entrada de uma unidade funcional podem vir de dois lados, nestes casos não se podem simplesmete liogar as linhas mas devem ser adicionado um multiplexer que permita a correcta selecção de entrada 2. Varias das unidades podem ser controladas dependendo do tipo de instrução Rui arcelino; 20-03-2006
Path (com ux e linhas Controlo) PCSrc ux PC= PC+4 PC= endereço do salto 4 Shift left 2 ALU result PC address register 1 register 2 register Reg Registers 1 2 ALUSrc ux 4 ALU operation Zero ALU ALU result ress em emtoreg ux 16 Sign 32 extend em Descrição do sequência de execução 1. Todas as instruções começam pela busca da instrução do endereço apontado por PC 2. Descodificação da instrução e leitura dos registos operandos, 3. Estes (registos operandos) podem ser manipulados para obter um endereço de memória (load ou store), executar uma operação lógica-aritmética (aritmetic-logical), ou uma comparação (branch) 8
Descrição do sequência de execução (cont.) 4. Após a ALU, as acções necessárias para completar as diversas classes de instruções varia, assim: emory reference precisam de aceder à memória para ler dados (load) ou escrever dados (store) 5. Arithmetic logical precisa de escrever o resultado de volta no registo Branches dependendo do valor da comparação pode ser preciso mudar o endereço da próxima instrução, caso contrário o PC deve ser incrementado de 4 Sequência de execução das instruções de formato R Instruções do tipo: add, sub, slt, and, or, xor, nor 1. Lê os registos rs e rt e envia-os como entradas para a ALU 2. Indica à ALU que operação deve fazer 3. Escreve os resultados no registo destino rd Todas as instruções R seguem a mesma sequência de execução 9
ADD R2, R1, R0 IF IF ID EX E WB Sequência de execução das instruções de formato I Instruções I, Operações Imediatas com registos addi, slti, andi, ori, xori lui Instruções I, acesso à memória lw, sw Instruções I, saltos condicionais beq, bne 10
Instruções I, Operações Imediatas com registos addi, slti, andi, ori, xori São executadas de modo semelhante ao formato R, A diferença está que um operando é imediato ADD R2, R1, 5 IF ID EX E WB 11
A instrução lui, (Load Upper Immediate) Apenas é necessário o operando imediato Lê o conteúdo de rs Soma o numero lido de rs com o valor imediato da instrução para calcular o valor da posição de memória Lê da posição de memória (LW) ou escreve na posição de memória (SW) calculada Para LW o valor lido é escrito no registo rt 12
LW R2, R1 (01) IF ID EX E WB SW R2, R1 (01) IF ID EX E WB 13
BEQ R0, 8 IF IF ID EX E WB IF ID EX E WB 14
BNE R0, 8 IF ID EX E WB ALU-type P C Not used Load P C Store P C Not used Branch (and jr) P C Not used Not used Not used Jump (except jr & jal) P C Not used Not used Not used Not used 15
Convenções de Projecto Lógico Elementos Combinacionais, em que as saídas dependem das entradas presentes. ALU é um exemplo. Elementos Sequ~nciais, existência de elementos estados em que pode haver armazenamento de dados. As saídas dependem das entradas presentes e de estados anteriores. Estes elementos de estados caracterizam completamente a máquina. Exemplos de elementos de estados são as instruções, memória de dados, registos Elemento de estado Falling edge Clock period Rising edge 16
Elementos de Estado Elementos de estado com relógio e sem relógio Relógio usado para efectuar o sincronismo Sincronismo pode ser efectuado: Pulso ascendente (rising edge) ou, Pulso Descendente (falling edge) Falling edge Clock period Rising edge Elementos de estado (sem relógio) Latch SET-RESET Saídas dependem das entradas presentes, mas também das entradas anteriores R Q Qn Q(n-1) R S 0 x 1 x x 1 S Q 1 0 0 1 0 0 17
Latch D Duas entradas: Valor de Dados a ser armazenado (D) Sinal de relógio (C) Indicando quando se lê & escreve (D) Duas saídas: O valor do estado interno (Q) e o seu complemento C Q D D _ Q C Q Flip-Flop D Variações são síncronas com o pulso de relógio D D C D latch Q D C D latch Q Q Q Q C D C Q 18
etodologia usada Sincronismo no pulso ascendente Execução típica Lê elementos de estado Atravessa lógica combinacional Escreve em elemento de estado State element 1 Combinational logic State element 2 Clock cycle Ficheiro de registos Construído usando Flip-Flop tipo D register number 1 register number 2 register Register file 1 2 19
Ficheiro de registos (cont.) register number 1 Register 0 Register 1... Register n 2 Register n 1 u x 1 register number 2 u x 2 Select Select A31 B31 u x C31 32 A 32 B u x 32 C A30 B30 u x. C30. A0 B0 u x C0 20
Si8crono com o pulso de relógio Register number 0 1 n-to-2n decoder n 1 n. C D C D Register 0 Register 1. C D Register n 2 Register C D Register n 1 Implementação simples address PC Sum a. b. Program counter c. er 21
em ress 16 Sign 32 extend em a. unit b. Sign-extension unit Register numbers 5 5 5 register 1 register 2 register Registers 1 2 4 ALU operation Zero ALU ALU result Reg a. Registers b. ALU 22
4 PC ress Registers ALU ress PCSrc ux 4 Shift left 2 ALU result PC address register 1 register 2 register Reg Registers 1 2 ALUSrc ux 4 ALU operation Zero ALU ALU result ress em emtoreg ux 16 Sign 32 extend em 23
Utilização de ux s para efectuar comutação PCSrc ux 4 Shift left 2 ALU result PC address register 1 register 2 register Reg Registers 1 2 ALUSrc ux 4 ALU operation Zero ALU ALU result ress em emtoreg ux 16 Sign 32 extend em Controlo Selecting the operations to perform (ALU, read/write, etc.) Controlling the flow of (multiplexor inputs) Information comes from the 32 bits of the instruction Example: add $8, $17, $18 Format: 000000 10001 10010 01000 00000 100000 op rs rt rd shamt funct ALU's operation based on instruction type and function code 24
Controlo e.g., what should the ALU do with this instruction Example: lw $1, 100($2) 35 2 1 100 op rs rt 16 bit offset ALU control input 0000 AND 0001 OR 0010 add 0110 subtract 0111 set-on-less-than 1100 NOR Why is the code for subtract 0110 and not 0011? Controlo ust describe hardware to compute 4-bit ALU control input given instruction type 00 = lw, sw 01 = beq, 10 = arithmetic function code for arithmetic Describe it using a truth table (can turn into gates): 25
Controlo 0 ux 4 [31 26] Control RegDst Branch em emtoreg ALUOp em ALUSrc Reg Shift left 2 ALU result 1 PC [25 21] register 1 address [20 16] 1 register 2 Zero 0 [31 0] ALU ALU 0 2 result ux [15 11] register ux 1 1 Registers [15 0] 16 Sign 32 extend ALU control ress 1 ux 0 [5 0] RegDst ALUSrc emto- Reg Reg em em Branch ALUOp1 ALUp0 R-format 1 0 0 1 0 0 0 1 0 lw 0 1 1 1 1 0 0 0 0 sw X 1 X 0 0 1 0 0 0 beq X 0 X 0 0 0 1 0 1 26
Linhas de controlo São implementadas utilizando lógica combinacional simples. Podem ser descritas por tabelas de verdade, funções lógicas. Inputs Op5 Op4 ALUOp ALU control block ALUOp0 Op3 Op2 Op1 Op0 ALUOp1 Outputs F (5 0) F3 F2 F1 F0 Operation2 Operation1 Operation0 Operation R-format Iw sw beq RegDst ALUSrc emtoreg Reg em em Branch ALUOp1 ALUOpO All of the logic is combinational We wait for everything to settle down, and the right thing to be done ALU might not produce right answer right away we use write signals along with clock to determine when to write Cycle time determined by length of the longest path 27
PCSrc ux 4 Shift left 2 ALU result PC address emória (200ps), ALU e somadores (100ps), Acesso ficheiro de registos (50ps) register 1 register 2 register Reg Registers 1 2 16 Sign 32 extend ALUSrc ux 4 ALU operation Zero ALU ALU result ress em em emtoreg ux PC ress or emory register emory register Registers A B ALU ALUOut 28
Consider each instruction from perspective of ISA. Example: The add instruction changes a register. Register specified by bits 15:11 of instruction. specified by the PC. New value is the sum ( op ) of two registers. Registers specified by bits 25:21 and 20:16 of the instruction Reg[emory[PC][15:11]] <= Reg[emory[PC][25:21]] op Reg[emory[PC][20:16]] In order to accomplish this we must break up the instruction. (kind of like introducing variables when programming) ISA definition of arithmetic: Reg[emory[PC][15:11]] <= Reg[emory[PC][25:21]] op Reg[emory[PC][20:16]] Could break down to: IR <= emory[pc] A <= Reg[IR[25:21]] B <= Reg[IR[20:16]] ALUOut <= A op B Reg[IR[20:16]] <= ALUOut We forgot an important part of the definition of arithmetic! PC <= PC + 4 29
Fetch Decode and Register Fetch Execution, emory ress Computation, or Branch Completion emory Access or R-type instruction completion -back step INSTRUCTIONS TAKE FRO 3-5 CYCLES! Use PC to get instruction and put it in the Register. Increment the PC by 4 and put the result back in the PC. Can be described succinctly using RTL "Register-Transfer Language" IR <= emory[pc]; PC <= PC + 4; Can we figure out the values of the control signals? What is the advantage of updating the PC now? 30
registers rs and rt in case we need them Compute the branch address in case the instruction is a branch RTL: A <= Reg[IR[25:21]]; B <= Reg[IR[20:16]]; ALUOut <= PC + (sign-extend(ir[15:0]) << 2); We aren't setting any control lines based on the instruction type (we are busy "decoding" it in our control logic) ALU is performing one of three functions, based on instruction type emory Reference: R-type: Branch: ALUOut <= A + sign-extend(ir[15:0]); ALUOut <= A op B; if (A==B) PC <= ALUOut; 31
Loads and stores access DR <= emory[aluout]; or emory[aluout] <= B; R-type instructions finish Reg[IR[15:11]] <= ALUOut; The write actually takes place at the end of the cycle on the edge Reg[IR[20:16]] <= DR; Which instruction needs this? 32
33