सी ++ में एकाधिक धागे के बीच स्मृति संघर्ष खोजें

मान लीजिए कि हमारे पास एक RAM है और वह RAM ब्लॉकों में व्यवस्थित है। सिस्टम पर कई प्रक्रियाएं चल रही हैं। हमें यह ध्यान रखना होगा कि प्रत्येक प्रक्रिया को निम्नलिखित जानकारी मिलती है, (थ्रेड टी, मेमोरी ब्लॉक एम, समय टी, आर/डब्ल्यू) यह इंगित करता है कि थ्रेड टी निश्चित समय पर मेमोरी ब्लॉक एम लागू कर रहा था और ऑपरेशन या तो पढ़ा जा सकता था (आर ) या लिखें (डब्ल्यू)।

निम्नलिखित मामला यह संकेत दे रहा है कि यह स्मृति संघर्ष है या नहीं -

• एक ही स्थान पर एक से अधिक पठन संचालन संघर्ष का कारण नहीं हैं।

• जब एम के स्थान पर x+5 से x-5 के बीच लेखन कार्य किया जा रहा हो, तो यह समय x पर थ्रेड एक्सेस करने वाले स्थान M के लिए एक संघर्ष पैदा करने के लिए जिम्मेदार होगा जहां x को कुछ समय कहा जाता है।

इसलिए, यदि थ्रेड T1 ने समय x+1 पर मेमोरी लोकेशन M को एक्सेस किया और थ्रेड T2 ने x+6 से पहले स्थान M को एक्सेस किया, तो T1 और T2 में विरोध हो रहा है, जब उनमें से कोई एक ऑपरेशन लिखता है।

यदि हमारे पास मेमोरी स्थानों तक पहुँचने वाले थ्रेड्स की एक सूची है। हमें सभी विरोधों को खोजना होगा।

तो, अगर इनपुट [(1, 932, 1, आर), (2, 512, 2, डब्ल्यू), (3, 932, 3, आर), (4, 512, 4, आर), (5 , 432, 5, आर), (6, 512, 6, आर), (7, 835, 7, डब्ल्यू), (8, 432, 8, आर)], तो आउटपुट परस्पर विरोधी धागे होंगे (2, 4 ) और (2, 6), और अन्य सभी ऑपरेशन समान हैं।

इसे हल करने के लिए, हम इन चरणों का पालन करेंगे -

• आईडी, मेमोरी_ब्लॉक, समय और संचालन के साथ थ्रेड बनाएं

• मेमोरी ब्लॉक के आधार पर सरणी th_arr को सॉर्ट करें, जब मेमोरी ब्लॉक समान हों तो समय का उपयोग करें।

• इनिशियलाइज़ i :=1 के लिए, जब i - n, अपडेट करें (i को 1 से बढ़ाएँ), करें -

  • अगर th_arr[i].memory_block, th_arr[i - 1].memory_block के समान है, तो -

    • अगर th_arr[i].time <=th_arr[i-1].time+5, फिर -

      • जे:=मैं - 1

      • जबकि (th_arr[i].memory_block, th_arr[j].memory_block और th_arr[i].time <=th_arr[j].time+5 और j>=0) के समान है, करते हैं -

        • अगर th_arr[i].ऑपरेशन 'W' या th_arr[j] के समान है। ऑपरेशन 'W' के समान है, तो -

          • परस्पर विरोधी धागे th_arr[j] और th_arr[i]

            . प्रदर्शित करें

        • (j को 1 से घटाएं)

उदाहरण (C++)

आइए बेहतर समझ पाने के लिए निम्नलिखित कार्यान्वयन देखें -

#include<bits/stdc++.h>
using namespace std;
class Thread {
   public:
   int id, memory_block, time;
   char operation;
};
bool compare(const Thread& x, const Thread& y) {
   if (x.memory_block == y.memory_block)
      return x.time < y.time;
   else return x.memory_block < y.memory_block;
}
void display_conflicts(Thread th_arr[], int n) {
   sort(th_arr, th_arr+n, compare);
   for (int i = 1; i < n; i++) {
      if(th_arr[i].memory_block == th_arr[i-1].memory_block) {
         if (th_arr[i].time <= th_arr[i-1].time+5) {
            int j = i-1;
            while (th_arr[i].memory_block == th_arr[j].memory_block && th_arr[i].time <= th_arr[j].time+5 && j >= 0) {
               if (th_arr[i].operation == 'W' || th_arr[j].operation == 'W') {
                  cout << "Conflicting threads [" << th_arr[j].id << ", " << th_arr[i].id << "]\n";
               }
               j--;
            }
         }
      }
   }
}
int main() {
   Thread th_arr[] = {{1, 932, 1, 'R'},{2, 512, 2, 'W'},{3, 932, 3, 'R'}, {4, 512, 4, 'R'},{5, 432, 5, 'R'}, {6, 512, 6, 'R'},{7, 835, 7, 'W'}, {8, 432, 8, 'R'}};
   int n = sizeof(th_arr)/sizeof(th_arr[0]);
   display_conflicts(th_arr, n);
}

इनपुट

{{1, 932, 1, 'R'},{2, 512, 2, 'W'},{3, 932, 3, 'R'}, {4, 512, 4,
'R'},{5, 432, 5, 'R'}, {6, 512, 6, 'R'},{7, 835, 7, 'W'}, {8, 432, 8,
'R'}}

आउटपुट

Conflicting threads [2, 4]
Conflicting threads [2, 6]