Performance Characterization of SPEC CPU 2026 on AMD EPYC 9755 Processor
summary
The gist
SPEC CPU 2026 is the first major update to the industrystandard CPU benchmark suite since 2017 This paper presents the first microarchitecture based performance characterization of the new suite…
In short
This study characterized SPEC CPU 2026 performance on AMD EPYC Zen 5 using a multi-lens approach across pipeline efficiency, control flow, and cache pressure. It found three distinct workload clusters and revealed that scale-dependent bottlenecks like SMT contention only appear under full system utilization.
Key concepts
- Frontend Control-Flow-Dominated Workloads
- These workloads are bottlenecked by the branch predictor's ability to handle control flow decisions, not just accuracy. They stress the pipeline's throughput and how well it manages conditional jumps and branches.
- High-Efficiency Compute Workloads
- These tasks show excellent utilization of execution resources but suffer when multiple threads compete for Shared Multi-Threaded (SMT) resources at scale. This contention reduces overall performance as more instances run concurrently.
- Scale-Dependent Effects
- Performance bottlenecks, such as SMT dispatch contention and L3 cache interference, are not present in single-instance tests. They only emerge when the entire system is fully utilized, making them crucial for understanding real-world multi-tenant server behavior.
Terminology used across episodes
This episode discusses
The paper
Performance Characterization of SPEC CPU 2026 on AMD EPYC 9755 Processor · Read on arXiv
Advanced Micro Devices, Inc. · IEEE
DOI: 10.1109/IISWC71020.2026.00022
Transcript
Introduction to the show: ident: Computer Science. The day in computer science: software, systems and theory on arXiv.
Tom: We're looking at the paper: "Performance Characterization of SPEC CPU 2026 on AMD EPYC 9755 Processor".
Title and authors: Tom: So we're looking at this paper titled "Performance Characterization of SPEC CPU two thousand twenty-six on AMD EPYC nine thousand seven hundred fifty-five Processor" <ref:2609.01527#pg1,Performance Characterization of SPEC CPU 2026 on AMD EPYC 9755 Processor>. It seems they’ve done the first microarchitecture based performance characterization for this new SPEC suite, and they’ve also done the first SPEC CPU characterization study on the Zen five architecture itself <ref:2609.01527#pg1,the first SPEC CPU characterization study on>.
Jane: That sounds like a big deal because this suite is brand new, released in May two thousand twenty-six and they are testing it on the AMD EPYC Zen five processor <ref:2609.01527#pg1>. It's important to know that this isn't just some quick look; they used a multi-lens methodology covering things like pipeline efficiency, control flow behavior, cache hierarchy pressure, and instruction mix.
Lu: And what’s really interesting is that they introduced scale analysis by comparing single-copy runs to full-system behavior. That’s crucial because those system-level bottlenecks are often invisible in conventional characterization studies <ref:2609.01527#pg1>.
Meng: I'm thinking about what that means for us on the ground—if you only run one instance, you see one thing, but when you scale up to five hundred instances, things change completely <ref:2609.01527#pg3>.
Lalam: The paper’s main finding is that the suite shows substantial behavioral diversity and they found three distinct behavioral clusters in the workloads <ref:2609.01527#pg1>.
Tom: Three clusters? What are those clusters, Jane? Are we talking about different types of software that stress the chip differently?
Jane: They are frontend control-flow-dominated workloads, which stress branch predictor throughput rather than accuracy. Then you have high-efficiency compute workloads that suffer from SMT contention when scaled up. And finally, there are memory bandwidth-bound floating point workloads with poor L3 filtering even when only one copy is running <ref:2609.01527#pg1>.
Lu: That clustering helps us understand *why* performance varies across the suite, because it separates the bottleneck type from just looking at a single score <ref:2609.01527#pg3>.
Meng: So for production deployment, that tells me if I’m running a workload that fits cluster one, I should focus my optimization efforts on branch prediction hardware rather than something else entirely <ref:2609.01527#pg1>.
Tom: Exactly. Now they talk about scale-dependent effects, which is where the real surprises are for me. They found that things like SMT dispatch contention and L3 capacity interference only show up when you run at full system utilization <ref:2609.01527#pg1>.
Jane: That’s a key piece of information because it means we can’t just look at single-copy data to guess how the system will perform under heavy load <ref:2609.01527#pg3>.
Lu: The paper shows that SMT dispatch contention among the most dispatch efficient workloads causes a throughput reduction of about nineteen point three percent when you run at five hundred copies, which is a significant drop <ref:2609.01527#pg1>.
Meng: Nineteen point three percent sounds like a lot of lost work if you’re running many concurrent AI inference instances <ref:2609.01527#pg3>.
Lalam: And they give an example, showing that the highest SMT contention occurs in workloads like seven hundred fifty <ref:2609.01527#pg2>.sealcrypto r and seven hundred thirty-six <ref:2609.01527#pg2>.ocio r when running at five hundred copies, with IPC dropping from two point seven one down to zero point four two <ref:2609.01527#pg1>.
Tom: That’s a pretty concrete number showing the severe throughput degradation under that kind of pressure <ref:2609.01527#pg3>.
Jane: It really highlights how memory pressure and SMT contention can interact in ways that aren't obvious from just looking at one benchmark score <ref:2609.01527#pg3>.
Lu: Architecturally, the most salient result they point to is not one specific cluster, but the scale-dependence itself. The effects that shape full system behavior—like SMT dispatch contention and shared L3 capacity interference—are absent at single-copy runs and only emerge when you hit full utilization <ref:2609.01527#pg1>.
Meng: That’s a lot of context for production engineers, because it means we need to design around that full system pressure rather than just optimizing for the best single-thread performance <ref:2609.01527#pg3>.
Tom: So, specifically for ML inference on EPYC, they suggest keeping those inference instance working sets within a single CCD’s thirty two megabyte L3 cache to avoid the pipeline inefficiency that happens when five hundred instances compete for that shared capacity <ref:2609.01527#pg3>.
Jane: That’s a very practical suggestion for deploying AI models on this hardware, focusing on keeping the working set local to minimize contention <ref:2609.01527#pg3>.
Lu: It points toward workload partitioning and placement strategies guided by those three behavioral clusters we talked about earlier <ref:2609.01527#pg1>.
Meng: If I’m deploying a large model, I need to figure out if it falls into the compute cluster or the memory bound cluster so I can manage its resource demands better <ref:2609.01527#pg3>.
Lalam: And they also suggest looking at compiler sensitivity by comparing GCC with vendor optimized toolchains like AOCC, because that choice itself affects how the benchmark behaves <ref:2609.01527#pg3>.
Tom: That’s interesting because we always have to consider the toolchain we are using when training and shipping models <ref:2609.01527#pg3>.
Jane: So, what does this mean for the future of this research? What should the next studies look at?
Lu: Future work should explore power efficiency across the entire benchmark suite, especially since there are distinct microarchitectural behaviors observed between integer and floating point workloads <ref:2609.01527#pg1>.
Meng: Power efficiency is always a concern for me when I’m trying to keep operational costs down at scale <ref:2609.01527#pg3>.
Lalam: And the cache contention patterns they identified motivate noisy-neighbor analyses, which are essential for understanding VM isolation and cloud multi-tenancy <ref:2609.01527#pg3>.
Tom: That makes sense. If we can isolate those noisy neighbors, we might be able to make better guarantees about performance in a shared environment <ref:2609.01527#pg3>.
Jane: So, to wrap up this discussion on the "Performance Characterization of SPEC CPU two thousand twenty-six on AMD EPYC nine thousand seven hundred fifty-five Processor," it shows that understanding the system-level effects at full utilization is as important as looking at single-copy behavior <ref:2609.01527#pg1>.
Lu: We established that the three behavioral clusters—control flow dominated, high efficiency compute, and memory bandwidth bound—are key to understanding how the Zen five architecture responds to different types of software <ref:2609.01527#pg1>.
Meng: And for deployment right now, it means we have specific strategies for managing L3 capacity interference and SMT contention based on which cluster our workloads fall into <ref:2609.01527#pg3>.
Lalam: We also found that the choice of compiler, like using GCC versus AOCC, is a variable that directly impacts the benchmark characteristics we measure <ref:2609.01527#pg3>.
Tom: So, to summarize this SPEC CPU two thousand twenty-six characterization study on AMD EPYC nine thousand seven hundred fifty-five Processor, the big picture is that performance isn't just about raw speed on a single core but how the entire system behaves when you push it to its limits <ref:2609.01527#pg1>.
Jane: And what this means for us is that we need to start thinking about resource management and workload placement based on these identified clusters and scale effects <ref:2609.01527#pg3>.
Lu: We’ll continue looking at how power efficiency interacts with these different workload types in future studies <ref:2609.01527#pg1>.
Meng: And I'm going to keep pushing for the practical deployment advice, focusing on how we can mitigate those L3 capacity issues when we run large AI models <ref:2609.01527#pg3>.
Lalam: It’s a solid foundation for understanding the Zen five architecture under real-world SPEC CPU two thousand twenty-six workloads, and that’s what this paper is about <ref:2609.01527#pg1>.
The paper's summary: Tom: So we’re looking at the summary of this paper on SPEC CPU two thousand twenty-six performance on AMD EPYC Zen five and it boils down to a few major things <ref:2609.01527#pg1>.
Jane: It says they did this first microarchitecture based performance characterization for the new benchmark suite, and also the first SPEC CPU characterization study on that specific Zen five chip <ref:2609.01527#pg1>.
Tom: Right, it sets an empirical foundation for architectural research and design decisions for next generation datacenter processors <ref:2609.01527#pg2>.
Jane: They used a multi-lens methodology spanning pipeline efficiency, control flow behavior, cache hierarchy pressure, and instruction mix to analyze both the SPECrate and SPECspeed suites <ref:2609.01527#pg1>.
Tom: And the big finding is that there’s substantial behavioral diversity across the suite <ref:2609.01527#pg1>.
Jane: They found three distinct clusters in those workloads <ref:2609.01527#pg3>.
Tom: What are those clusters, Jane? Are we talking about different types of software that stress the chip differently?
Jane: One is frontend control-flow-dominated integer workloads, which stress the branch predictor throughput rather than accuracy <ref:2609.01527#pg3>.
Tom: So those are the ones that test how good the branch predictor is, not just how right it is <ref:2609.01527#pg3>.
Jane: Then you have high-efficiency compute workloads that get exceptional dispatch utilization but suffer from SMT contention when scaled up <ref:2609.01527#pg3>.
Tom: So those are the workloads that seem efficient on paper, but they choke when you try to run them all together <ref:2609.01527#pg3>.
Jane: And finally, there are memory bandwidth-bound floating point workloads with poor L3 filtering even when only one copy is running <ref:2609.01527#pg3>.
Tom: That's a lot of different bottlenecks happening depending on what you run, right?
Jane: Exactly. And the scale analysis part was really important because they compared single instance behavior to full system behavior <ref:2609.01527#pg3>.
Tom: Because that’s where the system-level bottlenecks show up, which aren't visible in a one copy run <ref:2609.01527#pg3>.
Jane: They found scale-dependent effects, like SMT dispatch contention and L3 capacity interference, only emerge when you run at full utilization <ref:2609.01527#pg3>.
Tom: So if you only run one instance, those problems aren't there <ref:2609.01527#pg3>.
Jane: But when you hit full utilization, things degrade significantly. For example, SMT dispatch contention among the most efficient workloads causes a throughput reduction of about nineteen point three percent at five hundred copies <ref:2609.01527#pg1>.
Tom: Nineteen point three percent is a lot of lost work if you’re running many concurrent AI inference instances <ref:2609.01527#pg3>.
Jane: And they gave an example where IPC drops from two point seven one down to zero point four two in some cases when running at five hundred copies <ref:2609.01527#pg3>.
Tom: That really shows the severe throughput degradation under that kind of pressure <ref:2609.01527#pg3>.
Jane: Architecturally, the paper points out that the most important result isn't one specific cluster bottleneck, but how those effects change as you scale up <ref:2609.01527#pg1>.
Tom: So it’s less about optimizing one thing and more about managing the whole system under load <ref:2609.01527#pg3>.
Jane: They suggest that for ML inference on EPYC, keeping those inference instance working sets within a single CCD’s thirty two megabyte L3 cache helps avoid the pipeline inefficiency when five hundred instances compete for shared capacity <ref:2609.01527#pg3>.
Tom: That’s a very practical suggestion for deploying AI models on this hardware, focusing on keeping the working set local to minimize contention <ref:2609.01527#pg3>.
Jane: It also suggests that workload partitioning and placement strategies guided by those three behavioral clusters are important <ref:2609.01527#pg3>.
Tom: And they also mention that the choice of compiler, like using GCC versus AOCC, is a variable that directly impacts the benchmark characteristics we measure <ref:2609.01527#pg3>.
Jane: So to sum up this SPEC CPU two thousand twenty-six characterization study on AMD EPYC nine thousand seven hundred fifty-five Processor, the big picture is that performance isn't just about raw speed on a single core but how the entire system behaves when you push it to its limits <ref:2609.01527#pg1>.
Tom: And what this means for us is that we need to start thinking about resource management and workload placement based on those identified clusters and scale effects <ref:2609.01527#pg3>.
Jane: We’ll continue looking at how power efficiency interacts with these different workload types in future studies <ref:2609.01527#pg1>.
The paper's improvements: Tom: So the paper doesn't just stop at describing what’s wrong; they suggest several ways to fix those issues <ref:2609.01527#pg3>.
Jane: They point out that for AI systems, we should implement scale-aware resource management that accounts for SMT dispatch contention, which they call a system-level bottleneck invisible to conventional characterization <ref:2609.01527#pg3>.
Tom: So it’s not just about the chip design itself, but how we use it in production environments <ref:2609.01527#pg3>.
Jane: They also suggest using workload partitioning and placement strategies guided by those three behavioral clusters we talked about earlier—control flow dominated, high efficiency compute, and memory bandwidth bound workloads <ref:2609.01527#pg1>.
Tom: That means if I'm running an AI model on EPYC Zen five, I should be looking at which cluster it falls into to manage its resources better <ref:2609.01527#pg3>.
Jane: And for ML inference deployments specifically, they give a concrete tip: keep the inference instance working sets within a single CCD’s thirty two megabyte L3 cache <ref:2609.01527#pg3>.
Tom: That’s a very specific number to target to avoid that drop in Retiring from forty-three point zero percent down to thirteen point two percent when they compete for shared capacity <ref:2609.01527#pg3>.
Jane: So it’s about isolating the workload so it doesn't interfere with other instances <ref:2609.01527#pg3>.
Tom: They also look at the toolchain choice, suggesting we systematically compare GCC with vendor optimized toolchains like AOCC because that choice itself is a performance variable for Zen microarchitectures <ref:2609.01527#pg3>.
Jane: That makes sense, because the way you compile your code can really change how the benchmark behaves <ref:2609.01527#pg3>.
Tom: It’s like if you use a different engine to run the same car, it won't perform exactly the same way <ref:2609.01527#pg3>.
Jane: The authors also look at power efficiency across the whole suite as future work, especially since there are distinct microarchitectural behaviors between integer and floating point workloads <ref:2609.01527#pg1>.
Tom: Power efficiency is always a concern for me when I’m trying to keep operational costs down at scale <ref:2609.01527#pg3>.
Jane: And the cache contention patterns they identified also motivate noisy-neighbor analyses, which are essential for understanding VM isolation and cloud multi-tenancy <ref:2609.01527#pg3>.
Tom: If we can isolate those noisy neighbors, we might be able to make better guarantees about performance in a shared environment <ref:2609.01527#pg3>.
Jane: So this paper moves us from just identifying problems to suggesting actionable deployment strategies based on workload type and resource management <ref:2609.01527#pg3>.
Conclusion: Tom: So to wrap up this paper on "Performance Characterization of SPEC CPU two thousand twenty-six on AMD EPYC nine thousand seven hundred fifty-five Processor," it shows that performance isn't just about raw speed on a single core but how the entire system behaves when you push it to its limits <ref:2609.01527#pg1>.
Jane: It’s a lot of context for production engineers, because we need to start thinking about resource management and workload placement based on those identified clusters and scale effects <ref:2609.01527#pg3>.
Tom: Exactly. We need to move beyond single-score thinking when deploying AI systems <ref:2609.01527#pg3>.
Jane: And the future work they suggest is looking at power efficiency across the whole suite, especially since there are distinct microarchitectural behaviors between integer and floating point workloads <ref:2609.01527#pg1>.
Tom: Power efficiency is always a concern for me when I’m trying to keep operational costs down at scale <ref:2609.01527#pg3>.
Jane: And the cache contention patterns they identified motivate noisy-neighbor analyses, which are essential for understanding VM isolation and cloud multi-tenancy <ref:2609.01527#pg3>.
Tom: If we can isolate those noisy neighbors, we might be able to make better guarantees about performance in a shared environment <ref:2609.01527#pg3>.
Jane: It’s a solid foundation for understanding the Zen five architecture under real-world SPEC CPU two thousand twenty-six workloads <ref:2609.01527#pg1>.
Tom: We established that the three behavioral clusters—control flow dominated, high efficiency compute, and memory bandwidth bound—are key to understanding how the Zen five architecture responds to different types of software <ref:2609.01527#pg1>.
Jane: And for deployment right now, it means we have specific strategies for managing L3 capacity interference and SMT contention based on which cluster our workloads fall into <ref:2609.01527#pg3>.
Tom: So to summarize this SPEC CPU two thousand twenty-six characterization study on AMD EPYC nine thousand seven hundred fifty-five Processor, the big picture is that performance isn't just about raw speed on a single core but how the entire system behaves when you push it to its limits <ref:2609.01527#pg1>.
Jane: And what this means for us is that we need to start thinking about resource management and workload placement based on those identified clusters and scale effects <ref:2609.01527#pg3>.
Tom: We’ll continue looking at how power efficiency interacts with these different workload types in future studies <ref:2609.01527#pg1>.
Jane: And I'm going to keep pushing for the practical deployment advice, focusing on how we can mitigate those L3 capacity issues when we run large AI models <ref:2609.01527#pg3>.
Lu: If you look at the ideas in this paper, what would change if those scale-dependent effects weren't there? It would simplify things immensely for deployment decisions <ref:2609.01527#pg1>.
Meng: I just want to know if these suggestions translate into something that actually runs reliably on a production cluster without needing a custom monitoring tool like denet <ref:2609.01527#pg3>.
Lalam: I am confident in my answer; the paper is sure that managing SMT contention and L3 interference based on the workload type is the right direction for this architecture <ref:2609.01527#pg3>.
Tom: Alright, that’s our time on this one. We've covered how to read these numbers and what they mean for deployment <ref:2609.01527#pg1>.
Jane: Next up, we’ll be looking at the formal verification of an out-of-order multiprocessor against an in-order weak-memory ISA <ref:2607.18506#pg2>.
More episodes
- 2505.16254-Human-AI Writing as Distributed Cognition: Reassessing Collaborative Writing Theories in the Age of LLMs
- 2506.10913-Choreographic Quick Changes: First-Class Location (Set) Polymorphism
- 2507.14812-A Black-Box Approach for Exogenous Replenishment in Online Resource Allocation
- 2507.15448-Frames over finite fields with respect to the Galois inner product and their connections to self-orthogonal and LCD codes
- 2508.21572-NewsReX: An Open-Source Multi-Framework for Neural News Recommendation
- 2509.17028-Impact of Packetization on Network Calculus Analysis
- 2510.17342-AoA Services in 5G Networks: A Framework for Real-World Implementation and Systematic Testing
- 2511.04088-Efficient and rate-optimal list-decoding in the presence of minimal feedback
- 2511.17264-Notes on Stack Machines and Quantum Stack Machines
- 2601.15318-On the closest balanced game