Benchmarking in Vulkan or Dx12 is still a bit of a pain in the NAS, but PresentMon makes it possible to conduct accurate FPS and frametime tests without reliance upon FRAPS. July 11 marks DOOM's introduction of the Vulkan API in addition to its existing OpenGL 4.3/4.5 programming interfaces. Between the nVidia and AMD press events the last few months, we've seen id Software surface a few times to talk big about their Vulkan integration – but it's taken a while to finalize.
As we're in the midst of GTX 1060 benchmarking and other ongoing hardware reviews, this article is being kept short. Our test passes look only at the RX 480, GTX 1080, and GTX 970, so we're strictly looking at scalability on the new Polaris and Pascal architectures. The GTX 970 was thrown-in to see if there are noteworthy improvements for Vulkan when moving from Maxwell to Pascal.
This test is not meant to show if one video card is “better” than another (as our original Doom benchmark did), but is instead meant to show OpenGL → Vulkan scaling within a single card and architecture. Note that, as with any game, Doom is indicative only of performance and scaling within Doom. The results in other Vulkan games, like the Talos Principle, will not necessarily mirror these. The new APIs are complex enough that developers must carefully implement them (Vulkan or Dx12) to best exploit the low-level access. We spoke about this with Chris Roberts a while back, who offered up this relevant quote:
“There's been some jobification of CryEngine over the past few years, but we're taking it further because we know we're building for a high-end PC, so we have more threads available with more power than you typically do on a next-generation console. Part of that is a big task, because the renderer in CryEngine was pretty much built with the conception of one thread: a bunch of stuff gets put on the render pipeline, then it gets rendered-out. It assumes it's all rendered in the same space, area, et cetera, and so we need to compartmentalize that better and do better management of the individual resources so it's not one monolithic render pipeline.
"That's the fundamental, big work that we're embarking on, and I think that's something that is pretty fundamental to an engine, and they're not always constructed with that in mind.
"Even UE4, which is a bit newer than CryEngine – originally, the way it was structured, [it] was very much along the CryEngine paradigm, with the same sort of delineation of threads. I haven't looked at the [UE4] code recently, but that's what it was [like] quite a while ago. I think, fundamentally, there is some definite work that has to happen on the low-level in all game engines to really push Dx12. It's easy to do the demo like Square Enix did with Final Fantasy, but that's just pushing raw poly – look at the rig it was on, look at the graphics cards it was on. You could probably do the same with Dx11, that's just brute force. To really see the benefit of dx12, it's going to be more about doing that lower-level refactoring – then you'll be able to get some pretty interesting performance, even on some PCs that aren't quite as powerful.”
This benchmark of DOOM's Vulkan vs. OpenGL performance measures FPS, frametimes, and scaling on the RX 480, GTX 1080, and GTX 970 SSC (overclocked).
DOOM Benchmark Course
We tested using our updated 2015 Multi-GPU test bench, detailed in the table below. Our thanks to supporting hardware vendors for supplying some of the test components.
The latest AMD drivers (16.7.2 with RX 480 power patch) were used for testing. NVidia's 368.69 drivers were used. Game settings were configured to "Ultra" with anti-aliasing set only to FXAA (no multi-tap). Resolution settings were configured to 1080p, 1440p, and 4K. We performed some additional low-end GPU testing with “Medium” settings at 1080p. Tests were conducted in the Foundry, level 2. The test path is in the video further above.
Each scenario was tested for 30 seconds identically, then repeated three times for parity, per setting, per card – that's a maximum of 9 to 12 test passes per device.
FPS fluctuates heavily in the game. We chose one of the more intensive interior settings. Generally, card performance should be slightly higher than what's shown here – we didn't figure out a definitive “worst case,” but found a middle-of-the-road benchmark course in terms of intensiveness.
Average FPS, 1% low, and 0.1% low times are measured. We do not measure maximum or minimum FPS results as we consider these numbers to be pure outliers. Instead, we take an average of the lowest 1% of results (1% low) to show real-world, noticeable dips; we then take an average of the lowest 0.1% of results for severe spikes.
1080p DOOM Vulkan vs. OpenGL Benchmark – GTX 1080, RX 480, GTX 970
At 1080p, we're seeing the GTX 1080 FE produce a 19.4% increase from OpenGL 4.5 to Vulkan, moving the card from 139.7FPS AVG to 168.8FPS AVG. That's accompanied by an average frametime (ms time between frames) of 5.9ms in Vulkan.
The RX 480 produces a substantial 30.65% increase when moving from OpenGL 4.5 to Vulkan, which jumps the card from ~85FPS AVG to ~111FPS AVG. Its average frametime is 9ms.
And the Maxwell EVGA GTX 970 SSC from last generation shows negative scaling, a ~1% decrease in performance from OpenGL 4.5 to Vulkan. The 970 SSC's frametimes remain consistent at ~9.36ms average.
1440p DOOM Vulkan vs. OpenGL Benchmark – GTX 1080, RX 480, GTX 970
1440p shows a 5% increase for the GTX 1080 – a big drop in gains from 1080p, but one which scales with increased workload on the GPU – and moves the card from 109FPS to 114.55FPS. The GTX 1080 keeps tightly timed frame pacing, with an average frametime of 8.7ms.
AMD's RX 480 sees a 29.3% increase in performance when moving from OpenGL to Vulkan, sticking close to its ~31% gains seen at 1080p. The card moves from an average framerate output of 57FPS to 73.7FPS as a result, planting it firmly above 60FPS territory for 1440p. That's a significant jump in performance and makes a visible difference in gameplay fluidity. Averaged frametime output is 13.58ms for the RX 480, and is generally fluid.
The GTX 970 SSC sees effectively identical performance, with (technically) negative scaling at 0.36% slower with Vulkan. The GTX 970 SSC moves from 69.5FPS to 69.25FPS AVG. Frametime output is 14.44ms and sees some occasional variance with Vulkan, introducing the occasional (but generally infrequent) stutter.
4K DOOM Vulkan vs. OpenGL Benchmark – GTX 1080, RX 480, GTX 970
4K sees the end of Pascal scaling with Vulkan, creating an effectively identical (but negative) scaling when switching from OpenGL to the Vulkan API. The RX 480 is completely unplayable – as one might expect – but still produces a consistent scaling of 24.7% AVG FPS increase.
Conclusion: Consistent Upscaling on RX 480, Some on GTX 1080
Just to reiterate something: This is one game with the Vulkan API. We have seen countering results in Vulkan testing (vs. Dx11) in the Talos Principle, so it really comes down to implementation by developers, drivers, and the type of content rendered in that game.
That stated firmly and repeatedly, AMD's RX 480 is showing gains which actually outpace what we were told this morning – always a refreshing sight to see marketing be based in reality. The 480 consistently exceeds 20% scaling, with 1080p showing just above 30% AVG FPS increase (OpenGL → Vulkan) and 1440p showing ~29% AVG FPS increase. That's a big gain for the $240 card, and pushes the RX 480 well past “ideal playability” at 1440p. It sat just under 60FPS before the Vulkan update.
The GTX 1080, although unexciting in its scaling past 1080p, does show better ability to wield the new APIs than the Maxwell architecture (as represented by the GTX 970 SSC in these charts). The GTX 970 posts slight negative scaling from OpenGL to Vulkan, but is effectively (perceptibly) the same, with the occasional stutter at some resolutions.
Editorial, Test Lead: Steve “Lelldorianx” Burke
Test Technician: Andie “Draguelian” Burke
Video Producer: Andrew “ColossalCake” Coleman