pragma HLS bind_op - 2023.2 English

Description

Vitis HLS implements the operations in the code using specific implementations. The BIND_OP pragma specifies that for a specific variable, an operation (mul, add, div) should be mapped to a specific device resource for implementation (impl) in the RTL. If the BIND_OP pragma is not specified, Vitis HLS automatically determines the resources to use for operations.

For example, to indicate that a specific multiplier operation (mul) is implemented in the device fabric rather than a DSP, you can use the BIND_OP pragma.

You can also specify the latency of the operation using the latency option.

Syntax

Place the pragma in the C source within the body of the function where the variable is defined.

#pragma HLS bind_op variable=<variable> op=<type>\
impl=<value> latency=<int>

Where:

variable=<variable>

Defines the variable to assign the BIND_OP pragma to. The variable in this case is one that is assigned the result of the operation that is the target of this pragma.

op=<type>

Defines the operation to bind to a specific implementation resource. Supported functional operations include: mul, add, and sub

Supported floating point operations include: fadd, fsub, fdiv, fexp, flog, fmul, frsqrt, frecip, fsqrt, dadd, dsub, ddiv, dexp, dlog, dmul, drsqrt, drecip, dsqrt, hadd, hsub, hdiv, hmul, and hsqrt

Tip: Floating point operations include single precision (f), double-precision (d), and half-precision (h).

impl=<value>

Defines the implementation to use for the specified operation.

Supported implementations for functional operations include fabric, and dsp.

Supported implementations for floating point operations include: fabric, meddsp, fulldsp, maxdsp, and primitivedsp.

Note: primitivedsp is only available on AMD Versal™ devices.

latency=<int>

Defines the default latency for the implementation of the operation. The valid latency varies according to the specified op and impl. The default is -1, which lets Vitis HLS choose the latency.

The tables below reflect the supported combinations of operation, implementation, and latency.

Example

In the following example, a two-stage pipelined multiplier using fabric logic is specified to implement the multiplication for variable c of the function foo.

int foo (int a, int b) {
int c, d;
#pragma HLS BIND_OP variable=c op=mul impl=fabric latency=2
c = a*b;
d = a*c;
return d;
}

See Also

• set_directive_bind_op
• pragma_HLS_bind_storage