SPECint Explained: What CPU Benchmark Scores Mean for Anomaly-Detection Workloads

The SPECint benchmark compares integer CPU throughput, but it leaves out I/O, ML inference and tail latency, which often decide time-to-detect.

SPECint Explained: What CPU Benchmark Scores Mean for Anomaly-Detection Workloads
Written by TechnoLynx Published on 11 Jul 2026

The SPECint benchmark is the integer half of SPEC’s CPU suite. Its score is a geometric mean of timed runs of real, compute-bound programs, and it measures the processor, the memory hierarchy and the compiler together. SPEC states that the suite is not meant to stress networking, Java libraries or the I/O system. So a SPECint score is a good reference point for comparing CPUs on integer compute performance, but not a measure of time-to-detect on a live telemetry stream.

The useful question isn’t “which CPU has the highest score?” It’s “which stages of my pipeline does this score describe at all?” Answer that first and a SPEC result becomes a good reference point for hardware selection. Skip it and you can end up buying more of the resource that was never the constraint.

What a SPECint Number Captures About a CPU, and What It Leaves Out

SPEC CPU 2017 “intentionally depends on” three things: the CPU chips, the memory hierarchy (caches and main memory) and the C, C++ and Fortran compilers with their optimisers. Candidate programs were chosen partly on whether they are compute bound, spending most of their time in the benchmark source and little in I/O and system services. Most of them come from real end-user applications rather than synthetic loops.

“SPECint” is shorthand for the integer suites. SPEC CPU 2017 has 43 benchmarks in four suites: SPECspeed 2017 Integer and SPECrate 2017 Integer with 10 benchmarks each, SPECspeed 2017 Floating Point with 10, and SPECrate 2017 Floating Point with 13. The floating-point suites are a separate measurement. Our guide to interpreting SPECfp floating-point scores covers that half.

SPEC CPU does not subsume production-oriented CPU benchmark suites. A characterisation study found that SPEC CPU 2026 is less vector-intensive than MLPerf and puts less pressure on the instruction front end than DCPerf. The authors concluded that it “remains more representative of general-purpose CPU behavior than ML-oriented inference behavior”. A SPECint number is therefore less representative of the stage that runs a neural model and does not stress network ingestion.

How Does SPECint Work, and What Does It Mean in Practice?

SPECint’s overall score is the geometric mean of per-benchmark ratios. For each benchmark, SPEC computes a ratio: the time on a reference machine divided by the time on the system under test. For SPECrate, that ratio is multiplied by the number of copies run, so a higher ratio always means more computing per unit of time. The CPU 2017 reference machine is a historical Sun Fire V490 with 2100 MHz UltraSPARC-IV+ chips. Because of how the maths works, two systems rank the same against each other whichever reference machine is used. Each benchmark runs two or three times, and SPEC takes either the median of three or the slower of two.

Two practical consequences follow. A geometric mean rewards being good across the board, so a CPU can post a strong headline while being weak on the one benchmark whose behaviour looks most like your workload. The per-benchmark ratios on the result page are worth more than the composite. Second, running each benchmark more than once is SPEC’s way to provide some assurance that results are repeatable. The score is built from the median or slower run time, not from the latency spread an on-call engineer feels.

Choosing the Right SPEC CPU 2017 Integer Figure for an Anomaly-Detection Server

Under SPECspeed, one copy of each benchmark runs and the result is time-based, so a higher score means a shorter time. SPECrate is a throughput metric: the tester chooses how many concurrent copies to run, and a higher score means more work per unit of time. The rules on threading differ too. Compiler parallelisation, through OpenMP or auto-parallelisation, is allowed for SPECspeed and forbidden for SPECrate. Workload sizes differ as well. In CPU 2017, SPECspeed benchmarks should fit in 16 GB and SPECrate benchmarks in 1 GB per copy. For the integer suites, speed versions run on average about twice the dynamic instructions of the rate versions.

Base and peak describe how the benchmarks were compiled. Base requires every module in a given language to use the same flags in the same order, and every published result must include it. Peak is optional and allows per-benchmark flags and feedback-directed optimisation, which base forbids. On SPECrate, base also fixes one copy count for every benchmark, while peak lets the tester pick a different count for each. SPEC describes base as the performance available to “a user who is interested in performance, but who prefers not to invest the time required for tuning of individual programs”.

Your situation Metric to read first Why
One server handling many independent telemetry streams or sites SPECrate2017_int_base Concurrent copies are the closest analogue to parallel streams
One stream where each scoring step sets the latency floor SPECspeed2017_int_base It measures how fast a single task finishes, with compiler parallelisation allowed
You build the scoring service with profile-guided, per-component tuning Peak, as an upper bound Peak assumes tuning effort you may not repeat in production
Comparing two vendors’ submissions Base only, same suite and generation Base is mandatory on every result, so it is always available like-for-like

For a multi-stream anomaly host, SPECrate2017_int_base is the honest starting figure. Treat peak as what the hardware can do once someone has tuned each benchmark, which is not what your Python feature extractors will get.

Reading a Published SPEC CPU 2017 Integer Result: A Worked Example

Take one published CPU 2017 integer rate result: a two-chip system tested by Dell Inc.. It reports SPECrate2017_int_base = 904 and SPECrate2017_int_peak = 931. Read the fields in this order:

  1. Configuration. The result lists 112 cores, 2 chips and 2 threads per core enabled, which comes to 224 hardware threads. SPEC results describe whole systems, not chips, and must be reproducible on the system described. Memory speed is performance-relevant, so check it as well.
  2. Dates. The test ran in December 2022, with hardware available from February 2023 and software from June 2022.
  3. Base against peak. Peak is 931 / 904 ≈ 1.03 times base, so the per-benchmark tuning added roughly 3% on this system (arithmetic on the reported figures).
  4. Per-thread figure. 904 / 224 ≈ 4.0 base points per hardware thread. This is a derived number, useful only for comparing against other results computed the same way. SPEC’s fair-use rules allow derived quantities like “per chip”, but the basis of any comparison must be stated.
  5. Per-benchmark table. The table lists copies, seconds and ratio for each benchmark under both base and peak. For SPECrate, “seconds” is the time from the start of the first copy to the end of the last.
  6. Notes and flags. This is where the result can collapse. On this page, SPEC records a ruling that the compiler applied a transformation tuned to the 523.xalancbmk_r / 623.xalancbmk_s code and dataset with “narrow applicability”. SPEC says it will no longer publish results using that optimisation, and keeps this one only for historical reference.
  7. Estimates. Performance metrics may be estimated, but every estimated number must carry “est.” or “estimated” next to it.

SPEC wants its benchmarks to reflect real-world performance, so an optimisation that helps only the benchmark is not reflective of the real world. The score depends on the software stack that produced it, and two results built with different compilers are partly comparing compilers.

Can I Compare SPECint Scores from CPU 2006, CPU 2017 and CPU 2026?

No, not directly. SPEC says there is no formula for converting CPU 2006 results to CPU 2017 and that comparing CPU 2017 results with anything other than other CPU 2017 results is not valid. It says the same about CPU 2017 and CPU 2026. Its fair-use rules forbid comparing results across major releases of the same benchmark. SPEC expects some correlation between generations, but “far from perfect”, because the code, data sets, hardware stressed, metric calculations and run rules all change.

The suites really do differ:

  • CPU 2006 had 12 SPECint tests and 19 SPECfp tests. SPEC retired it on 9 January 2018 and stopped accepting submissions. Our page on what SPECint 2006 measured covers that generation for anyone holding older procurement data.
  • CPU 2017 reused some CPU 2006 programs with new workloads or newer source code, so 505.mcf_r may behave differently from 429.mcf. Song et al. (HPCA 2018) found that more than 25% of CPU 2017 benchmarks fall outside the performance space covered by CPU 2006 programs. A counter-based ISPASS 2018 study measured integer IPC 4.7% lower on average than in CPU 2006.
  • CPU 2026 has 52 benchmarks, up from 43, and more than twice the lines of source code. Its integer rate and integer speed categories hold 14 and 13 benchmarks. Counting rate and speed variants as one workload, only 3 of 19 integer workloads (omnetpp, gcc, xz) carry over from earlier suites. SPECspeed Integer gained explicit parallelism, and its memory allowance grew from 16 GB to 64 GB.

CPU 2026 scores will also look smaller. Its reference machine, an Ampere eMAG system, scores 2.78 on SPECrate2017_int_base with a single copy, against the CPU 2017 reference’s 1.00 by definition. Sensitivity to the compiler shifts as well. Moving from gcc-13 to gcc-15 gave a 1.09× integer rate speed-up on CPU 2026, driven mainly by fewer instructions, while on CPU 2017 the instruction count fell by only 5.1%. If your shortlist mixes generations, re-source the numbers within one suite rather than scaling one into another.

How Does a SPECint Score Map to the Compute Profile of Different Anomaly-Detection Algorithms?

SPECint predicts the stages that look like its benchmarks: compute-bound integer code that fits SPEC’s memory limits (16 GB for SPECspeed, 1 GB per copy for SPECrate) and spends little time in I/O and system services. The detail of each algorithm’s compute demands belongs with machine learning algorithms for anomaly detection. The stage view below is enough to decide how much weight the score deserves.

Pipeline stage What usually limits it Does SPECint predict it?
Ingesting SCADA, historian or message-bus data Network and I/O No. SPEC CPU is not intended to stress networking or the I/O system
Windowing and feature extraction over many tags Memory bandwidth and cache behaviour Partly: SPEC CPU 2026 contains no workloads that mainly stress memory bandwidth
Rule logic, tree ensembles, branchy scoring Integer execution, branch prediction Mostly, which is SPECint’s home ground
Neural inference (autoencoders, sequence models) Vector units or an accelerator Weakly. SPEC is closer to general-purpose CPU behaviour than ML inference
Alert routing, deduplication, persistence Queueing, OS scheduling, storage No

I/O-bound stages sit outside what SPEC CPU stresses, and SPEC CPU 2026 contains no workloads that mainly stress memory bandwidth. A SPECint score says little about either kind of stage. If accelerator inference sits on the critical path, SPECint, a CPU-only measure, does not cover that stage. LynxBenchAI publishes measured results for AI hardware in its AI hardware directory, and those results, not a CPU composite, are the reference for choosing the inference device.

Why a Higher-SPECint CPU Can Still Detect Anomalies Later

Time-to-detect is a latency property, and the tail must be low as well as the median. For SPECrate, the reported seconds run from the start of the first copy to the end of the last copy. That measurement spans whole copies, not how long one urgent event waits in a queue.

The measured evidence on tail latency points elsewhere. In a SoCC 2014 study of multi-core servers, 99th-percentile latency rose tenfold between 50% and 95% utilisation. The authors traced tail inflation to background processes, request reordering by the OS scheduler, poor interrupt routing, CPU power-saving mechanisms and NUMA effects. With the combined fixes, including core isolation, scheduler changes and NUMA pinning, Memcached’s 99.9th-percentile latency at 75% utilisation fell from 5 ms to 32 µs. Dedicating a core to interrupts improved the tail at a possible cost to maximum throughput. That trade spends throughput, the very quantity SPECrate measures.

Fan-out makes this worse. Dean and Barroso (CACM 2013) describe a case where the 99th-percentile latency of a single random request is 10 ms, but the 99th-percentile latency for all requests to finish is 140 ms. An anomaly pipeline that joins features from many tags or sites before scoring is a fan-out, and its alert waits for the slowest branch. A CPU with more SPECrate throughput, run at high utilisation on an untuned kernel across two NUMA nodes, can therefore detect later than a smaller host run with headroom and pinned threads.

How Do You Turn a Benchmark Score into Node Count and Cost per Monitored Stream?

The score is a ratio relative to other systems. On its own it cannot produce a node count. A workable method has three parts.

First, measure the CPU time per stream on one reference node with the real pipeline, and split it by stage using the table above. Second, apply the SPECrate2017_int_base ratio between that node and a candidate only to the integer-bound share. If a fraction s of per-event CPU time is integer-bound and the candidate is r times the reference on that metric, the expected speed-up is 1 / ((1 − s) + s / r), Amdahl’s law applied to the score. With a small s, even a large r buys little. Third, set the utilisation ceiling from your tail-latency target, not from 100%, because the tail grows sharply as utilisation rises. Node count is then the streams multiplied by the per-stream CPU need, divided by usable capacity per node at that ceiling, and cost per stream follows from node cost.

Where those nodes sit and how they connect to existing systems is covered in integrating AI anomaly detection with SCADA and observability stacks. Whether the whole footprint pays for itself is the question of when AI anomaly detection earns its cost.

How Should I Validate a SPECint Number Against My Own Anomaly-Detection Workload Before Committing to Hardware?

SPEC positions its suite as a good reference point only when it matches the type of workload you care about. An anomaly pipeline rarely matches it end to end, so validation is the step that makes the number usable. A procedure that holds up:

  1. Pull the candidate CPUs’ results from one suite and generation, base metric, and check the notes for compiler rulings and “est.” markers.
  2. Profile your pipeline on available hardware and record the integer-bound share of CPU time per stage.
  3. Replay recorded telemetry at production stream counts and measure end-to-end time-to-detect at the 99th percentile, not the mean.
  4. Score detection quality on streaming data as well as speed. The Numenta Anomaly Benchmark (Lavin and Ahmad, 2015) gives a repeatable, open-source environment that rewards detecting anomalies as early as possible without false alarms.
  5. Repeat step 3 with the tuning applied (pinning, interrupt placement, NUMA-local memory) before comparing hosts, because the tuning can move the tail.
  6. Compare the measured gain between candidates with what the SPECint ratio predicted for the integer-bound share. A large gap means another stage is the constraint.

FAQ

Is It Better to Have More Cores or a Faster Processor for Anomaly Detection?

It depends on whether you run many independent streams or one latency-critical stream. More cores show up in SPECrate throughput, while single-task speed shows up in SPECspeed. For many-stream hosts we would read SPECrate first, as long as utilisation stays low enough to protect the tail.

Do SPEC CPU Results Include Power or Energy?

They can, but only optionally. Since CPU 2017 V1.1, power measurement is not required. Unlike performance metrics, energy metrics must not be estimated.