MATLAB: Fast initialization of cell array of strings mex

mexspeed

I'm looking to initialize a cell array of strings in mex as quickly as possible from a long array of characters with an additional array of the locations of starts and stop from which to grab the strings. Any tips on ways of doing this quickly in Matlab?

I am planning on doing roughly the following:

intialize with mxCreateCellArray
initialize a cell with empty values using mxCreateCharArray – I think that using an empty value will prevent any initialization overhead. It would also be great if I could create a bunch of mxArray headers quickly in matlab without having to call a function for each one.
populate the cell data (string value) using string data that is 2 bytes per character and using mxSetData,mxSetM,mxSetN – here it seems that a smart memory allocator would allow initializing a large block of memory and then breaking it into smaller chunks, rather than individually requesting memory from the OS for each string

Best Answer

So, sounds like you have a single array of char data in your C routine, with a second int array that contains start/stop locations. I assume you know how many strings are involved up front from the int array. So just use mxCreateCellArray and then loop through your strings with mxCreateString and mxSetCell. It is unclear to me why you think you need mxCreateNumericArray for anything, since it is OK to have a NULL cell element for an empty cell (that's what MATLAB does at the m-file level). Also it is unclear to me what kind of speed/resource advantage you think you will get by using mxSetData, mxSetM, and mxSetN in some way (unless perhaps the strings in your char array are not individually null terminated?). Can you elaborate? Are all of the strings unique or are some of them shared among multiple cell elements?

I don't know how to create a bunch of mxArray's en masse using the official API functions. You have to do it one at a time.

Related Solutions

MATLAB: Contiguous memory for complex arrays in mex

Yes and No. It is easily possible to physically do this, but the clearing of such a variable will likely crash MATLAB if you are not very careful. The outline is as follows.

In the mex routine create a double array that is sized to hold all of your intended complex data. E.g., if you want a 1x5 complex array then create a double array that is 1x10. Then manually use mxSetN to change the column size to 5. Then pick the midpoint of the real data area and use mxSetPi to set the imaginary data pointer to that address. That will create a complex mxArray variable with the real and imaginary parts contiguous.

This will work fine up until the point that MATLAB tries to clear this variable from memory. Then it will try to free the address you just set with the mxSetPi function. Since this is not a valid address to free, the results are unpredictable and MATLAB will likely crash.

The only robust solution I can think of is to manually create a shared data copy of this variable, make it persistent, and keep this shared data copy inside the mex routine so MATLAB cannot try to clear it. Then use a mexAtExit function to manually reverse the process, use mxSetPi with a NULL, and then clear the variable. But I will tell you right now that this is very tricky to accomplish and requires that you dig under the hood of the mxArray structure to do some unofficial manipulation. You need to be able to detect when the mxArray is shared with other variables inside your mex routine, etc etc. Not recommended for the faint of heart and not easy to accomplish even for a seasoned programmer IMO.

You might be able to get away with it if you can keep all the operations inside the mex routine so that you can carefully manage all of the operations on the variable to ensure there is no shared data copy of it floating around in memory elsewhere, and then manually fix & clear it yourself inside the mex routine.

What operations will you be doing with this variable?

MATLAB: How to use the mxCreateCharArray routine in the C-Mex function

The mxCreateCharArray routine is similar to the mxCreateNumericArray routine in the sense that they both create multidimensional arrays. The first is an array of characters and the second is different data types.

The lines of code below demonstrate an example with mxCreateCharArray:

/*Filename: TEST.C*/
#include <string.h>
#include "mex.h"
#define TOTAL_ELEMENTS 4
void
mexFunction(int nlhs,mxArray *plhs[],int nrhs,const mxArray *prhs[])
{
      int bytes_to_copy;
      mxChar *dataptr;
      mxChar data[]={'a','b','c','d'};
      int dims[] = {2, 2};
      /* Check for proper number of input and output arguments */    
      if (nrhs > 1) {
mexErrMsgTxt("Too many input arguments.");
      } 
      if(nlhs > 1){
mexErrMsgTxt("Too many output arguments.");
      }    
      /* Create a 2-Dimensional string mxArray. */
      plhs[0]= mxCreateCharArray(2, (const int *)dims);  
      /* populate the real part of the created array */   
      dataptr = (mxChar *)mxGetData(plhs[0]);   
      bytes_to_copy = TOTAL_ELEMENTS * mxGetElementSize(plhs[0]);    
      memcpy(dataptr,data,bytes_to_copy);
}

At the MATLAB Command prompt you will get:

 >> mex test.c
 >> test
 ans =
 ac
 bd

Best Answer

Related Solutions

MATLAB: Contiguous memory for complex arrays in mex

MATLAB: How to use the mxCreateCharArray routine in the C-Mex function

Related Question