Everyone is going for ARM these days ̵
Everyone is going ARM these days
The processor world is a complex industry, and only a few designs from a few companies are capable of competing in terms of high performance. Typically, Intel or AMD takes the cake when it comes to performance, both producing x86 CPUs. But recently, CPUs from Apple and Amazon based on ARM have given Intel (and the x86 architecture) a run for their money.
Amazon has their Graviton2 CPU, which is no faster than Intel’s servers, but is cheaper and uses less power. With how much improvement it was over Graviton1, their next iteration will likely be fierce competition in the server room.
Apple broke out of the park with their first non-mobile CPU, the Apple Silicon M1 processor, which runs faster than desktop Intel CPUs and almost as fast as AMD’s Ryzen 5000 series, the current performance crown. It’s custom silicon that makes Apple Macbooks some of the world’s fastest laptops today, much to the chagrin of PC enthusiasts (myself included).
In fact, they are so far ahead of laptop space that Windows on the M1 Macbook runs faster than the Surface Pro X, despite Windows running on ARM alone via an emulator. And if that wasn’t demeaning enough, it absolutely crushes it with a Geekbench Single-Core score of 1,390 compared to the Surface’s 802, which is ridiculously bad in comparison. The M1 is seriously fast.
It’s also rumored that Microsoft is developing their own in-house ARM processor, and while that rumor comes from the Azure server space, they’d probably use the same chip for the Surface if they can match Apple’s performance.
What is the difference between ARM and x86?
At the end of the day, there is not too much difference between ARM and x86. You can still use Google Chrome and watch YouTube on both. In fact, you might be doing this now as almost all Androids and every iPhone use an ARM processor.
The main difference for most people is that older applications intended for x86 need to be recompiled to run on ARM as well. This is easy for some things, but not everything is supported, especially older software. But even that can usually go through x86 emulation, which Windows starts to support.
For developers, there are many differences in the way applications are compiled, but these days most compilers support the major instruction sets well, and you don’t really need to make many changes to get it compiled for multiple platforms. .
But how does ARM work faster?
To answer this question, we’ll have to dig deeper into how CPUs work under the hood.
ARM and x86 are both instruction sets, also known as architectures, which is basically a list of microcode “programs” that the CPU supports. Therefore, you don’t have to worry about running a Windows app on a specific AMD or Intel CPU; they are both x86 CPUs, and while the exact designs differ (and perform differently), they both support the same instructions. This means that any program compiled for x86 will generally support both CPUs.
In fact, CPUs perform operations sequentially, like a machine that needs to run a list of tasks. Each statement is known as one opcode, and architectures like x86 have a lot of opcodes, especially given that they have been around for decades. Because of this complexity, x86 is known as a “Complex Instruction Set” or CISC.
CISC architectures generally take the design approach to many things in a single instruction. For example, a multiplication instruction can move data from a memory bank to a register, then perform the multiplication steps, and shuffle the results in memory. All in one instruction.
However, under the hood, this instruction is unpacked into many “micro-ops” that the CPU executes. The advantage of CISC is memory usage, and since it used to be expensive, CISC used to be better.
However, that is no longer the bottleneck, and this is where RISC comes into play. RISC, or Reduced Instruction Set, basically puts an end to complex multi-part instructions. Each instruction can usually be executed in a single clock cycle, although many long operations have to wait for results from other parts of the CPU or memory.
While this appears to be on the decline, it has huge implications for CPU design. CPUs must load all their instructions from RAM and execute it as soon as possible. As it turns out, it’s much easier to do that when you have a lot of simple instructions instead of a lot of complex ones. The CPU runs faster if the instruction buffer can be filled, which is a lot easier to do if the instructions are smaller and easier to process.
RISC also has the advantage of something called Out-of-Order Execution or OoOE. In essence, the CPU has a unit in it that rearranges and optimizes the instructions that come in it. For example, if an application needs to compute two things, but they don’t depend on each other, the CPU can run both in parallel. Usually parallel code is very complicated for developers to write, but at the lowest levels of the CPU, it can use multi-tasking to speed things up. The Apple M1 chip uses OoOE with great success.
If you are interested in the inner workings you should read this fantastic article by Erik Engheim on what makes the Apple M1 chip so fast. Basically, it uses a lot of specialized silicon, off-order execution, and has a lot more instruction decoders to back up its speed.
Will ARM replace x86?
The honest answer is: probably. Intel has felt the end of Moore’s law for years, and while AMD has been able to boost performance in recent years, they’re not far ahead.
This isn’t to say x86 will die out anytime soon, but it’s clear that ARM has more potential than just being a mobile architecture – a stigma that is no longer valid given the industry’s current direction. The benefits of RISC architectures are clear, and with how much the Apple M1 chip has already improved, the future of the industry looks promising.
Plus, ARM isn’t the only RISC architecture out there. It is still owned, although ARM licenses its designs to third-party designers such as Qualcomm, Samsung, and Apple. RISC-V is open source and is also very promising. It is a standardized instruction set architecture, leaving the exact implementations to the manufacturer. As the industry generally moves towards RISC, there will be open and closed source implementations available.