Whole packets through open arrays

The caller keeps the shape

The formal input byte unsigned data[] is an open array: an unpacked array whose size the import leaves open. C receives an svOpenArrayHandle, a descriptor of the actual array, and the DPI C layer answers questions about it. svDimensions gives the number of dimensions, and svSize, svLeft and svRight describe one dimension; svLow and svHigh give the same bounds sorted. A legal actual array may start at 3, or at 5 and count down. Nothing promises an index 0.

For a sum the order makes no difference. For a CRC, a parser or a byte-stream decoder it is part of the format, so decide which end is the first byte and read in that order on purpose.

Read through the accessor

svGetArrElemPtr1(h, i) returns a pointer to element i of a one-dimensional array, using the array's own index. Outside the bounds it returns null, and Verilator also prints a warning. The formal type byte unsigned makes each element an unsigned char, so the model casts the pointer to that and reads one byte. Never cast the handle itself to an array, and never assume the elements sit next to each other in memory.

for (int k = 0; k < count; ++k) {
  const unsigned char* p =
    (const unsigned char*)svGetArrElemPtr1(d, k);
  *total += *p;   // null for pkt[3:5]
}

const int left = svLeft(d, 1);
const int step = left <= svRight(d, 1) ? 1 : -1;
for (int k = 0; k < count; ++k) {
  const unsigned char* p =
    (const unsigned char*)svGetArrElemPtr1(d, left + k * step);
  if (!p) { *total = 0; return 3; }
  *total += *p;
}

A pointer from the accessor is borrowed for the length of the call. The simulator may move or reuse that storage once the call returns, so a model that needs the packet later copies the bytes into memory of its own. svGetArrayPtr can hand out the whole block at once when the layout is supported, but only behind a check with the element-by-element walk as the fallback.

Bound the work

The count argument says how many bytes are valid. The handle knows how big the buffer is; it cannot know how much of it the packet filled. A fixed buffer of 64 bytes may carry a 12-byte packet, and the sum must stop at 12. The model refuses a negative count, a count beyond svSize, and a count above 1024, so the largest sum, 1024 times 255, stays far inside a 32-bit unsigned total.

1. Ascending bounds

   Three reads at indexes 3, 4 and 5.

   values	1, 128, 255
   status / total	0 / 384

2. Descending bounds

   Three reads at indexes 5, 4 and 3; the order changes nothing for a sum.

   values	2, 3, 4
   status / total	0 / 9

3. Empty packet

   A count of zero is legal: the loop runs zero times and the initialised total stays 0.

   count	0
   status / total	0 / 0

4. Count beyond the buffer

   A count of 4 on a three-element array is refused before any read.

   count	4
   status / total	2 / 0

One call per packet is the natural size. It keeps the pointer rules simple, and the transfer cost is easy to see in a profile. A call per bit or per byte buries the same work in thousands of crossings. Measure the crossing with real packets before you claim that fewer calls made anything faster.

Try it

Run it, then add a fourth array with the bounds [7:8] holding two bytes of 255 and assert a total of 510. A byte-sized accumulator would have lost the carry; the 32-bit total keeps it.

Then ask for a count of 4 on ascending and check that the status is 2 and the total 0: the model refuses before it reads anything.

#include "Vtb__Dpi.h"
#include "svdpi.h"
#include <cstdint>
#include <climits>
#include <cstring>
// status 0: summed. 1: wrong shape. 2: count outside the buffer or above 1024. 3: element missing.
extern "C" int sum_bytes(const svOpenArrayHandle data, int count, unsigned int* total) {
  *total = 0;
  if (svDimensions(data) != 1) return 1;
  if (count < 0 || count > svSize(data, 1) || count > 1024) return 2;  // 1024 x 255 fits a 32-bit sum
  const int left = svLeft(data, 1);
  const int step = left <= svRight(data, 1) ? 1 : -1;                   // walk from left toward right
  for (int k = 0; k < count; ++k) {
    const unsigned char* p = static_cast<const unsigned char*>(svGetArrElemPtr1(data, left + k * step));
    if (!p) { *total = 0; return 3; }                                    // outside the bounds: null
    *total += *p;                                                        // read now; never keep p
  }
  return 0;
}

Check yourself

`timescale 1ns/1ps
module tb;
  import "DPI-C" function int sum_bytes(input byte unsigned data[], input int count, output int unsigned total);
  byte unsigned d[5:3] = '{2, 3, 4};
  int unsigned total;
  initial begin
    void'(sum_bytes(d, 2, total));
    $display("%0d", total);
    $finish;
  end
endmodule

#include "Vtb__Dpi.h"
#include "svdpi.h"
#include <cstdint>
#include <climits>
#include <cstring>
// status 0: summed. 1: wrong shape. 2: count outside the buffer or above 1024. 3: element missing.
extern "C" int sum_bytes(const svOpenArrayHandle data, int count, unsigned int* total) {
  *total = 0;
  if (svDimensions(data) != 1) return 1;
  if (count < 0 || count > svSize(data, 1) || count > 1024) return 2;  // 1024 x 255 fits a 32-bit sum
  const int left = svLeft(data, 1);
  const int step = left <= svRight(data, 1) ? 1 : -1;                   // walk from left toward right
  for (int k = 0; k < count; ++k) {
    const unsigned char* p = static_cast<const unsigned char*>(svGetArrElemPtr1(data, left + k * step));
    if (!p) { *total = 0; return 3; }                                    // outside the bounds: null
    *total += *p;                                                        // read now; never keep p
  }
  return 0;
}

st = sum_high(p, 3, t);

st = sum_zero(p, 3, t);

st = sum_left(p, 3, t);

st = sum_right(p, 3, t);

#include "Vtb__Dpi.h"
#include "svdpi.h"
#include <cstdint>
#include <climits>
#include <cstring>
// One walker, four starting rules. Each reads count elements and adds them up.
static int walk(const svOpenArrayHandle d, int count, unsigned* total, int first, int step) {
  *total = 0;
  if (svDimensions(d) != 1) return 1;
  if (count < 0 || count > svSize(d, 1) || count > 1024) return 2;
  for (int k = 0; k < count; ++k) {
    const unsigned char* p = static_cast<const unsigned char*>(svGetArrElemPtr1(d, first + k * step));
    if (!p) { *total = 0; return 3; }
    *total += *p;
  }
  return 0;
}
static int dir(const svOpenArrayHandle d) { return svLeft(d, 1) <= svRight(d, 1) ? 1 : -1; }
extern "C" int sum_left(const svOpenArrayHandle d, int c, unsigned* t)  { return walk(d, c, t, svLeft(d, 1), dir(d)); }
extern "C" int sum_right(const svOpenArrayHandle d, int c, unsigned* t) { return walk(d, c, t, svRight(d, 1), -dir(d)); }
extern "C" int sum_high(const svOpenArrayHandle d, int c, unsigned* t)  { return walk(d, c, t, svHigh(d, 1), -1); }
extern "C" int sum_zero(const svOpenArrayHandle d, int c, unsigned* t)  { return walk(d, c, t, 0, 1); }