Improving matlab code performance with anonymous function bottlenecks

Question

I am facing serious performance issues with anonymous functions in matlab 2011a, where the overhead introduced by the anonymous container function is much larger than the time taken by the private function itself.

I read several related questions in which users explained with caution that this is a problem that others are experiencing, that I can significantly increase performance by getting rid of anonymous containers. Unfortunately, my code is structured in such a way that I am not sure how to do this without breaking a lot of things.

So, are there any workarounds to improve the performance of anonymous functions without completely eliminating them or developing templates that would allow me to do away with them without bloating my code and without spending a lot of time reorganizing?

Some information that may help:

The following is a collection of anonymous functions that are stored as a class property. Using an int array, which, in turn, is used by the switch statement, can replace the array in principle, but the contents of the GPs can be changed - there are other functions with the same argument structure as the traces used in it - and the contents of the GPs in some cases can be determined at runtime.

m3.GPs = {@(X,ytrain,xStar,noisevar,params)traingp(X,ytrain,xStar,noisevar,1,params,[1 0]'); @(X,ytrain,xStar,noisevar,params)traingp(X,ytrain,xStar,noisevar,1,params,[-1 1]'); @(X,ytrain,xStar,noisevar,params)traingp(X,ytrain,xStar,noisevar,2,params,0); @(X,ytrain,xStar,noisevar,params)traingp(X,ytrain,xStar,noisevar,3,params,0); @(X,ytrain,xStar,noisevar,params)traingp(X,ytrain,xStar,noisevar,4,params,[0 0 0]')}; 

Later, the GPs elements are called by a member function of the class, for example:

 GPt = GPs{t(j)}(xj,yj,gridX(xi),thetaT(1),thetaT(2:end)); 

According to the profiler, the battery life for anonymous wrappers is 95% of the total time (1.7 seconds for 44 calls!) Versus 5% for the function containing the data. I use a similar approach elsewhere, where the cost of anonymous wrappers is even greater, proportionally.

Does anyone have any thoughts on how to reduce the overhead of anonymous calls or, if they are not available, how to replace the anonymous function while maintaining the flexibility they provide (rather than introducing a bunch of additional bookkeeping and passing arguments)?

Thanks!

Answer 1

It all comes down to how much pain you are willing to endure in order to increase productivity. Here is one trick that avoids anonymous functions. I do not know how it will be profiled for you. You can put these "tiny" functions at the end of class files, which I assume (I know that you can put them at the end of regular function files.)

 function [output] = GP1(x,ytrain,xstar,noisevar,params) output = traingp(X,ytrain,xStar,noisevar,1,params,[1 0]); end ... m3.GPS = {@GP1, @GP2, ...}; 

Answer 2

Perhaps the "factory" function will help:

 >> factory = @(a,b,c) @(x,y,z) a*x+b*y+c*z; >> f1 = factory(1,2,3); >> f2 = factory(0,1,2); >> f1(1,2,3) ans = 14 >> f1(4,5,6) ans = 32 >> f2(1,2,3) ans = 8 >> f2(4,5,6) ans = 17 

Here, factory is a function that returns a new function with different arguments. Another example might be:

  factory = @(a,b,c) @(x,y,z) some_function(x,y,z,a,b,c) 

which returns the function x,y,z with the specified a,b,c .