Pointer Arithmetic - 2022.1 English

Vitis High-Level Synthesis User Guide (UG1399)

Document ID
UG1399
Release Date
2022-06-07
Version
2022.1 English

Introducing pointer arithmetic limits the possible interfaces that can be synthesized in RTL. The following code example shows the same code, but in this instance simple pointer arithmetic is used to accumulate the data values (starting from the second value).

``````#include "pointer_arith.h"

void pointer_arith (dio_t *d) {
static int acc = 0;
int i;

for (i=0;i<4;i++) {
acc += *(d+i+1);
*(d+i) = acc;
}
}
``````

The following code example shows the test bench that supports this example. Because the loop to perform the accumulations is now inside function `pointer_arith`, the test bench populates the address space specified by array `d[5]` with the appropriate values.

``````#include "pointer_arith.h"

int main () {
dio_t d[5], ref[5];
int i, retval=0;
FILE        *fp;

// Create input data
for (i=0;i<5;i++) {
d[i] = i;
ref[i] = i;
}

// Call the function to operate on the data
pointer_arith(d);

// Save the results to a file
fp=fopen(result.dat,w);
printf( Din Dout\n, i, d);
for (i=0;i<4;i++) {
fprintf(fp, %d \n, d[i]);
printf(  %d   %d\n, ref[i], d[i]);
}
fclose(fp);

// Compare the results file with the golden results
retval = system(diff --brief -w result.dat result.golden.dat);
if (retval != 0) {
printf(Test failed!!!\n);
retval=1;
} else {
printf(Test passed!\n);
}

// Return 0 if the test
return retval;
}
``````

When simulated, this results in the following output:

``````Din Dout
0   1
1   3
2   6
3   10
Test passed!
``````

The pointer arithmetic can access the pointer data out of sequence. On the other hand, wire, handshake, or FIFO interfaces can only access data in order:

• A wire interface reads data when the design is ready to consume the data or write the data when the data is ready.
• Handshake and FIFO interfaces read and write when the control signals permit the operation to proceed.

In both cases, the data must arrive (and is written) in order, starting from element zero. In the Interface with Pointer Arithmetic example, the code starts reading from index 1 (`i` starts at 0, 0+1=1). This is the second element from array `d[5]` in the test bench.

When this is implemented in hardware, some form of data indexing is required. Vitis HLS does not support this with wire, handshake, or FIFO interfaces.

Alternatively, the code must be modified with an array on the interface instead of a pointer, as in the following example. This can be implemented in synthesis with a RAM (`ap_memory`) interface. This interface can index the data with an address and can perform out-of-order, or non-sequential, accesses.

Wire, handshake, or FIFO interfaces can be used only on streaming data. It cannot be used with pointer arithmetic (unless it indexes the data starting at zero and then proceeds sequentially).

``````#include "array_arith.h"

void array_arith (dio_t d[5]) {
static int acc = 0;
int i;

for (i=0;i<4;i++) {
acc += d[i+1];
d[i] = acc;
}
}
``````