Aus diesen Gesprächen geht eines klar hervor: Trotz neuer Alternativen und lebhafter Debatten über die Zukunft von C++ ist und bleibt diese Sprache auch in den kommenden
Jahren ein Eckpfeiler in vielen Branchen. Wir sind stolz darauf, dass Visual Assist seit Jahrzehnten der MSVS/C++-Community dient und möchten Ihnen auch in Zukunft weiterhin zur Seite stehen.

Natürlich verändert sich die Landschaft. Die Gaming-Branche sieht sich nach dem massiven Wachstum und den Investitionen nach Covid mit erheblichen Herausforderungen
konfrontiert. Unternehmen suchen noch immer nach Wegen, um neue KI-Produkte zu integrieren, die für viele Programmierer schnell zu einer festen Größe werden. Und die Debatten über die Sicherheit von C++ werden immer hitziger.

Aus meiner Sicht ist es deshalb so wichtig, dass wir mit der Community, in Verbindung bleiben. Mit dem Fortschritt unserer Technologie werden alte Probleme obsolet und neue
tauchen auf. Ich bin stolz auf die Arbeit, die unser Team geleistet hat – und weiterhin leistet –, indem es erstens unseren Kunden zuhört und zweitens überlegt handelt, um Lösungen zu entwickeln, die diese Probleme lösen.

Ein Schwerpunkt, der für uns immer wichtig bleiben wird, ist die Nutzererfahrung. Entwickler sagen uns immer wieder, dass sie Tools erwarten, die ausgereift, nahtlos und intelligent sind … Tools, die nicht unnötig um Aufmerksamkeit buhlen oder nach Eingaben verlangen, sondern stattdessen subtil und zum richtigen Zeitpunkt die Produktivität steigern, ohne die
Konzentration zu stören.

Aus diesem Grund konzentriert sich unsere Roadmap für die kommenden Monate speziell darauf, die bestehenden Funktionen von VA zu optimieren, um noch mehr Produktivität zu
erzielen. Dies beginnt mit einer Modernisierung unserer Benutzeroberfläche (bleiben Sie auf dem Laufenden für unser nächstes Update), einer besseren Darstellung und schließlich etwas, worüber wir uns sehr freuen: dezente KI-Funktionen im Hintergrund. Mit anderen Worten: kein weiterer aufgesetzter KI-Chatbot, sondern „unter der Haube” integrierte Funktionen, die die Dinge, die Sie an VA lieben, noch besser machen – etwas, das über 70% von Ihnen in unserer kürzlich durchgeführten Community-Umfrage positiv bewertet haben.

Kann unser Parser in Verbindung mit KI beispielsweise schnell genaue Unit-Tests generieren? Können wir KI nutzen, um Probleme mit der Speichersicherheit zu identifizieren und dann die Refaktorisierung von VA einsetzen, um diese zu beheben? Wie kann KI unsere Umbenennungen, Inspektionen und Navigation verbessern? Das sind die Fragen, die wir uns stellen. Natürlich ist es noch früh und es gibt noch viel zu tun, aber wir sind begeistert von den Möglichkeiten. Und das können Sie auch sein!

Übrigens, haben Sie dazu eine Meinung? Schreiben Sie mir eine Nachricht – ich würde mich freuen, Ihre Gedanken zu hören.

Ben Schwenk,
Whole Tomato general manager

The post Wohin als nächstes? Ein kurzes Update über die Zukunft von Visual Assist von unserem GM first appeared on Tomato Soup.

Die Programmiersprache C++ hat sich noch nie vor Komplexität gescheut – aber selbst für eine Sprache, die für ihre Leistungsfähigkeit und Kontrolle bekannt ist, schien das #include-System wie ein Relikt aus einer anderen Zeit.
Module in C++ waren ein lang erwartetes Upgrade, das darauf abzielte, das Durcheinander der Includes zu beseitigen, die Build-Zeit zu verkürzen und die groß angelegte C++-Entwicklung etwas weniger mühsam zu gestalten.

Standardisiert in C++20 und erweitert in C++23, versprechen Module große Vorteile bei den Kompilierungszeiten. Aber auch im Jahr 2025 sind sie in den Toolchains der meisten Teams noch nicht so weit verbreitet. Einige Entwickler stürzen sich darauf und sehen echte Vorteile. Andere halten sich zurück und verweisen auf lückenhafte Compiler-Unterstützung, schwierige Build-Integration und die Scheu vor der Lernkurve, die mit jedem Paradigmenwechsel einhergeht.

In diesem Beitrag geht es nicht darum, Ihnen den neuesten Trend oder die neueste Konvention aufzudrängen – es ist ein praktischer Blick darauf, was C++-Module heute tatsächlich bieten, wo noch Einschränkungen bestehen und in welchen Fällen es sinnvoll ist, sie einzusetzen. Entscheiden Sie später selbst.

Eine kurze Einführung in C++-Module

Wenn Sie seit mehr als fünf Minuten mit C++ arbeiten, haben Sie sich bereits mit Header-Dateien beschäftigt. Sie sind leistungsstark, können aber auch zu Unübersichtlichkeit führen: Sie sind voller Makros, Schutzklauseln und redundanter Includes, die die Kompilierung verlangsamen und die Verfolgung von Abhängigkeiten zu einer mühsamen Aufgabe machen. Module wurden eingeführt, um einige dieser Probleme zu beheben.

Auf hoher Ebene ersetzen C++-Module das traditionelle präprozessorbasierte #include-Modell durch ein übersichtlicheres, strukturierteres System. Anstatt Code in Übersetzungseinheiten zu kopieren und einzufügen, werden Module einmal kompiliert und dann importiert, wodurch wiederholtes Parsen reduziert wird und Compiler mehr Kontext zur Optimierung von Builds erhalten.

So funktionieren C++-Module

Eine Modulschnittstelle ist eine eigenständige Datei – in der Regel mit der Erweiterung .ixx –, die deklariert, was anderen Teilen Ihres Programms zur Verfügung steht. Sie können dieses Modul dann mit dem Schlüsselwort „import“ in andere Dateien importieren (genau wie in Python), wodurch Header-Dateien vollständig überflüssig werden.
Im Hintergrund erstellt und speichert der Compiler die Modulschnittstelle im Cache, sodass zukünftige Builds die erneute Verarbeitung ihres Inhalts überspringen können – das spart Zeit und sorgt für Ordnung.

Die Timeline im Überblick

• C++20, offiziell veröffentlicht im Dezember 2020, führte die offizielle Modulunterstützung ein, obwohl frühe Compiler-Implementierungen nur teilweise verfügbar waren.
• C++23, veröffentlicht im Februar 2023, erweiterte die Spezifikation und bot eine bessere Unterstützung für Funktionen wie Modulpartitionen und Header-Unit-Kompatibilität.
• Toolchains wie Clang, MSVC und GCC entwickeln ihre Unterstützung weiter – aber bis 2025 ist die vollständige Interoperabilität noch in Arbeit.

Timeline für die Einführung von C++-Modulen

Argumente für die Einführung von C++-Modulen

Wenn Sie jemals erlebt haben, wie ein umfangreiches C++-Projekt nur langsam kompiliert wurde – oder Stunden damit verbracht haben, ein Gewirr aus Includes und Makros zu entwirren –, dann klingt die Idee von Modulen wahrscheinlich ziemlich verlockend. Hier kommen sie zum Tragen.

Verbesserte Build-Zeiten und Skalierbarkeit

Herkömmliches C++ kompiliert jede Übersetzungseinheit unabhängig voneinander und parst dabei wiederholt dieselben Header in Ihrer Codebasis. Das ist eine Menge doppelter Aufwand.
Mit Modulen können Compiler einmalig analysieren und die Ergebnisse zwischenspeichern (genau wie Visual Assist!). Modulschnittstellen werden vorkompiliert und wiederverwendet, wodurch redundante Analysen vermieden werden. Bei großen Projekten kann dies zu einer erheblichen Verkürzung der vollständigen Build- und inkrementellen Kompilierungszeiten führen, insbesondere in Kombination mit modernen Build-Systemen, die Module verstehen. Das ist nicht nur Theorie – Early Adopters haben bei der Portierung auf Module echte Vorteile festgestellt, insbesondere bei Bibliotheken mit Tausenden von Dateien und tiefen Abhängigkeitsketten.

Übersichtlichere Abhängigkeiten

Module bringen die dringend benötigte Struktur in C++. Sie reduzieren die Abhängigkeit von Präprozessor-Direktiven und eliminieren Include-Guards, Vorwärtsdeklarationen und subtile Header-Only-Fehler. Tatsächlich regen sie dazu an, klarer darüber nachzudenken, was offengelegt werden sollte und was privat bleiben sollte.
Da Sie nur das explizit exportieren, was benötigt wird, helfen Module dabei, die Kapselung durchzusetzen, wodurch APIs einfacher zu warten und weniger anfällig für unerwartete Ausfälle sind.

Verbesserte IDE- und Tooling-Unterstützung

Zwar sind noch nicht alle Editoren auf dem neuesten Stand, aber moderne IDEs und Compiler holen auf. Visual Studio, Clang-basierte Tools und sogar einige leichtgewichtige Editoren bieten zunehmend sinnvolle modulbewusste Funktionen – wie schnelleres IntelliSense, intelligentere Indizierung und weniger falsch-positive Diagnosen.
Sobald Ihre Toolchain Module gut unterstützt, werden Sie eine reibungslosere Entwicklererfahrung feststellen, insbesondere bei der Arbeit mit großen Codebasen.

Modernisierung und Zukunftssicherheit

Bei der Einführung von Modulen geht es nicht nur darum, die Build-Zeit zu verkürzen, sondern auch darum, sich an die zukünftige Ausrichtung der Sprache anzupassen. Da immer mehr moderne C++-Funktionen auf Module setzen (wie std::mdspan in C++23), sind Entwickler, die frühzeitig umsteigen, besser positioniert, um die neuen Funktionen zu nutzen.
Module sind auch ein Tor zu saubereren Build-Systemen, einer granulareren Abhängigkeitsverwaltung und noch sichererem Code, da sie die Sichtbarkeit von Symbolen einschränken und die versehentliche Offenlegung von APIs reduzieren können.

Branchentrends und frühzeitige Einführung

Obwohl Module noch keine kritische Masse erreicht haben, gewinnen sie zunehmend an Bedeutung. Bibliotheksentwickler und leistungsorientierte Teams sind dabei führend, insbesondere diejenigen, die SDKs, Spiel-Engines oder Systemsoftware entwickeln, bei denen die Erstellungszeit einen Engpass darstellt.
Wir haben auch gesehen, dass große Namen wie Microsoft mit der Einführung von Modulen in Teilen ihrer Standardbibliotheksimplementierung experimentieren, und einige Open-Source-Projekte haben bereits kleine Teile ihres Codes migriert, um die Lage zu sondieren.

Warum Sie die Einführung von C++-Modulen (vorerst) verschieben sollten

Trotz aller vielversprechenden Aussichten, die C++-Module bieten, ist die Einführung in der Praxis noch immer, nun ja, zurückhaltend. Entwickler stehen noch nicht gerade Schlange, um ihre gesamte Codebasis zu überarbeiten – und dafür gibt es gute Gründe.

Wenig Anreize für die Einführung

Selbst bei Greenfield-Projekten ist die Einführung von Modulen mit einer Lernkurve verbunden. Aber in Legacy-Codebasen? Die Migration kann entmutigend sein. Sie müssen Ihre Header-Struktur überdenken, enge Kopplungen entwirren und neue Abhängigkeiten des Build-Systems verwalten – ganz zu schweigen von der Umschulung Ihres Teams. Und dann ist da noch die Frage der Kompatibilität: Module sind nicht mit allem kompatibel, insbesondere wenn Sie stark auf Makros, bedingte Kompilierung oder plattformspezifische Header angewiesen sind.

Mit anderen Worten: Dies ist keine Refaktorisierung, die man an einem Wochenende erledigen kann – und für viele Teams überwiegen die Kosten noch nicht den Nutzen, sodass es sinnvoller wäre, Module stattdessen für neue Projekte zu verwenden.

Inkonsistenzen und Fragmentierung bei den Tools

Fragen Sie jeden Entwickler, der versucht hat, modular zu arbeiten: Es ist wichtig, welchen Compiler Sie verwenden. Zwar gibt es Unterstützung für Module in Clang, MSVC und GCC, diese ist jedoch nicht einheitlich – und versionsspezifische Eigenheiten können zu frustrierenden Inkonsistenzen führen.

Auch die Unterstützung durch Build-Systeme ist noch im Umbruch. CMake hat zwar Modulunterstützung hinzugefügt, diese wirkt jedoch noch experimentell, insbesondere bei komplexen Projektkonfigurationen oder plattformübergreifenden Builds. Andere Systeme wie Bazel oder benutzerdefinierte Build-Pipelines erfordern mehr Glue-Code, als die meisten Teams bereit sind zu pflegen.
Kurz gesagt: Die Tools sind noch nicht ganz ausgereift – insbesondere, wenn Sie nicht die allerneuesten Compiler-Versionen verwenden.

Mangelnde Ausgereiftheit des Ökosystems

Selbst wenn Ihre Toolchain auf dem neuesten Stand ist, ist das Ökosystem insgesamt möglicherweise noch nicht so weit. Die meisten Bibliotheken von Drittanbietern werden nicht mit Modulschnittstelleneinheiten ausgeliefert, was bedeutet, dass Sie entweder Ihre eigenen Wrapper schreiben müssen oder ohnehin auf #include zurückgreifen müssen. Das schränkt die Vorteile der Modularisierung in gemischten Umgebungen ein – und ehrlich gesagt sind das die meisten Umgebungen. Bis beliebte Bibliotheken (Boost, Qt usw.) zuverlässige Modulunterstützung bieten, können die meisten Teams nicht voll einsteigen, ohne Abstriche machen zu müssen.

Begrenzte Fallstudien aus der Praxis

Es mangelt noch immer an detaillierten Erfolgsgeschichten, wenn es um die großflächige Einführung geht. Einige Early Adopters haben Benchmarks oder Migrationshinweise geteilt, aber die meisten Beispiele aus der Praxis sind kleine Experimente und keine vollständigen Produktionsumstellungen.

Ohne umfassendere Fallstudien, aus denen sie lernen können, verfolgen viele Teams einen abwartenden Ansatz – sie beobachten, wie andere vorankommen, bevor sie selbst den Sprung wagen.

Bedenken hinsichtlich der Stabilität

Das Ökosystem der C++-Module befindet sich noch in der Entwicklung. Das Verhalten des Compilers kann sich zwischen den einzelnen Minor-Versionen ändern, bei Tooling-Updates treten modulbezogene Fehler auf und die Unterstützung des Build-Systems unterliegt ständigen Veränderungen.

Diese Unbeständigkeit erschwert den Einsatz von Modulen in der Produktion, insbesondere in Unternehmensumgebungen, in denen Stabilität von entscheidender Bedeutung ist.

Situationen, in denen Module sinnvoll sein können (oder auch nicht)

C++-Module sind keine Alles-oder-Nichts-Angelegenheit – und glücklicherweise müssen Sie nicht jedes #include herausnehmen, um sie zu verwenden. Je nach Projekt, Teamgröße und Tooling-Setup können Module entweder eine sinnvolle Optimierung oder eine unnötige Komplexität darstellen. Schauen wir uns das genauer an.

Wann Module sinnvoll sind

• Sie beginnen mit einer neuen Codebasis (insbesondere in großem Umfang)
  Greenfield-Projekte sind der perfekte Spielplatz für modernes C++. Wenn Sie ein großes System von Grund auf neu aufbauen, können Sie mit Modulen einen sauberen Start hinlegen – ohne Altlasten aus früheren Headern. Wenn Sie Ihren Code von Anfang an wie modulare Schnittstellen organisieren, können Wartung, Skalierbarkeit und Onboarding erheblich vereinfacht werden.
• Sie verwenden eine moderne Toolchain
  Wenn Ihr Team bereits die neuesten Versionen von GCC, Clang oder MSVC verwendet und Sie keine Probleme damit haben, Ihre Toolchain regelmäßig zu aktualisieren, können Sie besser von den verbesserten Kompilierungszeiten und der Struktur profitieren, die Module bieten.
• Sie erstellen wiederverwendbare Bibliotheken
  Module eignen sich hervorragend für das API-Design. Wenn Sie gemeinsam genutzte Komponenten, SDKs oder interne Pakete entwickeln, kann die Definition von Modulschnittstellen dazu beitragen, die Kapselung durchzusetzen und sauberere, besser vorhersehbare Abhängigkeiten zu schaffen.
• Sie haben ein starkes DevOps-/Infrastrukturteam
  Es ist nicht immer einfach, Module mit CMake oder Ihrer CI-Pipeline kompatibel zu machen. Teams mit dediziertem Infrastruktur-Support können die Lernkurve effektiver bewältigen und sind besser gerüstet, um mit Compiler-Eigenheiten oder Anpassungen des Build-Systems umzugehen.

In welchen Fällen Sie vielleicht noch warten sollten

• Sie arbeiten mit einer alten Codebasis
  Alter Code mag keine Veränderungen. Die Migration von Headern, das Entwirren zirkulärer Abhängigkeiten und die Nachrüstung von Modulzuordnungen können viel Zeit in Anspruch nehmen, ohne dass sich dies in greifbaren Ergebnissen niederschlägt – insbesondere, wenn Sie gleichzeitig Termine einhalten müssen.
• Ihr Build-System ist noch nicht bereit
  Wenn Ihr Projekt auf komplexen oder stark angepassten Builds basiert, kann die Einführung von Modulen eher zu Instabilität als zu mehr Geschwindigkeit führen. Selbst beliebte Tools wie CMake sind noch dabei, ihre Modulunterstützung zu optimieren, und noch laufen nicht alle Workflows reibungslos.
• Sie sind stark von Bibliotheken von Drittanbietern abhängig
  Bis weit verbreitete Bibliotheken Modulschnittstelleneinheiten liefern, werden Ihre Module in einer ungünstigen Koexistenz mit #include existieren. Diese Art von hybrider Umgebung kann frustrierend sein und zu verwirrenden Fehlern oder doppelten Arbeitsaufwänden führen.
• Ihr Team ist klein oder befindet sich in einer frühen Phase
  Wenn Sie schnell vorankommen und häufig liefern, lohnt es sich derzeit wahrscheinlich nicht, Zeit in die Umstrukturierung des Codes für Module zu investieren. In der Anfangsphase gewinnt in der Regel die Einfachheit – und Header funktionieren nach wie vor einwandfrei.
• Perspektiven der Community und Signale aus der Branche
  Während C++-Module weiter ausgereift werden, kommt ein Großteil ihrer Dynamik – und ihrer Zurückhaltung – aus der breiteren Community: Compiler-Anbieter, Normungsgremien, Open-Source-Maintainer und Entwickler, die erste Erfahrungen gesammelt und darüber berichtet haben. Schauen wir uns an, was das breitere C++-Ökosystem im Jahr 2025 über Module sagt.

Zusammenfassung: Wichtige Überlegungen vor der Entscheidung

Zum Abschluss fassen wir noch einmal die wichtigsten Punkte zusammen und skizzieren, was Sie beachten sollten, bevor Sie sich mit C++-Modulen beschäftigen:

Vorteile der Einführung von C++-Modulen

• Verbesserte Build-Zeiten: Wenn Sie mit großen Codebasen arbeiten, können die Leistungssteigerungen durch reduziertes redundantes Parsing erheblich sein.
• Übersichtlichere Abhängigkeiten: Module beseitigen viele der Probleme, die mit der Einbindung von Header-Dateien verbunden sind, wie z. B. verschachtelte Makros und zirkuläre Abhängigkeiten.
• Tooling-Unterstützung: Obwohl sich die meisten gängigen Compiler (MSVC, Clang, GCC) noch in der Entwicklung befinden, sind sie auf dem richtigen Weg, und die IDE-Unterstützung nimmt zu.

Nachteile der Einführung von C++-Modulen

• Fragmentierte Tooling: Die Unterstützung durch Compiler und Build-Systeme ist noch uneinheitlich. Wenn Sie eine bestimmte Toolchain verwenden, überprüfen Sie vor dem Einstieg die vollständige Kompatibilität.
• Migrationskosten: Die Umstellung eines bestehenden Projekts auf Module erfordert erhebliche Änderungen an Build-Systemen, Abhängigkeiten und möglicherweise auch am Code selbst.
• Fehlende Unterstützung durch Dritte: Wenn Ihr Projekt stark auf externe Bibliotheken angewiesen ist, überprüfen Sie, ob diese Module unterstützen, oder stellen Sie sich auf einige benutzerdefinierte Workarounds ein.
• Begrenzte Fallstudien: Die Akzeptanz von Modulen, insbesondere in großen realen Projekten, ist noch gering, was bedeutet, dass die Lernkurve steiler sein könnte als erwartet.

Wann sollten Sie C++-Module einsetzen?

• Neue Codebasen oder Projekte: Wenn Sie neu anfangen oder einem Projekt neue Funktionen hinzufügen, können Sie durch den frühzeitigen Einsatz von Modulen langfristig Zeit sparen.
• Open-Source-Bibliotheken: Wenn Sie eine weit verbreitete Bibliothek pflegen, könnte die Umstellung auf Module zu Leistungsverbesserungen führen, von denen die Community profitiert.
• Ältere Codebasen: Wenn Sie mit einem großen, etablierten Projekt arbeiten, ist der Aufwand für die Migration zu Modulen möglicherweise nicht gerechtfertigt, es sei denn, Sie verfügen über die entsprechenden Ressourcen.

Letztendlich hängt die Einführung von C++-Modulen im Jahr 2025 von der Größe, Komplexität und den langfristigen Zielen Ihres Projekts ab. Es kann sich lohnen, Module zunächst in kleineren, isolierten Teilen Ihres Projekts zu testen, um ihr Potenzial zu beurteilen, bevor Sie sich zu einer vollständigen Migration entschließen.

Erweiterte Unterstützung für Module in C++

Wenn Sie aufgrund der relativ begrenzten Auswahl an Tools für C++ noch unentschlossen sind, sollten Sie das Visual Assist-Plugin für Visual Studio in Betracht ziehen. In einem kürzlich veröffentlichten Update wurde die Erkennung beim Deklarieren neuer Module in Ihrem Projekt hinzugefügt. Diese zusätzliche Unterstützung erleichtert die Arbeit mit C++-Modulen, da die Navigations- und Auto-Vorschlagsfunktionen wie erwartet funktionieren.

Kostenfrei das Visual Assist Plugin laden und testen.

The post C++-Module: Was sie bieten und Gründe, warum man kritisch bleiben sollte first appeared on Tomato Soup.

Aber was wäre, wenn Sie das könnten? Das würde eine breite Palette von Möglichkeiten eröffnen. So könnte man z. B. aus mehreren Quellen lernen, drei mathematische Gleichungen gleichzeitig im Kopf lösen oder buchstäblich Multitasking betreiben, indem man mit jeder Hand etwas anderes macht.

Das ist die Idee, die hinter der Nutzung von Grafikprozessoren (GPUs) steht, um die Entwicklungszeit für einige spezielle Technologien zu verkürzen. Mit ihrer Fähigkeit, wesentlich mehr Threads (im Vergleich zu CPUs) zu verarbeiten, können sie Aufgaben ausführen, die eine starke Parallelverarbeitung erfordern, wie z. B. das Rendern von Grafiken, das Trainieren von Machine-Learning-Modellen und die Durchführung komplexer Simulationen.

Eine der Möglichkeiten, Ihre GPUs so zu programmieren, dass sie Daten ausspucken, die nicht nur aus Grafiken bestehen, ist ein Framework namens CUDA. Und genau damit befassen wir uns heute in diesem Blog.

Warum wird CUDA heute verwendet?

CUDA, die Abkürzung für Compute Unified Device Architecture, beschleunigt Rechenaufgaben durch die Nutzung von Grafikkarten (Graphics Processing Units, GPUs). Es handelt sich um ein Framework, das 2006 von NVIDIA entwickelt wurde. CUDA ermöglicht es Entwicklern, Programme zu schreiben, die große Rechenaufgaben in kleinere Aufgaben aufteilen und dabei parallele Berechnungen durchführen.

Dabei werden die vielen Kerne eines Grafikprozessors genutzt, um mehrere Rechenoperationen gleichzeitig durchzuführen – im Gegensatz zu einer CPU, die einige wenige leistungsstarke Kerne verwendet, die für die sequentielle Verarbeitung optimiert sind. Diese Parallelverarbeitungsfunktion beschleunigt Aufgaben mit großen Datensätzen oder komplexen Berechnungen, wie sie beim Grafik-Rendering, bei wissenschaftlichen Simulationen und beim maschinellen Lernen anfallen, erheblich.

CUDA von Nvidia gibt es seit mehr als zwei Jahrzehnten und aufgrund seiner Popularität und der hohen Kompatibilität mit den physischen Grafikkarten des Mutterunternehmens hat es sich zu einem der führenden Systeme in der Branche entwickelt. Und obwohl CUDA die Vorherrschaft in diesem Bereich verliert, bleibt es die erste Wahl für die Beschleunigung des Trainings von Modellen für computerbasiertes Lernen.

CUDA in der Industrie

Wir haben über die Vorteile der Verwendung von Grafikprozessoren gesprochen und darüber, wie man sie mit CUDA für bestimmte Aufgaben programmieren kann. Der beliebteste Anwendungsfall ist derzeit der Aufstieg des maschinellen Lernens und der künstlichen Intelligenz, aber wir haben ein paar andere Branchen aufgelistet, die Sie vielleicht noch nicht kennen und die ebenfalls die Vorteile der GPU-Rechenleistung nutzen können.

Anforderungen beim Erlernen der CUDA-Entwicklung

Die Nutzung von Grafikprozessoren und deren Programmierung mit CUDA ist zwar auf dem Vormarsch, aber es gibt immer noch eine erhebliche Hürde, um ein erfahrener CUDA-Programmierer zu werden. Die größte Stärke von CUDA ist auch einer der Faktoren, die das Erlernen erschweren. CUDA ist für die parallele Datenverarbeitung konzipiert, die sich grundlegend von der traditionellen seriellen Programmierung unterscheidet. Programmierer müssen Konzepte wie Threads, Blöcke und Grids verstehen und wissen, wie sie auf GPU-Hardware abgebildet werden.

Darüber hinaus ist C/C++, eine Sprache, die in der Regel für fortgeschrittene Entwickler geeignet ist, die am besten zu erlernende Sprache, wenn Sie die CUDA-Programmierung optimieren wollen (Sie können sich auch für Python mit PyTorch oder Jax entscheiden).

Schließlich erfordert CUDA ein tieferes Wissen über die physische Hardware (d. h. welche NVIDIA-GPU/s Sie verwenden). Sowohl bei der Hardware als auch bei den Software-Toolkits sind zusätzliche Einstellungen erforderlich, um Zugang zur grundlegenden Entwicklung und zu Tests zu erhalten. Um eine hohe Leistung zu erzielen, ist es außerdem erforderlich, die GPU-Architektur zu studieren, den Code sorgfältig zu optimieren und den Speicher genau zu verwalten.

Einrichten Ihres ersten CUDA Programmierprojekts

Mit Ihrem allerersten CUDA Projekt zu beginnen, mag einschüchternd erscheinen, aber mit der richtigen Anleitung können Sie Visual Studio in nur einer Stunde für CUDA Programmierprojekte konfigurieren. Befolgen Sie die folgenden Schritte, um loszulegen:

Installation von Visual Studio

Visual Studio ist eine gute erste Wahl für eine IDE, wenn Sie bereits mit C++ vertraut sind. Es ist kompatibel mit der Integration des NVIDIA CUDA Toolkits, mit dem Sie CUDA-Anwendungen innerhalb derselben Plattform kompilieren, debuggen und optimieren können.

• Download Visual Studio
  
  Laden Sie zunächst, Visual Studio von Microsoft herunter. Wählen Sie die von Ihnen bevorzugte Edition. Für unsere Installation haben wir eine Community-Version von Visual Studio 2022 heruntergeladen, da dies die neueste unterstützte Version für unser Windows 11-System ist.
• Führen Sie das Installationsprogramm aus, um die Installation abzuschließen.
  
  Folgen Sie den folgenden Aufforderungen, bis Sie zum Visual Studio-Installationsprogramm gelangen. Es wird Sie nach einigen Dingen fragen, z. B. nach dem Installationsverzeichnis, und wird einige Abhängigkeiten überprüfen. Danach sollten Sie Visual Studio aus diesem Fenster oder über eine Verknüpfung starten können.

Installieren des CUDA Toolkits

Nach der Installation von Visual Studio benötigen Sie den Download des CUDA Toolkits für Visual Studio. Es bietet die Tools, Bibliotheken und den Compiler (nvcc), die für die Entwicklung und Ausführung von CUDA-Anwendungen in Visual Studio erforderlich sind. Es ermöglicht die Integration von GPU-beschleunigtem Computing, was die Verwendung von NVIDIA-GPUs für leistungsstarke Aufgaben ermöglicht.

• Überprüfen Sie, ob Sie einen CUDA-kompatiblen Grafikprozessor haben
  Um einen reibungslosen Betrieb zu gewährleisten, sollten Sie zunächst überprüfen, ob Ihr aktueller Grafikprozessor ein unterstütztes Gerät ist. Navigieren Sie dazu zum Abschnitt Grafikkarten im Windows-Gerätemanager. Weitere Informationen finden Sie in der Installationsanleitung von NVIDIA.
• CUDA Toolkit von NVIDIA herunterladen
  
  Besuchen Sie die Website von NVIDIA um das Toolkit herunterzuladen und mehr darüber zu erfahren. Vergewissern Sie sich vor dem Herunterladen, dass Sie das richtige Betriebssystem, die richtige Version usw. ausgewählt haben. Die heruntergeladene Datei ist in unserem Fall 3,2 GB groß. Stellen Sie jedoch sicher, dass Sie über mindestens 10 GB freien Speicherplatz verfügen, da Sie die Installationsdateien vorübergehend extrahieren müssen, bevor Sie das Installationsprogramm ausführen.

• Starten Sie das Installationsprogramm
  
  Führen Sie nach dem Herunterladen das Installationsprogramm aus. Es überprüft Ihr Gerät auf fehlende Abhängigkeiten oder bereits vorhandene Installationen und passt Ihre Installationsdateien entsprechend an. Danach haben Sie das CUDA Toolkit auf Ihrem System installiert. Zusätzlich wird NSIGHT installiert, das spezielle Debugging- und Profiling-Funktionen für CUDA Anwendungen bietet.Sollten Sie bei der Installation des Toolkits auf Probleme stoßen, lesen Sie bitte die Installations- und Fehlerbehebungsanleitung von NVIDIA.Tipp: Wenn Sie Visual Studio Code bevorzugen, sollten Sie stattdessen Nsight über diesen Link installieren. Dabei handelt es sich um eine Anwendungsentwicklungsumgebung für „heterogene Plattformen, die die CUDA-Entwicklung für GPUs“ in Microsofts Visual Studio Code integriert.

Erste Schritte mit Ihrem ersten CUDA Projekt in Visual Studio

Nachdem Sie sowohl Visual Studio als auch das CUDA Toolkit installiert haben, können Sie nun Ihr erstes Projekt in Visual Studio initialisieren.

• Erstellen Sie ein neues Projekt.
  Beginnen Sie mit dem Öffnen von Visual Studio und erstellen Sie ein neues Projekt oder klonen Sie ein bestehendes Repository, um Ihre erste Projektdatei zu starten.
  
• Initialisieren Sie Ihr Projekt.
  
  An diesem Punkt haben Sie zwei Möglichkeiten: Entweder Sie starten eine komplett leere Konsole/ein leeres Projekt oder Sie wählen das CUDA 12.8-Projekt. Der Hauptunterschied besteht darin, dass die CUDA Runtime bereits mit den üblichen Arbeitslasten, Beispielcode und Anwendungsfällen ausgestattet ist. Wenn Sie jedoch von Grund auf neu beginnen, können Sie Ihr Projekt nur mit dem konfigurieren, was Sie benötigen, und sich mit dem Arbeitsbereich vertraut machen. Für dieses Projekt werden wir mit einem völlig leeren Projekt beginnen.
• Einstellen der Build-Konfiguration
  
  Wählen Sie oben im Visual Studio-Fenster Release und x64 (wenn Sie ein 64-Bit-System verwenden). Dadurch wird VS mitgeteilt, dass wir versuchen, eine Version einer Anwendung zu erstellen, die bereitgestellt werden kann, im Gegensatz zum Debuggen.
• Anpassen von Build-Abhängigkeiten
  
  • 
  • 
  • 
  
  Sie müssen sicherstellen, dass Visual Studio weiß, dass Sie versuchen, CUDA-Dateien zu erstellen und auszuführen. Um dies zu konfigurieren, klicken Sie mit der rechten Maustaste auf Ihren Projektnamen („CUDA Sample“) und klicken Sie auf Build Dependencies ? Build-Anpassungen. Es öffnet sich ein neues Fenster, in dem die verfügbaren Build-Anpassungsdateien aufgelistet sind. Stellen Sie sicher, dass Sie CUDA 12.8 ankreuzen und klicken Sie auf ok.
• Hinzufügen einer CUDA C++- oder Header-Datei
  
  Um neue Quelldateien hinzuzufügen, fügen Sie einfach neue Elemente hinzu, wie Sie eine normale .cpp- oder .header-Datei hinzufügen würden. Klicken Sie mit der rechten Maustaste auf einen Ordner und klicken Sie auf Hinzufügen | Neues Element, um auf Ihre Dateioptionen zuzugreifen.
• Überprüfen, ob die Datei- und Projekteinstellungen korrekt sind
  An diesem Punkt sollten Sie versuchen, eine Lösung zu erstellen, um sicherzustellen, dass alles reibungslos funktioniert. Wenn alles klappt, herzlichen Glückwunsch! Sie können nun mit der Arbeit an Ihrer ersten CUDA Datei in VS beginnen. NVIDIA stellt auch einige Beispielprojekte Beispielprojekte zur Verfügung, mit denen Sie das Setup testen, debuggen und sich mit bestehenden Projekten vertraut machen können, bevor Sie ein komplett neues Projekt erstellen.

Optimieren Sie Ihr Setup

VS und NVIDIA haben große Fortschritte bei der Erleichterung der CUDA-Entwicklung und der Einrichtung gemacht. Da es sich bei CUDA jedoch um eine proprietäre Sprache handelt, kann es immer noch vorkommen, dass Syntaxhervorhebungen oder verwirrende Eingabeaufforderungen von VS’s IntelliSense fehlen.

Um dies zu beheben, empfiehlt es sich, zusätzliche Plugins vom Visual Studio-Marktplatz zu installieren, die bei der korrekten Hervorhebung von Symbolen helfen können. Sie können z. B. das  Visual Assist-Plugin  herunterladen und installieren, das Unterstützung für CUDA-spezifischen Code bietet, der von Visual Studios IntelliSense möglicherweise noch nicht erkannt wird. Es bietet außerdem den zusätzlichen Vorteil, dass es neben der zusätzlichen Unterstützung für .cu- und .cuh-Dateien auch die Kernfunktionen für Navigation, Refactoring, Codehilfe und mehr bietet.

Fazit

CUDA ist zwar ein leistungsfähiges Tool, das auch in naher Zukunft von Bedeutung sein wird, aber die Landschaft des parallelen Rechnens ist dynamisch, und seine Dominanz wird von technologischen Fortschritten und veränderten Anforderungen der Industrie abhängen. Angesichts des rasanten Wachstums von KI und maschinellem Lernen wird CUDA jedoch aufgrund seiner Optimierung für Deep-Learning-Aufgaben wahrscheinlich relevant bleiben, zumal NVIDIA in diesem Bereich weiterhin Innovationen vorantreibt.

Zusammenfassend lässt sich sagen: Wenn Sie Ihre Fähigkeiten in der Softwareentwicklung in einem wachsenden und aufstrebenden Bereich ausbauen möchten, dann könnte CUDA das Richtige für Sie sein.

The post Einführung in die CUDA Entwicklung + Einrichten in Visual Studio first appeared on Tomato Soup.