Як отримати 100% використання центрального процесора від програми C.

Це досить цікаве питання, тож дозвольте мені встановити сцену. Я працюю в Національному музеї обчислювальної техніки, і нам щойно вдалося придбати суперкомп’ютер Cray Y-MP EL з 1992 року, і ми справді хочемо побачити, як швидко він може йти!

Ми вирішили, що найкращий спосіб зробити це - написати просту програму на С, яка б обчислювала прості числа і показувала, скільки часу це потрібно, а потім запускала програму на швидкому сучасному настільному ПК та порівнювала результати.

Ми швидко придумали цей код для підрахунку простих чисел:

#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 (The Cray працює UNICOS), працював ідеально, використовуючи 100% процесора і займаючи близько 10 хвилин. Повернувшись додому, я вирішив спробувати його на своєму сучасному ігровому ПК із шістнадцятковим процесором, і саме тут ми отримуємо свої перші випуски.

Я вперше пристосував код для роботи в Windows, оскільки саме цим користувався ігровий ПК, але із сумом виявив, що процес отримував лише близько 15% потужності центрального процесора. Я зрозумів, що це, мабуть, Windows, а не Windows, тому я завантажив живий компакт-диск Ubuntu, думаючи, що Ubuntu дозволить запустити процес із повним потенціалом, як це було раніше на моєму ноутбуці.

Однак я отримав лише 5% використання! Отже, моє питання полягає в тому, як я можу адаптувати програму для запуску на моєму ігровому автоматі або в Windows 7, або в живій Linux зі 100% завантаженням центрального процесора? Ще одне, що було б чудово, але не потрібно, - якщо кінцевим продуктом може бути один .exe, який можна легко розповсюджувати та запускати на машинах Windows.

Дуже дякую!

PS Звичайно, ця програма насправді не працювала зі спеціалізованими процесорами Crays 8, і це вже зовсім інше питання ... Якщо ви щось знаєте про оптимізацію коду для роботи на супер-комп’ютерах Cray 90-х, теж нам крикніть!

Якщо ви хочете 100% процесора, вам потрібно використовувати більше 1 ядра. Для цього вам потрібно кілька потоків.

Ось паралельна версія за допомогою 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;
}

Вихід:

Ця машина розрахувала всі 78498 простих чисел менше 1000000 за 29,753 секунди

Ось ваш 100% процесор:

Ви запускаєте один процес на багатоядерній машині, тож він працює лише на одному ядрі.

Рішення досить просте, оскільки ви просто намагаєтеся прив’язати процесор - якщо у вас 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, який генерує прості числа 50847534 до 1000000000 всього за 8 секунд на Pentium II-350.

Щоб легко споживати всі процесори, ви можете вирішити незручно паралельну проблему, наприклад, обчислити набір Мандельброта або скористатися генетичним програмуванням, щоб намалювати Мона Лізу в декількох потоках (процесах).

Інший підхід - взяти існуючу контрольну програму для суперкомп’ютера Cray і перенести її на сучасний ПК.

Причиною того, що ви отримуєте 15% на шестигранному процесорі, є те, що ваш код використовує 1 ядро ​​на 100%. 100/6 = 16,67%, що з використанням ковзного середнього з плануванням процесу (ваш процес працював би за нормальним пріоритетом) можна легко повідомити як 15%.

Отже, для того, щоб використовувати 100% процесор, вам потрібно було б використовувати всі ядра вашого центрального процесора - запустити 6 паралельних шляхів виконання коду для шестигранного центрального процесора і мати цей масштаб аж до кількості процесорів, які має ваша машина Cray :)

Також добре знайте, як ви завантажуєте центральний процесор. Процесор може виконувати багато різних завдань, і хоча багато хто з них буде повідомлено як "завантаження процесора на 100%", кожен з них може використовувати 100% різних частин процесора. Іншими словами, дуже важко порівняти два різних ЦП за продуктивністю, і особливо дві різні архітектури ЦП. Виконання завдання A може надавати перевагу одному центральному процесору над іншим, а виконуючи завдання B - може бути навпаки (оскільки ці два процесори можуть мати різні ресурси всередині і можуть виконувати код по-різному).

Ось чому програмне забезпечення так само важливо для забезпечення оптимальної роботи комп’ютерів, як і апаратне забезпечення. Це справді дуже актуально і для "суперкомп'ютерів".

Одним показником продуктивності процесора можуть бути інструкції в секунду, але знову ж таки інструкції не створюються рівними на різних архітектурах процесора. Ще одним показником може бути продуктивність кешування вводу-виводу, але інфраструктура кешування теж не є рівною. Тоді мірою може бути кількість інструкцій на використаний ват, оскільки подача та розсіювання енергії часто є обмежуючим фактором при проектуванні кластерного комп'ютера.

Тож першим вашим запитанням має бути: Який параметр ефективності для вас важливий? Що ви хочете виміряти? Якщо ви хочете побачити, яка машина отримує найбільше FPS у Quake 4, відповідь проста; ваша ігрова установка буде, оскільки Cray взагалі не може запустити цю програму ;-)

Вітаю, Стін

TLDR; Прийнята відповідь є одночасно неефективною та несумісною. Наступний алго працює в 100 разів швидше.

Компілятор gcc, доступний на MAC, не може працювати omp. Мені довелося встановити llvm (brew install llvm ). Але я не бачив, що простой процесора падав під час запуску версії OMP.

Ось знімок екрана під час запуску версії OMP.

Крім того, я використовував базовий потік POSIX, який можна запустити за допомогою будь-якого компілятора c, і побачив, що майже весь процесор витрачається, коли nos of thread= no of cores= 4 (MacBook Pro, 2,3 ГГц Intel Core i5). Ось програма -

#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);
}

Зверніть увагу, як витрачений весь процесор -

PS - Якщо ви не збільшуєте кількість потоків, фактичне використання центрального процесора зменшується (спробуйте вказати кількість потоків = 20.), оскільки система використовує більше часу на перемикання контексту, ніж фактичні обчислення.

До речі, моя машина не така міцна, як @mystical (Прийнята відповідь). Але моя версія з базовими потоковими потоками POSIX працює набагато швидше, ніж OMP. Ось результат -

PS Збільште навантаження потоків до 2,5 мільйонів, щоб побачити використання процесора, оскільки воно завершується менш ніж за секунду.

Спробуйте розпаралелювати вашу програму, використовуючи, наприклад, OpenMP. Це дуже проста та ефективна основа для складання паралельних програм.

Для швидкого вдосконалення одного ядра видаліть системні дзвінки, щоб зменшити перемикання контексту. Видаліть ці рядки:

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

Перший особливо поганий, оскільки він породжує новий процес на кожній ітерації.

Просто спробуйте заархівувати та розпакувати великий файл, ніщо, як важкі операції вводу-виводу, не може використовувати процесор.