Last week, Arm gave us a glimpse into the future by unveiling the next-generation of Arm processors: the Armv9 architecture. This is a huge deal for the future of mobile devices. The device you’re carrying around in your pocket is almost certainly running on an Arm-based processor, so these processor-level improvements will lead to faster, smarter, and more secure devices that you use day-to-day.
There are two groups of features in Armv9 that we’re particularly excited about. The first is that next-generation Arm processors will have security built in right at their very core. That includes features like the new Confidential Compute Architecture built around TrustZone, as well as brand new security features like Memory Tagging Extensions (MTE) specifically designed to help secure devices against sophisticated memory-corruption attacks.
The second exciting group of features are all about performance. Armv9 improves Scalable Vector Extension to SVE2, adds new features and optimizations for machine learning, and adds new features like the Transactional Memory Extension (TME) to make parallelizable programs even faster. These improvements won’t just make devices faster, they’ll also be helping power even better quality video, graphics, and games on your next-gen device.
Of course, these upcoming new Armv9-based devices mean a whole new class of devices to virtualize. And perhaps it’s worth explaining how we do it, and why we built our hypervisor to run natively on Arm.
Most device emulators rely on either dynamic translation technology or cross-compilation to emulate the software you’d normally find on a device. Dynamic translation uses software to translate each Arm instruction in the program into equivalent instructions that your non-Arm processor knows how to interpret. That gives a very accurate translation of how the program will behave, but unfortunately that translation takes both time and power to achieve. Over the course of emulating a substantial program, that extra time and power quickly adds up, giving you a slow and unresponsive emulated device that burns its way through your laptop’s battery life in minutes.
Cross-compilation is a different approach, and comes with different problems. For example, the emulated software is no longer exactly the same as the same software on a real device, and these differences can lead to missing bugs during development that suddenly show up when you deploy to real devices. Cross-compilation also doesn’t work if your application relies on libraries you don’t have source-code for.
At Corellium, we avoid all of these problems using our secret weapon: the Corellium Hypervisor on Arm (CHARM). This hypervisor is built from the ground-up to virtualize Arm-based devices, and we run them directly on Arm servers. Mobile applications on Corellium run natively fast because we run them directly on a modern Arm processor. The application, its shared libraries, the operating system, and all of the supporting services on the mobile device are running almost exactly as they would on a physical device. And that means they’re running the same logic in your virtual device as they would on a real device, with byte-for-byte and instruction-for-instruction clarity.
We’re excited for the release of Armv9. We don’t yet know what the future holds, but we already know the next generation of devices will be better, faster, and more secure than ever. And whatever those devices look like, we’ll be here at Corellium, giving you virtual, full-fidelity, and ultra-high performance virtual devices, powered by our next-gen Arm servers.
If you’re interested in learning more about Corellium’s leading Arm virtualization platform and tools, visit us at corellium.com and sign up for a free trial!