Why do GPU drivers get updated so frequently (every (two) week)?

Could someone explain the logic behind drivers getting updated so frequently in such a way that new updates will improve the performance of new video games? After every update, driver is claimed to have improved performance by 1-10 FPS, sometimes even more. I can’t understand this, isn’t driver a simple software interface? How can it require so many updates? I would be glad if someone could explain in simple words.

It’s largely down to games.

New games come out and Nvidia and AMD need to provide SLI / Crossfire profiles for those games as well as game-specific optimisations.

Could you explain this term “game-specific optimisations”?

Optimization, in computer science, means modifying a software system to make some aspect of it work more efficiently or use fewer resources. Such as, taking up less memory, executing more rapidly. (According to Wikipedia)

But how can this driver-optimization be game-specific? Doesn’t changing the whole driver mean that the change will have effect on all other games?

It means that you look at how Game A does a particular action, understand how to best unwind and rewind that particular chunk of code, and put in an optimization that gets the most out of your hardware. It may be useful if other games use the same set of instructions or your optimization may cause other game sequences to run slower. You can even put a check it to see if you’re running a particular game and only activate the optimization for that check passes to avoid unintended consequences.

This was used famously by some compilers which put in optimizations specifically for the benchmark tests. They would recognize code sequences that the tests used and because they knew what was expected could put in optimizations that really only had benefits for the test - making the hardware look faster than it really was.

Did you just post this exact same thread on [H]?

The iterative process of the System Development Life Cycle (SDLC). It would be havoc to update everything at once as not all the dependencies are exposed. You make a change, bench test it, release it, and see what hits the fan. Then move forward with the next one and so forth.

If you notice, when you install software from the more popular vendors, they ask you to opt-in on usage tracking, etc. They are collecting info from the GPU (or software or whatever) and are able to extract where any performance issues are. So, they are getting massive amounts of analytical information. If they see a GPU utilization bump with a particular game when the GPU is performing a particular function, they’ll look into it and see if the processes can be optimized or the usage can be mitigated in some way.

Among other things, graphics drivers have a full-fledged optimizing compiler for pixel/vertex/etc. shaders. New games have new shaders, and may have code structures that aren’t fully optimized by the old compiler. These changes are general purpose, but generally apply less to older games by virtue of them already having gone through the optimization process.

However, the main reason for the rapid iteration is as Quartz said–game profiles. This includes SLI/CrossFire, Optimus (and whatever AMD’s version is), and some other things. Generally these don’t require a full-fledged driver change, but instead just a database update which associates a game with the profile bits. Still, the change is distributed as a new driver even if the core code hasn’t changed much.

Not necessarily. If NewGameX comes out that uses a new technique, and you can recognize it in some way, then you can just have a block of code that looks like:

if (NewGameX) {
    // New optimized thing for NewGameX
} else {
   // Old behavior for other cases.

There may be a small amount of overhead that affects other games (you do have to check that they’re not NewGameX, then do the old thing), but that overhead can usually be made so small that it’s not measurable.

Sounds like a recipe for incredibly bloated and ultimately unmaintainable code.

Fortunately for those of us who run Linux NVidia tries not issue updates at a breakneck pace.

Around the internets, I’ve recently read a few posts about just that. This postdiscusses how we it’ll be very hard to emulate 2010 graphics hardware in 2030 (second page discusses video drivers). At least, we can’t just fire up any ol’ dosbox and count on brute force emulation of 1995-era software rendering.

That links to a forum post giving first-hand accounts of the complexity and bloat that gets added to every driver release to fix bugs and optimize every new game release.

“Bloated and unmaintainable” seems like an understatement.

Reported for forum change.

Really? Seems fine to me. I mean, you probably wouldn’t write exactly that block, you’d have a setup function that switched a function pointer around or something so that the primary code path was cleaner. But different code for different cases isn’t fundamentally bloated or unmaintainable, even if you have a bunch of cases.

It’d be nice if we could just write one general case algorithm that would handle everything, but the real world is full of special cases. Almost no one chooses purity of code over actual performance.

You wouldn’t happen to be one of the OpenSSL developers, would you?