समानांतर में प्रोसेसिंग वीसी: सुरक्षित तरीके से कैसे करें, या अस्थिर सुविधाओं का उपयोग किए बिना?

Question

मेरे पास एक विशाल वेक्टर है जो मैं समानांतर में लोड/कार्य करने में सक्षम होना चाहता हूं, उदा। एक धागे में पहले सौ हजार सूचकांक लोड करें, अगले में एक और आगे। इस कोड का एक बहुत गर्म हिस्सा होने जा रहा है के रूप में, मैं अवधारणा असुरक्षित कोड के इस निम्नलिखित सबूत के साथ आए हैं वृत्तखण्ड और Mutexes बिना यह करने के लिए:

let mut data:Vec<u32> = vec![1u32, 2, 3]; 
let head = data.as_mut_ptr(); 
let mut guards = (0..3).map(|i| 
    unsafe { 
    let mut target = std::ptr::Unique::new(head.offset(i)); 
    let guard = spawn(move || { 
     std::ptr::write(target.get_mut(), 10 + i as u32); 
    }); 
    guard 
    }); 

क्या मैं यहाँ याद है कि कर सकते हैं इसे संभावित रूप से उड़ाओ?

यह #![feature(unique)] का उपयोग करता है, इसलिए मुझे यह नहीं पता कि स्थिर में इसका उपयोग कैसे किया जाए। क्या इस तरह की चीज स्थिर में करने का कोई तरीका है (कच्चे पॉइंटर्स और Arc और Mutex के ओवरहेड का उपयोग किए बिना आदर्श रूप से सुरक्षित रूप से?

इसके अलावा, documentation for Unique को देखते हुए, यह

कहते हैं यह भी संकेत मिलता है कि सूचक की दिग्दर्शन Unique संदर्भ के लिए एक अनूठा पथ के बिना संशोधित किया जा नहीं करना चाहिए

मैं स्पष्ट नहीं कर रहा हूँ क्या "अद्वितीय पथ" का अर्थ है।

Answer 1

कोई इसके लिए बाहरी पुस्तकालय का उपयोग कर सकता है, उदा।

extern crate simple_parallel; 

let mut data = vec![1u32, 2, 3, 4, 5]; 

let mut pool = simple_parallel::Pool::new(4); 

pool.for_(data.chunks_mut(3), |target| { 
    // do stuff with `target` 
}) 

chunks और chunks_mut तरीकों समान रूप से आकार टुकड़ों में T रों का एक वेक्टर/टुकड़ा विभाजित करने के लिए सही तरीका है: simple_parallel (त्याग, मैं इसे लिखा था) एक लिखने की अनुमति देता है कि वे क्रमश: तत्वों पर एक इटरेटर वापसी और &mut [T] टाइप करें।