Arquitectura del computador

Carlos Enrique Caicedo

Harry Esteban Sánchez

Juan Andrés Rodríguez

Segundo proyecto

Pontificia Universidad Javeriana

. ALGORITMO DE BOOTH

En este caso, para realizar el algoritmo de Booth es necesario empezar con una explicación clara sobre cómo funciona este. Primero, se debe tener claridad sobre
el número de bits (n) que contienen los números a multiplicar ya que este representa la cantidad de veces que se va a ejecutar este algoritmo. Dicho esto, el
algoritmo de Booth sigue estos pasos:

1. Primeramente, se toman los números binarios que se quieren multiplicar y se convierten a su representación en complemento A2, el cual es una forma de
representación de los números negativos en el sistema binario.

2. Posteriormente se debe crear un registro el cual debe guardar los dos primeros n bits de derecha a izquierda. Los n bits más significativos se utilizan para
almacenar el multiplicando y los n bits menos significativos se inicializan a cero. Al primer número, es decir, el sumando, se le añaden n cantidad de 0 a la
derecha y al segundo se le añaden n cantidad de 0 a la izquierda

3. Cuando se tenga lo anterior, se realiza un bucle las mismas veces que el tamaño de bits (n). En cada iteración, se revisan estos dos bits guardados en el paso
anterior. Existen cuatro casos posibles para estos dos bits, si estos son iguales a "01", se resta el multiplicando del registro de multiplicación. Si son iguales a
"10", se suma el multiplicando al registro de multiplicación. En cualquier otro caso, no se realiza ninguna operación.

4. Después de cada iteración, el registro de multiplicación se desplaza un bit hacia la derecha. En la primera iteración, se agrega un cero al bit más
significativo y en las siguientes iteraciones, se agrega el bit más significativo del registro de multiplicación anterior.

5. Al final de las n iteraciones, los n bits menos significativos del registro de multiplicación contienen el producto final.

1 CMP comparador ALU XOR

1 bgt if

// Para esta función se añadieron dos funciones adicionales las cuales son CMP la cual es la encargada de comparar dos variables, en este caso enteros para
verificar si un a condición se cumple o no, si esta comparación es igual realiza la operación que se le indique.

// La otra funciona añadida es BGT la cual es un condicional que está encargada de finalizar un ciclo cuando la condición incluida en este se cumpla. Funciona
poniendo una condición la cual debe ser la cantidad de veces que se quiere ejecutar un ciclo, y siempre que el otro número sea menor a la cantidad de veces se va
a ejecutar.
// en los comentarios se encuentra una variable adicional llamada n la cual corresponde al número de bits de los números ingresados.

0 .data
1 a: .word#17 //multiplicando
2 p: .word#17 //multiplicador
3 s: .word#17 //complemento A2
4 auxiliar: .word#17 //Arreglo que se utiliza para que dentro de un mismo ciclo no se ejecute un condicional 2 veces, al final se copia este valor en p
5 carry: .word 1 // Variable que Guarda el carry de la suma
6 aux: .word 1 // Guarda solamente un bit de tal manera que se pueda hacer el corrimiento de valores en los casos presentados
7 isumado: .word1 //Guarda la siguiente posición de i, es decir i+1 hasta el final del ciclo se modifica la variable ya que si se modifica adentro
puede cumplir varias condiciones a la vez
8 MOV a,multiplicado // Valor de bits a multiplicar (multiplicando)
9 MOV p,multiplicador // Valor de bits a multiplicar (multiplicador)
10 loop blt i,8,exit_loop //For (inti=0;i<8)
11 CMP i(p),0 // Compara si p en la posición i es 0
12 MOV i(s),1 // cambia el 0 por 1
13 CMP i(p),1 // Compara si p en la posición i es 1
14 MOV i(s),0 // cambia el 1 por 0
15 ADD i,i,1 //i+=1
16 exit_loop // Sale del ciclo
17 CMP 8(s),0 // Compara s en la posicion n y valida si es igual a 0
18 MOV 8(s),1 // Cambia el valor de s en la posición n por 1
19 CMP 8(s),1 // Compara s en la posicion n y valida si es igual a 1
20 MOV 8(s),0 // Cambia el valor de s en la posición n por 0
21 loop bgt j,8,exil_loop //Entra al loop siempre que j sea menor a 8 porque son 8 bits
22 CMP 16(p),0 // Se compara p en la posición 2n con 0
23 CMP 17(p),0 // Se compara p en la posición 2n+1 con 0
24 Loop bgt i,i, // Entra al ciclo, en este caso, siempre que
25 ADD i,isumado,i+1 // se suma isumado con i+1 y se guarda en la variable i
26 MOV isumado(p),i(p) // Se copia el valor de p en la posicion i en p en la posicion isumado
27 ADD j,j,1 // Se suma j con l y se guarda en j
28 CMP 16(p),0 // Se compara p en la posición 2n con 0
29 CMP 17(p),1 // Se compara p en la posición 2n+1 con 1
30 loop bgt i,i,17 //
31 AND i(p),i(a) // se multiplica a en la posicion i con p en la posicion i
32 AND i(p),carry // se multiplica p en la posicion i con el carry
33 CMP i(p),1 // Se compara si p en la posición i es igual a 1
34 CMP i(a),1 // Se compara si a en la posición i es igual a 1
35 MOV carry,1 // Se copia el valor 1 al carry
36 CMP i(p),0 // Se compara si p en la posición i es igual a 0
37 MOV carry,0 // Se copia el 0 en el valor de carry
38 CMP i(p),0 // Se compara si p en la posición i es igual a 0
39 MOV carry,0 // Copiar 0 en el carry
40 Exit_loop // Se sale del ciclo
41 CMP 16(p),1 // Se compara p en la posición 2n con 1
42 CMP 17(p),0 // Se compara p en la posición 2n+1 con 0
43 loop bgt i,i,17 //
44 AND i(p),i(s) // se multiplica s en la posicion i con p en la posicion i
45 AND i(p),carry // se multiplica p en la posicion i con el carry
46 CMP i(p),1 // Se compara si p en la posición i es igual a 1
47 CMP i(s),1 // Se compara si s en la posición i es igual a 1
48 MOV carry,1 // Se copia el valor 1 al carry
49 CMP i(p),0 // Se compara si p en la posición i es igual a 0
50 MOV carry,0 // Se copia el valor 0 al carry
51 CMP i(p),0 // Se compara si p en la posición i es igual a 0
52 MOV carry,0 // Se copia el valor 0 al carry
53 Exit_loop // Se sale del ciclo
54 CMP 16(p),1 // Se compara p en la posición 2n para conocer si es igual a 1
55 CMP 17(p),0 // Se compara p en la posición 2n+1 para conocer si es igual a 0
56 MOV aux,17(p) // Se mueve 2n+1 al auxiliar “aux”
57 Loop bgt i,i, //
58 ADD i,isumado,i+1 // se suma el valor de isumado con i+1 y se guarda en la posicion i
59 MOV isumado(p),i(p) // se copia el valor de p en la posicion i en p en la posicion isumado
60 ADD j,j,1 // Se suma j con l y se guarda en j
61 exit_loop //Se sale del ciclo y se termina el programa
 Para este programa, el número de bits n=8, es por eso que es posible trabajar con las posiciones exactas de los bits, por eso es posible trabajar las posiciones
de los bits con números exactos 16 serian los bits con los 0 añadidos y 17 sería el 0 que se añade al final de las tres variables.
Al iniciar el programa se definen las tres variables como “a”, “p” y “s”, y a través de ciclos y condicionales se comprueban los dos últimos bits para
realizar las respectivas operaciones. este ciclo se ejecuta 8 veces y finalmente se tiene el resultado.
PRUEBA DE ESCRITORIO

1--7

8 0 0 0 0 0 1 0 1 0 0 0 0 0 0 0 0 0 Multiplicado

9 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 Multiplicador

0-20 1 1 1 0 1 0 1 1 0 0 0 0 0 0 0 0 0 Complemento A2

Iteracion 1

1-fin 0

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

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

Iteracion 2

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

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

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

Iteracion 3:

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

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

Iteracion 4:

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

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

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

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

Iteracion 5:

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

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

Iteracion 6:

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

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

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

Iteracion 7:

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

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

Iteracion 8:

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

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

2. BONUS

Para este punto, se solicita que a través del lenguaje ensamblador se haga una operación exponencial, se tenga un número “x” el cual será considerado como la
base y “y” será tomado como el exponente. En este caso, se usa el algoritmo de Booth ya que estamos trabajando con multiplicación de binarios. Para ello, se
debe multiplicar “x” por “x” y adicionalmente se debe guardar el resultado final y volverlo a multiplicar por el “x” inicial “y” veces ya que se está operando una
potencia.

.data //inicio del programa

1 x: .word 1 // x Es la variable que guarda la base
2 y: .word 1 // y Es la variable que guarda el exponente
3 iii: .word 1 // iii es un iterador el cual se encarga de hacer n operaciones
4 a: .word#17 //multiplicando
5 p: .word#17 //multiplicador
6 s: .word#17 //complemento A2
7 auxiliar: .word#17 // Arreglo que se utiliza para que dentro de un mismo ciclo no se ejecute un condicional 2 veces, al final se copia este valor en p
8 carry: .word 1 // Variable que guarda el carry de la suma
9 aux: .word 1 // Guarda solamente un bit de tal manera que se pueda hacer el corrimiento de valores en los casos presentados
10 isumado: .word1 //Guarda la siguiente posición de i, es decir i+1 hasta el final del ciclo se modifica la variable ya que si se modifica adentro
puede cumplir varias condiciones a la vez
11 MOV p,a // Copiar el valor que esta en a en p
12 MOV iii,0 // Copiar el valor 0 en iii
13 loop bgt iii,iii,y //
14 loop bgt i,8,exit_loop //
15 CMP i(p),0 // Se compara p en la posición i con 0
16 MOV 17(s),1 // Se copia el valor 1 en la posición 2n+1de s
17 CMP i(p),1 // Se compara p en la posición i con 1
18 MOV 17(s),0 // Se copia el valor 0 en la posición 2n+1 de s
19 ADD i,i,1 // Se suma i con l y se guarda en i
20 exit_loop // Se sale del ciclo
20 17 CMP 8(s),0 // Se compara s en la posición n con 0
21 MOV 8(s),1 // Se copia el valor 1 en la posición n de s
22 CMP 8(s),1 // Se compara s en la posición n con 1
23 MOV 8(s),0 // Se copia el valor 0 en la posición n de s
24 loop bgt j,8,exil_loop //
25 CMP 16(p),0 // Se compara p en la posición 2n con 0
26 CMP 17(p),0 // Se compara p en la posición 2n+1 con 0
27 Loop bgt i,i, //
28 ADD i,isumado,i+1 // Se suma isumado con i+1 y se guarda en la variable i
29 MOV isumado(p),i(p) // se copia el valor de p en la posicion i en p en la posicion isumado
30 ADD j,j,1 // Se suma j con l y se guarda en j
31 CMP 16(p),0 // Se compara p en la posición 2n con 0
32 CMP 17(p),1 // Se compara p en la posición 2n+1 con 1
33 loop bgt i,i,17 //
34 AND i(p),i(a) // Multiplica p en la posicion i con a en la posicion i
35 AND i(p),carry // Multiplica p en la posicion i con el carry
36 CMP i(p),1 // Se compara p en la posición i con 1
37 CMP i(a),1 // Se compara a en la posición i con 0
38 MOV carry,1// Se copia el valor 1 al carry
39 CMP i(p),0 // Se compara p en la posición i con 0
40 MOV carry,0 // Se copia el valor 0 al carry
41 CMP i(p),0 // Se compara p en la posición i con 0
42 MOV carry,0 // Se copia el valor 0 al carry
43 exit_loop // Se sale del ciclo
44 CMP 16(p),1 // Se compara p en la posición 2n con 1
45 CMP 17(p),0 // Se compara p en la posición 2n+1 con 0
46 loop bgt i,i,17 //
47 AND i(p),i(s) // Multiplica p en la posicion i con s en la posicion i
48 AND i(p),carry // Multiplica p en la posicion i con el carry
49 CMP i(p),1 // Se compara p en la posición i con 1
50 CMP i(s),1 // Se compara s en la posición i con 0
51 MOV carry,1 // Se copia el valor 1 al carry
52 CMP i(p),0 // Se compara p en la posición i con 0
53 MOV carry,0 // Se copia el valor 0 al carry
54 CMP i(p),0 // Se compara p en la posición i con 0
55 MOV carry,0 // Se copia el valor 0 al carry
56 Exit_loop // Se sale del ciclo
57 CMP 16(p),1 // Se compara p en la posición 2n con 1
58 CMP 17(p),0 // Se compara p en la posición 2n con 0
59 MOV aux,17(p) // Se copia el valor de 2n+1 al auxiliar
60 Loop bgt i,i, //
61 ADD i,isumado,i+1 // Se suma isumado con i+1 y se guarda en la variable i
62 MOV isumado(p),i(p) // Se copia el valor de p en la posicion i en p en la posicion isumado
63 ADD j,j,1 // Se suma j con l y se guarda en j
64 exit_loop // Se sale del ciclo
65 MOV hl,0 // Se copia el valor 0 en hl
66 MOV h,8 // Se copia el valor 8 en h
67 loop blt hl,hl,8 //
68 MOV lh(p),h(p) // Se copia el valor de p en la posicion h en p en la posición lh
69 ADD h,h,1 // Se suma h con l y se guarda en h
70 ADD hl,hl,1 // Se suma hl con l y se guarda en hl
71 exit_loop // Se sale del ciclo
72 exit_loop // Se sale del ciclo y se termina el programa

Este programa es muy parecido al anterior con la diferencia que se usa un ciclo for adicional ya que se necesita hacer una multiplicación de bits varias
veces. En él, se tiene la variable y que va a servir para saber cuantas veces se debe repetir este ciclo adicional.
Las variables “a” y “p” correspondientes respectivamente al multiplicando y el multiplicador, son igualadas a el valor ingresado en “x”.
Prueba de escritorio BONUS

funciones:
0 0 Correr a la derecha
0 1 p+a y corren a la derecha
1 0 p+s y corren a la derecha
1 1 Correr a la derecha

42

100*100=10000
Linea
1-2 y 2
1--7 Loop 1
8 A 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 Multiplicado
9 P 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 Multiplicador
Complemento
10-20 S 1 1 1 1 1 0 1 0 0 0 0 0 0 0 0 0 0
Iteracion 1
21-fin Aux 0
Auxiliar 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0
P 0 0 0 0 0 0 0 0 0 0 0 1 1 0 1 1 0
Iteracion 2
Aux 0
Auxiliar 1 1 1 1 1 0 1 0 0 0 0 1 1 0 1 1 0
carry 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
Auxiliar 0 1 1 1 1 1 0 1 0 0 0 0 1 1 0 1 1
P 0 1 1 1 1 1 0 1 0 0 0 0 1 1 0 1 1
Iteracion 3:
Aux 1
Auxiliar 1 0 1 1 1 1 1 0 1 0 0 0 0 1 1 0 1
P 1 0 1 1 1 1 1 0 1 0 0 0 0 1 1 0 1
Iteracion 4:
Aux 1
Auxiliar 1 1 0 0 0 0 1 0 1 0 0 0 0 1 1 0 1
carry 0 0 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0
Auxiliar 1 1 1 0 0 0 0 1 0 1 0 0 0 0 1 1 0
P 1 1 1 0 0 0 0 1 0 1 0 0 0 0 1 1 0
Iteracion 5:
Aux 1
Auxiliar 1 1 1 0 1 1 0 1 1 0 1 0 0 0 0 1 1 0
carry 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0
Auxiliar 0 1 1 1 0 1 1 0 1 1 0 1 0 0 0 0 1
P 0 1 1 1 0 1 1 0 1 1 0 1 0 0 0 0 1
Iteracion 6:
Aux 1
Auxiliar 0 1 1 1 1 0 1 0 1 0 0 0 0 0 0 0 1
carry 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0
Auxiliar 1 0 1 1 1 1 0 1 0 1 0 0 0 0 0 0 0
P 1 0 1 1 1 1 0 1 0 1 0 0 0 0 0 0 0
Iteracion 7:
Aux 0
Auxiliar 0 1 0 1 1 1 1 0 0 0 1 0 0 0 0 0 0
P 0 1 1 1 1 1 0 0 0 0 1 0 0 0 0 0 0
Iteracion 8:
Aux 0
Auxiliar 0 0 1 1 1 1 1 0 0 0 1 1 0 1 0 0 0
P 0 0 1 1 1 1 1 0 0 0 1 1 0 1 0 0 0
loop 1