Python auf Arm: Update 2025

Verfasst von Diego Russo, Arm Ltd

Warum Python für Arm wichtig ist

Python ist heute eine der am weitesten verbreiteten Programmiersprachen und treibt Anwendungen in den Bereichen Machine Learning (ML), Automatisierung, Data Science, DevOps, Webentwicklung und Entwickler-Tools an. Bei Arm betrachten wir Python nicht nur als eine zu unterstützende Sprache, sondern als strategische Priorität, um eine breite und wachsende Entwicklergemeinschaft zu ermöglichen.

In den letzten Jahren haben wir eng mit der Python-Community zusammengearbeitet, um Arm zu einer erstklassigen Plattform für die Python-Entwicklung zu machen. Dank konsequenter Upstream-Zusammenarbeit, gezieltem Engineering und Investitionen in das Ökosystem ist es heute praktikabel, Python-Workloads auf Arm über Linux, Windows und die Cloud hinweg zu entwickeln, zu testen und bereitzustellen.

Im Jahr 2024 haben wir darüber berichtet, wie Arm sein Engagement im Python-Ökosystem verstärkt hat. Ein Jahr später sehen wir die Ergebnisse dieser Investition mit neuer Infrastruktur, verbesserter Leistung und einer wachsenden Zahl von realen Projekten, die auf Arm laufen.

Dieser Beitrag beleuchtet die wichtigsten Entwicklungen des vergangenen Jahres und was vor uns liegt.

Was gibt es Neues im Jahr 2025

Einfachere Entwicklung: Von GitHub gehostete Runner für Linux und Windows auf Arm

Im Rahmen unserer Zusammenarbeit mit GitHub hat Arm dazu beigetragen, von GitHub gehostete CI-Runner für Arm-basierte Plattformen zu ermöglichen. Diese Runner sind jetzt verfügbar für

• Linux auf Arm (GA)
• Windows auf Arm, derzeit in der Beta-Phase

Arm sponserte die zugrunde liegende Infrastruktur und stellte technische Unterstützung während des Beta-Rollouts bereit. Diese Runner bieten Open-Source-Projekten eine schnelle und zuverlässige Möglichkeit, native CI-Workflows ohne Emulation oder Self-Hosting auszuführen.

Das CPython-Projekt war der erste Open-Source-Nutzer der Windows on Arm-Runner und nutzt diese weiterhin in täglichen CI-Pipelines. Dies trägt zur Gewährleistung einer erstklassigen Unterstützung für die Plattform bei.

Leistungsverbesserungen

Python 3.13 führte einen experimentellen Just-in-Time (JIT)-Compiler ein, der vom CPython-Team entwickelt wurde, um die Leistung in realen Anwendungen zu verbessern. Arm hat direkt zu dieser Anstrengung beigetragen, indem es den JIT auf Arm-Plattformen getestet, optimiert und erweitert hat, insbesondere für die AArch64-Architektur (siehe unten).

Unsere Arbeit umfasst die Behebung architektur­spezifischer Probleme, die Validierung von generiertem Maschinencode und die Verbesserung der Gesamt­qualität des JIT-Outputs auf Arm. Diese Bemühungen haben zu folgenden Ergebnissen geführt:

• Bis zu 4 % Geschwindigkeitssteigerung unter Linux
• 17 % Reduzierung der Größe generierter Header-Dateien
• Intelligentere Sprungbehandlung und effizientere Codeerzeugung
• Geringerer Speicher­aufwand durch Wiederverwendung von Trampolinen und gezielte Optimierungen

Das Ergebnis ist eine schnellere und zuverlässigere JIT-Erfahrung für Python-Workloads, die auf Arm laufen.

Bessere Ökosystem-Unterstützung für Windows auf Arm

Die Python-Unterstützung für Windows auf Arm reift weiter. CPython selbst und viele wichtige Pakete lassen sich nun problemlos auf der Plattform erstellen und ausführen. Dies ist auf Upstream-Korrekturen, verbesserte Build-Systeme und erweiterte CI-Abdeckung zurückzuführen.

Wir arbeiten eng mit Microsoft zusammen, um die allgemeine Python-Erfahrung auf Windows on Arm-Geräten zu verbessern. Dazu gehört

• Kompatibilität für beliebte Bibliotheken gewährleisten
• Optimierung von Build- und Packaging-Workflows
• Unterstützung wichtiger KI- und ML-Tools

Ein Bereich mit großen Fortschritten ist PyTorch, wo die Zusammenarbeit zwischen Arm und Microsoft native Builds und verbesserte Beschleunigungs­unterstützung ermöglicht hat.

Mit der Veröffentlichung von PyTorch 2.7 für Windows auf Arm können Entwickler jetzt auf Arm-native Builds für Windows zugreifen, die für Python 3.12 verfügbar sind. Dies ermöglicht es, ML-Workflows nativ auf Arm64 Windows-Geräten, einschließlich Copilot+ PCs, auszuführen und dabei vollen Zugriff auf die Hardware­funktionen zu haben.

Diese Verbesserungen unterstützen eine Vielzahl von ML-Anwendungs­fällen. Von generativen Modellen wie Stable Diffusion über natürliche Sprach­verarbeitung bis hin zu traditioneller Regression und Klassifizierung. Windows auf Arm ist jetzt eine produktions­reife Plattform für die moderne KI-Entwicklung.

Arms Engagement für die Python-Community

Wir unterstützen die Python-Community weiterhin nicht nur durch Code, sondern auch durch Infrastruktur, Finanzierung und Zeit durch

• Hosting des CPython Core Dev Sprint 2025 in unserem Büro in Cambridge
• Sponsoring von EuroPython 2022, 2023 und 2025
• Bereitstellung eines dedizierten Benchmark-Servers, integriert mit speed.python.org
• Finanzierung eines Vollzeit-CPython-Entwicklers, jetzt ein Core Committer

Arm hat sich der Unterstützung des Python-Ökosystems durch nachhaltige Upstream-Beiträge und Community-Investitionen verschrieben. Im vergangenen Jahr haben wir unsere Bemühungen verstärkt, die Community sowohl technisch als auch organisatorisch zu unterstützen.

CPython Core Dev Sprint 2025

Wir sind stolz darauf, den kommenden CPython Core Dev Sprint 2025 im September in unserem Büro in Cambridge zu veranstalten und zu sponsern. Der Sprint, der voraussichtlich der größte jemals abgehaltene Sprint sein wird, bringt über 55 Kern­entwickler und Mitwirkende aus Europa, den Vereinigten Staaten, Südkorea, Singapur und Australien zusammen.

Diese Sprints sind entscheidend für die Weiterentwicklung von Python, da sie persönliche Design­diskussionen, Upstream-Planungen und konzentrierte Entwicklungs­arbeiten ermöglichen, die aus der Ferne schwer zu koordinieren sind. Durch die Unterstützung dieses globalen Events hilft Arm, die technische Roadmap von Python zu beschleunigen und gleichzeitig unsere Zusammenarbeit mit den Menschen zu stärken, die die Sprache pflegen und gestalten.

Unterstützung von EuroPython

Außerdem sponserte Arm EuroPython 2025 zum dritten Mal, nachdem die Konferenz bereits 2022 und 2023 unterstützt wurde. Dies fördert die Zusammenarbeit zwischen Maintainern, Mitwirkenden und Nutzern weltweit.

Arm präsentierte auf der EuroPython 2025 einen Vortrag über den JIT mit dem Titel Exploring the CPython JIT, der eine technische Vertiefung des Zustands und der Entwicklung des JIT auf Arm-Plattformen bot. Wir werden Einblicke in unsere Arbeit mit dem neuen JIT-Compiler in Python 3.14 geben.

Dedizierter Arm-Benchmark-Server

Um die Kern­entwickler von Python bei der Leistungs­überwachung zu unterstützen, stellt Arm nun einen dedizierten Benchmark-Server auf Arm-Hardware bereit, der Ergebnisse auf speed.python.org veröffentlicht. Dieser Server integriert sich in die Leistungs­überwachungs­tools von Python und hilft dabei, die Auswirkungen von Code­änderungen auf Arm-Plattformen zu bewerten und datengesteuerte Optimierungen zu ermöglichen.

Upstream-First-Beiträge zu CPython

Arm investiert auch weiterhin direkt in Upstream-Arbeit. Als Ergebnis dieser Arbeit wurde ich kürzlich zum CPython Core Developer befördert, was unsere technische Zusammenarbeit mit dem Python-Projekt weiter stärkt.

Im vergangenen Jahr hat Arm zu verschiedenen Bereichen des Interpreters beigetragen, darunter

• Verbesserungen am CPython JIT
• Verbesserungen am Micro-Op-Optimierer
• Erweiterungen der Performance-Benchmarking-Infrastruktur
• Überprüfung von Pull Requests und Triage von Issues

Diese Bemühungen spiegeln das übergeordnete Ziel von Arm wider: nicht nur Plattform-Enablement, sondern nachhaltige, Upstream-First-Beiträge zur Python-Sprache selbst.

Technische Beiträge

Die jüngsten Beiträge von Arm zu CPython konzentrieren sich auf die Verbesserung des JIT und der Leistung auf AArch64-Plattformen. Jede dieser Änderungen verbessert den JIT-generierten Maschinencode für Arm-Plattformen, was zu einer effizienteren Python-Ausführung führt.

Obwohl der JIT noch in den Anfängen steckt, zeigt er bereits Potenzial in gezielten Workloads. Unsere Beiträge legen den Grundstein für zukünftige Geschwindigkeitssteigerungen auf Arm-basierten Systemen.

GH-123872: Generieren und Patchen von AArch64-Trampolinen

Diese Pull-Anfrage führt die Generierung und das Patchen von Trampolinen für AArch64 im JIT-Compiler ein. Durch die Implementierung dieser Trampoline kann der JIT Sprünge außerhalb des Bereichs effektiver handhaben und so die Zuverlässigkeit und Leistung von JIT-kompiliertem Code auf AArch64-Plattformen verbessern. Dieser Patch macht den JIT 0,8 % schneller und verbraucht 0,6 % weniger Speicher unter Linux.

GH-121001: Ersetzen von AArch64-Trampolinen durch LDR

Aufbauend auf der vorherigen Arbeit ersetzt diese Änderung den bestehenden Trampolin-Mechanismus durch die Verwendung der LDR-Instruktion für AArch64. Diese Vereinfachung reduziert die Komplexität und verbessert die Wartbarkeit des JIT-Code­generierungs­prozesses. Sie reduziert die Größe der vom Stencil generierten Header-Datei um 17 % und die Anzahl der gepatchten Funktionen von 4 auf 1.

// Old trampoline  
d2800008 mov x8, #0x0  
f2a00008 movk x8, #0x0, lsl #16  
f2c00008 movk x8, #0x0, lsl #32  
f2e00008 movk x8, #0x0, lsl #48  
d61f0100 br x8

// New trampoline  
58000048 ldr x8, 8  
d61f0100 br x8  
00000000 # Used to patch the 64-bit address  
00000000 # Used to patch the 64-bit address

GH-120250: JIT: Wiederverwendung von Trampolinen auf AArch64

Diese Verbesserung ermöglicht es dem JIT-Compiler, bestehende Trampoline auf AArch64 wiederzuverwenden, was Redundanzen minimiert und die Speichernutzung optimiert. Durch die Wiederverwendung von Trampolinen reduziert der JIT den Mehraufwand, der mit der Generierung neuer Trampoline für jeden Sprung außerhalb des Bereichs verbunden ist.

GH-131041: AArch64-Trampoline nur für lange Sprünge emittieren

Diese Optimierung stellt sicher, dass Trampoline nur bei Bedarf emittiert werden, insbesondere für lange Sprünge, die nicht direkt kodiert werden können. Durch die Vermeidung der Generierung überflüssiger Trampoline optimiert der JIT-Compiler den Code­generierungs­prozess und reduziert die Codegröße.

GH-131042: Entfernen des nachfolgenden Sprungs in AArch64 JIT-Stencils

Diese Verfeinerung eliminiert unnötige nachfolgende Sprünge in AArch64 JIT-Stencils. Durch das Entfernen dieser redundanten Instruktionen erzeugt der JIT effizienteren Maschinencode, was zu potenziellen Leistungs­steigerungen während der Ausführung führt, einschließlich einer Geschwindigkeits­steigerung von 1,4 % unter Linux.

// With the trailing jump that needs to be patched  
0x08, 0x00, 0x00, 0x90, // adrp x8, _JIT_OPERAND0  
0x08, 0x01, 0x40, 0xf9, // ldr x8, [x8]  
0x88, 0x1e, 0x00, 0xf9, // str x8, [x20, #0x38]  
0x00, 0x00, 0x00, 0x14, // b _JIT_CONTINUE  

// The trailing jump has been replaced with a NOP  
0x08, 0x00, 0x00, 0x90, // adrp x8, _JIT_OPERAND0  
0x08, 0x01, 0x40, 0xf9, // ldr x8, [x8]  
0x88, 0x1e, 0x00, 0xf9, // str x8, [x20, #0x38]  
0x1f, 0x20, 0x03, 0xd5, // nop (branch was removed)

Ausblick

Das Engagement von Arm im Python-Ökosystem wird auch 2025 und darüber hinaus fortgesetzt. Wir konzentrieren uns weiterhin auf Leistung, Ökosystem­enablement und Upstream-Zusammenarbeit. Ob durch Infrastruktur, Entwickler­finanzierung oder Beiträge zu CPython-Interna – unser Ziel ist es, Python auf Arm zu einer schnellen, stabilen und zugänglichen Plattform für alle Benutzer zu machen.

Wir werden weiterhin Beiträge in Schlüsselbereichen des Interpreters leisten, einschließlich des JIT, der SIMD-Ausführung und der Kern­evaluations­schleife. Zukünftig planen wir, die Integration von architektur­spezifischen Instruktionen wie NEON, SVE, SVE2, SME und Arms neuem SME2 in den JIT-Compiler zu untersuchen, um gezielte Workloads zu beschleunigen.

Wir engagieren uns auch dafür, die Community-Seite von Python zu stärken, indem wir Patches überprüfen, neue Mitwirkende betreuen und wichtige Veranstaltungen unterstützen, die Maintainer zusammenbringen.

Machen Sie mit

Wir freuen uns auf die Zukunft von Python auf Arm und möchten Ihre Meinung hören.

Jetzt ist der perfekte Zeitpunkt, um Ihre Python-Workloads auf Arm auszuführen. Es ist einfacher als je zuvor

• Von GitHub gehostete Runner für Linux und Windows auf Arm sind verfügbar
• Die meisten PyPI-Pakete funktionieren jetzt out-of-the-box auf Arm-Systemen
• Arm-Instanzen sind in allen großen öffentlichen Clouds verfügbar

Wenn Sie auf Probleme stoßen, melden Sie diese upstream oder kontaktieren Sie uns direkt.

Ob Sie an Python selbst arbeiten, Tools und Bibliotheken entwickeln oder Ihre Software auf Arm-basierte Systeme portieren – wir laden Sie ein, sich über das Arm Developer Program mit uns zu vernetzen. Es ist der beste Weg, auf dem Laufenden zu bleiben, auf technische Ressourcen zuzugreifen und mit Arm-Ingenieuren und anderen Python-Entwicklern zusammenzuarbeiten.

Lassen Sie uns Python auf Arm gemeinsam weiter verbessern.