Autor: Luca Jung

Veröffentlicht am

5 Anwendungen von LLMs wie ChatGPT in der Softwareentwicklung

Large Language Models (LLMs) sind vielseitig einsetzbar. Auch in der Softwareentwicklung sorgen diese für eine deutliche Effizienzsteigerung. Hier findest du fünf Anwendungsfälle für LLMs.

1. Schreiben von kleinen Softwareblöcken

Oft muss ein Softwareentwickler kurze Codeblöcke schreiben, die zwar nicht besonders komplex sind, aber notwendig, um die Funktionalität der Software zu garantieren. Das manuelle Schreiben dieser Codeblöcke kann jedoch viel Zeit in Anspruch nehmen. Zum Glück gibt es Abhilfe in Form von LLMs wie ChatGPT. Diese Modelle können mithilfe ihrer Fähigkeit, schnell und effizient Code erstellen, der oft sogar von guter Qualität ist und sinnvoll benannte Variablen sowie gründliche Kommentare enthält.

Trotzdem ist es je nach Prompt manchmal immer noch notwendig, den generierten Code manuell in den bestehenden Code zu integrieren. Dies liegt daran, dass Large Language Models nicht immer in der Lage sind, den Kontext und die spezifischen Anforderungen eines Projekts vollständig zu verstehen.

2. Dokumentieren von Code

Jeder kennt es wahrscheinlich: Man hat keine Zeit oder Lust, den gerade geschriebenen Code zu dokumentieren. Das kann zu Problemen führen, insbesondere wenn andere Entwickler später versuchen, den Code zu verstehen und zu verwenden. Glücklicherweise kann ChatGPT auch in diesem Fall schnell Abhilfe schaffen. Das Modell kann Lücken in der Code-Dokumentation erkennen und fehlende Dokumentationen hinzufügen.

Auch wenn es verlockend sein kann, auf die Dokumentation des Codes zu verzichten, sollte einem stets bewusst sein, dass gut dokumentierter Code langfristig Zeit und Ressourcen sparen kann. Eine klare und vollständige Dokumentation erleichtert es anderen Entwicklern, den Code zu verstehen und zu verwenden, was wiederum dazu beitragen kann, Bugs schneller zu finden, zu beheben und den Entwicklungsprozess insgesamt zu beschleunigen.

3. Verstehen von undokumentiertem Legacy-Code

Das Verstehen von Legacy-Code, insbesondere von undokumentiertem, kann sich als äußerst zeitaufwändig erweisen. Glücklicherweise können Large Language Models (LLMs) dabei helfen, indem sie den Code oft zuverlässig erklären können. Darüber hinaus können sie auch Fehler oder potenzielle Code-Optimierungen erkennen und vorschlagen, um die Leistung der Software zu verbessern.

Selbst in Fällen, in denen der Code nicht ausreichend dokumentiert ist oder der ursprüngliche Entwickler nicht mehr verfügbar ist, können LLMs dabei helfen, schnell Klarheit zu schaffen und Probleme zu lösen.

4. Code-Reviews

Durch den Einsatz von LLMs wie ChatGPT können potenzielle Fehler und Sicherheitslücken bereits vor dem Code-Review identifiziert werden. Das LLM kann den Code analysieren und auf mögliche Schwachstellen hinweisen. In vielen Fällen kann es sogar einen schnellen Fix für das Problem vorschlagen, was Entwicklern viel Zeit sparen kann. Durch diese Art der Vorprüfung kann der Code-Review-Prozess beschleunigt werden und es bleibt möglicherweise mehr Zeit für eine gründlichere Überprüfung und Optimierung des Codes.

5. Übersetzen von Code

Es kann vorkommen, dass ein Softwareentwickler mit Problemen konfrontiert wird, für die er in einer Programmiersprache schreiben muss, die er nicht gut beherrscht. In solchen Fällen kann die benötigte Funktionalität in einer anderen beliebigen Programmiersprache geschrieben und von ChatGPT in die Zielsprache übersetzt werden. Allerdings ist eine anschließende manuelle Integration des Codes in der Zielsprache notwendig. Der initiale Aufwand reduziert sich jedoch enorm, wenn man keine Erfahrung in der Zielsprache hat.
Durch z.B. ChatGPT können Entwickler also viele Programmiersprachen nutzen, ohne dass sie sich um die Details der Syntax und Grammatik sorgen müssen. Das gibt ihnen die Freiheit, sich auf die Funktion der Software zu konzentrieren, ohne sich zu sehr um die technischen Aspekte zu kümmern. Das spart Zeit und Kosten für Fortbildungen.

Zusammenfassung

LLMs wie ChatGPT können das Entwickeln von Software erheblich beschleunigen, indem sie den Entwicklern viel Arbeit abnehmen und dadurch mehr Zeit und Energie für andere wichtige Entwickleraufgaben freisetzen. Obwohl die Ausgaben von LLMs nicht immer perfekt sind, können sie dennoch dazu beitragen, das Verständnis von Code zu beschleunigen, Fehler zu finden und einfache Aufgaben zu übernehmen.

Wichtig ist jedoch, dass sich Entwickler sich nicht vollständig auf LLMs verlassen. Obwohl sie sehr nützlich sein können, ist es immer noch notwendig, die Ausgaben zu überprüfen und sicherzustellen, dass sie korrekt sind. Ein Entwickler sollte sich nicht blind auf die Ergebnisse von ChatGPT oder anderen LLMs verlassen, sondern immer eine kritische Prüfung durchführen, bevor er den Code in die Produktion schickt.

Veröffentlicht am

Predication

In diesem Artikel wird untersucht, warum gewöhnliche if-Anweisungen die Ausführungsdauer erheblich verlangsamen können und wie man dem entgegenwirken kann. Um die Ursprünge dieses Phänomens besser zu verstehen, ist ein grundlegendes Verständnis von Branch Prediction erforderlich.

Um die Ausführungsgeschwindigkeit von Code zu verbessern, verwendet die CPU das sogenannte Pipelining, um die Pipeline maximal auszulasten. Dieser Effekt kann jedoch durch sogenannte Pipeline-Flushes beeinträchtigt werden. Um dieses Thema genauer zu verstehen, hier ein kurzes Beispiel: Das folgende Programm zählt die Anzahl der Zahlen, die größer als 50 sind. Da die Zahlen mithilfe einer Zufallsfunktion und Modulo 101 generiert werden, liegen sie immer im Bereich von 0 und 100. Aus diesem Grund sollte der Counter in der if-Bedingung in etwa der Hälfte der Schleifendurchläufe erhöht werden.

C
#include <stdio.h>
#include <stdlib.h>
#include <time.h>

int main()
{
  int counter = 0;
  for (int i = 0; i < 100000; i++)
  {
    if (rand() % 101 > 50)
    {
      counter++;
    }
  }
  printf("%d", counter);
  return 0;
}

Warum genau ist diese Implementierung langsam? Die CPU versucht mithilfe der sogenannten Branch Prediction, zukünftige Programmzeilen vorherzusagen und vorzeitig auszuführen. Da die nächste Zufallszahl noch nicht bekannt ist, muss die CPU raten, ob der Counter erhöht wird oder nicht. Anhand dieser Entscheidung werden der Pipeline neue Instruktionen zugeführt. Wenn die Vorhersage jedoch falsch ist, wird ein Pipeline-Flush ausgelöst, der dazu führt, dass die Pipeline einige Takte benötigt, um alle vorherigen Anweisungen zu löschen. Erst dann kann die korrekte Instruktion ausgeführt werden. Da dies jedoch nur in 50% der Fälle zutrifft, kann praktisch kein Laufzeitgewinn durch die Branch Prediction erzielt werden. Im Gegenteil, durch die Flushes wird sogar die Ausführungsdauer verlangsamt. Bei den 50% spricht man auch von der Selektivität.

Wie kann dieses Verhalten verhindert werden?

Das beste Mittel, um falsche Branch Predictions zu vermeiden, besteht darin, erst gar keine Branches zu verwenden. Dazu kann die boolsche If-Bedingung in einen Integer gecastet werden. Dieser hat entweder den Wert 0 oder 1, der direkt auf die Variable counter addiert werden kann.

C
#include <stdio.h>
#include <stdlib.h>
#include <time.h>

int main()
{
  int counter = 0;
  for (int i = 0; i < 100000; i++)
  {
    counter += (int)(rand() % 101 > 50);
  }
  printf("%d", counter);
  return 0;
}

Auf diese Weise ist die Ausführungsgeschwindigkeit unabhängig von der Selektivität.

Vergleich der Laufzeiten von Branched zu Predicated

Deutlich wird bei einem Vergleich der Laufzeiten ersichtlich, wie sich die Selektivität auf die Performance auswirkt. Bei einer Selektivität von 50% zeigt sich deutlich, dass die Branch Prediction am ineffektivsten ist. Eine Implementierung mit Predication bleibt hingegen gänzlich unberührt von der Selektivität.

Veröffentlicht am

Performance Verbesserungen mit SIMD (Single Instruction multiple data)

„Single Instruction Multiple Data“ (SIMD) bezieht sich auf eine Art von paralleler Datenverarbeitung, bei der eine CPU oder ein Prozessor mehrere gleiche Operationen auf mehreren Daten gleichzeitig ausführt. Diese Methode wird oft eingesetzt, wenn sehr große und ähnliche Datenmengen effizient verarbeitet werden müssen.

Um sich das genauer vorzustellen, können wir uns das Beispiel der Vektor-Addition ansehen. Normalerweise würden wir jedes Element der Vektoren einzeln durchlaufen und addieren, um den Ergebnisvektor zu erhalten.

Im Code Beispiel würde die Implementation so aussehen:

C
int main(){
  float a[4] = {1.0f, 2.0f, 3.0f, 4.0f};
  float b[4] = {5.0f, 6.0f, 7.0f, 8.0f};
  float c[4];

  for (int i = 0; i < 4; i++) {
    c[i] = a[i] + b[i];
  }

  return 0;
}

Deutlich zu erkennen ist, dass der Operator immer derselbe ist (single instruction). Die Daten ändern sich jedoch mit jedem Schleifendurchlauf (multiple data).

SIMD ermöglicht die Ausführung derselben Addition in nur einem Schritt anstelle von vier Schritten, indem die Arrays in SIMD-Register kopiert werden. Diese Register haben typischerweise Größen von 128, 256 oder 512 Bit. Im vorliegenden Beispiel wird ein 128-Bit-SIMD-Register verwendet, da genau 4 float-Werte darin Platz haben.

C
#include <xmmintrin.h>

int main() {
  float a[4] = {1.0f, 2.0f, 3.0f, 4.0f};
  float b[4] = {5.0f, 6.0f, 7.0f, 8.0f};
  float c[4];

  __m128 vecA = _mm_load_ps(a);
  __m128 vecB = _mm_load_ps(b);
  __m128 vecC = _mm_add_ps(vecA, vecB);
  _mm_store_ps(c, vecC);

  return 0;
}

Muss ich meinen Code extra anpassen, um von SIMD zu profitieren?

Ja und nein. Moderne Compiler sind in der Lage solche Konstrukte zu identifizieren und automatisch in SIMD-Code umzuwandeln (Automatic vectorization). Auch wenn dies in der Theorie möglich ist erkennen Compiler nicht jede Stelle, vor allem an komplizierten Code Stellen. Daher ist es ratsam diese Explizit mit den C Compiler Intrinsics zu schreiben.

Hardwareimplementierung

SIMD wird in modernen CPUs und Prozessoren durch spezielle Schaltkreise implementiert, die als SIMD-Units oder Vector Units bezeichnet werden. Diese Schaltkreise sind speziell für die parallele Verarbeitung von Daten ausgelegt und können eine hohe Anzahl von Daten gleichzeitig bearbeiten.

In CPUs von Intel und AMD wird SIMD durch die SSE (Streaming SIMD Extensions) und AVX (Advanced Vector Extensions) implementiert. Die SSE-Technologie unterstützt SIMD-Operationen auf 128-Bit-Datenblöcken, während AVX bis zu 256-Bit-Datenblöcke unterstützt. AVX-512 erweitert die Technologie auf 512-Bit-Datenblöcke.

Bei Arm Prozessoren werden die SIMD-Funktionalitäten durch den Neon Befehlssatz hinzugefügt. Diese haben eine Breite von 128 Bit.

Hinweise

Wichtig zu berücksichtigen ist, dass das Kopieren von Daten zwischen den normalen und den SIMD-Registern einen zusätzlichen Overhead verursacht, der die Laufzeit des Programms beeinträchtigen kann. Daher sollte das Kopieren nur so selten wie möglich erfolgen, um negative Auswirkungen auf die Gesamtlaufzeit zu vermeiden.

Zusätzlich beschränkt die Verwendung von C-Compiler-Intrinsics die Zielplattformen, da nicht alle Prozessoren über SIMD-Register verfügen. In solchen Fällen ist es möglicherweise notwendig, eine alternative Codeversion ohne SIMD zu implementieren, um auch die Prozessoren ohne diese Register zu unterstützen.