How ARM Got here to Dominate the Cellular Market

When you think of mobile computer hardware, ARM is probably the first company that comes to mind, or should be. While Intel has been recognized as a leader in chip manufacturing for years – and still is today – ARM has slowly turned into a niche that eventually reached a turning point where computing devices no longer had to be faster, but you had to be more efficient and portable.

For this reason, ARM dominates the market for mobile processors with almost all important versions that are based on its architecture. We are talking about billions of chips that are used in embedded applications, biometric systems, smart TVs, iPhones, laptops and tablets. But why is that and why haven't other architectures like x86 gained a foothold? In this article, we'll give you a technical overview of what ARM is, where it came from, and why it has become so popular.

The first thing to note is that ARM (more recently stylized as an "arm" in lower case) doesn't make processors. Instead, they design the architecture of a CPU and license these designs to other companies such as Qualcomm or Samsung, which integrate them into their processors. Because everyone uses a common standard, code that runs on a Qualcomm Snapdragon processor also runs on a Samsung Exynos processor.

What is an ISA (Instruction Set Architecture)?

Every computer chip needs an ISA to function, and that's exactly what ARM represents. Our CPU design series is a must for a detailed look at how CPUs work inside. The first step in explaining ARM is to understand what exactly an ISA is and what is not.

It is not a physical component like a cache or a core, but defines how all aspects of a processor work. This includes things like the type of instructions the chip can process, how the input and output data should be formatted, how the processor interacts with the RAM and much more. Another possibility is that an ISA is a set of specifications, while a CPU is an implementation of these specifications. It's a blueprint for how all parts of a CPU work.

For example, ISAs indicate the size of each data item with the most modern using a 64-bit model. While all processors perform the three basic functions of reading instructions, executing those instructions, and updating their status based on the results, various ISAs can further break down these steps. A complex ISA like x86 typically divides this process into several dozen smaller operations to improve throughput. Other tasks, such as branch prediction for conditional instructions and prefetching future data, are also determined by an ISA.

In addition to defining a processor's microarchitecture, an ISA also specifies a set of instructions that it can process. Instructions are what a CPU executes in each cycle and is created by a compiler. There are many types of instructions, such as: B. Read / write memory, arithmetic operations, branch / jump operations and more. An example could be: "Add the content of memory address 1 to the content of memory address 2 and save the result in memory address 3."

Each command is typically 32 or 64 bits long and has multiple fields. The most important is the opcode, which tells the processor what type of instruction it is. Once the processor knows what type of instruction it will execute next, it will retrieve the relevant data needed for this operation. The location and type of data are specified in another part of the opcode. Here are some links to parts of the ARM and x86 opcode lists.

RISC vs. CISC

Now that we have a basic idea of ​​what an ISA is and what it does, let's take a look at what makes ARM so special. The most important feature is that ARM is a RISC (Reduced Instruction Set Computing) architecture, while x86 is a CISC (Complex Instruction Set Computing) architecture. These are two main paradigms of processor design and both have their strengths and weaknesses.

In a RISC architecture, each command directly specifies an action to be performed by the CPU, and they are relatively simple. On the other hand, instructions in a CISC architecture are more complex and specify a broader idea for the CPU. This means that a CISC CPU normally further divides each instruction into a series of micro-operations. A CISC architecture can encode many more details in a single command, which can significantly improve performance. For example, a RISC architecture may contain only one or two "add" instructions, while a CISC architecture may have 20 depending on the type of data and other parameters for the calculation. You can find a more detailed comparison between RISC and CISC here.

CISC RISC
Transfer complexity to hardware Transfer the complexity to the software
Many different types and formats for instructions Instructions follow a similar format
Few internal registers Many internal registers
Complex decoding to split command parts Complex compiler for writing code with detailed instructions
Complex forms of memory interaction Few forms of memory interaction
The instructions take different cycles All instructions end in a cycle
It is difficult to divide and parallelize the work Easy to parallelize work

Another view is the comparison with building a house. With a RISC system you only have a simple hammer and a saw, while with a CISC system you have dozens of different types of hammers, saws, drills and more. A builder using a CISC-like system can do more work because their tools are more specialized and powerful. The RISC builder would still be able to get the job done, but it would take longer because its tools are much more basic and less powerful.

You are probably thinking, "Why would anyone ever use a RISC system when a CISC system is so much more powerful?" However, performance is far from the only thing to consider. Our CISC Builder has to hire a number of additional staff because special skills are required for each tool. This means that the construction site is much more complex and requires a lot of planning and organization. Managing all of these tools is also much more expensive because each can work with a different type of material. Our RISC friend doesn't have to worry about that as his basic tools can work with anything.

The house designer has the choice of how he wants to build his house. You can create simple plans for our RISC Builder or more complex plans for our CISC Builder. The starting idea and the finished product will be the same, but the work in the middle will be different. In this example, the home designer corresponds to a compiler. It uses an input code (home drawing) created by a programmer (home designer) and issues a series of instructions (blueprints) depending on which style is preferred. This allows a programmer to compile the same program for an ARM CPU and an x86 CPU, although the resulting list of instructions will be very different.

We need less electricity!

Let’s go back to ARM. When you've connected the dots, you can probably guess what makes ARM so appealing to mobile system developers. The key here is efficiency. In an embedded or mobile scenario, energy efficiency is far more important than performance. A system developer will experience a small drop in performance almost every time it means saving energy. Until battery technology improves, heat and power consumption remain the main limiting factors in the development of a mobile product. For this reason, we do not see large desktop processors in our mobile phones. Sure, they're orders of magnitude faster than mobile chips, but your phone would get too hot to hold and the battery would last for only a few minutes. While a high-end desktop x86 CPU can consume 200 watts under load, a mobile processor achieves a maximum of 2 to 3 watts.

You could certainly make a lower performing x86 CPU, but the CISC paradigm works best for more powerful chips. For this reason, you don't see ARM chips in desktops or x86 chips in phones often. They are simply not designed for that. Why can ARM achieve such good energy efficiency? Everything goes back to the RISC design and the complexity of the architecture. Because there are not so many types of instructions to process, the internal architecture can also be much simpler. The administration of a RISC processor is also less complex.

All of this leads directly to energy savings. A simpler design means that more transistors can contribute directly to performance instead of managing other parts of the architecture. A given ARM chip cannot process as many types of instructions or as fast as a given x86 chip, but this makes up for the efficiency.

Say hello to my little friend

Another important feature that ARM has brought to the table is the heterogeneous big.LITTLE computer architecture. This type of design has two companion processors on the same chip. One will be a core with very low power consumption, while the other will be a much more powerful core. The chip analyzes the system load to determine which core to activate. In other scenarios, the compiler can instruct the chip to call the more powerful core if it knows that a computation-intensive task is pending.

If the device is inactive or only performing a basic calculation, the core with lower power (LITTLE) is switched on and the more powerful core (Big Core) is switched off. ARM has indicated that this can result in energy savings of up to 75%. Although a conventional desktop CPU will certainly reduce its power consumption in times of lower load, there are certain parts that can never be switched off. Since ARM can completely switch off a core, it clearly outperforms the competition.

Processor design is always a series of compromises at every step of the process. ARM focused on the RISC architecture and paid off well. In 2010, they had a 95% market share in mobile phone processors. This has decreased slightly as other companies have tried to enter the market, but there is still no one around.

Licensing and widespread use

ARM's licensing approach for companies is another reason for their dominance. Building chips physically is immensely difficult and expensive, so ARM doesn't. As a result, their offers can be more flexible and adaptable.

Depending on the application, a licensee can select the desired functions and then have ARM select the most suitable chip for them. Customers can also design their own proprietary chips and implement only some of the ARM instruction sets. The list of technology companies using the ARM architecture is too big to fit here, but to name a few: Apple, Nvidia, Samsung, AMD, Broadcom, Fujitsu, Amazon, Huawei, and Qualcomm all use ARM technology .

In addition to the power supply for smartphones (handheld computers), Microsoft has further developed the architecture for its Surface and other light devices. We wrote a full review of Windows 10 for ARM over a year ago, and although these efforts haven't yet brought the operating system to the end, we've seen newer and better initiatives like the Surface Pro X since then. Apple has done the same. It has long been rumored that we can theoretically bring macOS to ARM so we can have laptops that work as efficiently as a phone.

For years, even arm in the data center was mostly about energy savings for years – a critical factor when it comes to thousands and thousands of servers. However, larger computer installations have recently been deployed to provide both performance and performance improvements over existing Intel and AMD solutions. Frankly, that's not something many people expected to happen so soon.

ARM has also built a large complementary intellectual property (IP) ecosystem that can be run on its architectures. These include accelerators, encoders / decoders and media processors for which all customers can acquire license rights for use in their products.

ARM is also the architecture of choice for the vast majority of IoT devices. Amazon Echo and Google Home Mini both run on ARM Cortex processors. They have become the de facto standard, and you need a good reason not to use an ARM processor when designing mobile electronics.

Do you fit all of this into one chip?

In addition to the central business area ISA, ARM has also expanded the area System-on-a-Chip (SoC). The market for mobile computers has changed to a more integrated design approach as space and power requirements have increased. A CPU and an SoC have many similarities, but an SoC is really the next generation of mobile computing.

A system-on-a-chip does exactly what it sounds like. It combines many different components on one chip to increase efficiency. Imagine shrinking an entire desktop motherboard to a single chip, and that's exactly what an SoC is. It usually has a CPU, graphics processor, memory, peripheral controller, power management, network and some accelerators. Before this design was adopted, systems required a separate chip for each of these functions. Communication between chips can be 10 to 100x slower and use 10 to 100x more power than an internal connection on the same chip. This is why the mobile communications market has adopted this concept so strongly.

Presentation of the many functions in an ARM-based Qualcomm SoC

Obviously SoCs are not suitable for every system type. You won't see desktops or mainstream laptops with SoCs because the number of things you can pack into a single chip is limited. There is no way to house the functionality of an entire discrete GPU, a sufficient amount of RAM and all the necessary connections on a single chip. Just like the RISC paradigm, SoCs are great for low-power designs, but less so for higher-performing designs.

By now, I hope you understand why ARM has become so dominant in the mobile processor market. With their RISC ISA model, they can license plans to chip manufacturers. With the RISC model, they maximize energy efficiency versus performance. When it comes to mobile computing, this is the name of the game and they are grand masters.

Leave a Reply

Your email address will not be published. Required fields are marked *