爲什麼不執行內部組件

-1

所以，我創建了VHDL中組件的分層設計。目前的頂級實體如下。爲什麼不執行內部組件

library ieee; 
use ieee.std_logic_1164.all; 
use ieee.numeric_std.all; 

--This component takes 2 numbers written in scientific notation and returns the same numbers with the same exponent 

entity exp_equalizer is 

    generic(
     TOTAL_BITS : natural := 23; 
     EXP_BITS : natural := 6 
    ); 

    port(
     man_1_in : in std_logic_vector(TOTAL_BITS - EXP_BITS - 2 downto 0); 
     exp_1_in : in std_logic_vector(EXP_BITS - 1 downto 0); 
     man_2_in : in std_logic_vector(TOTAL_BITS - EXP_BITS - 2 downto 0); 
     exp_2_in : in std_logic_vector(EXP_BITS - 1 downto 0); 
     man_1_out : out std_logic_vector((TOTAL_BITS - EXP_BITS - 1) * 2 - 1 downto 0); --extended precision 
     man_2_out : out std_logic_vector((TOTAL_BITS - EXP_BITS - 1) * 2 - 1 downto 0); 
     exp_out : out std_logic_vector(EXP_BITS - 1 downto 0); 
     difference : out unsigned(EXP_BITS - 1 downto 0) 
    ); 
end exp_equalizer; 

architecture exp_equalizer_arq of exp_equalizer is 

    signal exp_1   : std_logic_vector(EXP_BITS - 1 downto 0)    := (others => '0'); 
    signal exp_2   : std_logic_vector(EXP_BITS - 1 downto 0)    := (others => '0'); 
    signal man_1   : std_logic_vector(TOTAL_BITS - EXP_BITS - 2 downto 0) := (others => '0'); 
    signal man_2   : std_logic_vector(TOTAL_BITS - EXP_BITS - 2 downto 0) := (others => '0'); 
    signal comparer_greater : std_logic           := '0'; 
    signal comparer_smaller : std_logic           := '1'; 
    signal smaller_exp  : std_logic_vector(EXP_BITS - 1 downto 0)    := (others => '0'); 
    signal greater_exp  : std_logic_vector(EXP_BITS - 1 downto 0)    := (others => '0'); 
    signal smaller_man  : std_logic_vector(TOTAL_BITS - EXP_BITS - 2 downto 0) := (others => '1'); 
    signal greater_man  : std_logic_vector(TOTAL_BITS - EXP_BITS - 2 downto 0) := (others => '1'); 

    component comparer is 
     generic(
      BITS : natural := 16 
     ); 

     port(
      number1_in  : in std_logic_vector(BITS - 1 downto 0); 
      number2_in  : in std_logic_vector(BITS - 1 downto 0); 
      first_greater : out std_logic; 
      second_greater : out std_logic; 
      equals   : out std_logic 
     ); 

    end component; 

    component binary_multiplexer is 
     generic(
      BITS : natural := 16 
     ); 
     port(
      number1_in : in std_logic_vector(BITS - 1 downto 0); 
      number2_in : in std_logic_vector(BITS - 1 downto 0); 
      chooser : in std_logic; 
      mux_output : out std_logic_vector(BITS - 1 downto 0) 
     ); 
    end component; 

    for greater_exp_mux : binary_multiplexer use entity work.binary_multiplexer; 
    for smaller_exp_mux : binary_multiplexer use entity work.binary_multiplexer; 
    for greater_man_mux : binary_multiplexer use entity work.binary_multiplexer; 
    for smaller_man_mux : binary_multiplexer use entity work.binary_multiplexer; 
    for comparer_0 : comparer use entity work.comparer; 

begin 

    comparer_0 : comparer 
     generic map(BITS => EXP_BITS) 
     port map(
      first_greater => comparer_smaller, 
      second_greater => comparer_greater, 
      number1_in  => exp_1, 
      number2_in  => exp_2, 
      equals => open 
     ); 

    greater_exp_mux : binary_multiplexer 
     generic map(BITS => EXP_BITS) 
     port map(
      chooser => comparer_greater, 
      number1_in => exp_1, 
      number2_in => exp_2, 
      mux_output => greater_exp 
     ); 

    smaller_exp_mux : binary_multiplexer 
     generic map(BITS => EXP_BITS) 
     port map(
      chooser => comparer_smaller, 
      number1_in => exp_1, 
      number2_in => exp_2, 
      mux_output => smaller_exp 
     ); 

    greater_man_mux : binary_multiplexer 
     generic map(BITS => TOTAL_BITS - EXP_BITS - 1) 
     port map(
      chooser => comparer_greater, 
      number1_in => man_1, 
      number2_in => man_2, 
      mux_output => greater_man 
     ); 

    smaller_man_mux : binary_multiplexer 
     generic map(BITS => TOTAL_BITS - EXP_BITS - 1) 
     port map(
      chooser => comparer_smaller, 
      number1_in => man_1, 
      number2_in => man_2, 
      mux_output => smaller_man 
     ); 

    process(exp_1, exp_2, man_1, man_2, comparer_greater, comparer_smaller, smaller_exp, greater_exp, smaller_man, greater_man) is 
     variable shifting_difference : unsigned(EXP_BITS - 1 downto 0)        := (others => '0'); 
     variable extended_man_greater : std_logic_vector((TOTAL_BITS - EXP_BITS - 1) * 2 - 1 downto 0) := (others => '0'); 
     variable extended_man_smaller : std_logic_vector((TOTAL_BITS - EXP_BITS - 1) * 2 - 1 downto 0) := (others => '0'); 
    begin 
     exp_1 <= exp_1_in; 
     exp_2 <= exp_2_in; 
     extended_man_greater((TOTAL_BITS - EXP_BITS - 1) * 2 - 1 downto (TOTAL_BITS - EXP_BITS - 1)) := greater_man; 
     extended_man_smaller((TOTAL_BITS - EXP_BITS - 1) * 2 - 1 downto (TOTAL_BITS - EXP_BITS - 1)) := smaller_man; 
     shifting_difference := unsigned(greater_exp) - unsigned(smaller_exp); 
     man_1_out <= std_logic_vector(shift_right(unsigned(extended_man_smaller), to_integer(shifting_difference))); 
     man_2_out <= extended_man_greater; 
     exp_out <= greater_exp; 
    end process; 

end architecture;

，我使用這個測試平臺

library ieee; 
use ieee.std_logic_1164.all; 
use ieee.numeric_std.all; 

entity exp_equalizer_tb is 
end entity; 

architecture exp_equalizer_tb_arq of exp_equalizer_tb is 

    signal man_1_in : std_logic_vector(15 downto 0) := (others => '0'); 
    signal exp_1_in : std_logic_vector(5 downto 0) := (others => '0'); 
    signal man_2_in : std_logic_vector(15 downto 0) := (others => '0'); 
    signal exp_2_in : std_logic_vector(5 downto 0) := (others => '0'); 
    signal man_1_out : std_logic_vector(31 downto 0) := (others => '0'); 
    signal man_2_out : std_logic_vector(31 downto 0) := (others => '0'); 
    signal exp_out : std_logic_vector(5 downto 0) := (others => '0'); 
    signal difference : unsigned(5 downto 0) := "000000"; 

    component exp_equalizer is 
     generic(
      TOTAL_BITS : natural := 23; 
      EXP_BITS : natural := 6 
     ); 

     port(
      man_1_in : in std_logic_vector(TOTAL_BITS - EXP_BITS - 2 downto 0); 
      exp_1_in : in std_logic_vector(EXP_BITS - 1 downto 0); 
      man_2_in : in std_logic_vector(TOTAL_BITS - EXP_BITS - 2 downto 0); 
      exp_2_in : in std_logic_vector(EXP_BITS - 1 downto 0); 
      man_1_out : out std_logic_vector((TOTAL_BITS - EXP_BITS - 2) * 2 + 1 downto 0); --extended precision 
      man_2_out : out std_logic_vector((TOTAL_BITS - EXP_BITS - 2) * 2 + 1 downto 0); 
      exp_out : out std_logic_vector(EXP_BITS - 1 downto 0); 
      difference : out unsigned(EXP_BITS - 1 downto 0) 
     ); 
    end component; 
    for exp_equalizer_0 : exp_equalizer use entity work.exp_equalizer; 

begin 

    exp_equalizer_0 : exp_equalizer 
     generic map(TOTAL_BITS => 23, EXP_BITS => 6) 
     port map(
      exp_1_in => exp_1_in, 
      exp_2_in => exp_2_in, 
      man_1_in => man_1_in, 
      man_2_in => man_2_in, 
      exp_out => exp_out, 
      man_1_out => man_1_out, 
      man_2_out => man_2_out, 
      difference => difference 
     ); 

    process 
     type pattern_type is record 
      m1 : std_logic_vector(15 downto 0); 
      e1 : std_logic_vector(5 downto 0); 
      m2 : std_logic_vector(15 downto 0); 
      e2 : std_logic_vector(5 downto 0); 
      mo1 : std_logic_vector(31 downto 0); 
      mo2 : std_logic_vector(31 downto 0); 
      eo : std_logic_vector(5 downto 0); 
     end record; 
     -- The patterns to apply. 
     type pattern_array is array (natural range <>) of pattern_type; 
     constant patterns : pattern_array := (
      ("0000000000000001", "000000", "0000000000000001", "000000", "00000000000000010000000000000000", "00000000000000010000000000000000", "000000"), 
      ("0000000000000001", "111110", "0000000000000000", "111111", "00000000000000010000000000000000", "00000000000000000000000000000000", "111111") 
     ); 

    begin 
     for i in patterns'range loop 
      -- Set the inputs. 
      exp_1_in <= patterns(i).e1; 
      exp_2_in <= patterns(i).e2; 
      man_1_in <= patterns(i).m1; 
      man_2_in <= patterns(i).m2; 

      wait for 100 ms; 

      assert patterns(i).mo1 = man_1_out report "BAD MANTISSA 1, GOT: " & integer'image(to_integer(signed(man_1_out))); 
      assert patterns(i).mo2 = man_2_out report "BAD MANTISSA 2, GOT: " & integer'image(to_integer(signed(man_2_out))); 
      assert patterns(i).eo = exp_out report "BAD EXP, GOT: " & integer'image(to_integer(signed(exp_out))); 
      -- Check the outputs. 
     end loop; 
     assert false report "end of test" severity note; 
     wait; 
    end process; 
end;

但對於什麼，我能看到，內部部件（比較器和多路複用器）不被「執行」，結果端口是測試它從未改變。

所有組件的所有IN端口都作爲其進程的觸發器。

我一直在讀一點關於這個，發現組件不能在進程內部執行，所以也許，當我這樣做： exp_1 < = exp_1_in; exp_2 < = exp_2_in; 我實際上並沒有觸發組件。

但是，我看到一個與我在這裏嘗試的非常相似的例子。 https://www.altera.com/support/support-resources/design-examples/design-software/vhdl/v_hier.html

我不知道我的問題在哪裏。我已經測試過每個組件，它們都可以工作。

編輯：

我分析與ghdl每個文件-a 然後建立一個可執行文件從測試平臺與ghdl -e exp_equalizer_tb 最後，我運行可執行文件./ exp_equalizer

我做了一個腳本，對我的項目中的每個組件都做同樣的事情，並且我爲它們的測試平臺提供了斷言和報告，它們都可以工作精細。是在這個組件，我沒有得到預期的結果。

來源

2017-09-21 user3013172

執行什麼？你使用什麼程序進行了哪些步驟？ – JHBonarius

你的例子並不完整。如果沒有全部代碼，我們不能重現您的問題。 – JHBonarius

除了沒有[最小，完整和可驗證的示例]（https://stackoverflow.com/help/mcve）並且無法重現您的模糊問題，您可以注意到該過程在敏感性列表中有exp_1和exp_2，但是不評估它們，而評估exp_1_in和exp_2_in，但不在靈敏度列表中。您需要非常仔細地檢查敏感列表。 – user1155120

如果您的其他實體沒有至少某些源代碼，則無法再現您的特定問題。

我不使用GHDL，但我要去扔猜測在這裏，這個問題可能是這幾行：

for greater_exp_mux : binary_multiplexer use entity work.binary_multiplexer; 
for smaller_exp_mux : binary_multiplexer use entity work.binary_multiplexer; 
for greater_man_mux : binary_multiplexer use entity work.binary_multiplexer; 
for smaller_man_mux : binary_multiplexer use entity work.binary_multiplexer; 
for comparer_0 : comparer use entity work.comparer;

我以前看到很多問題與配置，尤其是與合成器。通常不是模擬器中的問題，但是誰知道。

另外，看起來在你的情況下，他們沒有任何目的，所以你應該讓IMO將它們排除在外。

來源

2017-09-21 14:36:40 DLnd

只要在binary_multiplexer和comparer的庫工作中找到兼容的實體聲明和體系結構，就可以對這些行進行註釋，但影響不大。參見IEEE Std 1076-2008 7.3.3默認綁定指示。註釋掉它們可以幫助我們在沒有它們的情況下搜索分析錯誤：7.3.2.2實體方面*在分析第一個表單的實體方面時，與實體名稱表示的實體聲明相對應的庫單元需要存在; ... * ghdl正確檢測到的錯誤。 – user1155120

爲什麼不執行內部組件

回答

相關問題