Diseñando un ALU simple

Necesito diseñar una ALU con dos entradas de 8 bits A y B y entradas de control x, y y z que admitan las siguientes operaciones:

x  y  z  |  operation

0  0  0  |  S = A-B
0  0  1  |  S = A+B
0  1  0  |  S = A*8
0  1  1  |  S = A/8
1  0  0  | S = A NAND B (bitwise)
1  0  1  | S = A XOR B (bitwise)
1  1  0  | s = reverse the bits of A
1  1  1  | S = NOT A (bitwise)

Se supone que esto se debe hacer con un sumador de 8 bits y un extensor de lógica aritmética. Al leer mi libro de texto, veo que el propósito de un extensor AL es alterar los bits de entrada para que un sumador, en lugar de muchos componentes adicionales, pueda usarse para hacer todo (o al menos eso es lo que entiendo de él). ) Por ejemplo, el extensor AL podría poner los bits en el complemento de dos para que el sumador reste. Del mismo modo, para las operaciones lógicas bit a bit, los bits podrían alterarse adecuadamente y una de las entradas del sumador podría ser cero para que el resultado se obtenga correctamente.

Pero, ¿qué hago exactamente con respecto a la multiplicación? Mi libro es muy vago, así que no estoy seguro de si un extensor AL requeriría que haga algo inteligente para que el sumador haga el trabajo (¿solo agrego 8 veces en mi caso? ... ja, ja), o si simplemente puede lanzar un multiplicador allí. Tendré que leer sobre la división, pero apuesto a que es similar a la multiplicación.

Bueno, de todos modos, la conclusión sigue siendo, ¿qué es un "extensor" AL "permitido" ser / poder tener en él? ¿Es su único propósito alterar la entrada para que se pueda alimentar a un sumador?

* EDITAR: Bueno, es multiplicación / división por 8, por lo que esto se puede realizar fácilmente con el desplazamiento hacia la izquierda o hacia la derecha por 3. ¿Seguiría teniendo un extensor de AL real / apropiado si añadiera algunos cambios allí? (Tal vez estoy pensando demasiado en esto como un completo principiante ...)

El enfoque más simple sería decodificar las entradas xyz en ocho líneas. Luego, a partir de estos, implementa la lógica que controla las líneas de selección de chips para habilitar la unidad adecuada que maneja las entradas, así como cualquier transformación que sea necesaria para que la unidad realice la operación correcta.

No creo que pueda usar un sumador para sus operaciones lógicas porque el sumador lleva (a menos que tenga alguna entrada que inhabilite el comportamiento de la propagación de transporte). Pero puede tener una sola unidad para hacer toda la lógica.

Tal vez hay una razón por la que llaman a estos ALU, con una A y una L. separadas :)

La multiplicación por 8 solo significa poner ceros en las tres líneas de entrada más bajas, ignorar las tres líneas superiores y asignar la línea 0 a la línea 3, 1 a 4, y así sucesivamente. Es como un interruptor de ferrocarril.

(Truco)
La solución más simple pero más poderosa es usar una memoria Flash como una tabla de búsqueda para los resultados. La entrada A de 8 bits + la entrada B de 8 bits + el código de operación de 3 bits es de 19 bits. Elige un 512 k$\times$Flash de 16 bits (alrededor de $ 2), use las 19 líneas de entrada como dirección y programe con los resultados para cada combinación de entrada. De esta manera, puede realizar cualquier operación que desee. ¿Quieres pecado (A)? Simplemente agregue una tabla de búsqueda sinusoidal de 256 palabras, incluso puede tener un resultado preciso de 16 bits. No está limitado a multiplicar por 8; puede multiplicar A por B. Igualmente, puede dividir A por B y obtener un cociente de 8 bits y un resto de 8 bits. Para la multiplicación y división, usará todos los bits en un bloque de 64 palabras, pero por ejemplo, la inversión de bits hace un uso menos eficiente: no depende del valor de B, por lo que tendrá 256 valores idénticos para cada entrada A, y el byte de alto orden ni siquiera se usaría. Entonces, mientras que solo necesitas 256$\times$ 8 = 2048 bits para la inversión de bits que usaría 65536 $\times$16 = 1048576 bits; Eso no es muy eficiente. Podría llamar a esto un serio inconveniente de la solución Flash, pero me gustaría verte implementar un 8$\times$ 8 multiplicador usando puertas lógicas básicas por $ 2.

OK, tal vez no quieras eso; Las puertas lógicas son mucho más desafiantes. Como dice Kaz , comience con un decodificador de 3 a 8 para tener una señal única para cada código de operación. Puede hacer esto con compuertas básicas, pero sugeriría usar un 74HC238 para comenzar. Cuando el ALU funciona, aún puede reemplazar el HC238 por una colección de puertas.

Lo que no desea para el multiplicador es un registro de desplazamiento que se desplaza a la izquierda 3 veces. Esa es una función registrada que necesita un reloj, en lugar de una función combinatoria que produce el resultado de inmediato. (Tenga en cuenta que Flash también produce cualquier resultado en nanosegundos, aunque más lento que con la lógica combinatoria). Tenga una ruta de A0 a Y3, A1 a Y4, etc., que habilite con el código de operación decodificado "010". Del mismo modo, Y3 se conectará a A6 si la señal "011" está activa (división), y a A4 cuando el opcoe es "110" (inversión de bits). Eso significa mucha multiplexación.

Para volver al Flash, también puede hacer una combinación de lógica combinatoria para operaciones simples, como NAND, NOR, shift left, shift right$^{(*)}$, y solo use Flash para la multiplicación y división. Podría usar un Flash más pequeño (128 kword en lugar de 512 kword), o agregar funciones más avanzadas, como el seno que di como ejemplo (tal vez no sea el mejor, pero estoy seguro de que puede pensar en algo).

$^{(*)}$¿Cómo es que tienes una multiplicación por 8, pero no queda el cambio más básico? Desplazar hacia la izquierda / derecha, rotar hacia la izquierda / derecha (tanto a través de acarreo como no) son imprescindibles para cualquier ALU, y puede dividir por 8 usando 3 derechos de desplazamiento, mientras que no puede dividir por 2. La inversión de bits es un DSP típico función, pero no quieres construir un DSP para empezar, ¿verdad? Cambiaría las funciones a

x  y  z  |  operation

0  0  0  |  S = A - B
0  0  1  |  S = A + B
0  1  0  |  S = shift left A by 1 bit
0  1  1  |  S = shift right A by 1 bit
1  0  0  |  S = A NAND B (bitwise)
1  0  1  |  S = A XOR B (bitwise)
1  1  0  |  S = rotate left A
1  1  1  |  S = NOT A (bitwise)

Me quedé atrapado en el mismo problema del mismo libro. Afortunadamente me topé con este hilo que me dio una idea de qué hacer. Kaz tiene un muy buen punto sobre conducir ceros y líneas de mapeo. El extensor de ALU en este libro está diseñado de n (n que representa el número de bits sobre los cuales operar) componentes combinacionales idénticos pero separados y un componente diferente para llevar. Estos componentes tienen cinco entradas y dos salidas. Las cinco entradas son: 'X', 'Y', 'Z' (para seleccionar la operación) y 'a', 'b' (bits individuales de A y B con el mismo significado). Supongo que la idea aquí es dividir el problema en trozos más pequeños para tener una tabla de verdad de tamaño razonable. Es decir, 5 entradas frente a 8 + 8 + 3 = 19 entradas si el extensor acepta todos los bits de A y B más entradas de control. Ahora, si el extensor estuviera compuesto de tal manera (19 entradas), creo que la lógica para la multiplicación podría implementarse en ese único componente, pero escribir una tabla de verdad para esto estaría fuera de discusión. De todos modos, mi solución es usar muxes después de cada componente que maneja los bits individuales ayb, suponiendo que el componente ya esté diseñado de tal manera que una entrada XYZ = 010 pase 'un' bit sin cambios y filtre 'b', es decir 'b' = 0. El mux debe tener dos entradas, una del componente anterior y otra del componente tres lugares a la derecha. Tres muxes más a la derecha deben tener ceros como segunda entrada. Una lógica combinatoria simple con una compuerta AND y dos inversores puede configurar los muxes cuando XYZ = 010.