openmp
ओपनएमपी की कटौती

टिप्पणियों

पीआई के हाथ लगाने का अंदेशा- # प्रगामा ऑप्स कमी को दर्शाता है

int i;
int n = 1000000;
double area = 0;
double h = 1.0 / n;

#pragma omp parallel shared(n, h)
{
  double thread_area = 0;                      // Private / local variable

  #pragma omp for
  for (i = 1; i <= n; i++)
  {
    double x = h * (i - 0.5);
    thread_area += (4.0 / (1.0 + x*x));
  }

  #pragma omp atomic                       // Applies the reduction manually
  area += thread_area;                     // All threads aggregate into area
}
double pi = h * area;

थ्रेड्स को #pragma omp पैरेलल में स्पॉन किया गया है। प्रत्येक थ्रेड में एक स्वतंत्र / निजी थ्रेड_एरिया होगा जो इसके आंशिक जोड़ को संग्रहीत करता है। निम्नलिखित लूप के लिए #pragma omp का उपयोग करके थ्रेड्स के बीच वितरित किया जाता है। इस लूप में, प्रत्येक थ्रेड अपने स्वयं के थ्रेड_ की गणना करता है और इस लूप के बाद, कोड क्रमिक रूप से क्षेत्र को परमाणु के माध्यम से एकत्रित करता है

#Pragma परमाणु पर आधारित कटौती का उपयोग करके PI का अनुमान

double area;
double h = 1.0 / n;
#pragma omp parallel for shared(n, h, area) 
for (i = 1; i <= n; i++)
{
  double x = h * (i - 0.5);
  #pragma atomic
  area += (4.0 / (1.0 + x*x));
}
pi = h * area;

इस उदाहरण में, प्रत्येक थ्रेड्स पुनरावृत्ति गणना के सबसेट को निष्पादित करते हैं और वे परमाणु रूप से साझा चर क्षेत्र में जमा होते हैं, जो यह सुनिश्चित करता है कि कोई खोए हुए अपडेट नहीं हैं। हम यहां #pragma परमाणु का उपयोग कर सकते हैं क्योंकि दिए गए ऑपरेशन (+ =) को परमाणु रूप से किया जा सकता है, जो कि #pragma omp आलोचनात्मक के उपयोग की तुलना में पठनीयता को सरल करता है।

#Pragma omp क्रिटिकल के आधार पर कटौती का उपयोग कर पीआई का अनुमान

double area;
double h = 1.0 / n;
#pragma omp parallel for shared(n, h, area) 
for (i = 1; i <= n; i++)
{
  double x = h * (i - 0.5);
  #pragma omp critical
  {
    area += (4.0 / (1.0 + x*x));
  }
}
double pi = h * area;

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

#Pragma omp कमी क्लॉज का उपयोग करके पीआई का अनुमान

int i;
int n = 1000000;
double area = 0;
double h = 1.0 / n;
#pragma omp parallel for shared(n, h) reduction(+:area) 
for (i = 1; i <= n; i++)
{
  double x = h * (i - 0.5);
  area += (4.0 / (1.0 + x*x));
}
pi = h * area;

इस उदाहरण में, प्रत्येक थ्रेड पुनरावृत्ति गणना का सबसेट निष्पादित करता है। प्रत्येक थ्रेड में क्षेत्र की अपनी स्थानीय निजी प्रतिलिपि होती है और समानांतर क्षेत्र के अंत में वे सभी अतिरिक्त ऑपरेशन (+) लागू करते हैं ताकि क्षेत्र के लिए अंतिम मान उत्पन्न हो सके।