实际测试几个ai的编程能力

甲骨文免费机要求cpu不能长期闲置，否则可能会认为机器空闲而回收。所以，有了下面的要求。 这是个很简单的程序了，显然是交给AI，今天无聊，我同时让几个AI来写想来对比一下。我很惊讶的是比较结果。

省流: DeepSeek > Claude > ChatGpt > Llama * claude和gpt的排名不是太确定，第一和最后是很确定的。
代码核心是怎么控制cpu占用，下面我就只贴出来相关代码，其它省略了。

prompt: 帮我写段linux的c代码，cpu.c，它是让cpu空转的。它可以跟一个参数，比如 ./cpu 10 ，表示占用10%的cpu资源。 需要多cpu多线程下也能工作。 程序运行后fork到后台，永远执行。
*都只是向ai发起第一次询问时取这条结果，没有再次的交互。

ChatGPT:
仅仅是sleep一下，这个并不会消耗cpu资源。

// 单线程函数，用于控制 CPU 占用率
void* control_cpu(void* arg) {
    int usage = *(int*)arg;
    struct timespec busy_time, idle_time;

    // 计算忙碌时间和空闲时间
    busy_time.tv_sec = 0;
    busy_time.tv_nsec = usage * 10 * 1000 * 1000; // 使用率对应的纳秒数
    idle_time.tv_sec = 0;
    idle_time.tv_nsec = (100 - usage) * 10 * 1000 * 1000; // 空闲时间对应的纳秒数

    while (running) {
        // 模拟忙碌
        clock_nanosleep(CLOCK_MONOTONIC, 0, &busy_time, NULL);
        // 模拟空闲
        clock_nanosleep(CLOCK_MONOTONIC, 0, &idle_time, NULL);
    }

    return NULL;
}

Claude:
试图通过一个循环for (long long i = 0; i < 10000000L * cpu_load_percentage; i++)来消耗CPU，确实这可以消耗，但是，它完全控制不了运行时间，因为各CPU性能不一样。这是大学第一学期C语言课就会知道的常识。

void *busy_work(void *arg) {
    while (should_run) {
        // Busy wait
        for (long long i = 0; i < 10000000L * cpu_load_percentage; i++) {
            __asm__ volatile ("nop");
        }
        // Sleep to control total CPU usage
        usleep(10000 * (1.0 - cpu_load_percentage));
    }
    return NULL;
}

LLAMA:
错误与Claude一样，更扯的是，它居然想只*1000而已，太低估CPU的计算能力了。

void* cpu_idle(void* arg) {
    int cpu_usage = *(int*)arg;
    int sleep_time = 100 - cpu_usage;

    while (1) {
        // 占用 CPU 资源
        for (int i = 0; i < cpu_usage * 1000; i++) {
            volatile int x = i * i;
        }

        // 休眠
        usleep(sleep_time * 1000);
    }

    return NULL;
}

DeepSeek:
今天的测试胜利者，完全出乎我的预料。
四个AI中，它是唯一正确编码的。

void* cpu_busy_loop(void* arg) {
    struct timespec start, now;
    long elapsed_ns;
    long sleep_ns;
    long busy_ns;

    // 计算每个周期中忙碌和睡眠的时间
    busy_ns = (target_cpu_usage * NS_PER_SEC) / 100;
    sleep_ns = NS_PER_SEC - busy_ns;

    while (running) {
        clock_gettime(CLOCK_MONOTONIC, &start);

        // 忙碌循环
        while (1) {
            clock_gettime(CLOCK_MONOTONIC, &now);
            elapsed_ns = (now.tv_sec - start.tv_sec) * NS_PER_SEC + (now.tv_nsec - start.tv_nsec);
            if (elapsed_ns >= busy_ns) {
                break;
            }
        }

        // 睡眠
        struct timespec sleep_time;
        sleep_time.tv_sec = sleep_ns / NS_PER_SEC;
        sleep_time.tv_nsec = sleep_ns % NS_PER_SEC;
        nanosleep(&sleep_time, NULL);
    }

    return NULL;
}