Performance Testing Intel’s Core i9-9980XE 18-core CPU In Linux

We’ve been hugely focused on Windows benchmarks lately, so it’s about time we spice things up and get another collection of Linux tests together. The last time we tackled CPU performance in Linux was with the launch of Intel’s Core i9-9900K. That article prefaced the Windows one, so it’s a bit of a parallel that we’re kicking off our i9-9980XE coverage the same way (Windows coverage will come soon.)

With its 36 threads, 7980XE owners won’t need to begrudge the newer chip much. What Intel’s brought to the table with the 9980XE is more 14nm refinement, improved thermal interface material under the integrated heat spreader (for improved temperatures and overclocking), and naturally, some clock boosts.

The 7980XE topped out at 4.2GHz one-core Turbo, whereas the 9980XE bumps that to 4.4GHz. Likewise, the Turbo Boost Max (best core) peak increases 100MHz, to 4.5GHz. These may be seemingly minor gains, but every little bit helps when you’re treating your CPU like a workhorse.

At the moment, our Linux testing is simple in the grand scheme, but it will evolve over time, notably to include more GPU-related tests, including gaming and workstation. As always, we’re open to suggestions if you think we’re missing something important.

Without wasting too much time, here’s the hardware involved in this latest round of testing:

This may be the quickest we’ve produced results for a new Linux release before, with Ubuntu 19.04 having launched around the same time we were preparing to begin testing. Our configuration is pretty out-of-the-box, with required software installed on top of the default desktop, sleep disabled, and the performance profile enabled with this command:

echo performance | tee /sys/devices/system/cpu/cpu*/cpufreq/scaling_governor

A big chunk of our Linux benchmarking is done with the help of the Phoronix Test Suite, which we’d recommend anyone give a try if they wish to embark on a voyage to traverse a sea of available tests.

Compile

The current kernel compile champion for the desktop is AMD’s Ryzen Threadripper 2990WX, but the i9-9980XE, with fourteen fewer cores, manages to sit just inches behind. The 28-core Xeon 3175X would undoubtedly top the chart here, finally giving us that elusive sub-30 second result.

With the ImageMagick compile, Intel grows a bit stronger, allowing the 9980XE to place ahead of the 2990WX with the same kind of performance delta we saw AMD take with the kernel compile test.

Blender Cycles Rendering

When AMD first talked about its Threadripper series, it had a few applications in mind when it talked about performance increases. Blender was one of them, and we can see why from charts like these. Thread count matters a lot for two things: bed sheets, and Blender.

For those interested, we recently posted an in-depth look at Blender 2.80 performance in Windows, which includes GPU and heterogeneous rendering performance. Our Linux Blender tests will evolve over time, as time allows us to craft better tests.

Ray Tracing

Blender’s Cycles renderer is good not only at tracing rays, but delivering extremely scalable results. The same can be said about most ray tracers, such as the three above. These particular options are generally antiquated, or have evolved into other projects, but they still act as a good raw performance test of tracing capabilities, and they all seem to agree on scaling, with core count holding great importance.

HandBrake

HandBrake fares a bit better in Linux with many core processors than Windows, but at the top-end, it takes a lot of extra horsepower to exhibit a little gain. AMD’s 32-core chip beats out the 9980XE in the x264, but by only three seconds, despite having so many more cores. Intel’s multi-media prowess gains it a lead in the x265 test, mimicking some H.265 tests we’ve done with some Windows encoders (eg: Adobe Media Encoder, MAGIX Vegas Pro).

If anything should be clear by now, it’s that the top of the performance stack can be crowded, but it doesn’t take much moving down to make a significantly detrimental difference in performance. We questioned whether we even wanted to include the bottom Ryzen APUs, but felt it would provide a more useful baseline. It helps to really understand how software performs both with high-performing, and also modest processors.

Scientific

Using our processors for science has forever been a thing, and it’s always benefited from faster hardware. With today’s many core processors, the performance delivered is simply staggering, especially when you compare their effectiveness compared to the bottom-half of the stack. Clearly, very few people are analyzing scientific data on a mainstream processor, and to some who work in such fields, even a 32-core desktop processor may be lacking.

Nonetheless, AMD struck hard in the LavaMD test, with the 2990WX placing well ahead of the 9980XE, and likewise, so does the 2970WX. Intel then closed the gap in the fluid dynamics test, once again proving that team blue hits the gym often to improve its core strength.

OpenSSL Encryption

Compression

In an encryption battle, both processor optimizations and core counts can equally make a big difference, and we can see a bit of that here with the 9980XE placing not too far behind the 2990WX, despite its leaner core counts. For the respective price ranges across the board, all of the chips here perform very well in encryption, thanks to continued performance focus from AMD and Intel. But, naturally, the higher-end you go, the more you will benefit.

We actually took good advantage of the 9980XE’s compression strength last week when we archived a lot of data for our internal test suite when using the ultra compression level. This is a usage scenario many people don’t think about until they actually need to do batch compression, at which point it can feel worse than waiting for a render to complete.

Chess Engine

A chess engine benchmark has got to be about as niche as it can get, but the fact is, they’ve been inherently designed to scale like crazy, and we see a great example of that here. Contrary to some belief we’ve come across, chess engines are not just benchmarks – some are really used by chess fanatics who want to play against realistic, challenging, and scalable competition.

Think this testing is a waste of time? That’s what we call a rook mistake!

Memory

For those with the heaviest memory bandwidth needs, you’ll absolutely want a 4-channel rig whether it’s AMD or Intel. That said, the results here are a little sporadic, with AMD’s top-end chips placing far lower than we’d expect, and the last-gen 10-core from Intel proving the strongest – all despite each respective series of chips being tested in the same machine.

Intel seems to have a clear bandwidth advantage here, with some of the top AMD chips experiencing some truly odd performance, which is interesting since Linux is usually our “Threadripper Regression Free Zone”.

Kernel Scheduling

“Hackbench” might sound like a lame attempt at a cool benchmark name, and perhaps it is, but it’s representative of an important piece of performance: kernel scheduling. The faster a chip can handle duties it’s handed, the more responsive and efficient a system will be.

Kernel scheduling will happen quicker thanks to higher clock speeds, and will handle more tasks at once with extra cores, so those chips with the best of both worlds will reign supreme. In this case, that’s the Intel Core i9-9980XE we’ve been analyzing this entire article. The 2990WX falls not too far behind, largely fueled by its huge core advantage.

Final Thoughts

We recently updated our Linux testing suite a wee bit, making minor changes, but at the expense of dropping all single-threaded benchmarks – by accident. We hadn’t thought much about every single set of results being hugely optimized for core counts, which is unfortunate as there is a clear difference in those benchmarks, with Intel continuing its legacy of delivering high IPC and high clock speeds to give us the highest single-threaded performance of the bunch.

When it comes to many core processors, Intel’s proven to be the safer bet for those who want to avoid odd behavior that sometimes strikes Threadripper. Take our weird memory scaling in Linux as one example. Some of our Windows benchmarks have shown some strange scaling as well, but the situation is undoubtedly better in Linux.

When the choice is between Threadripper (2990WX, at $1,699) and Core X (9980XE, at $1,999), you have to ask yourself how much you value single-threaded performance, which encompasses most of your general use. Are you willing to sacrifice some of that to gain in core count and further decrease render times? To Intel’s chagrin, we’re sure, Threadripper happens to be very strong in many areas, but the company is lucky in that it’s not strong in every way, including one of the most important ones: single-threaded processing.

As mentioned before, we’re open for suggestions on Linux tests you think we should include. The next time we do a full round of testing, we’ll keep single-threaded tests in mind. We also have plans to evaluate more enterprise-esque solutions, but much more testing has to first be done to determine their usefulness.