Algoritmo de Booth

1. UNIVERSIDAD AUTÓNOMA
METROPOLITANA
ARQUITECTURA DE COMPUTADORAS
“Algoritmo de Booth”
A pesar de los cambios y avances en interfaz para el manejo de las
computadoras, no se debe olvidar que la CPU trabaja con números binarios.
Tal como se estudió en la UEA “Arquitectura de computadoras”, a grandes
rasgos, la computadora opera mediante transferencia de datos entre registros
y memoria, coordinación de sus componentes con la señal de reloj, y múltiples
operaciones.
Para entender la relevancia del algoritmo, se debe tener presente que al
representar valores binarios negativos se necesita un bit extra junto al bit más
significativo, el cual indicará un valor positivo si es 0 y un número negativo si es
1. Andrew Donald Booth inventó este algoritmo en 1950, el cual aumentó la
velocidad de operación al multiplicar números binarios con signo.
Operación del algoritmo.
Dado un multiplicando (M) y un multiplicador (Q), se debe analizar pares de bits
del multiplicador, concatenados de izquierda a derecha. Si la combinación de
bits es 01, se realiza una suma, si es 10 será una resta, y cuyo resultado se
multiplicarán por el multiplicando:
01 → 𝑆𝑆𝑆𝑆𝑆𝑆𝑆𝑆 → 2 𝑝𝑝𝑝𝑝𝑝𝑝𝑝𝑝𝑝𝑝𝑝𝑝ó𝑛𝑛 𝑑𝑑𝑑𝑑𝑑𝑑 0
10 → 𝑅𝑅𝑅𝑅𝑅𝑅𝑅𝑅𝑅𝑅 → 2 𝑝𝑝𝑝𝑝𝑝𝑝𝑝𝑝𝑐𝑐𝑐𝑐ó𝑛𝑛 𝑑𝑑𝑑𝑑𝑑𝑑 1
𝑀𝑀𝑀𝑀𝑀𝑀𝑀𝑀𝑀𝑀𝑀𝑀𝑀𝑀𝑀𝑀𝑀𝑀𝑀𝑀𝑀𝑀𝑀𝑀𝑀𝑀 𝑥𝑥 (𝑠𝑠𝑠𝑠𝑠𝑠𝑠𝑠𝑠𝑠 𝑦𝑦 𝑟𝑟𝑟𝑟𝑟𝑟𝑟𝑟𝑟𝑟𝑟𝑟)

2. Ejemplo:
𝑀𝑀𝑀𝑀𝑀𝑀𝑀𝑀𝑀𝑀𝑀𝑀𝑀𝑀𝑀𝑀𝑀𝑀𝑀𝑀𝑀𝑀𝑀𝑀𝑀𝑀 = 𝑀𝑀
𝑀𝑀𝑀𝑀𝑀𝑀𝑀𝑀𝑀𝑀𝑀𝑀𝑀𝑀𝑀𝑀𝑀𝑀𝑀𝑀𝑀𝑀𝑀𝑀𝑀𝑀 = 𝑄𝑄 = 01110110
𝑄𝑄 = 0 1 1 1 0 1 1 0
27
26
25
24
23
22
21
20
𝑀𝑀𝑀𝑀𝑀𝑀𝑀𝑀𝑀𝑀𝑀𝑀𝑀𝑀𝑀𝑀𝑀𝑀𝑀𝑀𝑀𝑀𝑀𝑀𝑀𝑀 𝑥𝑥 𝑄𝑄 = 𝑀𝑀𝑀𝑀𝑀𝑀𝑀𝑀𝑀𝑀𝑀𝑀𝑀𝑀𝑀𝑀𝑀𝑀𝑀𝑀𝑀𝑀𝑀𝑀𝑀𝑀 𝑥𝑥 (+27
− 24
+ 23
− 21)
= 𝑀𝑀𝑀𝑀𝑀𝑀𝑀𝑀𝑀𝑀𝑀𝑀𝑀𝑀𝑀𝑀𝑀𝑀𝑀𝑀𝑀𝑀𝑀𝑀𝑀𝑀 𝑥𝑥 (118)
Operación del algoritmo en Verilog.
Para su implementación en Verilog, se deben considerar los siguientes puntos:
• Se necesita un bit auxiliar para iniciar la comparación de 2 bits, al cual se
le asignará un cero. En el ejemplo visto anteriormente no es relevante
desde dónde se empiece a comparar, pero para fines prácticos se
propone comenzar con el bit menos significativo, es decir, en la primera
iteración se concatenará el bit menos significativo del multiplicador y el
bit auxiliar (que almacena primeramente cero).
• Para poder interpretar los valores negativos, se debe tener 2 entradas de
n+1 bits, siendo n el número de bits que se necesitan para representar el
valor que se desea multiplicar.
• Habrá 3 situaciones al comparar el par de bits concatenados, una en la
que se realice la suma, en otra la resta, y posterior a cualquiera de esas
operaciones, se dará un corrimiento a la derecha para poder comparar
los siguientes bits. El tercer caso será cuando no exista cambio entre los
bits (00 o 11), entonces se realizará directamente el corrimiento.

3. • Además, se necesitará un registro de tamaño n+1, el cual se empleará
para efectuar las sumas y restas.
• La condición que detendrá el algoritmo será cuando el contador, con
valor inicial n+1, llegue a cero. Por lo tanto, después de cada corrimiento
el contador debe tener un decremento en 1. Si aún no se terminan de
comparar todos los pares de bits, se debe regresar al paso donde se
verifica qué combinación de bits se tiene.
• El resultado se guardará en un registro de tamaño 2x(n+1).
Diseño de hardware para el algoritmo de Booth.
CLK
Multiplicando
Tamaño: n+1 bits
Multiplicador
Tamaño: n+1 bits
Registro auxiliar
Tamaño: n+1 bits
Bit auxiliar
1 bit
Contador
n
Operando1 Operando2
Resultado

4. Diagrama de flujo.
Start
A ← 0
bitAux ← 0
M ← Multiplicando
Q ← Multiplicador
Contador ← n
INICIALIZAR
Q[0], bitAux
VERIFICAR
A ← A + M A ← A - M
01 10
SUMA RESTA
Corrimiento a la derecha
A → Q → bitAux
Contador ← Contador - 1
Resultado ← A, Q
CORRIMIENTO
CUENTA
CICLO
¿Contador == 0?
End
00
11
Sí
No
INICIO

5. INICIALIZAR
VERIFICAR
CUENTA
CICLO
VERIFICAR
CUENTA
CICLO
VERIFICAR
Ejemplo de operación:
𝑂𝑂𝑂𝑂𝑂𝑂𝑂𝑂𝑂𝑂𝑂𝑂𝑂𝑂𝑂𝑂1 = −7
𝑂𝑂𝑂𝑂𝑂𝑂𝑂𝑂𝑂𝑂𝑂𝑂𝑂𝑂𝑂𝑂2 = 8
𝑀𝑀 = −7𝐷𝐷 = 11001𝐵𝐵
𝑄𝑄 = 8𝐷𝐷 = 01000𝐵𝐵
𝐴𝐴 = 0𝐷𝐷 = 00000𝐵𝐵
𝑏𝑏𝑏𝑏𝑏𝑏𝑏𝑏𝑏𝑏𝑏𝑏𝑏𝑏𝑏𝑏𝑏𝑏𝑏𝑏𝑏𝑏 = 0
𝐶𝐶𝐶𝐶𝐶𝐶𝐶𝐶𝐶𝐶𝐶𝐶𝐶𝐶𝐶𝐶 = 5
Q[0] = 0 bitAuxiliar = 0
0 0 0 0 0 0 0 1 0 0 0
A Q bitAuxiliar
Contador = 5 - 1 = 4
¿Contador == 0? → No
Q[0] = 0 bitAuxiliar = 0
0 0 0 0 0 0 0 0 1 0 0
A Q bitAuxiliar
Contador = 4 - 1 = 3
¿Contador == 0? → No
Q[0] = 0 bitAuxiliar = 0
CORRIMIENTO
CORRIMIENTO

6. CUENTA
CICLO
VERIFICAR
RESTA
CUENTA
CICLO
VERIFICAR
SUMA
0 0 0 0 0 0 0 0 0 1 0
A Q bitAuxiliar
Contador = 3 - 1 = 2
¿Contador == 0? → No
Q[0] = 1 bitAuxiliar = 0
A ← A – M
0 0 0 0 0 A
+ 0 0 1 1 1 Complemento a 2 de M
0 0 1 1 1 Nuevo valor de A
Ahora es importante notar que se debe conservar el signo de A, esto se logrará usando un
registro auxiliar “signo”.
0 0 0 1 1 1 0 0 0 0 1
Signo A Q bitAuxiliar
Contador = 2 - 1 = 1
¿Contador == 0? → No
Q[0] = 0 bitAuxiliar = 1
A ← A + M
1 1
0 0 0 1 1 A
+ 1 1 0 0 1 M
1 1 1 0 0 Nuevo valor de A
CORRIMIENTO
CORRIMIENTO

7. CUENTA
CICLO
1 1 1 1 0 0 1 0 0 0 0
Signo A Q bitAuxiliar
Contador = 1 - 1 = 0
¿Contador == 0? → Sí
Resultado ← A, Q
Resultado = 1 1 1 1 0 0 1 0 0 0
El resultado obtenido es en complemento a 2, así el complemento a 2 se puede
calcular de 2 maneras:
• Cambiando 1’s por 0’s y viceversa, y sumándole 1.
• Encontrar el primer 1 menos significativo, conservarlo, respetar los bits
menos significativos, y los bits más significativos cambiarlos (1’s por 0’s y
viceversa)
Antes de realizar el cambio, se debe observar cuál es el signo del resultado. En
este ejemplo fue negativo:
− 𝐶𝐶𝐶𝐶𝐶𝐶𝐶𝐶𝐶𝐶𝐶𝐶𝐶𝐶𝐶𝐶𝐶𝐶𝐶𝐶𝐶𝐶𝐶𝐶2(1111001000)
Ahora se realiza el cambio:
→ Encontrar el primer 1 menos significativo, conservarlo y respetar los bits
menos significativos. Intercambiar los 1’s y 0’s de los bits restantes (más
significativos).
𝑅𝑅𝑅𝑅𝑅𝑅𝑅𝑅𝑅𝑅𝑅𝑅𝑅𝑅𝑅𝑅𝑅𝑅 = − 0000111000𝐵𝐵 = −56𝐷𝐷
CORRIMIENTO

8. Código del programa en Verilog.
Con la finalidad de que el proceso sea más claro, se usaron parámetros para
nombrar los estados y poder seguir la secuencia del ejemplo.
`timescale 1ns / 1ps
///////////////// Verilog Module /////////////////
//////////////////////////////////////////////////////////////////
module booth(
input [4:0] oper1,
input [4:0] oper2,
input clk,
output reg[9:0] resultado
);
//ESTADOS DEL ALGORITMO
parameter inicio=3'b000, inicializar=3'b001,
verificar=3'b010, resta=3'b011, suma=3'b100,
corrimiento=3'b101, cuenta=3'b110, ciclo=3'b111;
//VARIABLES
reg [4:0] a, q, m;
reg [2:0] contador;
reg bitAux, signo;
reg [2:0] actual, futuro;
//INICIALIZACION
initial a = 0;
initial q = 0;
initial m = 0;
initial contador = 5;
initial bitAux = 0;
initial signo = 0;
initial resultado = 0;
initial actual = inicio;
initial futuro = inicializar;
//BLOQUE PARA LA TRANSICIӎ
always @(posedge clk)
actual = futuro;
//DETECTA EL ESTADO ACTUAL
//CALCULA EL ESTADO SIGUIENTE
//REALIZA OPERACIONES
always@(actual)
case(actual)
inicio:begin
futuro = inicializar;
end

9. inicializar:begin
m = oper1;
q = oper2;
futuro = verificar;
end
verificar:begin
case({q[0],bitAux})
2'b00:futuro = corrimiento;
2'b01:futuro = suma;
2'b10:futuro = resta;
2'b11:futuro = corrimiento;
endcase
end
resta:begin
a=a-m;
futuro = corrimiento;
end
suma:begin
a=a+m;
futuro = corrimiento;
end
corrimiento:begin
bitAux = q[0];
q = q>>1;
q[4] = a[0];
a = a>>1;
signo = a[3];
a[4] = signo;
futuro = cuenta;
end
cuenta:begin
contador = contador-1;
futuro = ciclo;
end
ciclo:begin
if(contador != 0)
futuro = verificar;
else begin
resultado[9:5] = a;
resultado[4:0] = q;
end
end
default:begin
actual = inicializar;
futuro = verificar;
end
endcase
endmodule

10. `timescale 1ns / 1ps
///////////////// Verilog Test Fixture /////////////////
///////////////////////////////////////////////////////////
module booth_tb;
// Inputs
reg [4:0] oper1;
reg [4:0] oper2;
reg clk;
// Outputs
wire [9:0] resultado;
// Instantiate the Unit Under Test (UUT)
booth uut (
.oper1(oper1),
.oper2(oper2),
.clk(clk),
.resultado(resultado)
);
initial begin
// Initialize Inputs
oper1 = -7; // M
oper2 = 8; // Q
clk = 0;
// Wait 100 ns for global reset to finish
#100;
// Add stimulus here
forever begin
clk=~clk;
#50;
end
end
endmodule

11. Ejecución del programa.

12. Descargar el proyecto en Verilog.
https://drive.google.com/file/d/1J01IpsBgVmrGk_5s_k4ZYJWWmVfPAoOR/view?
usp=sharing
Bibliografía.
https://www.geeksforgeeks.org/computer-organization-booths-algorithm/
https://es.wikipedia.org/wiki/Algoritmo_de_Booth