set_directive_performance - 2024.1 English

Vitis High-Level Synthesis User Guide (UG1399)

Document ID
UG1399
Release Date
2024-05-30
Version
2024.1 English

Description

Tip: set_directive_performance applies to loops and loop nests, and requires a known loop tripcount to determine the performance. If your loop has a variable tripcount then you must also specify set_directive_loop_tripcount.

The set_directive_performance lets you specify a high-level constraint, target_ti or target_tl, defining the number of clock cycles between successive starts of a loop, and lets the tool infer lower-level UNROLL, PIPELINE, ARRAY_PARTITION, and INLINE directives needed to achieve the desired result. The set_directive_performance does not guarantee the specified value will be achieved, and so it is only a target.

The target_ti is the interval between successive starts of the loop, or between the start of the first iteration of the loop, and the next start of the first iteration of the loop. In the following code example, a target_ti=T would mean the target interval for the start of loop L2 between two consecutive iterations of L1 should be 100 cycles.

const int T = 100;
L1: for (int i=0; i<N; i++)
  L2: for (int j=0; j<M; j++){
pragma HLS performance target_ti=T
   ...
   }

The target_tl is the interval between start of the loop and end of the loop, or between the start of the first iteration of the loop and the completion of the last iteration of the loop. For example, in the preceding code example a target_tl=T means the target completion of loop L2 for a single iteration of L1 should be 100 cycles.

Note: set_directive_inline is applied automatically to functions inside any pipelined loop that has II=1 to improve throughput. If you apply the PERFORMANCE pragma or directive that infers a pipeline with II=1, it will also trigger the auto-inline optimization. You can disable this for specific functions by using set_directive_inline off.

The transaction interval is the initiation interval (II) of the loop times the number of iterations, or tripcount: target_ti = II * loop tripcount. Conversely, target_ti = FreqHz / Operations per second.

For example, assuming an image processing function that processes a single frame per invocation with a throughput goal of 60 fps, then the target throughput for the function is 60 invocations per second. If the clock frequency is 180 MHz, then target_ti is 180M/60, or 3 million clock cycles per function invocation.

Syntax

Specify the directive for a labeled loop.

set_directive_performance <location> [OPTIONS]

Where:

<location> specifies the loop in the format function/loop_label.

Options

-target_ti=<value>
Specifies a target transaction interval defined as the number of clock cycles for the loop to complete an iteration. The transaction interval refers to the time the loop starts processing a transaction and the time it begins processing the next transaction. The <value> can be specified as an integer, floating point, or constant expression that is resolved by the tool as an integer.
Note: A warning will be returned if truncation occurs.
-target_tl=<value>

Specifies a target latency defined as the number of clock cycles for the loop to complete all iterations. The transaction latency is defined as the interval between the start of the first iteration of the loop , and the completion of the last iteration of the loop. The <value> can be specified as an integer, floating point, or constant expression that is resolved by the tool as an integer.

unit=[sec | cycle]
Specifies the unit associated with the target_ti or target_tl values. The unit can either be specified as seconds, or clock cycles. When the unit is specified as seconds, a unit can be specified with the value to indicate nanoseconds (ns), picoseconds (ps), microseconds (us).

Example 1

The loop labeled loop_1 in the function func is specified to have target transaction interval of 4 clock cycles:

set_directive_performance func/loop_1 -target_ti=4