With GDC 2014 having drawn to a close, we have finally seen what is easily the most exciting piece of news for PC gamers. As previously teased by Microsoft, Microsoft took to the stage last week to announce the next iteration of DirectX: DirectX 12. And as hinted at by the session description, Microsoft’s session was all about bringing low level graphics programming to Direct3D.

As is often the case for these early announcements Microsoft has been careful on releasing too many technical details at once. But from their presentation and the smaller press releases put together by their GPU partners, we’ve been given our first glimpse at Microsoft’s plans for low level programming in Direct3D.

Preface: Why Low Level Programming?

The subject of low level graphics programming has become a very hot topic very quickly in the PC graphics industry. In the last 6 months we’ve gone from low level programming being a backburner subject, to being a major public initiative for AMD, to now being a major initiative for the PC gaming industry as a whole through Direct3D 12. The sudden surge in interest and development isn’t a mistake – this is a subject that has been brewing for years – but it’s within the last couple of years that all of the pieces have finally come together.

But why are we seeing so much interest in low level graphics programming on the PC? The short answer is performance, and more specifically what can be gained from returning to it.

Something worth pointing out right away is that low level programming is not new or even all that uncommon. Most high performance console games are written in such a manner, thanks to the fact that consoles are fixed platforms and therefore easily allow this style of programming to be used. By working with hardware at such a low level programmers are able to tease out a great deal of performance of this hardware, which is why console games look and perform as well as they do given the consoles’ underpowered specifications relative to the PC hardware from which they’re derived.

However with PCs the same cannot be said. PCs, being a flexible platform, have long worked off of high level APIs such as Direct3D and OpenGL. Through the powerful abstraction provided by these high level APIs, PCs have been able to support a wide variety of hardware and over a much longer span of time. With low level PC graphics programming having essentially died with DOS and vendor specific APIs, PCs have traded some performance for the convenience and flexibility that abstraction offers.

The nature of that performance tradeoff has shifted over the years though, requiring that it be reevaluated. As we’ve covered in great detail in our look at AMD’s Mantle, these tradeoffs were established at a time when CPUs and GPUs were growing in performance by leaps and bounds year after year. But in the last decade or so that has changed – CPUs are no longer rapidly increasing in performance, especially in the case of single-threaded performance. CPU clockspeeds have reached a point where higher clockspeeds are increasingly power-expensive, and the “low hanging fruit” for improving CPU IPC has long been exhausted. Meanwhile GPUs have roughly continued their incredible pace of growth, owing to the embarrassingly parallel nature of graphics rendering.

The result is that when looking at single threaded CPU performance, GPUs have greatly outstripped CPU performance growth. This in and of itself isn’t necessarily a problem, but it does present a problem when coupled with the high level APIs used for PC graphics. The bulk of the work these APIs do in preparing data for GPUs is single threaded by its very nature, causing the slowdown in CPU performance increases to create a bottleneck. As a result of this gap and its ever-increasing nature, the potential for bottlenecking has similarly increased; the price of abstraction is the CPU performance required to provide it.

Low level programming in contrast is more resistant against this type of bottlenecking. There is still the need for a “master” thread and hence the possibility of bottlenecking on that master, but low level programming styles have no need for a CPU-intensive API and runtime to prepare data for GPUs. This makes it much easier to farm out work to multiple CPU cores, protecting against this bottlenecking. To use consoles as an example once again, this is why they are capable of so much with such a (relatively) weak CPU, as they’re better able to utilize their multiple CPU cores than a high level programmed PC can.

The end result of this situation is that it has become time to seriously reevaluate the place of low level graphics programming in the PC space. Game developers and GPU vendors alike want better performance. Meanwhile, though it’s a bit cynical, there’s a very real threat posed by the latest crop of consoles, putting PC gaming in a tight spot where it needs to adapt to keep pace with the consoles. PCs still hold a massive lead in single-threaded CPU performance, but given the limits we’ve discussed earlier, too much bottlenecking can lead to the PC being the slower platform despite the significant hardware advantage. A PC platform that can process fewer draw calls than a $400 game console is a poor outcome for the industry as a whole.

Direct3D 12 In Depth
POST A COMMENT

105 Comments

View All Comments

  • klmccaughey - Wednesday, March 26, 2014 - link

    DirectX needs to die.

    I think this is a response to Mantle. The best choice for PC gamers would be an API that is not linked to Windows as an OS. Windows is dying, and this is an attempt by MS to keep Windows an essential part of PC gaming. If we had Mantle and NVMantle then we could free PC gaming from the yoke of MS and (almost) everyone would be happy.

    The idea of extending DX to phones etc is pure arrogance and a bad decision. The architecture is so different that I cannot see the API's lining up in anything other than a forced manner.

    As a one-time assembly language games programmer for 8-bits, and then embedded system software programmer in same + C, I really wish that we could get a largely OS independent low level API. OpenGL needs killed too as it has been committee'd into a mess.

    Let's start again and have an industry standard (as far as possible) low to mid level API, backed by the graphics card producers.

    I fear DX12 could be the last gasp of PC gaming as Windows falls into obscurity and we see a fragmentation of the platform that isn't covered by a good graphics API.
    Reply
  • Scali - Wednesday, March 26, 2014 - link

    "If we had Mantle and NVMantle then we could free PC gaming from the yoke of MS and (almost) everyone would be happy."

    Perhaps you've heard of this thing called OpenGL...?
    PC gaming could have been freed from MS at any time... Somehow it never happened...

    "The idea of extending DX to phones etc is pure arrogance and a bad decision."

    DX11 is already on Windows Phone. It's only logical that DX12 also comes to phones (seeing as even phones have DX11-capable hardware soon, which is enough to support DX12).
    Reply
  • Ubercake - Friday, March 28, 2014 - link

    I feel more comfortable with a non-GPU designing 3rd party creating the low-level API, but when that 3rd party is Microsoft I worry DX12 will be in a Beta stage far longer than even Mantle. Reply
  • boe - Tuesday, April 01, 2014 - link

    Crysis 4 and DX12 can't come soon enough for me :) Reply
  • eskates - Tuesday, April 01, 2014 - link

    I'm curious about the future of Mantle. The biggest downside to it is the fact that it's limited to AMD GPUs.

    The game consoles would be a great place to implement it. The problem is that game developers are already using the custom APIs provided by Sony and Microsoft. So Mantle integration will have to provide something that those console-specific APIs aren't already providing.

    On top of that is the fact that a lot of console games are also coming to PC. Developers might need to take advantage of low level APIs to make a game run as well on the consoles as they do on PC. But PC doesn't necessarily need that extra performance boost unless the developer wants to try to keep the system requirements low. But then only newer GPUs are going to support DX12 and although you can get a card for around $100 that will support it, a lot of low end hardware that's currently in PCs will not be able to support it. This is a problem with Mantle too.

    So, what seems like an advantage to me at first - AMD being the exclusive GPU for "next-gen" consoles - turns out to be another roadblock to full adoption for Mantle.

    What happens if Mantle comes out of beta and is announced as being compatible with non-AMD GPUs and this all happens in the next 6 months (by Sept/Oct 2014)? Will it be enough to gain the support needed to make DX12 unnecessary?

    When DX12 releases what will it have that Mantle won't? And if Mantle has become superbly popular during the development of DX12, then what will DX12 offer that motivates the industry to adopt it?

    If Mantle is unable to succeed in gaining any ground over the next 6-12 months. I don't foresee it being used much. It's difficult to go up against Microsoft, who has had a strong-hold on the industry with DirectX for more than a decade and who has the funding and political support to make it successful.

    A lot of unanswerable questions come to mind. It's going to be an interesting shift in both programming and hardware and a welcome change to the way hardware is utilized today.
    Reply

Log in

Don't have an account? Sign up now