Compartilhar via

Adicionar suporte do Arm ao seu aplicativo do Windows

Os dispositivos baseados em Arm estão se tornando cada vez mais populares devido à sua eficiência energética, maior duração da bateria e impressionante poder de processamento, além do suporte do Windows on Arm para NPUs (Unidades de Processamento Neural) ajustadas 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 podem interferir na criação de uma versão baseada em Arm64 do seu aplicativo.

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

As versões arm do Windows 10 incluem a tecnologia de emulação que permite que aplicativos x86 não modificados existentes sejam executados em dispositivos Arm. O Windows 11 estende essa emulação para executar aplicativos Windows x64 não modificados em dispositivos baseados em Arm.

Embora a capacidade de emular dispositivos x64 e x86 no Arm seja um ótimo passo em frente, este guia ajudará você a adicionar suporte nativo do Arm para que seu aplicativo possa aproveitar os ganhos de desempenho nativos e as qualidades exclusivas dos dispositivos alimentados pelo Arm64, incluindo:

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

Além disso, drivers do kernel devem ser criados como Arm64 nativo. 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 componentes internos do sistema operacional ou do hardware em execução no modo kernel, em vez de no modo de usuário, e que ainda não foram atualizados para dar suporte a processadores Arm64, consulte Compilar drivers Arm64 com o WDK.

Observação

Os PWAs (Aplicativos Web Progressivos) já serão executados com o 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), você pode usar:

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

  • Visual Studio 2022 v17.4 ou posterior. Esta é a primeira versão GA do Visual Studio que dá 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 Microsoft Visual C++ (MSVC) oferecem um desempenho significativamente melhor em comparação com as versões anteriores emuladas.

  • (Opcional) LLVM (Clang) v12+ ou posterior. LLVM 12 adiciona a versão binária oficial disponibilizada em Windows no Arm64, incluindo um compilador Clang, o LLD Linker e bibliotecas de tempo de execução do compiler-rt.

Se você estiver atualizando seu aplicativo do 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

GCC, o suporte à Coleção de Compiladores GNU está previsto para um futuro próximo.

Etapas para adicionar suporte nativo do Arm64

Para atualizar seu aplicativo para ser executado nativamente no Arm64:

  1. Adicionar uma configuração do Arm64 ao seu projeto no Visual Studio
  2. Testar e depurar o aplicativo Arm64 recém-criado
  3. Criar e testar seu aplicativo em dispositivos Arm

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

  1. Atualizar seu instalador e publicar seu aplicativo atualizado
  2. Plano 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 Standard (ou no menu "Compilar"), selecione Configuration Manager...
  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 certifique-se de que o valor em "Copiar configurações de" esteja definido como x64. Marque a caixa "Criar novas plataformas de projeto" e, em seguida, selecione OK.

Parabéns! Você começou a adicionar suporte do Arm ao seu aplicativo. Em seguida, verifique se a Solução Arm64 é compilada com êxito.

Se a sua solução não for concluída com sucesso, você precisará resolver os problemas que estão causando o erro de compilação. O motivo mais provável é que uma dependência não está disponível para ARM64, que é abordada em solução de problemas abaixo.

(opcional): se você quiser verificar em primeira mão se o binário do aplicativo foi criado para o Arm64, abra o diretório do projeto no PowerShell (clique com o botão direito do mouse no projeto do aplicativo no Gerenciador de Soluções do Visual Studio e selecione Abrir no Terminal). Altere os diretórios para que o novo diretório de bin\ARM64\Debug ou Versão do projeto seja selecionado. Insira o comando: dumpbin /headers .\<appname>.exe (substituindo <appname> pelo nome do seu aplicativo). Deslize para cima nos resultados de saída do terminal para localizar 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-criado

Para verificar se a Solução Arm64 é compilada com êxito 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. Alterar a configuração de build de Debug para Release.
  3. No menu suspenso "Compilar", selecione Recompilar Solução e aguarde a recompilação do projeto.
  4. Você receberá a mensagem de saída 'Rebuild All succeeded'. Caso contrário, consulte a seção Solução de Problemas abaixo.

Depois que os binários forem criados para que seu aplicativo dê suporte ao Arm64, você desejará testá-los. Isso exigirá ter um dispositivo ou uma máquina virtual executando o Windows no Arm.

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

Hardware ou máquinas virtuais do Windows on 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 VM (máquina virtual) executando o Windows no Arm para dar suporte a CI e teste, consulte Início Rápido: Criar uma máquina virtual do Windows on Arm no portal do Azure.

Etapa 3 – Criar e testar seu aplicativo em dispositivos Arm

Adicionar um ciclo de automação de testes é uma consideração importante para sua estratégia de integrações contínuas e entrega contínua (CI/CD). Para soluções arm64 em execução no Windows, é importante executar seu conjunto de testes na arquitetura Arm64. Isso pode ser hardware real do Windows no 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 um resultado compilado cruzado para Arm64.

Etapa 4 – Atualizar seu instalador e publicar seu aplicativo atualizado

Se você publicar na Microsoft Store, depois de criar 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-criados 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 você 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 êxito. A maioria das estruturas do instalador, como WiX, Squirrel, InnoSetup, InstallAwaree outros, são compatíveis com o Windows no Arm sem problemas.

Se você oferecer o instalador do aplicativo de uma página da web, poderá usar User-Agent Client Hints para detectar quando o cliente está visitando de um dispositivo Windows em Arm e oferecer a versão nativa atualizada do seu aplicativo para Arm. Ao contrário da cadeia de caracteres do agente de usuário, User-Agent Client Hints permite diferenciar clientes em dispositivos 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, você vai querer 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.

Resolução de problemas

Problemas comuns que podem interferir ou impedir a adição de uma versão do Arm64 do seu aplicativo do Windows x64 ou x86 existente incluem:

Uma dependência não compilada para ARM64 está bloqueando você de um build bem-sucedido

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

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

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

  • Para dependências de software livre, considere verificar vcpkg para ver se existe uma versão mais recente da dependência que inclui suporte arm64 para a qual você pode atualizar. Se nenhuma atualização existir, considere contribuir com a adição do suporte do ARM64 ao pacote por conta própria. Muitos mantenedores de software livre ficariam gratos pela contribuição.

  • A organização Linaro também trabalha com empresas e comunidades de software livre para desenvolver software em tecnologia baseada em Arm. Você pode fazer uma solicitação com a Central de Serviços do Linaro para ajudar na atualização do suporte do pacote para quaisquer dependências ausentes relacionadas ao Windows em Arm.

  • Considere usar Arm64EC . As versões arm64EC de dependências podem ser usadas para recriar um aplicativo enquanto ainda utilizam 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 neste caso.)

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

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

  • As chamadas de funções intrínsecas específicas de CPU ou instruções assembly embutidas precisarão ser modificadas para se adequar às instruções e funções disponíveis no CPU da Arm. Para obter diretrizes, consulte: Usando assembly e intrínsecos em código C ou C++.

Seu aplicativo depende de um driver de kernel

drivers do kernel precisam ser criados como nativos Arm64. 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 componentes internos do sistema operacional ou do hardware em execução no modo kernel, em vez de no modo de usuário, e que ainda não foram atualizados para dar suporte a processadores Arm64, consulte Compilar drivers Arm64 com o WDK.

Além disso, os drivers no Windows devem ser criados 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 criando 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, as seguintes ferramentas e estruturas também têm suporte para o Arm64:

  • do .NET 7
  • .NET 6 (LTS)
  • .NET 5.0.8+
  • .NET Framework 4.8.1
  • clang-cl compila o código C++ para Windows e pode servir como um substituto direto para o compilador e o linker do MSVC. Ele ainda usa cabeçalhos e bibliotecas do MSVC e é compatível com o ABI do MSVC.

Além de frameworks de terceiros, incluindo:

Precisa de assistência? Utilize nosso serviço App Assure

O Serviço de Consultoria Arm do App Assure está disponível para ajudar os desenvolvedores a criar aplicativos otimizados para a arquitetura 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.