tema13 alu numeros enteros

11

��

� ��

Óscar David Robles SánchezÁngel Serrano Sánchez de León

Luis Rincón Córcoles

Estructura y Tecnología de Computadores (ITIG)

2

Tema 13. Construcción de una unidad aritmética y lógica (números enteros)

Programa

1. Introducción.

2. Construcción de una ALU básica.

3. Multiplicación básica y su circuitería.

4. División básica y su circuitería.

5. Bibliografía.

Conceptos básicos: Unidad aritmético-lógica, operaciones lógicas, sumador, restador, indicador de resultado, algoritmos de multiplicación de enteros sin signo, algoritmos de división de enteros sin signo (división por restauración).

22

3


1. Introducción

Una unidad aritmética y lógica (UAL) es un circuito combinacional que realiza las operaciones aritméticas y lógicas básicas en el computador.

• Operaciones aritméticas básicas: suma, resta, multiplicación, división.

• Operaciones lógicas básicas: NOT, AND, OR, NAND, NOR.

• En inglés: ALU (arithmetic and logic unit).

• En algunos sitios: unidad aritmético-lógica.

A L U

operando1 operando2

operación indicador de resultado

resultado

4


2. Construcción de una ALU básica

La implementación de circuitos para operaciones lógicas es muy sencilla: basta simplemente con una batería de puertas lógicas y un multiplexor accionado por las correspondientes señales de selección.

Ejemplo: unidad lógica de 1 bit con las funciones AND y OR:

Operación: señal de selección de 1 bit.

2.1. Operaciones lógicas

b

0

1

Result

Operation

a

Operación

MUX

33

5


2.2. Sumador completo

Sumador completo (tema 6):• 3 entradas (a, b y AcarreoE).

• 2 salidas (Suma y AcarreoS).

1+1+1=1111111

1+1+1=1001011

1+0+1=1001101

1+0+0=0110001

0+1+1=1001110

0+1+0=0110010

0+0+1=0110100

0+0+0=0000000

SumaAcarreoSAcarreoEbaOperación

SalidasEntradas

Suma

AcarreoE

AcarreoS

a

b

��

��

⊕⊕==+++=

�� ++=

6


Añadimos el sumador completo a nuestra ALU, haciendo más grande el multiplexor:

b

0

2

Operación

a

1

AcarreoE

AcarreoS

Resultado

44

7


2.3. Restador

• Resta en complemento a 2: suma del negado más 1.

1ba1)b(a(-b)ab-a ++=++=+=

Resta: AcarreoE = InvertirB = 1

8


2.4. Operación slt (activar si menor que)slt $rd, $rs, $rt

0

3

Resultado

Operación

a

1

AcarreoE

0

1

InvertirB

b 2

Menor

Comparación

DesbordamientoDetección del

Desbordamiento

Bits 0 - 30 Bit 31

$rd = 0000000116 si $rs < $rt

$rd = 0000000016 si $rs � $rt

55

9


Resta: AcarreoE = InvertirB = 1

Suma: AcarreoE = InvertirB = 0

Ambas se pueden combinar en una única señal NegarB.

Comparacióna31

0

Resultado0

AcarreoE

a0

Resultado1a1

0

Resultado2a2

0

Operación

b31

b0

b1

b2

Resultado31

Desbordamiento

InvertirB

AcarreoE

AcarreoEALU0MenorAcarreoS



AcarreoEALU31Menor

10


Comparacióna31

0

Resultado0a0

Resultado1a1

0

Resultado2a2

0

Operación

b31

b0

b1

b2

Resultado31

Desbordamiento

InvertirB

Cero

AcarreoEALU31Menor




2.5. Indicador de resultado: Detector de ceros

66

11


set on less than111

resta110

suma010

or001

and000

FunciónLineas de control de la ALU

ALU ResultadoCero

Desbordamiento

a

b

Operación ALU

AcarreoSNegarB Señales de control del MUX

2.6. Resumen de la ALU hasta ahora

12


3. Multiplicación básica y su circuitería

0010

× 0011

0010

0010

0000

+ 0000

0000110

Multiplicando

Multiplicador

Producto

�Vamos a estudiar tres algoritmos de multiplicación para enteros sin signo.

77

13


� ��

• 1 registro y desplazador hacia la izquierda de 64 bits (multiplicando).

• 1 registro desplazador hacia la derecha de 32 bits (multiplicador).

• 1 registro de 64 bits (producto).

• ALU para datos de 64 bits.

• Circuitería de control.

14


4

3

2

1

0000 01100010 000000003: Despl. Mcador. dcha.

0000 01100010 000000002: Despl. Mcando. izda.

0000 01100001 000000001: Ninguna operación



0000 01100000 100000001: Ninguna operación



0000 01100000 010000011a: Prd. = Prd. + Mcando.



0000 00100000 001000111a: Prd. = Prd. + Mcando.

0000 00000000 00100011Valores iniciales0

ProductoMultiplicandoMultiplicadorOperaciónIteración

Resultado

0010 × 0011 = ?

88

15


Segunda versión del algoritmo y su circuitería

• La mitad de los bits del multiplicando en el algoritmo anterior son 0.

• La ALU de 64 bits es un despilfarro.

• Al desplazar, se introducen ceros por la derecha del multiplicando, que ya no afectarán a los bits menos significativos del producto.

• Por tanto: multiplicando fijo y desplazamiento del producto a la derecha.

16


• 1 registro de 32 bits (multiplicando).

• 1 registro desplazador hacia la derecha de 32 bits (multiplicador).

• 1 registro desplazador hacia la derecha de 64 bits (producto).



99

17


4

3

2

1

0000 0110001000003: Despl. Mcador. dcha.

0000 0110001000002: Despl. Prd. dcha.

0000 1100001000001: Ninguna operación


0000 1100001000002: Despl. Prd. dcha.

0001 1000001000001: Ninguna operación


0001 1000001000012: Despl. Prd. dcha.

0011 0000001000011a: Prd. = Prd. + Mcando.


0001 0000001000112: Despl. Prd. dcha.

0010 0000001000111a: Prd. = Prd. + Mcando.

0000 000000100011Valores iniciales0

ProductoMultiplicandoMultiplicadorOperaciónIteración

Resultado

0010 × 0011 = ?

18


• El registro producto tiene espacio desaprovechado, en el que encaja el multiplicador:

• A medida que dicho espacio desaparece, los bits del multiplicador también.

• El registro multiplicador se pone en la mitad derecha del registro producto.

Versión final del algoritmo y su circuitería

1010

19


• 1 registro de 32 bits (multiplicando).

• 1 registro desplazador hacia la derecha de 64 bits (producto).



20


0000 011000102: Despl. Prd. dcha.

0000 110000101: Ninguna operación4

0000 110000102: Despl. Prd. dcha.

0001 100000101: Ninguna operación3

0001 100000102: Despl. Prd. dcha.

0011 000100101a: Prd. = Prd. + Mcando.2

0001 000100102: Despl. Prd. dcha.

0010 001100101a: Prd. = Prd. + Mcando.1


ProductoMultiplicandoOperaciónIteración

Resultado

0010 × 0011 = ?

1111

21


111 10

-10 11

011

-10

01

Divisor

Cociente

Dividendo

Resto

� No existe un bloque combinacional “divisor”.

� Hacer un circuito que resuelva la operación rápido es más complicado que en la multiplicación.

� Secuencia de sumas, restas, comparaciones y desplazamientos.

� La división “ofrece” la posibilidad de dividir por 0.

� Vamos a estudiar tres algoritmos de división por restauración para enteros sin signo.

4. División básica y su circuitería

22


• 1 registro desplazador hacia la derecha de 64 bits (divisor).

• 1 registro desplazador hacia la izquierda de 32 bits (cociente).


• 1 registro de 64 bits (resto).


� ��

1212

23


0000 00010000 000100113: Despl. Div. dcha.

0000 00010000 001000112a: Rst.�0 � Despl. Coc., Coc0=150000 00010000 001000011: Rst. = Rst. – Div.

0000 00110000 001000013: Despl. Div. dcha.

0000 00110000 010000012a: Rst.�0 � Despl. Coc., Coc0=140000 00110000 010000001: Rst. = Rst. – Div.

0000 01110000 010000003: Despl. Div. dcha.

0000 01110000 100000002b: Rst.<0 � Rst.=Rst.+Div., Despl. Coc., Coc0=031111 11110000 100000001: Rst. = Rst. – Div.

0000 01110000 100000003: Despl. Div. dcha.


0000 01110001 000000003: Despl. Div. dcha.


0000 01110010 00000000Valores iniciales0RestoDivisorCocienteOperaciónIteración

0111 ÷ 0010 = ?

RestoCociente

24


Segunda versión del algoritmo y su circuitería

� Como mucho, sólo la mitad del divisor contiene información útil.

� Se pueden reducir el registro Divisor y la ALU a la mitad.

� Desplazar el resto a la izquierda consigue el mismo efecto (alineación) que desplazar el divisor a la derecha.

� Se simplifica así la circuitería necesaria.

1313

25


• 1 registro de 32 bits (divisor).

• 1 registro desplazador hacia la izquierda de 32 bits (cociente).


• 1 registro desplazador hacia la izquierda de 64 bits (resto).


26


� De forma análoga a la multiplicación, se puede introducir el registoCociente en el de Resto.

� Resto se inicializa con el dividendo en su mitad derecha y el cociente en su izquierda.

� Esta mejora hace que el resto sufra un desplazamiento a la izquierda de más, lo que requiere una rectificación final.

Versión final del algoritmo y su circuitería

1414

27


• 1 registro de 32 bits (divisor).

• 1 registro desplazador derecha-izquierda de 64 bits (resto).



28


0001 00110010Despl. 1 bit a la dcha. la mitad izda. del Rst.5

0010 001100103a: Rst.�0 � Despl. Rst. izda., Rst0=1

0001 000100102: Rst. = Rst. – Div.4

0011 000100103a: Rst.�0 � Despl. Rst. izda., Rst0=1

0001 100000102: Rst. = Rst. – Div.3

0011 100000103b: Rst.<0 � Rst.=Rst.+Div., despl. Rst. izda., Rst0=0

1111 110000102: Rst. = Rst. – Div.2

0001 110000103b: Rst.<0 � Rst.=Rst.+Div., despl. Rst. izda., Rst0=0

1110 111000102: Rst. = Rst. – Div.1

0000 11100010Despl. Rst. izda.


RestoDivisorOperaciónIteración

0111 ÷ 0010 = ?

Resto Cociente

1515

29


5. Bibliografía� D.A. PATTERSON, J.L HENNESSY. Computer Organization and Design.

Morgan Kaufmann, 2005.

� D. A. PATTERSON, J. L. HENNESSY. Estructura y diseño de computadores. Reverté, 2000.

� DORMIDO, S. CANTO M.A., MIRA J., DELGADO A.E. Estructura y Tecnología de Computadores. 2ª edición. Sanz y Torres, 2000.

� D. A. PATTERSON, J. L., HENNESSY. Computer Organization and Design. Morgan Kaufmann, 2005.

� J.M. ANGULO, J.GARCÍA. Sistemas Digitales y Tecnología de Computadores. Paraninfo, 2002.

� P. DE MIGUEL. Fundamentos de los Computadores. 7ª edición. Paraninfo, 1999.

� W. STALLINGS. Organización y Arquitectura de Computadores. 5ª edición, Prentice Hall, 2000.

tema13 alu numeros enteros

Documents