Cómo acelerar el emulador de Android*

en la Arquitectura Intel®
Por Costas Stylianou (Intel), publicado el 9 de agosto de 2013

Traducir

Sinopsis:
Si es un desarrollador Android* insatisfecho con el rendimiento del emulador de
Android, este documento es para usted. Una y otra vez, hemos oído de muchos
desarrolladores Android que el emulador es lento y molesto para trabajar, ¡pero no
tiene por qué ser así! Si usa un equipo razonablemente moderno con un procesador
Intel® que tenga Intel® Virtualization Technology habilitada y sistema operativo
Microsoft Windows* o Apple Mac OS*, entonces puede usar el Intel® Hardware
Accelerated Execution Manager (Intel® HAXM), o KVM para Linux*, para acelerar muy
fácilmente el emulador de Android en un orden de magnitud, lo que hará más rápidas
las pruebas y las depuraciones de sus aplicaciones de Android. En este documento se
explican todos los pasos necesarios para acelerar el emulador y cómo trabajar con él.
Luego explicamos cómo usar el kit de desarrollo nativo (NDK) para compilar código
nativo x86 y la forma correcta de enviar APK que contengan bibliotecas nativas x86 a
la tienda Google Play. Intel HAXM también se utiliza para acelerar el emulador de
Tizen*, pero esto se encuentra fuera del alcance de esta documentación. Para
obtener más información, visite tizen.org en la sección SDK.

Índice
1. Introducción
2. Instalación
2.1. Prerrequisitos
2.2. Instalación en Windows
2.3. Instalación en Linux
2.3.1. Instalación de KVM
2.4. Cómo crear un AVD (dispositivo virtual de Android*)
3. Métodos más conocidos
3.1. Cómo probar su aplicación con el emulador de Eclipse
3.2. Envío de varios APK para diferentes ABI comparado con el envío de binarios
pesados a Google Play
3.3. Compile su NDK para x86
3.3.1. Cómo agregar la ruta del NDK a su variable de entorno
 3.3.2. Cómo compilar con el NDK
3.3.3. Otra manera de compilar con el NDK

1. Introducción
Este documento lo guiará a lo largo de la instalación del Intel® Hardware Accelerated
Execution Manager (Intel® HAXM), un motor de virtualización asistido por hardware
(hipervisor) que usa Intel® Virtualization Technology (Intel® VT) para acelerar el
desarrollo de Android* en Windows*. También explica cómo configurar una máquina
virtual basada en kernel (KVM) asistida por hardware en Linux* y los métodos más
conocidos de compilación nativa y envío de aplicaciones a la tienda Google Play para
x86.

2. Instalación
2.1. Prerrequisitos
 Es necesario que tenga instalado el kit de desarrollo de software (SDK) de Android.
 Su equipo debe tener un procesador Intel compatible con Intel VT-x y EM64T, y con la
funcionalidad Execute Disable (XD) Bit habilitada desde el BIOS.

2.2. Instalación en Windows

Después de haber instalado el SDK de Android, abra el SDK Manager. En la sección
de extras, podrá encontrar el Intel HAXM.

Marque la casilla y haga clic en el botón “Install packages…”; cuando haya instalado
el paquete, el estado aparecerá como “Installed”, es decir, instalado, lo que es
engañoso, ya que este no es el caso. El SDK sólo copia el ejecutable de Intel HAXM
a su máquina, y depende de usted instalar el ejecutable.

Para instalar el ejecutable de Intel HAXM, busque en su disco duro IntelHaxm.exe (o

IntelHAXM.dmg en Mac OS X). Si dejó todos los valores predeterminados, debería
estar en C:\Program Files\Android\android-
sdk\extras\Intel\Hardware_Accelerated_Execution_Manager\IntelHaxm.exe.

Intel HAXM sólo funciona en combinación con una de las imágenes de sistema x86 de
procesador Intel® Atom™, que se encuentran disponibles para Android 2.3.3 (API 10),
4.0.3 (API 15), 4.1.2 (API 16), 4.2.2 (API 17). Estas imágenes de sistema de Intel se
pueden instalar de la misma manera que las imágenes basadas en ARM, mediante el
administrador de SDK.
Cuando hace clic en el ejecutable de IntelHaxm, se muestra una pantalla de
bienvenida como esta:
Puede ajustar la cantidad de memoria RAM que se asigna a Intel HAXM. Después de
ajustarla, haga clic en Next. La pantalla siguiente confirma la asignación de memoria.
Si todo está como lo desea, haga clic en Install.
A fin de poder instalar el Intel HAXM, debe tener habilitada Intel VT-x en su BIOS, si
no, verá un error como este durante la instalación:
Si se produce este error, vaya al BIOS y habilítela.

La segunda opción para descargar el Intel HAXM y la imagen de sistema del emulador
x86 Emulator System Image es ir directamente al sitio web:
http://software.intel.com/en-us/android y descargar de allí todos los componentes
necesarios.

2.3. Instalación en Linux

Los pasos para acelerar el emulador de Android en Linux son diferentes que en
Windows y Mac OS X, porque Intel HAXM no es compatible con Linux, así que es
necesario usar KVM en su lugar. Los pasos que se muestran a continuación
corresponden a Ubuntu* 12.04 y pueden diferir ligeramente en otras distribuciones de
Linux.

Al igual que en Windows (y Mac OS X), primero necesita descargar el SDK de Android
desde el sitio para desarrolladores de Android. Encontrará un paquete de ADT
(herramientas para desarrolladores de Android) que contiene tanto el entorno de
desarrollo integrado (IDE) de Eclipse* como el SDK de Android. Descargue el archivo
zip y extráigalo a su máquina Linux. Asegúrese de elegir la versión adecuada para su
distribución de Linux, ya sea de 32 o de 64 bits. Esto es fácil de verificar con el
comando:

file /sbin/init

Antes de comenzar a instalar los paquetes requeridos para KVM, es recomendable

que se asegure de tener el repositorio más reciente; para hacerlo, escriba:

sudo apt-get update

2.3.1. Instalación de KVM
Para instalar y ejecutar KVM, que es una solución de virtualización completa para
Linux en hardware x86 (es decir, Intel VT), primero necesita comprobar que su CPU
admita virtualización de hardware; para hacerlo, escriba:

egrep –c ‘(vmx|svm)’ /proc/cpuinfo

Si el resultado es 0, significa que su CPU no admite virtualización de hardware, la cual

es necesaria para ejecutar KVM. Si el resultado es 1 o más, puede continuar, pero de
todos modos asegúrese de que esté habilitada en el BIOS (ver Sección 2.2).

A continuación, debe instalar KVM, a menos que ya la tenga instalada. Para ver si su
procesador admite KVM, escriba:

kvm-ok

Si tiene KVM, verá esto:

"INFO: Your CPU supports KVM extensions

INFO: /dev/kvm exists
KVM acceleration can be used"

Pero debe ir al BIOS y activar Intel VT si ve esto otro:

"INFO: KVM is disabled by your BIOS

HINT: Enter your BIOS setup and enable Virtualization Technology (VT),
and then hard poweroff/poweron your system
KVM acceleration can NOT be used"

El siguiente paso es instalar la KVM y otros paquetes necesarios. Para hacerlo,

escriba:

sudo apt-get install qemu-kvm libvirt-bin ubuntu-vm-builder bridge-utils

En la ventana siguiente, puede seleccionar “No configuration” si no desea hacer

cambios a su configuración:
A continuación, agregue su usuario al grupo KVM y al grupo libvirtd. Para hacerlo,
escriba:

sudo adduser your_user_name kvm

sudo adduser your_user_name libvirtd

Después de la instalación, vuelva a iniciar sesión y los cambios surtirán efecto. Para
probar la instalación, escriba:

sudo virsh -c qemu:///system list

Ahora puede ir al paso siguiente, que es crear y ejecutar el dispositivo virtual de

Android (AVD). Este procedimiento es el mismo para Linux y Windows.

2.4. Cómo crear un AVD (dispositivo virtual de

Android*)
Después de instalar el SDK e Intel HAXM (o KVM en Linux), puede crear un
dispositivo virtual que tenga emulación acelerada por hardware. Para hacerlo, vaya a
AVD Manager y cree un nuevo dispositivo. Asegúrese de seleccionar Intel Atom
(x86) como CPU/ABI. Esta selección sólo aparece en el menú desplegable si tiene
instalada la imagen de sistema x86 Intel; para que los gráficos sean más suaves,
active la emulación de GPU cuando cree el AVD.
Haga clic en New y
cree su AVD x86.
Asegúrese de elegir
una API compatible
con imágenes de
sistema x86, que
CPU/ABI esté
establecido en x86 y
de haber habilitado la
emulación de GPU
(OpenGL ES*).
Cuando haya hecho
eso, haga clic
en Create AVD para
crear el AVD.
 Para iniciar el AVD
x86, haga clic en Start
y luego en Launch.

Si la instalación fue exitosa, cuando se esté iniciando el emulador, aparecerá un

cuadro de diálogo que indicará que Intel HAXM se está ejecutando en modo virtual
rápido.

Si no se convenció del todo de que está usando una imagen de sistema x86, siempre
tiene la posibilidad de revisar los detalles en “About phone” dentro del emulador.

La mejora de rendimiento que apreciará con Intel HAXM o KVM depende de su PC, la
unidad, la memoria, etc., pero debería ser de un orden de magnitud de entre 5x y 10x.
La captura de pantalla de abajo muestra una comparación paralela de un AVD x86
con HAXM habilitado frente a un AVD basado en ARM. El AVD x86 arrancó hasta
llegar a la pantalla de bloqueo en 15 segundos, mientras que el AVD no Intel tardó 40
segundos, una gran diferencia.
[La mejora de rendimiento que observará con el Intel HAXM (o la KVM) debería ser de
entre 5x y 10x, según la configuración de su sistema: el software y las cargas de
trabajo que se usen en la pruebas de rendimiento puede que hayan sido optimizadas
para rendimiento solamente en microprocesadores Intel. Las pruebas de rendimiento,
tales como SYSmark* y MobileMark*, se miden con sistemas informáticos,
componentes, software, operaciones y funciones específicos. Todo cambio en
cualquiera de esos factores puede hacer que varíen los resultados. Debe consultar
más información y otras pruebas de rendimiento que lo ayuden a evaluar
íntegramente las compras que contemple hacer, incluido del rendimiento del producto
al combinarlo con otros. Configuración: en este caso, se usó Mac Book Pro para las
pruebas. Si desea obtener más información,
visitehttp://www.intel.com/performance”]

3. Métodos más conocidos

3.1. Cómo probar su aplicación con el emulador de
Eclipse
Ya sea que se trate de una aplicación basada en NDK o una aplicación Dalvik*, puede
usar Intel HAXM para acelerar el emulador cuando haga las pruebas. Si está
desarrollando software con Eclipse, puede seguir estos sencillos pasos para
cerciorarse de que esté usando Intel HAXM cuando inicie el emulador.

En primer lugar, confirme que haya creado el AVD como se describió en el paso 2. Si
tiene el AVD listo, vaya a Run As -> Run Config, como se muestra abajo:
Debería ir a una página como esta:
Aquí, puede marcar la casilla para seleccionar el AVD que desee. Después de haber
creado su AVD y haber establecido su configuración, para comenzar a compilar su
proyecto y depurarlo con el emulador, seleccione Run As -> Android Application. Esto
iniciará automáticamente el AVD acelerado por hardware.

Una vez iniciado el AVD, debería ver la pantalla de inicio de su aplicación (después de
desbloquear la pantalla).

3.2. Envío de varios APK para diferentes ABI

comparado con el envío de binarios pesados a Google
Play
En el pasado, se enviaba un binario pesado de la aplicación desarrollada, que
contenía todos los binarios y los archivos NDK, sin poder diferenciar entre
arquitecturas. Eso significaba que los usuarios tenían que descargar el APK entero
que contenía archivos no relevantes para las arquitecturas específicas; es decir, los
usuarios de x86 descargaban código ARM y viceversa. El inconveniente de esto es
que si usted tenía un binario realmente pesado, el usuario se veía forzado a descargar
una gran cantidad de información no correspondiente al dispositivo. Normalmente,
esto es aceptable si el APK es de menos de 10 a 20 MB.

Intel/Google han implementado ahora un mecanismo de filtrado de CPU, es decir que

usted puede enviar ahora varios APK que contengan diferentes bibliotecas específicas
de cada arquitectura con sólo seguir el código de versiones sugerido que se muestra
abajo.
El primer dígito corresponde a la interfaz binaria de aplicación (ABI), o sea, 6 para
x86; luego el nivel de API objetivo, esto es, 11; el tamaño de la pantalla, 13; y luego el
número de versión de su aplicación: 3.1.0.

Asegúrese de tener al menos un número de versión de 8 dígitos y de asignar el primer

dígito más alto a la versión x86. En el ejemplo de arriba, se pondría 6 para x86, 2 para
ARMv7 y 1 para ARMv5TE. Al hacerlo, las versiones x86 serán las preferidas en los
dispositivos x86 y las versiones ARM en los dispositivos ARM.

Al seguir estas pautas, puede garantizar que sus usuarios obtengan el mejor
rendimiento del dispositivo que poseen. Como beneficio extra, puede evitar que los
usuarios intenten ejecutar aplicaciones en dispositivos específicos debido a problemas
de traducción de código.

Se puede encontrar más información en: http://software.intel.com/en-

us/articles/google-play-supports-cpu-architecture-filtering-for-multiple-apk.

3.3. Compile su NDK para x86

En esta sección se mostrará cómo compilar la parte NDK de su aplicación para x86.

A fin de que la aplicación basada en NDK se ejecute en un AVD x86, debe compilar
su biblioteca NDK para la arquitectura x86. Para hacerlo, siga estos pasos sencillos:

Abra la línea de comandos y navegue a la carpeta donde están sus archivos NDK,
como se muestra abajo:
Asegúrese de haber establecido la ruta de la variable de entorno, así podrá usar el
script de compilación ndk desde cualquier lugar.

3.3.1. Cómo agregar la ruta del NDK a su

variable de entorno
A fin de configurar la variable de entorno para el NDK, haga clic en Computer y
seleccione Properties. Vaya a Advanced system settings y busque “Environment
variables”. Seleccione Path y haga clic en Edit. Al final de la cadena “Variable Value”,
agregue la ruta a su carpeta raíz de NDK, la que contiene el archivo ndk-build.cmd,
como en la imagen de abajo:

3.3.2. Cómo compilar con el NDK

Después de haber navegado desde la línea de comandos a su carpeta NDK, ejecute:

ndk-build APP_ABI:=all

Esto compilará su archivo NDK para cada arquitectura disponible, es decir, ARMv5TE,
ARMv7, x86 y mips.

Si desea compilar para una arquitectura específica, reemplace “all” con las diferentes
arquitecturas. Por ejemplo:

ndk-build APP_ABI:=armeabi armeabi-v7a x86 mips

No olvide actualizar su proyecto en Eclipse para capturar la configuración más
reciente, o sea las últimas carpetas que se crearon con el script de compilación ndk.
En las bibliotecas de carpetas de sus proyectos, debería ver ahora cuatro carpetas,
una por cada una de las arquitecturas.

Ahora está listo para usar el AVD x86 con su aplicación NDK.

3.3.3. Otra manera de compilar con el NDK

Otra manera de compilar su código nativo para todas las arquitecturas, incluida x86,
es modificar su archivo Application.mk, que se encuentra en la carpeta jni. Si no
tiene un archivo Application.mk, puede crear uno usted mismo y agregar la instrucción
siguiente:

APP_ABI:=armeabi armeabi-v7a x86 mips

De este modo, cuando ejecute el archivo por lotes, es decir, el script de compilación
ndk, compilará las bibliotecas para todas las arquitecturas disponibles.

Además, para facilitar el uso, en lugar de especificar todas las arquitecturas, puede
simplemente poner “all”:

APP_ABI:=all
Para obtener información más completa sobre las optimizaciones del compilador,
consulte nuestro Aviso de optimización.