Dela via

Lägga till armstöd i din Windows-app

Armbaserade enheter blir allt populärare på grund av sin energisnåla natur, längre batteritid och imponerande bearbetningskraft. Windows on Arm stöder neurala bearbetningsenheter (NPU:er) som är anpassade för de allt populärare AI- och Machine Learning-arbetsbelastningarna.

Den här guiden beskriver stegen för att lägga till stöd för dina Windows-appar för enheter som drivs av Arm64-processorer. Den innehåller också vägledning om sätt att hantera potentiella problem eller blockerare, till exempel beroenden från tredje part eller plugin-program, som kan störa skapandet av en Arm64-baserad version av din app.

Emulering på armbaserade enheter för x86- eller x64 Windows-appar

Arm-versioner av Windows 10 innehåller emuleringsteknik som gör att befintliga oförändrade x86-appar kan köras på Arm-enheter. Windows 11 utökar den emuleringen till att köra oförändrade x64 Windows-appar på armdrivna enheter.

Även om möjligheten att emulera x64- och x86-enheter på Arm-enheter är ett bra steg framåt, hjälper den här guiden dig att lägga till armbaserat stöd så att din app kan dra nytta av interna prestandavinster och de unika egenskaperna hos Arm64-drivna enheter, inklusive:

  • Optimera appens strömförbrukning för att förlänga enhetens batteritid.
  • Optimera prestanda för CPU, GPU och NPU:er för att påskynda arbetsflöden, särskilt när du arbetar med AI.

Dessutom måste kerneldrivrutiner skapas som native Arm64. Kerneln innehåller inte emulering. Den här begränsningen påverkar främst virtualiseringsscenarier. För appar som använder enhetsdrivrutiner som kräver direkt åtkomst till det interna operativsystemet eller maskinvaran som körs i kernelläge i stället för användarläge, och som ännu inte har uppdaterats för att stödja Arm64-processorer, se Skapa Arm64-drivrutiner med WDK.

Anmärkning

Progressive webbappar (PWA:er) körs redan med ursprunglig Arm64-prestanda.

Förutsättningar

Om du uppdaterar din app med hjälp av en Arm-baserad enhet (intern kompilering – generera koden för samma plattform som du kör på) kan du använda:

  • Introduktion till Visual Studio 17.10 – Förhandsversion 1 (feb 2024)

  • Visual Studio 2022 v17.4 eller senare. Det här är den första GA-versionen av Visual Studio som har inbyggt stöd för att skapa och felsöka Arm64-appar på Arm-baserade processorer. Både Visual Studio 2022 17.4 och Microsoft Visual C++ (MSVC) inbyggda Arm64-versioner ger betydligt bättre prestanda jämfört med tidigare emulerade versioner.

  • (Valfritt) LLVM (Clang) v12+ eller senare. LLVM 12 introducerar en officiell binärversion som är värd på Windows för Arm64, inklusive en Clang-kompilator, LLD-länkare och runtime-bibliotek för compiler-rt.

Om du uppdaterar din Windows-app för att stödja Arm med hjälp av en x64- eller x86 Intel-baserad enhet (korskompilering) kan du använda:

Överväg flera faktorer när du väljer mellan korskompilering eller intern kompilering, till exempel tillgänglig maskinvara och enkelhet i testkörning.

Anmärkning

GCC är GNU Compiler Collection support mål för den närmaste framtiden.

Steg för att lägga till inbyggt arm64-stöd

Så här uppdaterar du appen så att den körs internt på Arm64-enheter:

  1. Lägga till en Arm64-konfiguration i projektet i Visual Studio
  2. Testa och felsöka den nybyggda Arm64-appen
  3. Skapa och testa din app på Arm-enheter

När du har bekräftat att appen är optimerad för Arm-enheter:

  1. Uppdatera installationsprogrammet och publicera den uppdaterade appen
  2. Planera för pågående uppdateringar

Steg 1 – Lägga till en Arm64-konfiguration i projektet i Visual Studio

Så här lägger du till en ny ARM64-lösningsplattform med felsöknings- och lanseringsmål i ditt befintliga x64- eller x86-appprojekt:

  1. Öppna din lösning (projektkod) i Visual Studio (se förutsättningar för de versioner som stöds).
  2. I den nedrullningsbara menyn "Lösningsplattformar" i verktygsfältet Standard (eller i menyn "Skapa" väljer du Configuration Manager...
  3. Öppna den nedrullningsbara menyn "Aktiv lösningsplattform" och välj <Ny...>.
  4. I listrutan "Skriv eller välj den nya plattformen" väljer du ARM64 och ser till att värdet "Kopiera inställningar från" är inställt på x64 med kryssrutan "Skapa nya projektplattformar" aktiverat och välj sedan OK.

Grattis! Du har börjat lägga till Arm-stöd i din app. Kontrollera sedan om Arm64-lösningen har skapats framgångsrikt.

Om din lösning inte skapas framgångsrikt måste du lösa de problem som orsakar att bygget misslyckas. Den troligaste orsaken är att ett beroende inte är tillgängligt för ARM64, vilket beskrivs i Felsökning nedan.

(Valfritt): Om du vill kontrollera att din appbinärfil har skapats för Arm64 öppnar du projektkatalogen i PowerShell (högerklicka på appprojektet i Visual Studio Solution Explorer och välj Öppna i Terminal). Ändra kataloger så att projektets nya bin\ARM64\Debug katalog eller versionskatalog väljs. Ange kommandot: dumpbin /headers .\<appname>.exe (ersätt <appname> med namnet på din app). Rulla uppåt i terminalens utdataresultat för att hitta FILE HEADER VALUES avsnittet och bekräfta att den första raden är AA64 machine (ARM64).

Steg 2 – Testa och felsöka den nybyggda Arm64-appen

För att säkerställa att din Arm64-lösning har byggts framgångsrikt efter att du har lagt till Arm64-lösningsplattformen till ditt projekt i Visual Studio:

  1. Stäng fönstret Aktiv lösningsplattform .
  2. Ändra versionsinställningen från Debug till Release.
  3. I listrutan Skapa väljer du Återskapa lösning och väntar tills projektet har återskapats.
  4. Du får utdata Återskapa alla har lyckats. Om inte kan du läsa avsnittet Felsökning .

När binärfilerna har skapats för att appen ska ha stöd för Arm64 vill du testa dem. Den testningen kräver att en enhet eller en virtuell dator kör Windows på Arm.

Om du utvecklar på en Windows på Arm-enhet har du en enkel konfiguration med lokal felsökning i Visual Studio. Om du korskompilerar (med en enhet som inte körs på en Arm-processor) vill du använda fjärrfelsökning på en Windows på arm-enhet eller en virtuell dator för att aktivera din utvecklingsupplevelse i Visual Studio när du kör Arm64-appen på en annan enhet.

Windows på Arm-maskinvara eller virtuella datorer tillgängliga för test

Om du letar efter maskinvara som ska användas för kontinuerlig integrering (CI) och testning är det här några av Windows-enheterna med en Arm64-baserad processor:

Hjälp med att konfigurera en virtuell dator (VM) som kör Windows på Arm för att stödja CI och testning finns i Snabbstart: Skapa en virtuell Windows på arm-dator i Azure-portalen.

Steg 3 – Skapa och testa din app på Arm-enheter

Att lägga till ett testautomatiseringspass är en viktig faktor för din CI/CD-strategi (Continuous Integrations and Continuous Delivery). För Arm64-lösningar som körs i Windows är det viktigt att köra din testsvit på Arm64-arkitekturen. Den här arkitekturen kan vara faktisk Windows på arm-maskinvara, med hjälp av någon av de Arm-enheter som angavs tidigare, eller en virtuell dator, från de virtuella datorer som angavs tidigare.

Det är enklare att kompilera appen när den görs på samma dator som testerna, men i många fall krävs det inte. I stället kan du överväga att utöka den befintliga bygginfrastrukturen för att skapa korskompilerade utdata för Arm64.

Steg 4 – Uppdatera installationsprogrammet och publicera din uppdaterade app

Om du publicerar till Microsoft Store, när du har skapat en Arm64-version av din app genom att följa föregående steg, kan du uppdatera ditt befintliga apppaket i Microsoft Store genom att gå till instrumentpanelen för Partnercenter och lägga till de nybyggda ARM64-binärfilerna i sändningen.

Om du inte redan publicerar din app i Microsoft Store kan du följa anvisningarna för att skapa en appöverföring baserat på om du vill skicka ett MSI- eller EXE-, MSIX-paket, PWA- eller apptillägg.

Om du skapar ett eget installationsprogram bör du se till att det kan installera din nya Arm64-version. De flesta installationsramverk, till exempel WiX, Squirrel, InnoSetup, InstallAware och andra stöder Windows på Arm utan problem.

Om du erbjuder appens installationsprogram från en webbsida kan du använda User-Agent Klienttips för att identifiera när kunden besöker från en Windows på Arm-enhet och erbjuda dem den uppdaterade Arm-inbyggda versionen av din app. Till skillnad från användaragentsträngen gör User-Agent klienttips att du kan skilja kunder på Arm från kunder på x86-enheter.

Steg 5 – Planera för pågående uppdateringar

Nu när du publicerar en Arm64-version av din app vill du se till att den uppdateras på samma sätt som andra versioner av din app. Håll versioner och funktioner justerade mellan arkitekturer för att undvika kundförvirring i framtiden.

Felsökning

Vanliga problem som stör eller blockerar dig från att lägga till en Arm64-version av din befintliga x64- eller x86 Windows-app är:

Ett beroende som inte kompilerats för ARM64 hindrar en lyckad kompilering.

Om du inte kan skapa din app på grund av ett beroende, oavsett om det är internt, från en tredje part eller från ett bibliotek med öppen källkod, måste du antingen uppdatera beroendet för att stödja ARM64-arkitekturen eller ta bort den.

  • För interna beroenden, bygg om beroendet för ARM64-stöd.

  • För beroenden från tredje part begär du att underhållaren återskapar beroendet med ARM64-stöd.

  • För beroenden med öppen källkod kontrollerar du vcpkg för att se om en nyare version av beroendet innehåller ARM64-stöd som du kan uppdatera till. Om det inte finns någon uppdatering kan du överväga att bidra med ARM64-stöd till paketet själv. Många administratörer av öppen källkod uppskattar bidrag.

  • Linaro-organisationen samarbetar med företag och communitys med öppen källkod för att utveckla programvara för Arm-baserad teknik. Du kan skicka en begäran till Linaro Service Desk för att hjälpa till att uppdatera paketstöd för eventuella saknade beroenden relaterade till Windows on Arm.

  • Använd Arm64EC. Arm64EC-versioner av beroenden kan användas för att återskapa ett program samtidigt som x64-versioner av beroenden används. All x64-kod, inklusive kod från beroenden, i en Arm64EC-process körs under emulering i din app. (Arm64-versioner av beroenden kan inte användas i det här fallet.)

  • Ta bort och ersätt beroendet av ditt appprojekt.

Kod skrivs för en annan arkitektur än Arm64

Din app förlitar sig på en kerneldrivrutin

Kerneldrivrutiner måste skapas som inbyggd Arm64. Kerneln tillhandahåller ingen emulering. Den här begränsningen påverkar främst virtualiseringsscenarier. För appar som använder enhetsdrivrutiner som kräver direkt åtkomst till det interna operativsystemet eller maskinvaran som körs i kernelläge (i stället för användarläge), och som ännu inte har uppdaterats för att stödja Arm64-processorer, se Skapa Arm64-drivrutiner med WDK.

Dessutom måste drivrutiner i Windows skapas som Arm64 och kan inte emuleras. För appar som förlitar sig på programvarudrivrutiner som ännu inte har uppdaterats för att stödja Arm64-processorer, se Skapa Arm64-drivrutiner med WDK.

Verktygskedja för Windows på Arm

Förutom stöd för Visual Studio och LLVM (CLANG) som delas i avsnittet Förutsättningar i den här guiden stöds även följande verktyg och ramverk för Arm64:

Förutom ramverk från tredje part, inklusive:

Behöver du hjälp? Utnyttja vår App Assure-tjänst

App Assure Arm Advisory Service är tillgänglig för att hjälpa utvecklare att skapa armoptimerade appar. Den här tjänsten är utöver vårt befintliga löfte: dina appar körs på Windows på Arm, och om du stöter på några problem hjälper Microsoft dig att åtgärda dem. Läs mer.

Registrera dig för Windows Arm Advisory Services.

  • Last updated on