如何从C程序获取100％CPU使用率

这是一个非常有趣的问题，所以让我开始讨论。我在国家计算机博物馆工作，我们刚刚设法让一台Cray Y-MP EL超级计算机从1992年开始运行，我们真的很想知道它能走多快！

我们认为最好的方法是编写一个简单的C程序，该程序将计算质数并显示执行此操作需要多长时间，然后在快速的现代台式PC上运行该程序并比较结果。

我们很快想出了以下代码来计算质数：

#include <stdio.h>
#include <time.h>

void main() {
    clock_t start, end;
    double runTime;
    start = clock();
    int i, num = 1, primes = 0;

    while (num <= 1000) { 
        i = 2; 
        while (i <= num) { 
            if(num % i == 0)
                break;
            i++; 
        }
        if (i == num)
            primes++;

        system("clear");
        printf("%d prime numbers calculated\n",primes);
        num++;
    }

    end = clock();
    runTime = (end - start) / (double) CLOCKS_PER_SEC;
    printf("This machine calculated all %d prime numbers under 1000 in %g seconds\n", primes, runTime);
}

在运行Ubuntu（Cray运行UNICOS）的双核笔记本电脑上，它运行良好，获得100％的CPU使用率，耗时约10分钟。当我回到家时，我决定在我的六核现代游戏PC上进行尝试，这是我们收到的第一个问题。

我首先将代码修改为可以在Windows上运行，因为那是游戏PC所使用的，但是很遗憾地发现该过程仅获得CPU功率的15％。我认为Windows一定是Windows，因此我启动了Ubuntu的Live CD，以为Ubuntu可以像以前在笔记本电脑上那样充分发挥潜力，使该进程得以充分运行。

但是我只有5％的使用率！所以我的问题是，如何使该程序适应Windows 7或实时Linux上的游戏机上100％的CPU使用率？另一个很棒但不是必须的事情是，如果最终产品可以是一个可以轻松分发并在Windows计算机上运行的.exe。

非常感谢！

PS当然，该程序实际上无法与Crays 8专业处理器配合使用，这是另一个问题……如果您了解有关优化代码以在90年代的Cray超级计算机上工作的任何知识，我们也将大声疾呼！

如果要100％CPU，则需要使用多个内核。为此，您需要多个线程。

这是使用OpenMP的并行版本：

我必须增加限制，1000000以使其在我的计算机上花费超过1秒的时间。

#include <stdio.h>
#include <time.h>
#include <omp.h>

int main() {
    double start, end;
    double runTime;
    start = omp_get_wtime();
    int num = 1,primes = 0;

    int limit = 1000000;

#pragma omp parallel for schedule(dynamic) reduction(+ : primes)
    for (num = 1; num <= limit; num++) { 
        int i = 2; 
        while(i <= num) { 
            if(num % i == 0)
                break;
            i++; 
        }
        if(i == num)
            primes++;
//      printf("%d prime numbers calculated\n",primes);
    }

    end = omp_get_wtime();
    runTime = end - start;
    printf("This machine calculated all %d prime numbers under %d in %g seconds\n",primes,limit,runTime);

    return 0;
}

输出：

这台机器在29.753秒内计算了1000000以下的所有78498个质数

这是您的100％CPU：

您在多核计算机上运行一个进程-因此它仅在一个核上运行。

该解决方案非常简单，因为您只是尝试固定处理器-如果您有N个内核，请运行程序N次（当然，并行运行）。

例

这是一些可以NUM_OF_CORES并行运行程序时间的代码。它使用的是POSIXy代码，fork因此您应该在Linux下运行它。如果我所读到的有关Cray的信息是正确的，则移植此代码可能比其他答案中的OpenMP代码更容易。

#include <stdio.h>
#include <time.h>
#include <stdlib.h>
#include <unistd.h>
#include <errno.h>

#define NUM_OF_CORES 8
#define MAX_PRIME 100000

void do_primes()
{
    unsigned long i, num, primes = 0;
    for (num = 1; num <= MAX_PRIME; ++num) {
        for (i = 2; (i <= num) && (num % i != 0); ++i);
        if (i == num)
            ++primes;
    }
    printf("Calculated %d primes.\n", primes);
}

int main(int argc, char ** argv)
{
    time_t start, end;
    time_t run_time;
    unsigned long i;
    pid_t pids[NUM_OF_CORES];

    /* start of test */
    start = time(NULL);
    for (i = 0; i < NUM_OF_CORES; ++i) {
        if (!(pids[i] = fork())) {
            do_primes();
            exit(0);
        }
        if (pids[i] < 0) {
            perror("Fork");
            exit(1);
        }
    }
    for (i = 0; i < NUM_OF_CORES; ++i) {
        waitpid(pids[i], NULL, 0);
    }
    end = time(NULL);
    run_time = (end - start);
    printf("This machine calculated all prime numbers under %d %d times "
           "in %d seconds\n", MAX_PRIME, NUM_OF_CORES, run_time);
    return 0;
}

输出量

$ ./primes 
Calculated 9592 primes.
Calculated 9592 primes.
Calculated 9592 primes.
Calculated 9592 primes.
Calculated 9592 primes.
Calculated 9592 primes.
Calculated 9592 primes.
Calculated 9592 primes.
This machine calculated all prime numbers under 100000 8 times in 8 seconds

我们真的很想看看它能走多快！

您生成质数的算法效率很低。将其与Primegen在奔腾II-350上仅用8秒钟即可生成高达50000000534的灌注量的Primegen进行比较。

要轻松消耗所有CPU，您可以解决一个令人尴尬的并行问题，例如，计算Mandelbrot集或使用遗传编程在多个线程（进程）中绘制Mona Lisa。

另一种方法是采用Cray超级计算机的现有基准测试程序，并将其移植到现代PC上。

十六进制核心处理器获得15％的收益的原因是因为您的代码在100％的情况下使用1个核心。100/6 = 16.67％，使用移动平均和流程计划（您的流程将在正常优先级下运行）可以很容易地报告为15％。

因此，为了使用100％cpu，您将需要使用CPU的所有内核-为六核内核CPU启动6个并行执行代码路径，并且可以将此规模扩展到Cray计算机拥有的许多处理器：）

也要非常清楚如何加载CPU。一个CPU可以完成许多不同的任务，尽管许多任务都被报告为“ 100％加载CPU”，但它们各自可能占用100％的CPU不同部分。换句话说，很难比较两个不同的CPU的性能，尤其是两个不同的CPU体系结构。执行任务A可能会使一个CPU优先于另一个CPU，而执行任务B则很容易采用另一种方法（因为两个CPU内部可能具有不同的资源，并且执行的代码可能非常不同）。

这就是为什么软件与使硬件达到最佳性能同样重要的原因。对于“超级计算机”也确实如此。

一种衡量CPU性能的指标可能是每秒的指令数，但是在不同的CPU架构上，指令的创建就不同了。另一个指标可能是缓存IO性能，但缓存基础架构也不相等。然后，度量可能是所使用的每瓦特指令数，因为功率和功耗通常是设计集群计算机时的限制因素。

因此，您的第一个问题应该是：哪个性能参数对您很重要？您要测量什么？如果要查看哪台机器在Quake 4中获得最高的FPS，答案很简单；您的游戏设备将会运行，因为Cray根本无法运行该程序;-)

欢呼声，斯蒂恩

TLDR；公认的答案既低效又不兼容。关注算法的速度提高了100倍。

MAC上可用的gcc编译器无法运行omp。我必须安装llvm (brew install llvm )。但是我没有看到运行OMP版本时CPU空闲状态会下降。

这是运行OMP版本时的屏幕截图。

另外，我使用了基本的POSIX线程，该线程可以使用任何c编译器运行，当nos of thread= no of cores= 4（MacBook Pro，2.3 GHz Intel Core i5）时，几乎消耗了整个CPU。这是程序-

#include <pthread.h>
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#define NUM_THREADS     10
#define THREAD_LOAD 100000
using namespace std;

struct prime_range {
    int min;
    int max;
    int total;
};

void* findPrime(void *threadarg)
{
    int i, primes = 0;
    struct prime_range *this_range;
    this_range = (struct prime_range *) threadarg;

    int minLimit =  this_range -> min ;
    int maxLimit =  this_range -> max ;
    int flag = false;
    while (minLimit <= maxLimit) {
        i = 2;
        int lim = ceil(sqrt(minLimit));
        while (i <= lim) {
            if (minLimit % i == 0){
                flag = true;
                break;
            }
            i++;
        }
        if (!flag){
            primes++;
        }
        flag = false;
        minLimit++;
    }
    this_range ->total = primes;
    pthread_exit(NULL);
}

int main (int argc, char *argv[])
{
    struct timespec start, finish;
    double elapsed;

    clock_gettime(CLOCK_MONOTONIC, &start);

    pthread_t threads[NUM_THREADS];
    struct prime_range pr[NUM_THREADS];
    int rc;
    pthread_attr_t attr;
    void *status;
    pthread_attr_init(&attr);
    pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_JOINABLE);
    for(int t=1; t<= NUM_THREADS; t++){
        pr[t].min = (t-1) * THREAD_LOAD + 1;
        pr[t].max = t*THREAD_LOAD;
        rc = pthread_create(&threads[t], NULL, findPrime,(void *)&pr[t]);
        if (rc){
            printf("ERROR; return code from pthread_create() is %d\n", rc);
            exit(-1);
        }
    }
    int totalPrimesFound = 0;
    // free attribute and wait for the other threads
    pthread_attr_destroy(&attr);
    for(int t=1; t<= NUM_THREADS; t++){
        rc = pthread_join(threads[t], &status);
        if (rc) {
            printf("Error:unable to join, %d" ,rc);
            exit(-1);
        }
        totalPrimesFound += pr[t].total;
    }
    clock_gettime(CLOCK_MONOTONIC, &finish);
    elapsed = (finish.tv_sec - start.tv_sec);
    elapsed += (finish.tv_nsec - start.tv_nsec) / 1000000000.0;
    printf("This machine calculated all %d prime numbers under %d in %lf seconds\n",totalPrimesFound, NUM_THREADS*THREAD_LOAD, elapsed);
    pthread_exit(NULL);
}

请注意整个CPU是如何用完的-

PS-如果增加线程数，则实际CPU使用率会下降（尝试使线程数=20。），因为系统在上下文切换中使用的时间比实际计算要多。

顺便说一句，我的机器不如@mystical强大（接受的答案）。但是我的带有基本POSIX线程的版本比OMP更快。结果是-

PS在不到一秒钟的时间内完成处理，将线程负载增加到250万以查看CPU使用率。

尝试使用例如OpenMP并行化程序。这是组成并行程序的非常简单有效的框架。

为了快速改善一个内核，请删除系统调用以减少上下文切换。删除这些行：

system("clear");
printf("%d prime numbers calculated\n",primes);

第一个特别糟糕，因为它每次迭代都会产生一个新进程。

只需尝试对一个大文件进行Zip和解压缩，什么都不会做，因为繁重的I / O操作可以使用cpu。