Matlab: How to examine the compiled m-code progression from an external API?

Question

My question is extremely specific for the Arcana of the Matlab compiler and runtime. As soon as people familiar with the Matlab API can answer, I cut down a lot of the details. Please let me know if I will be more detailed.

Introduction

Using the Matlab compiler and runtime, I can call a function written in m-code from a C # program. Let me say:

function [result] = foo(n)
%[
    result = 0;
    for k = 1:n,
        pause(1.0); % simulate long processing
        result = result + 42;
    end
%]

with (somewhere behind some dllimports in C # code):

mclFeval(IntPtr inst, string name, IntPtr[] plhs, IntPtr[] prhs)

So far, so good, I have no problem with this (for example, to initialize the runtime, load the .cft file, sort MxArray using .Net types, etc.)

My problem

I would like to view the progress of my function foousing some callbacks canceland progress:

function [result] = foo(n, cancelCB, progressCB)
%[
    if (nargin < 3), progressCB = @(ratio, msg) disp(sprintf('Ratio = %f, Msg = %s', ratio, msg)); end
    if (nargin < 2), cancelCB = @() disp('Checking cancel...'); end

    result = 0;
    for k = 1:n,

        if (~isempty(cancelCB)), 
            cancelCB(); % Up to the callback to raise some error('cancel');
        end;
        if (~isempty(progressCB)),  
           progressCB(k/n, sprintf('Processing (%i/%i)', k, n));
        end

        pause(1.0); % simulate long processing
        result = result + 42;
    end
%]

, , , #, m-one.

• "mclmcr.h", , :

  extern mxArray* mclCreateSimpleFunctionHandle(mxFunctionPtr fcn);
  extern bool mclRegisterExternalFunction(HMCRINSTANCE inst, const char* varname, mxFunctionPtr fcn);
  

  , , , , , .

• COM # matlab:

  // Somewhere within C# code:
  var survey = new ComSurvey();
  survey.SetCancelCallback =  () => { if (/**/) throw new OperationCancelException(); };
  survey.SetProgressCallback = (ratio, msg) => { /* do something */ };
  

   

  function [result] = foo(n, survey)
  %[
      if (nargin < 2), survey = []; end
  
      result = 0;
      for k = 1:n,
  
          if (~isempty(survey)),
             survey.CheckCancel(); % up to the COM object to raise exception
             survey.SetProgress(k/n, sprintf('Processing... %i/%i', k, n));
          end
  
          pause(1.0); % simulate long processing
          result = result + 42;
      end
  %]
  

  :

  extern mxArray *mxCreateNumericArray(...)
  extern mxArray *mxCreateStructArray(...)
  

  , COM- MxArrays, ?

+ 1

, Matlab #, , mclCreateSimpleFunctionHandle - .

. . , , . (.. ).

• mxFunctionPtr, :

  // Mimic low level signature for a Matlab function pointer
  [UnmanagedFunctionPointer(CallingConvention.Cdecl, CharSet = CharSet.Ansi)]
  delegate void MCRInteropDelegate(int nlhs, IntPtr[] plhs, int nrhs, IntPtr[] prhs);
  

  // Same signature (but far more elegant from .NET perspective)
  delegate void MCRDelegate(MxArray[] varargouts, MxArray[] varargins);  
  

• :

  [DllImport("mclmcrrt74.dll", EntryPoint = "mclCreateSimpleFunctionHandle", CallingConvention = CallingConvention.Cdecl, CharSet = CharSet.Ansi, ExactSpelling = true)]
  static extern IntPtr _mclCreateSimpleFunctionHandle(MCRInteropDelegate fctn);
  

• , MxArray .NET-, mxArray*, :

  // Create MxArray from corresponding .NET delegate
  static MxArray CreateFromDelegate(MCRDelegate del)
  {
      // Package high level delegate signature to a 'dllimport' signature
      MCRInteropDelegate interopDel = (nlhs, plhs, nrhs, prhs) =>
      {
          int k = 0;
  
          var varargouts = new MxArray[nlhs];
          var varargins = new MxArray[nrhs];
  
          // (nrhs, prhs) => MxArray[] varargins 
          Array.ForEach(varargins, x => new MxArray(prhs[k++], false)); // false = is to indicate that MxArray must not be disposed on .NET side
  
          // Call delegate
          del(varargouts, varargins); // Todo: varargouts created by the delegate must be destroyed by matlab, not by .NET !!
  
          // MxArray[] varargouts => (nlhs, plhs)
          k = 0;
          Array.ForEach(plhs, x => varargouts[k++].getPointer());
      };
  
      // Create the 1x1 array of 'function pointer' type
      return new MxArray(MCRInterop.mclCreateSimpleFunctionHandle(interopDel));
  }
  

• , , module MCRModule ( , hInst* API mclFeval), foo .NET cancel :

  // Create cancel callback in .NET
  MCRDelegate cancel = (varargouts, varargins) =>
  {
      if ((varargouts != null) && (varargouts.Length != 0) { throw new ArgumentException("'cancel' callback called with too many output arguments"); } 
      if ((varargins != null) && (varargins.Length != 0) { throw new ArgumentException("'cancel' callback called with too many input arguments"); }
  
      if (...mustCancel...) { throw new OperationCanceledException(); }
  }
  
  // Enter the m-code
  // NB: Below function automatically converts its parameters to MxArray
  // and then call low level mclFeval with correct 'mxArray*' handles
  module.Evaluate("foo", (double)10, cancel);
  

  .NET- , foo cancel .

  , . , , , , ...

  (, - ).

  , , , mclCreateSimpleFunctionHandle.

Answer 1

mclCreateSimpleFunctionHandle API , ( Matlab), ( ). m-, # .

mclCreateSimpleFunctionHandle