⏱️ Lectura: 11 min
An Intel chip ran the same benchmark used by Top500 supercomputers and beat a laptop with Apple Silicon in energy efficiency: 6.21 versus 5.38 Gflops per watt. The test was run by engineer and YouTuber Jeff Geerling with a Dell XPS 13 and a MacBook, and he published the full results on GitHub so anyone can repeat them.
📑 En este artículo
For almost six years, since Apple launched the M1 in 2020, Apple Silicon’s energy efficiency advantage over Intel was almost always explained by the ARM architecture. The new Core 5 320 running inside the Dell XPS 13 calls that explanation into question.
TL;DR
- Jeff Geerling compared a Dell XPS 13 (Intel Core 5 320) against a MacBook with Apple Silicon in Top500’s HPL Linpack benchmark.
- The MacBook achieved 57.012 Gflops at 10.6W: 5.38 Gflops per watt of energy efficiency.
- The Dell XPS 13 reached 127.91 Gflops at 20.6W: 6.21 Gflops per watt, beating the MacBook.
- The Dell also beat the Mac Studio M3 and M4 in Gflops per watt; only the Mac Mini M4 (7.57) beats it.
- At idle and while browsing the web, both laptops consume nearly the same amount of power.
- The Mac wins on integrated GPU, audio, and not coming with Windows preinstalled; the Dell wins on Linux support and a backlit keyboard.
- Geerling published the full benchmarks on GitHub so anyone can reproduce them.
- The result reopens the debate: efficiency depends on chip design, not just whether it’s ARM or x86.
What happened
Content creator Jeff Geerling published a video titled “Intel Just Matched Apple Silicon. Seriously.” in which he compares two high-end laptops: a MacBook with Apple Silicon (which he refers to in the video as the “MacBook Neo”) and a Dell XPS 13 equipped with the new Intel Core 5 320 processor. According to Hackaday’s coverage of the video, Geerling uploaded the full benchmarks to GitHub for both machines, including methodology and scripts.
The core test is HPL Linpack (High Performance Linpack), the same test used by the Top500 ranking to rank the world’s fastest supercomputers. It’s a floating-point computation test that saturates every processor core for several minutes, allowing you to calculate how many floating-point operations per second (Gflops) a system can sustain, and at what energy cost.
The numbers, according to the video and Hackaday’s coverage: the MacBook with Apple Silicon ran the benchmark at 57.012 Gflops while consuming 10.6W, for an efficiency of 5.38 Gflops per watt. The Dell XPS 13 with the Core 5 320 reached 127.91 Gflops while consuming 20.6W: 6.21 Gflops per watt. In absolute numbers the Dell processes more than double, and it does so while spending less energy per unit of work.
Context and history
Since the M1 launched in 2020, the dominant narrative in the industry was that ARM is inherently more efficient than x86 because it uses fixed-length instructions, simpler to decode, versus x86’s more complex, variable instruction set. That reading was one of the justifications Apple gave for dropping Intel processors, and the same argument pushed Qualcomm to bet on its Snapdragon X chips for Windows laptops.
But for years, a group of microarchitecture engineers has been pointing out something different: real energy efficiency doesn’t depend so much on the instruction set (ISA) as on concrete physical design decisions, the manufacturing node, cache size and organization, the width of the execution units, and the voltage and frequency curve each manufacturer chooses. Geerling’s result with the Core 5 320 is direct evidence in favor of that second reading: it’s an x86 chip running under Linux or Windows that matches or beats Apple Silicon in Gflops per watt under sustained load.
💭 Key: This doesn’t mean x86 caught up to ARM overall. It means one specific x86 chip, on one specific workload, matched one specific ARM chip. Energy efficiency depends on chip design, not just which instruction family it belongs to.
Technical details and energy efficiency
The comparison isn’t limited to peak performance. Geerling also reports that at idle or while browsing the web, that is, with the processor far from its maximum load, the Dell XPS 13 consumes practically the same as the MacBook. The big difference only shows up under sustained computational load, which is exactly the condition HPL Linpack measures.
The following table summarizes the numbers published so far:
| Device | Processor | Gflops (HPL) | Power draw | Gflops per watt |
|---|---|---|---|---|
| MacBook (Apple Silicon) | Apple chip, generation unspecified in the video | 57.012 | 10.6 W | 5.38 |
| Dell XPS 13 | Intel Core 5 320 | 127.91 | 20.6 W | 6.21 |
| Mac Mini | Apple M4 | Not published in the source | Not published in the source | 7.57 |
| Mac Studio | Apple M3 / M4 | Not published in the source | Not published in the source | Lower than 6.21 |
The important detail is in the right-hand column: the Dell XPS 13 comes out ahead of the Mac Studio with M3 and M4 in Gflops per watt, and only falls behind the Mac Mini with M4, which reports 7.57 Gflops per watt. That Mac Mini remains, according to this data, the most efficient device in the group, but no longer by a categorical difference: the gap between the Mac Mini and the XPS 13 is smaller than the gap between the XPS 13 and the MacBook laptop.
flowchart TD
A["Run HPL Linpack at maximum load"] --> B["Measure power draw in watts during the run"]
B --> C["Record sustained Gflops"]
C --> D["Calculate Gflops per watt"]
D --> E["Compare against other devices"]
Outside the pure compute benchmark, Geerling also compares other aspects of the two laptops: the Mac wins on integrated GPU, audio quality, and not coming with Windows preinstalled. The Dell wins on being able to install Linux without friction and on having a backlit keyboard. These are product differences, not architecture differences, but they weigh into the purchase decision just as much as Gflops per watt.
How to test it yourself
You don’t need a Dell XPS 13 or a MacBook to understand the method. You can estimate your own Gflops-per-watt ratio with open source tools, although you won’t reproduce HPL Linpack exactly (that test distributes the load across nodes and uses a highly optimized BLAS library).
The first thing you need is a floating-point-intensive compute load. A simple NumPy script is enough to estimate sustained Gflops with a large matrix multiplication. This works the same on Windows, macOS, and Linux:
pip install numpyWith the library installed, this script measures how many floating-point operations per second your CPU can sustain:
import numpy as np
import time
n = 4096
a = np.random.rand(n, n).astype(np.float64)
b = np.random.rand(n, n).astype(np.float64)
start = time.perf_counter()
c = a @ b
elapsed = time.perf_counter() - start
flops = 2 * n ** 3
gflops = flops / elapsed / 1e9
print(f"Sustained Gflops: {gflops:.2f}")That script performs a 4096×4096 matrix multiplication and calculates Gflops from how long it takes. To turn it into an energy efficiency ratio you need to measure power draw while it runs:
- macOS:
sudo powermetrics --samplers cpu_power -i 1000in another terminal, while the script runs. - Linux:
sudo turbostat --interval 2, which reports CPU package power draw (PkgWatt column) in real time. - Windows: run the script inside WSL2 and use turbostat, or measure the device’s total power draw with Intel Power Gadget or HWiNFO64 if your CPU is Intel or AMD.
Divide the Gflops the script prints by the average watts the monitoring tool reported during the run, and you’ll have your own Gflops-per-watt number, comparable in spirit (not in exact magnitude) to the 5.38 and 6.21 Geerling reported.
💡 Tip: Run the script three or four times in a row before taking your measurement: most modern processors boost frequency for a few seconds and then throttle down due to temperature, so the number from the first run tends to be inflated.
Impact and analysis
The result matters to three different audiences. For someone buying a laptop to compile code, train small models, or run sustained compute loads, energy efficiency under real load matters more than idle consumption, and that’s where the gap between Apple Silicon and Intel’s latest x86 narrowed measurably. For Windows laptop makers who had been betting on ARM (Qualcomm Snapdragon X) as the only way to compete with Apple on battery life, this data complicates the sales pitch: if Intel can get close to Apple Silicon’s efficiency without changing architecture, the migration to ARM on Windows loses some of its urgency.
For the semiconductor industry in general, it reinforces something several chip designers have been repeating for a while: much of what people attribute to “ARM is more efficient” is actually “the specific chip Apple made, on the specific manufacturing node Apple uses, with Apple’s specific design decisions, is more efficient.” When another manufacturer matches those design variables, even with a different ISA, the result gets closer.
⚠️ Careful: This is a benchmark from a single content creator, not a peer-reviewed paper. HPL Linpack stresses parallel computation with data that fits well in cache: it doesn’t represent the real power draw of editing video, compiling a large project, or browsing, where Apple Silicon has historically kept winning on total battery life.
That limit is worth pointing out: the video’s own comments, cited by Hackaday, note that the Dell XPS 13 has a physically larger battery that offsets part of its higher power draw under load, and that the energy efficiency comparison at idle (where most people spend most of their usage time) shows both devices practically tied. A higher Gflops-per-watt ratio during a few minutes of peak load doesn’t automatically translate into more battery hours in daily use.
What’s next
With the scripts and raw data published on GitHub, it’s likely that other reviewers and hardware enthusiasts will run the same benchmark on other combinations: AMD’s Ryzen AI against Apple Silicon, Snapdragon X against the new Core 5, or earlier Intel generations to see when the gap started closing. That reproducibility is, in itself, the most useful part of this story: there’s no need to blindly trust Geerling’s number, anyone with a Dell XPS 13 and some free time can confirm or refute it.
📖 Summary on Telegram: View summary
Try it yourself: run the NumPy script above on your own laptop alongside powermetrics or turbostat and calculate your Gflops-per-watt ratio before deciding on your next purchase.
Frequently Asked Questions
What is the HPL Linpack benchmark?
It’s a floating-point computation test that solves a dense system of linear equations at maximum load. It’s the same test used by the Top500 ranking to rank the world’s fastest supercomputers, which is why it serves as a common reference across very different devices.
What does Gflops per watt mean?
It’s a measure of energy efficiency: how many billions of floating-point operations per second a processor delivers for each watt of energy it consumes. A higher number means the chip does more useful work with the same amount of energy.
Is the Intel Core 5 320 more efficient than all of Apple’s chips?
No. According to the video’s data, it beats the Mac Studio with M3 and M4, but the Mac Mini with Apple M4 remains more efficient, with 7.57 Gflops per watt versus the Dell XPS 13’s 6.21.
Does this mean Apple Silicon lost its battery advantage?
Not necessarily. The comparison measures efficiency under sustained maximum load. At idle and while browsing the web, which is where most people spend more time, both laptops consume similarly according to the video itself.
Where can I see the original benchmarks?
Jeff Geerling published the video and the test scripts on his channel and on GitHub; Hackaday covered the results with the full detail of the figures (see References).
Can I reproduce this test on my own computer?
You can estimate a comparable ratio with a NumPy script and a power monitoring tool like powermetrics (macOS) or turbostat (Linux), as explained in the “How to test it yourself” section of this article.
References
- Hackaday: coverage of Jeff Geerling’s video with the full benchmark figures.
- Jeff Geerling’s GitHub: repositories where he usually publishes the scripts and raw data from his benchmarks.
- Wikipedia: LINPACK benchmarks: technical explanation of the HPL benchmark used in the test.
- Top500: the supercomputer ranking that uses HPL Linpack as its performance reference.
📱 Enjoying this content? Follow @programacion on Telegram for daily tech content in Spanish: quick summaries, fresh content every day.
Imagen destacada: Foto de Stan Hutter en Unsplash
0 Comments