Size in bytes of a mxCreateStructMatrix

I'm using the MATLAB engine in C++ creating different arrays, structs etc. and parsing them to MATLAB.

I have created a rather complex structure (arrays, strings, and structures within structures etc.) using the mxCreateStructMatrix.

Now I would like to know the actual size in bytes of this combined MATLAB structure.

By knowing the size I would like to be able to do something like this (pseudo code):

mxArray* pmxStruct = mxCreateStructMatrix(1,1,num_fs,fs)
=== set all the fields ===
long sizeStruct = GETSIZEOFMXSTRUCT(pmxStruct)
BYTE *pBytes = new byte[sizeStruct]
memcpy(pBytes,pmxStruct,sizeStruct)
mxArray* pmxNew = (mxArray*)pBytes

Thanks :-)

-cpede

Answer 1

[Jan]

This is a bad idea. Although you would copy the header of the struct, you'd duplicate the pointers to the data. Then it will need only some further actions to let the memory manager crash.

If you want a shared data copy, use mxCreateSharedDataCopy, if you want to duplicate the header and the data use mxDuplicateArray.

[cpede]

But what I want is to have the structure in one continuous data block with a start pointer and a size. If I have such a pointer I could e.g. write this to a binary file, and read it back and get the correct MATLAB structure back.

-cpede

[Jan]

Sorry, this is not the way structs are stored in Matlab, and this concerns the numerical data types also as well as the cells. The mxArrays are not stored as contiguous byte streams in the memory and there are very good reasons for this.

I assume you are looking for the undocumented function mxSerialize. There are some other tools (as M-files) to serialize data in the FileExchange. Simply look there for "serialize" or ask Google.

[Bo]

Hmm, looking at e.g. the function I could imagine something like this:

mxArray* pByteArray = mxSerialize(pmxStruct);
size_t nElements = mxGetNumberOfElements(pByteArray);
UINT8 *pbData = new UINT8[nElements];
::CopyMemory(pbData,pByteArray,nElements*sizeof(UINT8));
mxArray* pByteArrayNew = mxDeserialize(pbData,nElements*sizeof(UINT8));
delete [] pbData;

But since mxSerialize makes a uint8 mxArray I maybe looses some of the information from my struct? Maybe only the data and not the header information is serialized? So I'm back to not having the size of the full mxArray! And since my original mxArray comes from a struct matrix, I don't know if it is capable of getting this back?

-cpede

[Friedrich]

mxSerialize converts all information into a byte stream. So no information are lost.

Why dont you create a mat file? ther is a mat file C/C++ API where you can easily create a mat file which contains your complex struct.

[Jan]

@Bo: Inside computers everything is stored in bytes, so there is no reason to assume that the byte stream looses any information. Do not confuse this with converting a double value to an uint8, e.g. x = uint8(pi). But the serialization means: y = typecast(pi, 'uint8') such that 8 bytes are replied, which carry the same information as the original double value.

Note that a struct contains fields, which are mxArrays again. And even their headers are stored in the serialized byte stream also. So there is no reason to assume, that it matters, if the variable is a scalar double or a struct array. Internally both look very similar: While numerical array contain a pointer to the data (real and imaginary parts, to be exact), struct arrays contain a pointer to an array of pointers to the field's data.

[James Tursa]

@cpede: See this thread for more info on mxSerialize and mxDeserialize:

http://www.mathworks.com/matlabcentral/answers/71028-use-function-handle-in-mex-file-serialize-it

[cpede]

Ok, the mxSerialize serializes all information into a uint8 array. Then I can assume that the byte size of this array is NumberOfElements*sizeof(uint8), - correct ?

So what could be wrong with following code:

mxArray* pByteArray = mxSerialize(pmxStruct);
size_t nElements = mxGetNumberOfElements(pByteArray);
UINT8 *pbData = new UINT8[nElements];
::CopyMemory(pbData,pByteArray,nElements*sizeof(UINT8));
mxArray* pByteArrayNew = mxDeserialize(pbData,nElements*sizeof(UINT8));
delete [] pbData;

Maybe mxDeserialize requires, that the returning mxArray is already allocated?

-cpede

[James Tursa]

1) "Then I can assume that the byte size of this array is NumberOfElements*sizeof(uint8), - correct ?"

Yes ... that is the size of the serialized array contained in the data of the pByteArray mxArray variable.

2) "So what could be wrong with following code: ..."

What is wrong is you are not copying the data of the serialized mxArray, which is where the information is. I.e., this line

::CopyMemory(pbData,pByteArray,nElements*sizeof(UINT8));

should be this instead:

::CopyMemory(pbData,mxGetData(pByteArray),nElements*sizeof(UINT8));

3) "Maybe mxDeserialize requires, that the returning mxArray is already allocated?"

No. mxDeserialize will allocate the variable itself. If you try to pre-allocate it you will just create a memory leak.

[Jan]

@cpede and Bo: Are you working together?

[cpede]

Yes we are, and mxGetData will probably make the difference, thanks.

-cpede