AArch64 Optimization – Intro

So, I figure it’s about time to take my current knowledge and do something of use in the real world with it. Specifically, the world of open source. So, let’s make something faster. Sound good? Yes, but I’m going to need to be a lot more specific than that. Let’s set some parameters and goals. First off, the goal will be to increase a piece of software’s (or a library’s) performance on the AArch64 architecture. If I also manage to increase its performance on x86 (or other architectures), then that’s even better. However, for the purposes of this, I will be focusing on AArch64 performance, and as long as performance on x86 does not decrease, I’ll consider the optimization a success.

As for some parameters, I’ll be choosing a piece of open source software (or library) that I am not currently involved with. Even more specifically, I’ll be choosing a single function (or method/routine/whatnot) and focusing on the performance of that. I’m still quite new to optimization, so only focusing on a single thing sounds like the best way to start. Furthermore, whatever piece of software I pick needs to be something that compiles to machine code, as optimization of interpreted languages is outside the scope of what I’m currently doing. Another parameter is that the chosen function must be CPU intensive – in other words, it needs to be something where optimizing it will actually make a difference. It’s a waste of time to write optimizations for functions that represent a very small portion of execution time, after all.

Oh, and for this, the optimization does not necessarily need to involve changing code. If I can optimize a program by changing build options, that is an entirely legitimate approach. That said, I’m most likely going to be looking for software that already has architecture specific code for x86 (but does not have AArch64 specific code, or at least does not have as much AArch64 specific code). There are a few reasons for this approach. The first is that it points out areas where optimization is useful – someone spent time optimizing code for x86, so it’s entirely likely that there are performance gains to be made there for AArch64 as well. Another reason being that writing code that will only be used for AArch64 means I can sidestep the issue of potential regressions on other architectures. I won’t limit myself to exclusively looking for architecture specific code, but it seems like the most practical approach here.

Anyway, I think I’m going to stop writing now and go off and search for software to optimize. I’m probably just going to look through the Fedora package list and see what I can find. Fedora in specific because I know it has a huge, well established repository, and because I have access to a large amount of boxes with Fedora installed already.

Leave a Reply

Fill in your details below or click an icon to log in:

WordPress.com Logo

You are commenting using your WordPress.com account. Log Out /  Change )

Google photo

You are commenting using your Google account. Log Out /  Change )

Twitter picture

You are commenting using your Twitter account. Log Out /  Change )

Facebook photo

You are commenting using your Facebook account. Log Out /  Change )

Connecting to %s

Create your website with WordPress.com
Get started
%d bloggers like this: