क्या आप समांतर एक्सटेंशन का उपयोग कर रहे हैं?

Question

मुझे आशा है कि यह स्टैक ओवरफ्लो का दुरुपयोग नहीं है; हाल ही में मैंने समानांतर एक्सटेंशन पर कुछ महान प्रश्न देखे हैं, और मुझे अपनी रूचि पिक्चर मिली है।

मेरा प्रश्न

: आप समानांतर एक्सटेंशन का उपयोग कर रहे हैं, और यदि ऐसा है तो, तो कैसे?

मेरा नाम स्टीफन Toub है और मैं माइक्रोसॉफ्ट में पैरलल कंप्यूटिंग मंच टीम पर कर रहा हूँ। हम समानांतर एक्सटेंशन के लिए जिम्मेदार समूह हैं। मैं हमेशा इस बारे में सुनने में रूचि रखता हूं कि कैसे डेवलपर्स समांतर एक्सटेंशन का उपयोग कर रहे हैं (उदाहरण के लिए समानांतर। फॉर, पीआईएलक्यू, कंसूरेंट डिक्शनरी इत्यादि), आपके पास सकारात्मक अनुभव, आपके नकारात्मक अनुभव, भविष्य के लिए अनुरोध अनुरोध, और इसलिए पर।
यदि आप इस तरह की जानकारी साझा करने के लिए तैयार हो जाएगा, कृपया निजी तौर पर ईमेल के माध्यम से stoub at microsoft dot com पर करते हैं, या तो यहाँ इस सवाल के जवाब के रूप या मेरे लिए।

मैं बहुत तुम से सुनने के लिए उत्सुक हूं।

अग्रिम धन्यवाद!

Answer 1

मैं अपने प्रोजेक्ट MetaSharp पर उपयोग किया गया है। मेरे पास डीएसएल के लिए एक एमएसबिल्ड आधारित संकलन पाइपलाइन है और एक चरण प्रकार कई मंचों में से कई है। एम: एम मंच का उपयोग करता है .एसएपरेल। फॉरएल (...)।

यहाँ snippet है:

protected sealed override IEnumerable<IContext> Process() 
{ 
    if (this.Input.Count() > 1) 
    { 
     this.Input 
      .AsParallel<IContext>() 
      .ForAll(this.Process); 
    } 
    else if (this.Input.Any()) 
    { 
     this.Process(this.Input.Single()); 
    } 

    return this.Input.ToArray(); 
} 

Answer 2

मैं नेस्ट Parallel.ForEach कॉल करने के लिए TPL उपयोग कर रहा हूँ। क्योंकि मैं इन कॉलों से शब्दकोशों तक पहुंचता हूं, मुझे ConcurrentDictionary का उपयोग करना पड़ता है।

• ForEach के अंदर प्रतिनिधियों ज्यादा काम नहीं करते तो मैं बहुत समानांतरवाद नहीं मिलता है: हालांकि यह अच्छा है, मैं कुछ मुद्दे हैं। प्रणाली अपने अधिकांश समय धागे में शामिल होने लगता है। यह अच्छा होगा अगर यह पता लगाने का कोई तरीका था कि यह बेहतर समेकन क्यों नहीं कर रहा है और इसे बेहतर बना रहा है।

• भीतरी ForEach पुनरावृत्तियों ConcurrentDictionary से अधिक उदाहरणों, जो प्रणाली शब्दकोश के लिए अपने समय प्रगणक की ज्यादा खर्च करने के लिए अगर मैं एक प्रगणक कैश नहीं जोड़ा था, कारण होता है।

• मेरे ConcurrentDictionary उदाहरणों में से कई वास्तव में सेट हैं, लेकिन ConcurrentSet नहीं है इसलिए मुझे ConcurrentDictionary के साथ अपना स्वयं का कार्यान्वयन करना पड़ा।

• ConcurrentDictionary वस्तु प्रारंभ वाक्य रचना का समर्थन नहीं करता तो मैं var dict = new ConcurrentDictionary<char, int> { { 'A', 65 } }; नहीं कह सकता भी है जिसका अर्थ है मैं वर्ग के सदस्यों को ConcurrentDictionary शाब्दिक नहीं सौंप सकते।

• कुछ ऐसे स्थान हैं जहां मुझे ConcurrentDictionary में एक कुंजी देखना है और यदि यह अस्तित्व में नहीं है तो मूल्य बनाने के लिए एक महंगी फ़ंक्शन कॉल करें। यह अच्छा होगा यदि वहाँ है कि एक addValueFactory लेती है, ताकि मूल्य केवल गणना की जा सकती है, तो कुंजी मौजूद नहीं है GetOrAdd की एक अधिभार थे। इसे .AddOrUpdate(key, addValueFactory, (k, v) => v) के साथ अनुकरण किया जा सकता है लेकिन यह प्रत्येक लुकअप के लिए एक अतिरिक्त प्रतिनिधि कॉल का ओवरहेड जोड़ता है।

Answer 3

मैं इसे बड़े पैमाने पर अभी तक उपयोग नहीं किया है, लेकिन मैं निश्चित रूप से इसके उपयोग करने के लिए अपने कान रखा और हमारे कोड बेस में अवसरों के लिए इसका इस्तेमाल करने के लिए (दुर्भाग्य से, हम कर रहे हैं डाल करने के लिए ढूंढें नेट-2.0 हमारी कई परियोजनाओं पर अभी भी समय के लिए बाध्य है)।एक छोटा सा मणि मैं अपने साथ आया एक अद्वितीय शब्द काउंटर था। मुझे लगता है कि यह सबसे तेज और सबसे संक्षिप्त कार्यान्वयन मैं के साथ आ सकता है - अगर किसी को बेहतर बना सकते हैं, कि awesomeness होगा:

private static readonly char[] delimiters = { ' ', '.', ',', ';', '\'', '-', ':', '!', '?', '(', ')', '<', '>', '=', '*', '/', '[', ']', '{', '}', '\\', '"', '\r', '\n' }; 
private static readonly Func<string, string> theWord = Word; 
private static readonly Func<IGrouping<string, string>, KeyValuePair<string, int>> theNewWordCount = NewWordCount; 
private static readonly Func<KeyValuePair<string, int>, int> theCount = Count; 

private static void Main(string[] args) 
{ 
    foreach (var wordCount in File.ReadAllText(args.Length > 0 ? args[0] : @"C:\DEV\CountUniqueWords\CountUniqueWords\Program.cs") 
     .Split(delimiters, StringSplitOptions.RemoveEmptyEntries) 
     .AsParallel() 
     .GroupBy(theWord, StringComparer.OrdinalIgnoreCase) 
     .Select(theNewWordCount) 
     .OrderByDescending(theCount)) 
    { 
     Console.WriteLine(
      "Word: \"" 
      + wordCount.Key 
      + "\" Count: " 
      + wordCount.Value); 
    } 

    Console.ReadLine(); 
} 

private static string Word(string word) 
{ 
    return word; 
} 

private static KeyValuePair<string, int> NewWordCount(IGrouping<string, string> wordCount) 
{ 
    return new KeyValuePair<string, int>(
     wordCount.Key, 
     wordCount.Count()); 
} 

private static int Count(KeyValuePair<string, int> wordCount) 
{ 
    return wordCount.Value; 
} 

Answer 4

हम इसे बड़े पैमाने पर का उपयोग नहीं करते, लेकिन यह निश्चित आ गया है सिद्धहस्त में।

मैं Parallel.Invoke() कॉल में कुछ अधिक समय-गहन कदमों को लपेटकर अपने लगभग लंबे समय तक चलने वाले यूनिट परीक्षणों के चलने का समय लगभग 1/3 उनके मूल समय को कम करने में सक्षम था।

मैं भी परीक्षण धागे की सुरक्षा के लिए समानांतर लाइब्रेरी का उपयोग कर प्यार करते हैं। मैं पकड़ लिया और इस तरह कोड कुछ के साथ Ninject साथ सूत्रण मुद्दों के एक जोड़े की रिपोर्ट की है:

var repositoryTypes = from a in CoreAssemblies 
        from t in a.GetTypes() 
        where t.Name.EndsWith("Repository") 
        select t; 
repositoryTypes.ToList().AsParallel().ForAll(
    repositoryType => _kernel.Get(repositoryType)); 

हमारे वास्तविक उत्पादन कोड में, हम कुछ एकीकरण कार्रवाई है कि हर कुछ मिनट चलाने के लिए अपेक्षा की जाती है चलाने के लिए कुछ समानांतर एक्सटेंशन का उपयोग , और जिसमें ज्यादातर वेब सेवाओं से डेटा खींचने शामिल हैं। वेब कनेक्शन में अंतर्निहित उच्च विलंबता के कारण यह समांतरता का विशेष लाभ लेता है, और हमारी नौकरियों को फिर से आग लगने से पहले सभी को समाप्त करने की अनुमति मिलती है।

Answer 5

मैं एक ConcurrentDictionary का उपयोग कर रहा हूं जो 100 मिलियन + आइटम स्टोर करता है। मेरा आवेदन उस पल में लगभग 8 जीबी मेमोरी का उपयोग करता है। ConcurrentDictionary तब फैसला करता है कि वह एक और जोड़ें पर बढ़ना चाहता है। और यह स्पष्ट रूप से बहुत कुछ बढ़ना चाहता है (कुछ आंतरिक प्राइमा एल्गोरिदम) क्योंकि यह स्मृति से बाहर हो जाता है। यह 32 जीबी मेमोरी के साथ x64 पर है।

इसलिए मैं एक (समवर्ती) शब्दकोश का स्वत: regrow/मिलावत ब्लॉक करने के लिए एक बूलियन चाहते हैं। इसके बाद मैं बाल्टी के एक निश्चित सेट के साथ सृजन में शब्दकोश शुरू कर दूंगा (यह एक निश्चित क्षमता के समान नहीं है!)। और यह समय के साथ थोड़ा धीमा हो जाएगा क्योंकि एक बाल्टी में अधिक से अधिक आइटम हैं। लेकिन यह रीहाशिंग और स्मृति से बहुत जल्दी और अनावश्यक रूप से बाहर निकलने से रोक देगा।