MATLAB: What libraries should I link against when creating a managed application which calls a MATLAB Compiler 4.5 (R2006b) generated shared library

MATLAB Compilerunmanaged

I have created a shared library with MATLAB Compiler. I am calling this library from C#. In order to create the mxArrays which need to be passed to these functions, I have imported functions from libmx.dll such as mxCreateDoubleMatrix as follows:

 [DllImport("libmx.dll")]
 private static extern IntPtr mxCreateDoubleMatrix(int m, int n, Complexity complexity);

When I run my application I receive segmentation violations.

Best Answer

The only MathWorks libraries which you should link against when calling a C/C++ shared library are the appropriate mclmcrrt library for your platform and version and the shared library which was generated by MATLAB Compiler. This is because all access to the MATLAB Compiler Runtime (MCR) (including the creation and access of mxArrays) must be marshaled through the mclmcrrt library for thread safety reasons.

For example on 32-bit Windows for MATLAB Compiler 4.6 (R2007a) this means linking against mwmclmcrrt76.dll. If you are implicitly linking (using load time dynamic linking) this means linking against the import library mclmcrrt.lib.

On a 32-bit Linux platform for MATLAB Compiler 4.6 (R2007a) this means linking against libmwmcrmcrrtso.7.6.

For explicit linking (run-time dynamic linking) the situation is more complicated because of a compatibility layer introduced in the mxArray API in MATLAB 7.3 (R2006b) for support of large arrays. The changes to the API required creation of two sets of functions *_700 and *_730 (for example mxCreateDoubleMatrix_700 and mxCreateDoubleMatrix_730). In general, you should use the *_730 functions for all applications which call MATLAB Compiler generated shared libraries. The *_700 functions are for backward compatibility.

In the previous example, where explicit linking is used from C#, with MATLAB Compiler 4.6 (R2007a) the import statement should read

 [DllImport("mclmcrrt76.dll")]
 private static extern IntPtr mxCreateDoubleMatrix_730([In]Int32 numRows, [In]Int32 numCols, [In]Int32 mxComplexity);

Related Solutions

MATLAB: How to create a C shared library using MATLAB Compiler 6.5 (R13) and use it with the C application

The following steps create a C shared library on UNIX:

1. Compile your MATLAB files into a shared library (on UNIX)

mcc -t -L C -W lib:libFile -T link:lib -h <matlab-file> libmmfile.mlib

The -t option tells the MATLAB Compiler to translate the MATLAB code to the target language.

The -L option specifies the target language, which is chosen to be C.

The -W option tells the MATLAB Compiler to build a wrapper for libraries with the name specified after "lib:".

The -T option tellls the compiler what stage should be reached and for what intentions. Here we want to link our application together to build a shared library.

Specifying the libmmfile.mlib file tells the MATLAB Compiler to link against the MATLAB file Math routines that have already been precompiled into shared libraries when necessary.

This step will produce libFile.so, libFile.exports, libFile.h and libFile.mlib. You can add the

-g switch to produce a shared library suitable for debugging.

2. Make sure to call the initialization and termination routines from your code before calling any of the MATLAB Files that are compiled. The initialization routine for the libFile.so file would be:

 libFileInitialize();

And the termination routine would be:

 libFileTerminate();

All the routines (symbols) defined in 'libFile.so' will be in the libFile.export file and the prototypes for these routines will be libFile.h.

3. You can call the functions compiled from the MATLAB code by invoking mlf<MATLAB-file>(...), from your own C code. Where MATLAB-file represents the name of the original MATLAB-file with the first letter in upper case.

4. Compile your program and link against the MATLAB C Math Libraries as well as the libFile library created above.

Here is an example that illustrates the above steps.

Inside the MATLAB environment:

1. Write a MATLAB file function named foo and saved as foo.m that contains the following code:

function y = foo(x)
y = x+1;

2. Use the MATLAB Compiler to compile foo.m into C code that can be included in a C shared library:

mcc -t -L C -W lib:libFoo -T link:lib foo.m libmmfile.mlib

This will generate the following files:

foo.c

foo.h

libFoo.c

libFoo.exports

libFoo.h

libFoo.mlib

libFoo.so

On certain UNIX platforms, the generated shared library file extension would be ".sl".

External to MATLAB:

1. Create the file called foowrap.c that calls the MATLAB Compiler generated shared library:

 /*
  * foowrap.c
  * Calls a MATLAB Compiler generated shared library.
  *
  */
 #include "libFoo.h"
 #include "matlab.h"
 #include <stdio.h>
 void main(void)
 {
     mxArray *x_ptr;
     mxArray *y_ptr;
     double *y;
     double ret;
     /* Create an mxArray to input into mlfFoo */
     x_ptr = mxCreateDoubleScalar(1);
     /* Call the library initialization function */
     libFooInitialize(); 
     /* Call the implementation function */
     y_ptr = mlfFoo(x_ptr);
     /* Call the library termination function */
     libFooTerminate();
     /* The return value from mlfFoo is an mxArray so we must extract the data from it */
     y = mxGetPr(y_ptr);
     ret = *y;
     /* Print a double precision number*/
     printf("The output of foo is %f\n",ret);
 }

2. Compile your application using one of the following methods:

With MBUILD (inside MATLAB):

mbuild foowrap.c -L./ -I./ -lFoo

In the above command, it is assumed that you are running the MBUILD command from the same directory in which you created the shared library. If this is not the case, then the -L and -I options should be followed by the locations of the shared library and the include files respectively.

Without MBUILD (outside MATLAB):

Building outside of MATLAB requires that you specify the locations of the MATLAB header files, the locations of the MATLAB shared libraries and the names of the MATLAB Libraries explicitly. With MBUILD this was not necessary because MBUILD finds and uses these files automatically. Actually, a good way to find these libraries would be to run MBUILD with the "-v" flag and use the compile and linker commands from the verbose output. If you do not have the possibility to execute the MBUILD command in MATLAB in verbose mode, please note that the required libraries to build your application outside MATLAB can be found in the following folders, in which "<mcr_root>" is the folder in which MATLAB Compiler Runtime (MCR) is installed on your computer:

 <mcr_root>/<mcr_version>/extern/lib/glnx86 (or glnxa64)
 <mcr_root>/<mcr_version>/bin/glnx86 (or glnxa64)
 <mcr_root>/<mcr_version>/extern/include

The "<mcr_version>" listed above is the version of the installed MCR. For instance, the MCR version related to MATLAB R2014b is 8.4 and therefore:

 <mcr_version> --> v84

Please refer to the following link for a complete list of MCR versions:

https://www.mathworks.com/matlabcentral/answers/102061-what-is-the-version-of-the-matlab-compiler-runtime-mcr-that-corresponds-to-the-version-of-matlab-c

Below is the command, if you were building using GCC outside MATLAB:

 gcc -o foowrap foowrap.c  -L/<mcr_root>/<mcr_version>/extern/lib/glnx86
 -L/<mcr_root>/<mcr_version>/bin/glnx86 -L./ -I/<mcr_root>/<mcr_version>/extern/include
 -I./ -lmmfile -lmatlb -lmx -lut -lm -lFoo

3. Set the search paths for the dynamic loader to find the shared library. The exact command depends on the exact UNIX operating system and the shell you are running. The following command assumes you are running in a csh shell.

 setenv LD_LIBRARY_PATH <matlabroot>/bin/<arch>:<matlabroot>/extern/bin/
 <arch>:<matlabroot>/sys/os/<arch>/

If the LD_LIBRARY_PATH was previously defined, the command would be:

 setenv LD_LIBRARY_PATH <matlabroot>/bin/<arch>:<matlabroot>/extern/bin/
 <arch>:<matlabroot>/sys/os/<arch>/:$LD_LIBRARY_PATH

4. Run the executable file, "foowrap" that was created:

 [unix]%> foowrap    
 The output of foo is 2.000000

MATLAB: Do I receive errors when trying to compile LOADLIBRARY or run an application that uses LOADLIBRARY with MATLAB Compiler 4.0 (R14)

This change has been incorporated into the documentation in Release 2011a (R2011a). For previous releases, read below for any additional information:

With MATLAB Compiler 4.0 (R14) and later, you can use MATLAB file prototypes as described below to load your library in a compiled application. Note that loading libraries using H-file headers is not supported in compiled applications.

This behavior occurs when LOADLIBRARY is compiled with the header argument as in the statement below:

loadlibrary(library, header)

In order to workaround this issue, execute the following command at the MATLAB commmand prompt:

loadlibrary(library, header, 'mfilename', 'mHeader');

... where mHeader is the name of a MATLAB file (in this case mHeader.m) that you would like to use when loading this library. This step only needs to be performed once to generate an MATLAB file for the library.

Now, in the code that is be compiled, you can call LOADLIBRARY with the following format:

loadlibrary(library, @mHeader, 'alias', alias)

With MATLAB Compiler versions 4.0.1 (R14+) and above, the generated MATLAB file mHeader.m will automatically be included in the CTF file as part of the compilation process. For versions 4.0 of the Compiler (R14) and later, include your library MATLAB file in the compilation with the '-a' option with MCC.

Note: With the MATLAB Compiler 3.0 (R13SP1) and earlier versions you cannot compile calls to LOADLIBRARY because of general restrictions and limitations of the MATLAB Compiler.

If you do not have a header file, the prototype file can be created manually. Follow the example in the documentation to generate a prototype file and modify it to suit the shared library you would like to use:

web([docroot,'/techdoc/ref/loadlibrary.html'])

Best Answer

Related Solutions

MATLAB: How to create a C shared library using MATLAB Compiler 6.5 (R13) and use it with the C application

MATLAB: Do I receive errors when trying to compile LOADLIBRARY or run an application that uses LOADLIBRARY with MATLAB Compiler 4.0 (R14)

Related Question