C प्रोग्राम से 100% CPU उपयोग कैसे प्राप्त करें

Question 1

यह काफी दिलचस्प सवाल है तो मुझे सीन सेट करने दीजिए। मैं द नेशनल म्यूजियम ऑफ़ कम्प्यूटिंग में काम करता हूं, और हम 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);
}

हमारे दोहरे कोर लैपटॉप पर जो उबंटू चल रहा है (क्रे क्रे यूनिकोस चलाता है), पूरी तरह से काम करता है, 100% सीपीयू का उपयोग कर रहा है और लगभग 10 मिनट या तो ले रहा है। जब मुझे घर मिला तो मैंने अपने हेक्स-कोर आधुनिक गेमिंग पीसी पर इसे आजमाने का फैसला किया और यही वह जगह है जहां हमें अपने पहले मुद्दे मिलते हैं।

मैंने पहली बार विंडोज पर चलने के लिए कोड को अनुकूलित किया था, क्योंकि गेमिंग पीसी जो उपयोग कर रहा था, लेकिन यह जानकर दुख हुआ कि यह प्रक्रिया केवल सीपीयू की शक्ति का लगभग 15% थी। मुझे लगा कि विंडोज विंडोज होना चाहिए, इसलिए मैंने उबंटू की एक लाइव सीडी में यह सोचकर बूट किया कि उबंटू अपनी पूरी क्षमता के साथ प्रक्रिया को चलाने की अनुमति देगा जैसा कि उसने पहले मेरे लैपटॉप पर किया था।

हालाँकि मुझे केवल 5% उपयोग मिला! तो मेरा सवाल यह है कि, मैं अपने गेमिंग मशीन पर चलने के लिए प्रोग्राम को विंडोज 7 या लाइव लिनक्स में 100% CPU उपयोग में कैसे अनुकूलित कर सकता हूं? एक और चीज जो बहुत अच्छी होगी लेकिन जरूरी नहीं है कि अंतिम उत्पाद एक .exe हो सकता है जिसे आसानी से वितरित किया जा सकता है और विंडोज मशीनों पर चलाया जा सकता है।

आपका बहुत बहुत धन्यवाद!

निश्चित रूप से इस कार्यक्रम वास्तव में Crays 8 विशेषज्ञ प्रोसेसर के साथ काम नहीं किया, और यह एक पूरी अन्य समस्या है ... यदि आप 90 के क्रे सुपर कंप्यूटरों पर काम करने के लिए कोड के अनुकूलन के बारे में कुछ भी जानते हैं तो हमें एक चिल्लाओ!

Question 2

यदि आप 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% CPU है:

यहाँ छवि विवरण दर्ज करें

Question 3

आप मल्टी-कोर मशीन पर एक प्रक्रिया चला रहे हैं - इसलिए यह केवल एक कोर पर चलती है।

समाधान काफी आसान है, क्योंकि आप सिर्फ प्रोसेसर को खूंटे के लिए कोशिश कर रहे हैं - यदि आपके पास एन कोर है, तो अपना प्रोग्राम एन बार चलाएं (समानांतर में, निश्चित रूप से)।

उदाहरण

यहां कुछ कोड हैं जो NUM_OF_CORESसमानांतर में आपके प्रोग्राम को चलाते हैं। यह POSIXy कोड है - यह उपयोग करता है fork- इसलिए आपको लिनक्स के तहत चलना चाहिए। यदि मैं क्रे के बारे में जो पढ़ रहा हूं वह सही है, तो इस कोड को 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

Question 4

हम वास्तव में देखना चाहते हैं कि यह कितनी तेजी से आगे बढ़ सकता है!

अभाज्य संख्याएँ उत्पन्न करने के लिए आपका एल्गोरिथ्म बहुत अक्षम है। इसकी तुलना प्रेजेन से करें जो एक पेंटियम II-350 पर केवल 8 सेकंड में 50847534 से 1000000000 तक उत्पन्न करता है।

आसानी से सभी सीपीयू का उपभोग करने के लिए आप एक शर्मनाक समानांतर समस्या को हल कर सकते हैं , जैसे, मैंडलब्रॉट सेट की गणना करें या एकाधिक थ्रेड्स (प्रक्रियाओं) में मोना लिसा को पेंट करने के लिए आनुवंशिक प्रोग्रामिंग का उपयोग करें ।

एक और तरीका यह है कि क्रे सुपर कंप्यूटर के लिए एक मौजूदा बेंचमार्क प्रोग्राम लिया जाए और इसे एक आधुनिक पीसी में पोर्ट किया जाए।

Question 5

हेक्स कोर प्रोसेसर पर आपको 15% का कारण मिल रहा है क्योंकि आपका कोड 100% पर 1 कोर का उपयोग करता है। 100/6 = 16.67%, जो प्रक्रिया निर्धारण के साथ एक चलती औसत का उपयोग कर रहा है (आपकी प्रक्रिया सामान्य प्राथमिकता के तहत चल रही होगी) आसानी से 15% के रूप में रिपोर्ट की जा सकती है।

इसलिए, 100% सीपीयू का उपयोग करने के लिए, आपको अपने सीपीयू के सभी कोर का उपयोग करने की आवश्यकता होगी - एक हेक्स कोर सीपीयू के लिए 6 समानांतर निष्पादन कोड पथ लॉन्च करें और इस पैमाने को सही करें, हालांकि आपके क्रे मशीन में कई प्रोसेसर हैं :)

Question 6

यह भी जान लें कि आप CPU को कैसे लोड कर रहे हैं। एक CPU कई अलग-अलग कार्य कर सकता है, और जब उनमें से कई को "CPU 100% लोड करना" के रूप में सूचित किया जाएगा, तो वे प्रत्येक CPU के विभिन्न भागों के 100% का उपयोग कर सकते हैं। दूसरे शब्दों में, प्रदर्शन के लिए दो अलग-अलग सीपीयू और विशेष रूप से दो अलग-अलग सीपीयू आर्किटेक्चर की तुलना करना बहुत कठिन है। निष्पादन कार्य A दूसरे पर एक CPU का पक्ष ले सकता है, जबकि कार्य B निष्पादित करते समय यह आसानी से दूसरे तरीके से हो सकता है (क्योंकि दो CPU में अलग-अलग संसाधन हो सकते हैं और कोड को बहुत अलग तरीके से निष्पादित कर सकते हैं)।

यही कारण है कि सॉफ्टवेयर उतना ही महत्वपूर्ण है जितना कि कंप्यूटर का प्रदर्शन उतना ही बेहतर है जितना कि हार्डवेयर। यह वास्तव में "सुपर कंप्यूटर" के लिए भी बहुत सही है।

सीपीयू प्रदर्शन के लिए एक उपाय प्रति सेकंड निर्देश हो सकता है, लेकिन फिर अलग सीपीयू आर्किटेक्चर पर फिर से निर्देश समान नहीं बनाए जाते हैं। एक और उपाय कैश IO प्रदर्शन हो सकता है, लेकिन कैश इन्फ्रास्ट्रक्चर समान नहीं है। तब एक माप प्रति वाट इस्तेमाल किए जाने वाले निर्देशों की संख्या हो सकती है, क्योंकि क्लस्टर कंप्यूटर को डिज़ाइन करते समय बिजली वितरण और अपव्यय अक्सर एक सीमित कारक होता है।

तो आपका पहला सवाल यह होना चाहिए: कौन सा प्रदर्शन पैरामीटर आपके लिए महत्वपूर्ण है? आप क्या मापना चाहते हैं? यदि आप यह देखना चाहते हैं कि कौन सी मशीन क्वेक 4 में से सबसे अधिक एफपीएस प्राप्त करती है, तो इसका उत्तर आसान है; अपने गेमिंग रिग होगा, क्योंकि क्रे उस कार्यक्रम को बिल्कुल भी नहीं चला सकता; ;-)

चीयर्स, स्टीन

Question 7

TLDR; स्वीकृत उत्तर अक्षम और असंगत दोनों है। निम्नलिखित एल्गो 100x तेजी से काम करता है ।

मैक पर उपलब्ध gcc संकलक नहीं चल सकता omp। मुझे llvm इंस्टॉल करना था (brew install llvm )। लेकिन मैंने यह नहीं देखा कि OMP संस्करण चलाते समय CPU निष्क्रिय हो रहा था ।

यहाँ एक स्क्रीनशॉट है जबकि OMP संस्करण चल रहा था।

वैकल्पिक रूप से, मैं बुनियादी POSIX धागा, कि किसी भी ग संकलक और का उपयोग कर चलाया जा सकता है इस्तेमाल किया देखा लगभग पूरे सीपीयू का इस्तेमाल किया जब nos of thread= no of cores= 4 (मैकबुक प्रो, 2.3 GHz इंटेल कोर 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);
}

ध्यान दें कि संपूर्ण CPU का उपयोग कैसे किया जाता है -

PS - यदि आप थ्रेड्स की संख्या नहीं बढ़ाते हैं तो वास्तविक CPU उपयोग कम हो जाता है (कोशिश करें कि थ्रेड्स की संख्या = 20 न बनाएं।) क्योंकि सिस्टम वास्तविक कंप्यूटिंग की तुलना में संदर्भ स्विचिंग में अधिक समय का उपयोग करता है।

वैसे, मेरी मशीन @mystical (स्वीकृत उत्तर) के रूप में गोमांस नहीं है। लेकिन बेसिक POSIX थ्रेडिंग के साथ मेरा संस्करण OMP एक की तुलना में तेजी से काम करता है। यहाँ परिणाम है -

PS CPU उपयोग को देखने के लिए थ्रेडलोड को 2.5 मिलियन तक बढ़ाता है, क्योंकि यह एक सेकंड से भी कम समय में पूरा होता है।

Question 8

उदाहरण के लिए, ओपनएमपी का उपयोग करके अपने प्रोग्राम को समानांतर करने की कोशिश करें। यह समानांतर कार्यक्रम बनाने के लिए एक बहुत ही सरल और प्रभावी ढांचा है।

Question 9

एक कोर पर त्वरित सुधार के लिए, संदर्भ-स्विचिंग को कम करने के लिए सिस्टम कॉल निकालें। इन लाइनों को हटा दें:

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

पहला विशेष रूप से खराब है, क्योंकि यह हर पुनरावृत्ति को एक नई प्रक्रिया देगा।

Question 10

बस एक बड़ी फ़ाइल को ज़िप और अनज़िप करने की कोशिश करें, भारी आई / ओ संचालन के रूप में कुछ भी सीपीयू का उपयोग नहीं कर सकता है।