Partager via

Ajouter la prise en charge Arm à votre application Windows

  • Article

Les appareils Arm sont de plus en plus prisés du fait de leur faible consommation électrique, de leur plus grande autonomie de batterie et de leur puissance de traitement impressionnante, en plus de la prise en charge de Windows sur Arm pour les unités de traitement neural (NPU) adaptées aux charges de travail d’IA et de Machine Learning de plus en plus répandues.

Ce guide décrit les étapes à suivre pour ajouter la prise en charge à vos applications Windows pour les appareils équipés de processeurs Arm64. Vous y trouverez également des conseils pour résoudre les problèmes ou les blocages potentiels (tels que des dépendances tierces ou des plug-ins) susceptibles de contrarier la création d’une version Arm64 de votre application.

Émulation sur les appareils Arm pour les applications Windows x86 ou x64

Les versions Arm de Windows 10 intègrent une technologie d’émulation qui permet aux applications x86 non modifiées existantes de s’exécuter sur les appareils Arm. Windows 11 étend cette émulation pour exécuter des applications Windows x64 non modifiées sur les appareils Arm.

Bien que la possibilité d’émuler des applications x64 et x86 sur des appareils Arm soit une grande avancée, ce guide vous aidera à ajouter la prise en charge native Arm pour permettre à votre application de tirer parti des gains de performance natifs et des qualités uniques des appareils Arm64, à savoir :

  • Une optimisation de la consommation électrique de votre application pour prolonger l’autonomie de la batterie.
  • Une optimisation des performances du processeur, du GPU et des NPU pour accélérer les flux de travail, en particulier lorsque vous utilisez l’IA.

Par ailleurs, les pilotes du noyau doivent être conçus avec une prise en charge native d’Arm64. Il n’existe pas d’émulation dans le noyau. Cela impacte principalement les scénarios de virtualisation. Pour les applications qui utilisent des pilotes de périphérique qui nécessitent un accès direct aux composants internes du système d’exploitation ou du matériel s’exécutant en mode noyau, et non en mode utilisateur, et qui n’ont pas encore été mis à jour pour prendre en charge les processeurs Arm64, consultez Création de pilotes Arm64 avec le WDK.

Remarque

Les applications web progressives (PWA) s’exécuteront déjà avec des performances Arm64 natives.

Prérequis

Si vous mettez à jour votre application à l’aide d’un appareil Arm (compilation/génération natives du code pour la plateforme que vous exécutez), vous pouvez utiliser :

  • Présentation de Visual Studio 17.10 – Préversion 1 (février 2024)

  • Visual Studio 2022 v17.4 ou une version ultérieure. Il s’agit de la première version en disponibilité générale de Visual Studio qui prend en charge en mode natif la création et le débogage d’applications Arm64 sur des processeurs Arm. Les versions Arm64 natives de Visual Studio 2022 17.4 et de Microsoft Visual C++ (MSVC) offrent de bien meilleures performances que les précédentes versions émulées.

  • (Facultatif) LLVM (Clang) v12+ ou version ultérieure. LLVM 12 ajoute une version binaire officielle hébergée sur Windows sur Arm64, avec un compilateur Clang, LLD Linker et des bibliothèques runtime compiler-rt.

Si vous mettez à jour votre application Windows de sorte qu’elle prenne en charge Arm avec un appareil basé sur un processeur Intel x64 ou x86 (compilation croisée), vous pouvez utiliser :

Plusieurs éléments sont à prendre en considération au moment de choisir entre la compilation croisée et la compilation native, tels que le matériel disponible et la simplicité d’exécution des tests.

Remarque

GCC (GNU Compiler Collection) devrait être pris en charge dans un avenir proche.

Étapes pour ajouter la prise en charge native d’Arm64

Pour mettre à jour votre application de sorte qu’elle s’exécute en mode natif sur Arm64 :

  1. Ajouter une configuration Arm64 à votre projet dans Visual Studio
  2. Tester et déboguer l’application Arm64 nouvellement créée
  3. Créer et tester votre application sur des appareils Arm

Une fois que vous avez confirmé que votre application a bien été optimisée pour les appareils Arm :

  1. Mettre à jour votre programme d’installation et publier votre application mise à jour
  2. Prévoir des mises à jour constantes

Étape 1 – Ajouter une configuration Arm64 à votre projet dans Visual Studio

Pour ajouter une nouvelle plateforme de solution ARM64 avec des cibles de débogage et de mise en production à votre projet d’application x64 ou x86 existant :

  1. Ouvrez votre solution (code du projet) dans Visual Studio (consultez les prérequis pour les versions prises en charge).
  2. Dans le menu déroulant « Plateformes de solution » de la barre d’outils Standard (ou dans le menu « Générer »), sélectionnez Gestionnaire de configuration...
  3. Ouvrez le menu déroulant « Plateforme de la solution active», puis sélectionnez <Nouveau...>.
  4. Dans le menu déroulant « Tapez ou sélectionnez la nouvelle plateforme », sélectionnez ARM64 et vérifiez que la valeur de « Copier les paramètres à partir de » est définie sur x64 et que la case « Créer des plateformes de projet » est cochée, puis sélectionnez OK.

Félicitations ! Vous avez commencé à ajouter la prise en charge d’Arm à votre application. Ensuite, vérifiez que votre solution Arm64 se génère correctement.

Si la génération de votre solution n’aboutit pas, vous devez résoudre les problèmes qui provoquent l’échec de la génération. La raison la plus probable est qu’une dépendance n’est pas disponible pour ARM64, ce qui est abordé dans la section Résolution des problèmes ci-dessous.

(Facultatif) : si vous voulez vérifier directement que le fichier binaire de votre application est à présent adapté à Arm64, vous pouvez ouvrir le répertoire de votre projet dans PowerShell (cliquez avec le bouton droit sur le projet de votre application dans l’Explorateur de solutions Visual Studio et sélectionnez Ouvrir dans le terminal). Changez les répertoires de sorte que le nouveau répertoire bin\ARM64\Debug ou Release de votre projet soit sélectionné. Entrez la commande : dumpbin /headers .\<appname>.exe (en remplaçant <appname> par le nom de votre application). Faites défiler les résultats du terminal vers le haut jusqu’à la section FILE HEADER VALUES et vérifiez que la première ligne est bien AA64 machine (ARM64).

Étape 2 – Tester et déboguer l’application Arm64 nouvellement créée

Pour vérifier si votre solution Arm64 se génère correctement après avoir ajouté la plateforme de solution Arm64 à votre projet dans Visual Studio :

  1. Fermez la fenêtre « Plateforme de la solution active ».
  2. Modifiez le paramètre de génération en le faisant passer de Debug à Release.
  3. Dans le menu déroulant « Générer », sélectionnez Régénérer la solution et attendez que le projet soit régénéré.
  4. La sortie vous indique que la régénération globale a réussi. Si ce n’est pas le cas, consultez la section Résolution des problèmes à la suite.

Une fois que les fichiers binaires sont créés pour que votre application prenne en charge Arm64, vous souhaiterez sans doute les tester. Pour cela, vous devrez disposer d’un appareil ou d’une machine virtuelle exécutant Windows sur Arm.

Si vous effectuez le développement sur un appareil Windows sur Arm, vous disposez d’une configuration facile avec le débogage local de Visual Studio. Si vous effectuez une compilation croisée (à l’aide d’un appareil qui ne s’exécute pas sur un processeur Arm), vous pouvez utiliser le débogage à distance sur un appareil Windows sur Arm ou une machine virtuelle pour activer votre expérience de développement dans Visual Studio tout en exécutant l’application Arm64 sur un autre appareil.

Matériel Windows sur Arm ou machines virtuelles disponibles pour les tests

Si vous cherchez du matériel à utiliser pour l’intégration continue (CI) et les tests, voici quelques appareils Windows dotés d’un processeur Arm64 :

Pour obtenir de l’aide sur la configuration d’une machine virtuelle exécutant Windows sur Arm pour prendre en charge la CI et le test, consultez Démarrage rapide : Créer une machine virtuelle Windows sur Arm dans le Portail Azure.

Étape 3 – Créer et tester votre application sur des appareils Arm

L’ajout d’un test d’automatisation réussi est une considération importante pour votre stratégie d’intégration continue et de livraison continue (CI/CD). Pour les solutions Arm64 s’exécutant sur Windows, il est important d’exécuter votre suite de tests sur l’architecture Arm64, qu’il s’agisse d’un matériel Windows sur Arm proprement dit, par exemple l’un des appareils Arm mentionnés ci-dessus, ou d’une machine virtuelle parmi celles citées précédemment.

Même s’il s’avère plus pratique de compiler l’application sur la machine qui a servi aux tests, il ne s’agit pas d’une obligation dans la majorité des cas. En revanche, vous pouvez envisagez d’étendre l’infrastructure de génération existante pour produire une sortie à compilation croisée pour Arm64.

Étape 4 – Mettre à jour votre programme d’installation et publier votre application mise à jour

Si vous publiez dans le Microsoft Store, après avoir créé une version Arm64 de votre application en ayant suivi les étapes précédentes, vous pouvez mettre à jour le package existant de votre application dans le Microsoft Store en accédant à votre tableau de bord de l’Espace partenaires et en ajoutant les fichiers binaires ARM64 nouvellement créés à la soumission.

Si votre application n’est pas déjà publiée dans le Microsoft Store, vous pouvez suivre les instructions pour créer une soumission d’application selon que vous voulez soumettre un fichier MSI ou EXE, un package MSIX, une application web progressive (PWA) ou une extension d’application.

Si vous créez votre propre programme d’installation, vous devez vérifier qu’il est capable d’installer correctement votre nouvelle version Arm64. La plupart des infrastructures de programme d’installation, telles que WiX, Squirrel, InnoSetup, InstallAware et d’autres, prennent en charge Windows sur Arm sans problème.

Si vous mettez à disposition le programme d’installation de votre application sur une page web, vous pouvez utiliser User-Agent Client Hints pour détecter les visiteurs équipés d’un appareil Windows sur Arm et leur proposer la version native Arm mise à jour de votre application. Contrairement à la chaîne de l’agent utilisateur, User-Agent Client Hints vous permet de distinguer les clients sur Arm des clients équipés d’appareils x86.

Étape 5 – Prévoir des mises à jour constantes

Maintenant que vous avez publié une version Arm64 de votre application, vous devez veillez à ce qu’elle soit mise à jour de la même manière que les autres versions de votre application. En effet, il vaut mieux jouer la carte de la cohérence entre les versions et les fonctionnalités pour les différentes architectures afin éviter afin d’éviter de dérouter les clients par la suite.

Résolution des problèmes

Certains problèmes peuvent vous contrarier ou vous empêcher d’ajouter une version Arm64 de votre application Windows x64 ou x86 existante. En voici quelques-uns parmi les plus courants :

Une dépendance non compilée pour ARM64 entrave la réussite de la génération

Si vous êtes dans l’impossibilité de générer en raison d’une dépendance, qu’elle soit interne, tierce ou issue d’une bibliothèque open source, vous devez soit trouver un moyen de mettre à jour cette dépendance pour prendre en charge l’architecture ARM64, soit la supprimer.

  • Pour les dépendances internes, nous vous recommandons de recréer la dépendance pour la prise en charge d’ARM64.

  • Pour les dépendances tierces, nous vous recommandons de soumettre une demande au mainteneur en vue de recréer la dépendance en question avec une prise en charge ARM64.

  • Pour les dépendances open source, vérifiez dans vcpkg s’il n’existe pas une version plus récente de la dépendance avec prise en charge ARM64 à laquelle vous pourriez passer. S’il n’existe pas de mise à jour, envisagez de contribuer vous-même à l’ajout de la prise en charge d’ARM64 au package. De nombreux mainteneurs open source vous seraient reconnaissants pour cette contribution.

  • L’organisation Linaro collabore également avec des entreprises et des communautés open source pour développer des logiciels basés sur la technologie Arm. Vous pouvez déposer une demande auprès du Service Desk Linaro en vue d’une mise à jour de la prise en charge du package pour les dépendances manquantes liées à Windows sur Arm.

  • Envisagez d’utiliser Arm64EC. Les versions Arm64EC des dépendances peuvent être utilisées pour recréer une application tout en continuant d’utiliser les versions x64 des dépendances. Dans un processus Arm64EC, n’importe quel code x64, y compris le code des dépendances, s’exécutera sous émulation dans votre application. (Les versions Arm64 des dépendances ne seront pas utilisables dans ce cas.)

  • La dernière option serait de supprimer et/ou de remplacer la dépendance dans le projet de votre application.

Le code est écrit pour une architecture spécifique différente d’Arm64

  • L’assembly ou les appels de fonctions intrinsèques inline propres au processeur doivent être modifiés pour correspondre aux instructions et fonctions disponibles sur le processeur Arm. Pour obtenir des conseils, consultez Using Assembly and Intrinsics in C or C++ Code.

Votre application repose sur un pilote de noyau

Les pilotes du noyau doivent être conçus avec une prise en charge native d’Arm64. Il n’existe pas d’émulation dans le noyau. Cela impacte principalement les scénarios de virtualisation. Pour les applications qui utilisent des pilotes de périphérique qui nécessitent un accès direct aux composants internes du système d’exploitation ou du matériel s’exécutant en mode noyau, et non en mode utilisateur, et qui n’ont pas encore été mis à jour pour prendre en charge les processeurs Arm64, consultez Création de pilotes Arm64 avec le WDK.

De plus, les pilotes Windows doivent être générés en Arm64 et ne peuvent pas être émulés. Pour les applications qui reposent sur des pilotes logiciels qui n’ont pas encore été mis à jour pour prendre en charge les processeurs Arm64, consultez Création de pilotes Arm64 avec le WDK.

Chaîne d’outils pour Windows sur Arm

Outre la prise en charge de Visual Studio et de LLVM (CLANG) tels qu’ils sont présentés dans la section Prérequis de ce guide, les outils et infrastructures suivants sont également pris en charge pour Arm64 :

Il en va de même des infrastructures tierces, dont :

Vous avez besoin d’aide ? Faites appel à notre service App Assure

Le service de conseil App Assure Arm est mis à la disposition des développeurs pour les aider à créer des applications optimisées pour Arm. Ce service vient s’ajouter à notre promesse existante : vos applications s’exécuteront sur Windows sur Arm et, si vous rencontrez des problèmes, Microsoft vous aidera à y remédier. Plus d’informations

Inscrivez-vous à Windows Arm Advisory Services.