Call Reentrant Code — Multithreaded with Persistent Data (UNIX Only)

This example requires POSIX thread (pthread) libraries and, therefore, runs only on UNIX® platforms. It is a multithreaded example that uses persistent data. Two threads call the MATLAB® function matrix_exp with different sets of input data.

MATLAB Code for This Example

function [Y,numTimes] = matrix_exp(X) %#codegen
    %
    % The function matrix_exp computes matrix exponential 
    % of the input matrix using Taylor series and returns 
    % the computed output. It also returns the number of 
    % times this function has been called.
    %
    
    persistent count;
    if isempty(count)
        count = 0;
    end
    count = count+1;
    
    E = zeros(size(X));
    F = eye(size(X));
    k = 1;
    while norm(E+F-E,1) > 0
        E = E + F;
        F = X*F/k;
        k = k+1;
    end
    Y = E ;
    
    numTimes = count;

Provide a Main Function

To call reentrant code that uses persistent data, provide a main function that:

  • Includes the header file matrix_exp.h.

  • For each thread, allocates memory for stack data.

  • Allocates memory for persistent data, once per root process if threads share data, and once per thread otherwise.

  • Calls the matrix_exp_initialize housekeeping function. For more information, see Deploy Generated Code.

  • Calls matrix_exp.

  • Calls matrix_exp_terminate.

  • Frees the memory used for stack and persistent data.

For this example, main.c contains: 

#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>
#include "matrix_exp.h"
#include "matrix_exp_initialize.h"
#include "matrix_exp_terminate.h"
#include "rtwtypes.h"
#define NUMELEMENTS (160*160)

typedef struct {
    real_T in[NUMELEMENTS];
    real_T out[NUMELEMENTS];
    real_T numTimes;
    matrix_expStackData* spillData;
} IODATA;

/*The thread_function calls the matrix_exp function written in MATLAB*/
void *thread_function(void *dummyPtr) {
  IODATA *myIOData = (IODATA*)dummyPtr;
  matrix_exp_initialize(myIOData->spillData);
  matrix_exp(myIOData->spillData, myIOData->in, myIOData->out, &myIOData>numTimes);
  printf("Number of times function matrix_exp is called is %g\n",myIOData->numTimes);
  matrix_exp_terminate();
}

int main() {
  pthread_t thread1, thread2;
  int  iret1, iret2;
  IODATA data1;
  IODATA data2;
  int32_T i;
    
  /*Initializing data for passing to the 2 threads*/
  matrix_expPersistentData* pd1 =
     (matrix_expPersistentData*)calloc(1,sizeof(matrix_expPersistentData));
  matrix_expPersistentData* pd2 =
     (matrix_expPersistentData*)calloc(1,sizeof(matrix_expPersistentData));
  matrix_expStackData* sd1 = (matrix_expStackData*)calloc(1,sizeof(matrix_expStackData));   
  matrix_expStackData* sd2 = (matrix_expStackData*)calloc(1,sizeof(matrix_expStackData));   
     
  sd1->pd = pd1;
  sd2->pd = pd2;
  data1.spillData = sd1;
  data2.spillData = sd2;
        
  for (i=0;i<NUMELEMENTS;i++) {
      data1.in[i] = 1;
      data1.out[i] = 0;
      data2.in[i] = 1.1;
      data2.out[i] = 0;
  }
    
  data1.numTimes = 0;
  data2.numTimes = 0;
    
  /*Initializing the 2 threads and passing required data to the thread functions*/
  printf("Starting thread 1...\n");
  iret1 = pthread_create(&thread1, NULL, thread_function, (void*) &data1);
  if (iret1 != 0){
		 perror("Thread 1 creation failed.");
exit(EXIT_FAILURE);
	}

  printf("Starting thread 2...\n");
  iret2 = pthread_create(&thread2, NULL, thread_function, (void*) &data2);
  if (iret2 != 0){
      perror( "Thread 2 creation failed.");
      exit(EXIT_FAILURE);
  }
    
  /*Wait for both the threads to finish execution*/
  iret1 = pthread_join(thread1, NULL);
  if (iret1 != 0){
		 perror( "Thread 1 join failed.");
exit(EXIT_FAILURE);
	}
    
  iret2 = pthread_join(thread2, NULL);
  if (iret2 != 0){
		 perror( "Thread 2 join failed.");
exit(EXIT_FAILURE);
	}
    
  free(sd1);
  free(sd2);
  free(pd1);
  free(pd2);
    
  printf("Finished Execution!\n");
  return(0);
    
}

Generate Reentrant C Code

To generate code, run the following script at the MATLAB command prompt.

% This example can only be run on Unix platforms
if ~isunix
  error('This example requires pthread libraries and can only be run on Unix.');
end

% Setting the options for the Config object

% Specify an ERT target
cfg = coder.config('exe');

% Enable reentrant code generation
cfg.MultiInstanceCode = true;

% Set the post code generation command to be the 'setbuildargs' function
cfg.PostCodeGenCommand = 'setbuildargs(buildInfo)';

% Compiling 
codegen -config cfg main.c  -report matrix_exp.m -args ones(160,160)

This script:

  • Generates an error message if the example is not running on a UNIX platform.

  • Creates a code generation configuration object for generation of an executable.

  • Enables the MultiInstanceCode option to generate reusable, reentrant code.

  • Uses the PostCodeGenCommand option to set the post-code-generation command to be the setbuildargs function. This function sets the -lpthread flag to specify that the build include the pthread library. 

    function setbuildargs(buildInfo)
% The example being compiled requires pthread support.
% The -lpthread flag requests that the pthread library 
% be included in the build   
    linkFlags = {'-lpthread'};
    addLinkFlags(buildInfo, linkFlags);

    For more information, see Build Process Customization.

  • Invokes codegen with the following options:

    • -config to pass in the code generation configuration object cfg.

    • main.c to include this file in the compilation.

    • -report to create a code generation report.

    • -args to specify an example input with class, size, and complexity.

Examine the Generated Code

codegen generates a header file matrix_exp_types.h, which defines:

  • The matrix_expStackData global structure that contains local variables that are too large to fit on the stack and a pointer to the matrix_expPersistentData global structure.

  • The matrix_expPersistentData global structure that contains persistent data.

/*
 * matrix_exp_types.h
 *
 * Code generation for function 'matrix_exp'
 *
 */

#ifndef __MATRIX_EXP_TYPES_H__
#define __MATRIX_EXP_TYPES_H__

/* Include files */
#include "rtwtypes.h"

/* Type Definitions */
#ifndef typedef_matrix_expPersistentData
#define typedef_matrix_expPersistentData

typedef struct {
  double count;
} matrix_expPersistentData;

#endif                                 /*typedef_matrix_expPersistentData*/

#ifndef typedef_matrix_expStackData
#define typedef_matrix_expStackData

typedef struct {
  struct {
    double F[25600];
    double Y[25600];
    double X[25600];
  } f0;

  matrix_expPersistentData *pd;
} matrix_expStackData;

#endif                                 /*typedef_matrix_expStackData*/
#endif

/* End of code generation (matrix_exp_types.h) */

Run the Code

Call the code using the command:

system('./matrix_exp')

See Also

|