[RFC] Non blocking if

[lekcyjna123]

I create this issue, to allow for brainstorm how to implement non blocking if in transactron. Lets take:

with Transaction().body(m):
   with m.If(m, cond):
      method(m)

In current implementation we always block method if transaction is called regardless of cond. We would like to not block method is cond is false.

The easy implementation idea is to calculate runnable signal for each pair of (transaction, method) using:

runnable = enable.implies(ready)

Where enable is signal pointing if transaction want to run method and ready say us if method is ready.

Above idea works as long as:

• cond is independent from method output or
• method from which it is a result is independent from scheduling result/input data

Lets say:

with Transaction().body(m):
   cond=method1(m, in_data1)
   with m.If(m, cond):
      method2(m)

Now we can consider two cases:

• if in_data1 influence cond then cond depends from scheduling result (as long as it is not single-caller method), so there is a combinational cycle, because scheduling result (so cond) influence scheduling of method2.
• if in_data1 is the same regardless of input there is no problem

---

To summarise. We have to decide how to handle if-s which depends from methods whose output depends on input. Some propositions:

• disallow non blocking if-s in situations where condition depends from scheduler. This solution is somehow similar to old handling of readiness of methods. We allowed ready signal to depends on input data only if method was single-caller
• Maybe we can start scheduling from methods whose output influence scheduling? In other words do scheduling in steps. Does this introduce possibility of deadlocks? Can we reuse schedule_before for that?

All other propositions are welcome.

[lekcyjna123]

If we had quasi-register, which store high till the end of the cycle, we could implement iterable algorithm in one cycle, but this will make critical path very long...

module circuit(input in1, clk, output out1);
  assign out1 = (in1 | out1) & clk;
endmodule

[lekcyjna123]

We can split above problem into two:

• don't block transaction if method not needed is not ready
• don't block transaction if method not needed is called by other transaction

[tilk]

If we had quasi-register, which store high till the end of the cycle, we could implement iterable algorithm in one cycle, but this will make critical path very long...

Please, no crazy clock manipulation. Pure synchronous logic only.

[lekcyjna123]

After our Monday talk with @piotro888 I decided to make a short verification in how many places we have method call under m.If which depends on other method output:

• "If" depends on synchronous registers: 6
• "If" depends on method results which result is independent from scheduler and input data (e.g. Fifo output): 5
• "If" depends on method result: 4
• So complicated that it is hard to say: 2

This results are based on simple grep for "m.If" on the whole coreblocks directory and checking if we have method calls under this "m.If" (or its "m.Else" branch). Results are promising in my opinion. In 11 places we have possibility to optimise blocking of methods, while only 6 places can not be optimised.

[tilk]

Did you check if there is even any benefit of trying to optimize them in this way? If some method is called in only one place, there is absolutely no harm in blocking it.