आज एक प्रोग्रामिंग चर्चा के दौरान एक दोस्त और मैं थोड़ा परेशान थे। उदाहरण के तौर पर, हमने List<int>
एन यादृच्छिक पूर्णांक (आमतौर पर 1.000.000) रखने की एक फिक्टिव समस्या बनाई है और एक ऐसा फ़ंक्शन बनाना चाहता था जो सभी इंटीग्रियों के सेट को वापस कर देता है जिसमें से एक से अधिक थे। बहुत सीधी चीजें। हमने इस समस्या को हल करने के लिए एक LINQ कथन बनाया है, और एक सादा सम्मिलन प्रकार आधारित एल्गोरिदम।LINQ संचालन सामान्य लूप से तेज क्यों हो सकता है?
अब, जैसा कि हमने गति की जांच की थी (कोड System.Diagnostics.StopWatch
का उपयोग करके), परिणाम भ्रमित थे। LINQ कोड ने केवल सरल प्रकार से बेहतर प्रदर्शन नहीं किया, लेकिन यह से एकforeach
/for
है जो केवल सूची का एक लूप था, और इसमें कोई ऑपरेशन नहीं था (जो, एक साइड ट्रैक पर, मैंने सोचा था कंपाइलर को पूरी तरह से खोजना और निकालना था)।
यदि हमने कार्यक्रम के उसी निष्पादन में यादृच्छिक संख्याओं का एक नया List<int>
उत्पन्न किया है और फिर LINQ कोड चलाया है, तो प्रदर्शन परिमाण (आमतौर पर हजारों) के आदेशों से बढ़ेगा। खाली लूप का प्रदर्शन बिल्कुल वही था।
तो, यहां क्या चल रहा है? क्या सामान्य लूप को बेहतर बनाने के लिए समानांतरता का उपयोग कर LINQ है? ये परिणाम कैसे संभव हैं? LINQ Quicksort का उपयोग करता है जो n * log (n) पर चलता है, जो प्रति परिभाषा पहले से धीमी है।
और दूसरे रन पर प्रदर्शन छलांग पर क्या हो रहा है?
हम दोनों इन परिणामों पर परेशान और चिंतित थे और समुदाय की कुछ स्पष्ट अंतर्दृष्टि की उम्मीद कर रहे थे, बस अपनी जिज्ञासा को पूरा करने के लिए।
कृपया कुछ कोड पोस्ट करें। –
शायद आप अपना परीक्षण साझा कर सकते हैं? –
अपना कोड पोस्ट करें। आप शायद [स्थगित निष्पादन] (http://blogs.msdn.com/b/charlie/archive/2007/12/09/deferred-execution.aspx) पर विचार नहीं कर रहे हैं। –