Fundamentally, what is a PC architecture, what is the difference between x64, x86, ARM, whatever else etc. and why do they offer different benefits or drawbacks or performances
In: 6
ELI5 answer
They’re the basic instruction sets that the worker…the processor works off of. Some are reduced (RISC) and some are more complex (CISC) with mixes in between. (ELI5 explanation of RISC/CISC below)
These instructions make up the ‘core’ of what each program (make burger patty, fill drink) can utilize to accomplish tasks that combined together create a whole sequence (full meal to customer….or an application).
The software utilizes these basic instructions as part of the [ISA](https://en.wikipedia.org/wiki/Instruction_set_architecture) to know what it can do.
The fast food worker (CPU) utilizes the cheat sheet of the ISA which has broken down steps of what he can do with his arms, legs, eyes etc. To then execute the program (the customer order/application).
x86 and AMD x64 (x86-64) all stem from a common root and are considered CISCs. (complex)
ARM is a RISC. (reduced)
—
Very high high level example
CISC will have an instruction called “Go to Bathroom” that does tons of things including going to bathroom, washing hands, doing your business etc.
RISC have basic instructions for moving your legs, arms, opening a door etc.
CISC instructions have a lot of overhead and sometimes do extra things that aren’t needed. When the program may only need to wash its hands, it may call the entire “Go to bathroom” and waste precious cycles doing bullshit.
RISC is much simpler and must have more expressive commands going to it and hence why its reduced. Its a reduced list of commands that can be utilized which makes it more efficent as it does less bullshit. But the size of the instruction sheet for ‘how’ to use the bathroom must now be larger
ELI5 answer:
x86 is 32 bit CPU, and x64 is 64 bit CPU
More bits isn’t always better; it depends on what you’re doing. Think of it like using a cup vs a bucket. Cups are better for drinking, but buckets are better for moving large volumes of water.
ARM can be 32 or 64 bits, and it’s like CPU-lite. Less functionality, less energy, less heat, better for mobile devices.
A *CPU* architecture is how the CPU is designed, what kind of instructions it accepts, how much internal memory it has, etc.
There’s architecture and microarchitecture – different microarchitectures work differently internally but still run the same programs (hopefully faster) – different architectures can’t run the same programs and need different versions of programs.
x64 is the 64-bit upgrade to x86 – a new architecture, but since it’s meant to be an upgrade, x64 CPUs also know how to run x86 programs. ARM is something different entirely, traditionally used for battery-powered things because it has better power efficiency, but in the last few years it’s also getting a lot more use in servers.
—
The obvious difference between different architectures is they run different program instructions. Because of x86/x64’s history the instructions are quite complicated, while ARM’s are quite simple. That means in ARM you need more of them to make a program, and each instruction takes up more memory than equivalent x86/x64 one, but on the other hand, there aren’t a bunch of transistors devoted to making sense of the complicated instructions, and if they are locked into making every instruction use the same amount of memory.
Since the ARM designers didn’t focus on making instructions small, they also had some leftover bits in each instruction, which they used for purposes not found in x86, which did focus on that. On the 32-bit version of ARM, every instruction is also an if-then statement – for free – and there are more registers (temporary holding locations for numbers).
All of these are definitions for opcodes on the CPU. Opcodes are essentially numbers that represent the operation being done. For example, you could say 1 means to add, 2 to subtract, 3 to multiply, etc. When people say that computers only understand binary, this is what they mean. When you run a program, it’s a list of these opcodes, which then translate to a specific operation on the CPU/GPU/whatever. This is the fundamental reason why programs need to be compiled for a specific instruction set architecture.
The main differences are that each chipset can support different kinds of operations. As an example, x86 can only support 32-bit memory addresses, which is why most computers these days use x64, which is a 64-bit backwards-compatible extension to x86. Some operations are useful for specific purposes but are expensive to make in hardware, so they support a different instruction set. And sometimes it’s not a technically good reason, it’s just vendor lock-in for business.
Different computer architectures do different things well.
A Ferrari might have the similar horse power to a Ford pickup, but they’re going to do different things well. There’s some stuff one or the other is much better for, some stuff they can both do, and some stuff only one or the other does. Some folks need a prius c, others need a semi.
ARM was originally designed to be simple. It’s meant to be used in places where power usage is a huge concern, like phones. It’s designed to use next to no power when it’s not actively doing things. x86/x64 are designed to give you the maximum power whenever you need it. If ARM were a nimble motorcycle, x86 is like a fully loaded semitruck barreling down the freeway. As a tool, ARM is specialized for power efficiency and give you the computing power you need intermittently. x86/x64 are specialized to give you consistent computing power all the time.
This line has blurred a lot over the years as technology has advanced. Both have started to take parts from the other and the lines have been blurred a little. But one thing that hasn’t changed is that x86 as a platform is like a collection of separate computers.
The Intel/AMD CPU, the discreet graphics card, the SSD, and your network card are effectively like different computers that talk to each other. This is why you can easily build your own AMD or Intel PC and choose what hardware you want on it. This is why you can just grab your OS of choice and install it and have it more or less work. They are designed to be swapped out.
In the ARM world it’s completely different. Everything from the CPU to graphics to the wireless radios are on one chip. It’s one fully enclosed computer where you cannot swap components. It’s not designed to do that. The OS you run on the device has to be custom-built for that device and that chip.
There is a reason for this difference, and it comes down to power efficiency. Because the entire computer on a single chip is going to use way less power than a collection of dozens of chips spread all over a tower. As a note, this is why you have to be VERY careful about support lifecycles for all ARM devices, but Android in particular because they have a shorter support window. In the x86/x64 world both AMD and Intel support their hardware for decades and there’s a very robust set of industry standards around the drivers. That does not exist in the ARM world, you are beholden to the support policies of the SoC maker, Qualcomm or Apple for most phones. This means that if there is ever a critical security flaw in the core of the OS, you cannot get an update when Qualcomm or Apple drop support for the SoC. This is a problem especially for Qualcomm phones because they purposefully limit their support cycle to 3 years from the release of the SoC. Yes there are open source efforts to extend the update window for Qualcomm based phones but it’s not guaranteed and they are reversed engineered. Which means that whoever did the work doesn’t have access to all the tools Qualcomm has to make sure fixes work and don’t introduce other security holes which presents a huge risk.
Fun fact, Intel and AMD computers already have ARM CPUs in them. They’re co processors designed to handle specialized tasks and you typically don’t interact with them directly though.
* x86 is short for 80×86 and it refers to the architecture developed by Intel for their 16bit and 32bit processors.
* x64 (more properly “AMD x86-64”) is the 64bit version of above, but developed by AMD. This was because Intel had decided to abandon the x86 architecture for Itanium. This was a disaster. AMD ate Intels lunch for YEARS in the 2000s over this misstep. Intel had to license AMD x86-64 from them.
* ARM is a processor that has roots in the old Apple 2/Commodore days. It is a simpler design. It offers fewer instructions, but runs them faster. They are built to run cooler, use less energy, and to be less expensive. This is why they are so popular in mobile devices. ARM does not make the processors, but licenses the design to Apple, Qualcomm, Samsung, nVidia, etc. There are 32bit and 64bit versions.
As for bits, this is this size of the register and (in most cases) the memory address size. The 8086 for example was an 16bit processor. All of the internal registers (temporary storage locations inside the processor) were 16bits wide and read memory 16bits at a time. The 8086, however, had a 20bit memory address bus. This allowed it to read up to 1MB of RAM/ROM instead of 65k…but still 16bits at a time. Starting with the 80386, Intel used 32bit registers and could address 4GB of RAM. AMD came out with AMD x86-64 and released the first Opteron in 2004. It can address 18 Exabytes of RAM (18,000 Petabytes, 18,000,000 Terabytes, 18,000,000,000 Gigabytes). While I think IBM and others might be messing around with 128bit processors, it does not seem necessary at the moment.
They are instruction sets. The set of all the instructions a CPU can execute.
Historically ARM and x86 had different design goals.
When the 8086 (the first of the x86 processors) was created memory was very expensive. Intel designed the instruction set where each instruction could perform multiple functions. For example, read a from memory, add to it, write back to memory. This reduced the size of programs, which saved memory.
ARM followed the RISC (Reduced Instruction Set Computer) design, as was fashionable at the time. This means each instruction performs only one function. For example, read from memory, add to it, and write back to memory takes 3 instructions. The idea is that the less complex circuitry of the simpler instructions would allow the CPU to be clocked higher and give better performance.
Historically ARM found success in embedded devices like smartphones and televisions, routers, etc. It’s not until very recently that they started showing up in PCs and servers.
The fact that ARM powers low-power devices has nothing to do with the instruction set itself. It’s just the niche that they happened to fill at the time.
All other explainations are very technical and I think they go beyond the point of the question.
The instruction set (like x86 or ARM) is the way the processor operates and in what way you need to give it instructions. In the end, they can both do the same things and even run the same programs, but their differences in operation mean that the code for those programs is written in a different way depending on the architecture.
For instance, on ARM, instructions have a fixed and predefined length (written in binary with 0 and 1) while x86 has variable length instructions with a different way to separate between them in the binary code. If you just give the ARM code to the x86 processor, it would not be ae to do meaningful operations on it at all.
Imagine a French and a German engineer, they can both do the same job even if they use slightly different methodologies, but each needs instructions in their respectable language, otherwise they won’t do the job.
Latest Answers