Datapath do MIPS. MIPS Implementação. sw) or, slt. Vamos examinar uma implementação que inclui um subconjunto de instruções do MIPS

Datapath do MIPS

MIPS Implementação

Vamos examinar uma implementação que inclui um subconjunto de instruções do MIPS

z Instruções de leitura (load lw) e de escrita (store

sw)

zInstruções aritméticas e lógicas

add, sub, and,

or, slt

2

MIPS Implementação (cont.)

z Os conceitos usados para a implementação deste subconjunto de Instruções do MIPS

z Usados em computadores Desktops, Servers,

Laptops, em sistemas embebidos com

processador de uso geral (general purpose) e processadores específicos (specific processors)

SÃO OS MESMOS QUE SÃO USADOS POR

UM ELEVADO CONJUNTO DE PROCESSADORES

Data Register # Register # Register # PC Address Instruction Instruction memory

Registers ALU Address

Data Data memory Add Add 4

MIPS Implementação (cont.)

z 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.

MIPS Implementação (cont.)

z 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 Memória - Lógicas e Aritméticas - Saltos

4

Sequência de execução de Instruções no MIPS

1. Leitura do código da instrução (Instruction

Fetch) IF

2. Descodificação da instrução (Instruction

Decoder) ID

3. Execução da instrução (Execution) EXE 4. Acesso à memória de dados (Memory) MEM 5. Escrita de resultados em registos (Write Back)

WB

DataPath do MIPS

AL U PC INSTRUCTION CACHE REGISTERS DATA CACHE

Adress Data Out Data In

Data Out

Adress

Data Out Data In

Step 1 Step 2 Step 3 (Step 4)

Utilização da ALU EXE (step 3)

Mesmos instruções de classes diferentes apresentam algumas semelhanças

z Excepto as instruções de salto todas usam a ALU após a leitura dos registos, para:

– Memory 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

z SIMPLICIDADE e REGURALIDADE das

instruções

z Simplifica a implementação efectuando a

execução da maior parte das instruções de um modo semelhante

6

STEP 4,5 – MEM, WB

z Após a ALU, as acções necessárias para

completar as diversas classes de instruções varia, assim:

– Memory 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

Data Register # Register # Register # PC Address Instruction Instruction memory

Registers ALU Address

Data Data memory Add Add 4

DataPath MIPS (Abstract View)

Data Register # Register # Register # PC Address Instruction Instruction memory

Registers ALU Address

Data Data memory Add Add 4 RM1

DataPath MIPS (Abstract View)

Data Register # Register # PC Address Instruction Instruction memory

Registers ALU Address Data memory Add Add 4 RM2

Diapositivo 13

RM1 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 Marcelino; 18-02-2006

Diapositivo 14

RM2 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 Marcelino; 20-03-2006

DataPath (com Mux e linhas Controlo)

Read register 1 Read register 2 Write register Write data Write data Registers ALU Add Zero RegWrite MemRead MemWrite PCSrc MemtoReg Read data 1 Read data 2 ALU operation 4 Sign extend 16 32 Instruction ALU result Add ALU result M u x M u x M u x ALUSrc Address Data memory Read data Shift left 2 4 Read address Instruction memory PC PC= PC+4 PC= endereço do salto

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)

9

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:

– Memory 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

z 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

ADD R2, R1, R0

IF IF

ID EX MEM WB

Sequência de execução das instruções de formato I

z Instruções I , Operações Imediatas com

registos addi, slti, andi, ori, xori –

lui

z Instruções I, acesso à memória lw, sw

11

z 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

z A instrução lui, (Load Upper Immediate)

z Apenas é necessário o operando imediato

z Lê o conteúdo de rs

z Soma o numero lido de rs com o valor imediato da instrução para calcular o valor da posição de memória

z Lê da posição de memória (LW) ou escreve na posição de memória (SW) calculada

13

LW

R2, R1 (01)

IF ID EX MEM WB

SW

R2, R1 (01)

BEQ

R0, 8

IF IF

15

BNE

R0, 8

IF ID EX MEM WB P C P C P C P C P C ALU-type Load Store Branch Jump Not used Not used Not used Not used Not used Not used Not used Not used Not used (and jr) (except jr & jal)

Convenções de Projecto Lógico

z Elementos Combinacionais, em que as saídas

dependem das entradas presentes. ALU é um exemplo.

z 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

17

Elementos de Estado

z Elementos de estado com relógio e sem relógio

z Relógio usado para efectuar o sincronismo

z Sincronismo pode ser efectuado:

– Pulso ascendente (rising edge) ou,

– Pulso Descendente (falling edge)

Clock period Rising edge

Falling edge

Elementos de estado (sem relógio)

z Latch SET-RESET

– Saídas dependem das entradas presentes, mas também

das entradas anteriores

R S Q Q 1 0 0 0 0 1 1 x x 1 x 0 S R Q(n-1) Qn

Latch D

z Duas entradas:

– Valor de Dados a ser armazenado (D)

– Sinal de relógio (C) Indicando quando se lê & escreve

(D)

z Duas saídas:

– O valor do estado interno (Q) e o seu complemento

Q C D _ Q D C Q

Flip-Flop D

z Variações são síncronas com o pulso de relógio

D C D latch D C Q D latch D C Q _Q Q Q D C

19

Metodologia usada

Sincronismo no pulso ascendente

z Execução típica

– Lê elementos de estado

– Atravessa lógica combinacional

– Escreve em elemento de estado

State element 1 State element 2 Combinational logic Clock cycle

Ficheiro de registos

z Construído usando Flip-Flop tipo D

Read register number 1 _Read data 1 Read register number 2 Read data 2 Write register Write Write data Register file

Ficheiro de registos (cont.)

R e a d re g is te r n u m b e r 1 R e g is te r 0 R e g is te r 1 . . . R e g is te r n – 2 R e g is te r n – 1 M u x R e a d re g is te r n u m b e r 2 M u x R e a d d a ta 1 R e a d d a ta 2 M u x C Select 32 32 32 B A M u x Select B31 A31 C31 M u x B30 A30 C30 .. . .. .

21

z Si8crono com o pulso de relógio

Write 0 1 n-to-2n decoder n – 1 n Register 0 C D Register 1 C D Register n – 2 C D Register n – 1 C D . . . Register number .._. Register data

Implementação simples

PC Instruction address Instruction Instruction memory Add Sum

Address Read data Data memory

a. Data memory unit Write data MemRead MemWrite b. Sign-extension unit Sign extend 16 32 Read register 1 Read register 2 Write register Write Data

Registers Data ALU

Data Zero ALU result RegWrite a. Registers b. ALU 5 5 5 Register numbers Read data 1 Read data 2 ALU operation 4

23 Data Register # Register # Register # PC Address Instruction Instruction memory

Registers ALU Address

Data Data memory Add Add 4 Read register 1 Read register 2 Write register Write data Write data Registers ALU Add Zero RegWrite MemRead MemWrite PCSrc MemtoReg Read data 1 Read data 2 ALU operation 4 Sign extend 16 32 Instruction ALU result Add ALU result M u x M u x M u x ALUSrc Address Data memory Read data Shift left 2 4 Read address Instruction memory PC

Utilização de Mux’s para efectuar comutação Read register 1 Read register 2 Write register Write data Write data Registers ALU Add Zero RegWrite MemRead MemWrite PCSrc MemtoReg Read data 1 Read data 2 ALU operation 4 Sign extend 16 32 Instruction ALU result Add ALU result M u x M u x M u x ALUSrc Address Data memory Read data Shift left 2 4 Read address Instruction memory PC

Controlo

z Selecting the operations to perform (ALU, read/write, etc.)

z Controlling the flow of data (multiplexor inputs)

z Information comes from the 32 bits of the instruction

z Example:

add $8, $17, $18 Instruction Format:

z 000000 10001 10010 01000 00000 100000

25

Controlo

z e.g., what should the ALU do with this instruction

z Example: lw $1, 100($2)

35 2 1 100

op rs rt 16 bit offset

z ALU control input 0000 AND 0001 OR 0010 add 0110 subtract 0111 set-on-less-than 1100 NOR

z Why is the code for subtract 0110 and not 0011?

Controlo

z Must describe hardware to compute 4-bit ALU control input

– given instruction type

00 = lw, sw 01 = beq, 10 = arithmetic

– function code for arithmetic

z Describe it using a truth table (can turn into gates):

Controlo

Read register 1 Read register 2 Write register Write data Write data Registers ALU A dd Zero Read data 1 Read data 2 S ign extend 16 32 Instruction [31–0] ALU result Add ALU result M u x M u x M u x Address D ata memory R ead data Shift left 2 4 R ead address Instruction m em ory PC 1 0 0 1 0 1 M u x 0 1 ALU control Instruction [5–0] Instruction [25–21] Instruction [31–26] Instruction [15–11] Instruction [20–16] Instruction [15–0] RegD st Branch MemRead MemtoReg ALUOp MemW rite ALUSrc RegW rite Control

Instruction RegDst ALUSrc Memto-Reg Reg Write Mem Read Mem

Write 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}

27

Linhas de controlo

z São implementadas utilizando lógica

combinacional simples. Podem ser descritas por tabelas de verdade, funções lógicas.

Operation2 Operation1 Operation0 Operation ALUOp1 F3 F2 F1 F0 F (5–0) ALUOp0 ALUOp

ALU control block

R -for ma t Iw sw be q Op 0 Op 1 Op 2 Op 3 Op 4 Op 5 Inputs O u tp uts R e gD st A LU Src M e mtoR e g R e gW rite M e mR e a d M e mW rite B ran ch A LU O p 1 A LU O p O

z All of the logic is combinational

z 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

z Cycle time determined by length of the longest path

Read register 1 Read register 2 Write register Write data Write data Registers ALU Add Zero RegWrite MemRead MemWrite PCSrc MemtoReg Read data 1 Read data 2 ALU operation 4 Sign extend 16 32 Instruction ALU result Add ALU result M u x M u x M u x ALUSrc Address Data memory Read data Shift left 2 4 Read address Instruction memory PC Memória (200ps), ALU e somadores (100ps), Acesso ficheiro de registos (50ps) Data Register # Register # Register # PC Address Instruction or data

Memory Registers ALU

Instruction register Memory data register ALUOut A B Data

29

z Consider each instruction from perspective of ISA.

z Example:

– The add instruction changes a register.

– Register specified by bits 15:11 of instruction. – 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[Memory[PC][15:11]] <= Reg[Memory[PC][25:21]] op

Reg[Memory[PC][20:16]]

– In order to accomplish this we must break up the instruction.

(kind of like introducing variables when programming)

z ISA definition of arithmetic:

Reg[Memory[PC][15:11]] <= Reg[Memory[PC][25:21]] op

Reg[Memory[PC][20:16]]

z Could break down to:

– IR <= Memory[PC]

– A <= Reg[IR[25:21]]

– B <= Reg[IR[20:16]]

– ALUOut <= A op B

– Reg[IR[20:16]] <= ALUOut

z We forgot an important part of the definition of arithmetic!

z Instruction Fetch

z Instruction Decode and Register Fetch

z Execution, Memory Address Computation, or Branch

Completion

z Memory Access or R-type instruction completion

z Write-back step

INSTRUCTIONS TAKE FROM 3 - 5 CYCLES!

z Use PC to get instruction and put it in the Instruction

Register.

z Increment the PC by 4 and put the result back in the PC.

z Can be described succinctly using RTL "Register-Transfer

Language"

IR <= Memory[PC]; PC <= PC + 4;

31

z Read registers rs and rt in case we need them

z Compute the branch address in case the instruction is a

branch z RTL: A <= Reg[IR[25:21]]; B <= Reg[IR[20:16]]; ALUOut <= PC + (sign-extend(IR[15:0]) << 2);

z We aren't setting any control lines based on the instruction

type

(we are busy "decoding" it in our control logic)

z ALU is performing one of three functions, based on

instruction type z Memory Reference: ALUOut <= A + sign-extend(IR[15:0]); z R-type: ALUOut <= A op B; z Branch: if (A==B) PC <= ALUOut;

z Loads and stores access memory MDR <= Memory[ALUOut];

or

Memory[ALUOut] <= B;

z R-type instructions finish

Reg[IR[15:11]] <= ALUOut;

The write actually takes place at the end of the cycle on the edge

z Reg[IR[20:16]] <= MDR;