Power-Limiting Your GPU for Local LLMs: 9% Less Power for 2% Less Speed

2026年7月30日

In crypto mining, deliberately capping a graphics card’s power draw was a standard trick for squeezing out better efficiency per watt. Lowering the power limit (a cap on power draw, set in watts) cuts both heat and your electricity bill. Does the same trick work for a local LLM (large language model — a ChatGPT-style text AI running on your own machine)? I was curious, so I measured it on the cards I have.

The short version: capping power barely slowed generation down. Heat and power draw both fell, so efficiency per watt improved. Cap it too aggressively, though, and speed collapses — there is a sweet spot. Below are the measured numbers as I stepped the power limit down. (Hands-on measurements, as of July 2026)

Test machine

The PC used for these measurements:

As an Amazon Associate we earn from qualifying purchases.

What I tested

The card is an RTX 3090 (default power limit: 370W). The model is a mid-sized dense model — the type that reads every weight on every token. I stepped the power limit down through 370 → 300 → 250 → 200 → 150W, measuring generation speed (tokens per second) and actual power draw at each step. On Linux, changing the limit takes one line (using nvidia-smi, the utility bundled with NVIDIA’s driver; it needs administrator rights):

Results

Reading the numbers

The headline is this: dropping the limit all the way to 250W barely changed the speed. Generation went from 25.0 to 24.5 — a 2% dip — while power draw fell about 9%. Heat and fan noise drop with it. That is about as close to free efficiency as you get.

Going further, to 200W, gave the best efficiency per watt in this test. Speed falls 16%, but power draw falls about 24%. For jobs that are not urgent, or for long unattended runs, this was the kindest setting for the electricity bill.

At 150W, though, speed collapsed to 9.5 and efficiency got worse again. Squeezed that hard, the card can no longer deliver what it needs to, and you burn power for very little output. Lower is not automatically better.

Why capping power costs so little speed

Text generation is limited less by raw compute than by how fast weights can be read from memory (memory bandwidth). In fact, even with the limit set to 370W, the measured peak during generation was only 304W — the card never reached its own ceiling. It was not using all the power available to it in the first place. Trimming headroom that was going unused does not cost you speed.

Recommended settings

These figures are specific to an RTX 3090 and this model. The sweet spot shifts with the card and the model, so step your own limit down gradually and find the point just before speed starts to break. AMD cards have a similar power control tool (rocm-smi).

The model you run changes the power draw too

Power draw depends on more than the cap — the model itself matters a lot. I measured several on the same card, all at the stock 370W limit.

The gap is clear. Dense models — which read every weight on every token — draw more power and deliver less per watt. Mixture-of-Experts (MoE) models, which activate only the parts they need, draw less and are far more efficient. The reason is simply that dense reads all the weights from memory each time while MoE reads only a fraction. In other words, most of the power is going into reading from memory. If efficiency matters to you, choosing an MoE model is a lever in itself.

Where does the power actually go — memory or compute?

Here is where it gets interesting. If power draw is mostly memory, then the GPU’s compute cores may just be burning watts for nothing. So I left the memory clock alone and stepped down only the core clock.

The result surprised me. Dropping the core clock cap from 1875 to 1200MHz cost only 5% of the speed while cutting power draw by 22% (247 → 193W). Those roughly 54 watts are what the compute cores were burning while waiting on memory. Push the cores to their floor and draw bottoms out at 166W — a reasonable estimate of the memory-side power that generation genuinely needs. Roughly speaking, the 247W splits into about 166W for memory and the rest of the board, plus about 80W for the compute cores, most of it wasted.

What is notable is that this targeted approach — capping only the core clock (sudo nvidia-smi -i 1 -lgc 210,1500 on Linux; -rgc to reset) — beat the blunt power cap from earlier. Compare at the same speed (24.5): the overall power cap draws 221W, the core-clock cap 206W. Trimming the specific thing that is wasteful beats squeezing everything uniformly.

Testing a second card (RTX 3060)

I repeated the test on a smaller card (RTX 3060, 12GB) running a lighter model. Efficiency improved as the limit came down, and was best at the tightest setting tested (100W) — the same direction as the 3090.

How the speed fell was different, though. On the 3090 with a larger model, cutting the core clock barely cost speed, because the cores were idling on memory anyway. On the 3060 with a light model, speed fell roughly in step with the cut. A light model keeps compute and memory more evenly balanced, so there is less idle core capacity to reclaim. The “big savings, almost no speed loss" sweet spot is largest when a big card runs a big model — that is, when memory stalls dominate.

Either way, capping power does improve efficiency. Step your own limit down with the card and models you actually use, watch where speed starts to fall, and settle just short of it.

Summary

The mining-era trick of capping power for better efficiency works on local LLMs too. At a 250W cap, speed was essentially unchanged and draw fell about 9%; at 200W you save roughly 24%. Digging further, the bulk of the power goes into memory reads, and the compute cores sit largely idle — so capping the core clock specifically saves more than capping total power. Choosing an MoE model helps as well. The underlying point is that text generation never uses all the power on tap, so the win comes from trimming the waste. Just don’t overdo it: find the point before speed breaks.

Test conditions: RTX 3090 / mid-sized dense model / median of three runs of 256 generated tokens. Power figures are measured averages during generation. Numbers vary with card, model and environment.