Definimos genricamente a la unidad ALU (por sus siglas en ingls Arithmetic Logic Unit) como una

de las unidades que forman parte de la Unidad Central de Procesos (es decir, del Procesador,
Microprocesador o CPU Central Processor Unit, por sus siglas en ingls) mediante la cual es
posible realizar una gran cantidad de operaciones aritmticas bsicas (Suma, Resta, Divisin y
Multiplicacin) adems de realizar algunas operaciones Lgicas (Yes, Or, Not, And Es decir, si; y,
o, no) entre dos nmeros o dos conjuntos de nmeros.

Estructura Bsica

Las cuatro entradas de A se combinan con las de B generando una operacin de salida de cuatro
bits en F. La entrada de seleccin de modo S2 distingue entre las operaciones aritmticas y lgicas.
Las entradas de seleccin S0 y S1 determinan la operacin aritmtica o lgica. Con las entradas S0
y S1 se pueden elegir cuatro operaciones aritmticas. Los acarreos de entrada y salida tienen
sentido nicamente en las operaciones aritmticas. El diseo de una ALU implica el diseo de la
seccin aritmtica, la seccin lgica y la modificacin de la seccin aritmtica para realizar las
operaciones aritmticas y lgicas.

Unidad de coma flotante

Una unidad de coma flotante o, tambin conocido como coprocesador matemtico, es un

componente de la unidad central de procesamiento especializado en el clculo de operaciones en
coma flotante. Las operaciones bsicas que toda FPU puede realizar son la suma y multiplicacin
usuales, si bien algunos sistemas ms complejos son capaces tambin de realizar clculos
trigonomtricos o exponenciales.

No todas las unidades centrales de procesamiento tienen una FPU dedicada. En ausencia de FPU,
la CPU puede utilizar programas en microcdigo para emular una funcin en coma flotante a
travs de la unidad aritmtico lgica (ALU), la cual reduce el coste del hardware a cambio de una
sensible prdida de velocidad.

En algunas arquitecturas, las operaciones en coma flotante se tratan de forma completamente

distinta a las operaciones enteras, con registros dedicados y tiempo de ciclo diferentes. Incluso
para operaciones complejas, como la divisin, podran tener un circuito dedicado a dicha
operacin.
Operaciones

La mayora de las ALU pueden realizar las siguientes operaciones:

Operaciones aritmticas de nmeros enteros (adicin, sustraccin, y a veces multiplicacin y

divisin, aunque sto es ms complejo)

Operaciones lgicas de bits (AND, NOT, OR, XOR, XNOR)

Operaciones de desplazamiento de bits (Desplazan o rotan una palabra en un nmero especfico

de bits hacia la izquierda o la derecha, con o sin extensin de signo). Los desplazamientos pueden
ser interpretados como multiplicaciones o divisiones por

Seccin Lgica

Los datos de entrada en una operacin lgica son manipulados en forma separada y los bits son
tratados como variables binarias. En la tabla se listan cuatro operaciones lgicas OR, OR -
Exclusiva, AND y NOT. En el circuito, las dos lneas de seleccin (S1, S0) permiten seleccionar una
de las compuertas de entrada, correspondientes a la funcin Fi.
Seccin Aritmtica

El componente bsico de la seccin aritmtica es un sumador en paralelo. Las operaciones

aritmticas configuradas en el circuito aritmtico se presentan en la tabla. En una ALU, la suma
aritmtica se puede implementar con un nmero binario en A, otro nmero en la entrada B y el
acarreo de entrada Cin en un valor lgico 0. El resto de las funciones se enuncian en la columna
descripcin.La implementacin de las funciones anteriores por medio de un circuito lgico sencillo
se describe a continuacin. El circuito se disea bajo el precepto de intervenir cada entrada Bi para
obtener las siguientes funciones:

Las doce operaciones generadas en el ALU se resumen en la tabla, la funcin en particular se

selecciona a travs de S2, S1, S0 y Cin. Las operaciones aritmticas son las mismas del circuito
aritmtico.
Conclusiones

Cabe resaltar, que una unidad aritmtica lgica debe procesar nmeros usando el mismo formato
que el resto del circuito digital. Hoy en da, este formato para los procesadores modernos, casi
siempre es la representacin del nmero binario de complemento a dos, es decir, el complemento
de dos de un nmero N que expresado en el sistema binario est compuesto por n dgitos. Las ALU
para cada uno de estos sistemas numricos mostraban diferentes diseos, lo cual influencio la
preferencia actual por el complemento a dos, debido a que sta es la representacin ms simple
para el circuito electrnico de la ALU para cualquier adicin y sustraccin, entre otros tipos de
operaciones matemticas.

Tambin, las unidades de aritmtica lgicas pueden realizar operaciones como operaciones
aritmticas de nmeros enteros (adicin, sustraccin, en algunos casos multiplicacin y divisin),
operaciones lgicas de bits (AND, NOT, OR, XOR, XNOR), operaciones de desplazamiento de bits
(los cuales son interpretados como multiplicaciones o divisiones por 2). Adems, los profesionales
como los ingenieros pueden disear una ALU para as calcular cualquier operacin sin importar lo
compleja que sea, de modo que el problema es que cuanto ms compleja sea la operacin ser
ms costosa la ALU, ya que a la vez usara ms espacio en el procesador y ms energa disipara. En
conclusin, las entradas de unidad aritmtica lgica son los datos en los que se harn las
operaciones llamados operandos y un cdigo de control indicando que operacin desea realizar el
usuario.
Sumador

entity Sum4Bits is

port(
A_in: in std_logic_vector (3 downto 0);
B_in: in std_logic_vector (3 downto 0);
S_out: out std_logic_vector (4 downto 0)
);
end Sum4Bits;

architecture arq of Sum4Bits is

begin

process(A_in, B_in)
--=========================================================
variable Cin: std_logic_vector(2 downto 0);
variable Cout: std_logic;
variable A: std_logic_vector (3 downto 0);
variable B: std_logic_vector (3 downto 0);
variable S: std_logic_vector (4 downto 0);
--=========================================================
begin

A:= A_in;
B:= B_in;

S(0) := A(0) xor B(0);

Cin(0) := A(0) and B(0);
--=========================================================
S(1) := ( A(1) xor B(1)) xor Cin(0);
Cin(1) := ((A(1) xor B(1)) and Cin(0)) or (A(1) and B(1));
--=========================================================
S(2) := ( A(2) xor B(2)) xor Cin(1);
Cin(2) := ((A(2) xor B(2)) and Cin(1)) or (A(2) and B(2));
--=========================================================
S(3) := ( A(3) xor B(3)) xor Cin(2);
Cout := ((A(3) xor B(3)) and Cin(2)) or (A(3) and B(3));
S(4) := Cout;
--=========================================================
S_out <= not S;
end process;
end arq;
Resta
entity Restador is

port(
A_in: in std_logic_vector (3 downto 0);
B_in: in std_logic_vector (3 downto 0);
S_out: out std_logic_vector (4 downto 0)
);
end;

architecture arq of Restador is

begin

process(A_in, B_in)
--==============================================================
variable Cin: std_logic_vector(4 downto 0);
variable A: std_logic_vector (3 downto 0);
variable B: std_logic_vector (3 downto 0);
variable S: std_logic_vector (4 downto 0);
--==============================================================
begin
A := A_in;
B := B_in;

Cin(0) := '0';
--==============================================================
S(0) := (A(0) xor B(0)) xor Cin(0);
Cin(1) := (not(A(0) xor B(0)) and Cin(0)) or (not A(0) and B(0));
--==============================================================
S(1) := (A(1) xor B(1)) xor Cin(1);
Cin(2) := (not(A(1) xor B(1)) and Cin(1)) or (not A(1) and B(1));
--==============================================================
S(2) := (A(2) xor B(2)) xor Cin(2);
Cin(3) := (not(A(2) xor B(2)) and Cin(2)) or (not A(2) and B(2));
--==============================================================
S(3) := (A(3) xor B(3)) xor Cin(3);
S(4) := (not(A(3) xor B(3)) and Cin(3)) or (not A(3) and B(3));
-- Cin(4) := (not(A(3) xor B(3)) and Cin(3)) or (not A(3) and B(3));
-- S(4) := Cin(4);
--==============================================================
S_out <= not S;
end process;
end arq;
Muliplicador
entity Mutiplicador_4Bits is
port(
A_in: in std_logic_vector (3 downto 0);
B_in: in std_logic_vector (3 downto 0);
R: out std_logic_vector (7 downto 0)
);
end Mutiplicador_4Bits;

architecture rtl of Mutiplicador_4Bits is

begin
--======================================================================
--== Ecuaciones para un sumador de 1 bit, entradas A y B con acarreo
--== S=(A xor B) xor (C_in)
--== C_out=((A xor B) and C_in )or (A and B)

Process(A_in, B_in)

variable C : std_logic_vector(14 downto 0);

variable A : std_logic_vector (3 downto 0);
variable B : std_logic_vector (3 downto 0);
variable C_in : std_logic_vector(11 downto 0);
variable C_out: std_logic_vector(11 downto 0);
variable S : std_logic_vector(11 downto 0);

begin
--======================================================================
A := A_in;
B := B_in;

--======================================================================
C(0) := A(1) and B(0);
C(1) := A(2) and B(0);
C(2) := A(3) and B(0);
C(3) := A(0) and B(1);
C(4) := A(1) and B(1);
C(5) := A(2) and B(1);
C(6) := A(3) and B(1);
C(7) := A(0) and B(2);
C(8) := A(1) and B(2);
C(9) := A(2) and B(2);
C(10):= A(3) and B(2);
C(11):= A(0) and B(3);
C(12):= A(1) and B(3);
C(13):= A(2) and B(3);
C(14):= A(3) and B(3);
--======================================================================
C_in(0) :='0';

R(0) <= not (A(0) and B(0));-------------------------------- Resultado 0

--======================================================================
--=================== Primer rengln sumadores =========================
--======================================================================
S(0) := (C(0) xor C(3)) xor C_in(0);
R(1) <= not S(0);-------------------------------------- Resultado 1
C_out(0) := ((C(0) xor C(3)) and C_in(0)) or (C(0) and C(3));

C_in(1) := C_out(0);
S(1) := (C(1) xor C(4)) xor C_in(1);
C_out(1) := ((C(1) xor C(4)) and C_in(1)) or (C(1) and C(4));

C_in(2) := C_out(1);
S(2) := (C(2) xor C(5)) xor C_in(2);
C_out(2) := ((C(2) xor C(5)) and C_in(2)) or (C(2) and C(5));

C_in(3) := C_out(2);
S(3) := (C(6) xor '0') xor C_in(3);
C_out(3) :=((C(6) xor '0') and C_in(3)) or (C(6) and '0');

--======================================================================
--=================== Segundo rengln sumadores ========================
--======================================================================

C_in(4) := '0';
S(4) := (C(7) xor S(1)) xor C_in(4);
C_out(4) := ((C(7) xor S(1)) and C_in(4)) or (C(7) and S(1));
R(2) <= not S(4);-------------------------------------- Resultado 2

C_in(5) := C_out(4);
S(5) := (C(8) xor S(2)) xor C_in(5);
C_out(5) := ((C(8) xor S(2)) and C_in(5)) or (C(8) and S(2));

C_in(6) := C_out(5);
S(6) := (C(9) xor S(3)) xor C_in(6);
C_out(6) := ((C(9) xor S(3)) and C_in(6)) or (C(9) and S(3));

C_in(7) := C_out(6);
S(7) := (C(10) xor C_out(3)) xor C_in(7);
C_out(7) := '0';
--======================================================================
--=================== Tercer rengln sumadores ========================
--======================================================================
C_in(8) := '0';
S(8) := (C(11) xor S(5)) xor C_in(8);
C_out(8) := ((C(11) xor S(5)) and C_in(8)) or (C(11) and S(5));
R(3) <= not S(8); -------------------------------------- Resultado 3

C_in(9) := C_out(8);
S(9) := (C(12) xor S(6)) xor C_in(9);
C_out(9) := ((C(12) xor S(6)) and C_in(9)) or (C(12) and S(6));
R(4) <= not S(9); -------------------------------------- Resultado 4

C_in(10) := C_out(9);
S(10) := (C(13) xor S(7)) xor C_in(10);
C_out(10):= ((C(13) xor S(7)) and C_in(10)) or (C(13) and S(7));
R(5) <= not S(10); ------------------------------------- Resultado 5

C_in(11) := C_out(10);
S(11) := (C(14) xor '0') xor C_in(11);
C_out(11):= ((C(14) xor '0') and C_in(11)) or (C(14) and '0');

R(6) <= not S(11);------------------------------------- Resultado 6

R(7) <= not C_out(11);--------------------------------- Resultado 7

end process;
--======================================================================
end rtl;
Divisor
entity divider is
port (
numerador_out : in std_logic_vector(3 downto 0);
denominador : in std_logic_vector(3 downto 0);
cociente_out : out std_logic_vector(3 downto 0)
);

end divider;

architecture rtl of divider is

signal numerador : std_logic_vector(7 downto 0);

signal cociente : std_logic_vector(7 downto 0);
signal residuo : std_logic_vector(3 downto 0);

--===============================================================
procedure div(
num : in std_logic_vector(7 downto 0);
denom: in std_logic_vector(3 downto 0);
coc : out std_logic_vector(3 downto 0);
res : out std_logic_vector(3 downto 0)) is

variable d, n1: std_logic_vector(4 downto 0);

variable n2 : std_logic_vector(3 downto 0);
--===============================================================
begin

d := '0' & denom;

n2 := num(3 downto 0);
n1 := '0' & num(7 downto 4);
--===============================================================
for i in 0 to 3 loop

n1 := n1(3 downto 0) & n2(3);

n2 := n2(2 downto 0) & '0';

if n1 >= d then
n1 := n1 - d;
n2(0):= '1';
end if;
end loop;
--===============================================================
coc := n2;
res := n1(3 downto 0);
end procedure;
--===============================================================
begin
numerador(7 downto 4) <= "0000";
numerador(3 downto 0) <= numerador_out(3 downto 0);
cociente(7 downto 4) <= "0000";
cociente_out(3 downto 0) <= not cociente(3 downto 0);

--===============================================================
process(numerador, denominador)

variable remH, remL, coctH, coctL: std_logic_vector(3 downto 0);

begin

div("0000" & numerador(7 downto 4), denominador, coctH, remH);

div(remH & numerador(3 downto 0), denominador, coctL, remL);
cociente(7 downto 4) <= coctH;
cociente(3 downto 0) <= coctL;
residuo <= remL;
end process;
--===============================================================
end rtl;