Mejorar mi ALU "De NAND a Tetris" en VHDL

Navega tus respuestas
1

Estoy siguiendo el curso De NAND a Tetris , pero en lugar de usar el software del autor, estoy tratando de programar directamente un Spartan 6 FPGA . Ahora estoy resolviendo el ejercicio ALU y terminé escribiendo el siguiente código ( descargo de responsabilidad: Comencé a aprender VHDL ayer): 

library IEEE;
use IEEE.STD_LOGIC_1164.ALL;
use IEEE.STD_LOGIC_UNSIGNED.ALL;

entity alu is
    Port (x  : in  STD_LOGIC_VECTOR(15 downto 0);
          y  : in  STD_LOGIC_VECTOR(15 downto 0);

          zx : in  STD_LOGIC;
          nx : in  STD_LOGIC;
          zy : in  STD_LOGIC;
          ny : in  STD_LOGIC;
           f : in  STD_LOGIC;
          no : in  STD_LOGIC;

          output : out STD_LOGIC_VECTOR(15 downto 0);
          zr     : out STD_LOGIC;
          ng     : out STD_LOGIC);

             constant zeros: STD_LOGIC_VECTOR(15 downto 0) := "0000000000000000";
end alu;

architecture Behavioral of alu is
begin
    op: process(x, y, zx, nx, zy, ny, f, no)
      variable px: STD_LOGIC_VECTOR(15 downto 0);
      variable py: STD_LOGIC_VECTOR(15 downto 0);
      variable po: STD_LOGIC_VECTOR(15 downto 0);
    begin
      px := x;
      py := y;

      px := zeros   when (zx = '1');
      px := not(px) when (nx = '1');
      py := zeros   when (zy = '1');
      py := not(py) when (ny = '1');

      if (f = '1') then 
        po := (px + py);
      else
        po := (px AND py);
     end if;

      po := not(po) when (no = '1');
      output <= po;

     if (po = zeros) then
        zr <= '1';
      else
        zr <= '0';
      end if;

      ng <= po(0);
    end process;
end Behavioral;

Ahora me pregunto si hay una forma más sencilla de lograr lo mismo, considerando:

  1. (VHDL) Buenas prácticas;
  2. (VHDL) Tamaño del código;
  3. Usando la menor lógica secuencial posible;
  4. Tamaño de la síntesis.
pregunta Hugo Sereno Ferreira

1 respuesta

2
  

(VHDL) Buenas prácticas;

Es mucho más fácil programar la reunión si haces que cada entidad esté sincronizada: dale un reloj (y reinicia si es necesario) y escribe un proceso cronometrado. Tampoco debe preocuparse por mantener las listas de sensibilidad actualizadas.

Note esto: 

use IEEE.STD_LOGIC_UNSIGNED.ALL;

No utilices eso, aunque se comporta mejor que std_logic_arith . Use ieee.numeric_std.all; en su lugar y luego use los tipos adecuados para sus vectores.

Uso de variables: es una buena señal en mi libro. Mantiene las cosas locales muy locales.

Podrías dimensionar tus variables automáticamente: 

variable px : std_logic_vector(x'range);

y su constante (que podría mover a la arquitectura, que sería más convencional): 

constant zeros: STD_LOGIC_VECTOR(x'range) := (others => '0');
  

(VHDL) Tamaño del código

No estoy seguro de que puedas guardar tanto código sin perder la legibilidad

  

Usando la menor lógica secuencial posible;

¿Por qué? Las chanclas son casi gratis en FPGAs. Casi siempre me quedo sin LUT primero.

  

Tamaño de la síntesis

No es frecuente que el código tenga la mayor influencia en el tamaño de la síntesis. Es algo de nivel superior como paralelo (mucha lógica) vs. secuencial (un poco de lógica a su vez, pero no olvide que la máquina de estado que lo controla puede ser una sobrecarga).

    
respondido por el Martin Thompson

Lea otras preguntas en las etiquetas

¿Sensor recomendado? Distancia - Alto calor y polvo ¿Qué pruebas se pueden realizar para detectar un IC defectuoso con solo un multímetro?