Heat transfer and throttling

Start a heavy game or a long compile and your laptop is quick for about half a minute, then the fan roars and everything gets slower - even though the code has not changed and the battery is full. Nothing broke. The chip walked into a physical wall it cannot cross: it is making heat faster than it can get rid of it. To understand why, we follow the heat on its journey from the silicon to the room.

Three ways heat moves

Before any of this, heat needs a way to travel. There are exactly three, and you have felt all of them.

One thing all three share: heat only ever flows from hotter to colder, never the reverse on its own. "Cold" does not flow into a warm room through an open freezer - warm air flows out. There is no cold; there is only more heat and less heat, and it always drains downhill in temperature. That one-way rule is the seed of the next lesson.

Play: the heat's journey off the chip

Here is the path heat takes from a running CPU to the room, drawn as a stack. The chip pours out a fixed number of watts; that power has to climb through the paste, the heatsink, and the fan-stirred air to escape. Turn the chip power up, or make any layer worse, and watch the junction temperature at the bottom climb toward the throttle line.

Now the predict probe resolves. Crank the fan to full and the junction temperature drops only a little if the paste is the weak link - because the fan only improves the last hop. The heat still has to crawl through whatever the worst layer is first. The bottleneck is set by the largest barrier in the chain, not by the fastest one.

Heat flow is Ohm's law in disguise

Newton noticed the simplest version of this centuries ago: an object cools at a rate proportional to how much hotter it is than its surroundings. Turn that around and it says the temperature gap needed to push a given flow of heat is proportional to the heat flow. Define the constant of proportionality as a thermal resistance and you get a clean law:

If that shape looks familiar, it should. It is exactly $V=IR$ from electric circuits, with temperature difference playing the role of voltage, heat flow playing the role of current, and thermal resistance playing the role of electrical resistance. The analogy is not a loose metaphor; the equations are identical, which is why engineers draw cooling systems as resistor networks.^[2]

And here is the part the widget makes vivid: the layers sit in series - paste, then heatsink, then air - and resistances in series add, just like resistors in a wire. The total temperature the chip runs above the room is the sum of the drops across every layer:

Because the resistances add, the worst layer dominates the sum. A brilliant fan (tiny $R_{\text{air}}$) cannot rescue a chip choked by dried cracked paste (huge $R_{\text{paste}}$). The chain is only as good as its worst link.

Why the laptop slows down

Everything connects now. In power and efficiency we saw that a chip turns nearly all the electrical power it draws into heat: a 45 watt CPU is a 45 watt heater. That $P$ is the heat flow in the equation above, and the faster the chip runs, the more power it burns and the more heat it must shed.

The chip has a temperature it must not exceed or it will be damaged. When the steady-state junction temperature would climb past that limit, the chip protects itself by thermal throttling: it lowers its own clock speed and voltage, which cuts $P$, which pins the temperature at the limit. Your frame rate drops, your compile slows, and the chip survives. The thirty-second head start is the time it takes the heatsink to soak up heat and reach that ceiling; after that, the cooling chain, not the silicon, sets your speed.^[3]

T_air   = 25.0     # ambient, Celsius
limit   = 95.0     # junction temperature the chip must not exceed

# Thermal resistances in series (kelvin per watt). They ADD, like resistors.
R_paste, R_heatsink, R_air = 0.10, 0.14, 0.35
R_total = R_paste + R_heatsink + R_air

def junction_temp(power_watts):
    return T_air + power_watts * R_total     # deltaT = P * R

requested = 65.0
if junction_temp(requested) > limit:
    # Throttle: cap power so the junction sits exactly at the limit.
    allowed = (limit - T_air) / R_total
    performance = allowed / requested        # fraction of full speed
    print(f"throttling to {performance:.0%} of full speed")
else:
    print("running at full speed")

Check yourself