{"id":1918,"date":"2023-12-13T11:39:35","date_gmt":"2023-12-13T16:39:35","guid":{"rendered":"https:\/\/blogs.mathworks.com\/matlab\/?p=1918"},"modified":"2024-01-24T08:04:50","modified_gmt":"2024-01-24T13:04:50","slug":"life-in-the-fast-lane-making-matlab-even-faster-on-apple-silicon-with-apple-accelerate","status":"publish","type":"post","link":"https:\/\/blogs.mathworks.com\/matlab\/2023\/12\/13\/life-in-the-fast-lane-making-matlab-even-faster-on-apple-silicon-with-apple-accelerate\/","title":{"rendered":"Life in the fast lane: Making MATLAB even faster on Apple Silicon with Apple Accelerate"},"content":{"rendered":"
Up to <\/span>3<\/span>.7<\/span>x<\/span> faster <\/span>Matrix-Matrix multiplication, <\/span>2x <\/span>faster LU factorisation, <\/span>1.7x<\/span> faster Cholesky <\/span>decomposition<\/span> and the<\/span> <\/span>p<\/span>otential for many more speed-ups <\/span>across different areas of linear algebra in MATLAB<\/span>. <\/span>What if I told you that you could have <\/span>all of<\/span> this right now on <\/span>your Apple Silicon machine<\/span>? <\/span>Interested<\/span>? <\/span>Read on.<\/span> <\/span><\/div>

It\u2019s<\/span> a<\/span>ll about the BLAS<\/span> <\/span><\/h2>
BLAS<\/span> (Basic Linear Algebra <\/span>Subprograms)<\/span><\/a> <\/span>is <\/span>probably the<\/span> most important software library <\/span>you\u2019ve<\/span> never heard of.<\/span> <\/span>It takes care of things like multiplying <\/span>two matrices together or <\/span>multiplying vectors by a scalar. Operations so simple you may not even <\/span>expect that something like MATLAB would use a library to <\/span>perform<\/span> them<\/span>.<\/span> <\/span><\/div>
The reason we use the BLAS library is speed!<\/span> <\/span>It\u2019s<\/span> <\/span>relatively easy<\/span> to implement these operations<\/span> <\/span>if you <\/span>don\u2019t<\/span> care about speed <\/span>but it is certainly not easy to implement them in such a way that they make maximum use of modern hardware<\/span>. The difference <\/span>in speed <\/span>between a naively written matrix-matrix multiplication routine and a high<\/span>ly<\/span> optimised one can be <\/span>thousands of times<\/span>! <\/span> <\/span><\/div>
Linear algebra is at the heart of <\/span>much of modern technical computing so<\/span> c<\/span>hip manufacturers<\/span>, such as <\/span>Intel, AMD and Apple <\/span>want to ensure that when you do linear algebra on their hardware <\/span>i<\/span>t<\/span>\u2019<\/span>s<\/span> <\/span>as fast as it can <\/span>p<\/span>ossibly be<\/span>.<\/span> As such, they all have their own implementation<\/span>s<\/span> of the BLAS library<\/span>, exquisitely tuned <\/span>to perfectly show-off the characteristics of <\/span>their CPUs.<\/span> <\/span><\/div>
None of this is news to regular readers of The MATLAB blog of course. I have a minor obsession with the BLAS library, and its <\/span>big sibling, the LAPACK library; both of which have been covered multiple times in articles such as <\/span>Trying out AMD\u2019s AOCL<\/span><\/a> and early posts exploring the <\/span>beta versions of MATLAB on Apple Silicon<\/span> (<\/span>here<\/span><\/a> and <\/span>here<\/span><\/a>)<\/span>. In these articles you can see how MATLAB\u2019s support of BLAS <\/span>has evolved recently, particularly for Apple Silicon.<\/span> <\/span><\/div>

You can now use Apple Accelerate <\/span>as the BLAS for MATLAB<\/span> on Apple Silicon<\/span> <\/span><\/h2>
MATLAB R2023b, the first<\/span> general release <\/span>of MATLAB for Apple Silicon, <\/span>uses<\/span> <\/span>O<\/span>penBLA<\/span>S<\/span> <\/span>and<\/span>,<\/span> <\/span>as I reported back in <\/span>June<\/span><\/a>, <\/span>performance is<\/span> <\/span>p<\/span>retty goo<\/span>d<\/span>.<\/span> From the beginning, however, users asked us \u2018Why aren\u2019t you using Apple Accelerate<\/span>; which contains <\/span>Apple<\/span>\u2019<\/span>s implementation of BLAS<\/span>?<\/span>\u2019<\/span>.<\/span> <\/span> We had our reasons (see the <\/span>relevant section in this article)<\/span><\/a> but the situation has since changed and<\/span> MathWorks <\/span>recently<\/span> <\/span>released an update <\/span>allowing you <\/span>to make use of it<\/span>. It was done so quietly, however,<\/span> that you<\/span> <\/span>a<\/span>lmost certainl<\/span>y<\/span> <\/span>missed it!<\/span> <\/span>S<\/span>o<\/span> <\/span>l<\/span>et\u2019<\/span>s<\/span> <\/span>fix that.<\/span> <\/span><\/div>
You need to be running at least R2023b Update 4<\/span>. <\/span>Anything earlier than R2023b <\/span>isn\u2019t<\/span> even running natively on Apple Silicon so start there.<\/span> Once you <\/span>have<\/span> R2023b installed, check which update you are running with the <\/span>version<\/span> command <\/span> <\/span><\/div>
version <\/span><\/span><\/div>
ans = <\/span><\/span><\/div>
'23.2.0.2428915 (R2023b) Update 4' <\/span><\/span><\/div><\/div>
If you are running <\/span>on an earlier update, fix that by <\/span>clicking on <\/span>Help->Check for Updates<\/span> <\/span> <\/span><\/div>
\"\"<\/img> <\/span><\/div>
Once <\/span>that\u2019s<\/span> done<\/span>, <\/span>you can <\/span>switch from using <\/span>OpenBLAS<\/span> to Apple Accelerate by following the instructions at <\/span>How can I use the BLAS implementations included in Apple Accelerate Framework with MATLAB R2023b Update 4<\/span><\/a><\/div>

Performance <\/span>discussion<\/span> <\/span><\/h2>
At the risk of <\/span>stating<\/span> the obvious, <\/span>if what <\/span>you\u2019re<\/span> interested in <\/span>isn\u2019t<\/span> related to linear algebra then you are not going to see any performance differences with this change<\/span>. <\/span>This is MATLAB<\/span> though<\/span>, <\/span>there\u2019s<\/span> a lot of linear algebra.<\/span> <\/span> <\/span><\/div>
If you want to repeat this benchmarks for yourself, the <\/span>script I used is on GitHub<\/span><\/a><\/div>

Matrix-Matrix multiplication<\/span> <\/span><\/h3>
Matrix-Matrix multiplication is where I s<\/span>aw the most speed-up<\/span>.<\/span> This is a BLAS operation that has clearly seen a lot of work by Apple. <\/span> <\/span><\/div>
Matrix Size<\/span> <\/span><\/div><\/td>
OpenBLAS<\/span> time (s)<\/span> <\/span><\/div><\/td>
Apple Accelerate<\/span> time (s)<\/span> <\/span><\/div><\/td>
x Speed-up<\/span> <\/span><\/div><\/td><\/tr>
1<\/span>,<\/span>000<\/span> <\/span><\/div><\/td>
0.<\/span>0172<\/span> <\/span><\/div><\/td>
0.00<\/span>46<\/span> <\/span><\/div><\/td>
3.<\/span>7<\/span>4<\/span> <\/span><\/div><\/td><\/tr>
5,000<\/span> <\/span><\/div><\/td>
1.15<\/span>83<\/span> <\/span><\/div><\/td>
0.4<\/span>171<\/span> <\/span><\/div><\/td>
2.78<\/span> <\/span><\/div><\/td><\/tr>
10,000<\/span> <\/span><\/div><\/td>
6.<\/span>8977<\/span> <\/span><\/div><\/td>
3.3186<\/span> <\/span><\/div><\/td>
2.08<\/span> <\/span><\/div><\/td><\/tr><\/table>

LU factorization<\/span> <\/span><\/h3>
LU factorization is a LAPACK <\/span>operation<\/span> and we <\/span>haven\u2019t<\/span> changed LAPACK libraries here. However, <\/span>LAPACK often makes use of BLAS so if you accelerate BLAS, you get <\/span>can<\/span> faster LAPACK for free. <\/span> <\/span><\/div>
Matrix Size<\/span> <\/span><\/div><\/td>
OpenBLAS<\/span> time (s)<\/span> <\/span><\/div><\/td>
Apple Accelerate time (s)<\/span> <\/span><\/div><\/td>
x Speed-up<\/span> <\/span><\/div><\/td><\/tr>
1,000<\/span> <\/span><\/div><\/td>
0.0124<\/span> <\/span><\/div><\/td>
0.0115<\/span> <\/span><\/div><\/td>
1.08<\/span> <\/span><\/div><\/td><\/tr>
5,000<\/span> <\/span><\/div><\/td>
0.4345<\/span> <\/span><\/div><\/td>
0.2556<\/span> <\/span><\/div><\/td>
1.7<\/span> <\/span><\/div><\/td><\/tr>
10,000<\/span> <\/span><\/div><\/td>
3.5928<\/span> <\/span><\/div><\/td>
1.6821<\/span> <\/span><\/div><\/td>
2.14<\/span> <\/span><\/div><\/td><\/tr><\/table>
I also tested <\/span>C<\/span>holesky<\/span> <\/span>decomposition <\/span>and got speed-ups ranging from<\/span> <\/span>1.28x to <\/span>1.77<\/span>x<\/span> <\/span><\/div>

Eigenvalues<\/span> <\/span><\/h3>
To test <\/span>e<\/span>igenvalue<\/span> <\/span>computation<\/span> I used the single output version<\/span> of<\/span> eig<\/span>.<\/span> <\/span>e = eig(A)<\/span>. <\/span>As with other <\/span>tests, I tried this on a range of random matrices<\/span>. <\/span>Things started off well<\/span>, with nice speed-ups for small matrices but <\/span>larger matrices saw quite <\/span>substantial<\/span> <\/span>slowdowns<\/span> on my M2 <\/span>machine when compared to the OpenBLAS original.<\/span><\/div>
I discussed this with a colleague who has an <\/span>M1<\/span> and he never saw any slowdowns. <\/span>For his machine, it was always faster <\/span>to use <\/span>Apple Accelerate<\/span> for <\/span>eig<\/span>. <\/span>As such, we suspect that this is an M2-speific issue and <\/span>will <\/span>investigate more closely to find out <\/span>what\u2019s<\/span> going on here<\/span> <\/span><\/div>
Matrix Size<\/span> <\/span><\/div><\/td>
OpenBLAS<\/span> time (s)<\/span> <\/span><\/div><\/td>
Apple Accelerate time (s)<\/span> <\/span><\/div><\/td>
x Speed-up<\/span> <\/span><\/div><\/td><\/tr>
1,000<\/span> <\/span><\/div><\/td>
0.4245<\/span> <\/span><\/div><\/td>
0.24<\/span>07<\/span> <\/span><\/div><\/td>
1<\/span>.<\/span>76<\/span> <\/span><\/div><\/td><\/tr>
5,000<\/span> <\/span><\/div><\/td>
22<\/span>.86<\/span>54<\/span> <\/span><\/div><\/td>
24.74<\/span> <\/span><\/div><\/td>
0.92<\/span> <\/span><\/div><\/td><\/tr>
10,000<\/span> <\/span><\/div><\/td>
145.4<\/span>076<\/span> <\/span><\/div><\/td>
201.57<\/span> <\/span><\/div><\/td>
0.72<\/span> <\/span><\/div><\/td><\/tr><\/table>
<\/span><\/div>

Details of test machine<\/span> <\/span><\/h2>
I used a<\/span>n<\/span> M2-based <\/span>Macbook<\/span> Pro<\/span> that was <\/span>plugged<\/span>-<\/span>in<\/span>. The output from the <\/span>cpuinfo command<\/span><\/a> <\/span>(available on File Exchange) <\/span>is as follows<\/span>.<\/span> <\/span> <\/span><\/div>
cpuinfo <\/span><\/span><\/div>
ans = <\/span><\/span><\/div>
struct<\/span>\u202f<\/span>with fields: <\/span><\/span><\/div>
<\/span><\/span><\/div>
CPUName: <\/span>'Apple M2 Pro' <\/span><\/span><\/div>
Clock: <\/span>'N\/A' <\/span><\/span><\/div>
Cache: 65536 <\/span><\/span><\/div>
TotalMemory: 1.7180e+10 <\/span><\/span><\/div>
NumCPUs: 1 <\/span><\/span><\/div>
TotalCores: 10 <\/span><\/span><\/div>
OSType: <\/span>'macOS' <\/span><\/span><\/div>
OSVersion: <\/span>'13.3.1' <\/span><\/span><\/div><\/div>
Other than <\/span>the issue with <\/span>eig<\/span>, w<\/span>hich I hope will get fixed at some point, switching to Apple Accelerate seems to be extremely beneficial<\/span>. <\/span>If you have an Apple Silicon Mac, <\/span>give it a try<\/span> and <\/span>tell me what you <\/span>come up with<\/span>.<\/span> <\/span><\/div>\r\n<\/div>