如何通过编程让单个CPU核心温度尽可能飙升？

需求场景 #

• 测试散热装置的散热能力
• 不修改BIOS设置，通过满负载提升风扇转速
• 测试温度节流对同芯片其他进程的性能影响

核心问题 #

现代CPU包含多个功能单元（整数ALU、FPU、向量单元等），不同微架构的优化方向有差异。需要专门设计的代码，让所有功能单元持续满负载运行，产生远超常规基准测试的热量——而非模拟真实负载或测试运算速度。

我尝试的代码 #

void busy_busy_busy()
{
   using uint_t = ::std::uint64_t;
   const auto maxuint = ::std::numeric_limits<uint_t>::max();
   ::std::random_device random_device;
   ::std::mt19937_64 generator(random_device());
   ::std::uniform_int_distribution<uint_t> ints(0, maxuint >> 1);
   ::std::uniform_real_distribution<long double> doubles(0, 1);
   long double starting = doubles(generator);
   long double const one_third = 1.0l / 3.0l;
   while (starting != one_third) {
      auto tmp = starting;
      tmp *= doubles(generator);
      starting *= ints(generator);
      starting += tmp;
      starting /= maxuint >> 2;
   }
}

这段代码的问题在于依赖随机数生成，频繁访问内存，无法让CPU所有功能单元持续满负载，内存开销会限制核心运算效率。

针对AMD Zen 2（3950X）的优化方案 #

Ryzen 9 3950X是16核Zen 2架构，每个核心包含整数ALU、FPU、AVX2向量单元。要让温度最大化，需让所有单元持续运算，避免内存瓶颈，同时绑定每个核心满负载运行。

1. 纯C++满负载代码 #

利用AVX2指令集，所有运算在寄存器内完成，无内存访问，同时占用所有功能单元：

#include <immintrin.h>
#include <cstdint>

// 单个核心满负载运算函数
void cpu_max_load() {
    // 初始化寄存器数据，避免依赖内存
    __m256i int_vec = _mm256_set_epi64x(0xDEADBEEF, 0xCAFEBABE, 0x12345678, 0x87654321);
    __m256d fp_vec = _mm256_set_pd(3.1415926535, 2.7182818284, 1.4142135623, 0.5772156649);
    uint64_t int_reg = 0xFFFFFFFFFFFFFFFF;
    long double fp_reg = 1.0L;

    while (true) {
        // 整数运算：占用ALU单元
        int_reg = (int_reg << 1) | (int_reg >> 63);
        int_reg += 0x12345678;
        int_reg *= 0x98765432;
        int_vec = _mm256_add_epi64(int_vec, int_vec);
        int_vec = _mm256_xor_si256(int_vec, _mm256_set_epi64x(int_reg, int_reg, int_reg, int_reg));
        
        // 浮点运算：占用FPU单元
        fp_reg *= 1.0000001L;
        fp_reg += 0.00000001L;
        fp_reg = fp_reg / 1.000000001L;
        fp_vec = _mm256_mul_pd(fp_vec, fp_vec);
        fp_vec = _mm256_add_pd(fp_vec, _mm256_set_pd(fp_reg, fp_reg, fp_reg, fp_reg));
        
        // 混合运算：让数据在单元间流动，避免流水线停顿
        int_vec = _mm256_cvtpd_epi32(_mm256_cvtepi32_pd(_mm256_castsi256_si128(int_vec)));
    }
}

2. 多核心满负载启动代码 #

需要将每个cpu_max_load绑定到单独物理核心，确保16个核心全部跑满：

#include <thread>
#include <vector>
#include <pthread.h>

// 绑定线程到指定核心
void bind_to_core(int core_id) {
    cpu_set_t cpuset;
    CPU_ZERO(&cpuset);
    CPU_SET(core_id, &cpuset);
    pthread_setaffinity_np(pthread_self(), sizeof(cpu_set_t), &cpuset);
}

int main() {
    const int num_cores = 16; // 3950X的物理核心数
    std::vector<std::thread> threads;

    for (int i = 0; i < num_cores; ++i) {
        threads.emplace_back([i]() {
            bind_to_core(i);
            cpu_max_load();
        });
    }

    for (auto& t : threads) {
        t.join();
    }

    return 0;
}

3. 内联汇编版本（更激进） #

直接控制CPU指令，最大化利用Zen 2的执行单元：

void cpu_max_load_asm() {
    asm volatile (
        // 初始化寄存器
        "mov $0xFFFFFFFFFFFFFFFF, %%rax\n"
        "movsd $1.0, %%xmm0\n"
        "vmovdqa %%ymm1, %%ymm2\n"
        "vmovdqa %%ymm3, %%ymm4\n"
        // 无限循环入口
        "loop_start:\n"
        // 整数ALU运算
        "shl $1, %%rax\n"
        "rcr $1, %%rax\n"
        "add $0x12345678, %%rax\n"
        "imul $0x98765432, %%rax\n"
        // 向量整数运算
        "vpaddd %%ymm1, %%ymm1, %%ymm1\n"
        "vxorps %%ymm2, %%ymm1, %%ymm1\n"
        // 浮点FPU运算
        "mulsd $1.0000001, %%xmm0\n"
        "addsd $0.00000001, %%xmm0\n"
        "divsd $1.000000001, %%xmm0\n"
        // 向量浮点运算
        "vmulpd %%ymm3, %%ymm3, %%ymm3\n"
        "vaddpd %%ymm4, %%ymm3, %%ymm3\n"
        // 混合运算：避免流水线停顿
        "vcvtpd2dq %%ymm3, %%ymm5\n"
        "vcvtdq2pd %%ymm5, %%ymm3\n"
        // 循环跳转
        "jmp loop_start\n"
        : // 无输出寄存器
        : // 无输入寄存器
        : "rax", "xmm0", "ymm1", "ymm2", "ymm3", "ymm4", "ymm5", "cc" // 声明被修改的寄存器
    );
}

编译说明 #

• GCC/Clang：添加编译选项 -mavx2 -O3
• MSVC：添加编译选项 /arch:AVX2

内容的提问来源于stack exchange，提问作者Omnifarious