KnowHow
Free Technical Resources

Here we present a 6-port Register File model. The logical function of a register file is very simple, it is after all the identity function, but once you start adding multiple read and write ports the complexity of modelling such a device seems to grow at an alarming rate.

This register file has 3 write and 3 read ports and a depth of 32 8-bit registers.

When it comes to coding up the design, there are a couple of key choices to make - behavioural or structural coding style. I trod the structural path as this allowed me to play with a variety of VHDL coding techniques. It also seemed that a behavioural approach wouldn't be as challenging...

From the code, you can see that quite a few generate statements are used. Sometimes the generate loop uses an array attribute, sometimes it uses a constant for the loop parameter. Many of the internal signals required the definition of their own data type. This was a synthesis tool constraint rather than a modelling decision, but that's another story. I also decided to mix multi-dimensional array indexing approaches. The register file ports and the latch actual signals are 2-index arrays whereas most of the other signals are arrays of vectors.

To implement the register file in a reasonably efficient way, I opted to use latches as the storage elements rather than flip-flops. There is no write address port conflict arbitration as yet.

You are welcome to use the source code we provide but you must keep the copyright notice with the code (see the Notices page for details).

 

library IEEE;
  use IEEE.std_logic_1164.all;
  use work.reg_file_pkg.all;
  use work.components.all;

entity reg_file_32_8_6port is
generic (
  num_write_ports : integer := 1;
  num_read_ports  : integer := 1;
  num_bidirectional_ports : integer := 0
);
port (
  write    : in std_logic_vector(((num_write_ports-1) + num_bidirectional_ports) downto 0);
  read     : in std_logic_vector((( num_read_ports-1) + num_bidirectional_ports) downto 0);
  address_write : in std_logic_2D_array(0 to 2, 4 downto 0);
  address_read  : in std_logic_2D_array(0 to 2, 4 downto 0);
  data_in  : in  std_logic_2D_array(0 to 2, 7 downto 0);
  data_out : out std_logic_2D_array(0 to 2, 7 downto 0)
);
end reg_file_32_8_6port;

architecture modular of reg_file_32_8_6port is

  constant depth : integer := 32;
  constant data_width : integer := 8;

  constant num_input_ports  : integer := num_write_ports + num_bidirectional_ports;
  constant num_output_ports : integer := num_read_ports  + num_bidirectional_ports;

  type select_bus is array (0 to num_input_ports-1) of std_logic_vector(depth-1 downto 0);
  -- 3 busses, 32 bits wide
  type address_write_bus is array (0 to num_input_ports-1) of std_logic_vector(log_2(depth)-1 downto 0);
  type address_read_bus  is array (0 to num_output_ports-1) of std_logic_vector(log_2(depth)-1 downto 0);
  type data_write_bus is array (0 to num_input_ports-1) of std_logic_vector(data_width-1 downto 0);
  type data_read_bus is array (0 to num_output_ports-1) of std_logic_vector(data_width-1 downto 0);

  signal data_WR_select : select_bus;

  signal addr_WR : address_write_bus;
  signal addr_RD : address_read_bus;
  signal WE_WR : std_logic_vector(0 to num_input_ports-1);
  signal OE_RD : std_logic_vector(0 to num_output_ports-1);

  signal data_WR : data_write_bus;
  signal latch_array_in  : std_logic_2D_array(0 to depth-1, data_width-1 downto 0);
  signal latch_array_out : std_logic_2D_array(0 to depth-1, data_width-1 downto 0);
  signal mux_out : data_read_bus;
  signal en : std_logic_vector(0 to depth-1);

begin

  s2: WE_WR <= not write;
  s3: OE_RD <= read;

  g3: for i in 0 to num_input_ports-1 generate
    g4: for j in 0 to log_2(depth)-1 generate
      addr_WR(i)(j) <= address_write(i, j);
    end generate g4;
    decode_addr_WR: demux_generic generic map (
      in_width => log_2(depth)
    ) port map (
      a      => addr_WR(i),
      enable => WE_WR(i),
      y      => data_WR_select(i)

    );
  end generate g3;

  g5: for i in data_in'RANGE(1) generate
    g6: for j in 0 to data_width-1 generate
      data_WR(i)(j) <= data_in(i, j);
    end generate g6;
  end generate g5;

  data_mux_selects: process (data_WR, data_WR_select)
    variable enable : std_logic_vector(0 to depth-1);
  begin
    for k in 0 to depth-1 loop
      for i in 0 to data_width-1 loop
        latch_array_in(k,i) <= data_WR(0)(i);
      end loop;
      enable(k) := '0';
      for j in 0 to num_input_ports-1 loop
        enable(k) := data_WR_select(j)(k) or enable(k);
      end loop;
      en(k) <= not enable(k);
      for j in 0 to num_input_ports-1 loop
        if data_WR_select(j)(k) = '1' then
          for i in 0 to data_width-1 loop
            latch_array_in(k,i) <= data_WR(j)(i);
          end loop;
        end if;
      end loop;
    end loop;
  end process;

  g0: for i in 0 to depth-1 generate
    g1: for j in 0 to data_width-1 generate
      latch_instance: d_latch port map (
        d      => latch_array_in(i,j),
        enable => en(i),
        q      => latch_array_out(i,j)
      );
    end generate g1;
  end generate g0;

  g2: for i in 0 to num_output_ports-1 generate
    g8: for j in address_read'RANGE(1) generate
      addr_RD(i)(j) <= address_read(i, j);
    end generate g8;
    op_mux: mux_generic
    generic map (
      data_width => data_width,
      funnel_factor => depth
    )
    port map (
      a   => latch_array_out,
      sel => addr_RD(i),
      y   => mux_out(i)
    );
  end generate g2;

  gi_mux: for i in 0 to num_output_ports-1 generate
    gj_data: for j in 0 to data_width-1 generate
      data_out(i,j) <= mux_out(i)(j);
    end generate gj_data;
  end generate gi_mux;

end modular;

To download the VHDL source code for this model, click here.

Back to VHDL models.