The discussion about the right resolution for processor tests is as old as benchmarks themselves. The desire to be as "practical" as possible often obscures the actual purpose of a processor test: to test the processor. The reason for this is a fundamentally wrong approach to the topic and thinking in resolutions. A comment by Raffael Vötter.
No matter which game or processor is tested, there are always voices that get hung up on the test resolution. This discussion only arises because we tend to think "wrong". Wrong in the sense of what goes on inside our computers and how it works. Since PC Games Hardware is currently renovating the CPU benchmark course, I'd like to drop a few words and thoughts on the subject. Certainly this won't end the Neverending Story, but it will certainly inspire one or the other to rethink.
1,280 × 720: Why this resolution?
There are good reasons for the 1,280 × 720 pixels. In most games, it is the lowest possible adjustable resolution in the 16:9 aspect ratio. The latter is by an overwhelming margin the most common column-to-row ratio in computer and console games. The aspect ratio determines the visible section in games, so it is by no means irrelevant. One could also reactivate a classic from the 90s and measure in 640 × 480 instead. However, this would result in a 4:3 aspect ratio and thus a reduced peripheral field of view. Since the edges play a more important role in our perception and current image sizes, we will stick with 16:9 and thus the same cropping as with 1,920 × 1,080, 2,560 × 1,440, 3,840 × 2,160 and many other popular resolutions.
If the latter resolutions are so popular and practical, why do we test processors so vehemently in 1,280 × 720? Because it's the only way to put the load on what should be tested: the CPU (as well as the attached infrastructure around RAM). Yes, we actually follow the insane idea of testing only the processor in a processor test and not the graphics card. At this point, please let's all take a short break and think about what has been said. Does this make sense? You're nodding, I'm sure. So let's continue with the text.
A CPU test is supposed to reveal how strong the CPU is. Makes sense, doesn't it? Let's run Cinebench or Handbrake, let's use it to test CPU performance. No one complains, everyone is happy about the numbers and bars gained with it. But nobody asks about the resolution. Have you noticed that? That's because of the expectations: application benchmarks are those weird, rather ugly applications where you don't move interactively in space. What do we care about resolution there? This is exactly the mindset that should become the standard when we talk about processor tests. Even for games!
To understand the problem and put it out of your mind, you just have to take a quick look under the hood of your PC and understand how it works. Don't worry, it's not going to be technical, but highly simplified - if you want to be more precise, you can help yourself to the rich literature on the subject, both on and offline. For us, this insight is important: The processor commands the graphics card, without instructions (drawcalls) the pixel specialist twiddles his thumbs. And now comes the clou, which seems to always fall under the table in this pixelated discussion: From the point of view of a main processor, there are no pixels. Pixels are the job of the graphics card, and only the graphics card. It takes care of squeezing all the data into a fixed pixel grid at the end and displaying it on the screen. This is called rasterization.
Gaming benchmarks without resolution
What does that mean exactly? Quite simply, in an ideal world, graphics cards would be infinitely fast at rasterizing, so resolution could also be infinite and we wouldn't have to worry about performance. In our imperfect world, however, each pixel to be drawn costs computing time. This computing time passes solely because of or in the GPU. While the graphics card struggles with the pixels, the processor is already preparing the next instructions and packs them into a strictly limited queue. The consequences of this interaction are clear: If the graphics card takes too long (-> GPU limit), the processor twiddles its thumbs. This would have fatal consequences in a processor test, because suddenly you are no longer testing the throughput of the processor, but that of the installed graphics card. CPU tests in the CPU limit are therefore the only logical and sensible thing to do.
Since we can't prevent games from generating a pixel grid for display on the screen at the end of all calculations, we have to make sure that the generation of the pixel grid, with which the processor has nothing on the heatspreader, doesn't slow down the action. We ensure this by using the lowest common denominator of 1,280 × 720, which is a cuddly 921,600 pixels in a 16:9 aspect ratio. To be on the safe side, the fastest possible graphics card is still used.
The penny still hasn't dropped? Maybe after another numbers game. If we were to test processors in the WQHD resolution, the graphics card would be confronted with 3,686,400 pixels - a factor of 4 compared to 1,280 × 720. Consequently, we would have to use a four times faster graphics card to achieve the same time during rasterizing and thus not slow down the CPU. Not to mention Ultra HD. Thus, we would need a graphics card that is 4× as fast as a Titan RTX or Geforce RTX 2080 Ti OC at this point. Since we haven't received any promises for test samples from time machines so far (only on April 1 something like that happens from time to time), this idea falls away.
Conclusion: 720p, reduced internally if necessary.
Long story short: We stick to 1,280 × 720 pixels for the game tests for good reasons. We even reserve the right to reduce this resolution further with the help of internal scaling controls if we see a partial graphics limit on modern super processors. In return, we leave all other effects active. This is because all effects generate drawcalls, which first the processor and then the graphics card have to take care of. A lot of effort to only test what we want to test. So that you can find out how fast a processor really is in our processor tests. And then there are the graphics card tests, where what has been said applies just as much - with the difference that it is only about pixels here and not the CPU performance underneath.
.gif "sm_B-) :-)")
Du hast einfach nur -dx12 an die Verknüpfung gepackt, oder?
