0

I am writing a Verilog code for synthesis of an algorithm, I am a little confused on what cases might cause latches to be inferred. Below is one such section of the code, though it works fine in simulation, I am worried it might cause problems on hardware. 

always@(b1 or b2)

.....
// b1_map,b2_map,m1_map & m2_map are derived from combinational functions using b1 & b2
.....

if(b1_map<=20 && m2_map<=20 && b1_map>=0 && m2_map>=0)



begin
accumulator1[b1_map][m2_map]= accumulator1[b1_map][m2_map] + 1;
end

if(b2_map<=20 && m2_map<=20 && b2_map>=0 && m2_map>=0)

begin
accumulator2[b2_map][m2_map]= accumulator2[b2_map][m2_map] + 1;
end

//accumulator1  & accumulator2 are 2d registers mapped like 2d arrays

So, In this case I want the data to be mapped only if it is in the specified limits. Will a latch be inferred because there is no "else" scenario defined? I didn't add an else statement because there is nothing I want to do with that data if it's not in the limits.

Improve this question
4
  • How will that help me? I would like this block to run only when the "b1" & "b2" data is present which happens only later in the program. Commented Nov 17, 2013 at 21:35
  • 1
    Your code looks like it will be generating lots of latches and it may cause issues with timing closure, among other things. It looks like you're performing basically a memory read and write to the same location. This is far better suited for implementation in a synchronous always @(posedge clk) block. Is there a very compelling reason this has to be asynchronous? Commented Nov 17, 2013 at 22:26
  • The data "b1" & "b2" used to map values onto the memory registers is not always available(available once in every 500~600ps). So, I thought it would be better if I used it in a separate "always(b1 or b2)" block. Commented Nov 17, 2013 at 22:31
  • 1
    You seem to have a fundamental misunderstanding. Synthesis creates hardware. You don't "run" hardware, it is always there doing something. It doesn't make sense to say that a signal is "not always available" because signals always exist in hardware and have some value. You need to tell the synthesizer what you want the hardware to do under all possible conditions or it will make (probably incorrect) assumptions. Commented Nov 18, 2013 at 13:03

3 Answers 3

Reset to default
3

If you write your if statements correctly, you will be fine. Latches are generated when there are paths through the if statement that do not update one or more of the outputs. Code like the following will generate a latch:

always @* begin
    if (a) begin
        b <= c & d;
        e <= f;
    end else begin
        b <= c | d;
    end
end

Notice that e is assigned only when a is true? This requires a latch to implement correctly.

Another posibility that will generate a latch is when the sensitivity list does not contain a signal used in the code. 

always @(a) begin
    if (a) begin
        b <= c & d;
    end else begin
        b <= c | d;
    end
end

This code will generate latches on c and d or on b because it will only allow b to be updated when a changes.

Improve this answer
Sign up to request clarification or add additional context in comments.

6 Comments

I understood that, But do you think there is problem with my code as well ? The simulation works perfect in Modelsim, but Quartus 2 gives me latch inferred warnings for accumulator 1 & accumulator2.
accumulator1 and accumulator2 are not in the sensitivity list, so it will generate latches. However, since you are assigning accumulator1 back to accumulator1, you cannot include it in the sensitivity list. So you're either going to have to live with the latches or write your code so that you aren't assigning a signal back to itself in an asynchronous block.
Is it okay to live with latches?
You generally want to avoid them unless there is no other good option. Generally asynchronous designs do not perform well on FPGAs. Is there a compelling reason that your design needs to be asynchronous? If not, then you should rewrite it so that your design is synchronous. This will generally let you run your design with a much faster clock.
I don't see a reason on why I have to keep it asynchronous, I found this an easier way. Will probably try rewriting the code to avoid this then. Latches would be avoided, if I can get this part to function correctly inside an always@(posedge clk) block, right?
|
1

Inferred latches can come from an incomplete sensitivity list or incomplete assignments.

Sensitivity lists for combinatorial blocks should generally be written with always @*. This avoid coding bugs when updating code. Combinatorial blocks (those not including an edge sensitivity) are once synthesised will perform in the manner of always @*. Specifically naming signals adds more work and will likely lead to RTL to gate level (post synthesis) errors.

Incomplete assignments which imply the value has to be held will infer a latch. Latches are not inherently bad but require careful consideration. Inferred one in this manner removes the thought fullness and control you would otherwise have over it. This can lead to complex timing issues. As the latch is level sensitive rather than edge sensitive. Ideally you want the latch to be open for the first have of the clock cycle so that it is closed when the data will be read from it. Inferred latches remove this control.

Completing if statements with an else, of default for case castanets which sets a sensible value (0's) can help avoid these accidental latches.

Improve this answer

2 Comments

Is it okay to use always@(*) in a block that contains both combinatorial and sequential?
@user2045143 no, always @* means combinatorial, always @(posedge clk) is sequential. These determine when the block is triggered for execution, when ever a signal changes (* for wildcard any signal) or on the edge of a clock.
1

You've misunderstood your problem (and you shouldn't have accepted an answer) - the issue isn't fundamentally related to 'latches'. Your code doesn't make sense (for synthesis). Quartus knows this, and it's basically telling you to rewrite your code.

You've got a combinatorial block that increments a number (immediately) when a signal changes. Two problems: (1) this is certainly not what you want in real hardware, and (2) the number must remain the same, and not increment, when b1 and b2 don't change. The second isue is the one Quartus is reporting - your circuit needs memory of some sort, which it's reporting as a 'latch'. It's not smart enough to report the first problem, which is the real issue.

Try to draw your circuit as a schematic with real hardware. What does 'any change on b1 or b2' actually mean? How are you going to maintain the value of the accumulators when b1 and b2 don't change? The circuit isn't impossible, but it's way beyond an SO question.

Make you circuit synchronous, triggering on a clock edge, with only a clock (and possibly a reset) in the sensitivity list, and keep the innards exactly the same. There's nothing wrong with your if statement, since you actually want the accumulator to remain unchanged if nothing interesting is happening on b1/b2.

Improve this answer

1 Comment

Thanks. I actually have made a lot of changes to my program now and Quartus no longer warns me about any latches. Looking at my question now, I understand I had got some fundamentals mixed up. I have learnt since then and was able to incorporate the above block within my synchronous block.

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.

Start asking to get answers

Find the answer to your question by asking.

Ask question

Explore related questions

See similar questions with these tags.