What’s the difference between x86 and ARM processors?

It used to be like this: there are powerful processors for desktop computers, laptops, and servers, and there are weak processors for mobile devices—phones and tablets.

Now the situation is changing: mobile processors are gradually overtaking desktop ones, and desktop ones are starting to borrow technologies from mobile ones.

RISC — simple instructions, lots of code

In the early days of processors, programmers didn’t have high-level languages ​​like JavaScript or Python. All commands were written in machine code or assembly language. At that time, programmers worked directly with the processor, and each command in the code represented an instruction for the processor.

For example, a typical program of that time for multiplying one number by another might look like this to a processor:

The result was a large program that was quite difficult to read.

This technology was called RISC – Reduced-instruction-set Computing, a computer with a limited set of commands.

Some time later, RISC technology was improved in two different ways, giving rise to the x86 and ARM architectures. The former were designed for powerful computers, while the latter were designed for smaller, more energy-efficient devices.

x86 is a complex RISC

As computers developed, programmers wanted to write more complex programs. But the more complex the program, the more code they had to write.

Then Intel released the 8086 processor, which supported many new instructions. These simplified code writing, partially closing the gap between machine code and high-level programming languages.

Let’s take the same code example for multiplying two numbers. For the 8086 processor, the code looked like this:

“Multiply numbers” is a new complex instruction available in this processor. When the processor encounters it in code, it executes many other instructions similar to the ones we wrote at the beginning and gets the same result.

This technology is called CISC – complex instruction set computer.

On the one hand, it’s now easier for programmers to write code: instead of thirty instructions, they can write three, and the result will be the same. The more new complex instructions a processor supports, the faster the development.

On the other hand, the processor now has to spend some time translating complex commands into simple ones. When it receives the command “Multiply these two numbers” from the programmer, it converts it into those same thirty lines of code and executes each command.

The 8086 processor was followed by the 80286 and 80386 processors. They were so successful for their time that from then on, Intel ended the designation of all its main processors with “86,” and the technology and instruction set were called “x86.”

ARM is an advanced RISC

ARM, whose name stands for “Enhanced RISC Machines,” took a different approach. Their approach was: why bother with complex processor instructions when you can maximize the use of simple instructions and focus on efficiency?

As a result, ARM improved the RISC architecture, simplified the instructions, and focused on efficiency.

At that time, ARM processors weren’t as fast as x86 processors, but they consumed much less power. Over time, this allowed ARM processors to be used in mobile phones.

So, the difference between the processors is that x86 is CISC, and ARM is RISC?

Most people think that way, and in some ways it’s probably true. But it’s not entirely accurate.

Modern x86 processors are 80% RISC modules that process RISC instructions. Each complex CISC instruction is broken down by a special decoder into many simple instructions, which are then executed by these modules.

It turns out that any modern processor is still based on a RISC architecture, on top of which additional commands are layered for each device.

What makes ARM successful?

To produce a processor with x86 architecture, a company must design and draw all the transistors and connections between them. This is a complex and expensive process, unaffordable for small companies. Of the major x86 processor manufacturers, only Intel and AMD remain.

ARM has taken a different approach: they sell licenses to anyone to manufacture processors based on their architecture. This means any company can purchase a license and manufacture its own ARM processors. The company can also improve its processors as much as they like, changing its layout, adding new modules, and so on.

It was the availability of licenses and competition that led to the rapid development of ARM processors, not the RISC architecture or instruction sets.

Samsung, Nvidia, Qualcomm, Atmel, Huawei, and many others currently produce their own ARM-based processors. If you’re a smartphone manufacturer, you can develop your own ARM-based processor or buy a ready-made one from any other company. This creates market competition, a technology race, and overall progress.

The main thing is the internal structure of the processor

Modern processors consist of many individual modules, each of which does something different, for example:

The manufacturer’s implementation of module layout and interconnection determines the processor’s performance and applicability across various applications. And because the ARM architecture is based on simple instructions, it’s easier to interconnect such modules. Thus, ARM’s strength lies in its simplicity and flexibility.