Partilhar via

Adicionar suporte Arm à sua aplicação Windows

Os dispositivos baseados em ARM estão a tornar-se cada vez mais populares devido à sua natureza eficiente em termos de energia, maior autonomia da bateria e impressionante poder de processamento. O Windows on Arm suporta Unidades de Processamento Neural (NPUs) ajustadas para as cargas de trabalho de IA e Machine Learning cada vez mais populares.

Este guia aborda as etapas para adicionar suporte aos seus aplicativos do Windows para dispositivos equipados com processadores Arm64. Ele também fornece orientação sobre maneiras de resolver possíveis problemas ou bloqueadores, como dependências ou plug-ins de terceiros, 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 x86 ou x64 do Windows

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

Embora a capacidade de emular x64 e x86 em dispositivos Arm seja um grande 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 equipados com Arm64, incluindo:

  • Otimizar o consumo de energia da sua aplicação para prolongar a vida útil da bateria do dispositivo.
  • Otimizando o desempenho de CPU, GPU e NPUs para acelerar fluxos de trabalho, especialmente ao trabalhar com IA.

Além disso, os drivers do kernel precisam ser construídos como Arm64 nativo. 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 componentes 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 suportar processadores Arm64, consulte Criando drivers Arm64 com o WDK.

Observação

Os Progressive Web Apps (PWAs) já sã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), você pode usar:

  • Apresentando o Visual Studio 17.10 – Preview 1 (fev 2024)

  • Visual Studio 2022 v17.4 ou posterior. Esta é a primeira versão GA do Visual Studio que suporta nativamente a criação e depuração de aplicativos Arm64 em processadores baseados em Arm. As versões nativas do Visual Studio 2022 17.4 e do Microsoft Visual C++ (MSVC) Arm64 fornecem um desempenho significativamente melhor em comparação com as versões emuladas anteriores.

  • (Opcional) LLVM (Clang) v12+ ou posterior. LLVM 12 adiciona uma versão binária oficial hospedada em Windows em Arm64, incluindo um compilador Clang, o linker LLD e as bibliotecas runtime do compiler-rt.

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

Considere vários fatores ao escolher entre compilação cruzada ou compilação nativa, como hardware disponível e simplicidade de execução de teste.

Observação

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

Etapas para adicionar suporte nativo ao Arm64

Para atualizar seu aplicativo para ser executado nativamente em dispositivos Arm64:

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

Depois de confirmar que seu aplicativo está otimizado para dispositivos Arm:

  1. Atualize o instalador e publique o aplicativo atualizado
  2. Planejar 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 alvos de depuração e publicação ao projeto de aplicativo x64 ou x86 que já possui:

  1. Abra sua solução (código do projeto) no Visual Studio (consulte de pré-requisitos para as versões suportadas).
  2. No menu de seleção "Plataformas de solução" na barra de ferramentas padrão (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 verifique se o valor "Copiar configurações de" está definido como x64 com a caixa de seleção "Criar novas plataformas de projeto" ativada e, em seguida, selecione OK.

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

Se sua solução não for compilada com êxito, 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, que é abordado abaixo em Solução de Problemas.

(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 bin\ARM64\Debug ou Release do seu projeto seja selecionado. Digite o comando: dumpbin /headers .\<appname>.exe (substituindo <appname> pelo nome do seu aplicativo). Desloque-se para cima nos resultados de saída do seu terminal para encontrar a seção FILE HEADER VALUES e confirmar se a primeira linha é AA64 machine (ARM64).

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

Para verificar se sua 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. Altere a configuração de compilação de Debug para Release.
  3. No menu suspenso Build , selecione Rebuild Solution e aguarde a reconstrução do projeto.
  4. Você recebe um resultado Rebuild All foi bem-sucedido. Caso contrário, consulte a seção Solução de problemas .

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

Se estiver a desenvolver num dispositivo Windows em Arm, terá uma configuração fácil para a depuração local com o Visual Studio. Se você estiver compilando cruzadamente (usando um dispositivo que não esteja sendo executado em um processador Arm), então você deseja usar a depuração remota em um dispositivo Windows on Arm ou uma máquina virtual para habilitar sua experiência de desenvolvimento no Visual Studio enquanto executa o aplicativo Arm64 em outro dispositivo.

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

Se você está procurando hardware para usar para integração contínua (CI) e testes, estes são alguns dos dispositivos Windows com um processador baseado em Arm64:

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

Etapa 3 - Crie e teste seu aplicativo em dispositivos Arm

Adicionar um ciclo de automação de testes é uma consideração importante para a 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. Essa arquitetura pode ser 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 na mesma máquina que os testes, mas em muitos casos não é necessário. Em vez disso, você pode considerar estender a infraestrutura de compilação existente para produzir uma saída compilada cruzada para o Arm64.

Etapa 4 - Atualize o instalador e publique seu aplicativo atualizado

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

Se ainda não publica a sua aplicação na Microsoft Store, pode seguir as instruções para criar uma submissão de aplicação com base no envio de um MSI, EXE, pacote MSIX, PWA ou complemento de aplicação.

Se você construir seu próprio instalador, você deve garantir que ele possa instalar sua nova versão do Arm64 com sucesso. A maioria das estruturas de instalação, como WiX, Squirrel, InnoSetup, InstallAwaree outras suportam o Windows on Arm sem problemas.

Se oferecer o instalador do seu aplicativo a partir de uma página da Web, poderá usar User-Agent Client Hints para detetar quando o cliente está a visitar de um dispositivo Windows em Arm e oferecer a versão nativa atualizada de Arm do seu aplicativo. Ao contrário da cadeia de caracteres do agente do usuário, User-Agent Client Hints permite diferenciar clientes no Arm dos clientes em dispositivos x86.

Etapa 5 - Planejar atualizações contínuas

Agora que você publica uma versão Arm64 do seu aplicativo, você quer garantir que ele permaneça atualizado da mesma forma que outras versões do seu aplicativo. Mantenha as versões e os recursos alinhados entre arquiteturas para evitar confusão com o cliente no futuro.

Solução de problemas

Problemas comuns que interferem ou impedem que você adicione uma versão Arm64 do seu aplicativo x64 ou x86 existente do Windows incluem:

Uma dependência não compilada para ARM64 está bloqueando você de uma compilação bem-sucedida

Se não for possível criar seu aplicativo devido a uma dependência, seja interna, de terceiros ou de uma biblioteca de código aberto, será necessário atualizar essa dependência para oferecer suporte à arquitetura ARM64 ou removê-la.

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

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

  • Para dependências de código aberto, verifique vcpkg para ver se uma versão mais recente da dependência inclui suporte ARM64 para o qual você pode atualizar. Se não houver nenhuma atualização, considere contribuir com a adição do suporte ARM64 ao pacote. Muitos mantenedores de código aberto apreciam a contribuição.

  • A organização Linaro trabalha com empresas e comunidades de código aberto para desenvolver software em tecnologia baseada em Arm. Você pode fazer uma solicitação com o Linaro Service Desk para ajudar a atualizar o de suporte ao pacote para quaisquer dependências ausentes relacionadas ao Windows on Arm.

  • Use Arm64EC. As versões Arm64EC das dependências podem ser usadas para reconstruir uma aplicação enquanto ainda utilizando as versões x64 das dependências. Qualquer código x64, incluindo código de dependências, em um processo Arm64EC é executado sob emulação em seu aplicativo. (As versões Arm64 das 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

  • Você precisa modificar o conjunto específico da CPU ou chamadas de função intrínseca em linha para corresponder às instruções e funções disponíveis na CPU Arm. Para obter orientação, consulte: Usando Assembly e Intrínsecos em código C ou C++.

Seu aplicativo depende de um driver de kernel

Os controladores do kernel devem ser construídos na arquitetura Arm64 nativa. 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 componentes 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 suportar processadores Arm64, consulte Criando 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 suportar 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 do deste guia, as seguintes ferramentas e estruturas também são suportadas para o Arm64:

Bem como estruturas de terceiros, incluindo:

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

O Serviço de Consultoria do App Assure Arm está disponível para ajudar os desenvolvedores a criar aplicativos otimizados para o Arm. Este serviço é adicional à nossa promessa existente: as suas aplicações são executadas no Windows on Arm e, se encontrar algum problema, a Microsoft ajuda-o a corrigi-los. Mais informações.

Inscreva-se no Windows Arm Advisory Services.

  • Last updated on