Vitis HLS does not require
that an array be specified with the static qualifier
to synthesize a memory or the const qualifier to
infer that the memory should be a ROM. Vitis HLS analyzes the design and attempts to create the most optimal hardware.
Important:
Xilinx highly
recommends using the
static qualifier for arrays that are intended
to be memories. As noted in Array Initialization, a
static type behaves in an almost identical manner as a memory
in RTL.The
const qualifier is also
recommended when arrays are only read, because Vitis HLS cannot always infer that a ROM should be used by
analysis of the design. The general rule for the automatic inference of a ROM is
that a local (non-global), static array is fully
written to before being read, and never written again. The following practices in
the code can help infer a ROM: - Initialize the array as early as possible in the function that uses it.
- Group writes together.
- Do not interleave
array(ROM)initialization writes with non-initialization code. - Do not store different values to the same array element (group all writes together in the code).
- Element value computation must not depend on any non-constant (at compile-time) design variables, other than the initialization loop counter variable.
If complex assignments are used to initialize a ROM (for example,
functions from the math.h library), placing the
array initialization into a separate function allows a ROM to be inferred. In the
following example, array sin_table[256] is inferred
as a memory and implemented as a ROM after RTL synthesis.
#include "array_ROM_math_init.h"
#include <math.h>
void init_sin_table(din1_t sin_table[256])
{
int i;
for (i = 0; i < 256; i++) {
dint_t real_val = sin(M_PI * (dint_t)(i - 128) / 256.0);
sin_table[i] = (din1_t)(32768.0 * real_val);
}
}
dout_t array_ROM_math_init(din1_t inval, din2_t idx)
{
short sin_table[256];
init_sin_table(sin_table);
return (int)inval * (int)sin_table[idx];
}Tip: Because the
sin() function results in constant values, no
core is required in the RTL design to implement the sin() function.