Warum funktioniert dieses einfache VHDL-Muster für ein Schieberegister nicht wie erwartet?

Auf den ersten Blick würde man erwarten, dass sich der folgende VHDL-Quellcode wie ein Schieberegister verhält. In diesem q, im Laufe der Zeit wäre

"UUUU0", "UUU00", "UU000", "U0000", "00000", ....

aber stattdessen ist es immer Unach fünf (oder mehr) aufeinanderfolgenden Taktzyklen.

Warum ist das?

Dieser Code ist eigentlich eine viel vereinfachte Version einer viel komplizierteren Simulation. Aber es zeigt die Symptome, die ich sehe.

Es zeigt dieses interessante und unerwartete Ergebnis während der Simulation sowohl unter ModelSim als auch unter ActiveHDL, ich habe keine anderen Simulatoren ausprobiert und würde (neben einer Erklärung der Ursache) gerne wissen, ob andere genauso handeln.

Um diese Frage richtig beantworten zu können, müssen Sie Folgendes verstehen:

• Ich weiß, dass dies nicht der beste Weg ist, ein Schieberegister zu implementieren
• Ich weiß, für die RTL-Synthese sollte dies einen Reset haben.
• Ich weiß, dass ein Array von std_logic ein std_logic_vector ist.
• Ich kenne den Aggregationsoperator &.

Was ich auch gefunden habe:

• Wenn die Zuweisung temp(0)<='0';innerhalb des Prozesses verschoben wird, funktioniert es.
• Wenn die Schleife ausgepackt ist (siehe kommentierter Code), funktioniert es.

Ich möchte wiederholen, dass dies eine sehr vereinfachte Version eines viel komplizierteren Designs (für eine Pipeline-CPU) ist, das so konfiguriert ist, dass es nur die unerwarteten Simulationsergebnisse zeigt. Die eigentlichen Signaltypen sind nur eine Vereinfachung. Aus diesem Grund müssen Sie Ihre Antworten mit dem Code in der Form so betrachten, wie sie sind.

Meine Vermutung ist, dass der Optimierer der VHDL-Simulations-Engine fälschlicherweise (oder vielleicht gemäß der Spezifikation) nicht die Mühe macht, die Ausdrücke innerhalb der Schleife auszuführen, da sich keine Signale außerhalb ändern, obwohl ich dies widerlegen kann, indem ich die ausgepackte Schleife in eine Schleife platziere.

Ich gehe also davon aus, dass die Antwort auf diese Frage eher mit den Standards für die VHDL-Simulation der nicht expliziten VHDL-Syntax und der Art und Weise, wie VHDL-Simulations-Engines ihre Optimierungen durchführen, zu tun hat, als ob das angegebene Codebeispiel der beste Weg ist, etwas zu tun oder nicht.

Und nun zu dem Code, den ich simuliere:

 library ieee;
 use ieee.std_logic_1164.all;   

 entity test_simple is
    port (
        clk : in  std_logic;
        q   : out std_logic
    );                   
 end entity;

 architecture example of test_simple is
    type   t_temp is array(4 downto 0) of std_logic;
    signal temp : t_temp;
 begin

    temp(0) <= '0';

    p : process (clk)
    begin               
        if rising_edge(clk) then
            for i in 1 to 4 loop
                    temp(i) <= temp(i - 1);
            end loop;

            --temp(1) <= temp(0);   
            --temp(2) <= temp(1);
            --temp(3) <= temp(2);
            --temp(4) <= temp(3);
        end if;
    end process p;
    q <= temp(4);
 end architecture;

Und der Prüfstand:

library ieee;
use ieee.std_logic_1164.all;

entity Bench is
end entity;

architecture tb of bench is

component test_simple is
    port (
        clk : in  std_logic;
        q   : out std_logic
    );                   
end component;

signal clk:std_logic:='0';
signal q:std_logic;     
signal rst:std_logic;

constant freq:real:=100.0e3;

begin                       
    clk<=not clk after 0.5 sec / freq;

    TB:process
    begin
        rst<='1';
        wait for 10 us;
        rst<='0';
        wait for 100 us;
        wait;
    end process;

     --Note: rst is not connected
    UUT:test_simple  port map (clk=>clk,q=>q) ;
end architecture;