带有always_comb结构的Systemverilog问题

Question

我对这个 SystemVerilog 代码有疑问。这是代码：

module mult ( multiplicand, multiplier, Product, clk, clear, Startm, endm );

input [31:0] multiplicand;
input [31:0] multiplier  ;
input clk;
input clear; 
input Startm;

output logic [63:0] Product;
output logic endm;


enum logic [1:0] { inicio, multiplicar, nao_multiplicar, fim } estados;
logic [1:0] state;

logic [31:0] mplier;
logic [31:0] mplier_aux;
logic [31:0] mcand ;
logic [31:0] mcand_aux;
logic [63:0] Prod  ;
logic [63:0] Prod_aux;
logic [5:0] cont;
logic [5:0] cont_aux;

initial begin
    mplier     = multiplier;
    mplier_aux = multiplier;
    mcand     = multiplicand;
    mcand_aux = multiplicand;
    Prod      = 0;
    Prod_aux  = 0;
    state     = inicio;
    cont      = 0;
    cont_aux  = 0; 
end

always_ff @( posedge clk )
begin
    if( clear ) 
    begin
        state <= inicio;
    end
    else if ( Startm )
    begin
        case( state )
        inicio :
        begin
                    if( mplier[0] == 0 )
                    begin
                        state <= nao_multiplicar;
                    end
                    else if( mplier[0] == 1 )
                    begin
                        state <= multiplicar;
                    end
        end
        multiplicar :
        begin
                    if( cont == 32 )
                        state <= fim;
                    else if( mplier[0] == 0 )
                    begin
                        state <= nao_multiplicar;
                    end
                    else if( mplier[0] == 1 )
                    begin
                        state <= multiplicar;
                    end
        end
        nao_multiplicar:
        begin
                    if( cont == 32 )
                        state <= fim;
                    else if( mplier[0] == 0 )
                    begin
                        state <= nao_multiplicar;
                    end
                    else if( mplier[0] == 1 )
                    begin
                        state <= multiplicar;
                    end
        end
        fim:
        begin
                    state <= inicio;
        end
        endcase
    end
end
    always_comb
    begin
        case(state)
        inicio:
        begin
                    mplier = multiplier;
                    mcand  = multiplicand;
                    Prod   = 0;
                    cont_aux = cont + 1;
                    cont = cont_aux;
        end
        multiplicar:
        begin   
                    mcand_aux  = mcand  << 1;
                    mcand      = mcand_aux  ;
                    mplier_aux = mplier >> 1;
                    mplier     = mplier_aux ;
                    Prod_aux   = Prod + mcand;
                    Prod       = Prod_aux;
                    cont_aux   = cont + 1;
                    cont       = cont_aux;
        end
        nao_multiplicar:
        begin
                    cont_aux = cont + 1;
                    cont     = cont_aux;
        end
        fim:
        begin
                    Product = Prod;
                    endm    = 1;
        end
        endcase
    end     
endmodule

我正在尝试使用 32 位输入和 64 位乘积编写一个乘法器 布斯算法。出现此错误：

always_comb 构造并不推断纯粹的组合逻辑

为什么会发生这种情况？

Answer 1

在 always 块中描述组合逻辑时，您必须确保所有变量都分配给代码中所有路径中的值。否则将推断出锁存器。在传统的 always 块中很容易错过类似的内容，因此 SystemVerilog 中引入了 always_comb 块来显式检查这一点。

在您的情况下，您有一些总线没有在 case 语句的每个分支中分配值，例如 mcand 没有在分支 nao_multiplicar 中为其分配值> 和fim。

有2种解决方案。首先是分配给所有代码分支中的所有变量。

另一种解决方案是在 case 语句之前的 always_comb 中为所有变量写入“默认”值。这样，每次 always_comb 块触发时，每个变量都会被分配一个值，并且不会出现警告。那么我们的 case 语句只需要处理需要改变的变量：

always_comb
begin
    // Defaults (I think I got them all)
    mplier     = multiplier;
    mcand      = multiplicand;
    Prod_aux   = 0;
    Prod       = 0;
    cont_aux   = 0;
    cont       = 0;
    Product    = 0;
    endm       = 0;

    // Now override the defaults when appropriate
    case(state)
    inicio:
    begin
                mplier = multiplier;
                mcand  = multiplicand;
                Prod   = 0;
                cont_aux = cont + 1;
                cont = cont_aux;
    end
    multiplicar:
    begin   
                mcand_aux  = mcand  << 1;
                mcand      = mcand_aux  ;
                mplier_aux = mplier >> 1;
                mplier     = mplier_aux ;
                Prod_aux   = Prod + mcand;
                Prod       = Prod_aux;
                cont_aux   = cont + 1;
                cont       = cont_aux;
    end
    nao_multiplicar:
    begin
                cont_aux = cont + 1;
                cont     = cont_aux;
    end
    fim:
    begin
                Product = Prod;
                endm    = 1;
    end
    endcase
end     

Answer 2

当我删除 initial 块时，所有编译错误都被消除。我正在使用 Cadence 和 Synopsys 的模拟器。

以下引用自 IEEE Std, 1800-2009，第 9.2.2.4 节“顺序逻辑always_ff 过程”：

always_ff 过程强加了
限制它包含一个和
只有一个事件控制，无阻塞
时序控制。上的变量
作业的左侧
一个always_ff过程，包括
a 的内容中的变量
称为函数，不应写成
通过任何其他进程。

always_comb 有一个类似的引用。

该文档可以从 IEEE 轻松获得。您的模拟器还应该有文档。

在这种情况下，您从工具收到的错误消息似乎没有多大帮助。

Answer 3

always_comb 将推断组合逻辑，但是，在你的always_comb 块中，你正在执行像 C 代码一样的分配，例如：

always_comb
begin
  ...
  cont_aux   = cont + 1;
  cont       = cont_aux;
  ...
end

在这里，你要求创建一个带有反馈的组合逻辑。

如果你想及时存储值，你必须将你的赋值放在一个always_ff块中，这将推断顺序逻辑。

always_ff @(posedge clk)
begin
  ...
  cont <= cont + 1;
  ...
end

Answer 4

LRM 是我用于系统 verilog 的最有用的文档

http://www.vhdl.org /sv/SystemVerilog_3.1a.pdf