Is it safe to pack multiple arrays in an array of pointers?

[roastduck]

Hi team,

I have a function that accepts all the parameters in an array of pointers. The parameters are unpacked to be used. Like this:

void f(void **params) {
  double *param0 = (double*)params[0];
  double *param1 = (double*)params[1];
  // do computation with `param0` and `param1`.
}

This function is inside the derived part of program, and the interface passed to __enzyme_autodiff has clearly separated parameters.

Is packing parameters like this safe for Enzyme? I found Enzyme outputs an incorrect result if I do this.

A more complete example is below. icf's gradient will be wrong. But unfortunately it is not a full program and I failed to make it smaller for reproducing. Once I embed the data inside the program (by separated arrays, and pack them into an array of pointers just in the program body), the result will be magically become correct. I guess this is because the pointer alias analysis can distinguish these arrays then by the embedded input.

#include <cpu_runtime.h>                                                                                                                                                                                                           

void run(void **params, void **returns, size_t **retShapes, size_t *retDims, CPUContext_t ctx) {
  double (*_means)[2] = (double(*)[2])(params[1]);
  double (*_icf)[3] = (double(*)[3])(params[2]);
  double (*_x)[2] = (double(*)[2])(params[3]);
  auto &&_out = ((double &)*((double *)(params[6])));
  double _Ls[5][2][2];
  for (int _i__3 = 0; _i__3 < 5; _i__3++) {
    double _ret[2][2];                                                                                                                                                                                                                           
    for (int _i__4 = 0; _i__4 < 2; _i__4++) {
      double _output[2];
      for (int _i__6 = 0; _i__6 < (_i__4 + 1); _i__6++) {
        _output[_i__6] = 0x0p+0f;
      }
      if ((((-1 * _i__4) + 1) == 1)) {
        _output[1] = _icf[_i__3][2];
      }
      for (int _i__8 = 0; _i__8 < 2; _i__8++) {
        _ret[_i__8][_i__4] = _output[_i__8];
      }
    }
    for (int _i__9 = 0; _i__9 < 2; _i__9++) {
      for (int _i__10 = 0; _i__10 < 2; _i__10++) {
        _Ls[_i__3][_i__9][_i__10] = _ret[_i__9][_i__10];
      }
    }
  }
  {
    double _xcentered[1000][5][2];
    for (int _i__11 = 0; _i__11 < 1000; _i__11++) {
      for (int _i__14 = 0; _i__14 < 5; _i__14++) {
        for (int _i__15 = 0; _i__15 < 2; _i__15++) {
          _xcentered[_i__11][_i__14][_i__15] = (_x[_i__11][_i__15] - _means[_i__14][_i__15]);
        }
      }
    }
    {
      double _Y[1000][5][2];
      for (int _i__16 = 0; _i__16 < 1000; _i__16++) {
        for (int _i__17 = 0; _i__17 < 5; _i__17++) {
          for (int _i__18 = 0; _i__18 < 2; _i__18++) {
            _Y[_i__16][_i__17][_i__18] = 0;
            for (int _i__19 = 0; _i__19 < 2; _i__19++) {
              _Y[_i__16][_i__17][_i__18] += (_Ls[_i__17][_i__18][_i__19] * _xcentered[_i__16][_i__17][_i__19]);
            }
          }
        }
      }
      {
        double _y__2;
        _y__2 = 0;
        for (int _i__26 = 0; _i__26 < 1000; _i__26++) {
          for (int _i__27 = 0; _i__27 < 5; _i__27++) {
            for (int _i__28 = 0; _i__28 < 2; _i__28++) {
              _y__2 += ((_icf[_i__27][_i__28] * _xcentered[_i__26][_i__27][_i__28]) + _Y[_i__26][_i__27][_i__28]);
            }
          }
        }
        _out = _y__2;
      }
    }
  }
}

void run_wrapper(double *alphas, double *means, double *icf, double *x, double *wishart_gamma, int32_t *wishart_m, double *out, CPUContext_t ctx) {
    void *params[] = {alphas, means, icf, x, wishart_gamma, wishart_m, out};
    void *returns[] = {};
    size_t *retShapes[] = {};
    size_t retDims[] = {};
    run(params, returns, retShapes, retDims, ctx);
}

void __enzyme_autodiff(...);
int enzyme_dup;
int enzyme_out;
int enzyme_const;

extern "C" void d_run(void **params, void **returns, size_t **retShapes, size_t *retDims, CPUContext_t ctx) {
    double d_out = 1;
    __enzyme_autodiff(run_wrapper,
        enzyme_dup, (double*)params[0], (double*)params[7],
        enzyme_dup, (double*)params[1], (double*)params[8],
        enzyme_dup, (double*)params[2], (double*)params[9],
        enzyme_const, (double*)params[3],
        enzyme_const, (double*)params[4],
        enzyme_const, (int32_t*)params[5],
        enzyme_dup, (double*)params[6], &d_out,
        enzyme_const, ctx);
}

Is packing of parameters like this likely to be attributed to the incorrect result? If not, what else can be wrong?

Thanks.

[roastduck]

Marking __attribute__((always_inline)) at the inner function makes the function correct. Is it expected? I want to try -enzyme -enzyme-inline=1, but how to set -enzyme options using ClangEnzyme, since the use of LLVMEnzyme is now discouraged?

[tgymnich]

Packing parameters like this should work. But you are clearly encountering some kind of bug here, which needs to be investigated. Enzyme inline can be used like so: /path/to/clang test.cpp -fpass-plugin=/path/to/ClangEnzyme-16.so -Xclang -load -Xclang /path/to/ClangEnzyme-16.so -O2 -o test -mllvm -enzyme-inline=1