CC4301 Arquitectura de Computadores

Luis Mateu - Johan Fabry [lmateu|jfabry]@dcc.uchile.cl

Mtodos de diseo de circuitos digitales Sistemas combinacionales

En un circuito combinacional los valores de las salidas dependen nicamente de los valores que tienen las entradas en el presente. Se construyen a partir de compuertas lgicas: AND, OR, NOT u otras.

x y

NOT AND

OR

NOT

Ejemplo: Circuito C1 Para especicar la funcin de un circuito se usan: 1. Tablas de verdad: Para cada combinacin de entradas se especican las salidas. 2. Formulas Algebraicas: Se usa notacin algebraica que se deriva directamente del circuito.

x 0 0 1 1

y 0 1 0 1

z 1 1 1 0

z = x . y + y
Formula de C1

Tabla de verdad de C1 Observe que la tabla de verdad de C1 es idntica a la tabla de NAND. Entonces C1 es equivalente a z = (x.y) Dado que un NAND produce las mismas salidas que C1 y que un NAND necesita menos transistores que C1, entonces un NAND resulta ms conveniente. Se necesita una metodologa que permita transformar circuitos costosos en circuitos ms simples. La teora del Algebra de Boole nos permitir comprender esta metodologa.
1

Tabla de Compuertas Lgicas

Smbolo Signicado Tabla de Verdad Formula Algebraica

x
AND

y-lgico

x
OR

o-lgico

x 0 0 1 1 x 0 0 1 1

NOT

negacin

y 0 1 0 1 y 0 1 0 1 x 0 1

z 0 0 0 1 z 0 1 1 1 z 1 0

z = xy

z=x+y

z = ~x

x
XOR

o-exclusivo

x
NAND

y-negado

x
NOR

o-negado

y
2

x 0 0 1 1 x 0 0 1 1 x 0 0 1 1

y 0 1 0 1 y 0 1 0 1 y 0 1 0 1

z 0 1 1 0 z 1 1 1 0 z 1 0 0 0

z=x!y

z = ~(xy)

z = ~(x+y)

Algebra de Boole Un lgebra de Boole es una estructura algebraica denotada por < A , + , . , 0 , 1 >, en donde: A es un conjunto + y . son operadores binarios {0, 1} A La estructura verica los siguientes axiomas: A1 asociatividad de + a, b, c : (a+b) + c = a + (b+c) = a+b+c a, b, c : (a.b) . c = a . (b.c) = a.b.c = abc a, b: a+b = b+a a, b: a.b = b.a a+0 = a a.1 = a a . (b+c) = ab + ac a + (bc) = (a+b) . (a+c)

A1' asociatividad de . A2 conmutatividad de +

A2' conmutatividad de . A3 neutro para +

A3' neutro para . A4 distrib de . c/r a +

A4' distrib de + c/r a . A5

existencia de complemento a !a tq a + a = 1 y a . a = 0

Teoremas bsicos de un lgebra de Boole: T1 T2 T3 T4 T5 T6 a+a=a a+1=1 a + ab = a a = a (ab) = a + b a + ab = a + b T5' T6' (a+b) = a b a (a+b) = ab T1' T2' T3' a.a=a a.0=0 a (a+b) = a

Otras maneras de escribir OR: AND: NOT: + . | & ~ || && !

Propuesto: La estructura < {0, 1}, OR, AND, 0, 1> correspondiente a las compuertas lgicas es un lgebra de Boole, con 0 = 1 y 1 = 0 Demostracin: usando tablas de verdad para vericar que se cumple cada uno de los axiomas. Ejemplo: (completar esta tabla) a 0 0 0 0 1 1 1 1 b 0 0 1 1 0 0 1 1 c 0 1 0 1 0 1 0 1 1 1 1 1 0 0 1 0 0 0 0 0 ab (ab)c bc a(bc)

Nota: 3 variables implican 2^3 las. Columnas 3 y 5 resultan ser iguales. Propuesto: Verique la distributividad de + c/r . : a+(bc) = (a+b)(a+c) Demostracin:! (ejercicio ...)

Demostracin de teoremas del lgebra de Boole: T1: a + a = (a + a) . 1 = (a + a) . (a + ~a) = a + (a . ~a) = a + 0 = a [A3, A5, A4, A5, A3] T1: Basta reemplazar en la demostracin anterior los + por . , 0 por 1 , Ax por Ax , y viceversa. T4: Sea b = ~a , entonces: ! b + a = 1 ya que b + a = ~a + a = a + ~a = 1 [A2, A5] ! b . a = 0 ya que b . a = ~a . a = a . ~a = 0 [A2, A5] # luego a = ~b por la unicidad de A5 a = ~~a

Propuesto: Mostrar que ~((~(a.~b)).~b) = a+b usando algebra de Boole Demostracin:! (ejercicio ...)

Metodologa de diseo de circuitos combinacionales a partir de una tabla de verdad. Por etapas: 1. Dada una tabla de verdad, obtener una formula algebraica. 2. Dada una formula algebraica obtener el diagrama circuital. Etapa 2 es la mas sencilla: Se construye el rbol de operaciones de la expresin y se reemplazan los operadores por las respectivas compuertas.
+
. x ~ y ~ ~ z x y . y z
x y z ~y
NOT OR

~y+z
AND

x(~y+z)~z

+
z

~z
NOT NOT

~(xyz)
OR

f(x,y,z)

xyz
AND

! Ejemplo: Circuito C2: f(x, y, z) = x(~y+z)~z+~(xyz)+y

Etapa 1 es mas complejo. Por ejemplo considerando la tabla de verdad a la derecha: Por simple inspeccin: f(x,y) = ~xy + x~y por que ! f(x,y) vale 1 cuando x es 0 e y es 1 # f(x,y) vale 0 cuando x es 1 e y es 0 Esta forma de determinar intuitivamente una formula est respaldada tericamente por el siguiente teorema. Teorema de Shannon: Sea f:{0,1}n {0,1} # f(x1 ... xi ...xn) =# xi . f(x1 ... 1 ... xn) + # # # # ~xi . f(x1 ... 0 ... xn)

x 0 0 1 1

y 0 1 0 1

f(x,y) 0 1 1 0

Demostracin: Basta probar la igualdad para xi = 0 y xi = 1 Caso xi = 0 : f(x1 ... 0 ... xn) # # # # # # ! ! ! ! ! Caso xi = 1 : f(x1 ... 1 ... xn) # # # # # # # # # # # = 0 . f(x1 ... 1 ... xn) #+ ~0 f(x1 ... 0 ... xn) =0# # # + f(x1 ... 0 ... xn) = f(x1 ... 0 ... xn) = 1 . f(x1 ... 1 ... xn) #+ ~1 f(x1 ... 1 ... xn) = f(x1 ... 1 ... xn) # + 0 = f(x1 ... 1 ... xn)
5

Aplicando recursivamente el teorema: ! f(x1 ... xn) = # ~x1 . ... . ~xn-1 . ~xn . # f(0 ... 00) + # # # ~x1 . ... . ~xn-1 . xn . #f(0 ... 01) + # # # ~x1 . ... . xn-1 . ~xn . #f(0 ... 10) + # # # ~x1 . ... . xn-1 . xn . # f(0 ... 11) + # # # ... # # # x1 . ... . xn-1 . xn . # # f(1 ... 11) En el ejemplo: x 0 0 1 1 y 0 1 0 1 f(x,y) 0 1 1 0 f(x,y) # # # # ! # # # # =# # # # =# # # # =# ~x~y .# f(0,0) + ~xy .# f(0,1) + x~y .# f(1,0) + xy . # f(1,1) ~x~y .#0 + ~xy .# 1 + x~y .# 1 + xy . # 0 ~xy + x~y

Observe que el teorema de Shannon es slo vlido para la lgica con {0,1}, no para cualquier lgebra de Boole. Metodo general 1. Dada la tabla de verdad para f, para cada la se crea un sumando del tipo: ! [~]x1 [~]x2 ... [~]xn f(la), en donde xi aparece negado si en esa la xi = 0 2. Se eliminan todos los sumandos que se multiplican por 0 (porque x.0 = 0 y x . 1 = x) Ejemplo: g(x,y) = ~xy + x~y +xy x 0 0 1 1 y 0 1 0 1 g(x,y) 0 1 1 1 ~xy + x~y+ xy Pero claramente (!) g(x,y) = x + y Demostracin: 1. Tabla de + igual a tabla de g 2. Usando lgebra de Boole: (xy = xy + xy) ~xy + xy + x~y = ~xy + xy + xy + x~y = (~x + x) y + x (y + ~y) = y + x = x+ y

Con las siguientes dos reglas se puede llegar a simplicar cualquier frmula del tipo suma de productos: 1. xy~z + x~y~z = x~z (no importa el nmero de variables) 2. x~yz + xyz + xy~z = xz + xy (porque = x~yz + xyz + xyz + xy~z)

Mapas de Karnaugh Para visualizar mejor los productos que se pueden reducir se usan tablas de verdad reordenadas, llamadas mapas de Karnaugh. Ejemplo: Mapa de Karnaugh: x 0 0 0 0 1 1 1 1 y 0 0 1 1 0 0 1 1 z 0 1 0 1 0 1 0 1 f(x,y,z) 1 1 0 1 1 0 0 0 f(x,y,z) = # ~y~z + # ~xz ~xyz + x~y~z 1 ~x~y~z + ~x~yz + x \ yz 0 00 1 ~x~y~z 1 x~y~z 01 1 ~x~yz 0 11 1 ~xyz 0 0 10 0 ! ! ! Fijense en el orden de yz !

Principio fundamental: en una mapa de Karnaugh los trminos que se originan de dos celdas adyacentes siempre dieren en una sola variable (Gray code). x \ yz Los mapas son circulares: f(x,y,z) = x~z 1 1 x~y~z Un 1 se puede usar ms de una vez en una simplicacin, aprovechando que ~x~y~z = ~x~y~z + ~x~y~z f(x,y,z) = ~y~z + ~x~z x \ yz 0 00 1 ~x~y~z 1 1 x~y~z 0 0 01 0 11 0 0 0 1 xy~z 10 1 ~xy~z 0 0 00 0 01 0 11 0 10 0

Se pueden agrupar bloques adyacentes: Agrupando 2n 1 se eliminan n variables. Cada 1 debe ser cubierto al menos una vez. f(x,y,z) = ~yz + yz = z

x \ yz 0

00 0

01 1 ~xy~z

11 1 ~xyz 1 xyz 11 0 1 0 0

10 0

1 xy~z

Por 4 variables: ! Fijense en el orden de xy ! f(x,y,z,w) = # ~x~y~z + # # ~xyzw+ # # ~y~w

xy \ zw 00 01 11 10

00 1 0 0 1

01 1 0 0 0

10 1 0 0 1

Observe que la funcin sin simplicar require 18 AND y 5 OR, mientras que al simplicarla queda en 6 AND y 2 OR. Mapas de Karnaugh de cualquier tamao El problema se reduce a encontrar secuencias de los valores binarios en que los elementos adyacentes dieren en un solo bit (n-bit Gray codes). S1 = 0, # 1 S2 = 00,# 01, # 11, # 10, S3 = 000, # 001, # 011, # 010, # 110, # 111,# 101, # 100 ... informalmente: Sn+1 = 0.Sn + 1.invertir(Sn)

Problema: Construir un circuito que calcule la suma de 3 nmeros binarios de 1 bit x,y,z, dando como resultado un nmero de 2 bits c, r (acarreo y resultado) . Tabla de verdad y mapas de Karnaugh: x 0 0 0 0 1 1 1 1 y 0 0 1 1 0 0 1 1 z 0 1 0 1 0 1 0 1 c 0 0 0 1 0 1 1 1 r 0 1 1 0 1 0 0 1 x \ yz 0 1 00 0 0 01 0 1 c = xy + yz +xz 11 1 1 10 0 1 x \ yz 0 1 00 0 1 01 1 0 11 0 1 10 1 0

r = x~y~z + ~x~yz +xyz +~xy~z

Diagrama circuital:
03_Sumador (1 of 1)
X 0

Y 0

Z 0

0 R

0 C

Propuesto: usando lgebra de Boole, muestre que si se remplazan tanto AND como OR por NAND en este circuito, el circuito sigue calculando la misma funcin. Problema: Construir un sumador de 2 nmeros binarios de 4 bits cada uno. Solucin 1: usando la metodologa recin vista. ! Con 8 entradas, la tabla de verdad tiene 256 las ! Demasiado largo. c x y 1 0 1 1 0 0 1 0 1 1 0 0 1 0 1 1 0 Diagrama circuital: 04_Sumador4Bit (1 of 1) Se suma cada columna con un sumador de 3 bits. Solucin 2: usando el circuito sumador de 3 bits.

0 X3 0 Y3

0 X2 0 Y2

0 X1 0 Y1

0 X0 0 Y0 0

0 Z3

0 Z2

0 Z1

0 Z0

Funciones incompletamente especicadas Es frecuente que el valor de una funcin ante ciertas entradas pueda ser 0 o 1. Eso se anota con X en la posicin correspondiente de la mapa de Karnaugh: f(x,y,z,w) =# # # # # # # x+ z+ yw + ~y~w xy \ zw 00 01 11 10 00 1 0 X 1 01 0 1 X 1 11 1 1 X X 10 1 1 X X

Las X se hacen valer 1 si esto es conveniente para obtener una frmula ms pequea.
10

Sistemas Secuenciales
Un circuito secuencial es un circuito en donde las salidas no slo dependen de los valores de las entradas en el presente, sino que tambin dependen de un estado interno del circuito. Este estado interno vara en funcin de las historia de los valores de las entradas. Denicin: Diagrama de tiempo es un grco de los valores que toman un conjunto de lneas (seales, conexiones) en funcin del tiempo.

1 x 0 x
AND

c = xy

1 y 0 1 c 0 1 r 0 t

r = x!y
XOR

Ejemplo: Circuito C3 con su diagrama de tiempo En C3, los valores de c y r se calculan en funcin de los valores de x e y en el mismo instante. (En la prctica, el cambio en c o r siempre se produce con un pequeo retardo, despus que cambian x o y, hoy es +- 10 picosegundos = 10-11 segundo) La echa indica causalidad: el cambio de x origina el cambio en r. Al contrario, no hay causalidad entre el cambio de x e y. En un diagrama de tiempo, no es necesario colocar todas las echas de causalidad, slo se colocan aquellas que sean tiles para el lector del diagrama. Resumiendo: en el ejemplo de circuito combinacional C3 ! # ! # c(t) = f(x(t),y(t)) r(t) = g(x(t),y(t))

Denicin: Reloj () es una compuerta que genera una seal que cambia peridicamente de valor.
Pulso de bajada T Pulso de subida

Valores tpicos de perodo del reloj T = 125 microsegundos a 0.3 nanosegundos. frecuencia = f = 1/T = 8Mhz a 3.3 Ghz
11

Circuitos Secuenciales En este tipo de circuitos, las salidas no slo dependen de las entradas, sino que tambin dependen del estado interno del circuito. Concretamente: 1. Un circuito secuencial posee un nmero nito de estados. En un instante dado el circuito se encuentra en uno y solo uno de sus estados. 2. Una de las entradas del circuito secuencial se denomina el reloj. El intervalo entre dos pulsos de bajada del reloj es un ciclo del circuito. El estado del circuito se mantiene constante durante un ciclo del reloj. 3. En un instante dado, el circuito calcula sus salidas en funcin de sus entradas, exceptuando el reloj, y de su estado interno. 4. Al nal de cada ciclo (justo antes del pulso de bajada del reloj) el circuito calcula su estado vlido para el prximo ciclo en funcin de su estado actual y sus entradas. Un circuito secuencial actua como circuito combinacional dentro de un ciclo. Si cambian sus entradas, tambien pueden cambiar sus salidas. Especicacin de circuitos secuenciales: Diagrama de estados Un diagrama de estados especica formalmente el comportamiento de un circuito secuencial.
0*/0 11/1 00/0 10/0 11/1 *0/0 01/0 xy/z 1*/1 01/1

Ejemplo: Diagrama de Estados E1 para un circuito con entradas x e y y salida z. Los crculos rotulados representan los estados del circuito. Las echas representan las transiciones de estado y los rtulos especican las salidas en funcin de las entradas para el estado del cual sale la echa. El comportamiento informal de un circuito secuencial se aprecia mejor en un diagrama de tiempo.
x y z

B
12

Un diagrama de estados especica completamente un circuito secuencial. Por lo tanto por cada estado salen echas con rtulos para todas las combinaciones de entradas posibles. El * en una entrada se usa para especicar 2 rtulos simultneamente: uno con esa entrada en 0 y el otro en 1. Al contrario de un diagrama de estado, un diagrama de tiempo es una especicacin incompleta del circuito. Pueden haber muchos diagramas de estado que satisfacen el mismo diagrama de tiempo. Pero dado un diagrama de estado, un estado inicial y valores para sus entradas durante un intervalo de tiempo, el diagrama de tiempo para sus salidas es uno y slo uno. Sin embargo, un problema usual es encontrar al menos un diagrama de estado que satisfaga un diagrama de tiempo. Por ejemplo, el siguiente diagrama de tiempo describe informalmente un circuito detector de secuencias 1 1 en su entrada.
x y

Observe que el circuito secuencial solo puede registrar lo que sucede al nal de cada ciclo. El circuito puede sealar que hubo dos 1 consecutivos an cuando x tuvo una corta transicin a 0 en la mitad del ciclo. Un diagrama de estado para este diagrama de tiempo es:
1/0 0/0

A
0/0 1/0 0/1 1/1

Los rtulos subrayados son necesarios para que este diagrama de estado satisfaga el diagrama de tiempo anterior.

13

El circuito secuencial mnimo: el Flip-Flop Data

d d q q

Data

1/0 0/0

A
0/1

1/1

En un ciclo, el valor de q es el valor que tenia d justo antes del comienzo del ciclo (i.e. el pulso de bajada del reloj). El ip-op data es el primero de los biestables que veremos. Es importante porque permite almacenar un valor binario durante todo un ciclo. Si se desea almacenar varios bits basta colocar varios ip-op en paralelo. Los microprocesadores usan ip-ops data para almacenar los registros.
qn
d Data q

dn

n+1 ...
Reg

n+1

!
q0
d Data q

d0

Implementacin de circuitos secuenciales El problema esencial es representar y almacenar el estado interno del circuito. Supongamos que sabemos implementar el ip-op data. Entonces podemos codicar los estados de cualquier circuito secuencial en la forma de nmeros binarios y luego utilizar ip-ops data para almacenar la codicacin elegida.

14

Forma general de la implementacin de un circuito secuencial: Este circuito secuencial puede poseer a lo ms 2 n estados posibles. En cada ciclo el circuito combinatorio recibe las entradas del circuito secuencial: (X) y la codicacin del estado actual (Q), los que usa para calcular las salidas (Y) y la codicacin del prximo estado (D). El registro almacena D en el pulso de bajada del reloj y se lo enva al circuito combinatorio (Q), lo que marca el comienzo de un nuevo ciclo.

Y Circuito Comb.

Entradas
Q

Salidas
D

n Q Reg D

Metodologa de diseo de un circuito secuencial, a partir de un diagrama de estado Presentaremos esta metodologa aplicando al diagrama de estados E1 Primero: Codicacin de estados: para representar 3 estados, se necesitan log2 3 ip-ops data: Estado A B Segundo: Tablas de verdad: a partir del diagrama del estado se construye una tabla de verdad para especicar las salidas Z, d1 y d0 del circuito combinacional. C q1 0 0 1 q0 0 1 0

q1 q0 A A A A B B B B 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1

x 0 0 1 1 0 0 1 1

y 0 1 0 1 0 1 0 1

d1 d0 1 1 0 1 0 1 0 0 0 0 1 0 0 0 0 0

z 0 0 0 1 0 0 0 1 C C C C ? ? ? ?

q1 q0 1 1 1 1 1 1 1 1 0 0 0 0 1 1 1 1

x 0 0 1 1 0 0 1 1

y 0 1 0 1 0 1 0 1

d1 d0 0 0 0 0 X X X X 0 1 1 1 X X X X

z 0 1 1 1 X X X X

15

Tercero: Mapas de Karnaugh y frmulas algebraicas

q10 \ xy 00 01 11 10

00 1 0 X 0

01 1 1 X 0

11 1 0 X 0

10 0 0 X 0

q10 \ xy 00 01 11 10

00 0 0 X 0

01 0 0 X 1

11 0 0 X 1

10 1 0 X 1

d1 = ~q1~q0~x + ~q1~q0y +~q1~xy

d0 = q1y +~q0x~y

q10 \ xy 00 01 11 10

00 0 0 X 0

01 0 0 X 1

11 1 1 X 1

10 0 0 X 1

z = xy + q1y + q1x

Cuarto: Diagrama circuital completo (ejercicio): basta hacer el circuito para el circuito combinacional y insertarlo en el circuito secuencial.

16

Implementacin de Biestables
Previo: Tiempos de Retardo Hasta el momento se ha supuesto que las salidas de una compuerta elemental (ej: AND) se calculan en forma instantnea. En un diagrama de tiempo, esto se gracara:

x(t)
AND

x z(t) = x(t).y(t) y z

y(t)

En la realidad una compuerta calcula sus salidas con un cierto tiempo de retardo :

x(t)
AND

x z(t) = x(t-!).y(t-!) y z !

y(t)

No todas las compuertas tienen el mismo retardo, pero por simplicidad supondremos el mismo tiempo de retardo para todas las compuertas bsicas. Para n compuertas bsicas anidadas (puestas en cascada) el tiempo de retardo es T = n. Para un sumador de nmeros de n bits que usa el circuito sumador de 3 bits en cascada (i.e. la generalizacin del sumador de 4 bits visto en la n de circuitos combinacionales). Si en un instante dado el bit menos signicativo de un argumento cambia, despus de cuanto tiempo se ha calculado la nueva suma? Solucin: Si cada sumador de 3 bits tiene un retardo 3, T = 3n

17

El Biestable Reset/Set

~R

~R ~S

~Q Q

~S ~Q Q

Descripcin: Cuando ~R = ~S = 1, Q y ~Q se mantienen constantes y con valores opuestos: ! Si ~R 0 Q 0, ~Q 1 1 ! ! Si ~S 0 Q 1, ~Q 0

~R 0 ~Q

~S = ~R = 0 esta prohibido ! (Por que ?)

Q 1

Observacion: R viene de Reset, y S de set. ~S La negacin sobre R y S (~R y ~S) signica 0 que la accin Reset o Set se produce cuando la seal est en 0 (y no en 1). Existe un biestable que usa R y S, pero histricamente ha sido ms caro de fabricar, (usa NOR en vez de NAND) entonces no se usa. El Latch

WR

L WR

~Q
L

Q
Q

L 0 ~R ~S

~Q 1 0 Q

Descripcin: Mientras WR = 1, Q = L. Cuando WR = 0, Q vale lo que tena L justo antes del pulso de bajada de WR.
18

0 WR

El Flip-Flop Data

~Q Q

D 1 Latch

~Q 0 1 Q

Latch

D WR

Latch

Q ~Q

D WR

Latch

Q ~Q

WR = 1 en Pulso de subida

WR = 1 en Pulso de bajada

La implementacin visto es de un registro master/slave: equivalente a un ip-op data pero mas robusto, porque el ip-op data depende de los tiempos de retardo:. Ejercicio: Verique en un diagrama de tiempo que el Flip Flop Data slo cambia en el pulso de bajada de . Para ello je valores para D y y en los valores iniciales de l y Q. Luego calcula L, Q y ~ en funcin de D y . Observacin: El latch no sirve para hacer circuitos sequenciales. Ejemplo: en el siguiente circuito secuencial si se reemplaza el Flip Flop Data por un latch: Cuando est en 1, Q adquiere valores oscilatorios que difcilmente pueden servir para algo.

! Q D

L
WR

WR Q L

19

Diseo Modular de Circuitos

El nmero de las de la tabla de verdad de un circuito combinacional aumenta exponencialmente con el nmero de entradas (mientras que el nmero de columnas aumenta linealmente con las entradas y salidas). Esto signica que la metodologa que vimos no sirve para circuitos que tienen muchas entradas. Los circuitos complejos (con muchas entradas) se disean acoplando circuitos ms simples. Esto ltimo se denomina diseo modular. Estrategias de Diseo Modular Primero: Diseo en Paralelo: Ejemplo a la derecha. Las salidas de 1 no dependen de ninguno de los clculos que se hacen en 2, y viceversa 1 es completamente independiente de 2. Segundo: Diseo en Cascada: Por ejemplo el sumador de nmeros de n bits que usa el circuito sumador de 3 bits en cascada. Una de las entradas de cada sumador de 3 bits (el carry) depende de una salida de otro sumador de 3 bits. Tercero: Diseo Serial o Secuencial. El clculo se descompone en n etapas o clculos intermedios. Cada uno de estos clculos se ejecuta en un ciclo del reloj. La idea es utilizar el mismo mdulo para realizar los n clculos intermedios en n ciclos. Ejemplo: un sumador serial.

x0 x1 y0 y1
x0 x1 y0 y1

z0 z1

x0y0 x1y1

1
AND

z0

2
AND

z1

Cuarto: Diseo en Pipeline: Esto se ver al nal del curso. Estrategias de comunicacin entre mdulos Primero: Punto a Punto# #
1 2

Segundo: 1 a n#
1 2

#
1

Tercero: n a 1

MUX

Cuarto: Bus
1 2 3

20

Elementos modulares para el diseo de circuitos Decodicador Descripcin: si EN = 0 todos los Qj estn en 0. si EN = 1 y el valor de A2-A0 es i, entonces Qi = 1 y el resto = 0.
Decod 3x8 Q7 A2 Q6 A1 A0 Q1 Q0

Qj =

0 si EN = 0 0 si i ! j, EN = 1 1 si i = j, EN = 1

...

...

EN

Implementacin:

...
0

21

Descodicador de 6x64 Se usan 9 decodicadores 3x8 puertas en cascada y/o paralelo.

EN A5 A4 A3 A2 A1 A0

EN Q7 ...

Decod 3x8 Q1 Q0

Decod 3x8 ... EN

Q0 Q1 Q7

Cascada

Decod 3x8 ... EN

Q8 Q9 Q15

...

Paralelo

Com punto a punto

Com 1an
Decod 3x8 ... EN Q63 Q56 Q57

22

Multiplexor:
x3 x2 x1 x0 z=xi

MUX A0 A1 i

x3 x2 x1 x0 EN Decod 2x4

Implementacin usando compuertas tristate: # y = x si c = 1, y = tristate si c= 0

x y x y

A0 A1
x3 x2 x1 x0 EN Decod 2x4

Una salida en estado tristate est desconectada y por lo tanto no hay corto circuito si otra fuente aplica un potencial a la misma lnea.

A0 A1
1 0 1 0 1 0 1 0

1 1

0 0

1 !corto!

0 tristate

Sumador Serial El sumador recibe serialmente dos nmeros binarios de menor a mayor signicancia. La suma comienza cuando H pasa de 0 a 1 y termina cuando ! H pasa de 1 a 0.
H

x y H

SUM

x y r c

XXXXXXXX
0 0 1 1

XXX

23

c out SUM 3 bits c r c in

Control

Diseo modular en serie: se reutiliza el sumador de 3 bits ya visto y se introduce un circuito sequencial que se acuerda del acarreo c.
0*/X 10/0 H Cin/Cout 11/1

Diagrama de estados para el circuito Control (estados = carry generado en el ciclo anterior).

11/0

c=0
10/1 0*/X

c=1

Left Shifter / Right Shifter

Xn-1 Yn-1 Xn-2 Yn-2 X << m X0 Y0 Yj = Y=x<<m X Xn-1 Yn-1 Xn-2 Yn-2 >> m X0 Y0 X0 0 si j >= n-m Xj-m si j < n-m 0 Y0 Y=x>>m << 1 Xn-1 Xn-2 Yn-1 Yn-2

Yj =

0 si j < m Xj-m si j >= m

Solo mostramos la implementacin de <<1 Ntense que m es una constante ja para el circuito. Ms tarde usaremos estos circuitos para implementar un circuito que reciba m como argumento. Conditional Left Shifter / Right Shifter
n X X Y Y X << m? C n n X Y Y X >> m? C C Y= n X >> m A=1 A=0 MUX A Y Y

X si c = 0 X << m si c = 1

Y=

X si c = 0 X >> m si c = 1

Solo mostramos la implementacin de >>m?

24

Barrel Shifter Implementacin: usando las siguientes propiedades: m = K0.20 + K1.21 + K2.22 + K3.23 + K4.24 + K5.25 # y! x<<(n+l) = (x << n) << l

x << m = (((((x << K5.25) << K4.24) << K3.23) << K2.22) << K1.21) << K0.20 Usando esta ltima frmula haremos una implementacin en cascada.

<< 32? X C

<< 16? C ...

<< 1? C Y

K5 K4 ... K0

La Multiplicacin en Cascada
X Y 0101 * 1010 0000 Si es 0, la la es 0 0101 0000 Si es 1, la la es 1 + 0101 Z 0110010
4 X 4 Y

Ext 4!8 8 .c Y0
X.Y0

La multiplicacin en binario es ms simple que la misma en decimal. El resultado del producto de 2 nmeros de n bits tiene 2n bits como mximo. Para la implementacin necesitamos un circuito que extiende un nmero de n bits a uno de m bits, agregando 0 a la izquierda, y un multiplicador por un valor de un bit (es decir, calcula x. 1 o x.0). La implementacin de ambos es trivial (Primero: inputs siempre 0. Segundo: usando compuertas AND).

<< 1 Y1 .c
(X<<1) .Y1

<< 1 .c

+ Y2
(X<<2) .Y2

<< 1 .c

+ Y3
(X<<3) .Y3

+ 8 Z

25

El problema de este circuito es que es my costoso. Para multiplicar cantidades de 32 bits se requieren 31 sumadores ! Por esta razn, los microprocesadores ms econmicos realizan una multiplicacin en serie. Pseudo-code: Mult (x,y de 32 bits){ sea Rx de 64 bits = Ext 3264 (x); sea Ry de 32 bits = y; sea Rz de 64 bits = 0; while (Ry != 0) { if(Ry[0] != 0) Rz += Rx; Rx := Rx << 1; Ry := Ry >> 1; } return Rz; } La multiplicacin en serie se implementar en un circuito con el siguiente diagrama de tiempo.

!
H x y rdy z

XXXXXXXX XXXXXXXX

a b

XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

XXXXXXXXXXXXXXXXXXXXXXXXXX

a*b

La transicin de 0 a 1 en H indica que en x e y hay valores que deben multiplicarse. El multiplicador calcula de a un bit por cada ciclo.

26

Implementacin:

32 Y X 32

>> 1

A=0 MUX A=1 A Ry Ry[0]

rdy

Ext 32!64 << 1

A A=1 MUX A=0

Rx

.c +

.c H Control

Rz

!
64 Z

27

Arquitectura Lgica
Es la visin que tiene un programador de la mquina, sin importar su implementacin. Se preocupa de: La representacin de los nmeros y datos Las operaciones realizables En lenguaje de mquina o conjunto de instrucciones. Representacn de nmeros La mquina representar los nmeros en palabras de 8, 16, 32 o 64 bits. Una palabra es una secuencia de bits y sirve para almacenar enteros sin signo, enteros con signo, caracteres, nmeros reales, etc. Usaremos la siguiente notacin para una palabra x de n bits : x = |xn-1 xn-2 ... x1 x0| El valor numrico almacenado en la palabra x depende de la representacin usada: Primero: Enteros sin signo# [[x]]u = i=0n-1 xi2i

Observe que [[ ]]u es una funcin que recibe una secuencia de bits (una palabra) y entrega un numero [0,2n-1] Segundo: Enteros con signo# # # # # # [[x]]s #= [[x]]u si x = |0 xn-2 ... x1 x0| # = [[x]]u-2n si x = |1 xn-2 ... x1 x0|

Con [[ ]]s : palabra de n bits [-2n-1, 2n-1-1[ En el siguiente grco se observa la diferencia entre [[x]]u y [[x]]s para n = 3 [[000]]s = 0 , [[011]]s = 2(3-1)-1 = 3, [[100]]s = -(2(3-1))-(23) = -4 , [[111]]s = -1
7 6 5 4 3 2 1 0 -1 -2 -3 -4 000 001 010 011 100 101 110 111 Unsigned Signed

28

Tercero: Nmeros reales de precisin simple (norma IEEE) ! ! [[ | s | exp1 ... exp7 | frac0 ... frac22 | ]]f ! ! ! = 1.frac.2(exp-127).1 si s = 0 ! ! ! = 1.frac.2(exp-127).-1 si s = 1 ! ! ! Adems exp ~= 0 y exp ~= 127

Cuarto: Nmeros reales de precisin doble (norma IEEE) ! ! [[ | s | exp1 ... exp10 | frac0 ... frac51 | ]]f ! ! ! = 1.frac.2(exp-1023).1 si s = 0 ! ! ! = 1.frac.2(exp-1023).-1 si s = 1 ! ! ! Adems exp ~= 0 y exp ~= 1023

No todas las arquitecturas ofrecen nmeros reales por hardware. Ej: M32 (que veremos ms tarde) no lo ofrece. Operaciones entre enteros: Suma de enteros Sea x, y palabras de n bits. sumador(x,y) = {x y, Carry(x,y)} es la salida del sumador visto en clases truncado a n bits y corresponde a la suma de palabras. En general se cumple que el nmero representado por la suma de las palabras x e y es la suma de los nmeros representados por x e y. Es decir: ! ! 0 0 1 1 0 0 ! 0 1 0 1 1 0 ! u u + [[x y]]u =?= [[x]]u+ [[y]]u 5 3 0 1 [1] 0 1 1 1 0 1 0 1 1 0 u u + 5 15

u 8

u 4

Pero dado que el resultado de se trunca a n bits, la suma no coincide cuando hay desborde. Observe que 5 + 15 = 20 no es representable en 4 bits. Veamos qu ocurre cuando vemos las misma suma pero usando enteros con signo: 0 0 1 1 0 0 0 1 0 1 1 0 s s + 5 3 0 1 0 1 1 1 0 1 0 1 1 0 s s + 5 -1

s -4

s 4

5+3 = 8 no es representable en 4 bits con signo. La idea fundamental es que coincide con la suma si el resultado de la suma es representable en n bits.
29

Matemticamente escribimos: [[x y]]u =mod2n= [[x]]u + [[y]]u y [[x y]]s =mod2n= [[x]]s + [[y]]s con a =modm= b a modm = b modm.

Conclusin fantstica: el sumador visto en clases sirve para sumar nmeros sin signo y nmeros con signo. De ah el inters de la representacin usada para los enteros con signo. Resta de Enteros Denicin:! ! Propuesta: [[x - y]]u =mod2n= [[x]]u - [[y]]u y [[x - y]]s =mod2n= [[x]]s - [[y]]s x - y = x ~y 1

1
-

1 1 0

0 0 0

1 1 0

u u -

13 5
-

1 0 1

1 1 0

0 0 0

1 1 0

s s -

-3 5

1 1 1 1 1 0 0 0 1 0 1 0 0

0 1

u 8

s -8

Conclusin ms fantstica: el sumador visto en clases nos sirve tambin para restar nmeros, con signo o sin signo. En realidad, la representacin de los nmeros con signo se escogi cuidadosamente de manera que el mismo sumador sirviera para realizar todas las operaciones. Esto se debe a que en los primeros computadores colocar circuitos distintos para realizar estas 4 operaciones (2 sumas y 2 restas) era demasiado caro.

30

Conversion entre palabras de distinto tamao Reduccin: se eliminan los bits ms signicativos. # # Trunc nm ( | xn-1 ... xm-1 ... x0 | ) = | xm-1 ... x0 |

Propuesta: [[Trunc nm(x)]]u =mod2m= [[x]]u [[Trunc nm(x)]]s =mod2m= [[x]]s Si una palabra de n bits contiene un nmero representable en m bits, la operacin de truncacin no altera el nmero representado. 0 0 1 0 1 u 5 0 0 1 0 1 s 5

Trunc 54 0 1 0 1 u 5 u 26

Trunc 54 0 1 0 1 s 5 s -6

Trunc 54 1 0 1 0 u 10

Trunc 54 1 0 1 0 s -6

(porque 26 no es representable en 4 bits, en cambio, -6 si) Extensin sin signo: Se agregan 0s a la izquierda Denicin: Ext umn ( | xm-1 ... x0 | ) = | 01 ... 0n-m xm-1 ... x0 | Propuesta: [[Extumn(x)]]u = [[x]]u

u 13

s -3

Extu45 0 1 1 0 1 u 13 0

Extu45 1 1 0 1 s 13

Observe que al extender una palabra con ceros su valor sin signo se preserva. Sin embargo su valor con signo no necesariamente se mantiene, a pesar que el nmero -3 es representable en 5 bits.
31

Extensin con signo: se repite el bit de signo. Denicin: Ext smn ( | xm-1 ... x0 | ) = | xm-1 ... xm-1 xm-1 ... x0 | # Propuesta: [[Extsmn(x)]]s = [[x]]s # (n-m veces xm-1)

u 13

s -3

Exts45 1 1 1 0 1 u 20 1

Exts45 1 1 0 1 s -3

Conclusin: La truncacin es la misma para nmeros con signo y sin signo, pero la extensin es distinta. Esto no es grave, porque sigue siendo trivial hacer un circuito que extienda con o sin signo de acuerda a lo que diga una de sus entradas.

32

Intel x86 Assembler

x86 no es una CPU, sino que es una arquitectura. Primera CPU de 16 bits: Intel 8086, 1978. Con un conjunto de instrucciones IA-16. Primera CPU de 32 bits: Intel 80386, 1985. Con un conjunto de instrucciones IA-32, compatible con IA-16. Primera CPU de 64 bits: AMD Athlon 64, 2003. Con un conjunto de instrucciones AMD64, no compatible con Intel IA-64, x86-64 y IA-64, pero compatible con IA-32. ! Nosotros nos centraremos en mostrar el conjunto de instrucciones IA-32

Propiedades Bsicas de la Arquitectura: CISC (Complex Instruction Set Computer), instrucciones de largo variable Little-Endian 8 registros para uso general, 8 registros de punto otante Pila Registros Registro: memoria de la CPU. Casi todas las operaciones son llevadas a cabo usando registros como fuente de informacin o como destino.

! ! {A, B, C, D}
8 bit 8 bit

!H
8 bit

!L
8 bit 8 bit 8 bit 8 bit SI ESI = stream source 8 bit 8 bit 8 bit 8 bit DI 8 bit 8 bit

!X
E!X 8 bit 8 bit 8 bit

EFLAGS Overow, Carry, Sign, Zero Direction, Aux Carry, Interrupt, Parity, 8 bit ...

EDI = stream dest 8 bit 8 bit BP EBP = stack base pointer 8 bit 8 bit 8 bit 8 bit SP 8 bit 8 bit

8 bit

8 bit

8 bit

EIP = instruction pointer

ESP = stack pointer

No hablamos de los registros segment, kernel, application special purpose, punto otante.
33

Preliminaries Los diferentes ensambladores existentes en el mercado usan diferentes sintaxis para escribir programas. En este apunte nosotros usaremos la sintaxis de GNU Assembler (GAS) = AT&T sintaxis para escribir (otro standard : sintaxis Intel). Para ver un programa de ejemplo: gcc -S -O helloworld.c El tamao de la memoria que se use para operar debe ser especicado poniendo como sujo de la instruccin, sino no puede ser determinada automticamente Sujos: b = byte = 8 bit, w = word = 16 bit, l = long = 32 bit Instrucciones Aritmticas Una instruccin contiene los siguiente argumentos: dest (destino): Puede ser un registro o una ubicacin en memoria. src (fuente): Puede ser un registro, una ubicacin la memoria o una constante. Si dest es un argumento entonces el resultado esta contenido en dest. Uno de los dos argumentos debe ser un registro (add, sub, adc, sbb).

add src, dest sub src, dest adc src, dest sbb src, dest inc dest dec dest neg dest

Add/subtract contents of mul src Unsigned/signed multiply src by src to/from dest. imul src value in corresponding register (see below). Add, setting carry bit Subtract using carry bit. Faster add 1, dest Faster sub 1, dest = dest * -1 div src Unsigned/signed divide value in idiv src corresponding register by src (see below). If quot does not t, arithmetic overow interrupt.

mul arg / imul arg op size 8 bits 16 bits 32 bits arg 2 AL AX EAX dest high AH DX EDX dest low AL AX EAX op size 8 bits 16 bits 32 bits

div arg / div arg dividend AX DX,AX EDX,EAX remain AH DX EDX quot AL AX EAX

Ejemplo (# indica un comentario) inc %eax! ! ! incl %eax!! ! add $42, %bh! ! addb $0x2A, %bh! sbbw %ax, %bx! ! # # # # # add 1 to the value in the register eax idem add 42 to the value in the register bh idem subtract ax from bx, result is in bx

Los operadores $42 y $0x2A se llaman immediate operands.(operadores inmediatos)

34

Addressing modes, MOV and LEA La instruccion mov es usada para mov src, dest copiar informacin desde la memoria a un registro, desde un registro a memoria o desde la memoria a otra ubicacin de la memoria. Copy data from src to dest

La forma ms fcil de usar la instruccin mov es copiando operados dentro de registros o copiar valores desde un registro a otro de manera inmediata. Ejemplo: movl $42, %eax movb %ah, %bl Para mover informacin entre la memoria y los registros, dos maneras de direccionamiento son usadas por la memoria operando: displacement addressing mode y register indirect addressing mode. La manera bsica de direccionar memoria es llamada direccionamiento directo (direct addresing mode) o solo desplazamiento (displacement addressing mode). La direccin sera un desplazamiento desde la base de la memoria, 0. mov copia informacin desde una ubicacin de la memoria a un registro o desde un registro a una ubicacin en la memoria. Example code: .data! ! foo:!! ! ! .int 2! [...] .text! ! ! .global _main !! _main: [...] ! movl $6, foo! ! ! ! ! [...] #seccion de texto, el codigo va aqui #una funcion global llamada _main ! ! ! #seccion data, para declarar varibles globales #variable llamada foo #es un entero con valor 2

#copia 6 a la ubicacion #de la memoria de foo

35

El direccionamiento indirecto (register indirect addressing mode) permite direccionar indirectamente una ubicacin de la memoria a travs de un registro. El operando no es la direccin actual sino que el es valor especico de la direccin a usar. Esto es similar a usar punteros en C. Para calcular la direccin sern necesarios 4 parmetros. Por lo tanto la direccin vendra dada por: disp + base + index * scale disp(base, index, scale) keyword disp base index scale meaning displacement base register index register examples foo(,1) (%eax) -4(%ebp) foo(,%eax) dereferencing what foo pointer (not in a register) address in eax address 4 bytes above stack base foo array index eax, if foo contains 1byte sized data

constant 1, 2, foo(,%eax,4) foo array index eax, if foo contains 44 or 8 byte sized data 0(%eax,%ebx,2) index ebx of array starting in eax, if contains 2-byte sized data

Ejemplo: Dado int i, *a, r; calcula r = (-a[i]) * 10; Suponiendo i in ebp - 4, a in ebp - 8, r in ebp - 12 movl -4(%ebp), %eax ! ! movl -8(%ebp), %ebx!! ! movl 0(%ebx,%eax,4), %eax! negl %eax!! ! ! ! imull $10, %eax! ! ! movl!%eax,-12(%ebp)!! ! #get i #get a #get a[i] #-a[i] #(-a[i]) *10, truncate to 32 bits #copy to r

Todo direccionamiento a la memoria se puede hacer as, tambin cuando se esta haciendo una operacin aritmtica. Es til por el ejemplo si queremos tener un loop: inc -4(%ebp) ! ! #i++ Para cargar dentro de un registro una direccin de memoria hay que usar load effective address . Ejemplo: lea 0(%ebx,%eax,4), %eax! ! lea foo, %eax! ! ! ! lea mem, reg Load the address of the memory location mem into reg

#copy address of a[i] (above) to eax #copy address of foo in eax

Para aumentar el tamao de una variable (Ej: de byte a int), se usan las operaciones move and extend. Estas operaciones reciben dos sujos: tamao de la fuente y tamao de destino. Ejemplo: movb $-204, %al movsbw %al, %bx movs src, dest movz src, dest
36

Extend considering sign Extend with 0s

Pruebas y Saltos Para ejecutar un salto (Ej: para hacer un if ) hay que llevar a cabo dos pasos: 1. Hacer una operacin de prueba, que da valor a EFLAGS 2. Saltar segn sea el contenido de EFLAGS.

cmp arg1, arg2 test arg1, arg2

Like sub arg1, arg2 Bitwise AND

La ejecucin de los tests no produce ningn resultado, solo da un valor al registro EFLAGS. Los saltos van a un lugar especicado en el cdigo (Ver ejemplos). je loc jne loc jg loc jge loc jl loc jle jo loc Ejemplos: cmp %ax, %bx jg label1!! test $1, %ebx jnz sig_u:! label1: test %ah, %ah jz label3!! sig_u: cmp %al, %ah jz l_42! ! Jump on equal Jump on not equal Jump on greater Jump on greater or equal Jump on lesser Jump on lesser or equal Jump on overow jnz loc jz loc ja jae jb jbe jmp Jump on not zero Jump on zero jg for signed numbers jge for signed numbers jl for signed numbers jle for signed numbers Jump always

# salta a label1 si ax > bx # salta a sig_u si bit menos signific de ebx es 1 # salta a label3 si ah = 0 (ah && ah = ah) # salta l_42 si ah = al

Ejemplo: dado int *a, n, s = 0, i = 0 escriba while (i<n) s+= a[i++] Asuma *a en eax, n en ebx, s en ecx, i en esi movl $0, %ecx! ! ! ! movl $0, %esi! ! ! ! L1: cmp %ebx, %esi!! ! ! jge L2 movl (%eax, %esi, 4), %edx! addl %edx, %ecx! ! ! addl $1, %esi! ! ! ! jmp L1 L2: [...] #s #i #i ? n #a[i] #s += a[i] #i++

37

Operaciones Lgicas, Shift y Rotate and src, dest or src, dest xor src, dest not dest ror dest rol dest Bitwise and Bitwise or Bitwise xor Bitwise inversion rotate right 1 bit rotate left 1 bit shr dest shl dest sar dest sal dest scr arg scl arg Shift right 1 bit, pad with 0 Shift left 1 bit, pad with 0 Shift right 1 bit, pad with sign bit Shift left 1 bit, pad with 0 shr with bit shifted into carry ag shl with bit shifted into carry ag

Rotates son como shifts, salvo que el bit que se pierda es usado como relleno. Manipulacin del Stack La CPU mantiene una pila en la memoria donde el tope de la pila esta referenciado por el registro esp. Esta pila crece hacia abajo en la memoria, es decir, despus de hacer push el tope de la pila ser una ubicacin menor. Push y pop toman un immediato, registro o direccin de memoria como argumento. Tamao minimo de un push (and pop) es 16 bits push src pop dest Push value on stack, decrease esp Pop stack to dest, increase esp

Para eliminar datos desde el tope de la pila, sin tener que usar pop: addl $x, %esp (donde x es el tamao en bytes del dato). Para copiar datos desde el tope de la pila sin usar mov: x(%esp), dest (donde x es el offset del tope de la pila). Para copiar datos dentro de la pila: mov src, x(%esp) Subroutine Calls El CPU tambin tiene un registro (escondido), call lab push IP then jmp lab que se llama Instruction Pointer (IP). El IP apunta al lugar en memoria donde se encuentra ret pop into IP la instruccin que se esta ejecutando. Manipular ese registro permite saltos y subrutinas. El stack se usa de la siguiente manera para implementar llamadas a subrutinas. 1. El llamador apila argumentos en la pila en orden inverso y llama con call (lo que apila el Instruction Pointer) 2. Se encadenan los registros de activacin ebp 3. Se resguardan registros que no deben ser modicados segn la convencin del llamador 4. Se agranda el registro de activacin para variables locales 5. Se calcule el valor 6. El valor retornado queda en eax 7. Se botan los variables globales y se restituyen los registros guardados 8. El llamado retorna usando ret (lo que depila el Instruction Pointer) 9. El llamador depila los argumentos
38

Ejemplo: Llamador res = proc(arg1, arg2) Llamado int proc(int p1, int p2){ int local; [...] return local; }

Convencin de llamador: el llamado debe preservar ebx, esi, edi, esp, ebp, y puede modicar eax, ecx, edx. pushl arg2 pushl arg1 call proc movl %eax, res addl $8, %esp # # # # # paso paso paso paso paso 1 1 1 6 9 .global proc proc: pushl %ebp # paso 2 movl %esp, %ebp # paso 2 pushl %edi # paso 3 pushl %esi # paso 3 pushl %ebx # paso 3 subl $4, %esp # paso 4 [...] # paso 5 movl -16(%ebp), %eax # paso 6 addl $4, %esp # paso 7 popl %ebx # paso 7 popl %esi # paso 7 popl %edi # paso 7 leave # paso 7 ret # paso 8

#leave = #movl %ebp, %esp #popl %ebp

39

Buffer overow attacks La manera en que x86 hace llamadas a subrutinas permite fcilmente que ret no salta de vuelta a la instruccin original pero a otro lugar en memoria. Eso se logra sobreescribiendo ebp + 4 Cuando se hace ret cualquier dato en memoria a ese lugar se considera como la prxima instruccin y se ejecutara. Escribir en ebp + 4 puede ser accidental, causando un crash, pero tambin puede ser intencional, en un caso de ataque por buffer overow. Esto ultimo se puede hacer abusando la prxima funcin: int getUserID(){ ! char BUF[7]; ! [ get user id as string, ! put in BUF ] ! return [ convert BUF]; } .global getUserID getUserID: ! pushl %ebp! #p2 ! movl %esp, %ebp! ! subl $8, %esp! ! [ get user input ] [ convert to int, put in ! addl $12, %esp!! ! ret! ! ! !

#p2 #p4 eax ] #p7 #p8

Supngamos que el usuario entra 12345678....****. Eso se escribe en BUF, cual se ubica en el stack. Stack ESP + 12 ESP + ESP + ESP 8 4 Contiene **** = 0x2A2A2A2A .... = 0x2E2E2E2E 5678 1234 Debera contener ebp + 4 = IP del llamador (jmp) ebp del llamador (paso 2) BUF[4] ! BUF[6],\0 BUF[0] ! BUF[3]

(El char * tienen ascii code 42 = 0x2A, y . tiene ascii code 56 = 0x2E) Resultado: con el ret el CPU salta a la direccin de memoria 0x2A2A2A2A y ejecuta cualquier cdigo que se encuentra alla !

40

Formato de instruccin

prex

opcode 1 or 2 bytes

mod-reg-r/m

sib 1 byte

displac

immediate 0,1,2 or 4 bytes

0 ! 4 bytes

1 byte

0,1,2 or 4 bytes

mod 2 bits

reg 3 bits register operand

r/m 3 bits

scale 2 bits

index 3 bits register

base 3 bits

other operand

value

register

Ejemplos: addl # # # addl # # # %ebx # # # %esp # # # ! # # # = | 0000 0011 1110 0011 | = | opcode | mod-reg-r/m | = | 0000 0011 | 11 | 100 | 011 | = | addl | reg | esp | ebx |

-8(%ebp), # # # # # #

%esi# = | 0000 0011 0111 0101 1111 10000 | # = | opcode | mod-reg-r/m | immediate | # = | 0000 0011 | 01 | 110 | 101 | 1111 1000 | # = | addl | esi p1 | ebp | esi p2 | -8 |

El cdigo de operacin (opcode) puede ser distinto para la misma instruccin: Instruccin addl -8(%ebp), %esi addl %esi, -8(%ebp) addb %dh, -8(%ebp) addb $1, %esi opcode 0x03 0x01 0x00 0x83 Normal Invertido Bytes + Invertido Immediato motivo

Falta addw %si, -8(%ebp) . Por eso se necesita usar un prejo. El prejo 0x66 indica que los operados son de 16 bits. Entonces: addw %si, -8(%ebp)! = | 0x66 | 0x01 | ...

41

SPARC Assembler
SPARC = Scalable Processor Architecture Primero CPU: SPARC, 32 bits, 1987-1992 Primero CPU 64 bits: UltraSPARC, 1995 Arquitectura abierta y sin derechos exclusivos. ! Nosotros nos centraremos en SPARC

Architectural basic properties RISC (Reduced Instruction Set Computer) Big-Endian (hasta UltraSparc: Bi-Endian) 32 registros de uso general visibles, 32 registros de punto otante Usa ventana de registros RISC: Diseo de U.California Berkeley Set de instrucciones minimalista, fcil a descodicar Instrucciones ortogonales Meta: 1 instruccin cada ciclo del reloj Branch Delay Slot 2 implementaciones directas : SPARC y MIPS Registros r0 ... r7 = g0 ... g7 Globales r8 .. r15 = o0 ... o7 Output r16 ... r23 = l0 ... l7 Locales r24 ... r31 = i0 ... i7 Input f0 ... f31 punto otante pc program counter psr processor state register y usado por mul y div

El registro g0 siempre contiene un cero y no puede ser modicado. Por convenciones de software, algunos registros tienen usos especiales: i6, i7, o6, o7, g1 ... g7. Estos registros no se pueden usar. El programador debe usar los registros locales primero, luego i0 ... i5, luego o2 ... o5. g1 ... g4 voltiles (usado por el compilador) i6 = fp frame pointer (stack pointer del llamador), debe preservarse o6 stack pointer o7,i7 direccin de retorno

42

Llamadas y Ventanas de Registros Hay 2 32 conjuntos de 16 registros, en un momento dado, se puede ver 1 conjunto, llamada ventana de registros. Los registros in, local y out dependen de la ventana, los global son independientes. Para cambiar de ventana se usa SAVE (prxima ventana) y RESTORE (ventana anterior). o0 ... o7 son los registros i0 ... i7 de la prxima ventana: i0...i7, l0...l7, SAVE RESTORE i0...i7, l0...l7, o0...o7 i0...i7, l0...l7, o0...o7 o0...o7

Window overow: un SAVE agota los registros. El Sistema Operativo debe resguardar registros en memoria para liberar registros. Instrucciones Formatos de instruccin simple y uniforme: 32 bits (const = 13-bit signed int, address = 22-bit signed int, ! = commentario) Operaciones aritmticas / lgicas con operandos en registros opcode %reg1, %reg2, %reg3 ! reg3 = reg1 op reg2 opcode %reg1, const, %reg2 ! reg2 = reg1 op const Lectura de registros en memoria LDx [%reg+const], %reg LDx [%reg+%reg], %reg LDx [%reg], %reg Escritura de registros en memoria STx %reg, [%reg+const] STx %reg, [%reg+%reg] Instrucciones de control: saltos y subrutinas Bx address Cargar direcciones y NOP SETHI %hi(const32),%reg ! carga 22 bits de orden superior OR %reg,%lo(const32),%reg ! los 10 restantes SET const32,%reg NOP ! op sinttica del assembler ! = SETHI 0,%G0

! [%reg] = [%reg+%g0]

Ms info en el chero sparc.pdf (de http://www.cs.umanitoba.ca/~cs222/sparc.ps)

43

Ejecucin de instrucciones Conceptualmente: 1. 2. 3. 4. Fetch: instr = (%pc) %pc = %pc + 4 Examinar cdigo de operacin (primeros 8 bits) de instr Ejecutar

Nota: 1 y 2 se puede ejecutar en paralelo de 3 y 4 para mejor rendimiento. Branches y Branch Delay Slot Por lo anterior, en SPARC, la instruccin siguiente al branch tambin se ejecuta ! Lo usual es poner ah alguna instruccin cuya ejecucin tambin sea til, o bien un NOP. Lo que no se puede colocar en ese "delay slot" es otra instruccin branch, ni tampoco una instruccin SET (porque esta ltima es, en realidad, dos instrucciones).

44

Formato de instruccin Load/store: op [rs1 + rs2], rd (load) o op rd,[rs 1+ rs2] (store) (asi = address space indicator)
31 30 29 25 24 19 18 14 13 12 5 4 0

11

rd

op

rs1

asi

rs2

op [rs + siconst12 ], rd (load) o op rd, [rs + siconst13] (store)

31 30 29 25 24 19 18 14 13 12 0

11

rd

op

rs1

siconst12

Operaciones aritmticas / lgicas op rs1, rs2, rd

31 30 29 25 24 19 18 14 13 12 5 4 0

10

rd

op

rs1

rs2

op rs1, siconst13, rd
31 30 29 25 24 19 18 14 13 12 0

10
SetHI:
31 30 29

rd

op

rs1

siconst12

25 24

22 21

00

rd

100

const22

Conditional branches
31 30 29 28 25 24 22 21 0

00 a
Call
31 30 29

cond

010

disp22

01

const30

Descodicacion: Primary opcode y Secondary opcode (Inspirado por http://www.cs.unm.edu/~maccabe/classes/341/labman/node9.html )

45

Arquitectura fsica de un Computador

Consideramos el computador con la arquitectura M32 (m32-arch.pdf)
I/O CPU Memoria A D C C L K

IOC

IOC

A D C
direcciones datos control

A D C

Toda la comunicacin entre estos mdulos se realiza a travs de los buses. Hay 3 buses: 1. Bus de Datos : D31 - D0 2. Bus de Direcciones : A31 - A2, BE3 - BE0 3. Bus de Control: indica el tipo de operacin a realizar RD = lectura, WR = escritura, CLK = el reloj, WAIT = sirve para prolongar el acceso a la memoria. La CPU o procesador es el interprete del lenguaje de mquina. Todo el proceso de una instruccin se realiza internamente en la CPU. En la CPU estan los registros (R0 - R31), el contador de programa (PC) y registro de estado (SR). Los programas y los datos se almacenan en memoria.
!
RD WR A D

Examinemos en un diagrama de tiempo la ejecucin de la instruccin stw R2, [R3+8].

XX PC XX inst 1 2 3 4 XXXXX XXX R3 + 8 X R2 5 XXX

Esta instruccin se codica en una palabra de 32 bits en memoria.

Para ejecutar una instruccin, el procesador pasa por 3 fases: I. Fetch: En esta fase se carga la instruccin que est en la memoria en un registro interno de la CPU. La fase fetch se ejecuta en 2 ciclos del reloj. (1) La CPU coloca el PC en el bus de direcciones. (2) La CPU activa RD y mantiene el PC en el bus de direcciones. La memoria responde a la seal RD colocando el contenido de la direccin especicada. II. Decodicacin: En esta fase el procesador examina la instruccin y decide como ejecutarla. Para esto se necesita solo el ciclo (3) III. Ejecucin: En esta fase se ejecuta la instruccin. Esta fase depende del cdigo de operacin de la instruccin. Como la instruccin es un stw la CPU la ejecuta en 2 ciclos: (4) La CPU calcula la direccin como R3+8 y la coloca en el bus de direcciones.(5) la CPU mantiene la direccin en el bus y activa la seal WR. Al mismo tiempo coloca R2 en el bus de datos. La memoria modica el contenido de la direccin especicada con el dato que aparece en el bus.
46

La Memoria
Existen varios tipos de memoria: SRAM, DRAM, SDRAM, ROM, EPROM, Flash ... SRAM = Static Random Access Memory Memoria esttica de acceso aleatorio. Son rpidas, se borran si se apagan, necesitan 4 o 6 transistores por bit. Se etiquetan como [numero de palabras] x [ancho de palabra] y [tiempo de acceso].
Direccin Read Write Chip Select RD, CS

A17-A0 256K x 8 RD 12 ms WR CS D7-D0

A Datos D

X XX
Tiempo de accesso

Comportamiento en un diagrama de tiempo: El tiempo de acceso es el tiempo transcurrido desde que se coloca una direccin en A hasta que la memoria entrega el dato.
RD Din L WR WR Latch Q Dout

Implementacin: Este tipo de chip se puede implementar usando latches para cada bit. Se usa un descodicador para seleccionar la palabra que se va a escribir o leer.

N columnas WR = 0

Bit A
M

...
WR = 1

WR CS RD

Decod M+1 x M+1 2 EN

...
2M las

... ...

DN-1
47

DN-2

D0

Para conectar este chip a la CPU, hay que resolver varios problemas: Primero : Tamao de palabra del bus de datos (32) y el ancho de memoria (8) no coinciden. Por lo tanto hay que colocar varios chips en paralelo: (todo los chips se activan al mismo tiempo). (A1 y A0 siempre son 0 por motivo de alineamiento de memoria.)
A31 -A2 WR RD
256K x 32
A17-A0 RD WR CS

Capacidad total: 1 MB. Problema: Las direcciones 0, 1MB, 2 MB, ... son sinnimos. Si se escribe x en la direccin 0 , tambin se leer x en las direcciones 1MB, 2 MB, ...

256K x8 D7-D0

256K x8

256K x8

256K x8

D31-D24

D23-D16

D15-D8

D7-D0

Segundo : La memoria solo debe accesarse en el rango de direcciones [0, 1MB[. Pero: a [0, 1MB [ a = |a31 a30 ... a20 a21 ...a2 a1 a0| = |0 0 ... 0 ? ? ... ? 0 0| (1MB = 2^20)

SEL [0,1MB[ A31-A20 CS RD WR

Para limitar el rango de acceso, usamos la linea CS (Chip Select) de la memoria. Un chip se accesa solo si CS est en 1. Si ste est en 0, el chip no participa en un accesso, CS se calcula como Ahora, si se lee la direccin 1MB se lee basura, puesto que CS permanece en 0: La memoria no entrega nada en el bus de datos.

Te r c e r o : L a m e m o r i a p u e d e s e r insuciente. Se coloca un mdulo de 1MB en las direcciones [0, 1MB[ y otro modulo en [1MB, 2MB [ Observe que estos mdulos nunca se activan al mismo tiempo. SEL [0,1MB[ = 1 # Si (RD+WR) y A [0, 1MB[ # i.e. a # = |a31 a30 ... a20 a21 ... a2 a1 a0| # # = |0 0 ... 0 ? ? ... ?0 0| SEL[1MB, 2MB[ = 1 # Si (RD+WR) y A [1 MB, 2MB[ # i.e. a # = |a31 a30 ... a20 a21 ... a2 a1 a0| # # = |0 0 ... 1 ? ? ... ? 0 0|

A31-A20

A31-A2 WR RD
A17-A0 RD WR CS

SEL [0,1MB[

256K x 32

D31-D0

48

Ejercicio: Interfaz de memoria de 8MB, ubicada en [0, 8MB[ Solucin: Se colocan 8 bancos de 1MB y se activan por medio de un descodicador. a [0, 8MB [ a = |a31 a30 ... a23 a22 a21 a20 a21 ... a2 a1 a0| = |0 0 ... 0 b2 b1 b0 ? ? ... ? 0 0| hay que agregar

Cuarto : La memoria puede tener un tiempo de acceso muy extenso

por ejemplo 2 ciclos de espera (wait states). Cuando la CPU est en el segundo ciclo de una lectura o escritura y detecta que la lnea WAIT est en 1 en el pulso de bajada del reloj, repite el segundo ciclo hasta que WAIT se ponga en 0 Para activar la lnea WAIT se coloca un circuito generador de ciclos de espera. Implementacin: clase auxiliar.

DRAM = Dynamic RAM Son los ms usadas debido a su baja costo por bit. Se implementan con un condensador para almacenar 1 bit y un transistor para seleccionarlo:
SEL

Para escribir el bit se coloca SEL en 1 y un 0 o 1 en DATA, lo que DATA descarga o carga el condensador. Cuando SEL=0 el condensador se mantiene aislado, por lo que mantiene su carga por algunos milisegundos. Para leer el dato se coloca SEL en 1. Si el condensador est cargado, se descarga generando una dbil corriente que es detectada como 1. Esto signica que la lectura es destructiva: despus de leer un bit, hay que reescribirlo para no perder los 1. Las desventajas de este tipo de memoria son: 1. lento: tiempo de acceso de 60 -70 ms (vs 10 - 20 ms para las estticas) 2. cada 4 milisegundos hay que reescribirlos completamente. Esto se debe a que los condensadores se descargan lentamente, an cuando no se lean. Las DRAM se venden en chips o DIMMs (Dual In-line Memory Module), sucesor al SIMM (Single In-line Memory Module). SIMMs de 72 pins tienen un bus de datos de 32 bits o 36 si incluyen paridad. La paridad es un bit adicional redundante que se calcula como el XOR de 8 bits de datos. La paridad permite detectar errores de almacenamiento en la memoria dinmica, producidos ej. por la descarga de un condensador. Durante la lectura se verica que la paridad almacenada coincide con la paridad calculada a partir de 8 bits de datos. Si no coincide se genera un interrupcin por parity error. La paridad siempre detecta errores de
49

un solo bit en un byte. Error-Correcting Memory usa un sistema de paridad (Hamming Codes) para corregir errores: en la reescritura de memoria se detecta errores y los datos corregidos son reescrito en memoria. Articulo: DRAM Errors in the Wild: A Large-Scale Field Study Bianca Schroeder, U of Toronto, y Eduardo Pinheiro y Wolf-Dietrich Weber, Google. (SIGMETRICS/ Performance09) Resumen: Estudio de 2.5 aos de DRAM de the majority of machines in Googles eet. About a third of all machines in the eet experience at least one memory error per year. In more than 93% of the cases a machine that sees a correctable error experiences at least one more correctable error in the same year. 20% of the machines with errors make up more than 90% of all observed errors DIMM error rates are [...] a mean of 3,751 correctable errors per DIMM per year.
Direccin multiplexada 11 Row Access Column Access

A21-A11 /A10-A0 RAS CAS

RD WR Din Dout

Los chips que vienen en un DIMM se organizan como una matriz de bits. El acceso a la memoria dinmica es ms complejo que el de la memoria esttica debido a la multiplexin del bus de direcciones.

A21-A11
11

2K

Latch
CAS RAS A D RD 11

... Decod 11x2K

RAS XX la XX colum X bit

11

1 bit

...

2K

CAS

Latch
A10-A0

Amplic, latch multiplex

Din

RD WR Dout

Durante el acceso a la la, se lee toda la la de condensadores. Como la lectura es destructiva (es decir descarga los condensadores), la la se reescribe completamente a nal del acceso. En el acceso a la columna se selecciona un bit dentro de la la. Por otra parte, cada la debe ser reescrita cada 4 milisegundos para que no se borre. Esta se logra con un acceso a la la sin acceso a la columna. Des esto se encarga el hardware en forma transparente para el software. En general, un chip no entrega o recibe datos bit por bit, pero usa bloques de 8 bits (un byte). Tambin por cada acceso a una la se pueden accesar 4 columnas dentro de esa
50

misma la, lo que permite un acceso secuencial ms eciente que el acceso aleatorio. Este tipo de acceso se denomina page mode. SDRAM = Synchronous DRAM + DDR = Double Data Rate La interfaz a SDRAM es sincrnico: DRAM entregue los datos los mas rpido posible, SDRAM espera hasta x ciclos del reloj (= CAS latency, especicado por software). As funciona de manera sincrnico con el CPU. El uso del bus de datos es ms complicado: por una escritura los datos tienen que estar en el bus de datos en el empiezo de la operacin, en una lectura, los datos aparecen en el bus de datos en la n de la operacin (n ciclos del reloj ms tarde). El circuito que maneja el bus tiene que asegurar que no hay colisiones. Una evolucin de page mode es burst mode. En burst mode, se lee o escribe automticamente los datos de las 4 columnas dentro de una la en 4 ciclos sucesivos del reloj. Se resulta muy til para vaciar o llenar el cach del CPU (ver mas tarde). Double Data Rate SDRAM acelera burst mode acesando no solo datos en el pulso de bajada de la reloj, pero tambin en el pulso de subida. El bus de datos ahora funciona a doble velocidad: double data rate. Sinnimos por double data rate son, double pumped, dual-pumped, y double transition. Ojo: la transmisin de datos dentro de un burst es 2 veces ms rpido, pero el tiempo de acceso de memoria no cambia.

ROM = Read Only Memory Vienen grabados de fabrica y no se pueden escribir. No se borran al apagarlas, son lentas. Se usan para almacenar el programa de bootstrap (el cargador del sistema operativo) o en control automtico/ embarcado. Son relativamente econmicas pues requieren de a lo ms 1 transistor por bit. PROM = Programmable ROM Es una ROM que se programa con dispositivos especiales. Cada bit se implementa con un transistor y un fusible. Los 0 se pueden cambiar por 1 aplicando una intensidad fuerte de corriente para quemar el fusible. Pero una vez que se quema el fusible no se puede volver a 0.

SEL

SEL

SEL

DATA

Luego de grabarlas, se instalan en el computador, el que no puede modicarlas. La ventaja sobre el ROM es que no es necesario pedirle al fabricante que las grabe.

51

EPROM = Erasable PROM Son similares al las PROM, pero el fusible se puede restituir con luz ultravioleta aplicada en una ventana de cuarzo ubicada sobre el silicio. La luz solar contiene luz ultravioleta de modo que una vez que se borra su contenido se debe tapar la ventana, para que no se borre.

Flash Este es un tipo de memoria que no se borra al apagarla, pero que se puede escribir en el mismo computador, aunque no tan ecientemente come una DRAM o SRAM. Se puede cambiar 0 por 1 fcilmente, pero se borran por las completas. Tiene un limite a cuantas veces puede ser escrito y borrado (write-erase cycles).

52

La CPU
Consideramos la CPU M32 (m32-imp.pdf m32-modules.pdf) El el circuito se puede distinguir: Unidades de almanacamiento: PC, R-BANK, IR, SR, AR Unidades combinacionales: ALU, MUX, ... Unidad de control Buses internos: Seales de control > que van de la unidad de control a las componentes. ALU (Arithmetic/Logic Unit) Realiza todos los clculos del tipo z = x op-alu y en donde op-alu es la operacin que indique la unidad de control. Adems indica las caractersticas del resultado en ZVSC Control Unit Circuito secuencial muy complejo que genera las seales de control. Estas hacen uir los datos y direcciones por los buses que interconectan las unidades de almacenamiento y las de clculo. R-Bank (Register bank) Almacena los registros R0-R31 En s1 y s2 se indica el numero de los registros que aparecen constantemente por RS1 y RS2. Adems si WR-Rd = 1 se escribe en Rd en forma sncrona en d (la actualizacin se produce en el pulso de bajada) Registros sncronos: PC y SR Mantienen el contador de programa y el registro de estado ZVSC Registros asncronos: IR y AR Mantienen la instruccin en curso y la direccin que se debe colocar en el bus de direcciones. R-SEL Extrae de la instruccin los nmeros de los registros que intervienen en una operacin Y-SEL Elige el segundo operando de una instruccin, el que puede ser 0, 4 o lo que diga la instruccin (RS2 o imm) o un desplazamiento de 24 bits en caso de un salto Branch Unit Calcula la condicin de salto durante instruccin del tipo b<cond> <label> DBI (Data Bus Interface) Interfaz con el bus de datos. Durante lecturas y escrituras, la memoria espere bytes y halfwords en posiciones distintas de donde se encuentra en la palabra original. DBI desplaza los datos y extiende el signo si es necesario. ABI (Address Bus Interface) Genera los valores de A31-A2 y BE3-BE0 a partir de una direccin y el tipo de operacin que le indique la unidad de control.
53

Funcionamiento En cada ciclo del reloj la unidad de control genera las seales de control para llevar los datos de los registros a los buses externos y a las unidades de calculo. Restricciones Las seales de control permanecen constantes durante todo un ciclo del reloj. Solo cambian en el pulso de bajada del reloj. En un bus se puede colocar un y solo un dato en un ciclo del reloj La actualizacin del PC, SR, y Rd ocurre solo en el pulso de bajada del reloj. Cada unidad de clculo puede realizar un y solo un clculo en cada ciclo del reloj. Etapas en la ejecucin de una instruccin del tipo add R3, R4, R11

1 instruccin

!
RD A D

XX PC XX inst fetch1 fetch2

XXXXX

decode

exec

Para describir las operaciones que se llevan a cabo en cada ciclo se utilizan dos niveles de arbitraccin.! Transferencia entre registros fetch1 : ! AR := PC ! goto fetch2 fetch2: ! IR := Memw[AR] ! if WAIT goto fetch2 ! else goto decode decode: ! PC := PC 4 ! goto execute1 Seales de Control OP-Y-SEL := @0 OP-ALU := @OR WR-AR, EN-A OP-ABI := @W OP-DBI := @LDW SEL-D, WR-IR, EN-A, RD OP-ABI := @W OP-Y-SEL := @4 OP-ALU := @ADD WR-PC

Importante: en un mismo ciclo el orden en que se indican las transferencias o seales de control es irrelevante pues todas ocurren al mismo tiempo (en paralelo).Las seales de control no especicadas permanecen en 0.
54

Las transferencias entre registros estn restringidas por lo que permiten hacer las componentes, buses y seales de control. Supongamos que la instruccin es add R4, -103, R11 Transferencia entre registros exec1 : ! R11 := R4 -103 ! goto fetch1 Seales de Control SEL-REG, WR-RD, WR-SR, RD-DEST OP-Y-SEL := @INST OP-ALU := @ADD

Supongamos que la instruccin es stb R3,[R5 + R0] Transferencia entre registros exec1 : ! AR := R5 R0 ! goto exec2 exec2 : ! Memb[AR] := Truncb[R3] ! if WAIT goto exec2 ! else goto fetch1 Seales de Control SEL-REG, WR-AR, EN-A OP-Y-SEL := @INST OP-ALU := @ADD OP-ABI := @W SEL-REG, RD-DEST, EN-D,EN-A, WR OP-Y-SEL := @0 OP-ALU := @OR OP-DBI := @STB OP-ABI := @B

Supongamos que la instruccin es bg <label> Transferencia entre registros exec1 : ! if br? goto exec2 ! else goto fetch1 exec2 : ! PC := PC Exts(IR[23-0])) ! goto fetch1 WR-PC OP-Y-SEL := @DISP OP-ALU := @ADD Seales de Control

55

Implementacin de la ALU
x y OP-ALU Cin

MUX

Y/~Y Y X AND Y X OR Y X XOR Y X SLL Y X SRA Y X SRL Y X C ADD C

000

001 z31

MUX

110

SEL

VCS Z

En cada ciclo del reloj la ALU realiza en paralelo las 7 operaciones que implementa. Un multiplexor se encarga de seleccionar la operacin que indique la unidad de control. La unidad ADD calcula V y C ! C = ultimo carry ! V = 1 si x31 = y31 != z31 , V = 0 sino El resto de la unidades V = 0, C = Cin Ejercicio: completar la tabla de verdad para el circuito combinacional: OP-ALU (ADD) (ADDX) 0000 0001 Cin x 0 1 (SUB) 0010 x C 0 0 1 1 SEL 110 110 110 110 Y/~Y 1 1 1 0 Calcula xy xyc xyc x~y1

56

El banco de registros 1 registro sincrono:

WR S 1 0

MUX

F/F Data

31 registros + R0

d Dec 5x32

Rd

s1

s2

Reg 1 0

Reg 2

Reg 31

0000

0001

0010 MUX

1111

0000

0001

0010 MUX

1111

Rs1

Rs2

57

La unidad de control Corresponde a un circuito secuencial complejo.

*/ 00 (OP-Y-SEL) */ 0101 (OP-ALU) */ 1 (WR-AR) */ 1 (EN-A) */ 00 (OP-ABI) */ 0 (*)

(WAIT) 1 / % (WAIT) 0 / 000 (OP-DBI) (WAIT) 0 / 1 (SEL-D) ...

Fetch 1

AR := PC

Fetch 2

IR := Memw[AR]

Decode

OP = JMPL / ... ... OP = LDW / ... ...

OP = ADD / ... OP = ADDX / ... PC := PC ! 4

Dado que M32 no tiene ms de 32 instrucciones slo se necesitan 5 bits para codicar todas las instrucciones.

Exec2

OP = LDW / ... ... OP = JMPL / ...

Exec1

En un ciclo ocurren las siguientes acciones: 1. La unidad de control calcula las seales de control para dirigir los datos hacia las unidades de clculo. 2. Las unidades de clculo efectan sus clculos 3. Los resultados son almacenados en algn registro Cada una de estas acciones toma un tiempo de retardo. El periodo del reloj debe ser jado de modo que se alcancen a realizar en un ciclo del reloj. La evolucin de los microprocesadores est dirigida por lograr mayor rapidez al mismo precio. Para lograr mayor rapidez se lucha por: 1. Hacer que los transistores reaccionen ms rpido disminuye el periodo del reloj. 2. Mejorar la tasa de instrucciones ejecutadas por ciclo de reloj (M32: 1 por cada 4 o 5 ciclos). 3. Disminuir el tiempo de calculo de seales de control y tiempo de calculo dentro del procesador Una forma de lograr esto ltimo es en vez de calcular las seales de control en este ciclo, calcularla en el ciclo precedente. Dicho de otra forma: en cada ciclo se calculan las seales de control que se usarn en el prximo ciclo. Estas seales se dirigen a un registro sincrono que se actualiza en el pulso de bajada del reloj. Notense que esta optimisacin no sera posible aplicarla si no existia el ciclo decode, pues la instruccin que jar las seales de control que se aplicarn en el ciclo exec.

58

Entrada / Salida
Problema: Cmo comanda/examina la CPU a los dispositivos de entrada y salida? Entrada / Salida mapeada en memoria
Bus E/S

Boton

Indicador

Los dispositivos se disfrazan de memoria, reaccionan en un rango de direcciones. Para examinar un dispositivo Para comandar un dispositivo Ejemplo: para saber si el botn se fue presionado se lee en la direccin 0xf000 Para encender o apagar el botn se escribe en la direccin 0xf000. Un programa lee en una direccin del dispositivo. Un programa escribe en una direccin del dispositivo

A15-A0 D7-D0 RD WR SEL A=0xf000 D0 D0

WR 5V

Latch

Amplicador

Supongamos que R1 = 0xf000 ldw [R1 + 0 ], R2 ! R2 = |?...?b|, b = 0 botn presionado, b = 1 botn arriba. ! (en C: R = *((char*) 0xf000) ) stw R3, [R1 + 0] ! R3 = |?...?1| apaga la luz ! ! R3 = |?...?0| enciende la luz (en C:*((char*) 0xf000) = R )

Obs: se se escribe un valor en la direccin de un dispositivo y luego se se lee su contenido, en general no se obtiene lo mismo que se escribi. ! un dispositivo se disfraza de memoria, pero no se comporte como memoria!

59

Ejemplo 2: visor de calculadora Solucin 1 (cara): asignar una direccin de 1 byte a cada dgito. Cada segmento est asociado a un bit dentro del byte. Si se escribe |01011110| en 0xe003 entonces aparecer b en el cuarto dgito.

4 3

5 6

0 1

...

2 7 0xe007

...

0xe001 0xe000

A15-A0 D7-D0 RD WR SEL A! [0xe000, 0xe007] E Decod ... 3x8 A15-A3 A2-A0

WR

Latch

...

WR

Latch

...

Obs: al leer la direccin de un dgito no se lee su contenido en el visor (se lee basura), pues esta interfaz solo permite escribir en los latches. Solucin 2 (econmica): Hacer una interfaz que permita encender no ms de un dgito a la vez. Hacer un programa que enciende secuencialmente cada dgito ms de 60 veces por segundo. Esto crea la ilusin ptica de que el visor est permanente encendido. Mapeo del visor en memoria: ! 0xe000 indica qu dgito est encendido ! 0xe001 el bitmap de ese dgito Cdigo en C: char bm_digs[8] /* bitmap de cada dgito */ display() { ! char *port_ndig = (char *) 0xe000; ! char *port_bmdig = (char *) 0xe001; ! ! for(int num_digit = 0; ; num_digit = (num_digit+1) % 8) { ! ! *port_ndig = num_digit;! ! ! /* cual dgito */ ! ! *port_bmdig = bm_digs[num_digit];! /* dibuja dgito */ ! ! usleep(1000/(60*8)); } }

60

A15-A0 D7-D0 RD WR SEL A =0xe000, 0xe001] A15-A2 A0 D2-D0 A0 D7-D0

WR Latch A

WR Latch B

Decod 3x8

...

...

El descodicador entrega casi todas sus lneas en 1 por lo que esos dgitos se apagan. Una sola lnea esta en 0 la que corresponde al dgito iluminado. Cada una de sus segmentos est conectado a un bit del latch B que controla si enciende o no.

Controlador de entrada y salida Problema: Si se quiere mostrar el visor, el programa gasta todo su tiempo en el ciclo display(). Si se dedica a otro clculo, el visor se apaga ! Solucin: Usar un controlador para desplegar el visor. Un controlador es un microprocesador dedicado a una funcin especca requerida para el funcionamiento de algn dispositivo. La CPU y el controlador i n t e r c a m b i a n informacin a travs de una lnea de comunicacin.

MEM

CPU

Interfaz de comm

Controlador

...

Tpicas lneas de comunicacin: # Serial RS232 ! ! Velocidad 300 a 115,200 bit/s ! ! Distancia hasta 10 metros ! ! Uso: modem, tty, teclado (obsoleto), mouse (obsoleto) ! SATA ! ! Velocidad 1.5 Gbit/s(SATA/150), 3 Gbit/s(SATA/300), 6 Gbit/s(SATA 6 Gbit/s) ! ! Distancia hasta 1 metro ! ! Uso: discos duros, DVD, ...
61

! ! ! ! ! ! ! ! ! ! !

USB ! Velocidad 1.5 o 12 Mbit/s (1.0), 480 Mbit/s (2.0), 5 Gbit/s (3.0, 3.2 Gbit/s real) ! Distancia ocial hasta 5m (1,0, 2.0), 3m (3.0) ! Cable 5 hilos (1.0, 2.0), 9 hilos con traco bidirecional (3.0) ! Permite el uso de maximum 5 HUBs ! Uso: Universal (?) FireWire ! Velocidad 400 Mbit/s (FW 400) o 800 Mbit/s (FW800) ! Distancia hasta 4.5m (FW 400), o 100m (FW 800 sobre Cat5e UTP) ! Permite el use de maximum 16 HUBs (FW400) ! Uso: A/V, ej cameras

FireWire vs USB: USB es mas barato por que no necesita uso de controlador. Pero en el mundo real USB es mas lento que FireWire por que es limitado por la velocidad del procesador (alcanza +- 280 Mbit/s en uso prolongado). Obs: MB != Mb : MegaByte != Megabit. Para evitar confundir aqu usamos Mbit. Transmisin paralela Puertas paralelas usan 8 lneas de datos para transmitir simultneamente 8 bits de informacin. Si se necesita enviar ms de 1 byte, se transmiten secuencias de 1 byte. Ventajas (en teora): Implementacin fcil. 8x mas rpido que enviar los 8 bits en serie. Desventajas (vida real): Crosstalk: Interferencia dentro de las 8 seales en el cable produce degradacin rpida de los seales. El cable tiene que ser corto. Skew: Dado a efectos fsicos, la velocidad de transferencia de los 8 seales es diferente, entonces no llegan al destino al mismo tiempo. Para reducir/evitar crosstalk hay que blindar las lneas para que lleguen ms lejos (tpicamente ms que 2 metros), lo que incrementa el costo del cable. No se puede llegar a las distancias de cables seriales. No hay solucin para evitar skew. El controlador al destino tiene que resguardar todos los bits hasta que llega el ultimo bit del byte. Los problemas de crosstalk y skew crecen cuando la velocidad de comunicacin (frecuencia del reloj) esta ms alta. Puertas paralelas son obsoletos por el precio y la limitacin en longitud del cable. Casi todas las lneas de comunicacin hoy en da usan transmisin serial.

62

Transmisin serial La forma ms econmica para transmitir informacin es una linea serial. Cada byte se transmite en un paquete. Ambas puertas (la del computador y la del dispositivo) se conguran para usar el mismo formato de paquete: La misma velocidad: (300, 2400, 9600, 19200, 38400, ... 115 200 bit/s) Igual numero de bits de datos (5, 6, 7, 8) Igual paridad (sin, par, impar)

Deteccin del comienzo de 1 paquete El estado natural de la lnea cuando no se transmiten datos es el valor 1.La transicin a 0 indica el comienzo de un paquete. El tiempo de transmisin del paquete (start bit + paridad + datos + al menos 1 stop bit) est determinado por la velocidad congurada. Luego la lnea tiene que quedar en 1. Una nueva transicin a 0 indica el comienzo del nuevo paquete. Envo / Recepcin de datos por una puerta serial Un programa opera una puerta serial como si fuera una puerta paralela (+-). Se envan bytes completos escribiendo en una puerta de datos. Es la puerta serial (1 chip) que se encarga de transmitir ese byte bit a bit por un solo cable. Ese chip es muy comn y tiene un costo muy bajo. Del mismo modo es la puerta serial la que recibe bit a bit un paquete y lo transforma a un byte que puede ser ledo en la puerta de datos. Interfaz con el computador
Puerta Serial Send Rec GND Rec Send GND Controlador

SEL A D A0

!
CS

C/~D RD WR D7-D0

La puerta serial se opera a travs de: Puerta de datos (C/~D = 0): Cuando se escribe/lee en esta puerta se envia/recibe un byte. Puerta de control (C/~D = 1): Se escribe en esta puerta para congurar nmero de bits, paridad, etc. Se lee en esta puerta para averiguar el estado de envo / recepcin de los datos.

63

En cdigo: char *port_data = (char *) 0xf12c; char *port_ctrl = port_data + 1; *port_ctrl = [...] /* Configurar */ char status = *port_ctrl /* = |??????RT| R = 1 => se puede enviar un byte T = 1 => se recibio un byte*/ void ! ! ! ! } } enviar(char *buff, int n){ while(n--){ ! while(!*port_ctrl&1) /* se puede enviar? */ ! ! ; /* busy wait */ ! *port_data = *buff++; /* envia 1 byte*/

La transmisin de 1 byte toma +-1 ms a 9600 bps, por lo que el ciclo de busy wait se ejecuta 1000 a 10,000 veces antes de poder volver a transmitir. La recepcin es similar: void ! ! ! ! } } recibir(char *buff, int n){ while(n--){ ! while(!*port_ctrl&2) /* se puede recibir? */ ! ! ; /* busy wait */ ! *buff++ = *port_data; /* recibe 1 byte*/

Organizacin de la puerta serial (Chip tipo 16450 UART) Cuando se completa la recepcin de 1 byte, se almacena en el latch, esperando a que sea leido por la CPU. Se se recibe un nuevo byte antes de que la CPU lea el previo, se pierde 1 byte. Esto da un tiempo de 1 ms a 9600 bps para leer el byte. Para evitar ese problema se puede reemplazar el latch por un buffer de 16 bytes (16550 UART), lo que multiplica por 16 el plazo de lectura.
REC r RDY RD D7- D0

Latch s

Shift Register

Send

Latch r

Shift Register

Rec

A A

B B
! ! ! ! ! UART = ! Universal ! Asynchronous ! Reciever ! Transmitter

A
64

Interrupciones (interrupts) Problema: un ciclo de busy-waiting ocupa el 100% de la CPU ninguna otra actividad. Solucin: El mecanismo de interrupciones permite que la CPU puede ejecutar otros procedimientos mientras se espera que un dispositivo est disponible para enviar o recibir un dato.
Intn MEM CPU Int1 Int0

no se puede realizar

...

Comm RDY

Cuando el dispositivo necesita la atencin de la CPU, interrumpe el procedimiento en curso, colocando la entrada INTx de la CPU en 1.

Con esto la CPU suspende la ejecucin del procedimiento en curso e invoca una rutina de atencin de interrupciones. Esta rutina se encarga de interactuar con el dispositivo. (Ej: recibir un byte, enviar un nuevo byte.) Luego se retorna el procedimiento suspendido en el punto en donde qued y en forma transparente, es decir, sin que se entere de que fue interrumpido. Se dice que este tipo de interrupciones ocurre por hardware, al contrario existen interrupciones que se activan por software: se ejecuta una instruccin con cdigo de operacin inexistente, se divide por 0, se lee una palabra no alineada, etc. Obs: la instruccin trap en IA86 no existe ! Por ello causa una interrupcin. Las interrupciones por hardware pueden ser inhibidas con instrucciones de mquina (ej: enable_int y disable_int). Un bit del registro de estado indica se las interrupciones estan inhibidas o no. En M32 agregamos un bit I al registro de estado ZVSC IZVSC Si I = 1 pueden

ocurrir interrupciones por hardware, si I = 0 no pueden ocurrir interrupciones por hardware. Este bit no puede inhibir las interrupciones por software. La direccin de la rutina de atencin de interrupciones (por software y hardware) se obtiene de un vector de interrupciones. El vector de interrupciones se ubica tpicamente o en una direccin ja dependiente de la arquitectura (ej: 80888 dir 0) o se apunta desde un registro especial en la CPU (ej: 80386). La unidad de control chequea durante el ciclo fetch en estado de la lnea Int Si Intn = 1 la unidad de control invoca la interrupcin. 0 +4 +8 + 12 div por 0 cd de op no existente int por hw 1 int por hw 2

... ...

65

Para ello hay que resguardar cualquier registro que necesite la rutina de atencin y que el procedimiento puede eventualmente estar utilizado. La unidad de control se encarga de PC y SR. La rutina de atencin se encarga de Rx. Todos estos registros deben ser restaurados al retomar el procedimiento interrumpido, para evitar su funcionamiento incorrecto. En cdigo el trabajo realizado por la unidad de control (se supone R31 es un stack pointer): R31 := R31 - 8 Memw[R31 + 4] := PC!! !Push PC Memw[R31 + 0] := Extw(SR)! !Push SR SR.I = 0! ! ! ! !inhibe las ints PC := Memw[IVR + 4 + x]! !dir del vec ints + despl de la int [ rutina de atencin de interrupciones, termina con RETI ] SR := Memw[R31 + 0]!! PC := Memw[R31 + 4]!! R31 := R31 + 8 !Pop SR (restaura SR.I) !Pop PC

Obs: Para retornar el procedimiento interrumpido, se debe invocar RETI la que restaura correctamente SR y PC El dispositivo continua colocando INT en 1 hasta que se suprima la causa de la interrupcin. Por ello se necesita inhibir las interrupciones antes de invocar la rutina de atencin. Sino, despus de ejecutar la primera instruccin, se volvera a provocar una nueva interrupcin, cayndose en un ciclo innito. Al restaurar SR se rehabilitan las interrupciones nuevamente. En algunas arquitecturas se puede inhibir selectivamente las interrupciones por hardware. La rutina de atencin puede rehabilitar las interrupciones an sin terminar de atender su dispositivo. Esto permitira que otros dispositivos puedan interrumpir la rutina de atencin, cuando el tiempo de reaccin a una interrupcin es critico (en prctica no se hace) El hecho que la rutina de atencin deba resguardar los registros que usa y que retorne con RETI obliga a programarla en assembler (al menor una parte), o a usar un compilador que genera cdigo especial. Ejemplo: transmisin serial usando interrupciones. La puerta serial tiene 2 salidas que no hemos visto. Rutina de atencin de INT2: (n = numero de bytes que quedan) <resguardar registros> while (n > 0 && *port_ctrl & 2) { ! n--; ! *buff++ = *port_data; } if (n == 0) Procesar (); <restaurar registros> RETI
66

P Serial CPU Int1 Int2 TxRDY RxRDY

Obs: Desde el instante en que el dispositivo sube la interrupcin hasta que se llama la rutina de atencin, puede pasar bastante tiempo ya que: las interrupciones pueden estar inhibidas otros dispositivos pueden pedir interrumpir, pero se atienden de uno a la vez. Por ello se reciben todos los bytes que hayan llegado. Si el buffer interno de la puerta serial se llena antes de la interrupcin hay perdida de bytes! Evaluacin: Supongamos un CPU lento de 10 MIPS (+- 33 MHz i386) Busy-waiting: mnimo 10 instrucciones por byte transferido. Tasa mxima de transferencia = +- 1 MB/s (1 milln de byte / s), con 100% ocupacin de la CPU. Interrupciones: +- 100 instrucciones por byte transferido. Tasa mxima de transferencia = +- 100 KB/s (100 000 byte / s) si hay 1 byte / interrupcin. Ocupacin de la CPU para una puerta de 2000 byte / s. 100 instr / byte * 2000 byte / s = 200.000 instr / s. = 2% de 10 MIPS = 2% de la CPU El 98% restante se ocupa para otras tareas!

Entrada / Salida usando canales DMA Problema: Primero: Consideran un dispositivo USB2 lento que transere 16 Mbit/s (USB2 max = 480 Mbit/s) = 2 MB/s. (= +- 2 000 000 bytes / s) 2 000 000 bytes/s * 100 inst/byte = 200 000 000 inst/s = 200 MIPS = 2000 % de la CPU (Con busy-waiting se require el 200 % de la CPU) Segundo: Ciertos dispositivos pierden datos si no se les atiende dentro de un plazo prudente, plazo que puede no cumplirse si se inhiben las interrupciones. Solucin: DMA = Direct Memory Access Objetivos: desligar a la CPU de la transferencia de bloques de datos entre memoria y dispositivos permitir velocidades de transferencia acotadas por la velocidad de la memoria. Un controlador de DMA es un co-procesador dedicado a transferir datos entre memoria y dispositivos sin parar la CPU. Para que un dispositivo pueda usar DMA su interfaz con el bus debe ser capaz de generar y entender la linea DREQ (Data Request) y DACK (Data Acknowledge). El controlador de DMA tiene un numero jo de pares DREQ/DACK. Solo se puede conectar un dispositivo por par.
67

Cuando un programa (ej: un driver) necesita hacer una transferencia, congura el DMA con la siguiente informacin: direccin de un buffer en memoria nmero n de bytes a transferir numero del par DREQ/DACK que usa el dispositivo sentido de la transferencia El controlador de DMA posee varias puertas de control por donde recibe esta informacin. Para transferir los datos ocurre lo siguiento (en resumen): 1. El dispositivo coloca DREQ en 1 2. El controlador DMA pide el bus a la CPU, usando una linea HOLD. 3. La CPU concluye cualquier operacin que esta usando el bus, lleva todas sus lineas que lo conectan al bus a tristate, y coloca una linea HOLDA (HOLD ACK) en 1. 4. El DMA transere datos: coloca la direccin en el bus de direcciones, RD o WR en 1, y seala al dispositivo que escriba o lea el dato en el bus de datos. (= un acceso simultneo a la memoria y a una puerta de datos del dispositivo). 5. Si el dispositivo lleva la lnea DREQ en 0, el DMA lleva HOLD a 0 y lleva sus lneas a tristate, la CPU lleva HOLDA a 0 y puede volver a ocupar el bus. 6. Sino, se trata de una transferencia en rfaga (burst transfer), goto 4. Obs: La CPU y controlador DMA comparten el mismo bus de datos y por lo tanto comparten toda la memoria y dispositivos. Solo uno de ellos puede acceder al bus en un instante dado. Mientras el DMA ocupa el bus, la CPU puede continuar ejecutando la instruccin de mquina en curso, pero si se necesita acceder al bus debe esperar a que el DMA suelte el bus. La transferencias que realiza el DMA son absolutamente transparentes para el programa que ejecuta la CPU. Al n de la transferencia de n bytes, el DMA interrumpe la CPU usando una lnea de interrupcin.

Evaluacin: Costo de transferencia de un bloque de n bytes: programacin del DMA (costo jo) 1 acceso a memoria y dispositivo por cada byte, por el controlador DMA 1 interrupcin al nal del bloque

68

Arquitecturas Avanzadas
Memoria Cach La CPU gasta mucho tiempo esperando el envo de datos desde y hacia la memoria. Memoria ms rpida implique un CPU mas rpido. Como tener acceso rpida a la memoria? Memoria dinmica (DRAM): econmico, pero lenta. Memoria esttica (SRAM): rpida, pero cara. Experimento: Descomponer la memoria requerida por un programa en lneas de 4, 16, 32 o 64 bytes de direcciones contiguas. Contabilizar el nmero de accesos a cada una de las lneas durante un intervalo de ejecucin de un programa. Hacer un ranking de las lneas ms accesadas. Hecho emprico 1: El 98% de los accesos se concentran en el 3% de las lneas. Localidad espacial: si se hace un acceso a un elemento de memoria, hay alta probabilidad que se hace un otro acceso a elementos que se encuentran cerca en el futuro prximo. Usando este fenmeno podemos tener accesos mas rpidas a la memoria y entonces un CPU mas rpido. Idea 1: Reservar una memoria esttica (el cach) de pequeo tamao (Sc) para guardar las lneas mas accesadas ahora. El resto se almacena en le memoria dinmica (Tamao Sm, con Sc << Sm). Problema: Cmo saber cuales sern las lneas ms accesadas durante el intervalo de ejecucion? Hecho emprico 2: un buen predictor de las lneas que sern ms accesadas en el futuro cercano es el conjunto de las lneas que fueron accesadas en el pasado ms reciente Localidad temporal: si se hace un acceso a un elemento de memoria, hay alta probabilidad que se hace un otro acceso a este elemento en el futuro prximo.

69

Idea 2: Guardar en el cach las ltimas lneas de la memoria que hayan sido accesadas. Supongamos: Tc = Tiempo acceso cach ! = +- 10ms, Tm = Tiempo acceso memoria ! = 70ms % de exito = hit rate = hr ! = 90 99 % T accesso: Tc <= hr * Tc + (1-hr)*Tm << Tm

Memoria Cach No de linea 4 20 1 ... 1021 ... ... N bytes N 2N 3N 4N

El cach contiene una aproximacin de las lneas ms frecuentemente accesadas. Se requiere un campo adicional que almacene el nmero de lnea que se guarda en una lnea del cache. Costo = Sc * Costo(SRAM) + Sm * Costo (DRAM) Costo (DRAM) predomina. Problema: al accesar la memoria hay que buscar el nmero de linea en el cach. Para que sea eciente hay que buscar en paralelo muy caro. Grados de asociatividad de un cach: full: una lnea de la memoria puede ir en cualquier lnea del cach 1: si el cach tiene Lc lneas, la lnea l de la memoria solo puede ir en la lnea l mod Lc del cach 2: se usan 2 caches paralelos de 1 grado de asociatividad 4: se usan 4 caches paralelos de 1 grado de asociatividad ... Lectura en cach de grado de asociatividad 1 Al leer la lnea l se examina la etiqueta n de la lnea l mod Lc del cach. Si l = n xito Si l != n fracaso. Hay que recuperar la lnea de la memoria dinmica y reemplazar la lnea n por la l Grado mas alto: vericar l = n en todos los caches. Obs: A igual tamao de cach a mayor nmero de grados de asociatividad mejor tasa de aciertos, pero mayor el costo. A igual grado de asociatividad, a mayor tamao del cach, mejor la tasa de aciertos. En la prctica, a igual costo el ptimo en la tasa de aciertos se alcanza en 1, 2, 4 (a 8) grados de asociatividad. La estadstica dice que se hacen 3 lecturas por una escritura. Polticas para la escritura: Write-through: las escrituras se hacen en el cach y en la memoria simultneamente, pero pueden hacerse sin bloquear a la CPU. Write-back: una escritura slo actualiza el cach. La memoria se actualiza cuando corresponde reemplazar esa lnea por otra.
70

Problemas de un cach de 1 grado de asociatividad. Ej. cache de 1024 bytes (1K) char buff [128*1024] for (;;) ! buff[0] + buff[64*1024] ! /* lnea mem buff[0] = lnea mem buff[64*1024] en el cach */ Tasa de aciertos con respectos a los datos = 0% En la prctica los programa no exhiben comportamientos tan desfavorables.La eciencia del cach depender de la localidad en los accesos del programa que se ejecuta. Esta localidad depende de las estructuras de datos que maneja el programa. De mayor a menor localidad: La pila: el acceso a variables locales tiene un hit rate que supera al 99% El cdigo presente muy buena localidad El acceso secuencial de grandes arreglos o matrices (que superan el tamao del cach) tienen mala localidad. Obs: Si durante un ciclo prolongado las variables locales y el cdigo del ciclo se mapean en el mismo lugar en el cach, el tiempo de ejecucin puede caer hasta un 50%. Este problema no ocurre en un cach de 2 grados de asociatividad, en donde si se pueden mantener en el cach 2 lneas que se mapean en el misimo sitio. Otra solucin es tener un cach separado para cdigo (instruction cache) y un separado para datos (data cache). Jerarqua de memoria: Capacidad Desempeo (Tambin en la jerarqua hay discos duros, DVD ... tiempos son de milisegundos hasta segundos) Registros Cach L1 Cach L2 Memoria dinmica 0 ciclos 1 ciclos 2 - 3 ciclos +-7 ciclos

Jerarqua de buses Una vez resuelto el problema de la velocidad de la memoria, el bus se transforma en el siguiente cuello de botella: Se pueden hacer buses econmicos en donde es posible conectar CPU, memoria, DMA y todos los dispositivos. Sin embargo el resultado es un bus muy lento por que las seales tardan demasiado en propagarse. En efecto, para que las seales lleguen a todas las componentes es necesario agragar buffer y transciever que amplican las seales, pero a su vez introducen un tiempo de retardo adicional. Por otro lado, se pueden hacer buses rpidos, pero que operan a distancias cortas (+- 10 20 cm) y con un nmero limitado de componentes conectadas al bus.

71

Solucin: Jerarquizar Las transferencias entre componentes se pueden ordenar: ! CPU ! ! ! Cache ! ! ! 98% ! ! ! ! ! Cach ! CPU! ! Memoria! Memoria! ! ! ! ! Memoria! Disco Red Otros dispositivos ! ! 90% (del resto) Frame Buffer simple

CPU o mem! !

Se crean buses especiales para cada una de estos niveles. Ejemplo: Pentium II, III, IV, Core 2 , Core 2 Duo

CPU Cach

Front Side Bus 800 Mhz * 64 bit +- 6GB/s DIMMs 2 canales de +- 6GB/s

PCIex 3.2GB/s

SATA 150MB/s IDE 100MB/s

Northbridge (Memory Hub)

Bus Proprietario PCI 120MB/s PCIe (4) 200MB/s

Southbridge (IO Hub) USB Flash BIOS

72

Pipelining Una forma de mejorar el rendimiento de M32 es hacer que la carga de la siguiente instruccin se efecte al mismo tiempo que la ejecucin de la instruccin actual, si sta no ocupa el bus.
add F 1 F 2 sub ldw add be add
D E D E D E1 E2

F1 F2

F1 F2

(1)

F1 F2

E D E D E

F1 F2

(2)

F1 F2 F1 F2

(1) Solo se puede hacer un acceso a memoria a la vez. En este caso, load necesita accesar la memoria, por lo que la carga de la siguiente instruccin no puede hacerse en pipelining. Sin embargo, los microprocesadores modernos incorporan dos buses: uno para datos y otro para instrucciones (arquitectura de Harvard). En este caso en (1) s se puede cargar la siguiente instruccin en pipelining, siempre y cuando la instruccin este en el cach.

Cache D CPU Cache I

Bus Snooping

(2) La siguiente instruccin se carga, pero no sirve, ya que el salto condicional previo se efecta. Para evitar que se tenga que botar instrucciones ya cargadas, en SPARC y otras arquitecturas se especique que los saltos son retardadas (delayed branch). La instruccin que sigue un salto se ejecuta an cuando ocurra el salto. Para implementar esto se usan dos circuitos secuenciales: La unidad de ejecucin: decodica y ejecuta las instrucciones La unidad de fetch: carga la siguiente instruccin Niveles de pipelining: en la prctica se emplean ms de 2 unidades para lograr ejecutar 1 instruccin por ciclo del reloj.

73

add ,,R1 sub R1,, ldw [],R2 add R2,, be ... ... ... add

D F

E D F

S E D F S E1

(1)
M S E S E

S = Guardar en Registro M = Acceso a Memoria

D (2) F

D (3) F

(4)
E S

D (3) F D F F

(1) se usa el registro calculada en la instruccin anterior, que todava no termina de actualizar. Register Bypassing es una tcnica que lleva el resultado de una operacin directamente a uno de los operadores de la siguiente instruccin. (2) el valor de R2 se conocer el nal del ciclo M, por lo que se introduce un ciclo de relleno a la espera de R2. (Pipeline Stall, Data Hazard) Register Scoreboarding permite acordarse de los registros con valor desconocido. (3) Se debe esperar a que la unidad de ejecucin se desocupe. (Pipeline Stall, Structural Hazard) (4) se produce el salto por lo que se descarta el trabajo hecho con las 3 siguientes instrucciones. Los saltos son dainos para la efectividad del pipeline (Branch Hazard)

Ejemplos: Pentium, SuperSparc: 5 niveles, Pentium III: 10 niveles, P4: 20 31, Core: 14 Con altos niveles de pipeline el trabajo que se descarta es inaceptable. Branch prediction es una tcnica que intenta de predecir saltos. Por ejemplo los saltos se almacenan en un Branch History Table. Al hacer la descodicacin de una instruccin de salto almacenada se sigue cargando instrucciones a partir de la direccin de destino. Actualmente los CPU logran predecir correctamente ms del 95% de los saltos. Todas estas tcnicas permiten acercarse a la barrera de 1 instruccin por tick.

74

Arquitecturas Superescalares Se sobrepase la barrera de 1 instruccin por ciclo. Ejemplo: superescalar de grado 2. La idea fundamental es que se colocan 2 pipelines en paralelo: se cargan 2 instrucciones a la vez se descodican 2 instrucciones a la vez se ejecutan 2 instrucciones a la vez se actualizan 2 registros a la vez El problema ocurre si en ejecucin hay una dependencia entre las 2 instrucciones. 1 2 3 4 5 add add add add sub R1, R2, R3 R5, 8, R7! R9, R10, R11! R11, 2, R7 ! R13, 18, R9!

! ! ! !

! ! ! !

1 2 3 4

y y y y

2 3 4 5

no dependen no dependen dependen: R11 no dependen

3 y 4 no pueden ejecutarse en paralelo. En la etapa de ejecucin se analizan las dependencias de ambas instrucciones. Si el resultado de la primera instruccin es un operando de la segunda, le ejecucin de la segunda se descarta y se repite en el ciclo siguiente, para garantizar la compatibilidad con un procesador non-superescalar. Los compiladores agregan una pasada que reordena las instrucciones de modo que no existen dependencias de datos. Ventajas: 1 < tasas de instrucciones por ciclo <= numero de pipelines Desventajas: Mucho mas alta complejidad de la CPU. Hay que recompilar para limitar las dependencias. Ejemplos: 486: 1 pipeline 4 etapas (stages) Pentium: 2 pipelines 5 etapas Pentium Pro Pentium III: 3 pipelines 10 etapas

75

Ejecucin fuera de orden Problema: Compiladores pueden reordenar las instrucciones, pro les falta conocimiento dinmico acerca de cuanto tomar un load, et cetera ... Solucin: ejecucin fuera de orden. Una dependencia de datos bloquea la instruccin involucrada, pero no las que vienen a continuacin si no existe dependencias. Se usa desde el Pentium pro.

load[R1+10],R2 add R2,R3,R4 add R3,10,R5 add R4,1,R6

3 pipelines

F F F

D D D F

A A

R E S

Retiro en orden R R E S R

Analisis E D S A

Con register renaming:

load[R1+10],R2 add R2,R3,R4 add R5,20,R2 add R2,8,R2 load[R1+10],R2 add R2,R3,R4 add R5,20,R2' add R2',8,R2"
F F F D D D F A A A D E A S E S E M M S R E S R R R

anti-dependencia

Ejecucin Especulativa

load[R1+4],R2 cmp R2,8 bgt L add R3,10,R4 ... L:add R4,1,R4'

F F F

D D D

A A A

R E S R E R B R F D ...

Prediccin correcta F D A E S

Prediccin mala R

En caso de no branch se restauran los nombres de los registros de modo que R4 retorna un valor original.

76

Ejemplo: Pentium III Traduccin de 1 instruccin CISC a 1 o 2 instrucciones RISC 2 ALUs enteros de 32 bits (2 mult + 2 suma x ciclo) 1 mult FP de 64 bits (1 mult + 1 suma x ciclo) 1 sumador de 64 bits (1 suma x ciclo) 1 load/store unit 1 jump unit 3 instruccin decodicacion x ciclo 40 instrucciones pendientes, pipeline de 10 etapas Ventajas: Velocidad hasta x2 , > tasa de instrucciones x ciclo No es necesario recompilar Permite realizar accesos concurrentes a la memoria Desventajas: Ms consumo por instruccin ejecutada: uso de energa hasta x10 Mucho mucho ms alta complejidad de la CPU Frecuencia mas baja

77

Multi-Core chips Ejemplo: Intel Core 2 Nehalem, Core i5/i7, Clock 2.6 -> 3.6 Ghz, 8 Mb Cache (Sept 2009)

Obs: Core i5/i7 tambin es especial por que cambia Jerarqua de buses: primero x86 intel con memory controller en el chip mismo (AMD hace algo similar desde 2003). Multi-Core chips son una versin de Symmetric Multi Processing (SMP): una arquitectura usando varios CPU en un computador, donde todos los CPU estn conectados a una sola memoria central. Eso permite a cada CPU de ejecutar un programa y trabajar con datos en cualquier lugar de memoria. Un chip multi-core contiene varios core, cada un CPU completo, con incluso sus propios L1 y L2 cache (salvo primeras implementaciones). Un chip N-core puede correr N hilos de ejecucin en paralelo, siempre si no usan recursos compartidos. Consideran que el bus ya es lento para 1 CPU, con varios CPU el problema es peor! Opciones diseo multicore: Revolucin: simplicar cada core y tener muchos cores en arquitectura masivamente paralelo. Ejemplo: IBM Cell (1 + 8 cores), Sun UltraSparc T1 (8 cores) son sin ejecucin fuera de orden. Evolucin: minimizar uso de energa y usar la ley de Moore para poner mas transistores en el mismo chip. Ejemplo: Intel Core Cache Coherency Todos los core tienen que ver la misma memoria. Los varios core pueden tener la misma linea de memoria en sus propios caches. Que pasa si un core escribe un valor en su cache (L1 o L2)? No es factible de dar acceso directo y completo desde el cache de un CPU a otro CPU en sistemas SMP (por velocidad baja del bus). Se necesita un protocolo de cache coherency. (Se necesita para cada implementacin de SMP).
78

Implementacin simple con write-through caches: Cada core Ci detecta cuando otro core Co escribe un valor en su cache. Si esta valor tambin esta en el cache de Ci, esta linea esta marcada sucia. Leer una linea sucia requiere cargar el nuevo valor desde memoria central. Implementacin mas sosticada usando bus snooping: Leer una linea sucia signica que la memoria central no esta up to date El core Co ve que el core Ci lee el valor cambiado usando bus snooping y provee el nueva valor directamente a Ci. En ese momento el memory controller tambin puede escribir esta valor en memoria Implementacin standard es MESI cache coherency protocol (Modied, Exclusive, Shared, Invalid). El nombre viene de los 4 estados en que puede ser una linea del cache: Modied: The local processor has modied the cache line. This also implies it is the only copy in any cache. Exclusive: The cache line is not modied but known to not be loaded into any other processor's cache. Shared : The cache line is not modied and might exist in another processor's cache. Invalid: The cache line is invalid, i.e., unused. (Start state) Mirando el bus de direcciones y algunos otros seales de control, se puede determinar las transiciones de un estado a otro. Una operacin especial: Request For Ownership (RFO) cuando un otro core quiere escribir una linea con status (local) Modied, este core manda los datos al otro core y marca la linea (local) como Invalid cuando este core quiere escribir una linea con status Shared, primero los otros core lo marcan como Invalid

79