Cannot use variable index in a constant list

Question

Using the Device Modeling Language (DML), version 1.4.

I create a param of lists like

param X = [ [0, 0, 0], [0, 0, 1].......];

And I want to access them in a method using variable like

method get_var(uint32 idx) -> (uint32) {
  return X[idx][0];
}

But when I try to compile it says I cannot use variable index in a constant list.

Is there a different data type that I should be using other than param to allow this? Or is there a way to define "idx" as a const so it could be used?

The workaround that I currently have is creating a session variable and copying the param list over during post_init() since then I'm allowed to access that session variable using variable index. I don't know if it's the best way to handle that.

score 3 · Answer 1 · edited Jan 17 '23 at 11:35

3

Another possibility is to use a session variable. Session variables will take some extra space, and will consume stack space equal to their size during object initialization, so they are not suited for very large arrays. But for reasonable array sizes < 256 it is a valid approach.

session int my_array[3][3] = {{0, 1, 2}, {4, 1, 2}, {1, 2, 3}};

method get_int(int idx) -> (int) {
    return my_array[idx][0];
}

edited Jan 17 '23 at 11:35

Love Waern

105
2

answered Jan 12 '23 at 09:39

Gustav Wiklander

87
5

This is probably the currently easiest solution, but also slightly expensive. I'd write `session const int` for clarity, to show it's a constant. – Erik Carstensen Jan 12 '23 at 09:44
The "allocated on stack" problem is negligible (it's a problem only for megabyte-sized initializers). A bigger cost problem is that a new copy of the array must be created for every instance of the device. – Erik Carstensen Jan 12 '23 at 09:48

score 1 · Answer 2 · answered Jan 11 '23 at 11:25

The traditional approach (popular in DML 1.2) is to use #foreach:

method get_var(uint32 idx) -> (uint32) {
  local int i = 0;
  #foreach item in (X) {
    if (i == idx) {
      return item[0];
    }
    ++i;
  }
}

This approach will however unroll the for loop, so it should be used with care if the list can be large.

Also, note that in other #foreach use cases where the loop body is somewhat large, you should break out the body into a separate method. Your get_var method is in fact one good example of how to do that.

score 1 · Answer 3 · answered Jan 12 '23 at 21:57

One solution is to provide an array value through an independent startup memoized method:

typedef int arr_t[3][3];
independent startup memoized method my_array() -> (arr_t *) {
    local arr_t *ret = new arr_t;
    *ret = {{1,2,3},{4,5,6},{7,8,9}};
    return ret;
}
method get_int(int idx) -> (int) {
    return (*my_array())[idx][0];
}

independent startup memoized means that the my_array method body will be called implicitly when the module is loaded, and the result of that call will be cached and reused in all subsequent explicit calls.

This solution is somewhat similar to the session solution but avoids the per-device memory overhead. Another advantage is that the initializer appears in a context that can run code; This can make it the preferred solution in cases where some of the array values can be inferred from others.

score -1 · Answer 4 · answered Jan 12 '23 at 16:53

One option is to provide the list as a C initializer in a header %{ %} block:

header %{
static const int my_array[3][3] = {{0, 1, 2}, {3, 4, 5}, {6, 7, 8}};
%}
// DMLC swallows the header block without parsing; "extern" declares to DMLC
// what it provides
extern const int my_array[3][3];
method get_int(int idx) -> (int) {
  return my_array[idx];
}

This approach is economic, both for memory consumption and compile speed, but the code looks awful, so this approach is mainly useful for auto-generated DML code.

Cannot use variable index in a constant list

4 Answers4

Linked