3.6.6 SmartHLS Migration Guide

#include <hls/ap_int.hpp>

using hls::ap_uint;

using hls::ap_int;

#include <hls/ap_fixpt.hpp>
using hls::ap_fixpt;
using hls::ap_ufixpt;
#define ap_fixed  ap_fixpt
#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.

• Remove the FIFO name argument from constructor call if it exists.
• Vitis/Vivado HLS’s stream has infinite depth in software simulation, that means stream's capacity will grow dynamically at simulation time. In SmartHLS, capacity of a FIFO has to be statically given for both hardware synthesis and simulation. Due to the nature of the simulation engine, capacity of a SmartHLS's FIFO may need to be much bigger in software simulation than what's actually needed in hardware implementation. Users can determine the FIFO's depth for simulation based on the application code and testbench.

Example of External FIFO Porting

Vitis/Vivado HLS

hls::stream<int> data;

SmartHLS

#define SIM_FIFO_DEPTH 1e4
hls::stream<int> data(SIM_FIFO_DEPTH);

Example of Internal FIFO porting

Vitis/Vivado HLS

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

SmartHLS

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

<AP_INT_VAR>.to_int64()

Vitis/Vivado HLS's ap_int has a rich list of C-type conversion functions (e.g. to_short(), to_int(), to_long()). Since SmartHLS currently only has to_uint64() and to_int64() available, users may need to add extra explicit casting to fit their needs.

(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.

Porting for a globally or locally declared variable

Vitis/Vivado HLS

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

SmartHLS

Move the pragma to right before the <VAR>variable declaration, and transform it to this form:

#pragma HLS memory partition variable(<VAR>) type(<TYPE>) dim(<DIM>)

For more information, see the Partition Memory pragma.

Porting for a top-level function argument

Vitis/Vivado HLS

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

SmartHLS

Move the pragma to the beginning of the function body, and transform it to this form:

#pragma HLS memory partition argument(<VAR>) type(<TYPE>) dim(<DIM>)

For more information, see the Partition Top-Level Interface pragma.

Porting complete memory partitioning in multiple but not all dimensions in an array

SmartHLS supports complete memory partitioning in either 1 or all dimensions, while Vitis/Vivado 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.

Vitis/Vivado HLS

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])

SmartHLS

#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.

Vitis/Vivado HLS

#pragma HLS inline

SmartHLS

#pragma HLS function inline

Vitis/Vivado HLS

#pragma HLS inline off

SmartHLS

#pragma HLS function noinline

See Pipeline Function and Pipeline Loop pragmas.

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