क्या random_shuffle threadsafe है? और rand_r का उपयोग कर अगर यह नहीं है

Question

एसटीडी है :: random_shuffle threadsafe? मुझे लगता है कि नियमित रैंड() थ्रेडसेफ नहीं है। यदि ऐसा है, तो मैं random_shuffle के साथ rand_r का उपयोग कैसे करूं ताकि मैं प्रत्येक थ्रेड को एक अद्वितीय बीज दे सकूं। मैंने random_shuffle के साथ कस्टम यादृच्छिक जेनरेटर का उपयोग करने के उदाहरण देखे हैं, लेकिन यह अभी भी मेरे लिए अस्पष्ट है।

धन्यवाद।

Answer 1

std::random_shuffle साथ rand_r उपयोग करने के लिए, आप एक (काफी तुच्छ) आवरण लिखने के लिए की आवश्यकता होगी। यादृच्छिक संख्या जनरेटर आप random_shuffle के पास एक पैरामीटर निर्दिष्ट करता है कि संख्या की सीमा का उत्पादन किया जाना है, जो rand_r नहीं स्वीकार करने के लिए की जरूरत है।

आपका आवरण कुछ इस तरह दिखेगा:

class rand_x { 
    unsigned int seed; 
public: 
    rand_x(int init) : seed(init) {} 

    int operator()(int limit) { 
     int divisor = RAND_MAX/(limit+1); 
     int retval; 

     do { 
      retval = rand_r(&seed)/divisor; 
     } while (retval > limit); 

     return retval; 
    }   
}; 

आप random_shuffle कुछ तरह के साथ इसे उपयोग करेंगे:

std::random_shuffle(whatever.begin(), whatever.end(), rand_x(some_seed)); 

Answer 2

आपको एक यादृच्छिक संख्या जनरेटर फ़ंक्शन या फ़ैक्टर ऑब्जेक्ट प्रदान करने की आवश्यकता है जो एक अभिन्न मूल्य प्रकार लेता है और कुछ अभिन्न प्रकार का एक और मान देता है जो कंटेनर की सीमाओं को ओवरफ़्लो नहीं करेगा जो आपके द्वारा फ़ंक्शन में पारित किए गए इटरेटर हैं के माध्यम से पुनरावृत्त इसके अलावा एक functor वस्तु के मामले में, यह operator() को लागू करना चाहिए ताकि यह एक समारोह की तरह कहा जा सकता है। क्योंकि आप एक धागा सुरक्षित यादृच्छिक संख्या जनरेटर की जरूरत है, एक बुरा विचार cstdlib से srand और rand उपयोग कर रहा है ... आप के बजाय कुछ functor वस्तु है कि एक धागा सुरक्षित यादृच्छिक संख्या जनरेटर को लागू करता है, या एक यादृच्छिक संख्या जनरेटर बनाने चाहिए कि विश्व स्तर पर सुलभ चर लागू नहीं करता है ताकि सब कुछ धागा-स्थानीय भंडारण बनी रहे।

तो उदाहरण के लिए, यह एक तरीका यह काम कर सकता है कि आपके पास कुछ अन्य प्रकार की यादृच्छिक संख्या जेनरेटर है जो आपको किसी अन्य लाइब्रेरी से प्राप्त हुआ है जो केवल मूल्यों की एक निश्चित सीमा के बीच यादृच्छिक मान उत्पन्न करेगा ताकि आप कंटेनर की सीमाओं को परिभाषित कर सकें यादृच्छिक-पहुंच इटरेटर्स के लिए random_shuffle एल्गोरिदम उपयोग करता है। अब क्या पुस्तकालय आप उपयोग पर निर्भर करता है, तो आप functor की तरह कुछ दिखाई दे सकता है निम्नलिखित:

class my_rand_gen 
{ 
    private: 
     random_gen_type random_range_gen; 
     int min; 
     int max; 

    public: 
     my_rand_gen(const random_gen_type& gen, int min_range, int max_range): 
        random_range_gen(gen), min(min_range), max(max_range) {} 

     int operator()(int value) 
     { 
      //ignore the input value and use our own defined range 
      //returns a value between min and max 
      return random_range_gen(min, max); 
     } 
}; 

अब आप की तरह एल्गोरिथ्म कॉल कर सकते हैं:

random_shuffle(my_vector_start_iter, my_vector_end_iter, 
       my_rand_gen(rand_generator_lib, 
          vector_start_index, 
          vector_end_index)); 

और यह शुरुआत के बीच में वेक्टर शफ़ल होगा और वेक्टर की सीमा ... दूसरे शब्दों में यह केवल vector_start_index और vector_end_index के बीच फेरबदल के लिए मूल्यों का उपयोग करेगा बह निकला बिना अपने वेक्टर को iterators खत्म।

Answer 3

शायद नहीं

।

adnrom_shuffle का दूसरा संस्करण उपयोग करें जो यादृच्छिक संख्या जनरेटर के लिए टेम्पलेट पैरामीटर लेता है: http://www.sgi.com/tech/stl/random_shuffle.html। जनरेटर से मेल खाना चाहिए: http://www.sgi.com/tech/stl/RandomNumberGenerator.html

struct MyRandomNumberGenerator 
{ 
    int operator()(int limit) const 
    { 
     // get threadsafe random number 
    } 
}; 

// Stuff 
random_shuffle(list.begin(), list.end(), MyRandomNumberGenerator());