News Vulkan: Erste Benchmarks der neuen API in Talos Principle

VikingGe schrieb:
Äh, ja? Von Exklusivtiteln abgesehen muss die Portierung auf eine Plattform einfach sein, sonst macht sich nämlich keiner die Mühe und die Plattform bleibt außen vor.

Daraus abzuleiten, dass Sony Vulkan-Support bieten wird, halte ich dennoch für gewagt, solange es dafür keine offizielle Aussage gibt. Das aktuelle Modell funktioniert für alle Beteiligten ja recht gut. Die XBone wirds sowieso nicht supporten, also wird es auch weiterhin 35 verschiedene Rendering-Backends in den Spielen geben.


Du hast da einen Denkfehler. Die PS4 ist aktuell Leadplattform von der aus für Xone und PC portiert wird. Da ist es egal was die PS4 als API nutzt. Aktuell würde es sich vllt. sogar rechnen ausschließlich für die PS4 zu entwickeln, da die Marktdurchdringung hoch genug ist. Ports sind da nur noch Gewinnmaximierung.

Das man dann auf DX12 setzt um Xone und PC gleichzeitig abzudecken (2 Fliegen mit einer Klappe und so) ist da nur naheliegend.
Ich bin gespannt wie es mit Vulkan weiter geht.
 
Zuletzt bearbeitet:
Nai schrieb:
Die andere Seite fand ich scheiße. Sah mir zu sehr nach Werbung und zu wenig nach Information aus

Tja, da hast du dann wohl ganz offensichtlich falsch geurteilt. :p

9t3ndo schrieb:
Du hast da einen Denkfehler. Due PS4 ist aktuell Leadplattform von der aus für Xone und PC portiert wird. Da ist es egal was die PS4 als Api nutzt.

Die PS4 wird als Leadplattform genutzt, gerade weil es das Portieren so einfach ist. Was für mehr Spiele sorgt und was wiederum mehr verkaufte Konsolen und mehr Devs bringt. Genau den gegenteiligen Effektkreislauf hatte Sony eben bei der PS3.
 
@ Zehkul

Schön das wir uns einig sind :)
 
Was ist Vulkan ?
 
zombie schrieb:

image-163254-panoV9free-xyvw-163254.jpg


Talos Principle ist ein Benchmark über die Menge an Lava einzelner Vulkane.
 
CCIBS schrieb:
Noch länger und öfter würde auch eine neue, alles ändernde API angekündigt

Es gibt zwei wesentliche Unterschiede zu OpenGL:
- unter Windows war es problemlos durch DirectX ersetzbar. Jetzt ist es umgekehrt, Vulkan kann mehr als DX12:
Windows 7, Windows 8, Windows 8.1 und auch 10.
- OpenGL für den PC und OpenGL ES für Mobilgeräte waren zwei Spezifikationen, Vulkan fasst beide zusammen.

Du musst für Vulkan also ohnehin entwickeln, und erreichst auch unter Windows eine viel größere Zielgruppe als mit DirectX 12.
 
HaZweiOh schrieb:
Es gibt zwei wesentliche Unterschiede zu OpenGL:
- unter Windows war es problemlos durch DirectX ersetzbar. Jetzt ist es umgekehrt, Vulkan kann mehr als DX12:
Windows 7, Windows 8, Windows 8.1 und auch 10.
Im Grunde (fast) die selbe Situation wie damals bei Vista und DX10. Und Vista hat sich sogar schleppender verbreitet als WIN10.


- OpenGL für den PC und OpenGL ES für Mobilgeräte waren zwei Spezifikationen, Vulkan fasst beide zusammen.

Du musst für Vulkan also ohnehin entwickeln, und erreichst auch unter Windows eine viel größere Zielgruppe als mit DirectX 12.
Verstehe ich den Gedankengang jetzt richtig? Weil man ein Spiel für Mobilgeräte auf Vulkan entwickelt, hat man es dann auch gleich für den PC? Also ich glaube nicht, dass die selben Spiele auf Mobilgeräte erscheinen wie auf dem PC. Auf jeden Fall nicht die Spiele, welche ich im Kopf habe.

Außerdem ist Vulkan, wenn ich es richtig verstanden habe, nur Grafik, während DirectX so ziemlich alles ist. Wohl auch einer der Hauptgründe, weshalb sich DirectX so gut durchsetzte.
 
dMopp schrieb:
OSX nutzt OpenGL 2.X (100%) oder seit Capitan "Metal" (Auch nix anderes wie Vulkan). 4.1 wird nicht voll supported :|
Bei 4.1 fehlt ARB_get_program_binary, bleibt aber immer noch volles 4.0 (und nicht uraltes 2.x).
Metal ist schon was anderes als Vulkan (oder auch als DX12), es ist bleibt auf halbem Wege stehen.
Für iOS und einfache Apps ganz geeignet. Kennt aber noch nicht mal Geometrie Shader oder Tesselation. (Im Gegensatz zu dem älteren OpenGL 4.0).
 
CCIBS schrieb:
Im Grunde (fast) die selbe Situation wie damals bei Vista und DX10.

Da kam noch dazu, dass der Weg von Konsole auf PC zum alten D3D9 Renderer am einfachsten und billigsten war, null Motivation, am PC die Limits auszutesten, die geringe Vista Verbreitung war da nur der letzte Sargnagel.

Ganz anders mit DX12 und Vulkan, die tatsächlich näher an der Konsole sind als vorige APIs.
 
Was mich mal interessieren würde: Wie architekturabhängig sind denn diese Low-Level-Optimierungen, die dank Vulkan und DX12 möglich werden sollen. Ich meine, der geringere Overhead ist ja schon mal gut, aber müssen die Entwickler dann je eine Version für Nvidia und eine für AMD (und bei Relevanz auch eine für APMs) schreiben um die Möglichkeiten wirklich auszunutzen (von den separaten Versionen für die Konsole mal ganz abgesehen)?
 
Der Spaß ist noch ausreichend weit abstrahiert. Da wird nicht in Assembler sondern in Hochsprachen programmiert.
 
@Piktogramm: Dass da nicht (oder nur wenig) in Assembler programmiert wird ist mir schon klar, aber wenn ich die HW maximal ausnutzen will (was ja angeblich der große Vorteil von Vulkan und DX12 ist) muss ich ja auch auf deren jeweilige Eigenheiten Rücksicht nehmen (z.B. den eSRAM bei der XB) und mich würde halt interessieren, wie ähnlich sich die Architekturen von AMD und Nvidia auf dieser Ebene noch sind.
 
Um solche Eigenheiten muss man sich nur insofern kümmern, dass man im Falle von z.B. eSRAM das Programm so gestaltet, dass der Speicher nicht zum Flaschenhals wird. Das geht am leichtesten, indem man schlicht die Auflösung begrenzt, was derzeit je bereits gemacht wird.

Auf sonstige Gegebenheiten sollte der Compiler hin optimieren.
 
Miuwa schrieb:
Wie architekturabhängig sind denn diese Low-Level-Optimierungen, die dank Vulkan und DX12 möglich werden sollen.
Vulkan soll ja nicht nur auf den Desktop-GPUs von Intel, AMD und Nvidia laufen, sondern auch auf den ganzen Smartphone- und Tablet-GPUs, die sich AFAIK schon recht stark von den Desktop-Architekturen unterscheiden.

Auf Eigenheiten musst du immer Rücksicht nehmen, das gilt auch schon für die alten APIs und bezieht sich dann auf so Dinge wie die minimale Anzahl an Pixeln pro Dreieck für optimale Performance, oder aber Tiling-Eigenschaften. Da gibt es zwischen den Architekturen teils große Unterschiede, an sich ist in den APIs aber nichts architekturspezifisches drin.

Letztenendes machen die APIs ja auch nicht viel. Etwas vereinfacht:

1) Du kannst Speicher anfordern, um irgendwelche Daten reinzuschreiben - z.B. Vertexdaten, Transformationsmatrizen oder Materialdaten. Nennt sich ganz schlicht Buffer.

2) Du erstellst Texturen und schreibst da irgendwelche Bilddaten rein. In Vulkan musst du der Textur aber auch sagen, für was sie verwendet wird, damit der Treiber das Layout im Speicher entsprechend anpassen kann.

3) Du programmierst Shader, die die Daten aus Schritt 1 und 2 nehmen, irgendwie mithilfe der Fixed-Function-Pipeline verwursteln und dann ggf. daraus ein Bild generieren, was dann entweder auf dem Bildschirm oder in einer Textur landet. Die Fähigkeiten der GPUs sind durch die Shader Models mehr oder weniger standartisiert, abseits von grundlegenden FMA-Operationen dürften hier aber schon die größten Architekturunterschiede deutlich werden - zum Beispiel die Performance des Texturfilters.

4) Du sagst der GPU, mit welchen Daten dein Shader arbeiten soll. Das geht in Vulkan über Descriptor Sets, in denen z.B. steht, welche Textur-Variable im Shader auf welche richtige Textur im Speicher abgebildet werden soll.

5) Du schickst einen Draw Call los. Der besteht aber letztenendes nur aus Anweisungen, wie oft der Vertex Shader aufgerufen werden soll, die nötigen Daten usw. hast du der GPU bereits mitgeteilt und alles andere regelt die Fixed Function-Pipeline. Deswegen ist so ein Aufruf auch ziemlich primitiv:
Code:
vkCmdDraw(VkCommandBuffer commandBuffer, uint32_t vertexCount, uint32_t instanceCount, uint32_t firstVertex, uint32_t firstInstance);


Die Art und Weise, wie man mit Vulkan Bilder auf den Bildschirm zaubert, unterscheidet sich letztenendes kaum von der Art und Weise, wie man es in modernem OpenGL macht. Es gibt ein paar Dinge, um die man sich nun selbst kümmern muss (zum Beispiel Swap Chain erstellen, was AFAIK aus der DirectX-Ecke kommt, oder Synchronisation zwischen GPU-Operationen), ein paar Dinge, um die man sich endlich selbst kümmern kann (Dinge, die unabhängig voneinander laufen, in separate Queues dispatchen, zum Beispiel), aber der Rest funktioniert sehr ähnlich.

Der größte Unterschied ist aber das Object Model und liegt damit im API-Design selbst, wo du dich eben selbst um Speicher, Lifetimes und solche Späßchen kümmern musst, im Gegenzug dazu gibt es aber weder eine globale State Machine (gut für Multithreading) und keine Zustandsvalidierung (gut für Overhead, aber schlecht für Debugging, deswegen gibts das ganze doch noch optional als Layer).
 
Zuletzt bearbeitet:
Danke für die ausführliche Antwort. Ich hab zwar ne ziemlich gut Vorstellung davon worauf es bei effizientem CPU-Code ankommt, aber keine Ahnung von Spieleprogrammierung
VikingGe schrieb:
Der größte Unterschied ist aber das Object Model und liegt damit im API-Design selbst, wo du dich eben selbst um Speicher, Lifetimes und solche Späßchen kümmern musst
Das ist doch z.B. genau so ein Punkt. Bisher haben sich die GPU Hersteller in ihren Treibern darum gekümmert, dass Speichermanagement mehr oder weniger individuell möglichst effizient auf die jeweilige GPU abzustimmen (ich nenn hier mal die Fury als Stichwort). Jetzt können und müssen das die Spiele- bzw. Engineentwickler übernehmen und da wäre es interessant zu wissen, wieviel Microoptierung für die jeweilige Architektur nötig / sinvoll / möglich ist.
 
So ganz den Durchblick habe ich da auch noch nicht, aber da sehe ich jetzt wenig neus architekturspezifisches Optimierungspotential, wohl aber welches, von dem alle Architekturen mehr oder weniger automatisch profitieren.
Da muss man aber auch unterscheiden, von welcher Art Speicher wir reden:

- Texturspeicher. Texturen liegen ja in der Regel nicht linear im Speicher, sondern eben so, dass die GPU da möglichst effizient drauf zugreifen kann - in der Regel tiled für bessere Cache-Effizienz beim Lesen.

Bei Vulkan kannst du Tiling explizit aktivieren und gibst nen Verwendungszweck an, der Treiber wählt dann das beste Layout aus - bei den älteren APIs muss der Treiber raten, was du vorhast. Da aber fast alle Texturen ausschließlich zum Sampling in Shadern verwendet werden, wird das nicht viel ändern. Auch daran, dass AMD zu blöd ist, 3D-Texturen richtig zu tilen (finde jetzt gerade den Artikel nicht wieder, aber das ist offenbar zumindest bei den älteren GCN-Karten ein echtes Problem), wird man nichts ändern können.

- Linearer Speicher. Hier musst du jetzt entscheiden, ob du Speicher willst, der
o nur von der GPU benutzt werden kann
o sowohl von GPU als auch CPU mit expliziten Synchronisationsprimitiven benutzt werden kann, oder
o voll kohärent von CPU und GPU benutzt werden kann.
Außerdem kannst du ein paar Eigenschaften verschiedener Speicherblöcke abfragen, wirklich Einfluss auf den Allokator kann man aber wohl nicht nehmen. Zumal der ja auch noch vom Treiber implementiert wird.

Der zweite Punkt wird glaube ich in der Regel so umgesetzt, dass GPU und CPU sich in ihren eigenen Addressräumen Speicher reservieren und die GPU dann bei Bedarf per DMA auf die Daten im normalen Systemspeicher zugreift. Sinn des Ganzen ist halt einfach, dass du Daten überschreiben kannst und dann ein Mal nen Commit ausführst. Der kohärente Modus dürfte dagegen auf HSA-fähigen APUs schnell sein, auf Desktop-Systemen mit dedizierter GPU dagegen eher langsam.

Das entspricht quasi 1:1 den entsprechenden Mapping-Flags der GL_ARB_buffer_storage-Extension, aber in D3D11 ist das meines Wissens nicht möglich und das Mappen eines Buffers in den CPU-Addressraum ist da damit nicht nur generell langsam, sondern erst recht langsam, wenn der Treiber nicht richtig errät, was deine Anwendung macht. Andererseits ist da auch kein gleichzeitiger Zugriff von GPU und CPU möglich, wobei der Punkt für Spiele weitaus weniger interessant sein dürfte als für Compute-intensive Anwendungen.

Weiterer Vulkan-Vorteil ist das Memory Model. Bei D3D11 sind AFAIK alle Operationen konsistent, bei OpenGL muss man nur wenige Operationen von Hand synchronisieren, bei Vulkan (soweit ich die Specs richtig verstehe) alle Operationen, die irgendwie voneinander abhängig sind.

Ansonsten gelten da aber dieselben Regeln wie sonst auch - lieber einen großen Puffer reservieren als zehn kleine und nicht quer über den ganzen Speicher verteilt lesen und schreiben. Aber auch das galt es schon bei den alten APIs zu beachten, denn die Möglichkeit, GPU-Speicher für nahezu beliebige Zwecke zu reservieren und sich dann damit auszutoben, ist nicht neu.
 
Zuletzt bearbeitet:
Also was ich jetzt zu dem NV und AMD vergleich mal sagen möchte.
Es is natürlich noch Early days für Vulkan und DX12.

Kann durchaus sein dass NV für alle gezeigten Spiele (Ashes of the Singularaty, Talos Principle, Fable Legends)
noch Treiberupdates bereitstellen und das Kräfteverhältnis wieder ins Gleichgewicht rückt.

Schön langsam muss ich aber sagen dass ich nicht mehr so recht daran glaube, vor allem weil NV in der Regel ja immer auch bei kleineren Titeln schnell einen optimierten Treiber bereitstellt.

Dazu kommt noch das meine Erwartung ja von vorne herein eine bessere Performance seitens AMD war.
Weil sie eben in der Theorie, die leistungsfähigeren Karten bauen was jetzt TFlops und so weiter angeht, aber immer Probleme mit Optimierung und Treiberoverhead hatten.

Und die ersten Benches sowohl von Vulkan als auch von DX12 scheinen das zu bestätigen...
 
Stebs schrieb:
Bei 4.1 fehlt ARB_get_program_binary, bleibt aber immer noch volles 4.0 (und nicht uraltes 2.x).
Metal ist schon was anderes als Vulkan (oder auch als DX12), es ist bleibt auf halbem Wege stehen.
Für iOS und einfache Apps ganz geeignet. Kennt aber noch nicht mal Geometrie Shader oder Tesselation. (Im Gegensatz zu dem älteren OpenGL 4.0).

Das mit dem 4.0 ist rein software emuliert (soweit ich mich erinnere) und das ist einer der Gründe, warum Spiele unter OSX so beschissene Performance aufweisen... Man munkelt, dass das neue WoW AddOn das erste Metal "Spiel" für OSX wird.

Was GL4.0 angeht:
. 4.2 zu 15% (zumindest mit meiner GTX775M)
tatsächlich, Gl4.1core wird zu 100% supported, ist an mir vorbei gegangen :O

Kann es sein, dass die Spiele die bisher unter OSX laufen nur openGL 3.x nutzen ? (Soweit ich mich erinnere war der 4.x support unter Yosemite und älter nicht vorhanden)

EDIT:
Ha, ich wusste es, bis heute wird nur OpenGL 2.1 voll supported, 3.0 zu 95% und 4.x 0%

screen.jpg
 
Zuletzt bearbeitet:
dMopp schrieb:
Ha, ich wusste es, bis heute wird nur OpenGL 2.1 voll supported, 3.0 zu 95% und 4.x 0%
Kann das an der Plattform und den Treibern liegen? Das sieht mir schon etwas merkwürdig aus. Im Grunde genommen könnte man von OGL ja praktisch nichts nutzen was nach v2.1 gekommen ist.
 
Zurück
Oben