# Dumpster Inference > Source: > Published: 2026-08-24 16:01:02+00:00 A machine is called obsolete when it stops being good at everything. Running a language model is not everything: it is one narrow job with one dominant constraint, and hardware that fails the general test can still be excellent at the specific one. This article is the measurement of that claim. Two machines, eight models, everything run twice. One cost €803 and was assembled from parts whose newest component is nine years old; the other cost €2,392 and is entirely current. On generation the old machine returns roughly half the speed — and on some models three quarters of it. What makes that possible is that specialisation changes which specification matters. On the one axis that decides generation speed, several of these discarded parts are not merely adequate. They are ahead. Before any of the numbers, the failure that nearly produced the wrong ones — because it is the most useful thing in this article for anyone running two cards. One TITAN Xp benchmarked 24% slower than its identical twin. No error, no throttle flag, nothing in any log. It simply sat at exactly its base clock forever, drawing 149 W where the other drew 256. I diagnosed a missing power cable, confidently and wrongly, because 150 W is precisely what you get from a slot plus one connector. It was the display server. The card had the monitor plugged into it, and a desktop session was enough to hold it at base clock indefinitely. Stopping the graphical session returned it to 1,885 MHz and 79.2 t/s. The machine now boots without a desktop, which is a strange thing to call a 23% performance upgrade, but it is one. If you have two cards and one is mysteriously slow, check what your screen is plugged into before you check anything else. A TITAN Xp cost €1,300 in 2017. It is now €250, because it is a Pascal card and Pascal has been dropped by the current NVIDIA driver — which sounds fatal and turns out to be an inconvenience you solve once, by freezing a driver version and never touching it again. Everything that is not a graphics card in this machine — twelve cores, twenty-four threads, thirty-two gigabytes in quad channel, board, case, power supply, disk — comes to €303. Graphics priced at what they sell for today: €250 per used TITAN Xp, €722 for an RTX 5060 Ti 16 GB, €450 for a used RTX 4070. Only the motherboard and one NVMe drive are estimates; everything else was paid or quoted this month. Look at what memory costs on the modern side of that bill: €600, second only to the graphics cards, and the fastest-rising number in desktop computing this year. It is also the line where the salvage approach pays best — not by finding a discount, but by leaving the market that sets the price. DDR4 left production recently, and several hundred million machines still run on it. Every one of them is a potential repair, an upgrade, a warranty swap. Demand did not stop; supply did. So the price went up — DDR4 now costs roughly what DDR5 does, for worse memory. DDR3 died a long time ago. Nobody repairs anything with it. The sticks sit in drawers, in recycling bins, in the boxes of people who upgraded in 2019 and never threw the old parts away. There is no demand at all, so there is no price. A technology is cheap when it is obsoleteandforgotten. In between — just out of production, still needed by everyone — is the most expensive it will ever be. More expensive than new. This is the entire trick, and it generalises beyond memory: anything still wanted costs money, anything nobody is looking for is nearly free, and quite often still excellent. The job is finding the second kind — and then checking whether it actually works. Eight models, the same GGUF files byte for byte on both machines, the same llama.cpp build, the same command, the same evening. The last column is what the €803 machine returns as a fraction of the €2,392 one. A note for anyone who read the two release-day pieces in this series: the figures here for Qwen3.8–27B and Muse-Glimmer-30B differ slightly from the ones published then — 23.5 against 23.63, 27.0 against 27.2. Nothing changed in the hardware. Those tests used a 256-token prompt and whatever build was current that day; everything in this article was re-measured from scratch with a 512-token prompt and both machines pinned to the same commit, because a comparison is only worth making when both sides ran the identical thing. Look at the bottom two rows. Qwen3.8–27B manages 16.5 tokens per second — against 83.7 for a *larger* file that happens to be a mixture-of-experts. In absolute terms it is dreadful. And yet, measured against the expensive machine, dense is where the gap is *smallest*: 70% and 73%, against 48–57% everywhere else. I predicted the opposite in writing, the day before, on the grounds that Pascal has no tensor cores and dense should be where it dies. It does die. It just dies less than the competition, and the reason is the same fact the article opened with. A dense model re-reads every weight for every token, so bandwidth is the ceiling — and a 2017 TITAN Xp has 547 GB/s against the RTX 4070’s 504 and the 5060 Ti’s 448. On that one axis the old cards are simply ahead. A mixture-of-experts touches a small slice per token. Bandwidth stops mattering, kernel efficiency takes over, and nine years of architecture arrives all at once. So the rule everyone repeats — *generation speed follows memory bandwidth* — holds **within an architecture**. Across architectures it only holds for dense models. I had been repeating it too. Generation is the number people quote. Prefill — how fast the model reads your prompt before it answers — is the one that decides whether long documents are usable, and it is compute-bound, which is exactly what these cards do not have. The first pass called the cheap drive the bottleneck and moved on. That was too convenient an answer, so it was measured again — and the second evening produced a more interesting one. Those figures were worth the second evening. Read speed was measured four ways — buffered raw device, O_DIRECT raw device at two block sizes, and hdparm — returning 400, 361, 369 and 414 MB/s. Write speed was measured through the page cache with fdatasync and again with O_DIRECT, which bypasses it entirely: 75.0 and 74.5 MB/s. Two completely different paths, half a megabyte apart. The slowness is the drive, not the ruler. Nothing is broken. The SATA link negotiates 6 Gbps, the median random read is 0.36 ms, and reads run at roughly 400 MB/s — which is all inference ever asks of a disk. What this drive cannot do is write: 75 MB/s sustained, and 31 MB/s when scattered and sequential writes land at the same time, which is exactly what a build or a model unpack looks like. So the correction to the first version of this article is worth stating plainly: the disk does not slow the tokens down. It slows *you* down. Every model copy, every build, every unpack takes four times longer than it should, and that cost is paid in your evening rather than in the benchmark. One result is still affected, but not for the reason first given. Qwen3-Next-80B is 33 GiB on a machine with 32 GB of RAM, so it cannot be held in memory and pages are read back during generation. At 400 MB/s the reads themselves are not the problem — having to do them at all is. Treat that row as partly a memory-capacity benchmark, and read its 17% prefill figure as the floor of a machine that is paging, not as a measurement of the cards. A cheap M.2 SATA drive in a €15 USB enclosure, plugged into the other machine, measures like this against the internal drive: Reads are a tie. On writes the external drive over USB is nearly five times faster than the internal one on native SATA — the bus everyone calls slow, beating the bus everyone calls fast, by a factor of five. What decides it is which drive is inside, not what it is plugged into. Which is the whole argument of this article, arriving from an unexpected direction. Under load the haul draws 293 W for 83.7 tokens per second; the grown-up machine draws 170 W for 159.3. Faster *and* cooler — three times cheaper per token. This is the point where an article normally concludes that the new hardware pays for itself. Turned round: the haul buys performance at €9.59 per token/second against €15.02. Thirty-six percent better value per euro — provided you are content to wait twice as long, which for a machine that talks faster than you can read, you generally are. **HUNT — Small DDR3 sticks, and all the channels.** 4 GB modules are the bargain because they are useless to everyone else — €0.88 per gigabyte against €9.38 for DDR3’s grandchild. Fill every slot: four channels at 1600 MT/s beat two channels at 3000. *The trap:* the cheap high-capacity DDR3 on eBay is server pull, which means registered. It will not boot on a consumer X79 board, Xeon or no Xeon. The part number ends in R — you want U. Ask before you pay. **HUNT — Yesterday’s flagship, for its VRAM.** A TITAN Xp is €250 and carries 12 GB at 547 GB/s — more bandwidth than a new RTX 4070. Two of them make 24 GB, which is the difference between running a model and reading about it. *The trap:* Pascal is dropped by current drivers. You freeze on the 580 branch with CUDA 12 and an older kernel, and you hold those packages so an update cannot quietly remove your graphics. That is a real, permanent cost. **HUNT — Server CPUs, for the memory controller.** A twelve-core Xeon E5–2697 v2 costs €50 — about the price of the case. You are not buying it for the cores; you are buying the four memory channels it brings. *The trap:* Ivy Bridge-E has no AVX2 and no FMA, the instructions llama.cpp reaches for when experts spill onto the CPU. That matters for exactly one row in the table above, and it is the row this machine handles worst. **LEAVE — The cheap SSD.** A DRAM-less budget drive reads fine — around 400 MB/s, which is all inference needs — but writes at only 75 MB/s sustained, and collapses to 31 when anything else touches the disk at the same time. It will not slow your tokens down. It will make every model copy, every build, every unpack take four times as long. The same money spent on a drive with DRAM writes five times faster. **LEAVE — Anything you need to be reliable.** This is a machine assembled from parts whose warranties expired during a previous decade, running a driver branch that will never be updated again, in a case chosen because it was €50. It is a wonderful toy. It should not be anywhere near something that matters. None of this is advice for production. If inference is load-bearing for you — if people are waiting on it, if money depends on it — buy supported hardware, get a warranty, and skip the whole genre. The point of this machine is that it exists at all: that a 35-billion-parameter model answers you at sixty tokens a second on a board designed many years ago, assembled on a kitchen table out of things other people threw away. Half the fun is the benchmark. The other half is finding out whether the junk works, and it usually does. Each of these was a real mistake caught mid-run, not a precaution invented afterwards. **Same software, proven not assumed.** The machines started on llama.cpp builds six days apart. Instead of hoping that was harmless, both builds were run on the same model: 83.11 vs 83.07 t/s. Six days of upstream work is worth 0.05%. Then both were aligned to commit 7077abb anyway. **A comma that ran one GPU.** In llama-bench the tensor-split separator is a *slash*. Writing -ts 50,50 is accepted silently and means something else entirely — two single-GPU runs. It cost 3% before it was caught, and it would have quietly deleted this article's central claim. **Power measured under load only.** The first pass averaged wattage across whole runs, including minutes spent loading models with the GPUs idle. That undercounted the salvage machine by up to 89% — because its disk is slower, so it idles more. The error flattered the thesis, which is the worst kind. **Everything twice.** Two independent passes. gpt-oss returned 146.37 t/s both times on the modern machine, Muse-Glimmer 27.04 both times. Seven of eight models landed within half a percent; gpt-oss on the old cards wanders ±3% and is flagged as such. **The disk, measured again after the first version of this article.** The original draft blamed a slow drive without checking what kind of slow. Re-measuring it four ways for reads and two for writes produced a different and better answer, and changed one conclusion in the piece. Convenient explanations are the ones that most deserve a second evening. One thing that cannot be controlled: the driver stacks differ and never can be. Pascal is unsupported by the current NVIDIA branch, so the haul is frozen on 580.173.02 with CUDA 12 and kernel 6.8, while the modern machine runs 595 with CUDA 13. That is not sloppiness — it is a permanent property of running 2017 cards in 2026, and part of what the €250 actually buys you. But it does mean this is a comparison of two machines, not of two chips. *The haul: ASUS P9X79 · Xeon E5–2697 v2 · 32 GB DDR3–1600 quad channel · 2× TITAN Xp · 1 TB SATA · Ubuntu 24.04, kernel 6.8, driver 580.173.02, CUDA 12.0* *Grown-up: ASUS PRIME X570-P · Ryzen 7 3700X · 64 GB DDR4 · RTX 4070 + RTX 5060 Ti · 2 TB NVMe · Ubuntu 26.04, kernel 7.0, driver 595, CUDA 13* *Bandwidth measured with a threaded sum over a 4 GB buffer, best of five. 16 model measurements, run twice.* *A note on method: the benchmark runs and the first draft of this article were produced with an agentic pipeline (Claude Code by Anthropic) on my own hardware. Every figure was checked against the raw logs before publishing; the analysis, the conclusions, and the mistakes are mine. Everything here is reproducible — same runtime, same commit, same second-hand parts.* [Dumpster Inference](https://pub.towardsai.net/dumpster-inference-d7c5c8e0ec74) was originally published in [Towards AI](https://pub.towardsai.net) on Medium, where people are continuing the conversation by highlighting and responding to this story.