pragma HLS stream - 2021.1 English

Description

By default, array variables are implemented as RAM:

• Top-level function array parameters are implemented as a RAM interface port.
• General arrays are implemented as RAMs for read-write access.
• Arrays involved in sub-functions, or loop-based DATAFLOW optimizations are implemented as a RAM ping pong buffer channel.

If the data stored in the array is consumed or produced in a sequential manner, a more efficient communication mechanism is to use streaming data as specified by the STREAM pragma, where FIFOs are used instead of RAMs.

Syntax

Place the pragma in the C source within the boundaries of the required location.

#pragma HLS stream variable=<variable> type=<type> depth=<int>

Where:

variable=<variable>

Specifies the name of the array to implement as a streaming interface.

depth=<int>

Relevant only for array streaming in DATAFLOW channels. By default, the depth of the FIFO implemented in the RTL is the same size as the array specified in the C code. This option lets you modify the size of the FIFO to specify a different depth.

When the array is implemented in a DATAFLOW region, it is common to use the depth option to reduce the size of the FIFO. For example, in a DATAFLOW region when all loops and functions are processing data at a rate of II=1, there is no need for a large FIFO because data is produced and consumed in each clock cycle. In this case, the depth option can be used to reduce the FIFO size to 1 to substantially reduce the area of the RTL design.

Tip: The config_dataflow -depth command provides the ability to stream all arrays in a DATAFLOW region. The depth option specified in the STREAM pragma overrides the config_dataflow -depth setting for the specified <variable>.

type=<arg>

Specify a mechanism to select between FIFO, PIPO, synchronized shared (shared), and un-synchronized shared (unsync). The supported types include:

• fifo: A FIFO buffer with the specified depth.
• pipo: A regular Ping-Pong buffer, with depth but without a duplication of the array data. Consistency can be ensured by setting the depth small enough, which acts as the distance of synchronization between the producer and consumer.
• shared: Specifies that an array local variable or argument in a given scope is viewed as a single shared memory, distributing the available ports to the processes that access it.
• unsync: Does not have any synchronization except for individual memory reads and writes. Consistency (read-write and write-write order) must be ensured by the design itself.

Example 1

The following example specifies array A[10] to be streaming, and implemented as a FIFO.

#pragma HLS STREAM variable=A

Example 2

In this example, array B is set to streaming with a FIFO depth of 12.

#pragma HLS STREAM variable=B depth=12 type=fifo

Example 3

Array C has streaming implemented as a PIPO.

#pragma HLS STREAM variable=C type=pipo

See Also

• set_directive_stream
• pragma HLS dataflow
• pragma HLS interface
• config_dataflow