3.6.6 SmartHLS Migration Guide

#include <hls/ap_int.hpp>

Depending on the type(s) used, add using hls::ap_uint;, and/or using hls::ap_int;

#include <hls/ap_fixpt.hpp>

Depending on the type(s) used, add using hls::ap_fixpt; #define ap_fixed ap_fixpt , and/or using hls::ap_ufixpt; #define ap_ufixed ap_ufixpt

#include <hls/streaming.hpp>

#define stream FIFO

Vitis/Vivado HLS’s stream constructor optionally takes a string name as argument, while SmartHLS’s FIFO constructor optionally takes depth and type.VHLS’s stream assumes infinite size in C simulation, so set equivalent SmartHLS FIFOs’ depths very deep for C simulation.Example of mapping an external FIFO:

VHLS: hls::stream<int> data;

SmartHLS: hls::stream<int> data(1e4);

Example of mapping an internal FIFO:

VHLS:

hls::stream<int> data;
#pragma HLS stream variable = data depth = 2

#ifndef __SYNTHESIS__
#define INTERNAL_STREAM_DEPTH  1e4
#else
#define INTERNAL_STREAM_DEPTH  2
#endif
hls::stream<int> data(INTERNAL_STREAM_DEPTH);

<AP_INT_VAR>.to_uint64(), or <AP_INT_VAR>.to_int64()

VHLS’s ap_int has a list of C-type conversion functions (e.g. to_short(), to_int(), to_long()), while SmartHLS only has to_uint64()/to_int64() and expects users to add explicit casting to the return value.

(ap_uint<...><AP_INT_VAR>.range(7,0)).to_int64()

In SmartHLS, the return value of <AP_INT_VAR>.range() cannot be used to directly invoke to_int64()/to_uint64().

std::stringstream istr(line)
ap_fixpt<W, IW, Q_M, O_M> = args;
double args_temp;
istr >> args_temp;
args = args_temp;

#ifdef __SYNTHESIS__
#define NDEBUG
#endif
#include <assert.h>

A global constraint of operation resources can be set via set_resource_constraint; constraining the operation resource within a function, a loop or a block of code is not yet available.

Functions that are not inlined (automatically by SmartHLS tool or specified via the Inline Function pragma) always have a single RTL module instance in hardware, and it is shared by all callers. Replication of a function instance in hardware can be achieved by the Replicate Function and Inline Function pragmas. In the case of multi-threading, each thread of a function creates an instance of the corresponding RTL module.

See the Partition Top-Level Interface and Partition Memory pragmas.

If the variable is globally/locally declared variable, move the pragma to right before the variable declaration.

If the variable is a top-level function argument, add the pragma to the beginning of the function definition block.

Example:

VHLS: #pragma HLS array_partition variable=<VAR> <TYPE> dim=<DIM>

If <VAR> is a global/local declared variable, use #pragma HLS memory partition variable(<VAR>) type(<TYPE>) dim(<DIM>) + move it to right before the <VAR> variable declaration.

If <VAR> is a top-level function argument, use #pragma HLS memory partition argument(<VAR>) type(<TYPE>) dim(<DIM>) + add it add the beginning of the function definition block.

SmartHLS supports complete memory partitioning in either 1 or all dimensions, while Vitis HLS can apply complete memory partitioning in more than 1 discrete dimensions. To port such case, users may need to reshape the array. Below is an example.

VHLS:

ap_uint<12> buffer[DIM_X][DIM_Y][DIM_Z];
#pragma HLS_ARRAY_PARTITION variable=buffer complete dim=1
#pragma HLS_ARRAY_PARTITION variable=buffer complete dim=2
// Access macro of 'buffer'
#define BUFFER(x,y,z)  (buffer[x][y][z])

#pragma HLS memory partition variable(buffer) type(complete) dim(1)
ap_uint<12> buffer[DIM_X*DIM_Y][DIM_Z];
// Access macro of 'buffer'
#define BUFFER(x,y,z)  (buffer[(x)*DIM_Y+(y)][z])

If inside a loop, the pragma should be moved outside the loop.

See the Bound Loop pragma, and lift it out of the loop. Note that SmartHLS does not capture the average number of loop iterations.

Example:

VHLS: #pragma HLS loop_tripcount min=<MIN> max=<MAX> avg=<AVG>

SHLS: #pragma HLS loop bounds lower(<MIN>) upper(<MAX>) + lift outside the loop

See Pipeline Function and Pipeline Loop pragmas.

If inside a loop, the pragma should be lifted outside the loop.

If inside a function, add the pragma to the beginning of the function definition block.