Вычисление двоичного логарифма итерационным методом на ПЛИС

 ----====================================================================================================================
----=========== PKG
----====================================================================================================================
library IEEE;
use IEEE.STD_LOGIC_1164.ALL;
use IEEE.NUMERIC_STD.ALL;
use ieee.math_real.all;

package log2Calc_pkg is

    -- расчет выходной разрядности
    function calc_dw(
        dw_in       : natural;
        dw_in_frac  : natural;
        dw_out_frac : natural
    ) return natural;

    -- определение задержки
    function calc_latency(
        dw_out      : natural;
        dw_out_frac : natural
    ) return natural;

end package log2Calc_pkg;

package body log2Calc_pkg is

    ----------------------------------------------------------------
    -- расчет выходной разрядности
    ----------------------------------------------------------------
    function calc_dw(
        dw_in       : natural;
        dw_in_frac  : natural;
        dw_out_frac : natural
    ) return natural is
        variable dw_in_int  : natural;
        variable dw_out_int : natural;
        variable value      : natural;
    begin
        dw_in_int := dw_in - dw_in_frac;

        if (dw_in_int >= dw_in_frac) then
            dw_out_int := natural(ceil(log2(real(dw_in_int))));
        else
            dw_out_int := natural(ceil(log2(real(dw_in_frac))));
        end if;

        value := dw_out_int + 1 + dw_out_frac;

        return value;
    end function calc_dw;

    ----------------------------------------------------------------
    -- определение задержки
    ----------------------------------------------------------------
    function calc_latency(
        dw_out      : natural;
        dw_out_frac : natural
    ) return natural is
        variable dw_out_int : natural;
        variable value      : natural;
    begin
        dw_out_int := dw_out - dw_out_frac;
        value      := 2 ** (dw_out_int - 1) + (dw_out_frac + 1) + 2;
        return value;
    end function calc_latency;

end package body log2Calc_pkg;

----====================================================================================================================
----=========== ENTITY
----====================================================================================================================
LIBRARY ieee;
USE ieee.std_logic_1164.all;
USE ieee.numeric_std.all;

use work.log2Calc_pkg.all;

ENTITY log2Calc IS
    generic(
        DW_IN       : natural := 16;
        DW_IN_FRAC  : natural := 14;
        DW_OUT_FRAC : natural := 22;
        DW_OUT      : natural := work.log2Calc_pkg.calc_dw(16, 14, 22)
    );
    PORT(
        clk     : in  std_logic;
        rst     : in  std_logic;
        valid_i : in  std_logic;
        data_i  : in  std_logic_vector(DW_IN - 1 downto 0); -- unsigned
        rdy_o   : out std_logic;
        valid_o : out std_logic;
        data_o  : out std_logic_vector(DW_OUT - 1 downto 0) -- signed 
    );
END log2Calc;

ARCHITECTURE rtl OF log2Calc IS

    constant DW_IN_INT  : natural := DW_IN - DW_IN_FRAC;
    constant DW_OUT_INT : natural := DW_OUT - DW_OUT_FRAC;

    type state_t is (IDLE,
                     EXPONENT,
                     MANTISSA,
                     RESULT
                    );
    signal STATE : state_t;

    signal zero : std_logic;

    signal order         : boolean;     -- true - [1,..) / false - (0, 1)
    constant LEN_CNT_EXP : natural := 2 ** (DW_OUT_INT - 1) + 1;
    signal cnt_exp       : integer range 0 to LEN_CNT_EXP - 1;
    signal buf           : integer range 0 to LEN_CNT_EXP - 1;

    constant STD_1 : unsigned(DW_IN downto 0) := to_unsigned(integer(1.0 * real(2 ** DW_IN_FRAC)), DW_IN + 1); -- ровно 1
    constant STD_2 : unsigned(DW_IN downto 0) := to_unsigned(integer(2.0 * real(2 ** DW_IN_FRAC)), DW_IN + 1); -- ровно 2

    signal shift : unsigned(DW_IN downto 0);

    signal exp_rdy : std_logic;
    signal exp_sh  : signed(DW_OUT - 1 downto 0); -- значение целой части без дробной
    signal exp     : signed(DW_OUT - 1 downto 0); -- значение целой части с учетом выделения бит под дробную (дробная по нулям)

    function max_nat(a : natural;
                     b : natural
                    )
    return natural is
    begin
        if (a > b) then
            return a;
        else
            return b;
        end if;
    end function max_nat;

    constant DW_NORM_FRAC : natural                        := max_nat(DW_IN_FRAC, DW_OUT_FRAC);
    constant DW_NORM      : natural                        := DW_NORM_FRAC + 2; -- [0,4)
    signal norm           : unsigned(DW_NORM - 1 downto 0);
    constant STD2_NORM    : unsigned(DW_NORM - 1 downto 0) := to_unsigned(integer(2.0 * real(2 ** DW_NORM_FRAC)), DW_NORM); -- ровно 2

    signal cnt_mant : integer range 0 to DW_OUT_FRAC;
    signal mant     : std_logic_vector(DW_OUT - 1 downto 0);

begin

    log2_proc : process(clk, rst)
        variable shift2_v : unsigned(DW_NORM - 1 downto 0);
        variable mult2_v  : unsigned(2 * DW_NORM - 1 downto 0);
    begin
        if (rst = '1') then
            STATE <= IDLE;

            zero <= '0';

            order <= true;

            cnt_exp <= 0;
            buf     <= 0;

            exp_rdy <= '0';
            exp_sh  <= (others => '0');
            exp     <= (others => '0');

            shift <= (others => '0');
            norm  <= (others => '0');

            cnt_mant <= 0;
            mant     <= (others => '0');

            rdy_o   <= '0';
            valid_o <= '0';
            data_o  <= (others => '0');

        elsif rising_edge(clk) then

            case STATE is
                --====================================================================================================================
                --=========== ожидание, определение больше 1 или нет
                --====================================================================================================================
                when IDLE =>
                    valid_o <= '0';

                    if (valid_i = '1') then
                        if (unsigned(data_i) = 0) then
                            zero <= '1';
                        else
                            zero <= '0';
                        end if;

                        rdy_o <= '0';

                        buf     <= 0;
                        cnt_exp <= 1;
                        shift   <= unsigned('0' & data_i);

                        exp_rdy <= '0';
                        exp_sh  <= (others => '0');
                        norm    <= (others => '0');

                        cnt_mant <= 0;
                        mant     <= (others => '0');

                        if (unsigned('0' & data_i) < STD_1) then -- в диапазоне (0,1)
                            order <= false;
                        else            -- в диапазоне [1,..)
                            order <= true;
                        end if;

                        STATE <= EXPONENT;
                    else
                        rdy_o <= '1';
                    end if;
                --====================================================================================================================
                --=========== вычисление целой части
                --====================================================================================================================
                when EXPONENT =>

                    if (cnt_exp = LEN_CNT_EXP - 1) then
                        cnt_exp <= 0;

                        STATE <= MANTISSA;
                    else
                        cnt_exp <= cnt_exp + 1;
                    end if;

                    buf <= cnt_exp;

                    if (order) then     -- больше 1 [1,..)
                        -- смещаем вправо (делим на 2) до тех пор, пока не будет меньше 2
                        shift <= shift_right(shift, 1); -- /2
                        if (shift <= STD_2 and exp_rdy = '0') then
                            exp_rdy <= '1';
                            exp_sh  <= resize(to_signed(buf, DW_OUT_INT), DW_OUT);

                            if (DW_IN_FRAC = DW_NORM_FRAC) then
                                norm <= unsigned(shift((DW_IN_FRAC + 2) - 1 downto 0));
                            else
                                norm(DW_NORM - 1 downto DW_NORM - (DW_IN_FRAC + 2)) <= unsigned(shift((DW_IN_FRAC + 2) - 1 downto 0));
                                norm(DW_NORM - (DW_IN_FRAC + 2) - 1 downto 0)       <= (others => '0');
                            end if;

                        end if;
                    else                -- меньше 1 (0, 1)
                    -- смещаем влево (умножаем на 2) до тех порт, пока не будет больше 1
                        shift <= shift_left(shift, 1); -- *2
                        if (shift >= STD_1 and exp_rdy = '0') then
                            exp_rdy <= '1';
                            exp_sh  <= resize(-to_signed(buf, DW_OUT_INT), DW_OUT);

                            if (DW_IN_FRAC = DW_NORM_FRAC) then
                                norm <= unsigned(shift((DW_IN_FRAC + 2) - 1 downto 0));
                            else
                                norm(DW_NORM - 1 downto DW_NORM - (DW_IN_FRAC + 2)) <= unsigned(shift((DW_IN_FRAC + 2) - 1 downto 0));
                                norm(DW_NORM - (DW_IN_FRAC + 2) - 1 downto 0)       <= (others => '0');
                            end if;

                        end if;
                    end if;
                --====================================================================================================================
                --=========== вычисление дробной части
                --====================================================================================================================
                when MANTISSA =>

                    if (cnt_mant = DW_OUT_FRAC) then
                        cnt_mant <= 0;

                        -- overflow
                        if (exp_rdy = '1') then
                            exp <= shift_left(exp_sh, DW_OUT_FRAC);
                        else
                            exp <= to_signed(integer(-(DW_IN_INT - 1) * 2 ** (DW_OUT_FRAC)), DW_OUT);
                        end if;
                        rdy_o <= '1';
                        STATE <= RESULT;
                    else
                        cnt_mant <= cnt_mant + 1;
                    end if;

                    if (norm >= STD2_NORM) then
                        mant(DW_OUT_FRAC - cnt_mant) <= '1';

                        shift2_v := shift_right(norm, 1);
                        mult2_v  := shift2_v * shift2_v;
                    else
                        mult2_v := norm * norm;
                    end if;
                    norm <= unsigned(mult2_v(DW_NORM - 1 + DW_NORM_FRAC downto DW_NORM_FRAC));

                --====================================================================================================================
                --=========== суммирование целой и дробной частей
                --====================================================================================================================
                when RESULT =>
                    valid_o <= '1';
                    if (zero = '1') then -- если вход нуль, то выдаем минимально возможное значение
                        data_o(DW_OUT - 1)          <= '1';
                        data_o(DW_OUT - 2 downto 0) <= (others => '0');
                    else
                        data_o <= std_logic_vector(exp + signed(mant));
                    end if;

                    exp_rdy <= '0';
                    exp_sh  <= (others => '0');

                    norm <= (others => '0');
                    mant <= (others => '0');

                    STATE <= IDLE;

            end case;

        end if;

    end process;

END rtl;

 library IEEE;
use IEEE.STD_LOGIC_1164.ALL;
USE IEEE.NUMERIC_STD.all;
use ieee.math_real.all;
use std.textio.all;
use std.env.all;

entity tb_log2Calc is
    generic(
        DW_IN       : natural := 12;
        DW_IN_FRAC  : natural := 10;
        DW_OUT_FRAC : natural := 10
    );
end entity;

architecture beh of tb_log2Calc is

    procedure clk_wait(
        signal   clk : in std_logic;
        constant th  : integer
    ) is
    begin
        for i in 0 to th - 1 loop
            wait until rising_edge(clk);
        end loop;
    end procedure clk_wait;

    -- переводит число типа real в std_logic_vector длины dw и точности dw_frac
    function real2std(data    : real;
                      dw      : integer;
                      dw_frac : integer;
                      sign    : boolean
                     ) return std_logic_vector is
    begin
        if (sign) then
            return std_logic_vector(to_signed(integer(data * real(2 ** dw_frac)), dw));
        else
            return std_logic_vector(to_unsigned(integer(data * real(2 ** dw_frac)), dw));
        end if;
    end;

    -- переводит число типа std_logic_vector длины dw и точности dw_frac в real
    function std2real(data    : std_logic_vector;
                      dw_frac : integer;
                      sign    : boolean
                     ) return real is
    begin
        if (sign) then
            return real(to_integer(signed(data))) / real(2 ** dw_frac);
        else
            return real(to_integer(unsigned(data))) / real(2 ** dw_frac);
        end if;
    end;

    --====================================================================================================================
    --=========== вычисление целой части y = log2(x)
    --====================================================================================================================
    constant DW_IN_INT : natural := DW_IN - DW_IN_FRAC; -- разрядность целой части входных даннных

    constant DW_OUT : natural := work.log2Calc_pkg.calc_dw(DW_IN, DW_IN_FRAC, DW_OUT_FRAC); -- разрядность выходных данных

    constant LATENCY : natural := work.log2Calc_pkg.calc_latency(DW_OUT, DW_OUT_FRAC); -- вычислительная задержка блока

    --====================================================================================================================
    --=========== сигналы
    --====================================================================================================================
    constant PERIOD : time      := 10 us;
    signal clk      : std_logic := '0';
    signal rst      : std_logic := '1';

    signal en : std_logic;
    --    signal cnt : integer range 0 to NUM_DATA - 1;

    signal y_in     : real                                  := 0.0;
    signal y_in_std : std_logic_vector(DW_OUT - 1 downto 0) := (others => '0');

    signal x_valid : std_logic                            := '0';
    signal x_std   : std_logic_vector(DW_IN - 1 downto 0) := (others => '0');
    constant ONES  : std_logic_vector(DW_IN - 1 downto 0) := (others => '1');
    signal x       : real                                 := 0.0;

    signal rdy_o       : std_logic;
    signal rdy_z       : std_logic;
    signal y_out_valid : std_logic;
    signal y_out_std   : std_logic_vector(DW_OUT - 1 downto 0);
    signal y_out       : real := 0.0;

    constant DW_ERR      : natural := 32;
    constant DW_ERR_FRAC : natural := 20;

    signal err_abs             : real                                  := 0.0;
    signal err_relative        : real                                  := 0.0;
    signal err_relative_dB     : real                                  := 0.0;
    signal err_abs_std         : std_logic_vector(DW_ERR - 1 downto 0) := (others => '0');
    signal err_relative_std    : std_logic_vector(DW_ERR - 1 downto 0) := (others => '0');
    signal err_relative_dB_std : std_logic_vector(DW_ERR - 1 downto 0) := (others => '0');

begin

    -- clk, rst
    proc_clk : process
    begin
        wait for PERIOD / 2;
        clk <= not clk;
    end process;

    proc_rst : process
    begin
        rst <= '1';
        wait for 15.2 * PERIOD;
        rst <= '0';
        wait;
    end process;

    --====================================================================================================================
    --=========== формирование данных на блок
    --====================================================================================================================
    input_proc : process(clk, rst)
    begin
        if (rst = '1') then
            en <= '1';

            x_valid <= '0';
            x_std   <= (others => '0');

        elsif rising_edge(clk) then

            rdy_z <= rdy_o;

            if (en = '1') then
                if (rdy_z = '0' and rdy_o = '1') then
                    if (x_std = ONES) then
                        en      <= '0';
                        x_valid <= '0';
                    else
                        x_std <= std_logic_vector(unsigned(x_std) + 1);

                        x_valid <= '1';
                    end if;
                else
                    x_valid <= '0';
                end if;
            end if;

            y_in <= log2(x);

        end if;
    end process;

    x        <= std2real(x_std, DW_IN_FRAC, false);
    y_in_std <= real2std(y_in, DW_OUT, DW_OUT_FRAC, false);

    --====================================================================================================================
    --=========== тестируемый блок
    --====================================================================================================================
    inst_log2 : entity work.log2Calc
        generic map(
            DW_IN       => DW_IN,
            DW_IN_FRAC  => DW_IN_FRAC,
            DW_OUT_FRAC => DW_OUT_FRAC,
            DW_OUT      => DW_OUT
        )
        port map(
            clk     => clk,
            rst     => rst,
            valid_i => x_valid,
            data_i  => x_std,
            rdy_o   => rdy_o,
            valid_o => y_out_valid,
            data_o  => y_out_std
        );

    --====================================================================================================================
    --=========== сравнение вычисленного с ожидаемым, вывод погрешности вычисления
    --====================================================================================================================
    y_out <= std2real(y_out_std, DW_OUT_FRAC, true);

    output_proc : process(clk, rst) is
        variable err_abs_v    : real;
        variable err_rel_v    : real;
        variable err_rel_dB_v : real;
    begin
        if (rst = '1') then

        elsif rising_edge(clk) then

            err_abs_v    := y_in - y_out;
            if (y_in = 0.0) then
                err_rel_v := 0.0;
            else
                err_rel_v := abs (err_abs_v / y_in);
            end if;
            err_rel_dB_v := 20.0 * log10(err_rel_v);

            if (y_out_valid = '1') then
                err_abs          <= err_abs_v;
                err_relative     <= err_rel_v;
                err_relative_dB  <= err_rel_dB_v;
                err_abs_std      <= real2std(err_abs_v, DW_ERR, DW_ERR_FRAC, true);
                err_relative_std <= real2std(err_rel_v, DW_ERR, DW_ERR_FRAC, true);
                if (err_rel_v = 0.0) then
                    err_relative_dB_std <= err_relative_dB_std;
                else
                    err_relative_dB_std <= real2std(err_rel_dB_v, DW_ERR, DW_ERR_FRAC, true);
                end if;
            end if;

        end if;
    end process output_proc;

    proc_check_end : process is
    begin
        wait until (x_std = ONES and en = '0');
        clk_wait(clk, 200);
        report "END SIM" severity note;
        finish(0);
    end process proc_check_end;

end architecture;