Home > Articles > Hardware

Understanding ARM Architectures

  • Print
  • + Share This
The ARM architecture is increasingly becoming relevant to software developers of all types. David Chisnall describes the unique features of the design and how they affect people writing code for these chips.
Like this article? We recommend

Like this article? We recommend

The ARM architecture is one of the most successful on the planet. If you own a mobile phone, it probably contains at least one ARM core; many slightly older phones contain two—one for the UI and one for the network stack. They're found in almost all handheld computing platforms, a number of embedded systems, and even a few desktop computers. The last couple of ARM generations have been capable of running much the same applications as on a modern desktop or laptop, with a sufficiently small power envelope that you can run them from a small battery.

The ARM architecture is slightly more recent than x86, but comes from a similar need. The 8086 chip was designed by Intel as a successor to existing 8-bit microprocessors, done by extending the 8080 architecture. The original 8086 was intended as a temporary product to plug a gap in Intel's product lines caused by delays in some of its other projects, but IBM's adoption of the 8086 chip for the PC architecture derailed this plan.

Acorn, a British microcomputer maker, had a similar problem in the early 1980s. Its existing lines were all based on the MOS Semiconductor 6502, an 8-bit CPU found in a large number of computers from that era. Rather than replace the 8-bit CPU with a 16-bit CPU, Acorn decided to make the jump all the way to 32 bits.

Inspired by the Berkeley RISC project, Acorn designed its own chip in-house. A lot of the overall design of the first ARM core (and, indirectly, all of its successors) comes from the fact that the Acorn team was resource-starved in comparison to its American counterparts. Limited manpower and budget meant that the first ARM cores were incredibly simple, with the side effect that they were also very low-power. This fact made the design attractive to another company, Apple, for its new Newton handheld PDA. Because Acorn was a direct competitor to Apple, however, buying chips directly from the manufacturer wasn't an attractive proposition. Advanced RISC Machines was spun out as a joint venture between Apple and Acorn, retaining the ARM acronym that originally stood for Acorn RISC machine.

Acorn shipped ARM-based desktops for most of a decade before finally going bust. ARM (now called ARM Holdings) continues to sell chip designs to other manufacturers.

IP Cores and SoCs

ARM doesn't manufacture chips; the company produces designs, which are licensed to other companies for manufacture. The cheapest ARM licenses just give you something that you can send directly to a chip fabricator for manufacturing. The most expensive licenses give you all of the design material and hardware description language (HDL) needed to make significant changes to the layout. Qualcomm is an example of the second kind of licensee. The Qualcomm Snapdragon contains a massively modified version of ARM's Cortex A8 core.

Most licensees are somewhere between those two levels. A company like Texas Instruments, for example, integrates an ARM core, its own digital signal processor (DSP), a third-party graphics processing unit (GPU), and various other components on a single system on chip (SoC). Most ARM cores are in this kind of package, which makes supporting ARM systems quite difficult for operating system developers, because all of these SoCs may contain different interrupt controllers, different video hardware, and so on. Operating systems typically list compatibility with a specific SoC, rather than simply with the ARM architecture—supporting the ARM core is only a small part of the puzzle.

The first ARM chips were connected to the BBC Micro—Acorn's most successful 8-bit line—via the tube port, which was designed for connecting a second processor. The BBC's heterogeneous multiprocessor design was an obvious influencing factor in the ARM architecture, which has native support for up to 16 coprocessors. It's quite common for some of the extra components in an SoC to use this interface, meaning that they can be almost as closely integrated as something like the x87 or Streaming SIMD Extensions (SSE) unit in an x86 chip.

The method of their manufacture also makes ARM cores a lot more varied than x86 chips. Most of the components of the design are modular, and large numbers of the components can be removed for simpler chips. Low-end ARM chips may support only a restricted instruction set, with no memory management unit (MMU), no floating-point unit (FPU), and not even division implemented in hardware. High-end chips may include an MMU, vector units, FPUs, multiple instruction formats, and even multiple cores.

  • + Share This
  • 🔖 Save To Your Account