स्ट्रिंग को संख्या में बदलें

प्रोग्रामिंग को समझने के लिए दूसरे दिन मेरे एक परिचित की मदद की। रास्ते में, उन्होंने एक प्रशिक्षण कार्यक्रम लिखा जो एक स्ट्रिंग को एक संख्या (इंट) में बदल सकता है। और किसी तरह मैं अपने स्वयं के अभेद्य की गति की तुलना करना चाहता था, मानक उपकरण की गति (Convert.ToInt32 और Int32.Parse) के साथ। इस तुलना का परिणाम, पहली नज़र में, कुछ हद तक असामान्य निकला।

मुझे लगता है कि आप में से कोई भी समस्या के बिना किसी समस्या को हल करने में सक्षम होगा, इसलिए मैं यह समझने की बात नहीं करता कि क्या और कैसे काम करता है।

class MyConvert { private static int CharToInt(char c) { return c - '0'; } public static int ToInt(string s) { if (s == null) throw new ArgumentException(); if (s.Length == 0) throw new ArgumentException(); bool isNegative = false; int start = 0; switch (s[0]) { case '-': if (s.Length == 1) throw new ArgumentException(); start = 1; isNegative = true; break; case '+': if (s.Length == 1) throw new ArgumentException(); start = 1; break; } int result = 0; for (int i = start; i < s.Length; i++) { if (c < '0' || c > '9') throw new ArgumentException(); result = checked(result * 10 + CharToInt(s[i])); } return (isNegative) ? -result : result; } } 

हम निम्नलिखित कार्यों की गति की तुलना करेंगे:

  static void MyConvertTest(int numbersCount) { for (int i = - numbersCount; i < numbersCount; i++) { if (i != MyConvert.ToInt(i.ToString())) { throw new ArgumentException(); } } } static void ConvertTest(int numbersCount) { for (int i = - numbersCount; i < numbersCount; i++) { if (i != Int32.Parse(i.ToString())) { throw new ArgumentException(); } } } 

मेरी मशीन पर (विंडोज 7, .NET 4.0, इंटेल i5) नंबर के साथ = 16,000,000, निम्नलिखित परिणाम औसत पर प्राप्त होते हैं:
ConvertTest: 08.5859994 सेकंड
MyConvertTest: 07.0505985 सेकंड

यदि आप Int32.Parse के बजाय Convert.ToInt32 का उपयोग करते हैं, तो परिणाम नहीं बदलेगा। लेकिन यह समझ में आता है, यह देखते हुए कि Convert.ToInt32 फ़ंक्शन खुद को Int32.Parse कहता है। इस प्रकार, हम पाते हैं कि आपकी अपनी बाइक की गति मानक फ़ंक्शन की गति ~ 18% से तेज है।

यदि आप दस्तावेज़ को देखते हैं , तो यह स्पष्ट हो जाता है कि फ़ंक्शन Int32.Parse काफी जटिल है। विशेष रूप से, यह क्षेत्रीय प्रारूपों को ध्यान में रखते हुए एक संख्या के स्ट्रिंग प्रतिनिधित्व को परिवर्तित कर सकता है। हालांकि मेरे अभ्यास में मुझे इस कार्यक्षमता का उपयोग नहीं करना पड़ा।

आइए हमारी रचना को थोड़ा और तेज करने की कोशिश करें। ऐसा करने के लिए, ToInt फ़ंक्शन में लूप बदलें

  for (int i = start; i < s.Length; i++) 

पर

  int length = s.Length; for (int i = start; i < length; i++) 

इस मामले में हमें मिलता है:
MyConvertTest: 06.2629928 सेकंड
यही है, अब हमारे फ़ंक्शन की गति मानक से ~ 27% अधिक तेज है। यह बहुत अप्रत्याशित है। मैंने सोचा था कि संकलक (या सीएलआर) यह समझने में सक्षम होगा कि चूंकि हम लूप के अंदर एस वेरिएबल को नहीं बदलते हैं, इसलिए एस.लिफ्ट वेल्यू केवल एक बार प्राप्त होगी।

अब CharToInt फ़ंक्शन को कॉल करने के बजाय, अपने शरीर को ToInt फ़ंक्शन में एम्बेड करें। इस मामले में
MyConvertTest: 05.5496214 सेकंड
इस प्रकार, मानक फ़ंक्शन के सापेक्ष ऑपरेशन की गति में ~ 35% की वृद्धि हुई। यह, बदले में, काफी अप्रत्याशित है, क्योंकि कंपाइलर (या सीएलआर) कुछ मामलों में यह अपने दम पर कर सकता है।

लगभग हर चीज को आजमाया जा चुका है। यह केवल लूप के लिए छोड़ देने की कोशिश करने के लिए रहता है। यह किया जा सकता है, उदाहरण के लिए, इस प्रकार है:

  unsafe public static int ToInt(string s) { if (s == null) { throw new ArgumentException(); } int result = 0; bool isNegative = false; fixed(char* p = s) { char* chPtr = p; char ch = *(chPtr++); switch (ch) { case '-': isNegative = true; ch = *(chPtr++); break; case '+': ch = *(chPtr++); break; } do { if (ch < '0' || ch > '9') { throw new ArgumentException(); } result = result * 10 + (ch - '0'); ch = *(chPtr++); }while (ch != '\0'); } return (isNegative) ? -result : result; } 

परिणाम:
MyConvertTest: 05.2410683 सेकंड
यह मानक फ़ंक्शन की तुलना में ~ 39% तेज है (और विकल्प के मुकाबले केवल 3% तेज)।

निष्कर्ष

बेशक, एक स्ट्रिंग को एक संख्या में परिवर्तित करने के कार्य की गति को बढ़ाने के प्रयासों का कोई विशेष मूल्य नहीं है। मैं एक भी स्थिति की कल्पना नहीं कर सकता जिसमें इस तरह के प्रदर्शन में वृद्धि का कम से कम कुछ महत्वपूर्ण प्रभाव हो। फिर भी, कुछ स्पष्ट निष्कर्ष दिए जा सकते हैं:

• कुछ मामलों में, आपकी अपनी रचनाएँ मानक समाधानों की तुलना में बेहतर काम कर सकती हैं।
  
• कुछ मामलों में, लूप के लिए अंतिम मान के लिए एक अलग चर को उजागर करना (अर्थात, "i <s" के साथ "i <s.Length" की जगह) गति में अच्छी वृद्धि (इस मामले में लगभग 10%) दे सकती है। हालांकि यह काफी हद तक सीएलआर के मूड पर निर्भर करता है।
  
• कुछ मामलों में, किसी पद्धति के कार्य में एक विधि को एम्बेड करने के बजाय विधि को कॉल करना भी मायने रखता है। हालांकि यह सीएलआर के मूड पर भी निर्भर करता है।
  

विभिन्न साहित्य में अक्सर काफी निष्पक्ष कथन हैं कि सभी निम्न-स्तरीय अनुकूलन को कंपाइलर और रनटाइम के कंधों पर रखा जाना चाहिए। वे कहते हैं कि वे काफी बुद्धिमान हैं और खुद बेहतर तरीके से जानते हैं कि यह कैसे बेहतर होगा। हालांकि, ऐसे परीक्षणों से पता चलता है, चक्रों का अनुकूलन और कार्यों की तैनाती के परिणामस्वरूप गति में 20 प्रतिशत वृद्धि हो सकती है (यदि आप 1 विकल्प की तुलना करते हैं)।

बेशक, आपको समझदारी से अनुकूलन करने की आवश्यकता है। और हमेशा वास्तविक परियोजनाओं में परियोजना के समर्थन की जटिलता को कुछ सेकंड तक काम में तेजी लाने से उचित ठहराया जा सकता है।

UPD ने प्लस के साथ समस्या को ठीक किया, धन्यवाद।
UPD 2 it4_kp ने सही रूप से देखा कि मेरे द्वारा प्रस्तावित सभी एल्गोरिदम में यह काम नहीं करता है

 MyConvert.ToInt( int.MinValue.ToString() ) 

वास्तव में, int.MinValue modulo int.MaxValue से एक अधिक है। और चूंकि मध्यवर्ती गणना में इंट से एक सकारात्मक सीमा बफर के रूप में उपयोग की जाती है, int.MinValue से मॉड्यूल इसमें शामिल नहीं है।
एक संभव समाधान: मध्यवर्ती बफर के रूप में एक नकारात्मक सीमा का उपयोग करें

  unsafe public static int ToInt(string s) { .... result = result * 10 - (ch - '0'); ..... return (isNegative) ? result : checked(-result); } 

प्रतीत होता है कि आदिम कोड में पहले से ही दो त्रुटियां हैं। मानक पुस्तकालयों को छोड़ने से पहले सोचने का एक अतिरिक्त कारण।