27 julio, 2015
Este articulo forma parte de una serie de notas acerca de desarrollo patrocinadas por Intel.
Para más información, puedes ingresar a la Zona para desarrolladores de Intel.
Introducción
El tema del momento en el mercado móvil son los sistemas Android de 64 bits. En septiembre de 2013, Apple lanzó el iPhone 5 con un procesador incorporado A7 de 64 bits. Y así se inició la carrera tecnológica en el sector de dispositivos móviles.
Resulta que el GNU/Linux con kernel basado en Android admite desde hace tiempo procesadores con registros de 64 bits. Ubuntu es “GNU/Linux”, mientras que Android es “Dalvik/Linux”. Dalvik es la máquina virtual (VM) de proceso del sistema operativo Android de Google, que ejecuta específicamente aplicaciones escritas para Android. Por esta razón, Dalvik es una parte esencial de la pila de software de Android, que se utiliza con habitualidad en dispositivos móviles tales como teléfonos y tabletas electrónicas, y en los últimos tiempos también en televisores y prendas inteligentes. Sin embargo, todos los desarrolladores que usan el NDK tienen que recompilar sus programas en función de la arquitectura más reciente, y la facilidad o dificultad de esto último depende de las herramientas que proporcione Google. Además, Google debe ofrecer compatibilidad con versiones anteriores, por ej, las aplicaciones de 32 bits del NDK deben funcionar en Android de 64 bits.
Los primeros procesadores de 64 bits se crearon en el tercer trimestre de 2013; se trataba del nuevo y poderoso sistema en chip (SoC) multinúcleo para equipos de escritorio y móviles. La nueva familia SoC consistía en procesadores Intel AtomTM para tabletas y dispositivos 2 en 1, procesadores Intel Celeron y procesadores Intel Pentium para 2 en 1, equipos portátiles, PC de escritorio y PC todo en uno.
En octubre de 2014, Google puso al alcance de los desarrolladores la versión preliminar de un emulador de imágenes para Android L de 64 bits. De esa manera, podían probar sus programas y reescribir el código, si lo necesitaban, antes del lanzamiento del sistema operativo. En un blog de Google+, varios desarrolladores indicaron que no era necesario portar los programas creados por entero con Java. Los ejecutaban tal cual en la versión L del emulador, compatible con la arquitectura de 64 bits. Aquellos que usaban otros lenguajes, en especial C y C++, tenían que hacer algunos ajustes antes de compilar en función del nuevo NDK para Android. Existen en el mercado versiones más viejas de dispositivos Android con procesadores de 64 bits; sin embargo, los fabricantes quizá tengan que actualizarlos rápido o escaseará el software para los usuarios.
Emulador de Android L de 64 bits
En junio de 2014, Google anunció que Android admitiría 64 bits en su versión L. Se trata de una noticia maravillosa para quienes quieren que sus dispositivos y aplicaciones funcionen con el mayor rendimiento posible. Algunos de los beneficios que destaca Google para esta actualización son el aumento de la cantidad de registros, un incremento del espacio de memoria direccionable y nuevos conjuntos de instrucciones.
El emulador de Android admite muchos elementos de hardware que se encuentran en dispositivos móviles, entre ellos los siguientes:
- Una CPU ARM y su correspondiente unidad de gestión de memoria (MMU)
- Una pantalla LCD de 16 bits
- Uno o más teclados (un teclado QWERTY y la cruceta o los botones asociados)
- Un chip de sonido con entrada y salida
- Particiones de memoria flash (emuladas por archivos de imagen de disco en la máquina para desarrollo)
- Un módem GSM, con una tarjeta SIM simulada
- Una cámara; uso de una cámara web conectada a la computadora para desarrollo
- Sensores, tales como el acelerómetro, que utilizan datos de un dispositivo Android conectado por USB
Es un importante paso adelante para desarrollar los dispositivos y aplicaciones que preferimos. Desafortunadamente, tendremos que esperar la salida de Android L para disfrutar de estas mejoras de rendimiento. Pocas semanas después de la aparición de Android L, se debería publicar la revisión 10 del Kit de Desarrollo Nativo (NDK), compatible con las tres arquitecturas de 64 bits en las que funcionará la nueva versión de Android: arm64-v8a, x86_64 y mips64. El código de las aplicaciones creadas con Java tendrá automáticamente un rendimiento superior en la nueva arquitectura de 64 bits x86. Google ha actualizado el NDK a la revisión 10b y agregó una imagen de emulador con la cual los desarrolladores pueden preparar sus aplicaciones de modo que se ejecuten en dispositivos fabricados con chips de 64 bits de Intel.
Hay que tener presente que el NDK es solo para aplicaciones nativas, no para aquellas creadas con Java en el SDK de Android común. A quienes hayan estado esperando con ansias que sus aplicaciones se ejecuten en 64 bits o necesiten actualizar a la versión más reciente del NDK, les recomendamos visitar el portal para desarrolladores.
Desarrollo de aplicaciones con el NDK para Android x86_64
El Kit de Desarrollo Nativo (NDK) es un conjunto de herramientas que permite a los desarrolladores implementar partes de una aplicación mediante el uso de lenguajes de código nativo tales como C y C++. Para ciertos tipos de aplicaciones, es útil porque posibilita volver a utilizar bibliotecas de código ya escritas en esos lenguajes, pero la mayoría de las aplicaciones no necesitan el NDK para Android. Hay que sopesar los beneficios y las desventajas de utilizarlo. En particular, usar código nativo en Android por lo general no supone una mejora de rendimiento apreciable, pero siempre implica un aumento de complejidad de la aplicación. Solo habría que emplear el NDK si es esencial para la aplicación, no porque se prefiera programar en C/C++.
La versión más reciente del NDK para Android se puede descargar haciendo click aquí.
En esta sección, veremos cómo compilar una aplicación de ejemplo con el NDK para Android.
Utilizaremos la aplicación de ejemplo san-angeles, que se encuentra en el directorio de ejemplos del NDK:
$ANDROID_NDK/samples/san-angeles
El código nativo está en el directorio jni/:
$ANDROID_NDK/samples/san-angeles/jni
El código nativo se compila para arquitecturas de CPU específicas. Es posible que las aplicaciones para Android contengan bibliotecas para varias arquitecturas en un único archivo apk.
Para establecer arquitecturas de destino, hay que crear el archivo Application.mk dentro del directorio jni/. La siguiente línea compila las bibliotecas nativas para todas las arquitecturas admitidas:
APP_ABI := all
A veces, es mejor especificar una lista de arquitecturas de destino. Esta línea compila las bibliotecas para las arquitecturas x86 y ARM:
APP_ABI := x86 armeabi armeabi-v7a
Como estamos creando una aplicación de 64 bits, debemos compilar las bibliotecas para arquitecturas x86_64:
APP_ABI := x86_64
La manera de compilar las bibliotecas es ejecutar la siguiente orden dentro del directorio de ejemplos:
cd $ANDROID_NDK/samples/san-angeles
Cuando la compilación se haya efectuado sin problemas, se debe abrir el ejemplo en Eclipse* como aplicación de Android y hacer clic en “Run” para ejecutarlo. Se debe seleccionar el emulador o un dispositivo Android conectado en el cual se desee ejecutar la aplicación.
Para lograr compatibilidad con todos los dispositivos existentes, es necesario compilar la aplicación para todas las arquitecturas. Si el archivo apk con las bibliotecas para todas las arquitecturas es demasiado grande, quizá convenga seguir las instrucciones de la Ayuda de Google Play para múltiples apk y preparar un apk distinto para cada plataforma.
Comprobación de las arquitecturas admitidas
Esta instrucción comprueba qué arquitecturas incluye el archivo apk:
aapt dump badging file.apk
En la línea siguiente aparecen todas las arquitecturas:
native-code: 'armeabi', 'armeabi-v7a', 'x86', 'x86_64'
Otro método es abrir el archivo apk como archivo zip y ver los subdirectorios del directorio lib/.
Optimización de programas de 64 bits
Reducción de la memoria que consumen las aplicaciones
Cuando un programa se compila en el modo de 64 bits, consume más memoria en la versión de 32 bits. A menudo, este aumento pasa inadvertido, pero el consumo de memoria puede llegar a ser el doble que en las aplicaciones de 32 bits. Los siguientes son los factores que determinan la cantidad de memoria que se consume:
- Algunos objetos, como por ejemplo los punteros, necesitan mucha memoria
- Alineación de datos y relleno de estructuras de datos
- Aumento del consumo de la memoria de pila
Los sistemas de 64 bits tienen mayor cantidad de memoria disponible para las aplicaciones de usuario que los sistemas de 32. Por lo tanto, si un programa usa 300 MB en un sistema de 32 bits con 2 GB de memoria, pero necesita 400 MB en un sistema de 64 bits con 8 GB de memoria; en términos relativos, el programa usa tres veces menos memoria en un sistema de 64 bits. La desventaja es la pérdida de rendimiento. Si bien los programas de 64 bits son más rápidos, extraer mayor cantidad de datos de la memoria podría anular todas las ventajas e incluso reducir el rendimiento. Transferir datos entre la memoria y el microprocesador (caché) es costoso.
Una manera de reducir el consumo de memoria es optimizar las estructuras de datos. Otra es usar tipos de datos que ahorren memoria. Por ejemplo, si tenemos que almacenar muchos números enteros y sabemos que sus valores nunca superarán UINT_MAX, podemos usar el tipo sin signo (“unsigned”) en lugar de tamaño t (“size t”), como se verá en la próxima sección.
