© DrHitch/Shutterstock.com
Das Vulkan-API Teil 1

2 Vulkan vs. OpenGL - Zukunft gegen Vergangenheit


Nachdem wir uns im vorigen Kapitel einen ersten Überblick über die Funktionsweise des OpenGL-Nachfolgers verschafft haben, werden wir uns hier mit den Voraussetzungen befassen, unter denen Vulkan [1], [2], [3] seine Vorteile gegenüber dem OpenGL-API voll ausspielen kann. Ohne neue Ansätze hinsichtlich der Szenenberechnung und -darstellung würden wir ansonsten allenfalls von einem geringeren Treiberoverhead profitieren können.

Haben Sie sich eigentlich schon einmal gefragt, warum wir alle paar Wochen immer wieder die Mitteilung erhalten, dass für unsere Grafikkarte ein neues Treiberupdate verfügbar ist? Wenn ein neues Grafikkartenmodell auf den Markt kommt, dann lässt sich das Release eines neuen Treibers ja durchaus nachvollziehen. Was jedoch die vielen weiteren zwischenzeitlich veröffentlichten Updates und Hotfixes betrifft, so hilft uns selbst ein Blick in die Releaseinformationen nicht wirklich weiter, da er leider viel mehr Fragen aufwirft als Antworten liefert:

  • behebt einige bekannte Treiberbugs
  • behebt mehrere Darstellungsfehler in Spiel X
  • verbessert die Performance in den Spielen Y und Z
  • usw.

In Anbetracht solcher oder so ähnlich klingender Aussagen werden sich vermutlich viele Computerbenutzer schon einmal die Frage gestellt haben, warum es offenkundig unmöglich zu sein scheint, einen fehlerfrei funktionierenden Grafiktreiber zu entwickeln. Nun ja, solange es nur am Treiber liegt, besteht immerhin ein wenig Grund zur Hoffnung, dass sich mit dem nächsten Release alles zum Besseren wenden wird. Im schlimmsten Fall ist jedoch die Hardware selbst für die schlechte Performance einzelner Spiele verantwortlich – wie in letzter Zeit am Beispiel der mangelhaften Asynchronous-Compute-Unterstützung (immerhin eines der wichtigsten Direct3D-12- bzw. Vulkan-Features) seitens der NVIDIA-Grafikkarten mehr als deutlich geworden sein dürfte. Ungeachtet ihrer Mitschuld gibt es neben Programmierfehlern oder einem misslungenen GPU-Design jedoch noch einen weiteren Grund, warum wir uns im Augenblick in dieser misslichen Lage befinden. Während sich Treiberbugs verhältnismäßig schnell korrigieren und Hardwareprobleme sich zumindest in zukünftigen Grafikkartengenerationen beheben lassen, sind die Geister der Vergangenheit ungleich schwerer in den Griff zu bekommen. Damit betagte Grafikanwendungen und Spiele lauffähig bleiben, müssen Grafiktreiber neben den aktuellen Direct3D-, OpenGL- oder Vulkan-Spezifikationen selbstverständlich auch immer die jeweils älteren API-Versionen unterstützen. Da diese jedoch für eine mittlerweile veraltete Hardwaregeneration konzipiert wurden, sind mögliche Komplikationen im Prinzip bereits vorprogrammiert. Bedenken Sie in diesem Zusammenhang, dass die neue Hardware zumindest in Teilen anders funktioniert als die ältere.

OpenGL – ein altgedientes Grafik-API stößt an seine Grenzen

Früher oder später wird die kontinuierliche Weiterentwicklung eines Grafik-APIs unvermeidlich an ihre Grenzen stoßen. Möchte man nämlich stets die neuesten Features moderner Grafikhardware und Multi-Core-CPUs unterstützen, wird es eines Tages einmal unmöglich werden, die Abwärtskompatibilität zu den älteren API-Versionen aufrechtzuerhalten. Spätestens dann wird es allerhöchste Zeit für einen Neuanfang. Im Ergebnis stehen uns heute mit Direct3D 12 und Vulkan zwei vollkommen neu entwickelte Grafikschnittstellen zur Verfügung. Ein wenig bedauerlich ist nur, dass sich Microsoft bei der Namensgebung wie üblich mit einer neuen Versionsnummer begnügt hat, obwohl die Unterschiede zwischen Direct3D 11 und Direct3D 12 im Prinzip genauso groß sind wie die zwischen OpenGL und Vulkan. Um besser nachvollziehen zu können, inwieweit sich die Funktionsweise der neuen Vulkan-Schnittstelle von der Funktionsweise älterer Grafik-APIs unterscheidet, sollten wir uns gemäß der Maxime „Lerne aus den Fehlern der Vergangenheit“ zunächst einmal mit den Gründen befassen, warum OpenGL langsam, aber sicher an seine Grenzen stößt.

Als in den 90er-Jahren des letzten Jahrtausends die ersten OpenGL-Spezifikationen veröffentlicht wurden, galten Mehrkernprozessoren oder leistungsfähige Grafikkarten noch als reine Zukunftsmusik. Um dem geringen Leistungsvermögen der damaligen Hardware Rechnung zu tragen, wurden sowohl OpenGL als auch Direct3D anfangs als globale Zustandsautomaten entworfen. In der heutigen Zeit ist ein solches Design jedoch nicht länger sinnvoll, denn ein globaler Zustandsautomat lässt sich nur sehr schlecht in eine auf Multi-Threading ausgelegte Anwendung integrieren – es sei denn, man würde den API-Einsatz auf einen einzigen Renderingthread (in der Regel handelt es sich hierbei um den Hauptprogrammthread) beschränken. Und genau an dieser Stelle liegt der sprichwörtliche Hund begraben: Im Kern ist OpenGL nach wie vor ein globaler Zustandsautomat! Sofern man die Kommunikation zwischen dem Hauptprogramm und der Grafikkarte (Rendering, Ressourcenmanagement sowie Bufferupdates) auf einen einzigen Thread beschränkt, ist alles im grünen Bereich. Betrachten wir in diesem Zusammenhang einmal die nachfolgend gezeigte Abfolge von Renderfunktionen:

[...]
Render_BackgroundBox();
Render_Asteroids();
Render_SpaceShips();
[...]

Wenn besagte Funktionen nacheinander aufgerufen werden, dann wird die GPU selbstverständlich keine Probleme damit haben, die in diesem Zusammenhang übermittelten Arbeitsanweisungen auf korrekte Weise zu interpretieren. Was aber wird wohl geschehen, wenn der Aufruf dieser Renderfunktionen von unterschiedlichen Threads aus erfolgt? Um diese Frage beantworten zu können, werfen wir zunächst einmal einen Blick auf die zugehörigen Arbeitsanweisungen, die von den einzelnen Threads aus an die Grafikkarte übermittelt werden müssen:

  • Renderingthread 1 ruft die Funktion Render_BackgroundBox() auf:
    1. Binde Textur-Array-Objekt (Background Box)
    2. Binde Index-Buffer-Objekt (Background Box)
    3. Binde Vertex-Buffer-Objekt (Background Box)
    4. Führe Draw Call aus (Background Box)
  • Renderingthread 2 ruft parallel zu Renderingthread 1 die Funktion Render_Asteroids() auf:
    1. Binde Vertex-Buffer-Objekt (Asteroids)
    2. Binde Index-Buffer-Objekt (Asteroids)
    3. Binde Textur-Array-Objekt (Asteroids)
    4. Führe Draw Call aus (Asteroids)

Würde man die zuvor betrachteten Threads in einer Art und Weise synchronisieren, dass Thread 2 erst dann mit seiner Arbeit beginnt, nachdem Thread 1 seine Arbeit beendet hat, würden die einzelnen Arbeitsanweisungen in der korrekten Reihenfolge an die GPU übermittelt werden. Allerdings bringt uns diese Art der Synchronisierung auch keinerlei Vorteile gegenüber der Verwendung eines einzelnen Renderingthreads. Dürften beide Threads ihre Arbeit hingegen parallel zueinander verrichten, dann können wir von Glück sagen, wenn die Arbeitsanweisungen auch tatsächlich in der korrekten Reihenfolge bei der GPU eintreffen würden. Schauen wir uns doch einfach mal eine besonders problematische Abfolge an:

1. [...]
2. Binde Textur-Array-Objekt (Background Box)
3. Binde Index-Buffer-Objekt (Background Box)
4. Binde Vertex-Buffer-Objekt (Asteroids)
5. Binde Vertex-Buffer-Objekt (Background Box)
6. Binde Index-Buffer-Objekt (Asteroids)
7. Führe Draw Call aus (Background Box)
8. Binde Textur-Array-Objekt (Asteroids)
9. Führe Draw Call aus (Asteroids)
10. [...]

Weder die Hintergrund- (Anweisung 7) noch die Asteroidendarstellung (Anweisung 9) würde bei der zuvor gezeigten Reihenfolge korrekt funktionieren, da die Vertex- und Index-Buffer-Objekte, die im Rahmen der Anweisungen 5 und 6 gebunden worden sind, schlichtweg nicht zusammenpassen!

Bei der Lösung dieses Problems setzen sowohl Vulkan als auch Direct3D 12 auf das gleiche Pferd: Arbeitsanweisungen dürfen nicht mehr einzeln, sondern müssen stattdessen als Pakete – in Form von so genannten Command-Buffer-Objekten (Vulkan-API: VkCommandBuffer) – an die GPU übermittelt werden. Da sich die einzelnen VkCommandBuffer-Objekte nur nacheinander abarbeiten lassen, müssen die betreffenden Buffer zunächst durch einen Aufruf der vkQueueSubmit()-Funktion in eine Warteschlange (VkQueue) eingefügt werden. Einmal erstellt, kann man einen Command-Buffer beliebig oft wiederverwenden. In unserem Demoprogramm kopieren wir beispielsweise sämtliche für die Hintergrunddarstellung erforderlichen GPU-Arbeitsanweisungen nur ein einziges Mal in den dafür vorgesehenen Buffer. Im Verlauf der Szenendarstellung genügt dann ein einfacher vkQueueSubmit()-Aufruf, um den Hintergrund zu rendern.

Während es durchaus nachvollziehbar ist, warum man frühere Grafik-APIs in Form von globalen Zustandsautomaten implementierte (es mangelte schlicht an einer vernünftigen Alternative), gibt es nichtsdestotrotz auch die eine oder andere Designentscheidung, die theoretisch zwar gut klingen mag, in der Praxis jedoch zwangsläufig zu Problemen führt. Nehmen wir als Beispiel die GLSL-Shader-Programme. Im Rahmen einer OpenGL-Anwendung erfolgt ihre Kompilierung durch den jeweils installierten Grafiktreiber. In der Theorie mag das wie eine hervorragende Idee erscheinen, denn man hatte mit dieser Vorgehensweise die Hoffnung verbunden, dass sich hierdurch die Ausführungsgeschwindigkeit der kompilierten Shader maximieren ließe. Nun ja, in der Praxis hat das letzten Endes zu großen Kompatibilitätsproblemen geführt. Im Prinzip kann man sich bei komplexen Shader-Programmen niemals wirklich sicher sein, ob sie auf sämtlichen Grafikkarten korrekt ausgeführt werden. Und selbst wenn, ist damit längst noch nicht ausgeschlossen, dass sich das durch ein Treiberupdate nachträglich ändert.

Eine weitere Designentscheidung, die sich massiv auf die Performance einer Grafikanwendung auswirkt, betrifft die Fehlerbehandlung. Bislang waren es die Treiber, die für die Überwachung der korrekten API-Benutzung (erkennen und abfangen so genannter Validity Errors) verantwortlich waren. Im Prinzip lassen sich sämtliche Lese- und Schreibzugriffe auf den GPU-Speicher durch den Treiber überwachen und falls erforderlich unterbinden. Allerdings wirkt sich eine sehr umfangreiche Fehlerbehandlung natürlich zunehmend negativ auf die Performance einer Grafikanwendung aus. Besonders problematisch ist es, wenn das betreffende API mit jeder neuen Spezifikation immer weiter ausgebaut und die Fehlerbehandlung entsprechend aufwendiger wird. Dummerweise ist das noch längst nicht alles, denn als Entwickler können bzw. dürfen wir leider nicht darauf vertrauen, dass die Fehlerbehandlung seitens der Grafiktreiber immer auch zu den gleichen Ergebnissen führt. Bei „Warnungen“ und „Fehlern“ kann es jedoch keinen Interpretationsspielraum geben. Ob eine Grafikanwendung abstürzt oder nicht, darf nicht davon abhängig sein, von welchem Hersteller die auf der Grafikkarte verbaute GPU stammt!

Anforderungen an ein modernes Grafik-API

Dass eine mithilfe eines modernen Grafik-API erstellte Anwendung auf sämtlichen Grafikkarten neueren Datums sowohl fehlerfrei als auch performant funktionieren muss, sollte eigentlich nicht extra betont werden müssen. Genauso selbstverständlich sollte es sein, dass ein Treiberupdate nicht plötzlich zu Darstellungsfehlern oder Programmabstürzen führen darf...

headline from sands settings