MEX - how to deepcopy returned data so MATLAB does not free it?

I have code written in C that I successfully compiled to MEX, but I have trouble with exchanging data between the C part and MATLAB.

My C code creates a structure that I return to MATLAB, and then after some time, MATLAB returns that structure back to the C code, but the data in the structure is lost by then (I suspect MATLAB has probably freed the memory).

What I do is basically (C):

// create a "Message" structure somewhere in the C code
MessageStruct *message = calloc(1, sizeof(MessageStruct));
message->type = 1; // set some member of the struct

// create a returnable message using mxCalloc, so the original memory can be freed
MessageStruct *returnableMessage = mxCalloc(1, sizeof(MessageStruct));

// copy the content
memcpy(returnableMessage, message, sizeof(MessageStruct));

// create a structure that can be returned (in reality there are more members than just one)
const char *fieldnames[1];
fieldnames[0] = (char*)mxMalloc(20);
memcpy(fieldnames[0],"type",sizeof("type"));
plhs[0] = mxCreateStructMatrix(1,1,1,fieldnames);
mxFree( fieldnames[0] );

// create mxArray and set the field of the output
mxArray *type = mxCreateDoubleScalar(returnableMessage->type);
mxSetFieldByNumber(plhs[0],0,0, type);

// free the original message and leave freeing the returnableMessage to MATLAB
free(message);

In MATLAB I get the struct by calling the corresponding MEX function and save it in a cell array:

msg = myMexFun();
allMessages{end+1, 1} = msg; % this is where I feel I have to deepcopy the data 

So far, it works. The message contains the correct data.

But then, after a while, I want to return the message back to C, but the data is gone and the struct is empty.

How could I deepcopy the data from the message to the cell array, and not only store a pointer to the original data that probably gets freed then? I want to be able to free the memory myself by deleting the element in the cell array within MATLAB.

[Jan]

allMessages{end+1, 1} = msg;

This is not a deep copy, but a shared data copy.

You have posted the working part of the code. Of course the problem is contai8ned in the not working part: What exactly is the code used for "I want to return the message back to C"?

[Robin Pape]

I have not figured that out yet, but it will probably be like this (if this is wrong, I also appreciate any help here):

// struct is passed from MATLAB to C in "prhs"
mxArray *type = mxGetField(prhs[0], 0, "type");
int32_t *ctype = (int32_t*) mxGetData(type);

MessageStruct *message = calloc(1, sizeof(MessageStruct));
message->type = *ctype;

But I think the problem has to be already contained in the original code, because the data from the struct already vanishes in MATLAB. So by the time I want to return the struct back to C, the data is already gone.

[Jan]

The contents of the field was a double initially. Now you convert the pointer to a int32. This is a bad idea.

The purpose of the code in the question is unclear. "message" and "returnableMessage" could be simply omitted. This double indirection looks useless.

This is dangerous:

fieldnames[0] = (char*)mxMalloc(20);
memcpy(fieldnames[0],"type",sizeof("type"));

It is not guaranteed, that the string is \0 terminated.

What does "the data is already gone" means exactly? Please post a minimal working example.

[Robin Pape]

EDIT: okay, I realize that I should have written "%f" in the mexPrintf-function instead of "%d". Changed this and now the minimal example works. I will see if that fixes the problem in my code, too.

The content of the field in my C-struct is int32, so I think it should be fine. Why do you think it was double?

The double indirection is necessary, because the message is created in different parts of the program. In this example it is useless, yes. I just thought I'd include it anyway.

The creation of the fieldnames comes from MathWorks: https://www.mathworks.com/matlabcentral/answers/97352-how-do-i-create-a-structure-array-from-a-c-mex-file-and-pass-it-to-matlab

Here is a simple minimal example (I copied most of the code from https://www.mathworks.com/matlabcentral/answers/312550-struct-as-input-to-mex-file).

#include "mex.h"
#include "matrix.h"

void mexFunction(int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[]) {
    double *tmp;
    mwIndex idx = 0;
    int ifield, nfields;
    const char **fname;       /* pointers to field names */
    nfields = mxGetNumberOfFields(prhs[0]);
    for (ifield=0; ifield< nfields; ifield++){
        tmp = mxGetPr(mxGetFieldByNumber(prhs[0],idx,ifield));
        mexPrintf("Number: %d \n", *tmp);
    };
};

When I compile it with mex and then run it like

myStruct.a = 3;
myStruct.b = 5;
minimalExample(myStruct)

I would expect it to print

Number: 3
Number: 5

But it prints

Number: 0
Number: 0

which is the same as in my code.

[James Tursa]

@Robin Pape

"The content of the field in my C-struct is int32, so I think it should be fine. Why do you think it was double?"

This code coverts returnableMessage->type into a double and stores it in the returned mxArray:

mxArray *type = mxCreateDoubleScalar(returnableMessage->type);
mxSetFieldByNumber(plhs[0],0,0, type);

Then this code seems to get the same MATLAB struct and treat this double as an int32 through pointer type punning:

mxArray *type = mxGetField(prhs[0], 0, "type");
int32_t *ctype = (int32_t*) mxGetData(type);

Hence Jan's comment. You appear to be treating a 64-bit floating point bit pattern as a 32-bit integer.

[Robin Pape]

Okay, got it. It works now, the problem was probably a combination of the incorrect data type and me forgetting one mxGetPr()...

Thank you!