openmp
अनियमित OpenMP समानता

टिप्पणियों

#pragma omp parallel
#pragma omp single
...
   #pragma omp task
   { code for a given task; }
...

OpenMP कार्यों का उपयोग करके एक c ++ सूची कंटेनर के समानांतर प्रसंस्करण

#include <omp.h>
#include <unistd.h>
#include <iostream>
#include <list>

static void processElement (unsigned n)
{
    // Tell who am I. The #pragma omp critical ensures that
    // only one thread sends data to std::cout
    #pragma omp critical
    std::cout <<
      "Thread " << omp_get_thread_num() << " processing element " << n
      << std::endl;

    // Simulate some work
    usleep (n*1000);
}

int main (void)
{
    std::list<unsigned> lst;

    // Fill the list
    for (unsigned u = 0; u < 16; ++u)
            lst.push_back (1+u);

    // Now process each element of the list in parallel

    #pragma omp parallel  // Create a parallel region
    #pragma omp single    // Only one thread will instantiate tasks
    {
            for (auto element : lst)
            {
                    #pragma omp task firstprivate (element)
                    processElement (element);
            }

            // Wait for all tasks to be finished
            #pragma omp taskwait
    }

    return 0;
}

यह उदाहरण OpenMP कार्य निर्माण ( #pragma omp task निर्देश का उपयोग करके) के माध्यम से समानांतर में एक STL सूची (कोड में lst नाम) के प्रसंस्करण का अनुकरण करता है। उदाहरण lst में प्रत्येक तत्व के लिए एक OpenMP कार्य बनाता है / चलाता है और OpenMP धागे कार्य चलाने के लिए तैयार होते ही निष्पादित करते हैं।

$ OMP_NUM_THREADS=4 ./a.out
Thread 0 processing element 16
Thread 3 processing element 3
Thread 2 processing element 1
Thread 1 processing element 2
Thread 2 processing element 4
Thread 1 processing element 5
Thread 3 processing element 6
Thread 2 processing element 7
Thread 1 processing element 8
Thread 3 processing element 9
Thread 2 processing element 10
Thread 1 processing element 11
Thread 0 processing element 15
Thread 3 processing element 12
Thread 2 processing element 13
Thread 1 processing element 14

OpenMP कार्यों का उपयोग करके पाई के लिए पुनरावर्ती गणना

नीचे दिया गया कोड पुनरावर्ती दृष्टिकोण का उपयोग करके पीआई के मूल्य की गणना करता है। यह MAX_PARALLEL_RECURSIVE_LEVEL लिए कि कौन सा पुनरावर्तन गहराई बनाना कार्य बनाना बंद कर देता है, MAX_PARALLEL_RECURSIVE_LEVEL मान को संशोधित करें। इस दृष्टिकोण के साथ पुनरावर्ती अनुप्रयोगों से समानता पैदा करने के लिए: जितने अधिक कार्य आप बनाते हैं, उतने ही अधिक समानांतर कार्य बनाए जाते हैं, लेकिन यह भी कम काम करता है। इसलिए आवेदन के साथ प्रयोग करना सुविधाजनक है कि यह समझने के लिए कि किस स्तर पर आगे के कार्य बनाने से प्रदर्शन के मामले में लाभ नहीं होता है।

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

double pi_r (double h, unsigned depth, unsigned maxdepth, unsigned long long begin, unsigned long long niters)
{
    if (depth < maxdepth)
    {
        double area1, area2;

        // Process first half
        #pragma omp task shared(area1)
        area1 = pi_r (h, depth+1, maxdepth, begin, niters/2-1);

        // Process second half
        #pragma omp task shared(area2)
        area2 = pi_r (h, depth+1, maxdepth, begin+niters/2, niters/2);

        #pragma omp taskwait

        return area1+area2;
    }
    else
    {

        unsigned long long i;
        double area = 0.0;

        for (i = begin; i <= begin+niters; i++)
        {
            double x = h * (i - 0.5);
            area += (4.0 / (1.0 + x*x));
        }

        return area;
    }
}

double pi (unsigned long long niters)
{
    double res;
    double h = 1.0 / (double) niters;

    #pragma omp parallel shared(res)
    {
#define MAX_PARALLEL_RECURSIVE_LEVEL 4

        #pragma omp single
        res = pi_r (h, 0, MAX_PARALLEL_RECURSIVE_LEVEL, 1, niters);
    }
    return res * h;
}


int main (int argc, char *argv[])
{
#define NITERS (100*1000*1000ULL)

    printf ("PI (w/%d iters) is %lf\n", NITERS, pi(NITERS));

    return 0;
}