Der kürzlich veröffentlichte AMD Ryzen 9 5950x bietet 16 Kerne und 32 Threads. Lassen Sie uns also sehen, welche Leistung wir aus einer parallelen C++ – Kompilierung mit diesen 32 Threads ziehen können. Zum Zeitpunkt dieses Schreibens weist der AMD Ryzen 9 5950x mit rund 3515 den höchsten Single-Core- CPU-Benchmark- Wert auf. C++Builder ist ein schnelles Tool zur Anwendungsentwicklung zum Erstellen von C++ – Windows-Apps. Es bietet normale Kompilierung und enthält in der neuesten Version ein Add-On namens TwineCompile , das alle 32 Threads des Ryzen 5950x-Kraftpakets verwendet, um mehrere Dateien im C++ – Projekt gleichzeitig zu kompilieren. Wir haben zwei frühere Beiträge verfasst, in denen wir den 5950x mit ~ 750.000 Codezeilen verglichen haben, die in Delphi kompiliert wurden, und 300 native Windows-Apps in Delphi parallel erstellt haben.

Das Projekt, das ich zum Testen der parallelen C++ – Kompilierung verwendet habe, ist eine große C++ – Windows-App mit 128 Formularen und laut C++Builder ~ 254.000 Zeilen C++. Die Formulare stammen aus den 50 Projektformularen in diesem C++ Cross Platform Samples- Repository. Wir haben die 50 Formulare 2 und 3 Mal verwendet, um zur 128-Nummer zu gelangen. Ursprünglich haben wir dieses Projekt gebaut, um den AMD Ryzen Threadripper 3990x mit 64 Kernen und 128 Threads zu bewerten. Sobald wir 128 Formulare im Projekt hatten, fügten wir jeder der 128 Einheiten generisches C++ hinzu, um sie auf jeweils über 1000 Zeilen zu bringen. Beachten Sie, dass jedes Projekt eine andere Arbeitsbelastung aufweist und die Ergebnisse in Ihren eigenen Projekten variieren können. Verschiedene C++ – Sprachfunktionen und Projektkonfigurationen können sich auf die Kompilierungszeiten auswirken.

Die vollständigen technischen Daten des AMD Ryzen 9 5950x-Benchmark-Computers sind AMD Ryzen 9 5950x, 64 GB DDR4 3200 MHz RAM, 1 TB NVMe SSD + 2 TB Festplatte, NVIDIA GeForce RTX 3070 8 GB und Windows 10 Pro. Um die CPU- und Festplatten-E / A-Nutzung der parallelen Kompilierung von C ++ Builder zu überwachen, habe ich  Task Manager DeLuxe  oder TMX (ebenfalls in Delphi integriert) verwendet. Der Task-Manager DeLuxe bietet eine erstaunliche Menge an Informationen zu Ihrem Windows-System. TMX ist bei  MiTeC erhältlich Dadurch werden auch eine Vielzahl von Delphi-Komponenten hergestellt, mit denen Sie auf viele der gleichen Informationen zugreifen können, die in TMX enthalten sind. Unten finden Sie die 32-CPU-Thread-Ansicht, die TMX bietet. Ich habe diesen Screenshot während der normalen synchronen C++Builder-Kompilierung gemacht. Sie können im Screenshot sehen, dass wirklich nur ein einziger Kern gleichzeitig für die Kompilierung verwendet wird.

Schauen wir uns als nächstes den Screenshot aus dem Task Manager DeLuxe kurz nach der parallelen C++-Kompilierung mit TwineCompile in C++Builder an. Sie werden in diesem Screenshot sehen, dass er alle Threads für die Kompilierung verwendet. Sie können sehen, wie alle 32 Threads verwendet wurden. TMX bietet auch eine praktische Überwachung der CPU-Taktfrequenz, da der AMD Ryzen 9 5950x Turbo-Boost bis zu 4,9Ghz erreicht (im Screenshot nur 4,2Ghz). Interessant ist hier, dass sich die Benchmarks bei jedem Durchlauf um ein paar Sekunden ändern, da das Turbo-Boosting von 3,9 Ghz auf 4,9 Ghz nicht konsistent ist.

Wenn Sie mehr über die AMD Ryzen 9 5950x CPU-Architektur erfahren möchten, hat AMD ein großartiges Video, in dem sie die Zen 3-Architektur erklären.

Kommen wir nun zum Vergleich der Zahlen. Es gibt eine Reihe von verschiedenen Arten von Builds, die in C++Builder durchgeführt werden können. Dazu gehören ein Debug-Build (-O0) und ein Release-Build. Beim Release-Build können verschiedene Optimierungsflags ausgewählt werden (-O1, -O2 und -O3). Jedes Flag hat ein anderes Optimierungsziel. -O1 erzeugt den kleinstmöglichen Code, -O2 erzeugt den schnellstmöglichen Code und -O3 erzeugt den am meisten optimierten Code. Laut Embarcadero bringt -O3 Geschwindigkeitsverbesserungen von bis zu doppelt so viel Leistung wie -O2.

Die Debug-Builds sind die schnellsten der vier Optimierungsstufen. Dies macht sich vor allem beim normalen Kompilieren bemerkbar, da die Release-Builds bis zu einer Minute länger brauchen als die Debug-Builds. Bei Verwendung der parallelen Kompilierung war der Build-Prozess sowohl im Debug- als auch im Release-Modus so schnell, dass es kaum eine Rolle spielt, da die Ergebnisse alle ziemlich nah beieinander liegen. Das erste Diagramm hier zeigt den normalen C++-Debug-Build (-O0) mit 396 Sekunden im Vergleich zum parallelen C++-Debug-Build (-O0) mit 33 Sekunden (12-mal schneller!). Wenn wir die Zahlen auf Codezeilen pro Sekunde umrechnen, erhalten wir etwa 7.696 Codezeilen pro Sekunde, wenn wir das parallele TwineCompile für -O0 verwenden. Der normale Debug-Synchron-Build für -O0 kommt auf 641 Zeilen pro Sekunde zum Kompilieren.

Im zweiten Diagramm haben wir den normalen C++ Release Build (-O1) mit 404 Sekunden gegenüber dem parallelen C++ Release Build (-O1) mit 32 Sekunden (~12X schneller!). Die Sekunden für den parallelen Build variieren je nach aktueller Geschwindigkeit des Turbo Boosts (irgendwo zwischen 3,9 Ghz und 4,9 Ghz). Wenn wir die Zahlen auf Codezeilen pro Sekunde umrechnen, erhalten wir etwa 7.937 Codezeilen pro Sekunde, wenn wir das parallele TwineCompile für -O1 verwenden. Der normale synchrone -O1-Build kommt auf 628 Zeilen pro Sekunde zum Kompilieren.

Im dritten Diagramm sehen wir den normalen C++ Release Build (-O2) mit 449 Sekunden gegenüber dem parallelen C++ Release Build (-O2) mit 37 Sekunden (~12X schneller!). Die Sekunden für den parallelen Build variieren je nach aktueller Geschwindigkeit des Turbo Boosts (irgendwo zwischen 3,9 Ghz und 4,9 Ghz). Wenn wir die Zahlen auf Codezeilen pro Sekunde umrechnen, erhalten wir etwa 6.864 Codezeilen pro Sekunde mit dem parallelen TwineCompile für -O2. Der normale synchrone -O2-Build kommt auf 565 Zeilen pro Sekunde zum Kompilieren.

Im vierten und letzten Diagramm haben wir den normalen C++ Release Build (-O3) mit 450 Sekunden gegenüber dem parallelen C++ Release Build (-O3) mit 36 Sekunden (~12X schneller!). Die Sekunden des parallelen Builds variieren je nach aktueller Geschwindigkeit des Turbo Boosts (irgendwo zwischen 3,9 Ghz und 4,9 Ghz). Ich habe hier zwischen 36 Sekunden und 40 Sekunden gesehen. Wenn wir die Zahlen auf Codezeilen pro Sekunde umrechnen, erhalten wir etwa 7.055 Codezeilen pro Sekunde, wenn wir das parallele TwineCompile für -O3 verwenden. Der normale synchrone -O3-Build kommt auf 564 Zeilen pro Sekunde zum Kompilieren.

Es genügt zu sagen, dass der Produktivitätsschub durch die parallele Kompilierung signifikant ist. Wenn man in der Lage ist, eine große C++-Anwendung in etwa 30 Sekunden zu kompilieren, kann man schneller iterieren (ähnlich der Iterationsgeschwindigkeit, die man in Delphi erreichen kann), weil die Kompilierzeiten so schnell sind. Ich bezeichne 128 Formulare und ~254k Zeilen Code für ein Windows-Projekt als groß. Es ist sicherlich kein kleines Projekt (2-3 Formulare) und es ist sicherlich kein großes Projekt (Millionen und Abermillionen von Codezeilen).

Vergleichen wir nun den Delphi 10.4.1-Compiler mit dem C++Builder Parallel-Compiler. In unserem ersten Blog in dieser Serie kompiliert eine AMD Ryzen 9 5950x CPU generiklastigen Object Pascal Code mit etwa 61.500 Zeilen pro Sekunde, was auf 1 Million Zeilen generiklastigen Object Pascal Code in 16 Sekunden hochgerechnet werden kann. Der schnellste parallele C++Builder-Build (-O1) kompiliert 7.937 Zeilen Code pro Sekunde, was auf 1 Million Zeilen C++ in ~126 Sekunden extrapoliert werden kann. Die gleiche synchrone C++-Kompilierung mit C++Builder -O1 betrug 628 Codezeilen pro Sekunde, was auf 1 Million C++-Codezeilen in 1592 Sekunden hochgerechnet werden kann. Wie Sie sehen können, nähert sich die parallele Kompilierung in C++Builder der Produktivität von Delphi an, da die Kompiliergeschwindigkeit um Größenordnungen schneller ist als die normale Kompilierung. C++Builder mit paralleler Kompilierung auf moderner Hardware durch TwineCompile kann Sie nahe an die Produktivität von Delphi mit der Geschwindigkeit und Leistung von C++ für Ihre Windows-Anwendungen bringen.

Moderne Hardware ist und der AMD Ryzen 9 5950x ist mit seinen 16 Kernen und 32 Threads großartig, aber die Ryzen 9 5950x CPU ist im Moment tatsächlich schwer zu bekommen. Wie sieht es mit der Verwendung von TwineCompile auf einer älteren Maschine aus? Ich habe in den letzten 8 Jahren einen i7-3770 mit 4 Kernen und 8 Threads als meinen täglichen Fahrer benutzt. Die Spezifikationen dieses Rechners sind ungefähr ein Intel i7-3770, 16GB RAM, 1TB SSD, Windows 10 Home. Sein CPU-Benchmark-Ergebnis für einen einzelnen Thread liegt bei 2069 im Vergleich zu 3515 beim 5950x. Das einzige Upgrade, das ich in den letzten 8 Jahren vorgenommen habe, war der Einbau einer Samsung 860 EVO 1TB SSD und das hat einen großen Unterschied bei den Kompilierzeiten gemacht. Ich habe wieder den Task Manager DeLuxe verwendet und Screenshots des normalen Kompilierens und des parallelen Kompilierens auf der i7-3770 8-Thread-Maschine gemacht. Zuerst zeigen wir einen normalen Kompiliervorgang in C++Builder. Wie Sie im Screenshot sehen werden, werden nur etwa 30 % der CPU für die Kompilierung des C++-Codes verwendet.

Als Nächstes werfen wir einen Blick auf den i7-3770-Rechner, diesmal unter Verwendung von C++Builder beim parallelen Kompilieren desselben 128-Form-Projekts und etwa 254.000 Codezeilen. Wie Sie sehen werden, werden dieses Mal alle 4 Kerne und 8 Threads angesprochen und die volle Leistung der Maschine zum Kompilieren genutzt.

Sehen wir uns einige Zahlen aus dieser Maschine an, wenn wir das gleiche 128-Form-C++Builder-Projekt synchron und parallel kompilieren. Das erste Diagramm zeigt den normalen C++-Debug-Build (-O0) mit 1023 Sekunden im Vergleich zum parallelen C++-Debug-Build (-O0) mit 170 Sekunden (6-mal schneller!). Wenn wir die Zahlen auf Codezeilen pro Sekunde umrechnen, erhalten wir etwa 1494 Codezeilen pro Sekunde, wenn wir das parallele TwineCompile für -O0 verwenden. Der normale synchrone Debug -O0 Build kommt auf 248 Zeilen pro Sekunde zum Kompilieren.

Das zweite Diagramm hier zeigt den normalen C++ Release Build (-O2) mit 935 Sekunden im Vergleich zum parallelen C++ Release Build (-O2) mit 142 Sekunden (~6x schneller!). Wenn wir die Zahlen auf Codezeilen pro Sekunde umrechnen, erhalten wir etwa 1788 Codezeilen pro Sekunde, wenn wir das parallele TwineCompile für -O2 verwenden. Der normale debug-synchrone -O2-Build kommt auf 271 Zeilen pro Sekunde zum Kompilieren. Eine interessante Sache, die ich hier sehe, ist, dass auf dem AMD Ryzen 9 3950x Rechner die Debug-Builds schneller waren als die Release-Builds, während auf dem älteren Rechner hier die Debug-Builds langsam sind. Ich habe keine harten Zahlen, aber ich würde vermuten, dass dies darauf zurückzuführen ist, dass Debug-Builds größer sind als Release-Builds und daher die Geschwindigkeit der Solid-State-Festplatte ins Spiel kommt.

Wie Sie sehen können, bietet die parallele Kompilierung von C++Builder selbst auf älterer Hardware einen RIESIGEN Produktivitätsschub mit viel schnelleren Kompilierzeiten. Wenn Sie eine ältere Maschine haben und keine SSD wie die Samsung 860 EVO verwenden, ist das ein einfaches Upgrade, um eine viel bessere Leistung als mit einer normalen Festplatte zu erzielen. Oder wenn Sie eine ältere Maschine betreiben, die nicht mindestens Quad-Core ist, können Sie ältere Quad-Core-Maschinen für relativ niedrige Kosten abholen.

In jedem Fall werden Sie unabhängig von der verwendeten Hardware (solange sie mindestens 2 Kerne hat) eine deutliche Steigerung der Kompilierzeit für Ihre C++-Projekte feststellen, wenn Sie den neuesten C++Builder mit paralleler Kompilierung durch TwineCompile verwenden. In diesem Blog-Beitrag haben wir den neuesten AMD Ryzen 9 5950x mit seinen 16 Kernen und 32 Threads einem Benchmarking unterzogen und schlüssig dargelegt, dass dies einen großen Unterschied für die Steigerung Ihrer Produktivität durch Iterationsgeschwindigkeit ausmachen kann. Ein relativ großes Windows C++ Projekt mit 128 Formularen und über 254.000 Zeilen Code kann durch parallele Kompilierung mit 16 Kernen und 32 Threads in etwa 30-40 Sekunden kompiliert werden. Das ist unglaublich. Ein älterer Rechner mit normaler synchroner Kompilierung brauchte für das gleiche Projekt zwischen ~15 Minuten und ~17 Minuten!

Jetzt ist eine großartige Zeit, um als C++-Entwickler Windows- (und iOS-) Anwendungen in C++ zu erstellen. Wir haben gesehen, wie ein einzelner Kern auf älterer Hardware 60 Minuten für die Kompilierung eines C++-Projekts mit 1 Million Codezeilen benötigen konnte, was jetzt mit paralleler Kompilierung auf moderner Hardware nur noch ~2 Minuten dauert! Die parallele Kompilierung bringt dringend benötigte Produktivität in die C++-Entwicklung, ohne die Geschwindigkeit und Leistungsfähigkeit der C++-Laufzeit zu beeinträchtigen. C++Builder 10.4.1+ ist das Werkzeug, mit dem Sie dieses Ziel erreichen können.

Weitere Informationen über den C++Builder-Compiler finden Sie im Embarcadero DocWiki.

Sie haben noch nicht die neueste Version von C++Builder? Werfen Sie einen Blick darauf.