MATLAB: Copying dynamic array to MxArray object using memcpy in c++

matlab enginemxarray

I am writing a c++ program that calls that Matlab Engine. I am getting an error when I try to use memcpy for a dynamically allocated multi-dimensional array. I have a type definition as follows in my header file:

typedef double* dblArrayptr;

My array definition in my function is as as follows:

dblArrayptr *A;

A = new dblArrayptr [2*NUMROWS];

for (int i=0;i<2*NUMROWS;i++)

A[i] = new double [2*NUMROWS];

I initialize this matrix A with some values and then try to use the memcpy command as follows: (note: this matrix has 44 rows and 44 columns).

memcpy((void *)mxGetPr(A_m), (void *)A,1936*sizeof(double));

I receive a memory access violation error. Access violation reading location.

This memcpy command seems to work ok if I have a single array (44×1) of type double.

Do I have to do an element by element copy?

Best Answer

Problem #1)

Your method is a poor way to allocate a 2D matrix because it does not require that all of the individual columns are contiguous in memory, hence you cannot reliably use memcpy on the entire data set at once to copy the contents into an mxArray. In the code snippet below, the memory behind A[i] is not necessarily contiguous to the memory behind A[i+1] etc.

    for (int i=0;i<2*NUMROWS;i++)  
    A[i] = new double [2*NUMROWS];

Problem #2)

Your memcpy is not even copying the data memory behind the pointers, it is copying the pointers themselves (i.e., the A array). Remember, A is not an array of doubles, it is (effectively) an array of pointers to doubles.

memcpy((void *)mxGetPr(A_m), (void *)A,1936*sizeof(double));

Solutions:

A poor way to do this would be to copy each column individually to the appropriate place in the mxArray data area in a loop. Gets the job done but it is rather inefficient and your code is more complex than it needs to be.

A better way to do this would be to allocate your entire 2D matrix all at once. That will allow you to copy the data to the mxArray data area in one fell swoop. If you really want the A[i] column pointers then just point them to the appropriate places within the contiguous 2D data area.

The best way is to avoid new altogether. Just create your mxArray up front and use mxGetPr to get a pointer into the data area. If you want the A[i] column pointers then just point them to the appropriate places within this contiguous data area (again avoiding the new).

Related Solutions

MATLAB: Problem in using mxSetPr

AP - the documentation for mxSetPr indicates that for the second input parameter to this function,

The array must be in dynamic memory; call mxCalloc to allocate this memory. Do not use the ANSI® C calloc function, which can cause memory alignment issues leading to program termination. If pr points to static memory, memory leaks and other memory errors can result.

Did you use mxCalloc to allocate memory to Ain and kernel? That being said, I did try the following test function

 void test()
 {
     mxArray* myMxArray  = 0;
     double*  myDblArray = 0;
     myMxArray  = mxCreateNumericMatrix( 0, 0, mxDOUBLE_CLASS, mxREAL );
     myDblArray = mxCalloc(4,sizeof(double));
     if (myMxArray!=NULL && myDblArray!=NULL)
     {
        mxSetPr(myMxArray,myDblArray);
        mxSetM(myMxArray,2);
        mxSetN(myMxArray,2);
        mxFree(myDblArray);
        mxDestroyArray(myMxArray); 
     }
 }

and the above crashed at the mxSetPr line. So I am a little puzzled by the above. James Tursa would most likely know what is wrong with the above code.

-------

The only time I've seen mxSetPr being used in for output (the lhs) of the mexFunction, so if I had to do something similar to what you are doing, I would have tried the following

 void myfun2(double *Ain   , int  AnRows    , int AnCols, 
             double *kernel, int kernelnRows, int kernelnCols,
             mxArray **lhs)
 {
     mxArray *rhs[3];
     double  *ptr;
     // create the mxArrays
     rhs[0] = mxCreateNumericMatrix( AnRows, AnCols, mxDOUBLE_CLASS, mxREAL );
     rhs[1] = mxCreateNumericMatrix( kernelnRows, kernelnCols, mxDOUBLE_CLASS, mxREAL );
     rhs[2] = mxCreateString       ( "same" );
     // copy the Ain and kernel data
     ptr = mxGetPr(rhs[0]);
     memcpy(ptr,Ain,sizeof(double)*AnRows*AnCols);
     ptr = mxGetPr(rhs[1]);
     memcpy(ptr,kernel,sizeof(double)*kernelnRows*kernelnCols);
     mexCallMATLAB(1, lhs, 3, rhs, "conv2");
     // destroy the mxArrays
     mxDestroyArray(rhs[0]);
     mxDestroyArray(rhs[1]);
     mxDestroyArray(rhs[2]);
 }

Note in the above how memcpy is used to copy the data from the Ain and Kernel arrays to the destination mxArrays. Note also that for every create of an mxArray, we must destroy or free memory allocated to that array.

For the case of the left-hand side result of the convolution, we pass an mxArray into this function as

 mxArray **lhs

As (presumably) memory will be dynamically allocated to it within the conv2 function, the caller of myfun2 does not need to allocate memory to this parameter, but the caller will be responsible for freeing the memory. For example,

 // do some work to create the Ain and Kernel matrices
 // declare the output matrix from the 2D convolution
 mxArray *convMtx = 0;
 // call the function to do the 2D convolution
 myfun2(Ain, AnRows, AnCols,kernel,kernelnRows,kernelnCols,&convMtx);
 if (convMtx!=NULL)
 {
    // do some stuff with convMtx
    // destroy mxArray
    mxDestroyArray(convMtx);
 }

See how we pass the convMtx into the function as &convMtx.

MATLAB: How to create an empty array in C and fill it in Matlab

You first need to fix your memory leaks, and then also check the return pointer from engGetVariable. Maybe you are just running out of memory because of the memory leaks. E.g.,

xProcess = mxCreateDoubleMatrix(numberProcess, 1, mxREAL); 
yProcess = mxCreateDoubleMatrix(numberProcess, 1, mxREAL);
xC = mxCreateDoubleMatrix(numberC, 1, mxREAL); 
yC = mxCreateDoubleMatrix(numberC, 1, mxREAL);
    :
xC = engGetVariable(ep,"xC");   <-- leaks the xC from above
    :
yC = engGetVariable(ep,"yC");  <-- leaks the yC from above
    :
xProcess = engGetVariable(ep,"xProcess");   <-- leaks the xProcess from above
    :
yProcess = engGetVariable(ep,"yProcess");  <-- leaks the yProcess from above

You need to put in some mxDestroyArray(xC) etc between the first group of lines above and the engGetVariable( ) lines below.

Also, check the return value of engGetVariable( ) for NULL. E.g.,

xC = engGetVariable(ep,"xC");
if( xC == NULL ) {
    /* Put code here to handle error */
}

Frankly, you should also be checking the return values of every malloc and calloc call.

Also I would note that you have a lot of data copying going on in your code. Can you simply work with the pointers returned from mxGetPr( ) directly instead of copying the data back & forth via memcpy each time? E.g., instead of this:

double *XC = NULL;
XC = (double *)malloc (mRowsC*sizeof(double) );
memcpy(XC, mxGetData(xC),mRowsC*sizeof(double));

why can't you just do this:

double *XC = mxGetPr(xC);

As a side note, you don't need those (void *) casts in your mcmcpy arguments ... you always get those conversions automatically from the compiler.

Best Answer

Related Solutions

MATLAB: Problem in using mxSetPr

MATLAB: How to create an empty array in C and fill it in Matlab

Related Question