Upload
others
View
12
Download
0
Embed Size (px)
Citation preview
16/04/2012
1
Arquitectura de Computadoras
Primavera 2012
1
Introducción
Construyendo el Datapath
Esquema de implementación Simple
Unidad de Control
2
Los elementos básicos de un sistema de computo son:
3
Nos centraremos en diseñar una implementación que incluya un subconjuto del conjunto de instrucciones discutido: ◦ Instrucciones de referencia a memoria lw y sw ◦ Instrucciones aritméticas y lógicas add, sub, and, or
y slt ◦ Instrucciones de decisión beq y salto incondicional j
Solo incluimos este subconjunto para hacerlo
mas claro e ilustrar los puntos claves de diseño
4
Todas las instrucciones del conjunto discutido requieren de los siguientes dos pasos: ◦ Obtener el código de la instrucción de la memoria El contador del programa (PC) tiene la dirección de
memoria donde se encuentra el código
Se utiliza PC para ir a memoria y obtener el código
◦ Leer uno o dos registros Se utilizan los campos de la instrucción para
seleccionar los registros que se leerán
En algunos casos (Instrucciones tipo I) solo leemos un registro y utilizamos otro campo de la instrucción como operando
5
Después de estos dos pasos, la ejecución de la instrucción requerirá acciones diferentes.
Sin embargo, muchas de estas instrucciones requieren pasos similares. ◦ Por ejemplo:
add obtiene los dos registros y usa ALU para sumarlos
lw obtiene un registro y lo suma a uno de sus campos por medio de la ALU para obtener la dirección de memoria que debe leer
6
16/04/2012
2
1. Analizar el conjunto de instrucciones => requerimientos del datapath
2. Seleccionar el conjunto de componentes del datapath y establecer la metodología de sincronización
3. Construir el datapath que satisfaga los requerimientos
4. Analizar la implementación de cada instrucción para determinar los puntos de control
5. Diseñar la unidad de control lógico
7
Todas las instrucciones siguen uno de los siguientes formatos
OPCODE RS RT RD SHAMT FUNCTION
6 bits 5 bits 5 bits 5 bits 5 bits 6 bits
OPCODE RS RT Dirección/Numero Inmediato
6 bits 5 bits 5 bits 16 bits
OPCODE Dirección
6-bits 26-bits
Formato R
Formato I
Formato J
8
Instrucción Transferencia de Registro PC
add R[rd] <– R[rs] + R[rt]; PC <– PC + 4
sub R[rd] <– R[rs] - R[rt]; PC <– PC + 4
and R[rd] <– R[rs] and R[rt]; PC <– PC + 4
ori R[rt] <– R[rs] or zero_ext(Imm16); PC <– PC + 4
slt R[rd] <- 1 if R[rs] < R[rt] else 0 PC <– PC + 4
lw R[rt] <- MEM[R[rs] + sign_ext(Imm16)] PC <– PC + 4
sw R[rt] -> MEM[R[rs] + sign_ext(Imm16)] PC <– PC + 4
beq IF (R[rs] == R[rt]) Then PC <- PC + sign_ext(Imm16<<2)]
else PC <- PC + 4
j PC <- PC:(Target<<2)
9
Memoria ◦ Las instrucciones deben estar almacenadas en la
memoria para poder ser ejecutadas
◦ Algunas instrucciones (lw, sw) requieren leer o guardar datos en memoria
Registros ◦ La mayor parte de las instrucciones requiere
acceder a información guardada en los registros (rt, rs)
◦ Algunas instrucciones deben guardar los resultados dentro de un registro (rt o rd)
10
Registro de Control de Programa (PC) ◦ Este registro nos permitirá seguir la secuencia de
instrucciones del programa
Extensor ◦ Algunas operaciones se realizan con números de 16
bits. Por lo cual, se debe extender el número a 32-bits para poder realizar la operación
Sumador para PC ◦ Se requiere sumar un 4 a PC o un número
extendido a 16 bits a PC
11
Elementos Combinacionales ◦ ALU
◦ Sumador
◦ Extensor de signo
◦ Multiplexores
Elementos de almacenamiento ◦ Memoria
◦ Registros
Metodología de sincronización
12
16/04/2012
3
0
1
A
B
Control
Multiplexor
Exte
nsor
de S
igno
A
16 bits
A
32 bits
A
B
Salida Suma
A
B
Salida
Sumador
ALU 13 14
D
Clock
P4
P3
P1
P2
5
6
1
2
3
(a) Circuit
D Q
Q
(b) Graphical symbol
Clock
Q
Q
4
15
Registros
◦ Los registros son una colección de N flip-flops tipo D con habilitación de escritura
◦ Cuando la habilitación de escritura es 0, el dato de salida no cambia
◦ Cuando la habilitación de escritura es 1, el dato de salida es el dato de entrada
Dato de Entrada N bits N bits
Dato de Salida
Reloj
Habilitación de Escritura
16
Archivo de Registros ◦ El archivo de registro contiene
32 registros de 32 bits ◦ Tiene 2 buses de lectura BUSA
y BUSB cada uno de 32 bits ◦ Cuenta con 1 bus de escritura
BUSW
◦ El registro se selecciona por medio de: RA: selecciona el registro de
lectura A
RB: selecciona el registro de lectura B
RW: selecciona el registro de escritura W
◦ El reloj solo es un factor en la escritura
RA 5
RB 5
RW 5
BUSW 32
BUSA 32
BUSB 32
Write Enable
Clock
17
Memoria
Memoria (Idealizada) ◦ Un puerto de entrada
WRITE ◦ Un puerto de salida READ
Una palabra de memoria se selecciona por medio de: ◦ Dirección
◦ WriteEnable = 1, entonces en la palabra seleccionada se escribe lo que se encuentre en WRITE
Reloj
Dirección 32
WRITE 8
READ 8
Write Enable
Clock
18
16/04/2012
4
19 20
Todos los elementos de almacenamiento se sincronizan con el mismo flanco del reloj
Cycle Time = CLK-to-Q + Longest Delay Path + Setup + Clock Skew
(CLK-to-Q + Shortest Delay Path - Clock Skew) > Hold Time
Clk
Don’t Care
Setup Hold
.
.
.
.
.
.
.
.
.
.
.
.
Setup Hold
21
Requerimientos de transferencia de registros ◦ Ensamblado del datapath
Obtención de la instrucción
Lectura de operandos
Ejecución de instrucción
22
Obteniendo la instrucción MEM[PC]
Actualizando el contador del programa ◦ PC <- PC + 4
◦ PC <- PC + “Algo mas” para beq y j
23
R[rd] <- R[rs] op R[rt], Ejemplo: add rd, rs, rt
◦ Ra, Rb, y Rw provienen de los campos de la instrucción rs, rt, y rd
◦ ALUctr y RegWr: lógica de control después de decodificar la instrucción
32
Result
ALUctr
Clk
busW
RegWr
32
32
busA
32
busB
5 5 5
Rw Ra Rb
32 32-bit
Registers
Rs Rt Rd
AL
U
op rs rt rd shamt funct
0 6 11 16 21 26 31
6 bits 6 bits 5 bits 5 bits 5 bits 5 bits
24
16/04/2012
5
Clk
PC
ALUctr
RegWr
busA, B
busW
Rs, Rt, Rd,
Op, Func
Clk-to-Q
Instruction Memory Access Time
Old Value New Value
Old Value New Value
Delay through Control Logic
Register File Access Time
Old Value New Value
ALU Delay
Old Value New Value
Old Value New Value
New Value Old Value
32
Result
ALUctr
Clk
busW
RegWr
32
32
busA
32
busB
5 5 5
Rw Ra Rb
32 32-bit
Registers
Rs Rt Rd
AL
U
Escritura de
registro ocurre
aqui
25
R[rt] <- R[rs] op ZeroExt[imm16] ]
32
Result
ALUctr
Clk
busW
RegWr
32
32
busA
32
busB
5 5 5
Rw Ra Rb
32 32-bit
Registers
Rs
Rt Rd RegDst
Zero
Ext
Mu
x
Mux
32 16 imm16
ALUSrc
AL
U
11
op rs rt immediate
0 16 21 26 31
6 bits 16 bits 5 bits 5 bits rd?
immediate
0 16 15 31
16 bits 16 bits
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
26
R[rt] <- Mem[R[rs] + SignExt[imm16]] ejemplo: lw rt, rs, imm16
11
op rs rt immediate
0 16 21 26 31
6 bits 16 bits 5 bits 5 bits rd
ExtOp
32
ALUctr
Clk
busW
RegWr
32
32
busA
32
busB
5 5 5
Rw Ra Rb
32 32-bit
Registers
Rs
Rt Rd
RegDst
Exten
der
Mu
x
Mux
32 16
imm16
ALUSrc Clk
Data In WrEn
32
Adr
Data
Memory
32
AL
U
MemWr Mu
x
W_Src
27
Mem[ R[rs] + SignExt[imm16] <- R[rt] ] Ejemplo: sw rt, rs, imm16
op rs rt immediate
0 16 21 26 31
6 bits 16 bits 5 bits 5 bits
ALUSrc ExtOp
32
ALUctr
Clk
busW
RegWr
32
32
busA
32
busB
5 5 5
Rw Ra Rb
32 32-bit
Registers
Rs
Rt
Rt
Rd
RegDst
Exten
der
Mu
x
Mux
32 16
imm16
Clk
Data In WrEn
32
Adr
Data
Memory
MemWr
AL
U
32
Mu
x
W_Src
28
beq rs, rt, imm16
◦ mem[PC] Obten la instr. de memoria ◦ Igual <- R[rs] == R[rt] Calcula la condición de salto ◦ if (COND eq 0) Calcula la dirección de la siguiente instrucción
PC <- PC + 4 + ( SignExt(imm16) x 4 )
◦ else PC <- PC + 4
op rs rt immediate
0 16 21 26 31
6 bits 16 bits 5 bits 5 bits
29
beq rs, rt, imm16 Datapath evalua la condición
op rs rt immediate
0 16 21 26 31
6 bits 16 bits 5 bits 5 bits
30
16/04/2012
6
31
El archivo de registros y la Memoria Ideal: ◦ El reloj es un factor solamente durante la operación de escritura ◦ Durante la operación de lectura, se comporta como lógica
combinacional: Dirección valida=> Salida después de “Tiempo de acceso.”
Critical Path (Operacion LW) =
PC’s Clk-to-Q +
Tiempo de Acceso a Memoria de Inst.+
Tiempo de Acceso a Archivo de Reg. +
ALU realiza la suma de 32 bits +
Tiempo de Acceso a la Memoria de datos +
Setup Time para la escritura de registro+
Retardo de reloj
Clk
5
Rw Ra Rb
32 32-bit
Registers
Rd
AL
U
Clk
Data
In
Data
Address Ideal
Data
Memory
Instruction
Instruction
Address
Ideal
Instruction
Memory
Clk
P
C
5 Rs
5 Rt
16 Imm
32
32 32 32
A
B
Nex
t A
dd
ress
32
ALUctr RegDst ALUSrc ExtOp MemtoReg MemWr Equal
Instruction<31:0>
<2
1:2
5>
<1
6:2
0>
<11
:15
>
<0
:15
>
Imm16 Rd Rs Rt
nPC_sel
Adr
Inst
Memory
DATA PATH
Control
Op
<2
1:2
5>
Fun
RegWr
33 34
ExtOp: “zero”, “sign” ALUsrc:
◦ 0 => regB; ◦ 1 => immed
ALUctr: “add”, “sub”, “or”
° MemWr: Escritura en memoria
° MemtoReg: 1 => Mem
° RegDst: 0 => “rt”; 1 => “rd”
° RegWr: Escritura a reg. destino
32
ALUctr
Clk
busW
RegWr
32
32
busA
32
busB
5 5 5
Rw Ra Rb
32 32-bit
Registers
Rs
Rt
Rt
Rd RegDst
Exten
der
Mu
x
32 16
imm16
ALUSrc ExtOp
Mu
x
MemtoReg
Clk
Data In WrEn 32 Adr
Data
Memory
MemWr
AL
U
Equal
0
1
0
1
0 1
=
35
inst Register Transfer
ADD R[rd] <– R[rs] + R[rt]; PC <– PC + 4
ALUsrc = RegB, ALUctr = “add”, RegDst = rd, RegWr, nPC_sel = “+4”
SUB R[rd] <– R[rs] – R[rt]; PC <– PC + 4
ALUsrc = ___, Extop = __, ALUctr = ___, RegDst = ___, RegWr(?), MemtoReg(?), MemWr(?), nPC_sel =__
ORi R[rt] <– R[rs] + zero_ext(Imm16); PC <– PC + 4
ALUsrc = ___, Extop = __, ALUctr = ___, RegDst = ___, RegWr(?), MemtoReg(?), MemWr(?), nPC_sel =__
LOAD R[rt] <– MEM[ R[rs] + sign_ext(Imm16)]; PC <– PC + 4
ALUsrc = ___, Extop = __, ALUctr = ___, RegDst = ___, RegWr(?), MemtoReg(?), MemWr(?), nPC_sel =__
STORE MEM[ R[rs] + sign_ext(Imm16)] <– R[rs]; PC <– PC + 4
ALUsrc = ___, Extop = __, ALUctr = ___, RegDst = ___, RegWr(?), MemtoReg(?), MemWr(?), nPC_sel =__
BEQ if ( R[rs] == R[rt] ) then PC <– PC + sign_ext(Imm16)] || 00 else PC <– PC + 4
ALUsrc = ___, Extop = __, ALUctr = ___, RegDst = ___, RegWr(?), MemtoReg(?), MemWr(?), nPC_sel =__
36
16/04/2012
7
nPC_sel <= if (OP == BEQ) then EQUAL else 0
ALUsrc <= if (OP == “000000”) then “regB” else “immed”
ALUctr <= if (OP == “000000”) then funct elseif (OP == ORi) then “OR” elseif (OP == BEQ) then “sub” else “add”
ExtOp <= _____________
MemWr <= _____________
MemtoReg <= _____________
RegWr: <=_____________
RegDst: <= _____________
38
op rs rt rd shamt funct
0 6 11 16 21 26 31
6 bits 6 bits 5 bits 5 bits 5 bits 5 bits
0
1
0
0
0
1
40
41
op rs rt immediate
0 16 21 26 31
6 bits 16 bits 5 bits 5 bits
1
0
0
1
1
1
42
op rs rt immediate
0 16 21 26 31
6 bits 16 bits 5 bits 5 bits
0
X
0
0
X
0
Estructura Logica vs. Fisica
Data
Out
Clk
5
Rw Ra Rb
32 32-bit
Registers
Rd
AL
U
Clk
Data
In
Data
Address Ideal
Data
Memory
Instruction
Instruction
Address
Ideal
Instruction
Memory
Clk
P
C
5 Rs
5 Rt
32
32 32 32
A
B
Nex
t A
dd
ress
Control
Datapath
Control Signals Conditions
43