Like bimap, but over the metadata of a PacketStream.

Like bimapMeta but can reason over signals, this circuit combinator is akin to <*>.

Always acknowledges incoming data.

Like either, but over the metadata of a PacketStream.

Like eitherMeta but can reason over signals, this circuit combinator is akin to <*>.

Never produces a value.

Copy data of a single PacketStream to multiple. LHS will only receive an acknowledgement when all RHS receivers have acknowledged data.

Like filter, but over the metadata of a PacketStream.

Like filterMeta but can reason over signals, this circuit combinator is akin to <*>.

Like first, but over the metadata of a PacketStream.

Like firstMeta but can reason over signals, this circuit combinator is akin to <*>.

Force a nack on the backward channel and Nothing on the forward channel if reset is asserted.

Like fst, but over the metadata of a PacketStream.

Like map, but over the metadata of a PacketStream.

Like mapMeta but can reason over signals, this circuit combinator is akin to <*>.

Undefined PacketStream null byte. Will throw an error if evaluated. The source of the error should be supplied for a more informative error message; otherwise it is unclear which component threw the error.

A pipeline skid buffer: places registers on both the backward and forward part of a circuit. This completely breaks up the combinatorial path between the left and right side of this component. In order to achieve this, it has to buffer Fwd twice.

Another benefit of this component is that the circuit on the left hand side may now use Bwd in order to compute its Fwd, because this cannot introduce combinatorial loops anymore.

Runs at full throughput, but causes 2 clock cycles of latency.

Place a register on the backward part of a circuit. This adds combinational delay on the forward path.

Place a register on the forward part of a circuit. This adds combinational delay on the backward path.

Like second, but over the metadata of a PacketStream.

Like secondMeta but can reason over signals, this circuit combinator is akin to <*>.

Like snd, but over the metadata of a PacketStream.

Strips trailing zero-byte transfers from packets in the stream. That is, if a packet consists of more than one transfer and _last of the last transfer in that packet is Just 0, the last transfer of that packet will be dropped and _last of the transfer before that will be set to maxBound. If such a trailing zero-byte transfer had _abort asserted, it will be preserved.

Has one clock cycle latency, but runs at full throughput.

Converts a PacketStream into a CSignal: always acknowledges.

When a packet is aborted, this circuit will truncate the current packet by setting the _last field of the transaction to Just 0 and the _abort field to True. All subsequent transactions will be consumed without being forwarded.

Sets _abort upon receiving backpressure from the subordinate.

UNSAFE: because fwdOut depends on bwdIn, this may introduce combinatorial loops. You need to make sure that a sequential element is inserted along this path. It is possible to use one of the skid buffers to ensure this. For example:

>>> safeAbortOnBackpressureC1 = unsafeAbortOnBackpressureC |> registerFwd
>>> safeAbortOnBackpressureC2 = unsafeAbortOnBackpressureC |> registerBwd

Note that registerFwd utilizes less resources than registerBwd.

Drop all backpressure signals.

Circuit to convert a CSignal into a PacketStream. This is unsafe, because it ignores all incoming backpressure.

Never acknowledges incoming data.

Sets data bytes that are not enabled in a PacketStream to 0x00.

Simple valid-ready streaming protocol for transferring packets between components.

Invariants:

1. A manager must not check the Bwd channel when it is sending Nothing over the Fwd channel.
2. A manager must keep sending the same data until the subordinate has acknowledged it, i.e. upon observing _ready as True.
3. A manager must keep the metadata (_meta) of an entire packet it sends constant.
4. A subordinate which receives a transfer with _abort asserted must either forward this _abort or drop the packet.
5. A packet may not be interrupted by another packet.

This protocol allows the last transfer of a packet to have zero valid bytes in _data, so it also allows 0-byte packets. Note that concrete implementations of the protocol are free to disallow 0-byte packets or packets with a trailing zero-byte transfer for whatever reason.

The value of data bytes which are not enabled is undefined.

Data sent from manager to subordinate.

Heavily inspired by the M2S data of AMBA AXI4-Stream, but simplified:

• _tdata is moved into _data, which serves the exact same purpose: the actual data of the transfer.
• _tkeep is changed to _last.
• _tstrb is removed as there are no position bytes.
• _tid is removed, because packets may not be interrupted by other packets.
• _tdest is moved into _meta.
• _tuser is moved into _meta.
• _tvalid is modeled by wrapping this type into a Maybe.

Data sent from the subordinate to manager.

The only information transmitted is whether the subordinate is ready to receive data.

FIFO circuit optimized for the PacketStream protocol. Contains two FIFOs, one for packet data (_data, _last) and one for packet metadata (_meta). Because metadata is constant per packet, the metadata FIFO can be significantly shallower, saving resources.

Moreover, the output of the FIFO has some other properties:

• All packets which contain a transfer with _abort set are dropped.
• All packets that are bigger than or equal to 2^contentDepth - 1 transfers are dropped.
• There are no gaps in output packets, i.e. Nothing in between valid transfers of a packet.

The circuit is able to satisfy these properties because it first loads an entire packet before it may transmit it. That is also why packets bigger than the content FIFO need to be dropped.

Two modes can be selected:

• Backpressure: assert backpressure like normal when the FIFO is full.
• Drop: never give backpressure, instead drop the current packet we are loading.

Specifies the behaviour of packetFifoC when it is full.

Asynchronous FIFO circuit that can be used to safely cross clock domains. Uses asyncFIFOSynchronizer internally.

Converts packet streams of a data width which is a multiple of n, i.e. dwOut * n, to packet streams of a smaller (or equal) data width dwOut, where n > 0. When n ~ 1, this component is just the identity circuit, idC.

If _abort is asserted on an input transfer, it will be asserted on all corresponding output sub-transfers as well. All zero-byte transfers are preserved.

Has one clock cycle of latency, all M2S outputs are registered. Throughput is optimal, a transfer of k valid bytes is transmitted in k clock cycles. To be precise, throughput is at least (1 / n)%, so at least 50% if n = 2 for example. We specify at least, because the throughput may be on the last transfer of a packet, when not all bytes have to be valid. If there is only one valid byte in the last transfer, then the throughput will always be 100% for that particular transfer.

Unsafe version of upConverterC.

Because upConverterC runs at full throughput, i.e. it only asserts backpressure if the subordinate asserts backpressure, we supply this variant which drops all backpressure signals. This can be used when the source circuit does not support backpressure. Using this variant in that case will improve timing and probably reduce resource usage.

Converts packet streams of arbitrary data width dwIn to packet streams of a bigger (or equal) data width dwIn * n, where n > 0. When n ~ 1, this component is just the identity circuit, idC.

If _abort is asserted on any of the input sub-transfers, it will be asserted on the corresponding output transfer as well. All zero-byte transfers are preserved.

Has one cycle of latency, all M2S outputs are registered. Provides full throughput.

Reads bytes at the start of each packet into a header structure, and transforms this header structure along with the input metadata to an output structure a, which is transmitted over a Df channel. Such a structure is sent once per packet over the Df channel, but only if the packet was big enough (contained at least headerBytes valid data bytes) and did not contain any transfer with _abort set. The remainder of the packet (padding) is dropped.

If the packet is not padded, or if the packet is padded but the padding fits in the last transfer of the packet together with valid data bytes, this component will give one clock cycle of backpressure per packet (for efficiency reasons). Otherwise, it runs at full throughput.

Reads bytes at the start of each packet into _meta. If a packet contains less valid bytes than headerBytes + 1, it will silently drop that packet.

If dataWidth divides headerBytes, this component runs at full throughput. Otherwise, it gives backpressure for one clock cycle per packet larger than headerBytes + 1 valid bytes.

Starts a packet stream upon receiving some data over a Df channel. The bytes to be packetized and the output metadata are specified by the input functions.

Writes a portion of the metadata to the front of the packet stream, and shifts the stream accordingly. This portion is defined by the (metaIn -> header) input function. If this function is id, the entire metadata is put in front of the packet stream.

Removes padding from packets according to some expected packet length field in the metadata. If the actual length of a packet is smaller than expected, the packet is aborted.

Has one clock cycle of latency, because all M2S outputs are registered. Runs at full throughput.

NB: dataWidth must be smaller than 2^p. Because this should never occur in practice, this constraint is not enforced on the type-level.

Merges multiple packet streams into one, respecting packet boundaries.

Routes packets depending on their metadata, using given routing functions.

Data is sent to at most one sink, for which the dispatch function evaluates to True when applied to the input metadata. If none of the predicates hold, the input packet is dropped. If more than one of the predicates hold, the sink that occurs first in the vector is picked.

Sends out packets in the same clock cycle as they are received, this component has zero latency and runs at full throughput.

Routing function for packetDispatcherC that matches against values with an Eq instance. Useful to route according to a record field.