Organización del
Computador
CPU 3 y 4 – Diseño de una
computadora
Consideraciones
Una única ALU, una única Memoria, un
único Banco de Registros.
 Dos tipos de problemas:

Una instrucción utiliza un mismo recurso
varias veces y se pierden los valores
anteriores.
 Una instrucción utiliza un mismo recurso en la
misma etapa para dos o más cosas distintas.

Algunos componentes disponibles
M e m W rite
A d d re s s
P C
W rite
da ta
R e ad
d a ta
M e m R ead
Unidad de memoria
R eg is te r
nu m b e rs
5
5
D ata
R e ad
re giste r 2
R eg is te rs
W rite
re giste r
W rite
d ata
A LU co n tr ol
R e ad
d ata 1
Z e ro
D a ta
ALU
R e ad
d ata 2
R e g W rite
Registros
32
Unidad de extensión
de signo
3
R e ad
re giste r 1
S ig n
ex te nd
m e m ory
Program Counter
5
16
ALU
ALU
re su lt
Diseño: Pasos necesarios
1er Paso: Analizar el conjunto de
instrucciones para determinar los
requerimientos del Camino de Datos.
 2o Paso: Seleccionar los componentes.
 3o Paso: Construir el Camino de Datos
según los requerimientos.
 4o Paso: Analizar la implementación de cada
instrucción para determinar las señales de
control necesarias.
 5o Paso: Construir el Control.

Cinco Etapas (o fases) de Ejecución
1. Fetch de Instrucción (Fetch/IF)
2. Decodificación (y lectura de registros)
(Decode/ID)
3. Acceso a datos en memoria (Mem)
(previo Cálculo de Dirección de
memoria)
4. Ejecución (Execution/EX)
5. Escritura en registros (Write Back/WB)
Formato MIPS de Instrucción
Son todas de 32 bits.
Tres formatos:
31

Tipo R (register)





31
Transferencia, salto
Operaciones con
operando inmediato
Tipo J (jump)

op
Aritméticas
Tipo I (immediate)
Saltos
26
rs
26
op
31
21
16
rt
21
rs
rd
6
sh
0
funct
16
rt
26
op
11
0
Address/inmediate
0
Target Address
Formato R: Register
31
26
0





21
rs
16
rt
11
rd
Sh (5)
6
0
fun (6)
op = 0
rs, rt = identificación de los registros fuente
rd = identificación del registro destino
sh = cantidad de shifts
func = identifica la operación (ej. add=32, sub=34,
sll=0,srl=10)
Formato R :Ejemplos
31

Add
$1, $2, $3
26
0
31

Sub
$1, $2, $3
Slt
0
$1, $2, $3
Set Less Than
Jr
$31
Jump Register
3
2
0
16
21
26
16
21
11
16
6
11
0
34
6
0
1
0
32
0
1
3
6
0
1
3
2
11
0
42
si ($2<$3) entonces $1=1sino $1=0
31

2
26
31

21
26
0
PC=$31
21
31
16
0
11
0
6
0
0
8
Formato I : Immediate
31
op

Addi $1,$2,100
26
21
rs
0
rt
31
8
$1=$2+100
16
Address/inmediate
26
21
2
16
1
0
100
Formato I : Immediate
31
26
op
21
rs
Lw $1, 100($2)
Load Word
Sw $1, 100($2)
Store Word
Address/inmediate
26
35
21
2
16
1
0
100
$1=M[$2+100]
31

0
rt
31

16
43
26
21
2
M[$2+100]=$1
16
1
0
100
Formato I : Immediate
31
26
op
21
rs
rt
31

Beq$1,$2,100
Branch Equal
Bne$1,$2,100
Branch Not Equal
0
Address/inmediate
26
4
21
1
16
2
0
100
si ($1=$2) entonces ir a PC+4+100
31

16
5
26
21
1
16
2
0
100
si ($1!=$2) entonces ir a PC+4+100
Formato J : Jumps
31
26
0
op
Target Address
31

J
26
10000
2
10000
PC 27..2=10000
31

0
Jal 10000
PC1..0=00
26
3
JUMP AND LINK
PC 27..2=10000
0
10000
$31=PC+4
PC1..0=00
RTL (Registrer Tranfer Language)
Cada instrucción está formada por un
conjunto de microoperaciones.
 Se utiliza para determinar la secuencia
exacta de microoperaciones.
 Ejemplo (Fetch en Marie):

t1:
 t2:


t3:
MAR  (PC)
MBR  Mem[MAR]
PC  (PC) + 1
IR  (MBR)
1o Paso: Tipo R (add, sub...)
31
26
0
21
rs
16
rt
11
rd
Sh (5)
R[rd] = R[rs] ‘op’ R[rt]; PC=PC+4
RTL
T1: IR  Mem[PC]
PC  PC + 4
T2: A  R[rs]
B  R[rt]
T3: ALUOut  A ‘op‘ B
T4: R[rd]  ALUOut
6
0
fun (6)
1o Paso: Tipo I (Branch)
31
op
BEQ
26
21
rs
16
rt
0
Address/inmediate
if (R[rs] == R[rt]) then
PC  PC+(sign_ext(Imm16)*4)
RTL
T1: IR  Mem[PC];
PC  PC + 4
T2: A  R[rs] (Se guardan para el ciclo siguiente)
B  R[rt]
ALUOut  PC + sign_ext (Imm16) << 2 (calcula la dir. del
salto)
T3: PC  ALUOut [Si el flag Zero esta activo]
1o Paso: Tipo I (Load)
31
26
op
LOAD
21
rs
16
rt
0
Address/inmediate
R[rt]  Mem[ R[rs]+sign_ext(Imm16) ]
RTL
T1: IR  Mem[PC]
PC PC + 4
T2: A  R[rs]
B  R[rt] (B no se usa)
T3: ALUOut  A + sign_ext (Imm16) (Calcula la dir.)
T4: MBR  Mem[ALUOut]
T5: R[rt]  MAR
1o Paso: Tipo I (Store)
31
op
STORE
26
21
rs
16
rt
0
Address/inmediate
Mem[ R[rs]+sign_ext(Imm16) ]  R[rt];
RTL
T1: IR  Mem[PC]
PC  PC + 4
T2: A  R[rs]
B  R[rt] (valor a escribir)
T3: ALUOut  A + sign_ext (imm16)
T4: Mem[ALUOut]  B
Resumen de las etapas
1er Paso: Requerimientos del Conjunto
de Instrucciones








Memoria
 Para instrucciones y datos
Registros (32x32)
 Leer rs, leer rt
 Escribir rt ó rd
PC, MBR
A, B para datos intermedios, ALUOut (retener salida ALU)
Extensor de signo (16 a 32)
Sumar y Restar registros y/o valores inmediatos
Operaciones lógicas (and/or) registros y/o valores
inmediatos
Sumar 4 al PC ó 4 + inmediato extendido * 4
2o Paso: Componentes del Camino de
Datos
MemWrite
Read
data
Address
PC
Write
data
.
R e ad
re giste r 1
5
R e ad
re giste r 2
R eg is te rs
W rite
re giste r
D ata
W rite
d ata
32
memory
a memory unit
b. Sign-extension unit
3
5
5
Sign
extend
MemRead
b. Program counter
R eg is te r
nu m b e rs
16
A LU co n tr ol
R e ad
d ata 1
Z e ro
D a ta
ALU
ALU
re su lt
R e ad
d ata 2
R e g W rite
a . R e g isters
b. ALU
2o Paso: Componentes del Camino de
Datos

Elementos de Almacenamiento: Banco de
Registro (dos puertos de lectura)
RegW
Read register
number 1
Register 0
Register 1
Register n – 1
LRA
M
u
x
5
Read data 1
LRB
BusA
ER
32
5
Register n
32 Registros de
32 bits
5
Read register
number 2
BusW
32
32
M
u
x
BusB
Read data 2
CLK
2o Paso: Componentes del Camino de
Datos

Elementos de Almacenamiento: Banco de
Registros (un puerto de escritura)
RegW
W rite
LRA
0
R eg iste r n um be r
C
D
n -to -1
de co de r
C
n– 1
5
R e giste r 0
1
LRB
BusA
ER
32
5
R e giste r 1
D
32 Registros de
32 bits
5
n
BusW
C
R eg iste r n – 1
32
32
D
C
R e giste r n
R e gister d ata
D
BusB
CLK
2o Paso: Componentes del Camino de
Datos

Una sola memoria para instrucciones y datos
IoD
IRW
WE
Del PC
dirección
MUX
Dato Out
32
De la ALU
32
Memoria
Dato In
32
CLK
IR
3er Paso: Reuso de Unidades
Funcionales: ALU única

ALU debe realizar
 operaciones sobre registros
 base + desplazamiento para loads y stores
 dirección destino de salto: registro + sign_ext(Imm16) * 4
 PC=PC+4
ALUctr
PC
M
U
X
32
BusA
32
BusB
32
M
U
X
4
32
>>2
SignExt
Inm16
32
32
3er Paso: Registro ALUout
DstW
ALUOut
ALUct
r
M
U
X
PC
32
BusA
32
BusB
32
M
U
X
4
32
>>2
SignExt
Inm16
32
32
3er Paso: Fetch - IF

Mem[PC]; PC  PC + 4 (código secuencial)
3er Paso: Decode - ID
3er Paso: Ejecución - EX
3er Paso: Operandos - Mem
3er Paso: Write back- WB
Señales de control
Grafo de Estados
IRMEM[PC];
PCPC+4
AR[rs];
BR[rt];
Jump
ALUOutPC+(signext(inm16)<<2)
Format R
Beq
ALUOutAopB
si (Z) PCALUOut
ALUOutA+
signext(inm16)
Sw
MEM[ALUOut]B
R[rd]ALUOut
ZA-B
Lw
MBRMEM[ALUOut]
R[rt] -MBR
PC PC[31:28] ||
(IR[25:0] <<2)
Grafo de Estados
S0
S1
S6
S8
S2
S3
S5
S7
S4
S9
Control de Señales
S0
RegWrite
IRWrite
MemRead
MemWrite
PCWrite
PCWCond
PCSource
ALUsrcA
ALUsrcB
MemToReg
RegDst
IoD
S1
S2
S3
S4
S5
S6
S7
S8
S9
Control de Señales
S0
S1
S2
S3
S4
S5
S6
S7
S8
S9
RegWrite
0
0
0
0
1
0
0
1
0
0
IRWrite
1
0
0
0
0
0
0
0
0
0
MemRead
1
MemWrite
0
0
0
0
0
1
0
0
0
0
PCWrite
1
0
0
0
0
0
0
0
0
1
1
PCWCond
PCSource
1
00
01
ALUsrcA
0
0
1
1
1
1
1
1
1
ALUsrcB
01
11
10
10
10
10
00
00
00
MemToReg
1
0
RegDst
0
1
IoD
ALUop
0
00
1
00
00
1
1
10
01
10
00
Máquina de Estados Finitos
• Implementación:
P C W rite
P C W rite C o n d
Io rD
M em R e ad
M e m W rite
IR W rite
C o n tro l lo g ic
M e m to R e g
P C S o u rce
ALUOp
O u tp u ts
A L U S rc B
A L U S rc A
R e g W rite
R e gD st
NS3
NS2
NS1
In s tru ctio n re g is te r
o p c o d e fie ld
S0
S1
S2
NS0
S3
O p0
O p1
O p2
O p3
O p4
O p5
In p u ts
S ta te re g is te r
Implementación con ROM


ROM = "Read Only Memory"
 Se graba la memoria con valores fijos
Se usa la ROM para implementar la Tabla de Verdad
 Con direcciones de m-bits, podemos direccionar
2m entradas en la ROM.
 Las salidas son los datos (palabras) direccionadas
m
n
0
0
0
0
1
1
1
1
0
0
1
1
0
0
1
1
0
1
0
1
0
1
0
1
0
1
1
1
0
0
0
0
0
1
1
0
0
0
1
1
1
0
0
0
0
0
1
1
1
0
0
0
0
1
0
1
Implementación con ROM

¿Cuantas entradas tenemos?




¿Cuantas salidas?





6 bits para el opcode
4 bits para el estado
= 10 líneas de direcciones (210 = 1024 posibles direcciones)
16 señales de control del camino de datos
4 bits de estado
= 20 lineas de salida
ROM de 210 x 20bits = 20Kbits
Problema: mucho desperdicio, ya que para
muchisimas entradas, las salidas son idénticas.

Por ejemplo, el codígo de operación se ignora muchas
veces
Implementación con PLA
O p5
O p4
O p3
O p2
O p1
O p0
S3
S2
S1
S0
P C W rite
P C W rite C o n d
Io rD
M em Read
M e m W rite
IR W rite
M e m toR e g
P C S o u rce 1
P C S o u rce 0
ALU O p1
ALU O p0
A L U S rcB 1
A L U S rcB 0
A L U S rcA
R e g W rite
R e g D st
NS3
NS2
NS1
NS0
ROM vs PLA

Se podrían hacer dos ROM:
— 4 bits de estado se usan como dirección de las palabras de
salida: 24 x 16 bits= 256bits de ROM
— 10 bits (6 opcode, 4 estado) se usan como dirección para la
función de transición (nuevo estado): 210 x 4 bits de ROM
— Total: 4K bits de ROM

PLA es mas pequeña
— puede compartir términos producto
— sólo utiliza las entradas que producen valores
— puede considerar los “no importa”

Tamaño (#inputs ´ #product-terms) + (#outputs ´ #product-terms)

En el ejemplo = (10x17)+(20x17) = 460 PLA cells
Una celda de PLA es un poco mas grande que una de ROM
Microprogramación
C o n trol u n it
P C W r ite
P C W r ite C on d
Io rD
M e m R ea d
M icr o c od e m e m ory
M e m W rite
IR W rite
B W rite
O u tpu ts
M e m to R e g
P C S o urc e
ALUOp
A L U S rc B
A L U S rc A
R eg W rite
R eg D s t
In p ut
1
A d d rC tl
D a ta pa th
• La ROM es la
memoria donde se
guardan las
instrucciones para el
camino de datos
(microinstrucciones)
M ic ro pro gra m c ou nte r
A dd e r
O p [5 – 0 ]
A d dre s s se le ct lo gic
Ins tru c tio n r e g is ter
o p co d e fie ld
• La dirección de la
ROM (microPC) es
el estado
Microprogramación

Es una metodología de especificación




Apropiada para arquitecturas con cientos de
instrucciones, modos, etc.
Las señales se especifican simbólicamente
usando microinstrucciones
Se define el formato de la microinstrucción,
estructurado en campos.
Luego cada campo se asocia a un conjunto de
señales
Diseño de microinstrucciones

Diferentes señales agrupadas por campos
Campo
Función
Alu Control
Que operación debe hacer la ALU en este ciclo
SRC1
Especifica el 1º operando de la ALU
SRC2
Especifica el 2º operando de la ALU
Register Ctrl
Especifica Lectura/Grabación de registros, y la fuente
para la grabación
Memoria
Especifica Lectura/Grabación. En lectura el registro de
destino
PCWriteCtrl
Especifica la grabación del PC
Secuencia
Determina como elegir la proxima microinstrucción
Formato de Microinstrucción
Field name
ALU control
SRC1
SRC2
Value
Add
Subt
Func code
PC
A
B
4
Extend
Extshft
Read
ALUOp =
ALUSrcA
ALUSrcA
ALUSrcB
ALUSrcB
ALUSrcB
ALUSrcB
Write ALU
RegWrite,
RegDst = 1,
MemtoReg = 0
RegWrite,
RegDst = 0,
MemtoReg = 1
MemRead,
lorD = 0
MemRead,
lorD = 1
MemWrite,
lorD = 1
PCSource = 00
PCWrite
PCSource = 01,
PCWriteCond
PCSource = 10,
PCWrite
AddrCtl = 11
AddrCtl = 00
AddrCtl = 01
AddrCtl = 10
Register
control
Write MDR
Read PC
Memory
Read ALU
Write ALU
ALU
PC write control
ALUOut-cond
jump address
Sequencing
Signals active
ALUOp = 00
ALUOp = 01
Seq
Fetch
Dispatch 1
Dispatch 2
10
=0
=1
= 00
= 01
= 10
= 11
Comment
Cause the ALU to add.
Cause the ALU to subtract; this implements the compare for
branches.
Use the instruction's function code to determine ALU control.
Use the PC as the first ALU input.
Register A is the first ALU input.
Register B is the second ALU input.
Use 4 as the second ALU input.
Use output of the sign extension unit as the second ALU input.
Use the output of the shift-by-two unit as the second ALU input.
Read two registers using the rs and rt fields of the IR as the register
numbers and putting the data into registers A and B.
Write a register using the rd field of the IR as the register number and
the contents of the ALUOut as the data.
Write a register using the rt field of the IR as the register number and
the contents of the MDR as the data.
Read memory using the PC as address; write result into IR (and
the MDR).
Read memory using the ALUOut as address; write result into MDR.
Write memory using the ALUOut as address, contents of B as the
data.
Write the output of the ALU into the PC.
If the Zero output of the ALU is active, write the PC with the contents
of the register ALUOut.
Write the PC with the jump address from the instruction.
Choose the next microinstruction sequentially.
Go to the first microinstruction to begin a new instruction.
Dispatch using the ROM 1.
Dispatch using the ROM 2.
Microprogramación

Microprogramando!
Label
Fetch
Mem1
LW2
ALU
control
Add
Add
Add
SRC1
PC
PC
A
SW2
Rformat1 Func code A
BEQ1
JUMP1
Subt
A
Register
control
SRC2
4
Extshft Read
Extend
B
B
PCWrite
Memory
control
Read PC ALU
Sequencing
Seq
Dispatch 1
Dispatch 2
Read ALU
Seq
Write MDR
Fetch
Write ALU
Fetch
Seq
Write ALU
Fetch
ALUOut-cond Fetch
Jump address Fetch
Referencias

Capitulo 5 - Patterson

Ver resumen en sección Download
Capitulo 4 - Tanembaun
 Capitulo 16 y 17 - Stallings
 Capitulo 4 - Null

Descargar

Document