Verständnis der Anwendungsleistung mit Dachlinienmodellierung

Bei der Berechnung der Leistung einer Anwendung kann sich die reale Leistung und die theoretische Leistung unterscheiden. Mit einem Ökosystem von Produkten, das mit hohen Leistungsbedürfnissen wie Excessive Efficiency Computing (HPC), Gaming oder in der aktuellen Landschaft – Großsprachenmodelle (LLMs) wächst, ist es wichtig, die Leistung einer Anwendung genau zu berechnen.

Das einfache Messen theoretischer Gflops (Gleitkommaoperationen professional Sekunde) reicht nicht aus, da Anwendungen diese Maximal in der realen Welt selten erreichen. Hier kommt das Dachlinienmodell ins Spiel und bietet eine klare visuelle Methode, um die Leistung einer Anwendung abzuschätzen und die kritische Rolle von hardwarespezifischen Optimierungen hervorzuheben.

Warum einfache Metriken nicht genug sind

Wenn wir über die Messung der Leistung nachdenken, gibt es einige Metriken, die in den Sinn kommen:

• Ausführungszeit: Das sagt es dir Wie lange Eine Aufgabe hat es erfüllt, aber keinen Einblick in Warum.
• Zyklen professional Anweisungen (CPI): Das only misst die Rechenleistung des Prozessors.
• Serielle gegen parallele Ausführung: Misst die Berechnung der Leistung übersehen Alle {Hardware} -Optimierungen.
• Schwimmpunktoperationen professional Sekunde (Flop/s): Das only stellt ein theoretisches Most dar, das in einem realen Szenario oft nicht erreichbar ist.

Obwohl dies gute Metriken sind, liefern sie im Allgemeinen nicht genügend Informationen. Beispielsweise ist die Verwendung der schwimmenden Punktvorgänge professional Sekunden eine theoretische Grenze, die nicht oft erreicht wird. Additionally benutze das als das nur Metrik reicht nicht aus, da es einen gemeinsamen Leistungsbegrenzer ignoriert – Datenbewegung.

Dachlinienmodellierung

Das Dachlinienmodell ist ein leistungsstarkes Software, das die Leistung einer Anwendung visuell gegen die Funktionen einer bestimmten Hardwarearchitektur wie einer CPU oder einer GPU ordnet. Das Modell hat seinen Namen aus der Type des von ihm erzeugten Grafik, das ein „Dach“ aus einer schrägen Linie und einer flachen, horizontalen Linie enthält. Diese Type stellt die ultimativen Leistungsgrenzen dar, die von der {Hardware} auferlegt wird.

Aus dieser Modellierungstechnik gibt es zwei Parameter, die die erreichbaren Grenzen mit {Hardware} definieren:

• Datenbewegung: Die Zeit, die zum Verschieben von Daten benötigt wird, berechnet als Gesamtdatengröße geteilt durch die Spitzenspeicherbandbreite des Methods.
• Berechnung: Die für Berechnungen erforderliche Zeit, die durch Teilen der Gesamtzahl der Gleitkommaoperationen durch die Spitzenberechnung des Methods (häufig in GFLOP/s) geteilt wird.

Die Gesamtausführungszeit einer Anwendung wird durch den größeren dieser beiden Werte bestimmt: max {data_movement, computation}.

Obwohl die {Hardware} eine bessere Berechnung der Leistung hat, kann Datenbewegungen häufig zum Engpass werden. Die Dachlinienmodellierung führt das Konzept von vor Arithmetische Intensität (KI). AI ist das Verhältnis der Floating-Punkt-Operationen, die für jedes vom Speicher verschobene Datenbyte ausgeführt werden.

• Ein Algorithmus mit hoher arithmetischer Intensität gilt als rechnenhungry. Die Leistung wird durch schnell berechnete Berechnungen eingeschränkt.
• Ein Algorithmus mit niedriger arithmetischer Intensität wird als datenhungry angesehen. Die Leistung ist begrenzt, wie schnell Daten verschoben werden können.

Die Grafik verstehen

Eine Dachlinie gilt für die erreichbaren Flop/S (y-Achse) gegen die arithmetische Intensität (x-Achse). Das „Dach“ selbst zeigt die Grenzen der {Hardware}. Der schräge Teil des Daches repräsentiert die Spitzendatenbandbreite (in GB/s), während der flache Teil die Peak -Rechenleistung (in GFLOPS) darstellt. Beachten Sie, dass sich alles im Bild in einer logarithmischen Skala befindet.

• Punkte unter dem Dach: Geben Sie die suboptimale Leistung an, die den Umfang der Verbesserung anzeigen.
• Punkte, die auf die schräge Linie treffen: Daten hungrige Anwendung. Die Leistung wird durch die Datenbandbreite begrenzt.
• Punkte, die die flache Linie treffen: Hungrige Anwendung berechnen. Es wird die vollständige Rechenleistung des Prozessors verwendet.

Warum ist Dachlinienmodellierung wichtig?

Die Dachlinienmodellierung bietet eine visuelle, intuitive Möglichkeit, die Anwendungsleistung zu verstehen und wichtige Merkmale wie Betriebsintensität, GPU -Funktionen und erreichbare Flop/s anzuzeigen. Diese Artwork von Modellierung hilft dem Programmierer, zielgerichtete Optimierungen für seine Anwendung für {Hardware} zu ermöglichen, mit denen bessere Ergebnisse erzielt werden können.

• Engpassanalyse: Eine visuelle Hilfe macht es dem Entwickler leicht, herauszufinden, wo der Engpass ist – Speicher oder Leistung. Wenn die Anwendung speicherintensiv ist, kann sich ein Entwickler auf die Verbesserung der Datenlokalität mit Techniken wie Caching oder Schleifenklappen konzentrieren. Wenn es intensiv berechnet wird, kann sich der Fokus auf parallele Berechnung oder Nutzung von Compiler -Optimierungen verlagern.
• {Hardware}- und Softwaredesign: Software program -Ingenieure sollten die zugrunde liegende {Hardware} nicht fürchten. Stattdessen sollte das {Hardware} -Design angenommen und optimiert werden. Software program -Ingenieure können Erkenntnisse aus der Dachlinienmodellierung verwenden, um die spezifische Architektur, die sie verwenden, zu nutzen und zu optimieren.

Dachlinienmodellierung in Aktion

Um die Modellierung von Dachlinien durchzuführen, müssen wir die Anwendung profilieren, um die Leistung zu verstehen. Aus Profilerstellung können wir Metriken wie Flops Operations (Flops Operations) und Reminiscence Bandbreite erhalten, die beide für die Modellierung von Dachlinien erforderlich sind. Dieser Artikel untersucht zwei dieser Instruments – Nvidia’s ncu Dies ist die NSight Compute CLI für die GPU -Analyse und den Pytorch -Profiler, insbesondere für Anwendungen mit Pytorch.

Für detaillierte Cuda -Kernel -Optimierung und präzise Flop/Byte -Berechnungen,, ncu Bietet direkte GPU -{Hardware} -Zählerinformationen. Im Gegensatz, torch.profiler.profile Bietet eine höhere Perspektive innerhalb von Pytorch und hilft beim Verständnis der Leistung auf Bedienungsebene, dem Tensor-Speicherverbrauch und dem gesamten Anwendungsverhalten, das sowohl die CPU- als auch die GPU-Aktivitäten umfasst.

Profilerstellung mit NCU

ncu ist die Befehlszeilenschnittstelle, die zum Profilieren von Cuda -Kerneln verwendet wird (2). Es kann die Ergebnisse direkt im Terminal angezeigt oder für eine spätere Analyse in einer Protokolldatei speichern. Um ein Dachlinienmodell zu erstellen, müssen wir die spezifischen Metriken erfassen, mit denen wir die arithmetische Intensität berechnen können.

Wir werden das Pytorch ImageNet -Repository (3) als Beispiel verwenden. Es ist eine gute Wahl, weil es leicht zu verstehen ist, von Pytorch intestine dokumentiert und mit ihrem Profiler zusammenarbeitet, damit wir uns wirklich mit der Leistung befassen können.

Schritt 1: Führen Sie den Befehl ncu aus, um Metriken zu sammeln

Der erste Schritt besteht darin, die Anwendung über NCU auszuführen, um die erforderlichen Daten auf {Hardware}-Ebene zu sammeln. Der Befehl sieht so aus:

ncu --log-file <log_file_name> 
    --metrics <list_of_metrics_separated_by_comma> 
    --target-processes all 
    python3 <your_application.py application_arguments>

• Protokollfile: Die Protokolldatei, in der wir die Ergebnisse speichern möchten.
• Metriken: Dies ist der wichtigste Parameter und zeigt die Metriken, die wir erfassen möchten. Zur Berechnung der arithmetischen Intensität betrachten wir:
  • dram__sectors_write.sum : Summe der Dram -Sektoren geschrieben
  • dram__sectors_read.sum : Summe der DRAM -Sektoren lesen
  • smsp__sass_thread_inst_executed_op_fadd_pred_on.sum : Summe der schwimmenden Punktzüge
  • smsp__sass_thread_inst_executed_op_fmul_pred_on.sum : Summe von Gleitkomma-Multiplikationen
  • smsp__sass_thread_inst_executed_op_ffma_pred_on.sum : Summe des fusionierten Fusions-Multiplikations-Operationen
• Zielprozess: all Flag stellt sicher, dass wir die gesamte Anwendung profilieren.

Unser Befehl ncu ändert sich zu:

ncu --log-file logs_example --metrics dram__sectors_write.sum, 
dram__sectors_read.sum, 
smsp__sass_thread_inst_executed_op_fadd_pred_on.sum,  
smsp__sass_thread_inst_executed_op_fmul_pred_on.sum, 
smsp__sass_thread_inst_executed_op_ffma_pred_on.sum 
--target-processes all python3 
essential.py /imagenet --arch resnet50 --epochs 1 --batch-size 10 
--print-freq 10 --seed 42

Schritt 2: Berechnung von Flops aus den Metriken

Sobald der Profiler ausgeführt wurde, können wir die gesammelten Metriken zusammenfassen, um die gesamten Schwimmpunktoperationen zu berechnen. Die Formel lautet:

(Flops = 2 * fma _count + fadd _count + fmul _count )

• Flops: Zählung von schwimmenden Punktoperationen.
• Fma_count: Fusions-Multiply-ADD-Operationen (FMA) gilt typischerweise als 2 Flops (eine Multiplikation und eine Addition). Dies wird durch die dargestellt smsp__sass_thread_inst_executed_op_ffma_pred_on.sum metrisch.
• FADD_COUNT: Dies wird durch die dargestellt smsp__sass_thread_inst_executed_op_fadd_pred_on.sum metrisch.
• Fmul_count: Dies wird durch die dargestellt smsp__sass_thread_inst_executed_op_fmul_pred_on.sum metrisch.

Schritt 3: Berechnen Sie die übertragenen Bytes

Als nächstes berechnen wir die Gesamtdaten, die zu und von DRAM übertragen werden. Die NCU -Metriken liefern die Anzahl der gelesenen und geschriebenen DRAM -Sektoren. Angenommen, eine gemeinsame Sektorgröße von 32 Bytes für modernen GPUs:

.

Schritt 4: Berechnen Sie die arithmetische Intensität

Mit Flops und Gesamtbytes können wir jetzt die arithmetische Intensität berechnen:

(Ai = flops / Complete _dram _bytes )

Schritt 5: Berechnen Sie die Ausführungszeit

Um die Leistung der Anwendung in Flop/S zu finden, benötigen wir auch die Ausführungszeit. Hierzu können wir Nvidia NSIGHT Methods (NSYS) verwenden, einen systemweiten Profiler, der die Laufzeit der Anwendungssegmente genau messen kann. Wir führen unsere Anwendung erneut mit NSYS aus, um einen zeitbasierten Bericht zu erstellen. Aus diesem Bericht können wir die gesamte GPU -Laufzeit extrahieren.

nsys profile -f true -o <your_nsys_output_file.qdrep> python3 
<your_application.py application_arguments>

Unser NSYS -Befehl ändert sich zu:

nsys profile -f true -o time.qdrep python3 essential.py /imagenet 
--arch resnet50 --epochs 1 --batch-size 10 --print-freq 10 
--seed 42

Nachdem wir diesen Befehl ausgeführt haben, können wir das bekommen GPU_RUNNING_TIME.

Schritt 6: Berechnen Sie die Anwendungsleistung

Schließlich berechnen wir die erreichte Leistung in Flop/s, indem wir die Gesamtflops durch die Ausführungszeit teilen:

(Flop / s = flops / gpu _running _time )

Dieser Wert gibt uns den „erreichbaren Flop/S“, den wir in unserem Dachliniengraphen zeichnen können.

Profilerstellung mit Taschenlampe

Für Anwendungen, die in Pytorch geschrieben wurden, das integrierte integrierte Anwendungen torch.profiler.profile Bietet eine benutzerfreundliche Möglichkeit, Leistungsdaten zu sammeln. Es gibt 2 Optionen, die den Entwicklern zur Verfügung gestellt werden:

• Verwenden Sie den Profiler -Kontextmanager
• Concentrating on Profiling für bestimmte neuronale Netzwerkschichten

Profiler -Kontextmanager

Der Teil des Code, den wir profilieren möchten torch.profiler.profile() Kontextmanager. Im with Aussage können Sie die definieren actions zu verfolgen (CPU, CUDA oder beides), setzen a schedule Um bestimmte Trainingsschritte zu profilieren, und wählen Sie, ob Tensorformen, Speicherverbrauch oder Flops aufgezeichnet werden. Sobald Sie im Kontext sind, müssen Sie anrufen prof.step() Am Ende jeder Iteration, um dem Profiler voranzukommen, insbesondere wenn ein Zeitplan verwendet wird.

with profile(
    actions=<arguments>,
    schedule=torch.profiler.schedule(<arguments>),
    record_shapes=<True|False>,
    profile_memory=<True|False>,
    with_flops=<True|False>
) as prof:

    ....
    prof.step()

• Aktivitäten: Geben Sie an, ob die CPU, CUDA oder beides profiliert werden soll.
• Zeitplan: Nützlich zum Profilieren mehrerer Schritte in der Trainingsschleife. Wenn der Zeitplanparameter verwendet wird, muss der Profiler Prof.Step () aufrufen, um zum nächsten Schritt zu wechseln.
• record_shapes: Ob Sie die Formen der Tensoren aufzeichnen.
• Profil_Memory: Um die Speicherverwendung zu erfassen
• With_Flops: Dies ist experimentell, wird aber verwendet, um mit Operatoren zu flopieren.

Unser Profiler -Befehl ändert sich zu:

with profile(
    actions=(ProfilerActivity.CPU, ProfilerActivity.CUDA),
    schedule=torch.profiler.schedule(wait=1, warmup=1, energetic=3, repeat=2),
    record_shapes=True,
    profile_memory=True,
    with_flops=True
) as prof:

Concentrating on Profiling für bestimmte neuronale Netzwerkschichten

Der Profiler kann auch zielgerichtet verwendet werden, um bestimmte Schichten eines neuronalen Netzwerks zu analysieren. Dies ist nützlich zu überprüfen, ob eine bestimmte Ebene mehr zur Leistung beiträgt als die anderen Ebenen, die dem Entwickler die Möglichkeit geben, bestimmte Ebenen zu ändern. Während dies sehr einfach zu bedienen ist, funktioniert die erste Choice besser. Die Ergebnisse der Pytorch -Profiler können auch in einem Tensorboard exportiert und sichtbar gemacht werden.

profiler.begin()
self.conv2(x)
profiler.cease()

LLMs und Dachlinienmodellierung

Wenn Sie zu dem Thema kommen, haben alle gewartet – hilft die Modellierung von Dachlinien bei der LLM -Leistungsberechnung? Die kurze Antwort lautet ja.

LLMs sind komplexe neuronale Netzwerkarchitekturen mit Milliarden von Parametern und den massiven Datensätzen, die sie verarbeiten. Während das Coaching eine sehr ressourcenintensive Aufgabe ist, müssen auch Inferenz und Feinabstimmung des Modells effizient sein.

• Engpässe: LLMs während der Inferenz können unter Engpässen leiden, da sie mit der Menge an Parametern arbeiten. Diese Parameter sind die Gewichte der Modelle und verursachen Probleme mit der Speicherbandbreite. Mithilfe der Dachlinienmodellierung können die genauen Schichten für die Engpässe vorgestellt werden.
• Hardwareauswahl: Da die meisten Organisationen vorhandene Modelle fein abschneiden, anstatt sie von Grund auf neu zu trainieren, ist die Auswahl der richtigen Infrastruktur von entscheidender Bedeutung für die Verwaltung der Kosten. Dies unterstreicht, wie wichtig es ist, eine optimale Infrastruktur für das Coaching zu wählen. Wenn Sie beispielsweise die {Hardware} entsprechend Ihrer LLM -Architektur auswählen oder Ihr Modell für eine bestimmte Architektur optimieren, kann das Coaching und die Inferenzkosten gesenkt werden.

Abschluss

Das Dachlinienmodell bietet eine leistungsstarke visuelle Analyse der Anwendungsleistungoptimierung. Durch die Visualisierung der Anwendungsleistung für Speicher und Berechnung wird eine klare Anleitung zur Auswahl des besten Weges zur Annäherung an Optimierungen vorgesehen. Während dieser Artikel nur naive Dachlinienmodelle betrachtete, gibt es fortschrittlichere Techniken wie hierarchische Dachlinienmodelle oder Hinzufügen von Decken für bestimmte Berechnungsoptimierungen.

Referenzen

(1) https://docsnersc.gov/instruments/efficiency/roofline/

(2) https://docs.nvidia.com/nsight-compute/nsightcomputecli/index.html

(3) https://github.com/pytorch/examples/tree/essential/imagenet

(4) https://developer.nvidia.com/nsight-systems