Dataflow Configuration - 2023.1 English

Synthesis: Dataflow Options

The syn.dataflow commands configure the dataflow analysis for the whole design. These settings specify the default memory channel and FIFO depth used by syn.directive.dataflow.

syn.dataflow.default_channel

By default a RAM memory configured in ping-pong fashion is used to buffer the data between functions or loops when dataflow pipelining is used. When streaming data is used (where the data is always read and written in consecutive order), a FIFO memory will be more efficient and can be selected as the default memory type.

The available channels are fifo and pingpong. The default is pingpong.

syn.dataflow.default_channel=fifo

Tip: Arrays must be set to streaming using the set_directive_stream command in order to perform FIFO accesses.

syn.dataflow.disable_fifo_sizing_opt

Disable FIFO sizing optimizations that increase resource usage; this can improve performance and reduce deadlocks.

syn.dataflow.disable_fifo_sizing_opt=1

syn.dataflow.fifo_depth

An integer value specifying the default depth of FIFOs. This option has no effect when pingpong memories are used. By default the FIFOs depth used in the channel will be set to the size of the largest producer or consumer (whichever is largest). In some cases this approach can be too conservative and result in FIFOs which are larger than needed. This option can be used to specify the depth when you know the FIFOs are larger than required.

syn.dataflow.fifo_depth=6

Important: Be careful when using this option as incorrect use can result in a design which fails to operate correctly

syn.dataflow.override_user_fifo_depth

Specify a depth for every hls::stream, overriding any user settings.

syn.dataflow.override_user_fifo_depth=12

This is useful for checking if a deadlock is due to insufficient FIFO depths in the design. By setting the override to a very large value (for example, the maximum depth printed by co-simulation at the end of simulation), if there is no deadlock, then you can use the FIFO depth profiling options of co-simulation and the GUI to find the minimum depth that ensures performance and avoids deadlocks.

syn.dataflow.scalar_fifo_depth

An integer value specifying the minimum depth of the scalar value propagation FIFOs as described in Specifying Compiler-Created FIFO Depth. These FIFOs are used to forward the value of scalar arguments of the dataflow regions to processes which have predecessors in the region itself. They do not affect functional correctness, but an insufficient automatically computed size can result in loss of performance and even deadlock.

syn.dataflow.scalar_fifo_depth=4

When this option is not specified, the minimum depth is the value of the syn.dataflow.fifo_depth option, or it is 2. As a rule of thumb, a good value is the average number of times the process forwarding the scalar value can start before the last process that reads it starts.

syn.dataflow.start_fifo_depth

An integer value specifying the minimum depth of the start propagation FIFOs as described in Specifying Compiler-Created FIFO Depth. These FIFOs are used to forward the ap_start handshake signal to processes which have predecessors in the region. They do not affect functional correctness, but an insufficient automatically computed size can result in loss of performance.

syn.dataflow.start_fifo_depth=5

When this option is not specified, the minimum depth is the value of the syn.dataflow.fifo_depth option, or it is 2. As a rule of thumb, a good value is the expected average number of times a process should be allowed to start in advance compared to its successors.

syn.dataflow.strict_mode

Set severity for dataflow canonical form messages. The available modes are: error, warning, off. The default is warning.

syn.dataflow.strict_mode=error

syn.dataflow.strict_stable_sync

Force synchronization of stable ports with ap_done. Refer to Stable Arrays for more information.

syn.dataflow.strict_stable_sync=1

syn.dataflow.task_level_fifo_depth

Default task-level FIFO depth (used for FIFOs automatically created to transfer scalars between processes). A FIFO is synchronized by ap_ctrl_chain. The write is the ap_done of the producer, the read is the ap_ready of the consumer. Like a PIPO in terms of synchronization, and like a FIFO in terms of access.

syn.dataflow.task_level_fifo_depth=7