ARM Architecture and Family

Question

I've started working on different ARM-based targets but there is still something I'm missing about ARM cores, architectures, instruction sets and core families. Having a look at the wikipedia page here: http://en.wikipedia.org/wiki/ARM_architecture#ARM_cores I see that there are multiple ARM architectures and multiple families for each architecture. For instance for ARMv6 architecture there are the ARM11 and the ARM-Cortex-M families. The same happens for ARMv7 and others. What is the difference between ARM11 and ARM Cortex-M given that the architecture is the same? Do the ARM11 and ARM Cortex-M both support the same instruction set given that they implement the same architecture?

Answer 1

The architectures are the specifications, i.e. the set of registers, instructions and operation modes that should be supported by implementations of the architecture.

A family is a specific detailed implementation of an architecture, i.e. the actual hardware details needed to create an ARM core. Finally a core is a specific implementation of an architecture, i.e. the actual blue-print of the transistors and other discrete parts needed to create a ARM CPU.

The ARM architectures are modular so families may implement only some features of the architecture and not others. Families may also have extensions not in the architecture and to make things even more interesting cores in the same family will usually differ in the features they support.

The reason ARM cores are called cores and not chips is that the specific chips may contain one or more cores (assuming the cores support it) or may have cores integrated with other components (I/O controllers, Memory interfaces, etc.) in the same chip.

ARM11 and ARM Cortex-M are different families implementing features in the ARMv6 architecture with different markets in mind: ARM-11 smartphones and tablets and Cortex-M micro-controllers AFAIK.

Answer 2

There is no clear answer, and probably the situation has changed over time - but I think the family term has lost most of it's value in this context.

The architectures define sets of features (both standard and optional). Over time you might see new features added as an extension, and later rolled in as a standard feature of the architecture. Architecture covers more than instruction set, system level features (like memory behaviour), privilege and protection, exception model, etc.

There are also application areas - split at a high level in the Cortex nomenclature into MCU (lower power, deterministic), Real-Time (deterministic, safety and error features), and Application (higher end, general purpose). These lead to a further level of specialisation with the architecture, so there is ARMv8-M, ARMv8-R and ARMv8-A (where you would end up writing completely different code at an OS level to take advantage of the features).

With older processors, there would have been variations on a specific design to change the feature-set with a focus on different markets, but this is not such an obvious distinction with Cortex designs (for example, the ARM9 family where cache, tightly-coupled-memory, MMU/MPU were the sort of options that existed).

Cortex-M could be treated as a family, but covers a wide performance range (over two similar architectures), and also a range of security features (with ARMv8-M).

You could also talk about the 'small' Cortex-A family, although for a specific application, there will be one specific core which is a better fit than the others. There are big.LITTLE pairings too, but they wouldn't be described as a family (but they specifically share a precise architecture).

A single specific architecture gives a guarantee of baseline features, but doesn't necessarily limit portability of much code since the different ISAs remain mostly common as the architectures evolve. (M-class code will run on A-class devices, at least if you're careful, and switch from A64 state).

A further complication with ARM cores is that the wider system in a specific device is mostly free for the vendor to customise - although there are some standards available if they chose to target a specific type of application. Looking at any specific vendor, you might even talk about a family of parts all based on a single ARM core.