{"id":509885,"date":"2026-06-25T04:42:10","date_gmt":"2026-06-25T04:42:10","guid":{"rendered":"https:\/\/www.newsbeep.com\/il\/509885\/"},"modified":"2026-06-25T04:42:10","modified_gmt":"2026-06-25T04:42:10","slug":"someone-changed-one-line-in-the-gcc-compiler-and-scored-a-12-improvement-on-modern-intel-and-amd-chips","status":"publish","type":"post","link":"https:\/\/www.newsbeep.com\/il\/509885\/","title":{"rendered":"Someone changed one line in the GCC compiler and scored a 12% improvement on modern Intel and AMD chips"},"content":{"rendered":"

Summary<\/p>\n

Adding 3 to GCC’s branch-misprediction scale makes it warier of branch mispredictions.<\/p>\n

SPEC CPU 2017 NAB test showed ~12% speedup on modern AMD and Intel CPUs.<\/p>\n

The change is due to arrive in GCC 17, coming in 2027.<\/p>\n

It has been a weird month for really small code adjustments that score noticeable performance wins. It was only a few days ago that we learned that someone modified three lines of code in the Linux kernel<\/a> and achieved a 5% storage speed boost because of it. Now, someone has stepped forward and claimed that a single line change in the GCC compiler added a 12% performance boost for modern AMD and Intel chips in a SPEC CPU 2017 benchmark.<\/p>\n

Adding 3 to a variable scored big wins for new AMD and Intel processors<\/p>\n

In all fairness, it was a very impactful addition of 3 <\/p>\n

\"An<\/p>\n

As spotted by Phoronix<\/a>, Intel software engineer Lili Cui has found a way to squeeze out more performance with minimal changes to the GCC compiler. The exact process Cui used to get this additional performance is a little complex, so let’s break it down.<\/p>\n

When a CPU runs code, it tries to “cheat” to boost its performance. When a CPU encounters a decision in the code (such as an if\/else statement), it ‘should’ wait for the calculations to tell it which road to take. However, with a process called “speculative execution,” the CPU predicts which way the program will take and begins processing the subsequent code ahead of time.<\/p>\n

It’s sort of like sending a text to your friend asking if they want to eat a burger or a pizza, then predicting they’ll want a burger and getting a patty on the grill. If you’re right, you can get the burger cooked faster and impress your friend with your speed. If you’re wrong, you have to stop, clean everything up, and cook a pizza instead. Similarly, an incorrect guess from the CPU means it has to go back to the decision and take the other path.<\/p>\n

This is called a “branch misprediction,” and Cui noticed<\/a> that performing them on modern CPUs costs more performance than people first assumed:<\/p>\n

Modern CPUs have deeper pipelines, making branch mispredictions more expensive. Increasing this cost encourages if-conversion, avoiding pipeline stalls from mispredicted branches.<\/p>\n

To fix this, Cui modified the line of code that defined the branch misprediction scale, which GCC’s internal code-generation math uses to gauge if it’s worth the risk to gamble on a branch. All Cui did was add 3 to the scale, and now the compiler is a lot warier about generating standard branching code. This makes it more likely to optimise the code another way, such as with a branchless sequence.<\/p>\n

Once done, Cui put their processors through a SPEC CPU 2017 benchmark called the 544.nab_r Nucleic Acid Builder (NAB), which calculates the physics and chemistry of molecules. Cui noted a 12% increase in performance for both Intel and AMD chips, as they spent less time backtracking and more time churning through code.<\/p>\n

It’ll be a while until we see this change, as it’s merged for GCC 17, releasing next year. However, it’s a cool story about how one little tweak can make a huge difference.<\/p>\n


\n \"The<\/p>\n

<\/a><\/p>\n

Related<\/p>\n

\t\t