MATLAB: Use function handle in MEX file (serialize it)

function handleinterfaceMATLABmex

What sorts of things can one do with a function handle in a MEX file?

What I'd like to do is extract all the relevant data from an mxArray that represents a function handle in such a way that I could create a different mxArray that will represent the same function handle.

In other words, I'd need to serialize an mxArray function handle.

I need this while building a bridge between MATLAB and another language. I would like to support classes in MATLAB. I can take apart just about any other kind of mxArray and put them back together as there exist mx* functions for these (e.g. mxGetData() for numerical arrays, etc.) So far it's only function handles I couldn't cope with.

EDIT: For this application I can always keep a dictionary of available function handles. I do not need or want to expose the underlying data (which may be a pointer, thus unsafe). But in order to keep a dictionary, I need to be able to at least compare function handles: do two mxArray refer to the same function handle?

Best Answer

You might look into these undocumented API functions:

mxSerialize
mxDeserialize

I have never used them myself, but you can find some information here:

http://stackoverflow.com/questions/4807035/is-it-possible-to-intercept-a-matlab-save-bytestream

I have no idea how these functions would work for a function handle, which can have multiple embedded mxArray data buried within them.

How are you going to deal with classdef objects?

Related Solutions

MATLAB: MxSetData to subset of mxArray

Not without a hack. The reason is as follows:

The API functions mxSetPr, mxSetPi, mxSetData, mxSetImagData, mxSetIr, and mxSetJc etc all check to see if the pointer passed in for the data memory is from the MATLAB Memory Manger allocation list. If it isn't, then the mex routine will crash MATLAB with an assertion fault. In practical terms, this means that you need to individually allocate each memory block using MATLAB API functions ... you can't allocate one big block and then piece it out to multiple mxArray's, and you can't use C native allocated memory either (e.g., can't use malloc and friends).(*)

So, the only way to attach such memory to the data area of an mxArray is to hack into the mxArray structure itself and set the desired pointer manually. But this leaves you in a precarious state, because if MATLAB ever tried to destroy this mxArray (e.g., maybe there is an error return from your mex routine and garbage collection takes place) then MATLAB would crash when it tried to free this memory. So you could do some things with it (e.g., as an input to mexCallMATLAB where you knew the function you were calling would not make a shared data copy of the input). But to be safe you would probably need to protect this mxArray from being garbage collected (i.e., make it persistent and set up a mexAtExit function to clean things up properly), and you would need a way for the mex routine to safely detach the data pointers before this mxArray gets destroyed. Bottom line is that doing this is possible, but very tricky to get things set up so that MATLAB does not crash ... and it requires a lot of hacks.

(*) Note: Earlier versions of MATLAB did not make these checks, so you could get away with using the API functions to set the data pointers with non-MATLAB allocated memory. But you would still be faced with a potential crash if MATLAB ever tried to destroy this mxArray while it was in the invalid state.

MATLAB: How to obtain the memory address for a variable in MATLAB 7.7 (R2008b)

The address of a MATLAB variable can be obtained using a MEX function.

The gateway routine of a MEX function has the following signature:

void mexFunction(int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[]);

Here prhs is an array of right-hand input arguments. It is an array of pointers to type mxArray. When a variable is passed as an input argument to a MEX function, the pointer to that variable is copied into prhs.

For example, if a MEX function, 'myMexFunction', is called using one input argument as shown below:

a = 5;
myMexFunction(a);

the address of the variable 'a' is copied into prhs[0].

The following C-MEX function, "mem_address.c", illustrates how you can obtain the address of each element of a row vector of type double. This code can be expanded to operate on other data-types as well.

#include "mex.h"
void mexFunction(int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[])
{
    double *ptr;
    int i;
    mwSize n;
      /* Function accepts only one input argument */
      if(nrhs > 1)
      {
          mexErrMsgTxt("Only one input argument accepted\n\n");
      }   
      /* This function works only with row vectors */
      if( mxGetM(prhs[0]) > 1 )
      {
          mexErrMsgTxt("Only row vectors are accepted\n\n");
      }
      /* Get the Pointer to the Real Part of the mxArray */
      ptr = mxGetPr(prhs[0]);
      n = mxGetN(prhs[0]);
      mexPrintf("Pointer Address of mxArray = %x\n\n", prhs[0]);
      for(i = 0; i < n; i++)
      {
          mexPrintf("Value of Real Argument at array index %d = %f\n", i, ptr[i]);
          mexPrintf("Pointer Address = %x\n\n", &ptr[i]);
      }
  }

You can MEX this C-file using the following command at the MATLAB prompt:

mex mem_address.c

This will generate a MEX file with an extension depending on your platform. You can run this MEX file as follows:

a = 5;
mem_address(a);

For more information about MEX-files please refer to the following:

https://www.mathworks.com/help/releases/R2019a/matlab/call-mex-file-functions.html

Best Answer

Related Solutions

MATLAB: MxSetData to subset of mxArray

MATLAB: How to obtain the memory address for a variable in MATLAB 7.7 (R2008b)

Related Question