Could some ELI5 ARM vs x86?

AdjectiveMoose · July 19, 2022

I've never taken any EE classes nor any computer architecture classes, so I'm coming from a newby, beginner perspective. All I'm getting from the internet is mainly "ARM is less power hungry and used for mobile devices while x86 is intel/AMD." I'm not even sure if this can even be ELI5'd but, what are some the technical differences that differentiates ARM from x86 that makes it suit different devices?

manikyath · July 19, 2022

in very basic terms: they're completely different ways to solve a problem.

it's tanker trucks vs pipeline infrastructure.

in essence, x86_64 is a 'complex instruction set computing' architecture. this means it can do A LOT more things in hardware, but as a result the hardware is more complex. (and CISC instructions are of variable length, meaning some stuff takes longer to process than others). the biggest issue we face with x86_64 is that it's a VERY old infrastructure, with A LOT of backwards compatibility requirements.

ARM, and RISC-V, are 'reduced instruction set computing' architectures. this means they limit the hardware options, in favor of software filling the gaps. (and RISC instructions are all the exact same length). the benefit here is that RISC generally fits on less silicon, and because the structure is so much simpler, the lack of hardware options gets offset by the performance and efficiency benefits.

RadiatingLight · July 19, 2022

Essentially, they speak different languages with 2 main differences:

Difference 1:

X86 is a very old language, and ancient commands must be supported in order to maintain backwards compatibility with old programs. For example, processors have registers (basically tiny super fast chunks of memory where they store the numbers they're currently working on. On 64-bit processors, this is naturally 64-bit. That's where the name comes from).

Modern X86 CPUs have ~20ish registers, but let's use the 'A' register as an example.

Old intel CPUs were 16-bit, and supported 3 ways to access this register. 'AX' referred to the entire register, but you could also use 'AH' to get the high bits (first 8) or 'AL' to get the low bits (last 8).

Then, intel upgraded to 32-bit CPUs, meaning the 'A' register was now 32-bits instead of 16-bits, but they couldn't break backwards-compatibility with programs that expected 'AX' to be just 16-bits in size, and so they created a new name: "EAX" to refer to the *E*xpanded AX register, and 'AX' would refer to the last 16-bits of the 'EAX' register.

The same thing happened for 64-bit, with 'RAX' being the name for the entire 64-bit region, 'EAX' still working and accessing the last 32 bits, 'AX' still being the last 16.

This happened for every register, for every command, etc. etc. (example: there is a different move/add/multiply/etc. command for 16-bit, 32-bit, and 64-bit numbers)

ARM doesn't have to deal with this, because it's new enough that these legacy instructions were never created for it in the first place.

Difference 2:

X86 has very specific instructions for very complex niche scenarios. (watch this video for some examples of really wacky specific instructions https://www.youtube.com/watch?v=Wz_xJPN7lAY). If you end up in one of these scenarios, then the instruction is perfect and probably faster than anything else you could've done, but the hardware to process all of these complex instructions takes up space on the chip, and the increased complexity makes it use more power.

ARM has a reduced instruction set, meaning that it's a simpler design that can do common operations with good power efficiency, at the expense of doing those niche/specific tasks slower, since you'll have to break them down into simple chunks that the processor can handle, rather than do them all at once.

Today, ARM is basically an objectively better architecture for general-purpose computing, and the only reason we're still on X86 for most things is because due to their different languages, switching to ARM would mean we need to emulate/translate every app, which is a pain and is slow.

TomChaai · August 3, 2022

You can't really ELI5 something that is more than forty years old, especially in the computer industry, one computer year equals probably ten human years.