bsxfun vs implicit expansion

The MATLAB docs recommend that calls to bsxfun are replaced with direct calls to the functions and operators that support implicit expansion. I have seen this same recommendation in several places on the file exchange (etc). However, a simple benchmark (see attached) seems to show that bsxfun is noticably faster, at least for this particular use case I'm interested in (complex vector times a complex 2D or 3D matrix with relatively large dimensions). The output image below is running in MATLAB 2023a. I get the same trend under both Windows and Linux on both new and old hardware. Is this an expected result? I couldn't find many details of what actually happens under the hood for both of these approaches and when it might be better to use one over the other.

[Stephen23]

Use whichever one you prefer.

My guess is that implicit expansion might have more potential for future improvement (e.g. multithreading or whatever magic TMW can implement), whereas BSXFUN is by design limited to repeated calls of an arbitrary function handle.

I (and a few other FEX contributors) prefer BSXFUN because of the backwards compatibility (back to R2007b).

[Bradley Treeby]

Thanks! I don't have a particular preference, except maximising performance. In this case, I don't need backwards compatibility either.

Interestingly, the situation is reversed if the benchmark is run using the gpuArray datatype. I just tried using NVIDIA GTX 1060 and A100 GPUs, and implicit expansion was 3-5 times faster.

The performance difference is enough in these different scenarios that I suspect I will end up writing benchmarks for every use case and datatype, which is pretty cumbersome.

Any inklings under which circumstances it might be better to use bsxfun vs implicit expansion and vice versa?

[Stephen23]

"Any inklings under which circumstances it might be better to use bsxfun vs implicit expansion and vice versa?"

In general I would expect implicit expansion to be faster (it is much easier to optimize a specific function on some arrays than optimize some code that has to call an arbitrary function handle multiple times). Together with the very explicit TMW advice this makes your choice quite clear.

"The performance difference is enough in these different scenarios that I suspect I will end up writing benchmarks for every use case and datatype, which is pretty cumbersome."

I would not recommend doing that, you are falling into this trap:

https://www.mathworks.com/matlabcentral/answers/1443594-matlab-jit-engine-nested-loops-data-type#answer_777409

https://www.mathworks.com/matlabcentral/answers/430098-documentation-on-jit-compiler

MATLAB is optimized to suit well-written code, not the other way round. Your choice is already clear.

[Joss Knight]

How are you doing the timing?

[Bruno Luong]

The mfile of timing is included in the question.

[Walter Roberson]

Historically, some of the frequent volunteers have found that bsxfun was faster for some situations but not all; implicit expansion is faster for some operations.

As far as I know, there is no guideance from Mathworks as to when each of the two would be expected to be faster.

[Joss Knight]

GPU is faster because consecutive operations can be fused in the implicit case. Not sure about the CPU case. I'll ask.

Answer 1

[Gagan Agarwal]

Hi Bradley,

I understand that you want to know the scenarios for which ‘bxfun’ is preferred and the scenarios for which use of ‘implicit expansion ‘is preferred.

In general, it has been observed that ‘implicit expansion’ tends to be faster than ‘bsxfun’. This is especially true when working with GPUs, where ‘implicit expansion’ often outperforms ‘bsxfun’. However, I couldn't find any specific scenarios that definitely determine when to use one over the other. Therefore, the best approach would be to decide on a case-to-case basis.

I hope this helps!