मेरे असाइन किए गए PLINQ क्वेरी को मेरे अनियंत्रित एक

Question

से तेज क्यों है, मैंने PLINQ के साथ स्वयं को परिचित करने के लिए कुछ बुनियादी नमूना कोड लिखा था।

मैं कुछ अजीब में आया था। मुझे नहीं पता कि यह मेरे कोड में एक त्रुटि है या PLINQ की मेरी समझ में एक त्रुटि है।

एमएसडीएन दस्तावेज बताता है कि AsOrdered() जोड़ना प्रदर्शन की संभावित लागत पर कॉल के आदेश को सुरक्षित रखेगा।

मैंने कुछ यूनिट परीक्षण लिखे और दस्तावेज में बताए गए परिणाम सेट पर आदेश पर प्रभाव देखा। लेकिन मैंने प्रदर्शन पर प्रतिकूल प्रभाव देखा है।

public IEnumerable<int> ParallelCalculatePrimesUpTo(int maxValue) 
{ 
    return from number in Enumerable.Range(1, maxValue).AsParallel() 
      where IsPrime(number) 
      select number; 
} 

public IEnumerable<int> OrderedParallelCalculatePrimesUpTo(int maxValue) 
{ 
    return from number in Enumerable.Range(1, maxValue).AsParallel().AsOrdered() 
      where IsPrime(number) 
      select number; 
} 

और मेरे बहुत ही सरल मानक

[TestMethod] 
    public void SimplisticBenchmark6() 
    { 
     var primeNumberCalculator = new PrimeNumberCalculator(); 

     var startTime = DateTime.Now; 

     primeNumberCalculator.ParallelCalculatePrimesUpTo(10000000).ToList(); 

     var totalTime = DateTime.Now - startTime; 

     Console.WriteLine(totalTime); 
    } 

    [TestMethod] 
    public void SimplisticBenchmark7() 
    { 
     var primeNumberCalculator = new PrimeNumberCalculator(); 

     var startTime = DateTime.Now; 

     primeNumberCalculator.OrderedParallelCalculatePrimesUpTo(10000000).ToList(); 

     var totalTime = DateTime.Now - startTime; 

     Console.WriteLine(totalTime); 
    } 

कोई फर्क नहीं पड़ता कि कितनी बार मैं इस परीक्षण चलाने का आदेश दिया संस्करण अव्यवस्थित एक बाहर धड़कता है:

यहाँ दोनों मेरे तरीका है। मुझे अपने क्वाड कोर कंप्यूटर पर आदेशित एक के लिए लगभग 4 सेकंड तेज मिलता है। मुझे आदेशित एक के लिए लगभग 18 सेकंड और अनियंत्रित के लिए 22 सेकंड मिल रहे हैं। मैंने दो दिनों के दौरान दर्जनों समय परीक्षण किए हैं (उन दिनों के बीच रिबूट के साथ)।

यदि मैं संख्या 10 000 000 से 6 000 000 कम करता हूं, तो अंतर अभी भी वहां है लेकिन कम ध्यान देने योग्य है और यदि मैं इसे 3 000 000 तक कम करता हूं, तो यह एक ही गति के बारे में है।

मैंने निष्पादन के दोनों क्रम में परीक्षण चलाने की कोशिश की और परिणाम समान हैं।

// uses inneficient trial division algorithm 
private bool IsPrime(int number) 
{ 
    if (number == 1) 
     return false; 

    for (int divisor = 2; divisor <= Math.Sqrt(number); divisor++) 
    { 
     if (number % divisor == 0) 
      return false; 
    } 

    return true; 
} 

यह क्या बताते हैं:

यहाँ IsPrime विधि PLINQ क्वेरी में बुलाया जाता है?

Answer 1

क्या आप हमें बता सकते हैं कि सीपीयू उपयोग 4 अलग-अलग कोरों में क्या है? यह संभव है कि AsOrdered() एक ही कोर पर होने वाली अधिक अनुक्रमिक कॉल को मजबूर कर रहा है। बेहतर इलाके के साथ, सिलिकॉन-स्तरीय कैशिंग और शाखा भविष्यवाणी आपके पक्ष में काम कर रही है।

एक और संभावना यह है कि AsOrdered() प्रक्षेपण का उपयोग करते समय monotonically बढ़ते पूर्णांक (int.Range) के मामले में .NET ढांचे में कुछ अनुकूलन है। मुझे यकीन नहीं है कि यह कैसे काम करेगा, लेकिन यह संभव है।

तुलना के लिए एक दिलचस्प परीक्षण यादृच्छिक क्रम में संख्याओं का तीसरा सेट उत्पन्न करना होगा (जाहिर है, आपको उन्हें समय से पहले यादृच्छिक बनाना होगा और फिर तीन सरणी बंद करना होगा)। फिर देखें कि इसका क्या संबंध है?

Answer 2

क्या आप हमेशा उसी क्रम में टेस्ट चलाते हैं?

मैंने अपनी मशीनों पर अपने परिणाम फिर से बनाए हैं और मैंने पाया कि, 'आदेश' परिणाम तेजी से थे। मैं थोड़ा बेंच मार्किंग के लिए कोड को संशोधित करते थे:

static void Main(string[] args) 
{ 
    const int size = 9000000; 
    BenchIt("Parallel", ParallelCalculatePrimesUpTo, size); 
    BenchIt("Ordered ", OrderedParallelCalculatePrimesUpTo, size); 
    Console.ReadKey(); 
} 

public static void BenchIt(string desc, Func<int, IEnumerable<int>> myFunc, int size) 
{ 
    var sw = new Stopwatch();    
    sw.Restart(); 
    myFunc.Invoke(size).ToList(); 
    sw.Stop(); 
    Console.WriteLine("{0} {1}",desc, sw.Elapsed); 
} 

मेरे नतीजे बताते हैं, शुरू में, कि आप सही थे। आदेशित विधि तेज थी। हालांकि, अगर मैंने कॉल के आदेश को स्वैप किया, तो मैंने पाया कि गैर-आदेशित विधि तेज थी। दूसरे शब्दों में, जो भी दूसरा चला गया वह तेज़ था। संभावित रूप से, टास्क समांतर लाइब्रेरी कर रहे थ्रेड-पूल प्रबंधन की वजह से।

लेकिन - मेरी मशीन पर दोनों के बीच अंतर बहुत छोटे थे। आपने जो अंतर देखा है उसके पास कहीं भी नहीं।

आपका हार्डवेयर कैसा दिखता है?

PLINQ कुछ अनुमान लगाता है कि सबसे तेज़ निष्पादन कैसे करें। मुझे नहीं पता कि यह सीधे इस मामले में आपकी मदद करेगा या नहीं; लेकिन आप IsPrime के बीच में एक ब्रेक पॉइंट सेट करना चाहते हैं और कुछ सौ पुनरावृत्तियों के बाद इसे रोकना और थ्रेड विंडो की जांच करना चाहते हैं।

ParallelCalculatedPrimesUpTo कविता OrderedParallelCalculatePrimesUpTo निष्पादित करते समय आपके पास कितने धागे हैं? मैं यहाँ पहुंच रहा हूँ; लेकिन यह संभव है कि यह आपकी मशीन पर अलग-अलग मूल्यों पर निर्णय ले रहा है जो आपके द्वारा देखे जा रहे अप्रत्याशित समय बनाता है। मेरी मशीन पर - मुझे हर बार आठ धागे मिलते हैं - लेकिन मेरे समय लगभग समान होते हैं - जो भी पहले कहा जाता है वह उन धागे के निर्माण के कारण धीमा होता है। लेकिन आपको किसी विशेष संख्या में धागे की गारंटी नहीं है (आप अधिकतम सेट कर सकते हैं, लेकिन आप उन्हें इस्तेमाल करने के लिए मजबूर नहीं कर सकते हैं)।