Measurements on an Intel Xeon E5-4657L v2 system, recorded on 2026-09-28.
The unchanged benchmark sources were built in an isolated directory.
Source checksums were verified after retrieving the results.

| Property | Value |
|---|---|
| CPU | Intel Xeon E5-4657L v2 @ 2.40 GHz, x86-64 |
| Topology | Four sockets, 12 cores per socket, two threads per core; 96 logical CPUs |
| Run affinity | Logical CPU 2, physical package 2; SMT sibling 50 |
| OS | Ubuntu 22.04.1 LTS; Linux 5.15.0-187-generic |
| Compiler | GCC 11.4.0, Ubuntu 11.4.0-1ubuntu1~22.04.3 |
| Flags | `-std=c++20 -O3 -DNDEBUG -march=native -fno-lto` |
| Native target | `-march=ivybridge -mtune=ivybridge` |
| Scalar extra flags | `-fno-tree-loop-vectorize -fno-tree-slp-vectorize` |
| Governor | `schedutil`, unchanged; no fixed frequency |
| Timing | Same 15-sample, 4,096-input, shuffled-case harness as the M4 run |

GCC 11 does not support C++26 mode. The header and benchmark use C++20
features, so they compiled without source changes. This is a different CPU
and compiler combination from the Apple Clang results; differences between
machines cannot be attributed solely to hardware.

Median nanoseconds per value:

| Operation | Normal optimization | Vectorization disabled |
|---|---:|---:|
| Runtime `/` | 3.414681 | 3.414225 |
| Literal `/ 3` | 0.353237 | 1.041806 |
| Precomputed `Divide` | 1.407824 | 1.405768 |

`Divide` achieved 2.43 times the throughput of runtime division in the normal
build, with 58.8% less time per value. Literal division achieved 9.67 times
the throughput. GCC generated scalar `idivl` for ordinary runtime division,
128-bit vector multiplication for constant division, and scalar multiply and
shift arithmetic for `Divide`. The class loop was not vectorized, which
explains its similar results across the two builds.

Construction-inclusive results, normal optimization, in nanoseconds per value:

| Values per batch | Runtime `/` | Construct once, then `Divide` |
|---|---:|---:|
| 1 | 4.910009 | 15.516331 |
| 4 | 3.536510 | 5.227608 |
| 16 | 3.364656 | 2.364968 |
| 64 | 3.424595 | 1.766425 |
| 256 | 3.420187 | 1.505613 |
| 1,024 | 3.414385 | 1.449324 |
| 4,096 | 3.414661 | 1.433737 |

Among the tested batch sizes, construction loses at one and four values and
wins from sixteen onward. That threshold depends on this harness, divisor,
compiler, and CPU. Timing includes a kernel call per batch and array loads
and stores; these are throughput measurements, not instruction latencies.

Both the release and address/undefined-behavior sanitizer builds passed
43,143,231 comparisons against built-in division. Each timed kernel and batch
size was also checked before calibration. Both timed suites ran sequentially,
pinned with `taskset -c 2`. Input initialization occurred after affinity was
set, so first-touch placement was local to that process's NUMA node.

- [Normal samples](auto-samples.csv), [summary](auto-summary.csv), [run log](auto-run.log).
- [Scalar samples](scalar-samples.csv), [summary](scalar-summary.csv), [run log](scalar-run.log).
- [Normal assembly](kernels-auto.s), [scalar assembly](kernels-scalar.s), [vectorizer report](vectorization.log).
- [Release correctness log](test-release.log), [sanitizer log](test-sanitized.log).
- [Machine metadata](metadata.json), [CPU description](lscpu.txt), [compiler](compiler.txt), [source hashes](source-sha256.txt).

To reproduce with GCC 11.4 on the Xeon system, copy `divide.hpp`,
`benchmark.cpp`, `benchmark_kernels.hpp`, `benchmark_kernels.cpp`,
`test_divide.cpp`, and [benchmark_linux.sh](../../benchmark_linux.sh) to a fresh
directory, then run:

```sh
bash benchmark_linux.sh 2 results
```

The runner accepts `DIVIDE_BENCH_CXX` for a specific GCC executable and
`DIVIDE_BENCH_STD` for the language mode. The recorded Xeon run used the
defaults, `g++` and `c++20`. It does not change system scheduling or power
settings; CPU affinity applies only to its child processes.