一个不小心导致的隐秘的组合逻辑环

YoungZ1

最近在写代码的时候发现一个很隐秘的组合逻辑环，一个不小心就会出现，应该是自己代码习惯的问题。代码见下方。刚好如下的两个模块fsm和fack形成了一个组合逻辑环“ack_i -> nstate -> req_o -> ack_i",用modelsim仿真一下代码会直接报错，用quartusII编译综合可以通过，但是会有警告表明产生了组合逻辑环。
仔细分析，产生这种情况的原因是，两个模块中都存在”input -> output 的组合逻辑“，如果这两个电路刚好匹配，就会形成组合逻辑环。但是如果是两个规模较大的模块，发现这种比较隐蔽的组合逻辑环感觉应该不是那么简单。


问题来了：是不是说每个模块里面最好将输入和输出用至少一级寄存器隔开比较安全？因为你不仔细分析不会知道其他人的代码是怎么写的，如果一旦产生了组合逻辑环，再次修改代码可能会导致比较复杂的改动（当然这里举例比较简单）。所以考虑安全性，最好采用这种方式。


请问，我的分析是不是正确的？上面讲的代码方式”每个模块里面最好将输入和输出用至少一级寄存器隔开比较安全“是不是应该采取？还是说”出现问题后再修改设计切断组合逻辑环“？谢谢！

代码如下："fsm.v":

   

        

            
1. `timescale 1ns/1ns
   
2. 
   
3. module fsm(
   
4.          input         clk
   
5.         ,input         rst_n
   
6.         ,output req_o
   
7.         ,input         ack_i
   
8.         ,output led_o
   
9. );
   
10.        
    
11.         localparam         F_IDLE         = 2'd0,
    
12.                                                         F_S0                =        2'd1,
    
13.                                                         F_S1                =        2'd2;
    
14.        
    
15.         reg        [1:0] cstate;
    
16.         reg        [1:0]        nstate;
    
17.        
    
18.         always @(posedge clk,negedge rst_n) begin
    
19.                 if(!rst_n)
    
20.                         cstate <= F_IDLE;
    
21.                 else
    
22.                         cstate <= nstate;
    
23.         end
    
24.        
    
25.         always @( * ) begin
    
26.                 case(cstate)
    
27.                         F_IDLE:
    
28.                                 nstate = F_S0;
    
29.                                
    
30.                         F_S0:
    
31.                                 if(ack_i)
    
32.                                         nstate = F_S1;
    
33.                                 else
    
34.                                         nstate = F_S0;
    
35.                        
    
36.                         F_S1:
    
37.                                 nstate = F_IDLE;
    
38.                        
    
39.                         default:
    
40.                                 nstate = F_IDLE;
    
41.                        
    
42.                 endcase
    
43.         end
    
44.        
    
45.         //assign req_o = (cstate == F_S0);  //ok;
    
46.         assign req_o = (cstate == F_S0) && (nstate == F_S0);  //error;
    
47.        
    
48.        
    
49.         assign led_o = (cstate == F_S1);
    
50.        
    
51.        
    
52. endmodule
    
53. 
            

   

    复制代码

"fack.v":

   

        

            
1. `timescale 1ns/1ns
   
2. 
   
3. module fack(
   
4.          input         req_i
   
5.         ,output ack_o
   
6. );
   
7. 
   
8.         assign ack_o = req_i;
   
9.        
   
10. endmodule
    
11. 
            

   

    复制代码

"top.v":

   

        

            
1. `timescale 1ns/1ns
   
2. 
   
3. module top(
   
4.          input         clk
   
5.         ,input         rst_n
   
6.         ,output led_o
   
7. );
   
8. 
   
9.         fsm                                fsm(
   
10.                  .clk                        (clk        )
    
11.                 ,.rst_n                (rst_n)
    
12.                 ,.req_o                (req        )
    
13.                 ,.ack_i                (ack        )
    
14.                 ,.led_o                (led_o)
    
15.         );
    
16.        
    
17.         fack                        fack(
    
18.                  .req_i                (req        )
    
19.                 ,.ack_o                (ack        )
    
20.         );
    
21.        
    
22. 
    
23. endmodule
    
24. 
            

   

    复制代码

YoungZ1

怎么没人遇到么，，，，，

liuguangxi

回复 2# YoungZ1


    根据需要来插入适当的寄存器，关键还是设计的时候要把电路结构考虑清楚。

YoungZ1

回复 3# liuguangxi


   嗯，谢谢了，设计时考虑好电路结构才是最重要的。

fishkking

模块划分和模块间接口定义，需要在写代码前完成的。一般在输入和输出各加打一拍，对时序收敛是有帮助的，因为有可能在另外的逻辑里，输出前已经做了很长的组合逻辑，你的逻辑你又有一些组合逻辑，可能会影响时序。当然，能不能加打拍，也要看设计，有些情况，两个模块间的交互要当前或下一周期完成。  总的来说，多个模块间的交互一定要先沟通设计好后，再写代码实现

yucaoxilin

好像一般规范要求是尽量做到每个模块组合逻辑入，时序逻辑出，目的是为了减小组合逻辑路径长度，也可以避免组合逻辑环路。

这种组合逻辑环路，一般的check工具都会报warning的，很容易检查出来

wsz561208

我公司的代码要求要求赋值规定如下：
always中只允许使用非堵塞性赋值<=，assign只有一种赋值符号=。
所以不允许在always里的使用组合逻辑。所有我也很少仿真像你发的那种例子。
你的状态机避免使用组合逻辑而使用时序逻辑，不能实现你的要求吗？我感觉这样好理解些

glsunxiaofeng

这个逻辑环的产生并不是你的代码风格引发的，而是你对你需要的功能并不清晰。
从你的代码来看fsm中的req_o就是ack_i同一条线，岂能ack_i作为因，req_o作为果呢。即便按照你正确的代码来运行，也不会有任何的波形出现的。
就好像你使用一根水管一头放在水桶里，然后你拿着另一头在外面绕了一下又放回了水桶里，会有水流出现吗？
理清楚你需要的时序关系再想如何写代码。

yaya126

Combinational loop can be easily found by lint tool such as lec, spyglass, etc.

wdzic_fbb

回复 9# yaya126


    nLint更好用