Best way to wrap a C array pointer as a Chapel array

Unfortunately there does not appear to be a function that works for every domain. DefaultRectangularArr uses a method called getDataIndex under the covers that performs this computation, and it looks like other array types rely on a similar method defined on an inner storage class. It looks like these are not available on the domains themselves. I suspect relying on any of these would be inadvisable as they may be changed as part of an implementation adjustment, anyways.

Our hope is that eventually pointers like what you are describing could be wrapped in Chapel arrays using something like the makeArrayFromPtr function defined for interoperability. Unfortunately this function only supports 1D 0-indexed arrays today, but work is currently being done to expand our support for array interoperability. I would expect that function to adjust its arguments or for another version to be defined for multi-dimensional arrays, and we are still figuring that out.

I was curious whether I could trick a Chapel array into referring to a buffer allocated in C without much effort. I was able to do it, but am not proud of the result. Specifically:

• it uses features that aren't user-facing, so may change or break at any future point
• it currently only works for rectangular Chapel arrays that start indexing at 0 in each dimension

With those caveats in mind, here's a simple C header that exposes a few simple routines to be called from Chapel. The first allocates a trivial 9-element array; the second frees its argument.

#include <stdlib.h>

double* getDataPtr() {
  double* dataPtr = (double*)malloc(9*sizeof(double));

  dataPtr[0] = 1.1;
  dataPtr[1] = 1.2;
  dataPtr[2] = 1.3;
  dataPtr[3] = 2.1;
  dataPtr[4] = 2.2;
  dataPtr[5] = 2.3;
  dataPtr[6] = 3.1;
  dataPtr[7] = 3.2;
  dataPtr[8] = 3.3;

  return dataPtr;
}

void freeDataPtr(double* ptr) {
  free(ptr);
}

and here's the Chapel code that calls into it, then forces the C pointer into an existing array of the appropriate size and 0-based indices:

//                                                                        
// Declare a Chapel array.  Note that this program will only work as      
// written if it uses 0-based indexing.                                   
//                                                                        
var A: [0..2, 0..2] real;

//                                                                        
// testit.h is the C code above.  It defines a simple C stub that returns a pointer
// to floating point data.                                                            
//                                                                        
require "testit.h";

//                                                                        
// Here are the key routines that testit.h exposes back to Chapel to      
// get and free a pointer to floating point data.                         
//                                                                        
extern proc getDataPtr(): c_ptr(real);
extern proc freeDataPtr(ptr: c_ptr(real));

//                                                                        
// Grab the pointer from C                                                
//                                                                        
const myCPtr = getDataPtr();

//                                                                        
// Save two pointer values defined in A's descriptor.  Note that these    
// are not part of its public interface, so are not recommended for       
// typical users and could change / break at any future point.            
//                                                                        
const saveData = A._value.data;
const saveShiftedData = A._value.shiftedData;

//                                                                        
// Replace these pointers with the one we got from C.                     
//                                                                        
A._value.data = (myCPtr: _ddata(real));
A._value.shiftedData = (myCPtr: _ddata(real));

//                                                                        
// print out A, "proving" that we're referring to the data from C         
//                                                                        
writeln(A);

//                                                                        
// restore the original pointers to avoid having Chapel try to free       
// the C memory / leak the Chapel memory.                                 
//                                                                        
A._value.data = saveData;
A._value.shiftedData = saveShiftedData;

//                                                                        
// Free the C data                                                        
//                                                                        
freeDataPtr(myCPtr);

The output of Chapel's writeln(A) statement is:

1.1 1.2 1.3
2.1 2.2 2.3
3.1 3.2 3.3

I think it'd be completely reasonable to file a feature request on Chapel's GitHub issues page proposing a better user-facing interface for adopting a C pointer like this, albeit in a nicer and more official way.

A slightly different approach might be below. The downside here is that this isn't a Chapel array, but it does allow for indexing/iterating just like a Chapel array would. This doesn't handle strides or non-zero alignments and there is no bounds-checking done.

prototype module CPtrArray {

  use SysCTypes;

  record CPtrArray {
    type eltType;
    param rank : int;
    const first : rank*int;
    const blk : rank*int;

    var data : c_ptr(eltType);


    proc init(type t, D : domain, ptr : c_ptr(t)) {
      this.eltType = t;
      this.rank = D.rank;
      this.first = D.first;
      var blktmp : rank*int;
      blktmp(rank) = 1;
      if (rank > 1) {
        for param idim in (rank-1)..1 by -1 {
          blktmp(idim) = blktmp(idim+1)*D.shape(idim+1);
        } 
      }
      this.blk = blktmp;
      this.complete();
      data = ptr;
    }

    proc getDataOffset(ndx : rank*int) : int {
      var offset = ndx(rank)-first(rank);
      if (rank > 1) {
        for param idim in 1..(rank-1) do
          offset += (ndx(idim)-first(idim))*blk(idim);
      }
      return offset;
    }

    inline proc this(ndx : rank*int) ref {
      return data[getDataOffset(ndx)];
    }

    inline proc this(i:int ...rank) ref {
      return this(i);
    }

    // Should provide iterators as well.                 
  }

}

A simple test program that uses it :

use CPtrArray;

var A : [0.. #10] real;
forall ii in 0.. #10 do A[ii] = ii+1.0;

writeln(A);

var ptr = c_ptrTo(A[0]);

// Code for testing the array class goes here
const D = {1.. #5, 3.. #2};
var A1 = new CPtrArray(real, D, ptr);

for ndx in D {
  writeln(ndx," ",A1[ndx]);
}