झूठी साझाकरण और ढेर चर

Question

मेरे पास छोटे लेकिन अक्सर फ़ंक्शन ऑब्जेक्ट्स का उपयोग किया जाता है। प्रत्येक धागे की अपनी प्रति प्राप्त होती है। सबकुछ स्थिर रूप से आवंटित किया जाता है। प्रतियां किसी वैश्विक या स्थैतिक डेटा को साझा नहीं करती हैं। क्या मुझे इस ऑब्जेक्ट को झूठी साझाकरण से बचाने की ज़रूरत है?

धन्यवाद। संपादित करें: यहां एक खिलौना प्रोग्राम है जो बूस्ट का उपयोग करता है। थ्रेड। क्षेत्र डेटा के लिए झूठी साझाकरण हो सकती है?

#include <boost/thread/thread.hpp> 

struct Work { 
    void operator()() { 
     ++data; 
    } 

    int data; 
}; 

int main() { 
    boost::thread_group threads; 
    for (int i = 0; i < 10; ++i) 
     threads.create_thread(Work()); 
    threads.join_all(); 
} 

Answer 1

धागे के बीच झूठी साझाकरण तब होती है जब 2 या अधिक धागे एक ही कैश लाइन का उपयोग करते हैं।

उदा। :

struct Work { 
    Work(int& d) : data(d) {} 
    void operator()() { 
     ++data; 
    } 

    int& data; 
}; 

int main() { 
    int false_sharing[10] = { 0 }; 
    boost::thread_group threads; 
    for (int i = 0; i < 10; ++i) 
     threads.create_thread(Work(false_sharing[i])); 
    threads.join_all(); 

    int no_false_sharing[10 * CACHELINE_SIZE_INTS] = { 0 }; 
    for (int i = 0; i < 10; ++i) 
     threads.create_thread(Work(no_false_sharing[i * CACHELINE_SIZE_INTS])); 
    threads.join_all(); 
} 

पहले ब्लॉक में धागे झूठी साझाकरण से ग्रस्त हैं। दूसरे ब्लॉक में धागे नहीं (CACHELINE_SIZE के लिए धन्यवाद)।

ढेर पर डेटा हमेशा अन्य धागे से दूर 'दूर' होता है। (खिड़कियों के नीचे, कम से कम कुछ पेज)।

फ़ंक्शन ऑब्जेक्ट की आपकी परिभाषा के साथ, झूठी साझाकरण दिखाई दे सकती है, क्योंकि Work के उदाहरण ढेर पर बनाए जाते हैं और यह ढेर स्थान थ्रेड के अंदर उपयोग किया जाता है।

इससे कई Work उदाहरण सामने आ सकते हैं और इसलिए कैश लाइनों को साझा करना पड़ सकता है।

लेकिन ... आपका नमूना समझ में नहीं आता है, क्योंकि डेटा को कभी भी स्पर्श नहीं किया जाता है और इसलिए झूठी साझाकरण को बेकार ढंग से प्रेरित किया जाता है।

इस तरह की समस्याओं को रोकने के लिए सबसे आसान तरीका है, अपने 'साझा' डेटा को स्थानीय रूप से स्टैक पर कॉपी करना है, और फिर स्टैक प्रति पर काम करना है। जब आपका काम समाप्त हो जाता है तो उसे आउटपुट var पर वापस कॉपी करें।

उदा:

struct Work { 
    Work(int& d) : data(d) {} 
    void operator()() 
    { 
     int tmp = data; 
     for(int i = 0; i < lengthy_op; ++i) 
      ++tmp; 
     data = tmp; 
    } 

    int& data; 
}; 

यह साझा के साथ सभी समस्याओं से बचाता है।

Answer 2

मैं विवरण के साथ पूरी तरह से सुरक्षित नहीं लग रहा है, लेकिन यहाँ मेरी ले रहा है:

(1) आपका सरल उदाहरण के बाद से बढ़ावा create_thread एक संदर्भ की उम्मीद टूटी हुई है, आप एक अस्थायी गुजरती हैं।

(2) यदि आप vector<Work> का उपयोग प्रत्येक थ्रेड के लिए एक आइटम के साथ करते हैं, या अन्यथा क्रमशः स्मृति में होते हैं, तो झूठी साझाकरण होती है।

Answer 3

मैंने थोड़ा सा शोध किया और ऐसा लगता है कि झूठी साझाकरण के लिए कोई चांदी बुलेट समाधान नहीं है। यहां मैं जो हूं (क्रिस्टोफर के लिए धन्यवाद): 1) अप्रयुक्त या कम अक्सर उपयोग की जाने वाली सामग्री के साथ दोनों तरफ से अपना डेटा पैड करें। 2) अपने डेटा को ढेर में कॉपी करें और सभी कड़ी मेहनत के बाद इसे वापस कॉपी करें। 3) कैश संरेखित स्मृति आवंटन का उपयोग करें।