The AMD RX 580 8GB Performance Review

Editor-in-Chief

Share:

Test System & Setup

Processor: Intel i7 5960X @ 4.4GHz
Memory: G.Skill Trident X 32GB @ 3200MHz 15-16-16-35-1T
Motherboard: ASUS X99 Deluxe
Cooling: NH-U14S
SSD: 2x Kingston HyperX 3K 480GB
Power Supply: Corsair AX1200
Monitor: Dell U2713HM (1440P) / Acer XB280HK (4K)
OS: Windows 10 Pro

Drivers:
AMD Crimson ReLive 17.10.1030 B8
NVIDIA 381.65 WHQL

*Notes:

– All games tested have been patched to their latest version

– The OS has had all the latest hotfixes and updates installed

– All scores you see are the averages after 3 benchmark runs

All IQ settings were adjusted in-game and all GPU control panels were set to use application settings

The Methodology of Frame Testing, Distilled

How do you benchmark an onscreen experience? That question has plagued graphics card evaluations for years. While framerates give an accurate measurement of raw performance , there’s a lot more going on behind the scenes which a basic frames per second measurement by FRAPS or a similar application just can’t show. A good example of this is how “stuttering” can occur but may not be picked up by typical min/max/average benchmarking.

Before we go on, a basic explanation of FRAPS’ frames per second benchmarking method is important. FRAPS determines FPS rates by simply logging and averaging out how many frames are rendered within a single second. The average framerate measurement is taken by dividing the total number of rendered frames by the length of the benchmark being run. For example, if a 60 second sequence is used and the GPU renders 4,000 frames over the course of that time, the average result will be 66.67FPS. The minimum and maximum values meanwhile are simply two data points representing single second intervals which took the longest and shortest amount of time to render. Combining these values together gives an accurate, albeit very narrow snapshot of graphics subsystem performance and it isn’t quite representative of what you’ll actually see on the screen.

FCAT on the other hand has the capability to log onscreen average framerates for each second of a benchmark sequence, resulting in the “FPS over time” graphs. It does this by simply logging the reported framerate result once per second. However, in real world applications, a single second is actually a long period of time, meaning the human eye can pick up on onscreen deviations much quicker than this method can actually report them. So what can actually happens within each second of time? A whole lot since each second of gameplay time can consist of dozens or even hundreds (if your graphics card is fast enough) of frames. This brings us to frame time testing and where the Frame Time Analysis Tool gets factored into this equation.

Frame times simply represent the length of time (in milliseconds) it takes the graphics card to render and display each individual frame. Measuring the interval between frames allows for a detailed millisecond by millisecond evaluation of frame times rather than averaging things out over a full second. The larger the amount of time, the longer each frame takes to render. This detailed reporting just isn’t possible with standard benchmark methods.

We are now using FCAT for ALL benchmark results in DX11.

DX12 Benchmarking

For DX12 many of these same metrics can be utilized through a simple program called PresentMon. Not only does this program have the capability to log frame times at various stages throughout the rendering pipeline but it also grants a slightly more detailed look into how certain API and external elements can slow down rendering times.

Since PresentMon throws out massive amounts of frametime data, we have decided to distill the information down into slightly more easy-to-understand graphs. Within them, we have taken several thousand datapoints (in some cases tens of thousands), converted the frametime milliseconds over the course of each benchmark run to frames per second and then graphed the results. This gives us a straightforward framerate over time graph. Meanwhile the typical bar graph averages out every data point as its presented.

One thing to note is that our DX12 PresentMon results cannot and should not be directly compared to the FCAT-based DX11 results. They should be taken as a separate entity and discussed as such.

Understanding the “Lowest 1%” Lines

In the past we had always focused on three performance metrics: performance over time, average framerate and pure minimum framerates. Each of these was processed from the FCAT or Presentmon results and distilled down into a basic chart.

Unfortunately, as more tools have come of age we have decided to move away from the “minimum” framerate indication since it is a somewhat deceptive metric. Here is a great example:

In this example, which is a normalized framerate chart whose origin is a 20,000 line log of frame time milliseconds from FCAT, our old “minimum” framerate would have simply picked out the one point or low spike in the chart above and given that as an absolute minimum. Since we gave you context of the entire timeline graph, it was easy to see how that point related to the overall benchmark run.

The problem with that minimum metric was that it was a simple snapshot that didn’t capture how “smooth” a card’s output was perceived. It is easy for a GPU to have a high average framerate while throwing out a ton of interspersed higher latency frames. Those frames can be perceived as judder and while they may not dominate a gaming experience, their presence can seriously detract from your immersion.

In order to understand the RX 580’s path to inception you have to look back at the somewhat troubled but ultimately successful RX 480. When it was launched, I praised it for focusing on value; it was actually one of the first GPUs to cost less than $300 but provide excellent performance metrics in both 1080P and 1440P scenarios. Unfortunately there were some speed bumps placed along the way since we soon found the reference versions drew excessive power from the PCI-E slot and at least initially, availability was sketchy at best. Things quickly turned around with multiple driver releases and just a few months ago we discovered the RX 480 had become the card to buy, often beating out the GTX 1060 in key gaming benchmarks.

What the RX580 strives to do is further capitalize upon the wave of positive press its now-discontinued sibling received by providing more performance per dollar. To accomplish this AMD us utilizing the same Polaris 10 core we have all come to know and love but through the use of a more mature 14nm FinFET manufacturing process, they have been able to offer substantially increased core frequencies.

There is supposedly also more overclocking headroom for their board partners and end users to tap into. Not only could this positively impact overall value but it could also help AIBs expand their selections of pre-overclocked Polaris-based products.

The RX 580 isn’t the only GPU getting a brand new coat of paint either. Since it is based off of the same yet slightly cut down version of the Polaris 10 core, the RX 470 will be making way for the new RX 570. This review will focus on the RX580 since my RX 570 sample arrived a bit late and with the Easter weekend upon me, there just wasn’t the time to properly execute.


The only other area where the newer Polaris products differentiate themselves from the outgoing cards is within their power consumption algorithms. The older Polaris-based GPUs featured a simple 2-state power system for their memory clocks wherein one was set for idle situations or extremely light workloads whereas the second state was reserved for higher performance situations.

Unfortunately this setup led to the memory entering its high performance mode when two displays were plugged in or when the video decode engine was required for simple online video playback. As a result power consumption in those two scenarios was much higher than it should have otherwise been.

To bypass this issue, AMD has now added a third power state for their onboard memory which sits between the idle and high performance “gears”. The byproduct of this move is lower power needs (and heat production) than before. It should also be noted that reduced single display idle power consumption numbers have been achieved by using that refined 14nm manufacturing process. There’s some hope this will allow standard idle numbers in our tests to register lower as well.

Looking at these numbers should completely eliminate the term “rebrand” from anyone’s mind, even though some will likely be disappointed that we’re still stuck on the original Polaris 10 architecture. Let’s call this a refresh, a refurbishment or a refinement but let’s not come down like a ton of bricks on AMD for sticking with a good thing.

At the top of the current Radeon stack is the RX 580 a card that sticks with the exact same 2304 Stream Processor layout as its predecessor but its Base and Boost frequencies receive a shot of adrenalin. That 1340MHz Boost clock should be easily achievable by the majority of cards since this time around AMD isn’t launching a reference version per se. Rather, board partners will be free to use their own heatsinks so we won’t have to worry about a poor-performing blower style cooler messing with results.

On the memory front all remains the same. Even though there are higher GDDR5 speed bins available these days, AMD has chosen to largely avoid them in an effort to reduce overall board costs. Another thing that should be mentioned is the return of a 4GB card. While the RX 570 will be pulling double duty by competing against the GTX 1060 3GB and GTX 1050Ti, AMD’s intent for the 4GB version this time around is for it to bridge the gap between NVIDIA’s 3GB and 6GB SKUs.

Moving a bit lower in the chart and we come up against two points that will likely prove to be the most controversial. The first of these is power consumption. While there are the minor revisions to Polaris which reduce bottom-end efficiency, there’s no escaping the fact that higher frequencies lead to increased power needs. As a result, the RX 580’s typically board power hovers around the 185W mark while board partners’ versions could top 200W. Given the RX 480’s original 150W rating was hotly debated from day one, this shouldn’t come as any surprise.

Pricing is also something I need to discuss since the RX 480’s $240 MSRP hasn’t budged since its launch. This time around I went to the source –that being board partners- since they’re ultimately the ones who set retail pricing whereas AMD’s numbers are simply a “guidance”.

As it turns out come launch you should be able to find reference spec’d cards for anywhere between $230 and $240USD. Finding those few $ Meanwhile overclocked versions will range from $260 upwards to $280USD. Whether or not there will be many cards available at the $230 mark remains to be seen but I have my fingers crossed.

The RX 570 on the other hand is an interesting little card. Not only does it sport massively increased frequencies over the RX 470 but it also sports a boost to memory frequencies. This should allow AMD’s new $170 GPU to open up a huge lead against the GTX 1050Ti but it also costs about $20 more than the NVIDIA card. Also of note is that the 570 will also be available in 8GB form for about $190.

Moving on to the subject of this review and I have a bit of a yin and yang situation for you. A bit before launch it came to our attention that AMD was seeding cards with their highest speed bin to reviewers. Typically that isn’t a problem since I would also be able to compare it against a typical reference-spec’d card to give a proper idea of what the overall competitive landscape looks like.

That wasn’t meant to be since the only sample I received was a Sapphire RX 580 Nitro+ Limited Edition which will retail for $280USD. Now granted, this card runs at a nominal speed of 1410MHz and has a secondary BIOS which pushes it even further to 1450MHz (for testing I used the default BIOS) but the optics of price become a huge issue. Remember, this is a whole $50 over AMD’s SRP. That may not sound like much but in this segment it is a significant premium.

I reached out to other board partners and in rode XFX at the last minute with their RX 580 GTS XXX Edition a card that has a price of just $240 but boasts close-to-reference speeds (the core is overclocked just 26MHz to 1366MHz) and pricing. With this we can actually get an almost-true apples to apples comparison against a bone stock RX 480 and GTX 1060 Founders Edition. My opinion wouldn’t be clouded by the specter of a $280 price either. For the fun of it I’m also throwing in an EVGA GTX 1060 6GB Superclocked card.

Right now it looks like the RX580 will be an extremely appealing replacement for the RX 480. Not only does it bring more performance to the table but pricing hasn’t increased by any appreciable amount. Meanwhile, NVIDIA doesn’t have anything in their lineup that can effectively compete against this initiative other than their upcoming GTX 1060 6GB 9Gbps edition. So could this finally be a convincing segment win for AMD? Let’s find out.

Posted in

Latest Reviews

Scroll To Top