2. Agenda
•Android* on IA Momentum
•Developing Android Apps for IA
•App Development with x86 NDK
3. Smartphones with Intel Inside
Megafon Mint Lenovo K800 Orange San Diego
Russia China Unicom UK, France
Lava Xolo Motorola Razr I ZTE
India Europe, Latin America Grand X IN
4. Why Intel® Atom™ processors & Android?
Enhanced Video and Graphics
• 2D/3D HW accelerated graphics performance optimized for Intel Atom
Processors
• Full HD support(1080p) for local video playback and HW-accelerated video
encode/decode for multiple formats (H.264, MPEG-4, H.263, Flash, etc.)
• SW-optimized audio codecs for more efficient CPU utilization
Connectivity, Security and Mobility across devices
• Connectivity & mobility through WiFi Direct and WiDi support
• Wind River, an Intel subsidiary, offers solution accelerators for DLNA,
SyncML, additional Bluetooth profiles, etc.
• Built-in HW assist for secure boot and full disk encryption.
Performance Leadership
• Fast web page loading , optimized for Intel Atom processor
• Best multi-tasking performance enabled by Intel® Hyper-Threading
Technology
• Hundreds of Intel software engineers working to optimize Android on Atom
Design-in and Application Enabling
• Intel technical support for design in and custom application enabling
• Intel® System Software Tools 1.0 for Android for power and performance
tuning
• Applications developed to Android SDK APIs run “as is” on all Intel platforms
• Most Android NDK applications run on Atom with simple recompile
5. Focusing on Mobile Experiences
Applications & Services, Operating Systems, Platforms and Silicon
BRAND EXPERIENC SECURITY TECHNOLOG
ES Y
+ 2012 2013 2014
32nm 22nm 14nm
#7 Largest
And More Dedicated
Security
Company
Entertainment Business Education Gaming Basic
6. Agenda
•Android* on IA Momentum
•Developing Android Apps for IA
•App Development with x86 NDK
7. Android* on Intel® Atom™ processor-based platforms
Applications
Apps
Home Contacts Phone Browser …
Application Framework
Experience
Activity Windows Content View …
Manager Manager Providers System
Notifica-
User
Package Telephony Resource Location tion
Manager Manager Manager Manager Manager
Libraries Android Runtime
Surface Media Core
Middleware
Manager Framework SQLite Libraries
Dalvik
OpenGL | ES FreeType WebKit Virtual
Machine
SGL SSL libc
…
Linux Kernel
Operating
Display Camera Flash Binder
System
Driver Driver Memory (IPC)
Driver Driver
Keypad WiFi Audio Power
Driver Driver Drivers Manage-
ment
8. Android* Optimizations for Intel® Atom™-based devices
Performance Tuning Power Reduction
• Dalvik VM runtime optimization • Power Management for Android
• x86 trace-based JIT and Native • OpenGL ES 1.1/2.0 Driver
Code Generation
• Enriched memory management • HW Overlay
(e.g., garbage collection)
• HW Accelerated Media
• JNI streamlining decode/encode
• Tuning of native libraries • Library to integrate w/ Android &
reference implementation (MIX)
• Bionic optimizations
• Standard SoC
• Javascript & HTML5 optimization drivers, middleware and
applications optimized for power
Intel has a rich history optimizing Java for IA. We’ve applied that
knowledge to Dalvik Java with impressive results
9. Performance Gains from optimizations
Dalvik Runtime Optimizations Android* Native Library
1.8 No SSE2 with SSE
No Trace JIT1
Trace JIT enabled 1.6
7
1.4
6
1.2
Performance
5
4 1
Performance
3 0.8
2 0.6
1
0.4
0
0.2
Linpack CaffeineMark 0
Up to 6x Improvement! HTML5 HTML5 HTML5 HTML5 JetBoy* Album
Slideshow Zoom Fancy Show Animation Stress Slideshow(SA)
Significant improvements in both web (HTML5)
and Java* workloads due to optimizations for Intel
Source: Intel Software and Solutions Group SSE instructions in Android graphics libraries.
1 Intel Z670 reference design with Honeycomb
2 SSE = Streaming SIMD Testing on Medfield (Z2460) CDK with Gingerbread.
10. Faster Emulation and Prebuilt Atom Images
Pre-built Atom Images
• Android SDK manager has x86 emulation
images built-in
• To emulate an Atom-based Android
phone, install the “Intel Atom x86 System
Image” available in the Android SDK
Manager
• http://software.intel.com/en-us/articles/installing-the-intel-
atom-tm-android-x86-emulator-image-add-on-from-the-
android-sdk-manager/
Much Faster Emulation
• Intel® Hardware Accelerated Execution
Manager (HAXM) for Mac and Windows
uses Intel® Virtualization Technology (VT)
to accelerate x86 emulation by an order of
magnitude
• VT is supported in Linux* (KVM) for x86
• http://software.intel.com/en-us/articles/intel-hardware-
accelerated-execution-manager/
11. Intel® Graphics Performance Analyzers (Intel® GPA)
System Analyzer
• Provides real-time
performance analysis of your
OpenGL-ES* applications
• Conduct real-time
experiments with OpenGL-ES*
state overrides
• Triage system-level
performance with CPU, Power
and GPU metrics
Note: Public release of Intel GPA for Android* is targeted for 2H-2012
12. Using Intel® Graphics Performance Analyzers
1. Install APK 2. Run Intel® GPA System Analyzer 3. View Profile
on development machine
13. Agenda
•Android* on IA Momentum
•Developing Android Apps for IA
•App Development with x86 NDK
14. Android* Native Development Kit (NDK)
Build scripts/toolkit to incorporate native
c/c++ code in Android Apps via JNI
Why Use NDK?
• Performance intensive tasks
• e.g.: signal-processing/custom-algorithms
• Differentiated app that takes advantage
of direct CPU/HW access
• e.g.: specialized games
• Software Code reuse
• Legacy Code
• Huge legacy IA code base & libraries
15. Android* Application Overview
Dalvik Application
Android NDK Application Java Native Java
Library Source
Compile Compile
with Javac with Javac
Dynamic Java Native Android
Library Library Class App Class
Application
File
Compile and Create C header
Link C Code with Javah -jni
Makefile
C Source Header
Code File
16. Adding Native Code to Android * Apps
Standard Android* Project Structure
Native Sources - JNI Folder
1. Create JNI folder 3. Create Android.mk
for native sources with build rules
2. Reuse or create
native c/c++ sources
NDK will automatically
create ABI lib folder.
4. Build Native code using
NDK-BUILD script.
19. Code Re-use Example (cont’d)
2. Define JNI Native Calls in Java* source to access CPUID native code
3. Declare call to Load native lib cpuid.so (“cpuid”)
20. Code Re-use Example (cont’d)
4. Build with “ant” to generate Java* classes
5. Use “javah” to generate JNI headers
21. Code Re-use Example (cont’d)
6. Implement native source stub based on generated header stub
7. Create Android.mk build rules for compiling native code with NDK
22. Code Re-use Example (cont’d)
8. Compile native sources with “ndk-build” script : specify APP_ABI=x86
9. Rebuild the final APK with ant, and optional install on emulator!
23. Porting Existing NDK-based Apps
A simple 4-step process:
1. Recompile existing native module with APP_ABI=all
2. Update the project to use Android* platform of choice (e.g. ICS
target API is “Android-15”)
24. Porting Existing NDK-based Apps (cont’d)
3. Repackage the project into final APK file
- Example: Using “ant debug” for demo purposes
4. Install/Test the App (APK) on x86 Android* emulator or device
25. NDK Tips: Let the NDK Do the Hard Work
• Include all ABIs in jni/Application.mk
Build ARM v5…
Build ARM v7a…
Build ARM x86…
• The NDK will generate highly optimized code for all target ABIs
26. NDK Tips: Use “Fat Binaries”
• Fat Binaries are .apk files that supports multiple ABIs
• Use “APP_ABI := armeabi armeabi-v7a x86” in Application.mk
– Can use “APP_ABI := all” since NDK version r7
libs/armeabi
Source Code
ndk-build apkbuilder
libs/armeabi-v7a
…
Application.mk
with multiple ABIs
libs/x86
27. Install Will Select The Right .so
Use lib/armeabi libraries
Use lib/armeabi-v7a libraries
Use lib/x86 libraries
• Android Market will automatically filter applications based on ABI support
29. Intel Technology is Used in a Broad Range
of leading Smartphones and Tablets …
K800
San Diego
Tab
Xoom
Editor's Notes
Intel has assembled a world-class software organization including more than 10,000 plus software-focused employees, and expertise from Wind River, McAfee and a dozen other recent acquisitions. All of this together means great news for our customer.We’ve categorized Intel’s advantages in a classic Intel fashion: with an acronym! “BEST”represents Intel’s Brand, Experiences, Security, Technology advantages. Brand: We should not underestimate the power of our brand, which is ranked as the 7th most influential by people who track this. We get this recognition in part because we have the best sales field in the tech industry and world-class marketing, especially in these emerging areas where Intel has little to no market share.Experiences: This is a distinct advantage for Intel.No single ARM vendor will offer the suite of ‘siliconized’ experiences. This includes Continuum apps to Intel Insider, Anti-Theft technology, and much more.Security: It seems like every day we are reading about another breech or e-attack. With Intel’s silicon plans and McAfee acquisition, Intel will offer the most protected device, data, malware, and identity protection in the industry. Withthe dramatic increase in issues …this is going to be more and more relevant.Technology: We are moving faster than Moore’s Law, targeting 4 process technology transitions in four years. We will lead on performance per battery charge versus ARM starting this year and only get better in 2013 and 14.
We optimize the Android stack from top to bottom:For the Application layer, we validate the top Android Market apps to ensure good performance on Atom and we incent developers to port their native apps to Atom.For the Application Framework we’re continuously optimizing web technologies such as HTML5 and JavaScript – and our results have been exceptional.For the Android Dalvik Virtual Machine (VM): we’ve applied more than a decade of experience in optimizing Java to optimizing Dalvik Java on Atom. For example, Intel’s Trace JIT compiler yields a 6x performance gain!For native libraries, we optimize the Webkit browser and V8 engines, the Bionic C and graphics libraries, and more.Finally, for the Linux Kernel and drivers: Intel is the 2nd largest contributor to the Linux code base in the world and employs many of its top software talent. We finely tune the Linux kernel and drivers for the best power, performance and memory footprint. ---------------------------- For Reference Only (not speaking points) ---------------3+ years of Android Optimizations for AtomDalvik VM Fast Interpreter optimizations in Android main branch since GingerbreadFor native apps, Intel Native Code Generation (NCG) pre-compiles compute intensive code and stores it locally so it runs faster the next time the app is called.SSE offloads in Android native libraries -> up to 1.7x improvement in popular workloadsJavascript, HTML5, Webkit, V8 browser optimizationsLLVM and Renderscript optimizationsDefinitions:The V8 JavaScript Engine is an open sourceJavaScript engine developed by Google. It ships with the Google Chrome web browser. V8 increases performance by compiling JavaScript to native machine code before executing it, versus executing bytecode or interpreting it.Bionic libc is a derivation of the BSDstandard C library code that was originally developed by Google for the Androidembedded system operating system. Bionic has several major Linux-specific features. Bionic is much smaller than glibc and somewhat smaller than uclibc.
On the left, you’ll notice we get up to a 6x boost from our optimized Trace JIT (Just in Time) compiler. The Linpackand CaffeineMark workloads run completely in the context of the Android Dalvik Java Virtual Machine. Caveat: Although we aim to upstream our optimizations as quickly as is practical, it is sometimes a long, drawn out process. Device developers always work directly with Intel to get the latest optimizations. Software developers who are part of our early, high touch programs as well as, of course, developers using commercial Atom systems will always have these optimizations. On the right, the green bars reflect the HTML5 and Java graphics boosts we get from adding Intel SSE instructions to Android native libraries.---------------------- For Reference Only, not for speaking points -----------------------------------4 workloads on left are HTML5 workloads that run in context of the Android browser. (Android browser is webkit-based and uses V8 JavaScript engine; similar to Chrome.)2 workloads on right are Android Java workloads that run in the context of Android’s Java graphics framework.These are not native apps, not written using the NDK; written using Java and the Java class libraries that Android provides (jetboy, Album).Our engineers constructed these workloadsto evaluate the graphics performance of our platforms. For example, tested Canvas capabilities – new HTML5 feature to do more sophisticated graphics -- and examined the % of time being spent on different routines in the platform and then hand-optimized the routines using SSE instructions.In most cases, we try to give these optimizations back to Android to upstream. Some are in the JPG libraries (e.g., HTML5 slideshow) already – native libraries in Android. Making the browser work great on IA:V8 JavaScript engine -> in AOSP for ARM; Intel enabled for x86Chromium HTTP stack - in AOSP for ARM; Intel enabled for x86Webkit-V8 interface optimization - speeds up some JavaScript image processing operationsSSE versions of image rendering routines
Intel works every day with Google to ensure things like our system images are linked to by the Android SDK Manager.Today we have Gingerbread system images available for the emulator. Look for ICS images imminently.We recently unveiled the Intel Hardware-Accelerated Execution Manager which speeds up Android emulation significantly. Google was so impressed that they decided to show it off at a recent Game Developer Conference in the Bay Area.