Accélération de l'émulateur Android sur l'architecture Intel®

beat-stauber (Intel)

Si vous êtes un développeur Android mécontent des performances de l'émulateur Android, ce document est pour vous. Nous avons fréquemment entendu de nombreux développeurs Android se plaindre de la lenteur et du manque de convivialité de l'émulateur, mais ça ne devrait pas être le cas…

N'hésitez pas à commenter cet article ! Commentez

- Titre : Accélération de l'émulateur Android sur l'architecture Intel®

- Auteur : beat-stauber (Intel)

- Parution : 16 octobre 2013

- Mise à jour : 28 novembre 2013

- Licence : Copyright ® 2013 Developpez LLC. Tous droits réservés Developpez LLC. Aucune reproduction, même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes, documents et images sans l'autorisation expresse de Developpez LLC. Sinon vous encourez selon la loi jusqu'à trois ans de prison et jusqu'à 300 000 € de dommages et intérêts.

Sommaire

- Extrait

- I. Introduction

- II. Installation

- II-A. Conditions préliminaires

- II-B. Installation sur Windows

- II-C. Installation sur Linux

- II-C-1. Installation de KVM

- II-D. Création d'un AVD (Android Virtual Device, appareil virtuel Android)

- III. Méthodes les mieux connues

- III-A. Tester votre application avec l'émulateur d'Eclipse

- III-B. Soumettre plusieurs APK pour différentes ABI vs. soumettre des fichiers binaires universels à Google Play

- III-C. Compiler votre code natif pour X86 en utilisant le NDK

- III-C-1. Ajouter le chemin d'accès du NDK à votre variable d'environnement

- III-C-2. Compiler avec le NDK

- III-C-3. Autre manière de compiler avec le NDK

- IV. Remerciements

Extrait

Si vous êtes un développeur Android mécontent des performances de l'émulateur Android, ce document est pour vous. Nous avons fréquemment entendu de nombreux développeurs Android se plaindre de la lenteur et du manque de convivialité de l'émulateur, mais ça ne devrait pas être le cas ! Si vous utilisez un ordinateur assez récent doté d'un processeur Intel® sur lequel la technologie de virtualisation Intel® est activée et exécutant Microsoft Windows ou Apple Mac OS, vous pouvez utiliser Intel® Hardware Accelerated Execution Manager, ou KVM pour Linux, pour accélérer considérablement l'émulateur Android très facilement, ce qui permettra d'accélérer les essais et le débogage de vos applications Android. Ce document décrit toutes les étapes nécessaires pour accélérer l'émulateur et comment l'utiliser. Nous expliquons ensuite comment utiliser le NDK pour compiler des codes x86 natifs et la manière correcte de soumettre des APK contenant des bibliothèques x86 natives à la boutique Google Play.

I - Introduction

Ce document va vous guider dans l'installation d'Intel® HAXM (Intel® Hardware Accelerated Execution Manager), un moteur de virtualisation (hyperviseur) assisté par le matériel qui utilise la technologie de virtualisation Intel® pour accélérer le développement Android sous Windows. Il explique également comment configurer une KVM assistée par le matériel sous Linux et les méthodes les mieux connues de compilation de code natif et de soumission d'applications à Google Play Store pour x86.

II - Installation

II-A - Conditions préliminaires

- Le SDK Android doit être installé.

- Votre ordinateur doit posséder un processeur Intel prenant en charge la technologie de virtualisation Intel, EM64T et le bit XD (Execute Disable), activés dans le BIOS.

II-B - Installation sur Windows

Après avoir installé le SDK Android, ouvrez le gestionnaire du SDK. Intel HAXM se trouve dans la section des extras.

Cochez la case et cliquez sur le bouton « Install packages… » (Installer les packages). Après avoir installé le package, l'état s'affiche comme « Installed » (Installé), ce qui est trompeur car ce n'est pas le cas. Le SDK copie uniquement le fichier exécutable Intel HAXM sur l'ordinateur et c'est à vous d'installer.

Pour installer le fichier exécutable Intel HAXM, recherchez le fichier IntelHaxm.exe (ou IntelHAXM.dmg sur Mac OS X) sur votre disque dur. Si vous avez conservé les valeurs par défaut, il devrait se trouver sous C:\Program Files\Android\android-sdk\extras\Intel\Hardware_Accelerated_Execution_Manager\IntelHaxm.exe.

Intel HAXM fonctionne uniquement en association avec une des images système x86 du processeur Intel® Atom™, disponibles pour Android 2.3.3 (API 10), 4.0.3 (API 15), 4.1.2 (API 16), 4.2.2 (API 17). Ces images système Intel s'installent exactement comme les images ARM, par le gestionnaire du SDK.

Lorsque vous cliquez sur le fichier exécutable IntelHaxm, un écran d'accueil s'affiche comme suit :

Vous pouvez spécifier la quantité de mémoire allouée à Intel HAXM. Après cela, cliquez sur Next (Suivant). L'écran suivant confirme l'allocation de mémoire. Si la configuration vous convient, cliquez sur Install (Installer).

Pour pouvoir installer Intel HAXM, la technologie de virtualisation Intel doit être activée dans le BIOS, autrement, vous obtenez une erreur comme celle-ci pendant l'installation :

Si vous obtenez cette erreur, accédez au BIOS et activez cette fonctionnalité :

La deuxième option de téléchargement d'Intel HAXM et de l'image système de l'émulateur x86 consiste à accéder directement au site Web : http://software.intel.com/fr-fr/android et à télécharger les composants nécessaires.

II-C - Installation sur Linux

Les étapes permettant d'accélérer l'émulateur Android pour Linux sont différentes de celles de Windows et de Mac OS X car Intel HAXM n'est pas compatible avec Linux et vous devez donc utiliser une KVM (kernel-based virtual machine) à la place. Les étapes ci-dessous ont été réalisées à l'aide d'Ubuntu 12.04 et peuvent être légèrement différentes avec d'autres distributions Linux.

Comme sous Windows (et Mac OS X), vous devez tout d'abord télécharger le SDK Android depuis le site des développeurs Android. Vous trouverez une archive ADT (Android Developer Tool) qui contient l'IDE Eclipse et le SDK Android. Téléchargez le fichier zip et décompressez-le sur votre ordinateur Linux. Veillez à bien télécharger la version correspondant à votre distribution Linux, 32 bits ou 64 bits. Vous pouvez le faire facilement à l'aide de la commande :

file /sbin/init

Avant d'installer les packages nécessaires à KVM, nous vous recommandons de vérifier que vous disposez du dernier référentiel, ce que vous pouvez faire en tapant :

sudo apt-get update

II-C-1 - Installation de KVM

Pour installer et exécuter KVM, qui est une solution de virtualisation complète pour Linux sur du matériel x86 (à savoir, technologie de virtualisation Intel), vous devez tout d'abord vérifier si votre UC prend en charge la virtualisation matérielle, ce que vous pouvez faire en tapant :

egrep -c ‘(vmx|svm)' /proc/cpuinfo

Si le résultat est 0, votre UC ne prend pas en charge la virtualisation matérielle, nécessaire pour l'exécution de KVM. Si le résultat est 1 ou plus, vous pouvez y aller, mais veillez quand même à ce qu'elle soit activée dans le BIOS .

Ensuite, vous devez installer KVM, sauf si c'est déjà fait. Vous pouvez vérifier si votre processeur prend en charge KVM en tapant :

kvm-ok

Si vous avez KVM, vous verrez ça :

"INFO: Your CPU supports KVM extensions (Votre UC prend en charge les extensions KVM)INFO: /dev/kvm exists (/dev/kvm existe)KVM acceleration can be used" (L'accélération KVM peut être utilisée.)

Autrement, si vous voyez ce qui suit, vous devez accéder au BIOS et activer la technologie de virtualisation Intel :

"INFO: KVM is disabled by your BIOS (KVM est désactivé dans votre BIOS)HINT: Enter your BIOS setup and enable Virtualization Technology (VT),and then hard poweroff/poweron your systemKVM acceleration can NOT be used" (CONSEIL : accédez à la configuration du BIOS et activez la technologie de virtualisation, puis arrêtez et redémarrez votre système avec le bouton matériel. L'accélération KVM ne peut PAS être utilisée.)

L'étape suivante consiste à installer la KVM et quelques autres packages nécessaires. Pour cela, tapez :

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

Ensuite, ajoutez votre utilisateur au groupe KVM et au groupe libvirtd. Pour cela, tapez :

sudo adduser your_user_name kvm sudo adduser your_user_name libvirtd

Après l'installation, ouvrez une nouvelle session afin que les modifications prennent effet. Vous pouvez tester l'installation en tapant :

sudo virsh -c qemu:///system list

Vous êtes maintenant prêt à passer à l'étape suivante, qui consiste à créer et exécuter l'AVD (Android Virtual Device). Cette procédure est la même pour Linux et Windows.

II-D - Création d'un AVD (Android Virtual Device, appareil virtuel Android)

Après avoir installé le SDK et Intel HAXM (ou KVM pour Linux), vous pouvez créer un appareil virtuel possédant une émulation accélérée par le matériel. Pour cela, accédez au gestionnaire AVD Manager et créez un nouvel appareil. Veillez à bien sélectionner Intel Atom (x86) comme UC/ABI. La sélection s'affiche dans la liste déroulante uniquement si l'image système Intel x86 est installée. Pour que les graphiques soient plus lisses, activez l'émulation du GPU lors de la création de l'AVD.

Cliquez sur New (Nouveau) et créez votre AVD x86. Veillez à sélectionner une API prise en charge par une image système x86, que l'UC/ABI est définie sur x86, et que vous avez activé l'émulation du GPU (OpenGL ES). Après cela, cliquez sur Create AVD (Créer l'AVD) pour créer l'AVD.

Vous pouvez lancer l'AVD x86 en cliquant sur Start (Démarrer), puis sur Launch (Lancer).

Si l'installation est réussie, lorsque l'émulateur démarre, une boîte de dialogue s'affiche montrant qu'Intel HAXM est exécuté en mode virtuel rapide.

Si vous n'êtes toujours pas convaincu que vous utilisez une image système x86, vous pouvez toujours examiner les détails dans la section « About phone » (À propos du téléphone) dans l'émulateur.

Les gains de performances que vous constaterez avec Intel HAXM ou KVM dépendent de votre PC, lecteur, mémoire, etc., mais les performances devraient être entre 5 et 10 fois supérieures. La capture d'écran ci-dessous montre une comparaison côte à côte d'un AVD x86/HAXM et d'un AVD ARM. L'AVD x86 a démarré jusqu'à l'écran de verrouillage en 15 secondes alors que l'AVD non Intel a pris 40 secondes, une grande différence.

Les performances obtenues avec Intel HAXM (ou KVM) doivent être de 5 à 10 fois supérieures, selon la configuration de votre système : les logiciels et les charges de travail utilisés dans les tests de performances peuvent n'avoir été optimisés que pour des performances sur microprocesseurs Intel. Les tests de performances, comme SYSmark et MobileMark, sont mesurés à l'aide d'éléments spécifiques : systèmes informatiques, composants, logiciels, opérations et fonctions. Toute modification de l'un de ces facteurs peut provoquer une variation des résultats. Vous devez consulter d'autres infos et d'autres tests de performances pour évaluer en connaissance de cause les achats que vous envisagez de faire, et notamment les performances de ce produit combiné à d'autres. Configuration : un Mac Book Pro a été utilisé pour le test dans ce cas. Pour davantage d'informations, accédez à http://www.intel.com/performance]

III - Méthodes les mieux connues

III-A - Tester votre application avec l'émulateur d'Eclipse

Qu'il s'agisse d'une application NDK ou d'une application Dalvik, vous pouvez utiliser Intel HAXM pour accélérer l'émulateur lors des tests. Si vous développez avec Eclipse, vous pouvez suivre ces simples étapes pour vous assurer que vous utilisez Intel HAXM lorsque vous démarrez l'émulateur.

Tout d'abord, veillez à bien créer votre AVD comme décrit dans l'étape 2. Si l'AVD est prêt, accédez à Run As -> Run Config (Exécuter comme -> Configuration d'exécution) comme illustré ci-dessous :

Vous devriez atterrir sur une page comme celle-ci :

Ici, vous pouvez sélectionner l'AVD que vous voulez en en cochant la case. Après avoir créé votre AVD et défini votre configuration, commencez à compiler votre projet et à le déboguer avec l'émulateur en sélectionnant Run As -> Android Application (Exécuter comme -> Application Android). Cela lancera automatiquement l'AVD avec accélération matérielle.

Après le démarrage de l'AVD, vous devriez voir l'écran d'accueil de votre application (après avoir déverrouillé l'écran).

III-B - Soumettre plusieurs APK pour différentes ABI vs. soumettre des fichiers binaires universels à Google Play

Dans le passé, vous soumettiez le fichier binaire universel de l'application développée, contenant toutes les bibliothèques et fichiers NDK, sans pouvoir différencier entre les architectures. Cela signifiait que les utilisateurs devaient télécharger le fichier APK entier contenant des fichiers qui n'étaient pas pertinents pour des architectures spécifiques, par ex., les utilisateurs x86 avaient un code ARM et inversement. Le problème était que si le fichier binaire était vraiment volumineux, l'utilisateur était forcé de télécharger une grande quantité de données qui ne concernaient pas leur appareil. Habituellement, cela est toujours acceptable si le volume de l'APK est inférieur à 10 ou 20 Mo.

La boutique d'applications de Google supporte la soumission de plusieurs APK contenant les différentes bibliothèques spécifiques à chaque architecture. Les APK envoyés doivent avoir des « versionCode » différents, et ce numéro doit être le plus élevé pour l'APK contenant les binaires x86. Vous pouvez par exemple utiliser cette convention :

Le premier chiffre se réfère à l'ABI, à savoir, 6 pour x86 ; ensuite le niveau d'API que vous ciblez, à savoir, 11 ; la taille de l'écran, 13 ; ensuite le numéro de version de votre application : 3.1.0.

Dans l'exemple ci-dessus, vous auriez 6 pour x86, 2 pour ARMv7 et 1 pour ARMv5TE. Cela permet de sélectionner de préférence les versions x86 pour les appareils x86 et les versions ARM pour les appareils ARM.

En suivant ces directives, vous pouvez vous assurer que vos utilisateurs tirent les meilleures performances de l'appareil qu'il possède. De plus, vous pouvez éviter que les utilisateurs tentent d'exécuter des applications sur des appareils spécifiques en raison de problèmes de traduction de code.

Vous trouverez davantage d'informations ici : http://software.intel.com/fr-fr/articles/google-play-supports-cpu-architecture-filtering-for-multiple-apk.

III-C - Compiler votre code natif pour X86 en utilisant le NDK

Cette section vous montrera comment compiler la partie NDK de votre application pour x86.

Pour que votre application NDK s'exécute sur un AVD x86, vous devez compiler la bibliothèque de votre NDK pour l'architecture x86. Pour cela, suivez ces simples étapes :

Ouvrez une invite de commande et naviguez jusqu'au dossier de vos fichiers NDK, comme suit :

Veillez à configurer le chemin d'accès de la variable d'environnement afin de pouvoir utiliser le script ndk-build depuis n'importe où.

III-C-1 - Ajouter le chemin d'accès du NDK à votre variable d'environnement

Pour configurer votre variable d'environnement pour le NDK, cliquez avec le bouton droit sur Ordinateur, puis sélectionnez Propriétés. Accédez à Paramètres système avancés et trouvez les variables d'environnement. Sélectionnez Path et cliquez sur Modifier. À la fin de la chaîne « Valeur de la variable », ajoutez le chemin d'accès au dossier racine du NDK, celui qui contient le fichier ndk-build.cmd comme dans l'image ci-dessous.

III-C-2 - Compiler avec le NDK

Après avoir navigué par l'invite de commande jusqu'au dossier NDK, exécutez :

ndk-build APP_ABI:=all

Cela compilera votre fichier NDK pour chaque architecture disponible, à savoir, ARMv5TE, ARMv7, x86 et mips.

Pour compiler pour une architecture spécifique, remplacez « all » par les différentes architectures. Par exemple :

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

Veillez à actualiser votre projet dans Eclipse pour prendre en compte vos derniers paramètres, à savoir, les derniers dossiers créés par le script ndk-build. Dans le dossier des bibliothèques de votre projet, vous devriez maintenant voir quatre dossiers, un pour chacune des architectures.

Vous êtes maintenant prêt à utiliser l'AVD x86 avec votre application NDK.

III-C-3 - Autre manière de compiler avec le NDK

Une autre manière de compiler votre code natif pour toutes les architectures, y compris x86, consiste à modifier le fichier Application.mk qui se trouve dans le dossier jni. Si vous n'avez pas de fichier Application.mk, vous pouvez en créer un vous-même et ajouter l'instruction ci-dessous :

APP_ABI:=armeabi armeabi-v7a x86 mips

Ainsi, lorsque vous exécutez le fichier de commandes, à savoir, le script ndk-build, il compilera les bibliothèques pour toutes les architectures disponibles.

Pour une utilisation plus facile, vous pouvez également indiquer « all » au lieu d'énumérer toutes les architectures :

APP_ABI := all

IV - Remerciements

Merci à Intel Developer Zone et à Xavier Hallade pour la rédaction de ce tutoriel.

Retrouvez le Blog de Xavier Hallade, Software Engineer chez Intel.

Pour toute question, merci de contacter Slim Soussi, EMEA Program Manager chez Intel : slim(pt)soussi(at)intel(pt)com