Matlab crashing when evaluating mex

I have the following C code, that I compile into a mex (32bit) with Visual Studio Express 2013:

#include <stdlib.h>
#include <stdio.h>
#include "mex.h"

void mexFunction(int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[])
{
  const size_t m = mxGetM(prhs[0]);
  const size_t n = mxGetN(prhs[0]);
  double** x = (double**)mxCalloc(n, m);
  for (size_t i = 0; i < n; i++)
    x[i] = (double*)mxCalloc(m, sizeof(double));

  for (size_t i = 0; i < n; i++)
    mxFree(x[i]);
  mxFree(x);
}

It is basically just allocating space to store a 2D matrix passed from Matlab, then deallocating it (without setting any value). When I compile it into mexw32 with Visual Studio Express 2013, then execute the following in Matlab 2013b 32bit, it crashes Matlab:

n = 51; x = zeros(3,n); myMex(x)

Here's the top of the stack log from the crash:

Stack: [0x00430000,0x00c30000],  sp=0x00c23f7c,  free space=8143k
Native frames: (J=compiled Java code, j=interpreted, Vv=VM code, C=native code)
C  [ntdll.dll+0x2e43e]  RtlInitUnicodeString+0x196
C  [ntdll.dll+0x2e0a3]  RtlFreeHeap+0x7e
C  [kernel32.dll+0x114bd]  HeapFree+0x14
C  [MSVCR100.dll+0x1016a]  free+0x1c

Does anyone have any idea whatI'm doing wrong here? Is it down to the way I deallocate each pointer?

Thanks in advance for your answers.

Answer 1

[James Tursa]

Here is some sample code for you to peruse. It takes a 2D matrix input and writes the input values to the screen using various methods. I prefer the first direct method, but the macro version of this has some readability advantages. I am not a big fan of using the [ ][ ] syntax in either methods shown. Whenever I encounter this style of coding for matrix access it always seems too burdensome to me and the perceived benefit simply to maintain the [ ][ ] coding style is not worth the trouble IMO. But to each his/her own, and I include them anyway.

/* Sample mex routine to demonstrate various ways to access an input 2D
 * matrix at the C level.
 *
 * Programmer: James Tursa
 */

/* Includes ----------------------------------------------------------- */

#include "mex.h"

/* Macros ------------------------------------------------------------- */

#define VALUES(i,j) values[(i)+(j)*m]

/* Gateway ------------------------------------------------------------ */

void mexFunction(int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[])
{
    size_t nChannels, nSteps, i, j, m, n, mn;
    double *values, *values_copy, *pr;
    double **values_matrix;

/* Argument checks */

      if( nlhs ) {
          mexErrMsgTxt("Too many outputs.");
      }
      if( nrhs != 1 || !mxIsDouble(prhs[0]) || mxIsComplex(prhs[0]) ||
          mxIsSparse(prhs[0]) || mxGetNumberOfDimensions(prhs[0]) != 2 ) {
          mexErrMsgTxt("Input must be a real full double 2D matrix.");
      }

/* Get some input argument info */

      m = nChannels = mxGetM(prhs[0]); /* Note that this is used in the macro VALUES */
      n = nSteps = mxGetN(prhs[0]);
      mn = m * n;
      values = mxGetPr(prhs[0]);

/* Here is a way to access the data directly */

      mexPrintf("\nDirect access using [ ] syntax:\n");
      for( j=0; j<nSteps; j++ ) {
          for( i=0; i<nChannels; i++ ) {
              mexPrintf("matrix(%d,%d) = %g\n",i+1,j+1,values[i+j*m]);
          }
      }

/* Here is a way to access the data directly using a macro */

      mexPrintf("\nDirect access using a macro:\n");
      for( j=0; j<nSteps; j++ ) {
          for( i=0; i<nChannels; i++ ) {
              mexPrintf("matrix(%d,%d) = %g\n",i+1,j+1,VALUES(i,j));
          }
      }

/* Here is a way to access the data directly using [ ][ ] syntax */

      mexPrintf("\nDirect access using [ ][ ] syntax:\n");
      values_matrix = (double **) mxMalloc( nSteps * sizeof(*values_matrix) );
      values_matrix[0] = values; /* 1st column pointer */
      for( j=1; j<nSteps; j++ ) {
          values_matrix[j] = values_matrix[j-1] + m; /* other column pointers */
      }
      for( j=0; j<nSteps; j++ ) {
          for( i=0; i<nChannels; i++ ) {
              mexPrintf("matrix(%d,%d) = %g\n",i+1,j+1,values_matrix[j][i]); /* Note [j][i] order */
          }
      }
      mxFree(values_matrix);

/* Here is a way to copy the data to row-ordered memory to use [ ][ ] syntax on the copy */
/* Note that using this method, the copied data is guaranteed to be contiguous in memory */
/* This is not worth it IMO since you basically have to transpose the data in order to   */
/* access it in the natural [ ][ ] C row-ordered syntax style ... quite inefficent use   */
/* of resources simply to get this coding style benefit.                                 */

      mexPrintf("\nCopy access using [ ][ ] syntax:\n");
      values_copy = (double *) mxMalloc( mn * sizeof(*values_copy) ); /* one contiguous block */
      values_matrix = (double **) mxMalloc( nChannels * sizeof(*values_matrix) );
      values_matrix[0] = values_copy; /* 1st row pointer */
      for( i=1; i<nChannels; i++ ) {
          values_matrix[i] = values_matrix[i-1] + n; /* other row pointers */
      }
      pr = values;
      for( j=0; j<nSteps; j++ ) {
          for( i=0; i<nChannels; i++ ) {
              values_matrix[i][j] = *pr++; /* copy the column data into rows */
          }
      }
      for( j=0; j<nSteps; j++ ) {
          for( i=0; i<nChannels; i++ ) {
              mexPrintf("matrix(%d,%d) = %g\n",i+1,j+1,values_matrix[i][j]); /* Note [i][j] order */
          }
      }
      mxFree(values_matrix);
      mxFree(values_copy);
  }

And a sample run using this routine:

>> x = reshape(1:6,2,3)
x =
     1     3     5
     2     4     6
>> matrix_access(x)

Direct access using [ ] syntax:
matrix(1,1) = 1
matrix(2,1) = 2
matrix(1,2) = 3
matrix(2,2) = 4
matrix(1,3) = 5
matrix(2,3) = 6

Direct access using a macro:
matrix(1,1) = 1
matrix(2,1) = 2
matrix(1,2) = 3
matrix(2,2) = 4
matrix(1,3) = 5
matrix(2,3) = 6

Direct access using [ ][ ] syntax:
matrix(1,1) = 1
matrix(2,1) = 2
matrix(1,2) = 3
matrix(2,2) = 4
matrix(1,3) = 5
matrix(2,3) = 6

Copy access using [ ][ ] syntax:
matrix(1,1) = 1
matrix(2,1) = 2
matrix(1,2) = 3
matrix(2,2) = 4
matrix(1,3) = 5
matrix(2,3) = 6

[MaFo]

That is perfect, many thanks for your very complete reply!

Answer 2

[Jan]

const size_t m = mxGetM(prhs[0]);
const size_t n = mxGetN(prhs[0]);

Now m and n are 1, because the first input is a scalar.

In

double** x = (double**)mxCalloc(n, m);

you allocate memory for n elements of size m bytes, which is 1 byte.

x[i] = (double*)mxCalloc(...)

writes a pointer to a double, which has 32 or 64 bits depending on the system, to an element you reserved 1 byte for. This should crash Matlab.

Try this:

void mexFunction(int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[])
{
const size_t m = (size_t) mxGetData(prhs[0]);
const size_t n = (size_t) mxGetData(prhs[1]);

double** x = (double**)mxCalloc(n, sizeof(double *));
for (size_t i = 0; i < n; i++)
  x[i] = (double*) mxCalloc(m, sizeof(double));

for (size_t i = 0; i < n; i++)
  mxFree(x[i]);

mxFree(x);
}

[MaFo]

Thanks for your quick reply.

When I link Matlab to Visual Studio and run the Matlab command above in debug mode, I get m = 3, n = 51, as expected. Interestingly enough, I can run that Matlab command several times via Visual Studio debugging, without crashing Matlab at all. And even after stopping VS debugging, it continues to work fine. If I close and restart Matlab, run the same command with the same mex ... it crashes again!

Would you advise another method to create a 2D matrix of doubles in the C code (corresponding to the one created in Matlab and passed as an argument to the mex)?

[MaFo]

I've tried your proposal, using:

double** x = (double**)mxCalloc(n, sizeof(double *));

but it still crashes Matlab when executing:

n = 51; x = zeros(3,n); myMex(x)

[James Tursa]

I think Jan had a typo. Go back to this:

  const size_t m = mxGetM(prhs[0]);
  const size_t n = mxGetN(prhs[0]);

That being said, this is still somewhat messy code IMO. What is the ultimate goal here? Will you be copying data back & forth between mxArray variables and your dynamically allocated memory? Are you just trying to learn how to use the double bracket [ ][ ] syntax with allocated memory? Or what? There may be better ways of going about things depending on what the end goal is. (e.g., with your method the data for this 2D matrix is not guaranteed to be contiguous in memory, but there are other methods of allocation that will guarantee this)

[MaFo]

Oh right, I didn't spot the typo, thanks for correcting. However now I get a "Out of memory" error in Matlab.

I'll try to clarify what I'm trying to do there: I have a number of channels for a number of steps, as a 2D matrix in Matlab (let's say nChannels x nSteps, with each size being unknown in advance). In the C code, I'd like to have easy access of the value of each channel at each step.

The complete code I was using looked like this, which I had simplified to the minimum which still showed the crash for demonstration purposes:

const size_t nChannels = mxGetM(prhs[0]);
const size_t nSteps = mxGetN(prhs[0]);
double** values = NULL;
values = (double**)mxCalloc(nSteps, nChannels);
for (int i = 0; i < nSteps; i++)
      values[i] = (double*)mxCalloc(nChannels, sizeof(double));
for (int col = 0; col < nSteps; col++)
{
      for (int row = 0; row < nChannels; row++)
            values[col][row] = mxGetPr(prhs[0])[row + col*nChannels];
}

[some code using values as a normal 2D matrix]

for (int i = 0; i < nChannels; i++)
      mxFree(values[i]);
mxFree(values);

I guess I could also just write another C function, which would pass the row and column required, and return the value directly from prhs[0].

Would you have a better suggestion on how to do that? If so, I'd be delighted to know it, as I'm still very new to mex and eager to learn, thanks.