Wrapping up our AMD product showcase coverage for the week, AMD’s final announcement for the showcase was a very brief announcement about a new API called Mantle. Mantle is something of an enigma at this point – AMD isn’t saying a whole lot until November with the AMD Developer Summit – and although it’s conceptually simple, the real challenge is trying to understand where it fits into AMD’s product strategy, and perhaps more importantly what brought them to this point in the first place. So although we don’t have all of the necessary details in hand quite yet, we wanted to spend some time breaking down the matters surrounding Mantle as much as we reasonably can.

Perspective #1: The Performance Case

The best place to start with Mantle is a high level overview. What is Mantle? Mantle is a new low-level graphics API specifically geared for AMD’s Graphics Core Next architecture. Whereas standard APIs such as OpenGL and Direct3D operate at a high level to provide the necessary abstraction that makes these APIs operate across a wide variety of devices, Mantle is the very opposite. Mantle goes as low as is reasonably possible, with minimal levels of abstraction between the code and the hardware. Mantle is for all practical purposes an API for doing bare metal programming to GCN. The concept itself is simple, and although low-level APIs have been done before, it has been some time since we’ve seen anything like this in the PC space.

Simplicity gives way to complexity however when we begin discussing not just what Mantle is, but why it exists. At the highest level Mantle exists because high level API have drawbacks in exchange for their ability to support a wide variety of GPUs. Abstractions in these APIs hide what the hardware is capable of, and the code that holds those abstractions together comes with its own performance penalty. Of all of those performance issues the principle issue at hand is the matter of draw calls, which are the individual calls sent to the GPU to get objects rendered. A single frame can be composed of many draw calls, upwards of a hundred or more, and every one of those draw calls takes time to set up and submit.

Although the issue will receive renewed focus today with the announcement of Mantle, we have known for some time now that groups of developers on both the hardware and software side of game development have been dissatisfied with draw call performance. Microsoft and the rest of the Direct3D partners addressed this issue once with Direct3D 10, which significantly cut down on some forms of overhead.

But the issue was never entirely mitigated, and to this day the number of draw calls high-end GPUs can process is far greater than the number of draw calls high-end CPUs can submit in most instances. The interim solution has been to attempt to use as few draw calls as possible – GPU utilization takes a hit if the draw calls are too small – but there comes a point where a few large draw calls aren’t enough, and where the CPU penalty from generating more draw calls becomes notably expensive.

Ergo: Mantle. A low-level API that cuts the abstraction and in the process makes draw calls cheap (among other features).

Perspective #2: The Console Connection

However even with a basic understanding of draw calls and their overhead, so far we haven’t really explained why Mantle exists, and indeed the entire frame of reference that Mantle resides in requires better understanding just why it exists. If Mantle was merely about providing a new low level API for GCN, then the issue would be far more straightforward, and Mantle in most likelihood remain an underutilized curiosity. Instead we have to talk about what is not said and not even hinted at, but what is more critical than Mantle’s performance improvements: the console connection.

As the supplier of the APUs in both the Xbox One and PS4, AMD is in a very interesting place. Both of these upcoming consoles are based on their GCN technology, and as such AMD owns a great deal of responsibility in developing both of these consoles. This goes not only for their hardware but also portions of their software stack, as it’s AMD that needs to write the drivers and AMD that needs to help develop the APIs these consoles will use, so that the full features of the hardware are made available to developers.

At the same time, when it comes to writing APIs we also have to briefly mention the fact that unlike the PC world, the use of both high level and low level APIs are a common occurrence in console software. High level APIs are still easier to use, but when you’re working with a fixed platform with a long shelf life, low level APIs not only become practical, they become essential to extracting the maximum performance out of a piece of hardware. As good as a memory manager or a state manager is, if you know your code inside and out then there are numerous shortcuts and optimizations that are opened up by going low level, and these are matters that hardcore console developers will chase in full. So when we talk about AMD writing APIs for the new consoles, we’re really talking about AMD writing two APIs for the new consoles: a high level API, equivalent to the likes of Direct3D and OpenGL, and a low level API suitable for banging on the hardware directly for maximum performance.

This brings us to the crux of the matter: what’s not being said. Simply put, what would happen if you ported both the high level and low level APIs from a console – say the Xbox One – back over to the PC? We already know what that high level API would look like, because it exists today in the form of Direct3D 11.2, an API peppered with new features that coincide with AMD GCN hardware features. But what about a low level API? What would it look like?

What’s not being said, but what becomes increasingly hinted at as we read through AMD’s material, is not just that Mantle is a low level API, but rather Mantle is the low level API. As in it’s either a direct copy or a very close derivative of the Xbox One’s low level graphics API. All of the pieces are there; AMD will tell you from the start that Mantle is designed to leverage the optimization work done for games on the next generation consoles, and furthermore Mantle can even use the Direct3D High Level Shader Language (HLSL), the high level shader language Xbox One shaders will be coded against in the first place.

Let’s be very clear here: AMD will not discuss the matter let alone confirm it, so this is speculation on our part. But it’s speculation that we believe is well grounded. Based on what we know thus far, we believe Mantle is the Xbox One’s low level API brought to the PC.

If indeed Mantle is the Xbox One’s low level API, then this changes the frame of reference for Mantle dramatically. No longer is Mantle just a new low level API for AMD GCN cards, whose success is defined by whether AMD can get developers to create games specifically for it, but Mantle becomes the bridge for porting over Xbox One games to the PC. Developers who make extensive use of the Xbox One low level API would be able to directly bring over large pieces of their rendering code to the PC and reuse it, and in doing so maintain the benefits of using that low-level code in the first place. Mantle will not (and cannot) preclude the need for developers to also do a proper port to Direct3D – after all AMD is currently the minority party in the discrete PC graphics space – but it does provide the option of keeping that low level code, when in the past that would never be an option.

Perspective #3: Developers, Developers, Developers

With that said, the potential for Mantle is not the same as the actual execution for Mantle, and even if we’re correct about Mantle’s Xbox One origins, Mantle’s success is far from guaranteed. Mantle right now is merely the toolset to realize the possibility of bringing over existing low level code to the PC. To be successful, AMD at a minimum needs to convince multiplatform developers that it’s worth their time to do Mantle enabled versions of their rendering engines, as despite the easy porting it’s still more work than just doing the typical Direct3D port. Even then, that only captures multiplatform ports; native PC games are another matter entirely. Mantle does not necessarily need native PC games to be successful for AMD, but certainly it would strongly validate the existence and capabilities of Mantle if AMD was able to get native PC games developed against it too. After all, the draw call benefits of Mantle are still very real, regardless of which platform is the lead platform for a game.

In fact the significance of developers in this entire process should not be understated. Mantle exists because it’s faster than high level APIs, it makes porting low level console code to the PC easier, and as it turns out, because it’s something developers have been telling AMD they want. More than anything else about Mantle, this is the point AMD has been trying to drive home, as they are well aware of the potential controversy Mantle would bring. Mantle doesn’t just exist because AMD wants to leverage their console connection, but Mantle exists because developers want to leverage it too, and indeed developers have been coming to AMD for years asking for such a low level API for this very reason. As such the impression we're getting from AMD – or at least the impression they're trying their best to give off – is that Mantle was created to satisfy these requests, rather than being something AMD created and is trying to drum up interest for after the fact.

The first game to use Mantle will be Battlefield 4, and as part of the Mantle announcement AMD had DICE put together a video for today’s product showcase, in which they spent some time discussing their own interest in Mantle and low level APIs. It’s one thing for AMD to claim that developers want Mantle – something that would be difficult for the press and consumers to validate – but it’s something else entirely when developers are willing to put together lengthy testimonials in support of Mantle. To that end DICE is just one developer, but with any luck for AMD they are the first of many developers. If AMD’s claims about developers asking for this are true, then we should be able to see for ourselves soon enough if and when more developers pledge support for the API.

Perspective #4: The Drawbacks of Low Level APIs

With all of that in mind, while Mantle has the potential to provide benefits to users and developers alike, there are also some very clear downsides to using a low level API in PC game development.

Unlike consoles, PCs are not fixed platforms, and this is especially the case in the world of PC graphics. If we include both discrete and integrated graphics then we are looking at three very different players: AMD, Intel, and NVIDIA. All three have their own graphics architectures, and while they are bound together at the high level by Direct3D feature requirements and some common sense design choices, at the low level they’re all using very different architectures. The abstraction provided by APIs like Direct3D and OpenGL is what allows these hardware vendors to work together in the PC space, but if those abstractions are removed in the name of performance then that compatibility and broad support is lost in the process.

A lot of press – ourselves included – immediately began comparing Mantle to Glide. Glide was another low level API that was developed by the long-gone GPU manufacturer 3dfx, and at the height of their power in the mid-to-late 90s 3dfx wielded considerable influence thanks to Glide. Glide was easier to work with than the immature Direct3D API, and for a time games either supported only Glide, or supported Glide alongside Direct3D or OpenGL. Almost inevitably the Glide rendering path was better in some respect, be it performance, features, or a general decrease in bugs. This was fantastic for 3dfx card owners, but as both AMD (nee ATI) and NVIDIA can tell you, this wasn’t great for those parties that were on the outside.

As a result of this, as great as Glide was at the time, it’s widely considered a good thing that Glide died out and that Direct3D took over as the reigning king of PC graphics APIs. Developers stopped utilizing multiple rendering paths, and their single rendering path was better for everyone as a result. Having games written exclusively in a common, industry standard API was better for everyone.

Mantle by its very nature reverses that, by reestablishing a low level API that exists at least in part in competition with Direct3D and OpenGL. Consequently while Mantle is good for AMD users, is Mantle good for NVIDIA and Intel users? Do developers start splitting their limited resources between Mantle and Direct3D, spending less time and resources on their Direct3D rendering paths as a result?

At the risk of walking a very fine line here, like so many aspects of Mantle these are not questions we have the answer to today. And despite the reservations this creates over Mantle this doesn’t mean we believe Mantle should not exist. But these are real concerns, and they are concerns that developers will need to be careful to address if they intend to use Mantle. Mantle’s potential and benefits are clear, but every stakeholder in PC game production needs to be sure that Mantle doesn’t lead to a repeat of the harmful aspects of Glide.

Final Words

When AMD first told us about their plans for Mantle, it was something we took in equal parts of shock, confusion, and awe. The fact that AMD would seek to exploit their console connection was widely expected, however the fact that they would do so with such an aggressive move was not. If our suspicions are right and AMD is bringing over the Xbox One low level API, then this means AMD isn’t just merely exploiting the similarities to Microsoft’s forthcoming console, but they are exploiting the very heart of their console connection. To bring over a console’s low level graphics API in this manner is quite simply unprecedented.

However at this point we’ve just scratched the surface of Mantle, and AMD’s brief introduction means that questions are plenty and answers are few. The potential for improved performance is clear, as are the potential benefits to multiplatform developers. What’s not clear however is everything else: is Mantle really derived from the Xbox One as it appears? If developers choose to embrace Mantle how will they do so, and what will the real performance implications be? How will Mantle be handled as the PC and the console slowly diverge, and PC GPUs gain new features?

The answers to those questions and more will almost certainly come in November, at the 2013 AMD Developer Summit. In the interim however, AMD has given us plenty to think about.

Comments Locked


View All Comments

  • wumpus - Friday, September 27, 2013 - link

    No. They are almost certainly completely different APIs that do different things. On the other hand, if you wanted to write your own OpenGL (or Wayland) drivers using Mantle, it should certainly be far easier (but the results will be slower than what AMD could do by writing directly to the hardware) than writing them for nvidia (without any API or other information). Linux users are salivating at the thought.

    On second thought, I suspect that AMD will do just that (write directX and OpenGL in Mantle). Hopefully it will make debugging a little easier. Just make sure that you look at both Mantle and non-Mantle benchmarks when comparing cards (because directX will suffer slightly if they do this).
  • inighthawki - Friday, September 27, 2013 - link

    Writing OpenGL to be on top of Mantle will not give a performance advantage, that makes no sense, otherwise OpenGL would just have been implemented that way to begin with. OpenGL and DX drivers must obey a specific set of interfacing rules. DX for example has a separate user mode and kernel mode driver that must interact in a specific way. Bypassing these is not an option. Same goes for OpenGL, which is a standardized interface on top of the OS. Best you could do is expose a few extensions to call to Mantle.
  • ddriver - Thursday, September 26, 2013 - link

    There is nothing really preventing nvidia from doing the same, although you can already customize the pipeline significantly since it is pretty much entirely programmable, even if you lack some features implemented by the driver you can still write your own code and get hardware accelerated custom render features.

    I suspect Mantle is nothing more than a "scenegraph" with implemented out of the box optimizations for the drawing calls to minimize the need for context switching and data transfer plus a bunch of pre-compiled ready-to-use compute kernels.

    This alone is more than enough to make up the numbers AMD claims, the difference from just drawing arbitrary stuff in sequential order to drawing selectively, in special order, employing instancing and offloading everything possible to the compute shaders will easily result in 9x if not significantly more rendering throughput. The problem is that if you want efficient drawing, you have to implement that yourself for your engine, while AMD offer to have it done for you, but only if you use an API that only works for their products. I don't think AMD even went for a hardware implementation of the scenegraph, that would have yielded more improvement, so most likely it is just a bit of code that could just as well be hooked to OpenGL and work for code that runs on every platform, so while a good effort, Mantle comes with a less-than-optimally-positive intent. It does way more good for AMD than for developers, and even does some harm, because besides competition it is also fragmentation and forcing extra work for developers. What is good for people are open and portable standards, so if AMD really wanted to make it good for users, it would simply make a good graphics API with optimizations for OpenGL that still markets AMD but works with non-AMD products too. This will give the healthy boost OpenGL needs, since it is capable and low level enough and perfectly extendable with hardware accelerated features, and unlike Direct3D it works everywhere, not only on M$$$ platforms. It was a heck of a b1tch move from M$ to disable OpenGL in windows phone, even though all the chips come with hardware support for it, once again creating more work for developers just for the sake of using a platform vendor limited API, which is BAD if it doesn't conform to an open standard.
  • itchytimes - Thursday, September 26, 2013 - link

    'There is nothing really preventing nvidia from doing the same'

    Except the fact that nvidia are in none of the new consoles, while AMD hardware is powering the PS4 and Xbox One. Both of which will have the ability to use AMD's Mantle with game developers already making use of it when creating games for the consoles. Making it a no brainer to use it for carrying the game over to PC with the Mantle API available there as well.

    It's ingenious.
  • chizow - Thursday, September 26, 2013 - link

    Nvidia already has a close-to-metal API, it's called NVAPI and they've had it for years. It literally spits out basic Assembly code (ADD, MUL, MAD, MOV) to run on their GPUs, if they really wanted to do something like Mantle I'm sure they could dress up CUDA to be the front end instead of DX, but I'm not really sure they'd want to do so. I'm really not sure if the PC market wants that (2 vendor specific gaming APIs?).
  • itchytimes - Thursday, September 26, 2013 - link

    Yes but it is not nvidia or AMD coding the games, it's the game developers. They'll be using Mantle already for developing console games, so using the implementation for the PC port is already work that is done.

    There is zero reason to do additional work just for an nvidia low level API on PC only that is additional work and expense.

    Nvidia is dead in the water with any attempt at their own version of Mantle.
  • chizow - Thursday, September 26, 2013 - link

    Sorry, I doubt that is the case. The developer will need to compile a new runtime that uses this new API, but AMD will most likely still need to provide some high level compiler or tools that converts OpenGL, C or whatever high level language they are using for source code and convert it to AMD's close-to-metal Mantle machine code.

    There is no way Devs are going to take on the additional burden of hand coding machine code for Mantle, that's a fact.
  • PhoenixEnigma - Thursday, September 26, 2013 - link

    The idea is that instead of writing something in OpenGL, developers write it in Mantle, which is harder but gets better performance. They're already doing this for the consoles where they need to eke out every last drop of performance, and AMD is already making developer tools to support this there. AMD is now giving them a way to take these more hand tuned routines and port them to PC, bypassing OpenGL/DX. There's certainly some work involved, but it's not all new code - it's letting devs reuse high quality code they've alrady written on a new platform, where before they were limited to DX and a performance hit.

    For a PC-only title, it's a much harder sell, granted, since there still needs to be a DX or OpenGL codepath, but for a console port it's at least an interesting option.
  • chizow - Thursday, September 26, 2013 - link

    Not sure where you all get the idea of developers writing code in Mantle since we already know Devs are writing code in OpenGL (PS4) or DirectX (XB1) or both (PC) as the source code. The only thing Mantle does is allow the source code to be compiled and executed in machine code at runtime, thus stripping out the middle API (DX, OpenGL).

    So intead of: Source code (DX, OGL) > Compiler > Platform-specific HLSL (DX, XNA, OGL) > Hardware Driver/Compiler > Machine Code > GPU

    You get: Source code > Mantle Compiler > Machine Code > GPU

    The 4th slide that talks about "simplified porting" touches on this.

    If Devs actually had to code low-level API...you're going to have a lot of Devs who are going to need to brush up on their matrix math. Drawing a simple diagonal line in 3D space for example goes from 1 instruction in HLSL to at least 3-4 in machine code. There's simply no way any Dev is going to undertake that task, maybe Carmack but he takes that kind of challenge on for fun more than efficiency.
  • mfergus - Friday, September 27, 2013 - link

    Except for maybe indie games, almost all games are low level on consoles. OpenGL will not be the common API used on the PS4. The PS3 also sorta supports OpenGL but nobody uses it. The 360 also supports DirectX sorta but it allows you to go much lower than PC DirectX. Low level API's have been and will always be common on consoles.

Log in

Don't have an account? Sign up now