ARM has been having quite the field day of late. The most powerful supercomputer on the surface of the earth, Fugaku, is based on a 52-core custom ARM processor by Fujitsu. It beat the closest rival by a factor of 2.8x. Then came the massive announcement from Cupertino that Apple is transitioning from using Intel processors to their own custom silicon based on ARM. The reasons for which we might never know but Intel has been stuck on the same microarchitecture for more than five years and AMD has been steadily gaining performance, and subsequently grabbing market share from the blue giant.
Of late more and more ODMs and OEMs have started experimenting with ARM on traditional notebooks. Microsoft came out with the Surface Pro X and we’ve seen several generations of Chromebooks based on MediaTek SoCs which are all using ARM cores. Even Qualcomm demoed their 8cx Compute platform roughly a year ago boasting of immense battery life. And don’t even get me started on all the smartphones in existence today, all of which, barring a few, are based on ARM platforms.
While it may seem that the computing ecosystem is about to get drowned in a deluge of ARM based solutions, there’s still the server space where ARM is yet to gain a proper foothold. A lot of folks believe that this final x86 bastion would get toppled soon but truth be told, that’s just wishful thinking. A lot depends on the capabilities of the two processor ISAs. While x86 is a CISC (Complex Instruction Set Computer), ARM is RISC (Reduced Instruction Set Computer). Writing efficient code for the two computer types is quite different. Not that you can’t have a dynamic binary translator such as Apple’s Rosetta to make x86 code work with ARM, the overhead is silly. Moreover, Rosetta might work since Apple maintains a strict control over the macOS ecosystem and therefore, the fragmentation is kept to a minimum. The rest of the x86 dev environments aren’t cut from the same cloth so the binary translator would have to account for thousands and thousands of more possibilities.
Fundamentally, RISC is a stripped down version of CISC so it’s easy to emulate software written for ARM on x86 hardware but going the other way around is a bit pricey, especially when it comes to RAM. And server environments aren’t exactly cheap for folks to waste petabytes of RAM just for the sake of translating ARM code to x86. The short-term solution would be to continue working on binary translators that are more efficient at the translation work and capable of working with lesser overheads but the long-term goal would be to tackle the problem at the source.
We write x86 code because that’s the system that we’re all used to and have learnt to code on. And it’s this very same code written for x86 that needs to run on servers. So if we were to start writing code for RISC, then it makes sense to have RISC servers because the development environment and the production environment would be the same. You’ll experience fewer issues and also end up saving a lot of money by reducing overheads. So RISC personal computers have to become as popular as existing x86 personal computers for this to ever happen. Having spoken to a few OEMs and ODMs in recent times about the viability of ARM for personal computers, I haven’t found many takers. RISC is good for devices that don’t need to do much, which is why we find them in Chromebooks and smartphones.
An x86 PC is way more capable than any RISC ever will be. So unless these OEMs finally consider the ARM platform to be mature enough to enter mainstream notebooks, we aren’t going to see RISC computers dominate the computing space. Once we see a fair amount of OEMs producing ARM notebooks and perhaps, even desktops, we’ll start seeing more developers pick it up as the platform of choice to work on. Then you’d see all the folks building compilers take notice and come out with better tools to compile the code for RISC platforms. Then there’s a little back and forth between hardware manufacturers and developers as they start figuring out more optimum ways of doing things. The hardware folks will come out with new ISAs which the software folks will have to incorporate into their compilers and then provide feedback, which in turn will help hardware folks to tune the new ISAs. This will go on for a long time before we can finally deem the RISC platform to be mature enough. It would be a couple of years after the platform matures that we see ARM finally take over the world. Till then, x86 is here to stay.
This opinion piece was published in the July 2020 issue of Digit magazine.