Dataflow circuit with bidirectional synchronization channels.

In the forward direction we assert validity of the data. In the backward direction we assert that the circuit is ready to receive new data. A circuit adhering to the DataFlow type should:

• Not consume data when validity is deasserted.
• Only update its output when readiness is asserted.

The DataFlow type is defined as:

newtype DataFlow' dom iEn oEn i o
  = DF
  { df :: Signal dom i     -- Incoming data
       -> Signal dom iEn   -- Flagged with valid bits iEn.
       -> Signal dom oEn   -- Incoming back-pressure, ready edge.
       -> ( Signal dom o   -- Outgoing data.
          , Signal dom oEn -- Flagged with valid bits oEn.
          , Signal dom iEn -- Outgoing back-pressure, ready edge.
          )
  }

where:

• dom is the domain to which the circuit is synchronized.
• iEn is the type of the bidirectional incoming synchronization channel.
• oEn is the type of the bidirectional outgoing synchronization channel.
• i is the incoming data type.
• o is the outgoing data type.

We define several composition operators for our DataFlow circuits:

• seqDF sequential composition.
• parDF parallel composition.
• loopDF add a feedback arc.
• lockStep proceed in lock-step.

When you look at the types of the above operators it becomes clear why we parametrize in the types of the synchronization channels.

Dataflow circuit synchronized to the systemClockGen. type DataFlow iEn oEn i o = DataFlow' systemClockGen iEn oEn i o

Create a DataFlow circuit from a circuit description with the appropriate type:

Signal dom i        -- Incoming data.
-> Signal dom Bool  -- Flagged with a single valid bit.
-> Signal dom Bool  -- Incoming back-pressure, ready bit.
-> ( Signal dom o   -- Outgoing data.
   , Signal dom oEn -- Flagged with a single valid bit.
   , Signal dom iEn -- Outgoing back-pressure, ready bit.
   )

A circuit adhering to the DataFlow type should:

• Not consume data when validity is deasserted.
• Only update its output when readiness is asserted.

Create a DataFlow circuit where the given function f operates on the data, and the synchronization channels are passed unaltered.

Create a DataFlow circuit from a Mealy machine description as those of Clash.Prelude.Mealy

Create a DataFlow circuit from a Moore machine description as those of Clash.Prelude.Moore

Create a FIFO buffer adhering to the DataFlow protocol. Can be filled with initial content.

To create a FIFO of size 4, with two initial values 2 and 3 you would write:

fifo4 = fifoDF d4 (2 :> 3 :> Nil)

Identity circuit

Sequential composition of two DataFlow circuits.

Apply the circuit to the first halve of the communication channels, leave the second halve unchanged.

Swap the two communication channels.

Apply the circuit to the second halve of the communication channels, leave the first halve unchanged.

Compose two DataFlow circuits in parallel.

Compose n DataFlow circuits in parallel.

Feed back the second halve of the communication channel. The feedback loop is buffered by a fifoDF circuit.

So given a circuit h with two synchronization channels:

h :: DataFlow (Bool,Bool) (Bool,Bool) (a,d) (b,d)

Feeding back the d part (including its synchronization channels) results in:

loopDF d4 Nil h

When you have a circuit h', with only a single synchronization channel:

h' :: DataFlow Bool Bool (a,d) (b,d)

and you want to compose h' in a feedback loop, the following will not work:

f `seqDF` (loopDF d4 Nil h') `seqDF` g

The circuits f, h, and g, must operate in lock-step because the h' circuit only has a single synchronization channel. Consequently, there should only be progress when all three circuits are producing valid data and all three circuits are ready to receive new data. We need to compose h' with the lockStep and stepLock functions to achieve the lock-step operation.

f `seqDF` (lockStep `seqDF` loopDF d4 Nil h' `seqDF` stepLock) `seqDF` g

Feed back the second halve of the communication channel. Unlike loopDF, the feedback loop is not buffered.

Reduce or extend the synchronization granularity of parallel compositions.