एक बड़े धीमी प्रसंस्करण के समय के बजाय अलग-अलग फ़ंक्शन बना रहा है?

Question

मैं पाइथन में Google App Engine पर्यावरण और प्रोग्रामिंग में काम कर रहा हूं। मैं एक ऐसा फ़ंक्शन बना रहा हूं जो अनिवार्य रूप से एक यादृच्छिक संख्या/अक्षर स्ट्रिंग उत्पन्न करता है और फिर memcache को संग्रहीत करता है।

def generate_random_string(): 
# return a random 6-digit long string 

def check_and_store_to_memcache(): 
    randomstring = generate_random_string() 
    #check against memcache 
    #if ok, then store key value with another value 
    #if not ok, run generate_random_string() again and check again. 

क्या केवल एक बड़े व्यक्ति के बजाय दो कार्यों का निर्माण प्रदर्शन को प्रभावित करता है? मैं दो पसंद करता हूं, क्योंकि यह बेहतर तरीके से मेल खाता है, लेकिन अगर यह "सर्वोत्तम अभ्यास" है तो उन्हें संयोजित नहीं करना चाहिए।

Answer 1

अपने कोड को पढ़ने और आसानी से समझने में सक्षम होने पर ध्यान केंद्रित करें।

एक बार ऐसा करने के बाद, यदि आपके पास कोई प्रदर्शन समस्या है, तो देखें कि इसका कारण क्या हो सकता है।

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

कहा जा रहा है कि, विभाजन कार्यों में प्रदर्शन पर एक (बहुत, बहुत मामूली) प्रभाव पड़ता है। हालांकि, मैं इस तरह से इस बारे में सोचूंगा - यह आपको राजमार्ग पर 80 मील प्रति घंटे से 79.99 मील प्रति घंटे तक ले जा सकता है (जिसे आप वास्तव में कभी नहीं देख पाएंगे)। देखने के लिए महत्वपूर्ण चीजें स्टॉपलाइट्स और यातायात जाम से परहेज कर रही हैं, क्योंकि वे आपको पूरी तरह से बंद करना चाहते हैं ...

Answer 2

रीड सही है। परिवर्तन के लिए आप विचार कर रहे हैं, फ़ंक्शन कॉल की लागत चक्रों की एक छोटी संख्या है, और आपको नोटिस करने से पहले इसे प्रति सेकंड 10^8 या तो बार करना होगा।

हालांकि, मैं सावधानी बरतता हूं कि अक्सर लोग दूसरे चरम पर जाते हैं, और फिर है जैसे कि फ़ंक्शन कॉल महंगे थे। मैंने इसे अधिक डिज़ाइन किए गए सिस्टम में देखा है जहां अमूर्तता की कई परतें थीं।

कुछ मानव मनोविज्ञान क्या होता है जो कहता है कि कुछ कॉल करना आसान है, तो यह तेज़ है। यह कड़ाई से जरूरी से अधिक फ़ंक्शन कॉल लिखने की ओर जाता है, और जब यह अमूर्तता की कई परतों पर होता है, तो बर्बादी घातीय हो सकती है।

रीड की ड्राइविंग उदाहरण के बाद, एक समारोह कॉल एक चक्कर की तरह हो सकता है, और अगर चक्कर detours शामिल है, और अगर उन भी detours होते हैं, जल्द ही वहाँ जबरदस्त समय बर्बाद किया जा रहा है, कोई स्पष्ट कारण के लिए है, क्योंकि प्रत्येक कार्य कॉल निर्दोष दिखता है।

Answer 3

लगभग सभी मामलों में, गति बढ़ाने के लिए "इनलाइनिंग" कार्यों वजन कम करने के लिए बाल कटौती की तरह है।

Answer 4

दूसरों की तरह कहा है, मैं इस विशेष परिदृश्य में इसके बारे में चिंता नहीं करता। फ़ंक्शन कॉल में शामिल बहुत छोटा ओवरहेड प्रत्येक फ़ंक्शन के अंदर किए गए कार्यों की तुलना में कमजोर होगा। और जब तक इन कार्यों को तेजी से उत्तराधिकार में नहीं बुलाया जाता है, तब तक शायद इससे कोई फर्क नहीं पड़ता।

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

साल पहले मैंने गणित पुस्तकालय में हाइपोट (hypotenuse) फ़ंक्शन की खोज की थी जिसे मैं वीसी ++ ऐप में उपयोग कर रहा था, बहुत धीमी थी।यह मेरे लिए हास्यास्पद लग रहा था क्योंकि यह कार्यक्षमता का इतना आसान सेट है - वापसी sqrt (ए * ए + बी * बी) - यह कितना मुश्किल है? इसलिए मैंने अपना खुद लिखा और प्रदर्शन 16X ओवर में सुधार करने में कामयाब रहा। फिर मैंने फ़ंक्शन में "इनलाइन" कीवर्ड जोड़ा और इसे 3X तेज बना दिया (इस बिंदु पर लगभग 50 एक्स तेज)। तब मैंने फ़ंक्शन से कोड निकाल लिया और इसे अपने लूप में रखा और अभी तक एक और छोटा प्रदर्शन बढ़ाया। तो ... हाँ, वे परिदृश्य के प्रकार हैं जहां आप एक अंतर देख सकते हैं।