मुझे प्रदर्शन के बारे में कब ध्यान रखना चाहिए?


16

जावा के आईआरसी चैनल , एसओ, और अन्य स्थानों जैसी जगहों पर सबसे लंबे समय तक मुझे "चिंता के बारे में कुछ बताया गया है कि कोड कैसा दिखता है और इसकी पठनीयता / समझ अब क्या है, और प्रदर्शन बाद में बिल्कुल आवश्यक है"। तो सबसे लंबे समय के लिए, मैं वास्तव में अपने छोटे डेस्कटॉप या वेब ऐप के प्रदर्शन के बारे में ओसीडी नहीं रहा हूं, बस स्पष्ट रूप से अक्षम को हटा रहा हूं।

अधिकांश प्रतिक्रियाएं हैं "स्केलेबिलिटी के बारे में क्या?"। यह एक वैध बिंदु है, लेकिन अगर मेरा ऐप केवल 10,000 लाइनों को लंबा करने के लिए कहा गया है, तो मुझे कहना चाहिए कि क्या मुझे अपना कोड उन लोगों के छोटे प्रतिशत के लिए गड़बड़ी करना चाहिए जो कि 1,000,000 लाइन की फाइल में शॉव करने जा रहे हैं?

मेरा मुख्य प्रश्न यह है कि मुझे बड़े विशालकाय जटिल जानवरों के कार्यों को करने में आसान लेकिन कुछ हद तक अक्षम तरीके से व्यापार करना चाहिए जो कि चीजें बहुत जल्दी करते हैं लेकिन उन्नयन के किसी भी संभावित तरीके को नष्ट करते हैं और कोड को अत्यधिक कठिन बना देते हैं और अगले डेवलपर द्वारा वैसे भी फिर से लिखना शुरू कर देते हैं?

जवाबों:


23

समस्या होने पर प्रदर्शन की चिंता करें।

अगर आप 10,000 लाइन फ़ाइलों को प्रोसेस करने के लिए एक छोटा सा ऐप लिखते हैं और आपको हर 100 वीं फाइल में 1,000,000 लाइन फाइल मिलती है, तो शायद इससे कोई फर्क नहीं पड़ता कि उस एक फाइल को प्रोसेस करने में अधिक समय लगता है। हालाँकि, यदि आप नियमित रूप से ऐसी फाइलें प्राप्त कर रहे हैं जो शुरू में 5-10 गुना बड़ी हैं और आपके आवेदन को अपना काम करने में बहुत समय लग रहा है, तो आप प्रोफाइलिंग और अनुकूलन करना शुरू कर देते हैं।

अब, मैंने कहा "अपना काम करने के लिए बहुत लंबा है"। यह तय करने के लिए उपयोगकर्ता या प्रायोजक संगठन पर निर्भर है। अगर मैं एक कार्य कर रहा हूं और मुझे कुछ करने में 5 मिनट का समय लगता है जब यह मुझे सॉफ्टवेयर के बिना 3 या एक अलग उपकरण के साथ ले जाता है, तो मैं शायद एक बग रिपोर्ट या रखरखाव अनुरोध दर्ज करूंगा जिसमें सुधार हुआ है।

यदि आप उपयोगकर्ता हैं, तो आप चाहते हैं कि आपका सॉफ़्टवेयर कब तक अपना काम करना चाहता है - आप केवल यह तय कर सकते हैं कि क्या आप इसे तेज़ी से करना चाहते हैं या यदि आप अधिक पठनीय कोड के लिए अधिक प्रतीक्षा करने को तैयार हैं।



मैं प्रोफाइलिंग शुरू करता हूं और अनुकूलन करता हूं अगर 1) नौकरी में लंबे समय तक 2 लगते हैं) हार्डवेयर संसाधनों में से एक अधिकतम है (जैसे 100% सीपीयू)
ए Binzxxxxxx

10

मेरा मुख्य प्रश्न यह है कि मुझे बड़े विशालकाय जटिल जानवरों के कार्यों को करने में आसान लेकिन कुछ हद तक अक्षम तरीके से व्यापार करना चाहिए जो कि चीजें बहुत जल्दी करते हैं लेकिन उन्नयन के किसी भी संभावित तरीके को नष्ट करते हैं और कोड को अत्यधिक कठिन बना देते हैं और अगले डेवलपर द्वारा वैसे भी फिर से लिखना शुरू कर देते हैं?

यह आम तौर पर एक गलत द्विभाजन है । आप अद्भुत कुशल, पठनीय और बनाए रखने योग्य कोड लिख सकते हैं। आप अद्भुत रूप से अक्षम, गंदगी के अचूक ढेर लिख सकते हैं।

प्रदर्शन के मुद्दों से निपटने के दौरान, मैं आमतौर पर उस व्यावसायिक समस्या के बारे में सोचने की कोशिश करता हूं जिसे मैं हल कर रहा हूं। जब मेरे ग्राहक इसका उपयोग करेंगे तो मेरा सॉफ्टवेयर कैसे व्यवहार करेगा। क्या मेरे आवेदन प्रदर्शन जैकब नीलसन को खुश करेंगे ?


5
++ FALSE DICHOTOMY! क्या वे कभी नहीं सीखेंगे? जब आप एक प्रदर्शन समस्या को ढूंढते हैं और ठीक करते हैं, तो कोड न केवल तेज होता है, बल्कि यह बेहतर होता है । मुझे केवल इस बात का पछतावा है कि मेरे पास एक देने के लिए है!
माइक डनलैवी

+1 लिखने के लिए कि यह हमेशा एक गलत द्वंद्ववाद है ... हमेशा नहीं, लेकिन आमतौर पर।
डैन रोसेनस्टार्क

1
-1 लिखने के लिए यह आम तौर पर एक गलत द्वंद्वात्मकता है - तथ्य यह है, यह आमतौर पर सही होता है, और केवल दुर्लभ मामलों में एक गलत द्विभाजन होता है। अपने प्रोग्रामिंग कैरियर के 30 से अधिक वर्षों में मैंने बहुत सारे "अच्छी तरह से इरादा" प्रदर्शन अनुकूलन देखे हैं जो वास्तव में कोड को समझने और बनाए रखने के लिए कठिन बना दिया (और अक्सर कुछ अनुकूलित किया जो अनुकूलित होने के लिए पूरी तरह से अनावश्यक था)।
डॉक्टर ब्राउन

5

एक ट्रूइज़म जो मैंने कॉलेज में माइक्रोप्रोसेसरों का अध्ययन करने के लिए उठाया, जो मेरे साथ रहे: "सामान्य मामले को तेज करें। असामान्य मामले को सही बनाएं।"

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

लेकिन, एक बार अधिक से अधिक लोग इस तरह से इसका उपयोग करना शुरू कर देते हैं (या आपको बताना शुरू कर देते हैं "आप जानते हैं, मुझे उस उपकरण का उपयोग करना बहुत पसंद है, जो आपने मेरी साप्ताहिक टीपीएस रिपोर्ट में लिखा है, लेकिन यह सभी फ्रीकिन 'दिन) लेता है, तभी आप प्रदर्शन लाभ के लिए रखरखाव में आसानी से दूर व्यापार पर विचार करना शुरू करते हैं।


1

मेरा मुख्य प्रश्न यह है कि मुझे बड़े विशालकाय जटिल जानवरों के कार्यों को करने में आसान लेकिन कुछ हद तक अक्षम तरीके से व्यापार करना चाहिए जो कि चीजें बहुत जल्दी करते हैं लेकिन उन्नयन के किसी भी संभावित तरीके को नष्ट करते हैं और कोड को अत्यधिक कठिन बना देते हैं और अगले डेवलपर द्वारा वैसे भी फिर से लिखना शुरू कर देते हैं?

"इस बारे में चिंता करें कि कोड कैसे दिखता है और इसकी पठनीयता / समझ अब, और बाद में प्रदर्शन यदि आवश्यक हो तो" आसान तरीका है, और आम तौर पर अनहेल्दी है। एक अच्छा डिजाइन बनाए रखना आसान होगा, पढ़ने में आसान और कुशल होगा।

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

इसलिए, आपके प्रश्न का संक्षिप्त उत्तर है, "बेकार मत बनो। पुन: उपयोग के लिए लिखें। अवधारणाओं के प्रोटोटाइप / विकास के प्रमाणों को विकसित करते समय आलसी होना ठीक है, लेकिन उत्पादन कोड के लिए उस प्रोटोटाइप का उपयोग न करें।"

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


0

मैं कोड को पठनीय बनाने की कोशिश करता हूं - प्रदर्शन को धिक्कार है।

जब, और यदि, कोड बहुत धीमा साबित होता है, तो मैं इसे और तेज करने के लिए मना करूंगा। आमतौर पर रीफैक्टरिंग प्रक्रिया को बहुत सारी टिप्पणियों के साथ अपनाया जाता है क्योंकि कोड कम पठनीय होता है।


0

उम - कभी नहीं?

गंभीरता से, कोड को हमेशा लिखा जाना चाहिए ताकि आसानी से समझा और बनाए रखा जा सके।

प्रदर्शन समस्याओं से निपटने के लिए, उन्हें पहचानने से पहले उनके साथ व्यवहार करें, अपने कोड को पूर्व-अनुकूलित न करें क्योंकि तब आप केवल अनुमान लगा पाएंगे कि प्रदर्शन समस्याएं कहां हैं।

यदि आपका कोड स्पष्ट, संक्षिप्त, समझने योग्य और अनुरक्षित होने के लिए लिखा गया है, तो आपको या किसी अन्य प्रोग्रामर को इसे और अधिक कुशल बनाने के लिए कोड को फिर से भरने में कोई समस्या नहीं होनी चाहिए।


3
मैं इससे सहमत नहीं हूं। एक प्रदर्शन आवश्यकता एक प्रणाली के लिए एक वैध गैर-कार्यात्मक आवश्यकता है।
थॉमस ओवेन्स

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

आह। हाँ, उस मामले में आपका बिल्कुल सही है। आप संभावनाओं के बारे में चिंता नहीं करते हैं क्योंकि बहुत सारे हैं, लेकिन जो आप जानते हैं उस पर ध्यान केंद्रित करें।
थॉमस ओवेन्स

0

मैं आम तौर पर सबसे पहले और सबसे महत्वपूर्ण होने के लिए कोड लिखता हूं। यदि, और केवल अगर, मुझे पता है कि कार्यक्रम अपना काम करने के लिए बहुत धीमा है, तो मैं प्रोफाइल और अनुकूलन करता हूं। उस ने कहा, सामान्य अनुकूलन करने की आदत में कुछ भी गलत नहीं है जो आपके कोड की पठनीयता को प्रभावित नहीं करता है। यही है, यदि कोड का एक टुकड़ा दो समान (या लगभग समान रूप से) पठनीय तरीकों से लिखा जा सकता है, तो वह चुनें जो आमतौर पर तेज है।

उदाहरण के लिए, पायथन में, लिस्ट कॉम्प्रिहेंशन (या जनरेटर एक्सप्रेशन) समतुल्य forलूप की तुलना में अधिक तेज़ होते हैं , इसलिए मैं लिस्ट कॉम्प्रिहेंशन का उपयोग करता हूं, जहां मैं कर सकता हूं, यदि वे पठनीयता को प्रभावित नहीं करते हैं (उदाहरण के लिए, मैं लिस्ट को घोंसला नहीं बनाता मैं इससे बच सकता हूं, और इसके बजाय लूप के लिए उपयोग कर सकता हूं क्योंकि नेस्टेड सूची की समझ मानसिक रूप से कठिन हो सकती है)।

इसी तरह, अपरिवर्तनीय डेटा प्रकारों में परिवर्तनशील लोगों की तुलना में तेज़ी होती है, इसलिए मैं अपरिवर्तनीय डेटा प्रकारों का उपयोग करता हूं जहां मैं कर सकता हूं।


0

यदि आप वास्तव में प्रदर्शन-महत्वपूर्ण क्षेत्रों में काम कर रहे हैं, तो आप बाद में दक्षता को रोक नहीं सकते। यह उन मामलों में जल्दी से डिजाइन करने के तरीके के बारे में सोचने के लिए सबसे महत्वपूर्ण चीजों में से एक है और अंतिम परिणाम की स्थिरता से संबंधित है।

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

एक गेम डेवलपमेंट टीम 8 महीने के लिए एक इंजन के साथ उत्पादन करती है जो केवल 32 फ्रेम के साथ अपने बीफ़िएस्ट हार्डवेयर पर 2 फ्रेम प्रति सेकंड जाता है, जबकि हर बार 15 सेकंड के लिए स्टाल करने की प्रवृत्ति होती है जब स्क्रीन व्यस्त हो जाती है, तो बस तुरंत एक उपयोगी उत्पाद प्राप्त करने की संभावना नहीं होती है। एक छोटे से स्थानीय हॉटस्पॉट को ठीक करना। संभावना है कि उनका डिजाइन उन तरीकों से FUBAR है जो ड्रॉइंग बोर्ड के एक पुन: डिजाइन और डिजाइन में परिवर्तन के एक महाकाव्य को फिर से जीवंत करता है जो कोडबेस के हर कोने में कैस्केड कर सकता है।

जॉन कार्मैक के साथ, उन्होंने एक बार बात की कि कैसे एक तकनीकी डेमो को कम से कम सैकड़ों से हजारों फ्रेम प्रति सेकंड के हिसाब से चलाना होता है ताकि इसे उत्पादन में एकीकृत किया जा सके। यह दक्षता के साथ एक अस्वास्थ्यकर जुनून नहीं है। वह जानता है कि ग्राहकों को स्वीकार्य होने के लिए 30+ एफपीएस पर, उनकी संपूर्णता में खेल चलाने की आवश्यकता है। नतीजतन एक नरम छाया प्रणाली की तरह एक छोटा सा पहलू 30 एफपीएस पर नहीं चल सकता है, या फिर एक पूरे के रूप में खेल संभवत: आवश्यक रियलटाइम प्रतिक्रिया प्रदान करने के लिए पर्याप्त तेज़ नहीं हो सकता है। यह तब तक अनुपयोगी है जब तक यह आवश्यक दक्षता हासिल नहीं कर लेता। ऐसे प्रदर्शन-महत्वपूर्ण क्षेत्रों में जहां दक्षता के लिए एक मूलभूत आवश्यकता होती है, एक समाधान जो पर्याप्त गति प्राप्त करने में विफल रहता है, वास्तव में एक से बेहतर नहीं है जो सभी के लिए काम नहीं करता है,। और आप एक कुशल सॉफ्ट शैडो सिस्टम को डिज़ाइन नहीं कर सकते हैं जो एक रीयलटाइम गेम इंजन के लिए आवश्यक सैकड़ों से हजारों फ्रेम प्रति सेकंड तक चलता है जब तक कि आप इसकी दक्षता के रूप में विचारशील अग्रवर्ती राशि नहीं डालते। वास्तव में, ऐसे मामलों में, 90 +% कार्य दक्षता के आसपास उन्मुख होते हैं क्योंकि यह एक नरम छाया प्रणाली के साथ आने के लिए तुच्छ है जो पथ अनुरेखण का उपयोग करके प्रति फ्रेम 2 घंटे में ठीक काम करता है, लेकिन आप इसे ट्यून करने की उम्मीद नहीं कर सकते हैं दृष्टिकोण में एक पूरी तरह से अलग परिवर्तन के बिना प्रति सेकंड सैकड़ों फ्रेम पर चलने के लिए।

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

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

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

हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.