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

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

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

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

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

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

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

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

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

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

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

h = 1.0 / n;

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

  #pragma omp for
  for (i = 1; i <= n; i++)
  {
    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
}

pi = h * area;

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