Mit Sammlungen den Überblick behalten
Sie können Inhalte basierend auf Ihren Einstellungen speichern und kategorisieren.
Mit AGI Frame Profiler können Sie Ihre Shader untersuchen, indem Sie einen Draw-Aufruf aus einem unserer Rendering-Passes auswählen und entweder den Bereich Vertex Shader oder Fragment Shader im Bereich Pipeline durchgehen.
Hier finden Sie nützliche Statistiken aus der statischen Analyse des Shader-Codes sowie die Standard Portable Intermediate Representation (SPIR-V)-Assembly, in die unser GLSL kompiliert wurde. Außerdem gibt es einen Tab, auf dem eine Darstellung des ursprünglichen GLSL zu sehen ist, das mit SPIR-V Cross dekompiliert wurde. Es enthält vom Compiler generierte Namen für Variablen, Funktionen und mehr und bietet zusätzlichen Kontext für das SPIR-V.
Statische Analyse
Abbildung 1. Untertitel??
Mit Zählern für die statische Analyse können Sie Low-Level-Vorgänge im Shader ansehen.
ALU-Befehle: Diese Anzahl gibt an, wie viele ALU-Operationen (Additionen, Multiplikationen, Divisionen usw.) im Shader ausgeführt werden. Sie ist ein guter Indikator für die Komplexität des Shaders. Versuchen Sie, diesen Wert zu minimieren.
Wenn Sie allgemeine Berechnungen umgestalten oder Berechnungen im Shader vereinfachen, kann die Anzahl der erforderlichen Anweisungen reduziert werden.
Texture Instructions (Textur-Anweisungen): Diese Zahl gibt an, wie oft die Textur im Shader gesampelt wird.
Das Sampling von Texturen kann je nach Art der Texturen, aus denen gesampelt wird, aufwendig sein. Wenn Sie den Shader-Code mit den gebundenen Texturen im Abschnitt Descriptor Sets (Deskriptorsätze) abgleichen, erhalten Sie weitere Informationen zu den verwendeten Texturtypen.
Vermeiden Sie den zufälligen Zugriff beim Sampling von Texturen, da dieses Verhalten nicht ideal für das Zwischenspeichern von Texturen ist.
Branch Instructions (Verzweigungsanweisungen): Diese Zahl gibt die Anzahl der Verzweigungsvorgänge im Shader an. Das Minimieren von Verzweigungen ist ideal für parallelisierte Prozessoren wie die GPU und kann sogar dazu beitragen, dass der Compiler zusätzliche Optimierungen findet:
Verwenden Sie Funktionen wie min, max und clamp, um Verzweigungen für numerische Werte zu vermeiden.
Kosten für die Berechnung im Vergleich zur Verzweigung testen Da in vielen Architekturen beide Pfade einer Verzweigung ausgeführt werden, gibt es viele Szenarien, in denen die Berechnung immer schneller ist als das Überspringen der Berechnung mit einer Verzweigung.
Temporäre Register: Dies sind schnelle Register auf dem Chip, die zum Speichern der Ergebnisse von Zwischenvorgängen verwendet werden, die für Berechnungen auf der GPU erforderlich sind. Die Anzahl der Register, die für Berechnungen verfügbar sind, ist begrenzt. Wenn diese Grenze erreicht ist, muss die GPU auf anderen Off-Core-Speicher zurückgreifen, um Zwischenwerte zu speichern. Das führt zu einer Verringerung der Gesamtleistung. Dieses Limit variiert je nach GPU-Modell.
Die Anzahl der verwendeten temporären Register kann höher als erwartet sein, wenn der Shader-Compiler Vorgänge wie das Entrollen von Schleifen ausführt. Es ist daher ratsam, diesen Wert mit dem SPIR-V- oder dekompilierten GLSL-Code abzugleichen, um zu sehen, was der Code macht.
Analyse von Shader-Code
Untersuchen Sie den dekompilierten Shader-Code, um festzustellen, ob potenzielle Verbesserungen möglich sind.
Abbildung 2. Untertitel??
Genauigkeit: Die Genauigkeit von Shader-Variablen kann sich auf die GPU-Leistung Ihrer Anwendung auswirken.
Verwenden Sie nach Möglichkeit den Genauigkeitsmodifikator mediump für Variablen, da 16-Bit-Variablen mit mittlerer Genauigkeit (mediump) in der Regel schneller und energieeffizienter sind als 32-Bit-Variablen mit voller Genauigkeit (highp).
Wenn in den Variablendeklarationen im Shader oder oben im Shader mit einem precision precision-qualifier type keine Präzisionsqualifizierer zu sehen sind, wird standardmäßig die volle Präzision (highp) verwendet. Achten Sie auch auf Variablendeklarationen.
Die Verwendung von mediump für die Ausgabe von Vertex-Shadern wird aus den oben beschriebenen Gründen ebenfalls bevorzugt. Außerdem wird dadurch die Speicherbandbreite und möglicherweise die Nutzung temporärer Register reduziert, die für die Interpolation erforderlich sind.
Einheitliche Puffer: Versuchen Sie, die Größe von Uniform Buffers so klein wie möglich zu halten (unter Einhaltung der Ausrichtungsregeln). Das macht Berechnungen besser mit dem Caching kompatibel und ermöglicht es, einheitliche Daten in schnellere On-Core-Register zu verschieben.
Nicht verwendete Vertex-Shader-Ausgaben entfernen: Wenn Sie Vertex-Shader-Ausgaben finden, die im Fragment-Shader nicht verwendet werden, entfernen Sie sie aus dem Shader, um Speicherbandbreite und temporäre Register freizugeben.
Berechnungen vom Fragment-Shader zum Vertex-Shader verschieben: Wenn im Fragment-Shader-Code Berechnungen ausgeführt werden, die unabhängig vom Zustand des zu schattierenden Fragments sind (oder richtig interpoliert werden können), ist es ideal, sie in den Vertex-Shader zu verschieben. Das liegt daran, dass der Vertex-Shader in den meisten Apps viel seltener ausgeführt wird als der Fragment-Shader.
Alle Inhalte und Codebeispiele auf dieser Seite unterliegen den Lizenzen wie im Abschnitt Inhaltslizenz beschrieben. Java und OpenJDK sind Marken oder eingetragene Marken von Oracle und/oder seinen Tochtergesellschaften.
Zuletzt aktualisiert: 2025-07-27 (UTC).
[null,null,["Zuletzt aktualisiert: 2025-07-27 (UTC)."],[],[],null,["# Analyze shader performance\n\nAGI Frame Profiler allows you to investigate your shaders by\nselecting a draw call from one of our render passes, and going through either\nthe **Vertex Shader** section or **Fragment Shader** section of the **Pipeline**\npane.\n\nHere you'll find useful statistics coming from static analysis of the shader\ncode, as well as the [Standard Portable Intermediate Representation](https://en.wikipedia.org/wiki/Standard_Portable_Intermediate_Representation)\n(SPIR-V) assembly that our GLSL has been compiled down to. There's also a tab\nfor viewing a representation of the original GLSL (with compiler generated names for variables, functions, and more) that was decompiled with SPIR-V Cross, to provide additional context for the SPIR-V.\n\nStatic analysis\n---------------\n\n**Figure 1.**Caption??\n\nUse static analysis counters to view low-level operations in the shader.\n\n- **ALU Instructions**: This count shows the number of ALU operations\n (adds, multiplies, divisions, and more) are being executed within the\n shader, and is a good proxy for how complex the shader is. Try to minimize\n this value.\n\n Refactoring common computations or simplify computations done in the\n shader can help reduce the number of instructions needed.\n- **Texture Instructions**: This count shows the number of times texture\n sampling occurs in the shader.\n\n - Texture sampling can be expensive depending on the type of textures being sampled from, so cross-referencing the shader code with the bound textures found in the **Descriptor Sets** section can provide more information on the types of textures being used.\n - Avoid random access when sampling textures, because this behavior is not ideal for texture-caching.\n- **Branch Instructions**: This count shows the number of branch operations\n in the shader. Minimizing branching is ideal on parallelized processors such\n as the GPU, and can even help the compiler find additional optimizations:\n\n - Use functions such as `min`, `max`, and `clamp` to avoid needing to branch on numeric values.\n - Test the cost of computation over branching. Because both paths of a branch are executed in many architectures, there are many scenarios where always doing the computation is faster than skipping over the computation with a branch.\n- **Temporary Registers**: These are fast, on-core registers that are used to\n hold the results of intermediate operations required by computations on the\n GPU. There is a limit to the number of registers available for computations\n before the GPU has to spill over into using other off-core memory to store\n intermediate values, reducing overall performance. (This limit varies\n depending on the GPU model.)\n\n The number of temporary registers used may be higher than expected if the\n shader compiler performs operations such as unrolling loops, so it's good\n to cross-reference this value with the SPIR-V or decompiled GLSL to see what\n the code is doing.\n\n### Shader code analysis\n\nInvestigate the decompiled shader code itself to determine if there any\npotential improvements are possible.\n**Figure 2.**Caption??\n\n- **Precision** : The precision of shader variables can impact the GPU performance of your application.\n - Try using the `mediump` precision modifier on variables wherever possible, since medium precision (`mediump`) 16-bit variables are usually faster and more power efficient than full precision (`highp`) 32-bit variables.\n - If you don't see any precision qualifiers in the shader on variable declarations, or at the top of the shader with a `precision precision-qualifier type`, it defaults to full precision (`highp`). Make sure to look at variable declarations as well.\n - Using `mediump` for vertex shader output is also preferred for the same reasons described above, and also has the benefit of reducing memory bandwidth and potentially temporary register usage needed to do interpolation.\n- **Uniform Buffers** : Try to keep the size of **Uniform Buffers** as small as possible (while maintaining alignment rules). This helps make computations more compatible with caching and potentially allow for uniform data to be promoted to faster on-core registers.\n- **Remove unused Vertex Shader Outputs**: If you find vertex shader outputs\n being unused in the fragment shader, remove them from the shader to free up\n memory bandwidth and temporary registers.\n\n- **Move computation from Fragment Shader to Vertex Shader**: If the fragment\n shader code performs computations that are independent of state specific to\n the fragment being shaded (or can be interpolated properly), moving it to\n the vertex shader is ideal. The reason for this is that in most apps, the\n vertex shader is run much less frequently compared to the fragment shader."]]