Schnellere Kompilierung in Rust durch ein paralleles Frontend in der Nightly-Version

 (blog.rust-lang.org)
2 Punkte von GN⁺ 2023-11-11 | 1 Kommentare | Auf WhatsApp teilen

Schnellere Kompilierung mit dem parallelen Frontend des Rust-Compilers

  • Das Frontend des Rust-Compilers kann durch parallele Ausführung die Kompilierzeit deutlich verkürzen.
  • Das parallele Frontend ist eine experimentelle Funktion und kann im Nightly-Compiler mit der Option -Z threads=8 ausprobiert werden.
  • Die Veröffentlichung in einem stabilen Compiler ist für 2024 geplant.

Kompilierzeit und Parallelität

  • Die Kompilierzeit von Rust ist ein dauerhaftes Thema, und die Compiler Performance Working Group hat die Leistung des Compilers über mehrere Jahre hinweg kontinuierlich verbessert.
  • In den ersten zehn Monaten des Jahres 2023 wurden die Kompilierzeiten im Durchschnitt um 13 %, die Speichernutzung um 15 % und die Binärgröße um 7 % reduziert.
  • Der Compiler ist bereits stark optimiert, sodass neue Verbesserungsmöglichkeiten schwerer zu finden sind; Parallelität bleibt dabei eine große, aber schwierige Optimierung.

Bestehende Parallelität zwischen Prozessen

  • Beim Kompilieren von Rust-Programmen führt Cargo mehrere rustc-Prozesse parallel aus, um mehrere Crates zu kompilieren.
  • Wenn zwischen den Crates nur wenige Abhängigkeiten bestehen, funktioniert die parallele Ausführung gut; mit zunehmenden Abhängigkeiten nimmt sie jedoch ab.

Bestehende Parallelität innerhalb eines Prozesses: Backend

  • Der Compiler ist in Frontend und Backend unterteilt, wobei das Backend für die Codegenerierung zuständig ist und LLVM dies parallel verarbeitet.
  • Das Frontend übernimmt Parsing, Type Checking und weitere Aufgaben, konnte jedoch bis zu dieser Woche keine parallele Ausführung nutzen.

Neue Parallelität innerhalb eines Prozesses: Frontend

  • Das Frontend kann jetzt mit Rayon Kompilierarbeit in feingranularer Parallelität ausführen.
  • Wenn das parallele Frontend aktiviert ist und auf die Nutzung von 8 Threads eingestellt wird, zeigt sich eine deutliche Verkürzung der Laufzeit des Frontends.

Das Gesamtbild

  • Die Rust-Kompilierung profitiert schon lange von Parallelität zwischen Prozessen über Cargo sowie von Parallelität innerhalb eines Prozesses im Backend; nun kann auch das Frontend von Parallelität innerhalb eines Prozesses profitieren.
  • Der Compiler begrenzt die Zahl der erzeugten Threads mithilfe des jobserver-Protokolls, damit die Anzahl der CPU-Kerne nicht überschritten wird.

Verwendung

  • Der Nightly-Compiler wird mit aktiviertem parallelem Frontend ausgeliefert, läuft aber standardmäßig im Single-Thread-Modus.
  • Nutzer können mit der Option -Z threads in den Multi-Thread-Modus wechseln.

Auswirkungen auf die Leistung

  • Wenn das parallele Frontend im Single-Thread-Modus läuft, kann die Kompilierzeit im Vergleich zu bisher um 0 % bis 2 % langsamer sein.
  • Im Multi-Thread-Modus kann die Kompilierzeit um bis zu 50 % sinken, wobei der Effekt je nach Codeeigenschaften und Build-Konfiguration stark variiert.

Korrektheit

  • Im Single-Thread-Modus wird eine hohe Zuverlässigkeit erwartet.
  • Im Multi-Thread-Modus kann es bekannte Bugs und Deadlocks geben; die vom Compiler erzeugten Binärdateien sollten jedoch unabhängig vom verwendeten Frontend identisch sein.

Feedback

  • Wenn es Probleme mit dem parallelen Frontend gibt, können Issues mit dem Label "WG-compiler-parallel" geprüft und neue Issues eingereicht werden.

Zukünftige Arbeiten

  • Es wird weiter daran gearbeitet, die Leistung des parallelen Frontends zu verbessern und Bugs im Multi-Thread-Modus zu beheben.
  • Für 2024 ist geplant, die Option -Z threads zu stabilisieren, sodass stabile Releases standardmäßig im Multi-Thread-Modus laufen.

Meinung von GN⁺

Der wichtigste Punkt dieses Artikels ist, dass das Frontend des Rust-Compilers nun parallele Ausführung unterstützt und damit die Kompilierzeit deutlich verkürzt werden kann. Das bietet Rust-Entwicklern einen großen Vorteil in Form schnellerer Kompilierung und trägt zu einer effizienteren Entwicklungsumgebung bei. Die Einführung des parallelen Frontends ist eine spannende Nachricht für die Rust-Community und kann als Ergebnis kontinuierlicher Bemühungen zur Leistungsverbesserung gesehen werden.

Verwandte Beiträge

1 Kommentare

 
GN⁺ 2023-11-11
Hacker-News-Kommentare
  • Erwartungen an Verbesserungen der Rust-Kompiliergeschwindigkeit
    • Die langsame Kompilierung von Rust wird als Nachteil genannt, insbesondere bei der Arbeit in großen Repositories, wo sie zu höheren CI/CD-Kosten und Verzögerungen in der Entwicklung führt. Besonders problematisch ist es, wenn der Cache entfernt werden muss (was gelegentlich wegen Docker-Bugs vorkommt). Auf diese Fortschritte wird daher positiv reagiert.
  • Persönliche Erfahrungen mit der Rust-Kompiliergeschwindigkeit
    • Als Rust vor langer Zeit genutzt wurde, war die Kompilierung langsam, doch bei der erneuten Nutzung in letzter Zeit wird die Kompilierzeit fast nicht mehr wahrgenommen. Wenn Projekte jedoch größer werden, sind Verzögerungen beim Kompilieren weiterhin spürbar, weshalb diese Verbesserungen persönlich sehr willkommen sind.
  • Frage zum Rust-Kompilierungsprozess
    • Es wird gefragt, ob das Frontend von Rust erst nach Abschluss der Borrow-Checks das Backend arbeiten lassen kann. Dabei wird die Frage aufgeworfen, ob das Backend nicht spekulativ arbeiten und seine Arbeit verwerfen könnte, wenn Borrow-Check-Fehler gefunden werden.
  • Beobachtung zur Kompilierung von Rust-Binary-Crates
    • Im Gegensatz zu Library-Crates sind Binary-Crates standardmäßig groß und monolithisch aufgebaut, sodass ihre Kompilierung nicht parallelisiert wird und das größte Crate tendenziell serialisiert wird. Verbesserungen in diesem Bereich sind daher erfreulich.
  • Frage zur Nutzung von CPU-Kernen
    • Es wird gefragt, ob sich die Anzahl der CPU-Kerne beim Kompilieren automatisch nutzen lässt oder ob dafür ein fester Wert in einer Konfigurationsdatei eingetragen werden muss, die dann auch auf anderen Maschinen verwendet wird.
  • Warnung vor Bugs im Multithread-Modus
    • Es gibt bekannte Bugs und Deadlocks im Multithread-Modus; wenn die Kompilierung hängen bleibt, könnte eines dieser Probleme die Ursache sein. Gegenüber der Verwendung der Option -Z threads wird daher Vorsicht angemahnt.
  • Positive Einschätzung des aktuellen Stands der Rust-Kompiliergeschwindigkeit
    • Nach einigen Jahren ohne Rust fällt bei der jüngsten Rückkehr auf, dass die Kompiliergeschwindigkeit nahezu sofortig wirkt. Mit Tools wie ChatGPT lassen sich zudem Rust-Probleme, die früher schwer lösbar waren, heute leicht bewältigen, sodass der aktuelle Stand als sehr gut bewertet wird.
  • Frage zur Richtung der Rust-Kompilieroptimierung
    • Da Rust-Kompilierung bereits stark auf Dateiebene parallelisiert ist, wird die Sorge geäußert, ob eine Beschleunigung der Kompilierung einzelner Dateien nicht Ressourcen von der Parallelisierung auf höherer Ebene abzieht. Problematisch ist dabei, dass konkrete Daten dazu fehlen.
  • Ein begrüßender Kommentar zu den Verbesserungen der Rust-Kompiliergeschwindigkeit