To say there’s a bit of excitement for DirectX 12 and other low-level APIs is probably an understatement. A big understatement. With DirectX 12 ramping up for a release later this year, Mantle 1.0 already in pseudo-release, and its successor Vulkan under active development, the world of graphics APIs is changing in a way not seen since the earliest days, when APIs such as Direct3D, OpenGL, and numerous vendor proprietary APIs were first released. From a consumer standpoint this change will still take a number of years, but from a development standpoint 2015 is going to be the year that everything changed for PC graphics programming.

So far much has been made about the benefits of these APIs, the potential performance improvements, and ultimately what can be done and what new things can be achieved with them. The true answer to those questions are that this is going to be a multi-generational effort; until games are built from the ground-up for these APIs, developers won’t be able to make full use of their capabilities. Even then, the coolest tricks will take some number of years to develop, as developers become better acquainted with these new APIs, their idiosyncrasies, and the capabilities of the underlying hardware when interfaced with these APIs. In other words, right now we’re just scratching the surface.

The first DirectX 12 games are expected towards the end of the year, and in the meantime Microsoft and their hardware partners have been ramping up the DirectX 12 ecosystem, hammering out the API implementation in Windows 10 while the hardware vendors write and debug their WDDM 2.0 drivers. Meanwhile as this has been going on, we’ve seen a slow release of software released designed to showcase DirectX 12 features in a proof of concept manner. A number of various internal demos exist, and we saw the first semi-public DirectX 12 software release last month with our look at Star Swarm.

This week the benchmarking gurus over at Futuremark are releasing their own first run at a DirectX 12 test with their latest update for the 3DMark benchmark. Futuremark has been working away at DirectX 12 for some time – in fact they were the first partner to show DirectX 12 code in action at Microsoft’s 2014 DX12 unveiling – and now they are releasing their first DirectX 12 project.

In keeping with the general theme of the demos we’ve seen so far, Futuremark’s new DirectX 12 release is another proof of concept test. Dubbed the 3DMark API Overhead Feature Test, this benchmark is a purely synthetic benchmark designed to showcase the draw call benefits of the new API even more strongly than earlier benchmarks. Whereas Star Swarm was a best-case scenario test within the confines of a realistic graphics workload, the API Overhead Feature Test is a proper synthetic benchmark that is designed to test one thing and one thing only: how many draw calls a system can handle. The end result, as we’ll see, showcases just how great the benefits of DirectX 12 are in this situation, allowing for an order of magnitude’s improvement, if not more.

To do this, Futuremark has written a relatively simple test that draws out a very simple scene with an ever-increasing number of objects in order to measure how many draw calls a system can handle before it becomes saturated. As expected for a synthetic test, the underlying rendering task is very simple – render an immense amount of building-like objections at both the top and bottom of the screen – and the bottleneck is in processing the draw calls. Generally speaking, under this test you should either be limited by the number of draw calls you can generate (CPU limited) or limited by the number of draw calls you can consume (GPU’s command processor limited), and not the GPU’s actual rendering capabilities. The end result is that the API Overhead Feature Test can push an even larger number of draw calls than Star Swarm could.

To showcase the difference between various APIs, this test is available with DirectX 12 and Mantle, but also two different DirectX 11 modes. Standard DirectX 11 single-threading is one mode, alongside support for DirectX 11 multi-threading. The latter has a checkered history – it never did work as well in the real world as initially hoped – and in practice only NVIDIA supports it to any decent degree. But regardless, as we’ll see DirectX 12’s throughput will put even DX11MT to shame.

The test is designed to make API overhead the performance bottleneck. The test scene contains a large number of geometries. Each geometry is a unique, procedurally-generated, indexed mesh containing 112 -127 triangles.

The geometries are drawn with a simple shader, without post processing. The draw call count is increased further by drawing a mirror image of the geometry to the sky and using a shadow map for directional light.

The scene is drawn to an internal render target before being scaled to the back buffer. There is no frustum or occlusion culling to ensure that the API draw call overhead is always greater than the application side overhead generated by the rendering engine.

Starting from a small number of draw calls per frame, the test increases the number of draw calls in steps every 20 frames, following the figures in the table below.

To reduce memory usage and loading time, the test is divided into two parts. The second part starts at 98304 draw calls per frame and runs only if the first part is completed at more than 30 frames per second.

Post Your Comment

113 Comments

Yeah, 285 might outperform the 980 but keep in mind this is a very specific test only focusing one one aspect of rendering a frame. I mean, a man can accelerate faster than an F1 car over very short distance of few meters, but that doesn't really mean much in the real world.Keeping my fingers crossed though since I've always been AMD fan and I hope they can egain some market share.Reply

I did some math on what available information there is for the 390 versus the Titan and it seems to go toe-to-toe. If it has a lead, it won't be huge. I compared some leaked slides with the numbers Anandtech had for the Titan review. I suspect it will use a lot more electricity though and create more heat.

It doesn't really say anything about the performance of the 285x or the 980, or any of the others for that matter.

Just because they can make a couple more million draw calls a second doesn't mean you will ever see anything.

Just means the video card is really good at screaming for more work, not doing it. Hell these draw calls are all way beyond anything realistic anyhow, you will NEVER have one of these GPU's ever make half as many draw calls as being shown in this test in any real world usage scenario.Reply

If anything I would say that the Nvidia cards are more refined and more balanced, based on these draw call results. Nvidia has optimized more to get the most out of Dx11 while AMD shows a lead on actual hardware capacity through the greater gains both relative and absolute on draw call numbers. It is the very same trend you also see in the amount of hardware both companies use in their top tiered cards to achieve similar performance - AMD uses more, Nvidia uses less and wins on efficiency gains.Reply

Well AMD does win at double precision even over the Titan X. Nvidia pulled a lot of the double precision hardware to save on power, one of the ways maxwell is more efficient. This isn't a bad thing in the gaming community but ruins the Titan X for a lot of compute scenarios. So Nvidia really did lose out a lot in one area to beat AMD at efficiency.

If Anandtech benched Radeon silicon being fed by AMD FX or A10 then NO INTEL/nVidia siliocn would even come close to AMD GCN enabled Asynchronous Shader hardware. Intel and nVidia are now second rate siliocn in a DX12 world.

Even if there were no consoles, games wouldn't be targeted for high end PCs. They will be targeted for lower end PCs to increase the amount of market share they can reach. Maybe once in a blue moon, some developer who doesn't care about that will make the next Crysis.Reply