Algorithm &引用；在时间“时达到的迭代限制”；当我尝试模拟我的代码时

我试图用VHDL实现Booth算法，已经运行了一个“纸上测试”，代码显然可以运行，但是当我模拟它时，我没有得到想要的结果。。。然后，我替换代码进行A-Shift测试，但当我模拟代码时，我得到以下错误：

LIBRARY IEEE;
    USE IEEE.STD_LOGIC_1164.ALL;
    USE IEEE.STD_LOGIC_UNSIGNED.ALL;

ENTITY algor_booth IS
    PORT(oper1 :  IN STD_LOGIC_VECTOR(7 DOWNTO 0);
         oper2 :  IN STD_LOGIC_VECTOR(7 DOWNTO 0);
         sel :    IN STD_LOGIC;
         result : OUT STD_LOGIC_VECTOR(15 DOWNTO 0)
            );
END ENTITY;

ARCHITECTURE algor OF algor_booth IS
BEGIN
    PROCESS (sel)
        VARIABLE A, S, P: STD_LOGIC_VECTOR(16 DOWNTO 0);
        VARIABLE Ma2: STD_LOGIC_VECTOR(7 DOWNTO 0);
        --VARIABLE flag: STD_LOGIC;
    BEGIN

        IF sel = '0' THEN
            Ma2 := (NOT oper1) + 1;
            A   := oper1 & "00000000" & '0';
            S   := Ma2 & "00000000" & '0';
            P   := "00000000" & oper2 & '0';
        ELSE
            --flag := '0';
            FOR i IN 1 TO 8 LOOP
                IF P(1 DOWNTO 0) = "01" THEN
                    P := P + A;
                    --flag := '0';
                    --P(17) := flag;
                ELSIF P(1 DOWNTO 0) = "10" THEN
                    P := P + S;
                    --flag := '1';
                    --P(17) := flag;
                END IF;
                --P(17) := flag;
                P :=    P(16) & P(16 downto 1);
                --P(17) := flag;
            END LOOP;
            result <= P(16 DOWNTO 1);

        END IF;
    END PROCESS;
END algor;

错误（可抑制）：（vsim-3601）在180 ns时达到迭代限制5000

我只是替换这一行：

p:=STD_逻辑_向量（无符号（p）sra1）

对于这个：
p:=p（16）和p（16到1）

这是atm的代码：

LIBRARY IEEE;
    USE IEEE.STD_LOGIC_1164.ALL;
    USE IEEE.STD_LOGIC_UNSIGNED.ALL;

ENTITY algor_booth IS
    PORT(oper1 :  IN STD_LOGIC_VECTOR(7 DOWNTO 0);
         oper2 :  IN STD_LOGIC_VECTOR(7 DOWNTO 0);
         sel :    IN STD_LOGIC;
         result : OUT STD_LOGIC_VECTOR(15 DOWNTO 0)
            );
END ENTITY;

ARCHITECTURE algor OF algor_booth IS
BEGIN
    PROCESS (sel)
        VARIABLE A, S, P: STD_LOGIC_VECTOR(16 DOWNTO 0);
        VARIABLE Ma2: STD_LOGIC_VECTOR(7 DOWNTO 0);
        --VARIABLE flag: STD_LOGIC;
    BEGIN

        IF sel = '0' THEN
            Ma2 := (NOT oper1) + 1;
            A   := oper1 & "00000000" & '0';
            S   := Ma2 & "00000000" & '0';
            P   := "00000000" & oper2 & '0';
        ELSE
            --flag := '0';
            FOR i IN 1 TO 8 LOOP
                IF P(1 DOWNTO 0) = "01" THEN
                    P := P + A;
                    --flag := '0';
                    --P(17) := flag;
                ELSIF P(1 DOWNTO 0) = "10" THEN
                    P := P + S;
                    --flag := '1';
                    --P(17) := flag;
                END IF;
                --P(17) := flag;
                P :=    P(16) & P(16 downto 1);
                --P(17) := flag;
            END LOOP;
            result <= P(16 DOWNTO 1);

        END IF;
    END PROCESS;
END algor;

IEEE库；
使用IEEE.STD_LOGIC_1164.ALL；
使用IEEE.STD_LOGIC_UNSIGNED.ALL；
实体Algoru booth是
端口（操作1：在标准逻辑向量中（7到0）；
操作2：在标准逻辑向量中（7到0）；
sel：标准逻辑中；
结果：输出标准逻辑向量（15到0）
);
终端实体；
algor_booth的架构algor是
开始
过程（sel）
变量A，S，P:STD_逻辑_向量（16到0）；
变量Ma2:STD_逻辑_向量（7到0）；
--变量标志：标准逻辑；
开始
如果sel='0'，则
Ma2:=（不可操作1）+1；
A:=oper1和“00000000”和“0”；
S:=Ma2&“00000000”和“0”；
P:=“00000000”&oper2和“0”；
其他的
--标志：='0'；
对于1到8循环中的i
如果P（1到0）=“01”，则
P:=P+A；
--标志：='0'；
--P（17）：=旗帜；
如果P（1到0）=“10”，则
P:=P+S；
--标志：='1'；
--P（17）：=旗帜；
如果结束；
--P（17）：=旗帜；
P:=P（16）和P（16向下至1）；
--P（17）：=旗帜；
端环；
结果经过多次尝试后，只需将这一行更改为：
p:=p（16）&p（16向下为1）

对于这个：
p（16向下到0）：=p（17向下到1）

问题解决了

这是固定代码：

LIBRARY IEEE;
    USE IEEE.STD_LOGIC_1164.ALL;
    USE IEEE.STD_LOGIC_UNSIGNED.ALL;

ENTITY algor_booth IS
    PORT(oper1 :  IN STD_LOGIC_VECTOR(7 DOWNTO 0);
         oper2 :  IN STD_LOGIC_VECTOR(7 DOWNTO 0);
         sel :    IN STD_LOGIC;
         result : OUT STD_LOGIC_VECTOR(15 DOWNTO 0)
            );
END ENTITY;

ARCHITECTURE algor OF algor_booth IS
BEGIN
    PROCESS (oper1, oper2)
        VARIABLE A, S, P: STD_LOGIC_VECTOR(17 DOWNTO 0);
        VARIABLE Ma2: STD_LOGIC_VECTOR(7 DOWNTO 0);
        VARIABLE flag: STD_LOGIC;
    BEGIN
            Ma2 := (NOT oper1) + 1;
            A   := '0' & oper1 & "00000000" & '0';
            S   := '0' & Ma2 & "00000000" & '0';
            P   := '0' & "00000000" & oper2 & '0';  
            flag := '0';

            FOR i IN 1 TO 8 LOOP
                IF (P(1) = '0' AND P(0) = '1') THEN
                    flag := '0';
                    P(17) := flag;
                          P := P + A;
                ELSIF (P(1) = '1' AND P(0) = '0') THEN
                    flag := '1';
                    P(17) := flag;
                          P := P + S;
                END IF;
                P(17) := flag;
                P(16 downto 0) := P(17 downto 1);
                P(17) := flag;
            END LOOP;
            result <= P(16 DOWNTO 1);
    END PROCESS;
END algor;

IEEE库；
使用IEEE.STD_LOGIC_1164.ALL；
使用IEEE.STD_LOGIC_UNSIGNED.ALL；
实体Algoru booth是
端口（操作1：在标准逻辑向量中（7到0）；
操作2：在标准逻辑向量中（7到0）；
sel：标准逻辑中；
结果：输出标准逻辑向量（15到0）
);
终端实体；
algor_booth的架构algor是
开始
过程（操作1、操作2）
变量A，S，P:STD_逻辑_向量（17到0）；
变量Ma2:STD_逻辑_向量（7到0）；
变量标志：标准逻辑；
开始
Ma2:=（不可操作1）+1；
A:='0'&oper1&'00000000'和'0'；
S:='0'和Ma2&'00000000'和'0'；
P:=“0”和“00000000”以及操作2和“0”；
标志：='0'；
对于1到8循环中的i
如果（P（1）='0'和P（0）='1'），则
标志：='0'；
P（17）：=旗帜；
P:=P+A；
ELSIF（P（1）='1'和P（0）='0'），则
标志：='1'；
P（17）：=旗帜；
P:=P+S；
如果结束；
P（17）：=旗帜；
P（16降到0）：=P（17降到1）；
P（17）：=旗帜；
端环；
结果找到并消除组合循环。循环有效，当我进行上述更改时，问题就开始了。我分析、阐述并模拟了您的代码，将其转换为使用包numeric_std而不是Synopsys的std_logic_unsigned。将迭代限制设置为5000并且没有错误。请提供一个（包括您的测试台）。未验证您的算法。此模块内没有可运行5000次迭代的循环，因此错误是与此模块外的代码交互的结果。请给出一个最小的、完整的、可验证的示例，正如用户1155120所建议的那样。查看两个版本的代码，这里没有任何解释问题或修复方法。查看Modelsim用户手册，我们发现这是一个零时间循环，意味着看不见的测试台和设计模型之间的交互，您已经对其进行了调整以消除问题。如果没有一个最小的、完整的、可验证的示例来演示问题和解决方案，该问题和答案对于其他Stackoverflow读者来说是没有用处的。