MATLAB: Using RAM by mex-function

cmexmex compilerram

Something strange occurs when I try to transfer matrices to mex-function. When matrices size is not big the mex-function perform well, but if size of my matrices about 500*500 and more matlab will crush without any message. The terminal reports about a segmentation fault.

#include "mex.h"
#include <iostream>
#include "CFullVec.h"
double GAMMA, Mnuclon;
int NR, NZ;
   void mexFunction(int nlhs, mxArray *plhs[],   // output to ML
          int nrhs, const mxArray *prhs[]) // input to C++
  {{
       double *parGas, *parGrid, *parTime;
       size_t mrows, ncols;
       std::cout << "zdfgbDSFB" << std::endl;
       // check nb of gas parameters
       mrows = mxGetM(prhs[0]);
       ncols = mxGetN(prhs[0]);
       if(mrows!=2 || ncols!=1){
           mexErrMsgIdAndTxt("MATLAB:mexcpp:nargin", "Incorrect vector of the gas parameters");
       }
  // check nb of grid parameters
       mrows = mxGetM(prhs[1]);
       ncols = mxGetN(prhs[1]);
       if(mrows!=6 || ncols!=1){
           mexErrMsgIdAndTxt("MATLAB:mexcpp:nargin", "Incorrect vector of the grid parameters");
       }
       // check nb of time parameters
       mrows = mxGetM(prhs[2]);
       ncols = mxGetN(prhs[2]);
       if(mrows!=3 || ncols!=1){
           mexErrMsgIdAndTxt("MATLAB:mexcpp:nargin", "Incorrect vector of the time parameters");
       }
       parGas=mxGetPr(prhs[0]);
       double GAMMA = parGas[0];
       double Mnuclon = parGas[1];
       parGrid=mxGetPr(prhs[1]);
       NR = static_cast<int>( (parGrid[1]-parGrid[0])/parGrid[2] ) + 1;
       NZ = static_cast<int>( (parGrid[4]-parGrid[3])/parGrid[5] ) + 1;
       parTime=mxGetPr(prhs[2]);
       const int ST = static_cast<int>( parTime[0]/parTime[1] );
       const int CVAR = static_cast<int>( parTime[0]/parTime[2] );
        // check data dimensions
       for(int i=3; i<=3+7; i++){
           mrows = mxGetM(prhs[i]);
           ncols = mxGetN(prhs[i]);
           //std::cout << i << ' ' << mrows << ' ' << ncols << std::endl;
           if(mrows!=NR+2 || ncols!=NZ+2){
              // mexErrMsgIdAndTxt("MATLAB:mexcpp:nargin", "Incorrect array of initial data");
           }
       }
       double *rho, *Vr, *Vp, *Vz, *Br, *Bp, *Bz, *T; // these pointers are used both to input and to output
       // assign pointers to input
       rho=mxGetPr(prhs[3]); Vr=mxGetPr(prhs[4]); Vp=mxGetPr(prhs[5]); Vz=mxGetPr(prhs[6]);
       Br=mxGetPr(prhs[7]); Bp=mxGetPr(prhs[8]); Bz=mxGetPr(prhs[9]); T=mxGetPr(prhs[10]);
       FullVec U[NR+2][NZ+2];
     // something else....

The error happens in the last three lines. Also if the declaration of U[NR+2][NZ+2] is deleted the error may not happen. Therefore I think this error is associated with RAM, but the matrices take not more than 40-50 MB RAM and U[NR+2][NZ+2] takes about the same.

I use linux mint 64-bit. I add -largeArrayDims during compilation. Could you tell me, what is going wrong?

Best Answer

I haven't looked over your code in any detail, but this line definitely raises a red flag:

FullVec U[NR+2][NZ+2];

U is a local array variable, so its memory will be allocated from the stack, not the heap. While 50MB is not a particularly large number when compared to the heap, it is a potentially huge number when compared to the stack memory available. I can easily see where this could work without issue for small sizes, but blow the stack and crash MATLAB for a 50MB array. The solution is to never allocate variables of anywhere near this size off of the stack ... always allocate off of the heap instead. That means you need to allocate the memory for U using mxMalloc or mxCalloc since that memory comes from the heap. And since you are using the double bracket syntax [ ][ ] for accessing the elements, you will either need to give that syntax up and do your own manual indexing with single bracket [ ] notation, or you will need to allocate U in two stages (one for the first [ ] stuff and one for the second [ ] stuff). Let me know if you need help doing that. E.g., see this link for some example code on using double bracket [ ][ ] syntax with heap allocated memory:

https://www.mathworks.com/matlabcentral/answers/309434-matlab-crashing-when-evaluating-mex

Related Solutions

MATLAB: How to read back (and use) a matrix from a matlab function called from a mex file

I don't see anywhere in your code where you create a variable in histforce_ips[0]. E.g.,

mxArray * histforce_ips[1];
    :
mexCallMATLAB(1,histforce_ops,1,histforce_ips,"calchistforce");

There is nothing inbetween these lines that sets histforce_ips[0] to anything, so when you call mexCallMATLAB you are passing an invalid pointer for the input argument. You need to do something like this instead:

mxArray * histforce_ips[1];
    :
histforce_ips[0] = mxCreateDoubleMatrix(mrows,ncols,mxREAL);
    :
// Then fill in the values of histforce_ips[0] via mxGetPr etc
    :
mexCallMATLAB(1,histforce_ops,1,histforce_ips,"calchistforce");
    :
mxDestroyArray(histforce_ips[0]);
mxDestroyArray(histforce_ops[0]);

Also, I don't know if this will eventually make a difference in your code at some point, but the way you allocate your "a" and "b" matrices piecemeal means that the memory for them is not guaranteed to be contiguous. Generally, if you want to preserve the a[j][i] syntax of indexing I would recommend allocating a single block of memory and work with that instead. E.g.,

// allocate memory:
  a=(double**)malloc(mrows*sizeof(double *));
  b=(double**)malloc(mrows*sizeof(double *));
  a[0] = (double *) malloc(mrows*ncols*sizeof(double));
  b[0] = (double *) malloc(mrows*ncols*sizeof(double));
  for(i=1;i<mrows;i++){
      a[i] = a[i-1] + ncols;
      b[i] = b[i-1] + ncols;
  }
  :
  free(a[0]); free(a);
  free(b[0]); free(b);

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.

Best Answer

Related Solutions

MATLAB: How to read back (and use) a matrix from a matlab function called from a mex file

MATLAB: Problem in using mxSetPr

Related Question