Compartilhar via

Adicione suporte do Arm ao seu aplicativo Windows

  • Artigo

Os dispositivos baseados em Arm estão se tornando cada vez mais populares devido à sua natureza de energia frugal, maior duração da bateria e poder de processamento impressionante, além do suporte do Windows no Arm para NPUs (Unidades de Processamento Neural) ajustado para as cargas de trabalho de IA e Machine Learning cada vez mais populares.

Este guia abordará as etapas para adicionar suporte aos aplicativos do Windows para dispositivos alimentados por processadores Arm64. As diretrizes também abordarão maneiras de resolver possíveis problemas ou bloqueadores (como dependências de terceiros ou plug-ins) que possam interferir na criação de uma versão baseada em Arm64 do seu aplicativo.

Emulação em dispositivos baseados em Arm para aplicativos x86 ou x64 do Windows

As versões Arm do Windows 10 incluem a tecnologia de emulação que permite que aplicativos x86 sem modificações sejam executados em dispositivos Arm. O Windows 11 amplia essa emulação para executar aplicativos x64 do Windows sem modificações em dispositivos da plataforma Arm.

Embora a capacidade de emular dispositivos x64 e x86 em dispositivos Arm seja um grande avanço, seu aplicativo poderá aproveitar os ganhos de desempenho nativos e as qualidades exclusivas dos dispositivos da plataforma Arm64, incluindo:

  • Otimização do consumo de energia do aplicativo para estender a duração da bateria do dispositivo.
  • Otimização do desempenho de CPU, GPU e NPUs para acelerar fluxos de trabalho, especialmente ao trabalhar com IA.

Além disso, os drivers kernel devem ser criados como Arm64 nativos. Não há nenhuma emulação presente no kernel. Isso afeta principalmente os cenários de virtualização. Para aplicativos que utilizam drivers de dispositivo que exigem acesso direto aos internos do sistema operacional ou hardware em execução no modo kernel, em vez do modo de usuário, e que ainda não foram atualizados para dar suporte a processadores Arm64, consulte Criação de drivers Arm64 com o WDK.

Observação

PWAs (Aplicativos Web progressivos) já serão executados com desempenho nativo do Arm64.

Pré-requisitos

Se você estiver atualizando seu aplicativo usando um dispositivo baseado em Arm (compilação nativa – gerando o código para a mesma plataforma na qual você está executando), poderá usar:

  • Apresentando o Visual Studio 17.10 – Versão prévia 1 (fevereiro de 2024)

  • Visual Studio 2022 v17.4 ou posterior. Essa será a primeira versão em disponibilidade geral do Visual Studio que dará suporte nativo à criação e depuração de aplicativos Arm64 em processadores baseados em Arm. As versões Arm64 nativas do Visual Studio 2022 17.4 e do MSVC (Microsoft Visual C++) fornecem um desempenho significativamente melhor em comparação com as versões emuladas anteriores.

  • (Opcional) LLVM (Clang) v12+ ou posterior. O LLVM 12 adiciona a versão binária oficial hospedada no Windows no Arm64, incluindo um compilador Clang, o LLD Linker e bibliotecas de runtime do compilador rt.

Se você estiver atualizando seu aplicativo Windows para dar suporte ao Arm usando um dispositivo baseado em Intel x64 ou x86 (compilação cruzada), você poderá usar:

Há vários fatores a serem considerados ao escolher entre compilação cruzada ou compilação nativa, como hardware disponível e simplicidade da execução do teste.

Observação

A GCC (Nuvem da Comunidade Governamental), o suporte à GNU Compiler Collecion, está prevista para um futuro próximo.

Etapas para adicionar suporte nativo do Arm64

Para atualizar seu aplicativo para ser executado nativamente no Arm64:

  1. Adicione uma configuração do Arm64 ao seu projeto no Visual Studio
  2. Teste e depure o aplicativo Arm64 recém-compilado
  3. Compile e teste seu aplicativo em dispositivos Arm

Depois de confirmar que seu aplicativo foi otimizado com sucesso para dispositivos Arm:

  1. Atualize seu instalador e publique seu aplicativo atualizado
  2. Planeje para atualizações contínuas

Etapa 1 – Adicionar uma configuração do Arm64 ao seu projeto no Visual Studio

Para adicionar uma nova plataforma de solução ARM64 com destinos de depuração e lançamento ao seu projeto de aplicativo x64 ou x86 existente:

  1. Abra sua solução (código do projeto) no Visual Studio (consulte pré-requisitos para as versões com suporte).
  2. No menu suspenso "Plataformas de Solução" na barra de ferramentas Padrão (ou no menu "Compilar"), selecione Gerenciador de Configurações...
  3. Abra o menu suspenso "Plataforma de solução ativa" e selecione <Novo...>.
  4. No menu suspenso "Digite ou selecione a nova plataforma", selecione ARM64 e verifique se o valor "Copiar configurações de" está definido como x64 com a caixa de seleção "Criar novas plataformas de projeto" habilitada e selecione OK.

Parabéns! Você começou a adicionar o suporte do Arm ao seu aplicativo. Em seguida, verifique para ver se a Solução Arm64 é compilada de maneira bem-sucedida.

Se a Solução não for compilada com sucesso, você precisará resolver os problemas que estão causando a falha da compilação. O motivo mais provável é que uma dependência não está disponível para ARM64, o que é abordado em Solucionar problemas abaixo.

(Opcional): se você quiser verificar em primeira mão se o binário do aplicativo está compilado agora para o Arm64, abra o diretório do projeto no PowerShell (clique com o botão direito do mouse em seu projeto de aplicativo no Gerenciador de Soluções do Visual Studio e selecione Abrir no Terminal). Altere os diretórios para que o diretório novo bin\ARM64\Debug ou versão do projeto seja selecionado. Insira o comando: dumpbin /headers .\<appname>.exe (substituindo <appname> pelo nome do aplicativo). Role para cima nos resultados de saída do terminal para encontrar a seção FILE HEADER VALUES e confirme se a primeira linha é AA64 machine (ARM64).

Etapa 2 – Testar e depurar o aplicativo Arm64 recém-compilado

Para verificar se a Solução Arm64 foi compilada com sucesso depois de adicionar a plataforma de solução Arm64 ao seu projeto no Visual Studio:

  1. Feche a janela "Plataforma de solução ativa".
  2. Altere a configuração de compilação de Depuração para Versão.
  3. No menu suspenso "Compilar", selecione Recompilar solução e aguarde a recompilação do projeto.
  4. Você receberá uma saída "Recompilar Tudo bem-sucedido". Caso contrário, consulte a seção Solucionar problemas abaixo.

Depois que os binários forem compilados para que o seu aplicativo dê suporte ao ARM64, o ideal será testá-los. Para isso, será preciso ter um dispositivo ou uma máquina virtual que execute o Windows no ARM.

Se você estiver fazendo o desenvolvimento em um dispositivo Windows no ARM, terá uma configuração fácil com a depuração local do Visual Studio. Se a compilação cruzada (usando um dispositivo que não está em execução em um processador ARM), o ideal será usar a depuração remota em um dispositivo do Windows no ARM ou em uma máquina virtual para habilitar sua experiência de desenvolvimento no Visual Studio durante a execução do aplicativo do ARM64 em outro dispositivo.

Hardware ou máquinas virtuais do Windows no Arm disponíveis para teste

Se você estiver procurando hardware para usar para CI (Integração Contínua) e teste, estes são alguns dos dispositivos Windows com um processador baseado em Arm64:

Para obter ajuda para configurar uma máquina virtual (VM) executando o Windows no Arm para dar suporte a CI e testes, consulte Guia de início rápido: criar uma máquina virtual Windows no Arm no portal do Azure.

Etapa 3 – Compilar e testar seu aplicativo em dispositivos Arm

Adicionar um passe de automação de teste é uma consideração importante para sua estratégia de Integração contínua e Entrega contínua (CI/CD). Para soluções arm64 em execução no Windows, é importante executar seu conjunto de testes na arquitetura Arm64. Pode ser o Windows real no hardware Arm, usando um dos dispositivos Arm listados acima, ou uma Máquina Virtual, das VMs listadas acima.

Compilar o aplicativo é mais conveniente quando feito no mesmo computador que os testes, mas em muitos casos não é necessário. Em vez disso, você pode considerar ampliar a infraestrutura de build existente para produzir uma saída de compilação cruzada para o Arm64.

Etapa 4 – Atualizar o instalador e publicar seu aplicativo atualizado

Se você publicar na Microsoft Store, depois de compilar uma versão Arm64 do seu aplicativo seguindo as etapas acima, poderá atualizar seu pacote de aplicativos existente na Microsoft Store visitando seu Painel do Partner Center e adicionando os binários ARM64 recém-compilados ao envio.

Se seu aplicativo ainda não estiver publicado na Microsoft Store, você poderá seguir as instruções para criar um envio de aplicativo com base em se deseja enviar um MSI ou EXE, pacote MSIX, PWA ou complemento de aplicativo.

Se você criar seu próprio instalador, deverá garantir que ele seja capaz de instalar sua nova versão do Arm64 com sucesso. A maioria das estruturas do instalador, como WiX, Squirrel, InnoSetup, InstallAware e outras, dá suporte ao Windows no Arm sem problemas.

Se você oferecer o instalador do seu aplicativo a partir de uma página da Web, poderá usar Dicas de Cliente do Agente de Usuário para detectar quando o cliente está visitando a partir de um dispositivo Windows no Arm e oferecer a versão nativa do Arm atualizada do seu aplicativo. Ao contrário da cadeia de caracteres de agente do usuário, as Dicas de Cliente do Agente de Usuário permitem diferenciar clientes no Arm de clientes em dispositivos x86.

Etapa 5 – Planejar atualizações contínuas

Agora que você tem uma versão do Arm64 do seu aplicativo publicada, convém garantir que ela permaneça atualizada da mesma maneira que outras versões do seu aplicativo. É melhor manter versões e recursos alinhados entre arquiteturas para evitar confusão do cliente no futuro.

Solução de problemas

Os problemas comuns que podem interferir ou impedir que você adicione uma versão Arm64 do seu aplicativo existente x64 ou x86 do Windows incluem:

Uma dependência não compilada para ARM64 está impedindo que você faça uma compilação bem-sucedida

Se você não puder compilar devido a uma dependência, seja interna, de terceiros ou de uma biblioteca de código aberto, será necessário encontrar uma maneira de atualizar essa dependência para dar suporte à arquitetura ARM64 ou removê-la.

  • Para dependências internas, recomendamos recompilar a dependência para suporte a ARM64.

  • Para dependências de terceiros, recomendamos o registro de uma solicitação para que o mantenedor recompile com o suporte a ARM64.

  • Para dependências de código aberto, considere verificar o vcpkg para ver se existe uma versão mais recente da dependência que inclua suporte a ARM64 para a qual você possa atualizar. Se não houver nenhuma atualização, considere contribuir você mesmo com a adição de suporte a ARM64 ao pacote. Muitos mantenedores de código aberto ficariam gratos pela contribuição.

  • A organização Linaro também trabalha com negócios e comunidades de código aberto para desenvolver software em tecnologia baseada em Arm. Você pode registrar uma solicitação com a Central de Serviços da Linaro para ajudar a atualizar o suporte ao pacote para quaisquer dependências ausentes relacionadas ao Windows no Arm.

  • Considere usar Arm64EC. As versões Arm64EC de dependências podem ser usadas para recompilar um aplicativo e ainda utilizar versões x64 de dependências. Qualquer código x64, incluindo código de dependências, em um processo Arm64EC será executado em emulação em seu aplicativo. (As versões Arm64 de dependências não poderão ser utilizáveis nesse caso.)

  • A última opção seria remover e/ou substituir a dependência do projeto de aplicativo.

O código é escrito para uma arquitetura específica diferente do Arm64

  • O assembly específico da CPU ou as chamadas de função intrínsecas inseridas precisarão ser modificadas para corresponder às instruções e funções disponíveis na CPU do Arm. Para obter diretrizes, consulte: Usando assembly e intrínsecos no código C ou C++.

Seu aplicativo depende de um driver de kernel

Os drivers kernel devem ser compilados como Arm64 nativos. Não há nenhuma emulação presente no kernel. Isso afeta principalmente os cenários de virtualização. Para aplicativos que utilizam drivers de dispositivo que exigem acesso direto aos internos do sistema operacional ou hardware em execução no modo kernel, em vez do modo de usuário, e que ainda não foram atualizados para dar suporte a processadores Arm64, consulte Criação de drivers Arm64 com o WDK.

Além disso, os drivers no Windows precisam ser compilados como Arm64 e não podem ser emulados. Para aplicativos que dependem de drivers de software que ainda não foram atualizados para dar suporte a processadores Arm64, consulte Compilação de drivers Arm64 com o WDK.

Cadeia de ferramentas para Windows no Arm

Além do suporte para Visual Studio e LLVM (CLANG), conforme compartilhado na seção Pré-requisitos deste guia, também há suporte para as seguintes ferramentas e estruturas no Arm64:

Além de estruturas de terceiros, incluindo:

Precisa de assistência? Aproveite nosso serviço de Garantia de Aplicativo

Os Serviços de Consultoria de Garantia de Aplicativo estão disponíveis para ajudar os desenvolvedores a compilar aplicativos otimizados para Arm. Esse serviço se soma à nossa promessa existente: seus aplicativos serão executados no Windows no Arm e, se você encontrar problemas, a Microsoft ajudará você a corrigi-los. Saiba mais.

Inscreva-se nos Serviços de Consultoria do Windows Arm.