There is a battle heating up between ARM and Intel to see which processor architecture will rule in the 21st century. Intel x86 is the entrenched incumbent today, but ARM offers a distinct power advantage that may make it more attractive in the future. What’s the best CPU given the demands we see coming?
In 2011, ARM announced the Cortex-A15 processor, a multi-core, out-of-order superscaler design running at up to 2.5 GHz. The Cortex-A15 is significant as it represents a departure from previous ARM designs which focused primarily on minimal power usage at the expense of performance. In contrast, the Cortex-A15 is clearly focused at delivering strong performance numbers, with low power as a secondary objective. As covered in Scott’s previous article on ARM, ARM Holdings is fundamentally an intellectual property company that licenses its designs to other manufactures, who then create chips, which are then used in system products from other manufacturers. In late 2012, we started to see products using the Cortex-A15 design appearing in the market, and many more are expected in 2013.
But ARM is not the only processor company trying to win the future. A few weeks ago, Intel announced (and here) new low-power CPUs targeting data centers, based on its Atom architecture. The Atom S1200 series is designed to deliver x86 instruction-set compatibility in a low-power system-on-a-chip. The S1200 targets microservers and other performance-oriented applications that desire lower power dissipation.
Here’s a quick summary comparing the Samsung Exynos 5250, a licensed implementation of the Cortex-A15 that was introduced recently, to the Intel Atom S1260, the high end of the S1200 series. The Exynos 5 Series is used in the new Samsung Google Chromebook and Nexus 10 tablet. It’s important to note that each of these is a specific implementation of a broader processor family and thus makes implementation choices that might be suboptimal for one market in order to best optimize for another. An obvious example of that is the Exynos’s 4 GB memory limitation, which is reasonable for mobile applications but clearly suboptimal for cloud computing. But that said, the Cortex-A15 architecture supports up to 1 TB of memory using a 40-bit paged memory scheme (“Large Physical Address Extensions”).
|Feature||Samsung Exynos 5250||Intel Atom S1260|
|Instruction Set||ARM v7||Intel x86|
|Cores/Threads||2||2 / 4|
|Max Clock Frequency||1.7 GHz||2 GHz|
|Typical Power||2 – 4 W*||8.5 W|
|L2 Cache||1 MB||1 MB|
|Max Addressable Memory||4 GB||8 GB|
* Note that the power used by the Exynos 5250 is currently unknown, and very difficult to track down. I combed through the Samsung documentation and found nothing. The only vague estimate I could locate was here at Stream Computing. This may not be right. The key takeaway here is that it’s fairly low and probably less than the Atom 1260.
Now, the question is, which CPU is better, ARM or Intel x86? But that raises another question: better for what? The two markets of primary interest here at Leverhawk are mobile and cloud computing, so we’ll concentrate on those during the rest of the analysis.
The primary factors for comparison are going to be:
- Power usage
- Application compatibility
- Data center features
In the mobile world, power is the key determinant of success, all other things being equal. Whereas transistor count, memory sizes, and disk capacity keep rising, battery performance has not kept pace. The ARM architecture is quite power-efficient, and for that reason is currently used in a wide variety of popular mobile designs, including smartphones and tablets. But the mobile market includes laptops and netbooks in addition to smartphones and tablets.
When it comes to smartphones and tables, the general user thinking is something like, “I need to be able to carry my device around without charging it for at least a full workday. My device can’t be too heavy, so it can’t simply use a huge battery; the device must be power efficient. But given that all-day battery life threshold, I’ll take as much speed as I can get, because I’m always wanting to run richer applications on my device. I don’t need to run the same operating system I have on my desktop on my phone or tablet; I expect to buy new software to fit the new usage pattern. I don’t need terabytes of memory or slick data center features like ECC.”
As soon as you cut the dependency on running existing operating systems and applications and assume that new application environments will emerge (iOS and Android, for example), ARM is the clear winner because its more power efficient while still delivering good performance.
The thinking in the laptop and netbook market is slightly different, however. It goes something like, “I need battery life of 3 to 6 hours before I need to recharge. I expect my device to be bigger and heavier and it can therefore use a larger battery with greater capacity. This is my primary desktop device; it’s just mobile. Therefore, I need the device to run my desktop applications. While I might be willing to sacrifice some performance when I’m running on the battery, I want good performance when I’m plugged in. I’d like several GB of RAM, but I don’t need slick data center features.”
In this case, operating system and application compatibility remains a primary feature, and so a power-efficient x86 design is a better choice.
Now, all this might sound obvious, given that the market is already following these trends, but let’s see if we can pull out some takeaways:
- ARM will continue to do well in mobile devices where new operating systems and application environments are the norm. The user has no expectation of running desktop apps, and battery life is valuable.
- ARM will not make significant gains into the laptop or netbook space any time soon, however. If I want a mobile desktop, I want to take all my existing software with me. This won’t change until iOS or Android evolve to the point where they run acceptably on traditional keyboard-based devices and have developed a sufficiently-rich ecosystem so as to be able to replace all my desktop functionality.
- The one exception to this might be in highly limited laptop/netbooks like Google’s Chromebook, where the web browser is used to deliver applications over the network. These devices are not for everybody, but because of the tight control of the total software stack and the associated shift in usage, they can, and do, use ARM.
- Intel won’t do well in smaller devices like phones and tablets. While the latest Atom designs are quite power-efficient by traditional x86 standards, they can’t deliver the performance per watt of the latest ARM designs. Without a requirement for compatibility with traditional desktop software, there is no advantage in staying with x86. For instance, we see Microsoft’s new Surface RT tablet using ARM, but the new Surface Pro, which provides traditional Windows desktop compatibility, using x86. But the battery life of the Surface Pro is half that of the Surface RT.
- These takeaways ultimately represent a huge threat to the traditional Wintel ecosystem giants, Microsoft and Intel. If you consider that smartphones and tables are becoming the primary devices for many mobile workers, and that mobile is the primary growth market moving forward, you can appreciate the magnitude of the threat. Mary Meeker, a partner at venture capital firm Kleiner Perkins Caulfield and Byers, recently showed a slide that quantified this. The continuing popularity of attaching a keyboard to an iPad or Android tablet will increasingly enable these devices to compete with laptops and netbooks and could provide the catalyzing factor necessary for ARM to grow here.
So, what about cloud computing and server-side applications. The Intel x86 architecture is right at home in this environment. Indeed, the Intel Xeon line rules the raised floor space in most data centers today. But will that change? As Scott pointed out, the ARM-in-data-center value proposition is simple and straightforward: ARM is power efficient and data centers draw a lot of power. Reducing overall data center power usage by using ARM-based processing would lower operating costs and potentially facilitate smaller data centers through better cooling density.
The theory is great. Does it hold water?
To answer that we’ll need some idea of the expected workloads we’ll be running. There are a few key ones:
- Traditional Windows and Linux instances
- Single-function, tightly-controlled workloads like databases
- Cloud computing
- Large web properties
Let’s take them in turn.
- Traditional Windows and Linux instances – This is traditional IT as we know it today. The user wants to run a variety of random Windows or Linux-based workloads. In this application, application software compatibility is key. The hardware must provide good to great performance across a wide variety of applications. Here, x86 is going to shine. Scott mentioned that Microsoft is working on a Windows port for ARM. While this will help migrate some workloads, it won’t help transition the hundreds of thousands of enterprise applications already running on x86.
- Single-function, tightly-controlled workloads — If you can tightly control the application that will be running, you can optimize the hardware to deliver the best price, performance, and power usage. A good example here are databases, which are typically significant enough to be worthy of the effort. Folks like Oracle have realized this and even offer tuned hardware systems like Exadata. Whether ARM is a fit here will depend on whether you want to optimize for power consumption or performance. Oracle’s Exadata, for instance, optimizes for performance and uses Intel Xeon processors, not ARM, but other workloads might be a better fit.
- Cloud computing — In many ways, cloud computing is similar to the traditional Windows and Linux instances. If the service provider can’t predict the exact applications that will be run, then the default is going to be to provide a broadly compatible service based on x86. Further, if cloud providers are judged and compared on price/performance criteria, high-end Xeon processors will be the norm.
- Large web properties — You’ll sometimes see names like Facebook in the same sentence with ARM. A large web property is a special beast. First, it has large scale, so any power savings are likely to be valuable in aggregate. Second, the workloads are fairly tightly controlled and stable. Facebook’s data centers run all the individual workloads that make up the Facebook app, but those workloads are relatively stable from day to day. If the company can isolate some of those workloads, it can optimize the infrastructure appropriately. For instance, perhaps a portion of Facebook’s processing is IO-bound and doesn’t need heavy processing. This is a great place to introduce ARM into the environment. Facebook tightly controls what will run on the ARM processors and can port anything that they need to. Much of Facebook’s app is written in PHP and executes in the HipHop JIT compilation engine, for instance. If Facebook expands the JIT support to ARM, the company can rapidly move the bulk of the PHP code thereafter. Other web properties could pursue similar strategies. Both Google and Microsoft have written papers about using so-called “wimpy cores” for their processing, though they come to different conclusions (Google doesn’t like them, and Microsoft is cautiously optimistic).
So, the common theme through all of this is that x86 still holds a significant advantage over ARM with respect to application compatibility. If you’re running tightly-controlled applications, then power optimization using ARM might work for you, but if you’re expected to handle a variety of workloads and application code, x86 is the better choice.
Given that, Intel’s recently-announced Atom line may be just the ticket. While it isn’t as power-efficient as ARM in an absolute sense, it delivers a substantial power reduction will keeping x86 software compatibility and delivering server-class features like 64-bit processing, virtualization, and memory error correction. Microsoft found that there were a number of benefits to using Atom processors to process Bing workloads, though careful tuning was required to ensure performance goals were met.
Software compatibility is a powerful force that has pushed Intel’s x86 family to the pinnacle of the modern CPU hill. While ARM offers a distinct advantage over x86 in low power consumption, ARM requires that users abandon x86 software compatibility. In some cases, smartphones, tablets, and highly-controlled data center and cloud computing workloads, this is acceptable. Either the user doesn’t need or want to run existing x86 binaries or the code base is small enough that porting to ARM is a realistic task. Outside of these usage scenarios, however, ARM faces a daunting task. Intel’s recent micro-server optimized Atom processors offer a low-power option that retains x86 compatibility. In spite of these challenges, ARM is poised for significant growth in the smartphone and tablet market where x86 compatibility is neither expected or desired. Ultimately, growth in the smartphone/tablet market will help create a large ARM-based ecosystem that could challenge x86 in the data center, but this is a number of years away for all but specialized applications.