Matlab crashing when evaluating mex

2016 10 27
2 个回答
回答已采纳
更新时间：2016 11 3
8 次查看（30 天）

0 个投票

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.

请先登录，再回答此问题。

 采纳的回答

James Tursa
James Tursa 2016-11-3

1 个投票

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

1 个评论
显示 -1更早的评论 隐藏 -1更早的评论

MaFo
MaFo 2016-11-3
That is perfect, many thanks for your very complete reply!

请先登录，再进行评论。

更多回答（1 个）

Jan
Jan 2016-10-27
编辑：Jan 2016-11-3

1 个投票

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);
}

4 个评论
显示 2更早的评论 隐藏 2更早的评论

MaFo
MaFo 2016-10-27
编辑：MaFo 2016-10-27
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
MaFo 2016-10-28
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
James Tursa 2016-10-28
编辑：James Tursa 2016-10-28
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
MaFo 2016-11-2
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.

请先登录，再进行评论。

类别

在 帮助中心 和 File Exchange 中查找有关 Write C Functions Callable from MATLAB (MEX Files) 的更多信息

标签

Community Treasure Hunt

Find the treasures in MATLAB Central and discover how the community can help you!

Start Hunting!

Translated by