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, longa duração da bateria e poder de processamento impressionante. O Windows on Arm dá suporte a NPUs (Unidades de Processamento Neural) ajustadas para as cargas de trabalho de IA e Machine Learning cada vez mais populares.

Este guia aborda as etapas para adicionar suporte aos aplicativos do Windows para dispositivos alimentados por processadores Arm64. Ele também fornece diretrizes sobre 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 ajuda 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, os drivers de kernel precisam ser criados na forma nativa Arm64. O kernel não inclui emulação. Essa limitação afeta principalmente os cenários de virtualização. Para aplicativos que usam 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 são atualizados para dar suporte a processadores Arm64, consulte Como criar drivers Arm64 com o WDK.

Observação

Os PWAs (Aplicativos Web Progressivos) já sã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:

Considere vários fatores 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 em dispositivos 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 está otimizado 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): para verificar 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 da plataforma de solução ativa .
  2. Alterar a configuração de build de Debug para Release.
  3. No menu suspenso Compilar, selecione Reconstruir Solução e aguarde a reconstrução do projeto.
  4. Você recebe uma saída Recompilar Tudo com sucesso. Caso contrário, consulte a seção Solução de problemas .

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

Se você estiver desenvolvendo em um dispositivo Windows no Arm, terá uma configuração fácil com a depuração local do Visual Studio. Se você estiver compilando cruzadamente (usando um dispositivo que não está em execução em um processador Arm), você deseja usar a depuração remota em um dispositivo 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 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 teste é uma consideração importante para sua estratégia de CI/CD (Integração Contínua e Entrega Contínua). Para soluções arm64 em execução no Windows, é importante executar seu conjunto de testes na arquitetura arm64. Essa arquitetura pode ser um hardware real do Windows no Arm, usando um dos dispositivos Arm listados anteriormente, ou uma Máquina Virtual, das VMs listadas anteriormente.

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 do Arm64 do seu aplicativo seguindo as etapas anteriores, poderá atualizar seu pacote de aplicativos existente na Microsoft Store visitando o painel do Partner Center e adicionando os binários ARM64 recém-criados ao envio.

Se você ainda não publicar seu aplicativo na Microsoft Store, 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 possa 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ê publica uma versão do Arm64 do seu aplicativo, deseja garantir que ela permaneça atualizada da mesma maneira que outras versões do seu aplicativo. Mantenha versões e recursos alinhados entre arquiteturas para evitar confusão do cliente no futuro.

Resolução de problemas

Os problemas comuns que interferem ou impedem você de adicionar 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 seu aplicativo devido a uma dependência, seja interna, de terceiros ou de uma biblioteca de software livre, será necessário atualizar essa dependência para dar suporte à arquitetura ARM64 ou removê-la.

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

  • Para dependências de terceiros, solicite ao mantenedor que recompile a dependência com suporte do ARM64.

  • Para dependências de software livre, verifique vcpkg para ver se uma versão mais recente da dependência inclui suporte arm64 para o 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 apreciam a contribuição.

  • A organização Linaro 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.

  • Use 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 é executado em emulação em seu aplicativo. (As versões arm64 de dependências não são utilizáveis neste caso.)

  • Remova e substitua a dependência em seu projeto de aplicativo.

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

Seu aplicativo depende de um driver de kernel

Os drivers do kernel devem ser criados como nativos Arm64. O kernel não fornece nenhuma emulação. Essa limitação afeta principalmente os cenários de virtualização. Para aplicativos que usam 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 são atualizados para dar suporte a processadores Arm64, consulte Como criar 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 Como criar 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
  • O clang-cl compila o código C++ para Windows e pode servir como uma substituição para o compilador e o vinculador do MSVC. Ele ainda usa cabeçalhos e bibliotecas do MSVC e é compatível com o ABI do MSVC.

Além de estruturas 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 são executados no Windows no Arm e, se você encontrar problemas, a Microsoft ajuda você a corrigi-los. Saiba mais.

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

  • Last updated on