c++ - How do I profile a MEX-function in Matlab

Question

I have a Mex-function (a function in c++ that you can call from Matlab) that I have written, and I want to profile it using valgrind/kcachegrind. I know how to use valgrind/kcachegrind if you are running a c++ program directly, but is there a way to do this profiling if I am calling the c++ program from Matlab?

Answer 1

Profiling MEX files is tricky since the MEX files are shared libraries. It can not be done on Linux using standard 'gprof' approach - gprof simply does not do that. I tried to use sprof, but I get “PLTREL not found error” - sprof can not be used either. There is a previous post here, but no one gave a final answer.

Luckily, there is a way in which one can do it with valgrind on Linux. First, we need to write 'running' code that loads the mex file, provides the mexFunction symbol for us to call, and sets up the parameters of the MEX file. I have chosen to use the recommended way to do this with MATLAB - using MATLAB engine. The following code (save as test.c) loads a MEX file and finds the mexFunction symbol, loads input data from a file previously saved as 'input.mat' (can be done in MATLAB using save command), and calls the mexFunction.

#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <errno.h>
#include <dlfcn.h>
#include "engine.h"

typedef void (*mexFunction_t)(int nargout, mxArray *pargout [ ], int nargin, const mxArray *pargin[]);

int main(int argc, const char *argv[])

{
  Engine *ep;
  char buff[1024];
  int i;

  /* matlab must be in the PATH! */
  if (!(ep = engOpen("matlab -nodisplay"))) {
    fprintf(stderr, "Can't start MATLAB engine
");
    return -1;
  }
  engOutputBuffer(ep, buff, 1023);

  /* load the mex file */
  if(argc<2){
    fprintf(stderr, "Error. Give full path to the MEX file as input parameter.
");
    return -1;
  }
  void *handle = dlopen(argv[1], RTLD_NOW);
  if(!handle){
    fprintf(stderr, "Error loading MEX file: %s
", strerror(errno));
    return -1;
  }

  /* grab mexFunction handle */
  mexFunction_t mexfunction = (mexFunction_t)dlsym(handle, "mexFunction");
  if(!mexfunction){
    fprintf(stderr, "MEX file does not contain mexFunction
");
    return -1;
  }

  /* load input data - for convenience do that using MATLAB engine */
  /* NOTE: parameters are MEX-file specific, so one has to modify this*/
  /* to fit particular needs */
  engEvalString(ep, "load input.mat");
  mxArray *arg1 = engGetVariable(ep, "Ain");
  mxArray *arg2 = engGetVariable(ep, "opts");
  mxArray *pargout[1] = {0};
  const mxArray *pargin[2] = {arg1, arg2};

  /* execute the mex function */
  mexfunction(1, pargout, 2, pargin);

  /* print the results using MATLAB engine */
  engPutVariable(ep, "result", pargout[0]);
  engEvalString(ep, "result");
  printf("%s
", buff);

  /* cleanup */
  mxDestroyArray(pargout[0]);
  engEvalString(ep, "clear all;");
  dlclose(handle);
  engClose(ep);

  return 0;
}

The MEX file itself should also compiled with the mex -g switch. The above code has to be compiled with mex -g and using engopts.sh as compilation parameters. From MATLAB command line type

mex('-v', '-f', fullfile(matlabroot,...
    'bin','engopts.sh'),...
    'test.c');

or in a standard Linux terminal run

/path/to/matlab/bin/mex -g -f /path/to/matlab/bin/engopts.sh test.c

Profiling the MEX file with valgrind requires running the 'test' program from the command line. In the directory where both test and the MEX file reside type the command:

PATH=$PATH:/path/to/matlab/bin/ LD_LIBRARY_PATH=/path/to/matlab/bin/glnxa64/:/path/to/matlab/sys/os/glnxa64/ valgrind --tool=callgrind ./test ./mex_file.mexa64

Note that the path to MATLAB and correct architecture-dependent library paths need to be set! matlab executable must be present in the PATH, otherwise 'test' will fail.

There is one more catch. MATLAB engine requires csh to be installed on the system (you can use any shell, csh just needs to be present in /bin). So if you don't have it, you have to install it for this to work.