SLI -- an acronym that originally stood for Scan-Line Interleave, then later for Scalable Link Interface -- is, as of today, effectively dead in the form we've known it the longest. Modern GPUs that support DX12 support two forms of SLI: implicit and explicit. Implicit SLI is the mode used in DirectX 11, as well as previous versions of Microsoft's 3D API.
Nvidia made this announcement in the release notes for Version 456.38 of its GeForce Game Ready Software. Beginning on January 1, 2021, no new implicit SLI profiles will be provided for any RTX 2XXX or earlier GPU. All GPU support for SLI going forward will be via explicit SLI, which is to say, the game will have to support the mode directly rather than implementing the mode in-driver.
There's little reason to expect game developers to consider doing this, however. Of the various Ampere GPUs, only the RTX 3090 has the appropriate bridge connection points. Game developers aren't likely to invest in optimizing for the tiny percentage of the market that buys such cards, and while they may implement explicit support in a few games going forward to serve existing SLI owners, I expect the feature to die now that Nvidia won't be providing implicit driver updates any longer.
Breaking workloads down across multiple graphics cards is very difficult.
This will not affect any application that can run across multiple GPUs without depending on SLI, and the number of gamers likely to be impacted by these changes is small. The truth is, in the 10+ years that SLI has been available from AMD and Nvidia, it's never really lived up to its promise. Performance gains have been weakening for years, and it's not unusual to see people with SLI rigs complaining that neither of their GPUs is running at 100 percent.
It may seem strange that SLI is so difficult to implement properly given that games are held up as the stereotypical example of an embarrassingly parallel workload, but there's an explanation. Distributing a workload across two different GPUs requires effective parallelism at a very different level of the system compared with effectively scaling a single-GPU workload across a wider and wider GPU. In the first scenario, how effectively the workload scales will depend on a number of characteristics outside the GPU, including available PCI Express bandwidth, whether the PCIe chipset is attached directly to the CPU or hung off a southbridge, and how good the game (or driver) is at dispatching work to multiple cards in the first place.
In the second scenario, effective parallelism is dictated almost entirely by factors intrinsic to the GPU itself. AMD and Nvidia are both pretty good at this, which is why both companies can deploy the same architecture across chips with 384 cores or 3,840 cores. I don't want to say it's easier to solve parallelism at this level, but it is, at the very least, more straightforward. You can't improve SLI performance until you understand what the bottleneck is, and there are enough moving parts in the system to make locating and fixing the problem tricky. There's a reason Nvidia handled this in-driver rather than asking devs to implement the capability entirely on their own.
SLI also had to confront some intrinsic limits: Under the old, DX11-era model, GPU data in one card must be duplicated in the other. You might have two cards with 8GB of RAM each, but the total amount of memory in your graphics array was 2x8GB -- not 16GB. DirectX 12 lifts this restriction, but that hasn't been enough to drive much vendor interest in the feature.
Because DirectX 12 is a low-level API, Nvidia's old mechanisms for enabling SLI performance in DX11 games can't work the same way, and developers have had a limited appetite for implementing SLI in the first place. Things might have evolved in a different direction if SLI had become truly popular. In a world where consumers prefer playing with two lower-cost GPUs as opposed to a higher-cost model, we might have seen more of an effort to develop engines and rendering techniques specifically friendly to multi-GPU scaling. This did not happen.
It seems unlikely Nvidia will retain the feature indefinitely, and the RTX 3090 may be the last card to feature it, but the death of SLI isn't really something to lament. The technology never caught on in-market the way it would have needed to in order to drive its own adoption and optimization. Nvidia's support was typically better than AMD's, but as someone who used SLI at several points, it was always tetchy.
The era of multi-GPU gaming has effectively come to an end -- at least for now.
Now Read:
