MATLAB: Multithreading with mex functions

mex

The documentation of MATLAB suggests that it is OK to multithread with mex functions as long as as the mex API is not used. Multithreading and mex

The link above shows an example of a simple counter. We deploy a software tool developed in MATLAB. Much of the computationally intensive code is written in separately compiled FORTRAN or C modules. The MATLAB GUI just kicks off the executable and returns control to the user. When the executable is finished it writes the output to an ASCII text file. Is it possible to write a mex file that is kicked off when the executable is kicked off? That mex file would just be a while loop checking for the existence of the output file. Once the output file exists, the mex file would interrupt or notify that the results are ready. This would be better then our current implementation where the user clicks to load the results; if the data is not ready it just responds with an error saying to wait a little longer. Does anybody know if this is possible? The link aboves says that the mex API may not be used which includes simple things like mexPrintf. That makes me think that this may not be possible.

Any suggestions?

Best Answer

I'm not sure if I've interpreted your question correctly, but I think your main problem is working out how to get data back to MatLab asynchronously.

If that is correct, you can start a MatLab timer before firing off your processing app. The timer can poll once per second to check for the existence of the output, then kill itself and fire off some MatLab callback function once the file shows up... You can also do timeouts etc.

-g-

Related Solutions

MATLAB: Using Mex with Classes

One option is to keep your pointer in a high level variable (i.e., global) and set up a mexAtExit function to clean things up when the function is cleared. E.g.,

void *handle = NULL; // not sure of type here ... you didn't declare it above
void clear_handle(void)
{
    if( handle ) {
        exit_hw(handle);
        handle = NULL;
    }
}
void mexFunction( ...parms... )
{
if( !handle ) {
    handle = init_hw();
    if( !handle ) {
        mexErrMsgTxt("Unable to init handle.");
    }
    mexAtExit(clear_handle);
}
alloc_mem(handle);
get_data();
copy_to_mxDoubleMatrix();
}

Only on the first call init_hw is called and the handle remembered. When you clear this routine from memory, exit_hw is called to clean things up.

MATLAB: Is it possible to start new threads from a C-MEX file

There is no supported implementation of calling a single session of MATLAB in separate threads. However, it is possible to create new threads from a C MEX-file in a supported fashion; as long as those threads do not access MATLAB in any way. Since the MEX API is not thread safe, no MEX API functions can be used in the spawned threads including printf because printf is defined to be mexPrintf in the mex.h header file.

Below are two examples of multithreaded MEX functions on Windows. You can also create multithreaded MEX functions on other platforms, but the API functions for creating threads will be different.

The following is an example of a C MEX-file that creates a new thread using the function _beginthreadex. For details on this function, see:

https://www.microsoft.com/en-us/download/details.aspx?id=55984

The code below is adapted from the second example from the link above. Note that this example requires a Microsoft compiler.

#include "mex.h"
#include <windows.h>
#include <stdio.h>
#include <process.h>
unsigned Counter; 
unsigned __stdcall SecondThreadFunc( void* pArguments )
{
    while ( Counter < 1000000 )
        Counter++;
    _endthreadex( 0 );
    return 0;
} 
void mexFunction( int nlhs, mxArray *plhs[], 
  int nrhs, const mxArray*prhs[] )
     
{ 
    HANDLE hThread;
    unsigned threadID;
    printf( "Creating second thread...\n" );
    /* Create the second thread.*/
    hThread = (HANDLE)_beginthreadex( NULL, 0, &SecondThreadFunc, NULL, 0, &threadID );
    /* Wait until second thread terminates. If you comment out the line
     * below, Counter will not be correct because the thread has not
     * terminated, and Counter most likely has not been incremented to
     * 1000000 yet.*/
    WaitForSingleObject( hThread, INFINITE );
    printf( "Counter should be 1000000; it is-> %d\n", Counter );
    /* Destroy the thread object. */
    CloseHandle( hThread );
    return;
}

Save the code above into a file named create_thread.c. Then execute:\n

mex -setup

and choose a Microsoft compiler. Compile the C-MEX function with:\n

mex create_thread.c

If you execute the MEX-function from the MATLAB command line, you should see the following screen output:\n

Creating second thread...
Counter should be 1000000; it is-> 1000000

It is also possible to have the second thread continue to execute even after the function mexFunction has returned to the MATLAB command prompt. You can then call back into mexFunction and get the results from the second thread.

In this second example, the first time the MEX function is called, pass in the argument 'Init'. This will spawn a second thread. The second time the MEX function is called pass in the argument 'Finish' (or any other string). This will print the counter variable and clean up the thread.\n

#include "mex.h"
#include <windows.h>
#include <stdio.h>
#include <process.h>
#include <string.h>
/*These global variables will be accessible to both threads and will exist
 *in the MEX function through multiple calls to the MEX function */
static unsigned Counter;
static HANDLE hThread=NULL;
/*The second thread should not try to communicate with MATLAB at all. 
 *This includes the use of mexPrintf, which attempts to print to the
 *MATLAB command window. */
unsigned __stdcall SecondThreadFunc( void* pArguments ) {
    /* loop for 20 seconds */
    
    while ( Counter < 20 ) {
        Counter++;
        Sleep( 1000L );
    }
    
    _endthreadex( 0 );
    return 0;
}
void mexFunction( int nlhs, mxArray *plhs[], int nrhs, const mxArray*prhs[]) {
    unsigned threadID;
    char *cmd;
    
    /*  check for proper number of arguments */
    if(nrhs!=1)
        mexErrMsgTxt("One input required.");
    
    /* check to make sure the first input argument is a string */
    if (!mxIsChar(prhs[0]))
        mexErrMsgTxt("Input must be a string.");
    
    /* get command from first input */
    cmd = mxArrayToString(prhs[0]);
    /* if command is "Init", start the thread, otherwise wait for thread
     * to complete */
    if (!strcmp(cmd,"Init")) {
        
        /* make sure thread was not started using "mex locked" state */
        if (mexIsLocked())
            mexErrMsgTxt("Thread already initialized.");
        /* lock thread so that no-one accidentally clears function */
        mexLock();
                        
        /* Create the second thread. */
        mexPrintf( "Creating second thread...\n" );
        Counter = 0;
        hThread = (HANDLE)_beginthreadex( NULL, 0, &SecondThreadFunc, NULL, 0, &threadID );
    }
    else {
        /* make sure that the thread was started using "mex locked" status*/
        if (!mexIsLocked())
            mexErrMsgTxt("Thread not initialized yet."); /*This function will return control to MATLAB*/
        /* wait for thread to finish and get result */
        WaitForSingleObject( hThread, INFINITE );
        mexPrintf( "Counter should be 20; it is-> %d\n", Counter );
        
        /* Destroy the thread object, free memory, and unlock mex. */
        CloseHandle( hThread );
        mexUnlock();
    }
    return;
}

Save the code above into a file named create_async.c. Then execute:\n

mex create_async.c

Execute the following command to spawn the second thread\n

create_async Init

and you should see the following message\n

Creating second thread...

Next, execute the following command to get the results\n

create_async Finish

The program will pause until the second thread has finished executing, this will be approximately 20 seconds from the time the thread was created. You should then see the following message\n

Counter should be 20; it is-> 20

Best Answer

Related Solutions

MATLAB: Using Mex with Classes

MATLAB: Is it possible to start new threads from a C-MEX file

Related Question