क्या कोडिंग करते समय माइक्रो-ऑप्टिमाइज़ेशन महत्वपूर्ण है?


178

मैंने हाल ही में स्टैक ओवरफ्लो पर एक सवाल पूछा था कि पीएचपी में स्ट्रैटन () की तुलना में इस्सेट () क्यों तेज था । इसने पठनीय कोड के महत्व पर सवाल उठाए और क्या कोड में माइक्रो-सेकंड के प्रदर्शन में सुधार भी विचार करने लायक थे।

मेरे पिता एक सेवानिवृत्त प्रोग्रामर हैं, और मैंने उन्हें प्रतिक्रियाएँ दिखाईं। वह पूरी तरह से निश्चित था कि यदि कोई कोडर सूक्ष्म स्तर पर भी अपने कोड में प्रदर्शन पर विचार नहीं करता है, तो वे अच्छे प्रोग्रामर नहीं हैं।

मुझे यकीन नहीं है - शायद कंप्यूटिंग शक्ति में वृद्धि का मतलब है कि अब हमें इस तरह के सूक्ष्म प्रदर्शन में सुधार पर विचार नहीं करना है? शायद इस तरह का विचार वास्तविक भाषा कोड लिखने वाले लोगों पर निर्भर है? (उपरोक्त मामले में PHP के)।

पर्यावरणीय कारक महत्वपूर्ण हो सकते हैं - इंटरनेट दुनिया की 10% ऊर्जा की खपत करता है। मुझे आश्चर्य है कि लाखों वेबसाइटों पर कई बार खरबों की प्रतिकृति बनाने पर कोड के कुछ माइक्रो-सेकंड कितने बेकार हो जाते हैं?

मैं प्रोग्रामिंग के बारे में तथ्यों के आधार पर अधिमानतः उत्तर जानना चाहूंगा।

क्या कोडिंग करते समय माइक्रो-ऑप्टिमाइज़ेशन महत्वपूर्ण है?

25 उत्तरों का मेरा व्यक्तिगत सारांश, सभी को धन्यवाद।

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

if (expensiveFunction() || counter < X)

होना चाहिए

if (counter < X || expensiveFunction())

( उदाहरण @ zidarsk8 से ) यह एक सस्ता कार्य हो सकता है और इसलिए कोड को बदलना माइक्रो-ऑप्टिमाइज़ेशन होगा। लेकिन, एक बुनियादी समझ के साथ, आपको नहीं करना होगा, क्योंकि आप इसे पहली जगह में सही तरीके से लिखेंगे।


123
आप पिता की सलाह पुरानी है । मैं यह नहीं पूछूंगा कि इससे प्रदर्शन में कितना सुधार होता है। मैं पूछता हूं कि अड़चन कहां है। इससे कोई फर्क नहीं पड़ता कि आप कोड के एक खंड के प्रदर्शन में सुधार करते हैं यदि यह कोई समग्र अंतर नहीं बनाता है, तो आपकी सबसे धीमी लिंक गति निर्धारित करने जा रही है। PHP में यह नेटवर्क को लिख रहा है (जब तक कि आप आईई को अन्यथा नहीं साबित कर सकते हैं); जो अधिक पठनीय कोड लिखने में अनुवाद अधिक महत्वपूर्ण है।
मार्टिन यॉर्क

61
यदि मुख्य शब्द पर विचार किया जाता है, तो वह गलत नहीं है। आपको इसके बारे में कुछ सुराग देना होगा।
जेएफओ

37
मैं दुखी हूं क्योंकि प्रसिद्ध प्रीमेच्योर ऑप्टिमाइज़ेशन उद्धरण अभी तक उल्लेख नहीं किया गया है: "प्रोग्रामर अपने कार्यक्रमों के गैर-राजनीतिक हिस्सों की गति के बारे में सोचने या चिंता करने में बहुत समय बर्बाद करते हैं, और दक्षता पर इन प्रयासों का वास्तव में एक मजबूत नकारात्मक होता है डिबगिंग और रखरखाव पर विचार किए जाने पर प्रभाव। हमें छोटी क्षमताओं के बारे में भूलना चाहिए, 97% समय के बारे में कहना चाहिए: समय से पहले अनुकूलन सभी बुराई की जड़ है । फिर भी हमें उस महत्वपूर्ण 3% में अपने अवसरों को पारित नहीं करना चाहिए। "
तमारा वाइज्समैन

13
क्या आप "दुनिया की 10% ऊर्जा" पर एक स्रोत प्रदान कर सकते हैं?
माइकल ईस्टर

17
coder does not consider performance in their code even at the micro level, they are not good programmersसूक्ष्म-अनुकूलन से बहुत अलग है। यह सिर्फ अच्छा कोडिंग है।
12 अक्टूबर को woliveirajr

जवाबों:


90

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

माइक्रो-ऑप्टिमाइज़ेशन के साथ समस्या यह है कि यह आमतौर पर किसी भी अवधारणा के बिना किया जाता है कि प्रोग्राम वास्तव में आवश्यकता से अधिक समय कैसे बिताते हैं।

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

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

अन्य चीजें जो आपने ठीक नहीं कीं, उन्हें पहले जितना समय लग गया था, लेकिन जब से समग्र समय कम हुआ है, उन चीजों को अब एक बड़ा अंश लगता है, इसलिए यदि आप इसे फिर से करते हैं, तो उस अंश को भी समाप्त किया जा सकता है। यदि आप कई पुनरावृत्तियों पर ऐसा करते रहते हैं, तो आप बिना किसी माइक्रो-ऑप्टिमाइज़ेशन के , कभी भी बड़े पैमाने पर स्पीडअप प्राप्त कर सकते हैं ।

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


120

माइक्रो-ऑप्टिमाइज़ेशन केवल महत्वपूर्ण है यदि संख्याएं कहती हैं कि यह है।

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

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


दूसरी ओर, यदि धीमे बनाम तेज़ फ़ंक्शन का उपयोग करने के बीच कोई समस्या है, तो धीमे फ़ंक्शन का उपयोग करने का कोई कारण नहीं है - जैसे कि इस्सेट के मामले में।
माव्रिक

7
@Mavrik यह सच है। यदि आपके पास दो कार्य हैं, तो X और Y, और Y, X की तुलना में तेज़ है (कम से कम आपकी विशेष स्थितियों के लिए), Y का उपयोग न करने का कोई कारण नहीं है, यदि कोड अभी भी पठनीय और बनाए रखने योग्य है। लेकिन अगर आप Y के बारे में नहीं जानते हैं और आपको X के बजाय Y का उपयोग करने के लिए कोड को रिफलेक्टर करने की आवश्यकता है, और प्रदर्शन (उस कोड सेगमेंट का) कोई समस्या नहीं है, तो उस बदलाव को करने का कोई कारण नहीं है। यह सब ट्रेडऑफ के बारे में है - प्रदर्शन, समय, लागत, प्रयास, पठनीयता / स्थिरता, और इसी तरह।
थॉमस ओवेन्स

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

+1 अत्यधिक अनुकूलित कोड कम पठनीय और बनाए रखने योग्य है ... लेकिन हमेशा नहीं।
Boz

अधिक मामले जहां प्रदर्शन महत्वपूर्ण है: (1) गेमिंग; (2) बड़ी मात्रा में डेटा; (3) उच्च यातायात वेब साइट; (4) एक अत्यधिक जटिल यूआई की प्रतिक्रिया; (5) सेवा जो कि वायरस की जाँच की तरह पृष्ठभूमि में चलने वाली है; (6) वित्त; (7) स्मार्टफोन; और इसी तरह। यह शायद ही कभी RTS और एम्बेडेड सिस्टम जैसे गूढ़ मामलों तक सीमित है।
रेक्स केर

103

जब भी किसी को भी के बारे में पूछता है अनुकूलन , मैं की याद दिला रहा हूँ उद्धरण से माइकल ए जैक्सन

कार्यक्रम अनुकूलन का पहला नियम: यह मत करो।

कार्यक्रम अनुकूलन का दूसरा नियम (केवल विशेषज्ञों के लिए!): अभी तक ऐसा न करें

विकिपीडिया से उद्धरण ब्रिटिश अंग्रेजी के लिए सही है। * 8 ')

दूसरे नियम में निहित अपने कोड को प्रोफाइल करना है और केवल उन चीजों को अनुकूलित करने में समय व्यतीत करना है जिनसे फर्क पड़ेगा।

असेंबली में प्रोग्रामिंग करते समय, आपके पिता का दावा सही था। लेकिन यह इन दिनों अधिकांश लोगों की तुलना में धातु के ज्यादा करीब है। आज भी अपने आप को (प्रोफाइलिंग के बिना) ऑप्टिमाइज़ करने की कोशिश करने के परिणामस्वरूप आपका कोड रन धीमा हो सकता है अगर आपने कुछ अधिक सामान्य तरीके से किया है, क्योंकि सामान्य तरीके से आधुनिक जेआईटी कंपाइलरों द्वारा अनुकूलित किए जाने की अधिक संभावना है ।

सी में भी आपको कंपाइलर की तुलना में कोड के एक सेक्शन को ऑप्टिमाइज़ करने के तरीके के बारे में अधिक जानने के लिए ऑप्टिमाइज़ेशन में बहुत अच्छा होना चाहिए।

अगर आप इस बात से परिचित नहीं हैं कि Ulrich Drepper अपने उत्कृष्ट पेपर के बारे में क्या बात करता है, प्रत्येक प्रोग्रामर को मेमोरी के बारे में क्या जानना चाहिए , तो आप शायद एक ऐसे हारे हुए व्यक्ति पर हैं जो स्वयं को अनुकूलित करने की कोशिश कर रहा है। हालाँकि, शीर्षक शीर्षक के विपरीत (जो वास्तव में डेविड गोल्डबर्ग के समान रूप से शानदार है जो हर कंप्यूटर वैज्ञानिक को फ्लोटिंग-पॉइंट अंकगणित के बारे में जानना चाहिए ) इस स्तर की समझ नहीं होने से जरूरी नहीं कि आप एक अच्छा प्रोग्रामर बनने से रोकें, बस एक अलग तरह का प्रोग्रामर।

isset()बनाम strlen()में पीएचपी

मैं PHP नहीं जानता, इसलिए यह वास्तव में स्पष्ट नहीं है कि क्या isset()करना है। मैं इसे संदर्भ से हटा सकता हूं, लेकिन इसका मतलब यह है कि यह नौसिखिया PHP प्रोग्रामर के लिए समान रूप से अस्पष्ट होगा और यहां तक ​​कि अधिक अनुभवी प्रोग्रामर को डबल-लेने का कारण भी हो सकता है। यह एक भाषा का मुहावरेदार उपयोग है जो रखरखाव को एक बुरा सपना बना सकता है।

केवल इतना ही नहीं, बल्कि इस बात की कोई गारंटी नहीं है कि isset()हमेशा अधिक कुशल होगा, सिर्फ इसलिए कि यह अब अधिक कुशल है। एक अनुकूलन अब अगले वर्ष या 10 वर्षों में एक अनुकूलन नहीं हो सकता है। सीपीयू, सिस्टम, कंपाइलर समय के साथ सुधरते और बदलते हैं। यदि PHP का प्रदर्शन strlen()एक समस्या है, तो भविष्य में PHP संशोधित हो सकती है, तो कोड को अनुकूलित करने के लिए सभी को प्रारंभ () अनुकूलन को हटाने की आवश्यकता हो सकती है।

प्रत्येक अनुकूलन में भविष्य के विरोधी-अनुकूलन बनने की क्षमता होती है , इसलिए इसे एक न्यूनतम के लिए संभव कोड गंध माना जाना चाहिए।

व्यक्तिगत अनुभव से एक उदाहरण

इस तरह के एंटी-ऑप्टिमाइज़ेशन के उदाहरण के रूप में , मुझे एक बार फॉर्म के कोड से भरे एक विशाल कोडबेस को साफ करना if x==0 z=0 else z=x*yपड़ा क्योंकि किसी ने यह धारणा बना ली थी कि एक फ्लोटिंग पॉइंट मल्टीप्ल हमेशा एक शाखा की तुलना में अधिक महंगा होने वाला था। मूल लक्ष्य वास्तुकला पर इस अनुकूलन ने कोड को परिमाण का एक क्रम तेज बना दिया, लेकिन समय बदल जाता है।

जब हमने अधिक आधुनिक सीपीयू पर इस कोड का उपयोग करने की कोशिश की, जो कि अत्यधिक विडंबनापूर्ण था, तो प्रदर्शन बहुत खराब था - इनमें से हर एक बयान के कारण एक पाइपलाइन फ्लश होता है। कोड की इन सभी पंक्तियों को सरल z=x*yबनाते हुए कार्यक्रम को नई वास्तुकला पर तेजी से परिमाण का क्रम चलाने के लिए बनाया गया है, जो विरोधी अनुकूलन द्वारा खोए गए प्रदर्शन को बहाल करता है ।

आम तौर पर आज के लिए जिन समस्याओं का हमें अनुकूलन करना है, वे उन लोगों के लिए बहुत भिन्न हैं जिन्हें हमें 20 या 10 साल पहले अनुकूलित करना था।

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


3
पाइपलाइन फ्लश और कैश मिस क्या आप से बचना चाहते हैं: डी वे भयानक लागत है। लेकिन केवल उन कोडों के कुछ हिस्सों पर जो उन्हें कई बार कई कई बार उत्तेजित करते हैं।
डेडलिंक

7
मैं एक बात जोड़ूंगा कि कंपाइलर एक लंबा रास्ता तय कर चुके हैं और आपके लिए बहुत सारी चीजों का अनुकूलन करेंगे। AFAIK, वे मुश्किल सामान की तुलना में स्वच्छ, पठनीय कोड का बेहतर अनुकूलन करते हैं।
बेज़ुब

3
एक माइक्रो-ऑप्टिमाइज़ेशन का एक वास्तविक उदाहरण प्रदान करने के लिए +1 जिसने समय बर्बाद किया - और खुलासा किया कि माइकल जैक्सन एक प्रोग्रामर थे।
बोज

1
उदाहरण के लिए +1। यह पूरी तरह से दिखाता है कि आपको संकलक में तुच्छ परिवर्तन क्यों छोड़ना चाहिए।
back2dos

1
@Rex Kerr> एग्जाम्पल में, लागत ब्रांचिंग से आती है, जो CPU की पाइपलाइन को फ्लश करती है। फ़्लोटिंग पॉइंट गुणन महंगा भी है। क्या अधिक अतिशयोक्ति FPU पर higly निर्भर करता है और कोड चलाने वाले CPU की पाइपलाइन लंबाई है। मुझे आश्चर्य नहीं होगा कि यह कोड पुराने सीपीयू पर तेजी से चला, जिसमें छोटी पाइपलाइन और वर्तमान सीपीयू की तुलना में कम एफपीयू है।
२०:२२ बजे deadalnix

84
  1. कोड लिखें, जो साफ, संक्षिप्त, सरल और आत्म-व्याख्यात्मक हो।
  2. अड़चनों की पहचान करने के लिए प्रदर्शन परीक्षण करें।
  3. महत्वपूर्ण अनुभागों का अनुकूलन करें।

अंगूठे के एक नियम के रूप में: आपके कोड का 95% समय 5% चलता है। आपके कोड को प्रोफ़ाइल / बेंचमार्क करने से पहले अनुकूलन करने का कोई मतलब नहीं है और देखें कि कौन से 5% हैं जो 95% चलते हैं।

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

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

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


2
मुझे सबसे अच्छा जवाब मिला, उल्लेखनीय रूप से, बुग्जिला डेवलपर की मार्गदर्शिका में: "यदि आप पढ़ने योग्य होने की कोशिश करने के बजाय चतुर होने की कोशिश कर रहे हैं, तो हो सकता है कि आप चीजों को" तेज "बनाने की कोशिश कर रहे हैं? यदि हां, तो बस याद रखें : आपके मौजूद होने से पहले किसी समस्या का समाधान न करें। यदि आप नहीं जानते (वास्तविक, विस्तृत परीक्षण द्वारा) कि आपका कोड धीमा है, तो इसे "तेज़" बनाने के बारे में चिंता न करें। यह सिर्फ तक सीमित नहीं है। अनुकूलन - कई प्रोग्रामर लगातार उन समस्याओं को हल कर रहे हैं जो किसी ने कभी अनुभव नहीं किया है। ऐसा मत करो। " Bugzilla.org/docs/developer.html#general
मार्को

7
मैं आम तौर पर सहमत हूं - एक पंक्ति को छोड़कर, मैं मानता हूं कि "हर बेवकूफ सोचता है कि वे माइक्रो-ऑप्टिमाइज़ कर सकते हैं" ...;)
निम

@Nim: प्वाइंट लिया;)
back2dos

26

मैं आपके पिता से सहमत हूँ: "यदि कोई कोडर सूक्ष्म स्तर पर भी उनके कोड में प्रदर्शन पर विचार नहीं करता है, तो वे अच्छे खिलाड़ी नहीं हैं।" कुंजी "प्रदर्शन पर विचार करना" है। यह "हर कदम पर सूक्ष्म अनुकूलन करने के बराबर नहीं है"।

मैं अधिकांश अन्य टिप्पणियों से सहमत हूं - सी कार्यक्रमों को तेज करने के लिए जो उपयोग किया जाता है वह आज ऐसा नहीं कर सकते - लेकिन विचार करने के लिए अन्य गंभीर चीजें हैं: क्या मुझे C या C ++ का उपयोग करना चाहिए? सरल अतिभारित ऑपरेटरों वाली कक्षाएं प्रदर्शन को मार सकती हैं यदि आप उन्हें बहुत अधिक उपयोग करते हैं। क्या वो वजह बन रही हे? यह आपके आवेदन पर निर्भर करता है, लेकिन यदि आप इसे भी नहीं मानते हैं, तो आप बहुत अच्छे प्रोग्रामर नहीं हैं। कुछ लोग इसे लगभग 2 मिली सेकेंड के लिए मान सकते हैं और इसे खारिज कर सकते हैं, लेकिन मुझे लगता है कि बहुत सारे शाब्दिक रूप से भी इस पर विचार नहीं करते हैं।

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

एक और वास्तविकता यह है कि लोग कोड का पुन: उपयोग करना पसंद करते हैं, और जहां यह समाप्त होता है वह आपके लिखे जाने की तुलना में काफी भिन्न हो सकता है। अचानक लोगों की देखभाल हो सकती है।

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

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

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

यह इन साइटों पर एक लोकप्रिय राय नहीं है। अलविदा प्रतिष्ठा अंक…।


3
निश्चित रूप से, आपको इसे (अपने सिर के पीछे) पर विचार करना चाहिए और आम तौर पर इसे अस्वीकार करना चाहिए, जब तक कि इसके लायक नहीं दिखाया जाए। आपको यह विचार करने की आवश्यकता है कि अनुकूलन आमतौर पर कोड की पठनीयता को कम करते हैं और 10 या तो के कारक द्वारा कोड को बनाए रखने और बनाए रखने के लिए समय बढ़ा सकते हैं। यदि प्रोग्राम CPU गहन नहीं है, तो इसकी अक्सर आवश्यकता नहीं होती है। पहचानें कि आपका कंपाइलर आमतौर पर आप की तुलना में अनुकूलन करने में बहुत बेहतर है, और यह कि आपके कई अनुकूलन वास्तव में प्रदर्शन को प्रभावित करेंगे। यदि यह आपके अनुकूलन और प्रोफ़ाइल का परीक्षण करने के लिए आपके समय के लायक नहीं है, तो इसके अनुकूलन के लिए आपके समय के लायक नहीं है।
डॉम्ब जिंबोब

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

@ कालेब: एंग्री बर्ड्स का उदाहरण यह बताता है कि विशेष हार्डवेयर के लिए अनुकूलन क्यों नहीं किया जाता है। यह भी दिखाता है कि आप अधिक सामान्य "सी स्तर" अनुकूलन करने की जहमत किए बिना एक संपूर्ण ऐप कैसे बना सकते हैं और फिर जल सकते हैं। वास्तव में जलाया नहीं गया है, लेकिन अपने मूल इरादे से परे जाने में परेशानी हो रही है।
18

25

आइए सबसे पहले अपना मामला लेते हैं: PHP

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

सामान्य रूप में,

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

संकलित प्रोग्राम (C ++, जावा) के लिए, अनुकूलन अधिक महत्वपूर्ण है। लेकिन वहां भी, सबसे पहले आपको उस प्रोग्राम की प्रकृति / डोमेन / उद्देश्य को देखना होगा जो आप लिख रहे हैं। आपको उस अनुकूलन से होने वाले लाभ के विरुद्ध सूक्ष्म-अनुकूलन के लिए समय का सावधानीपूर्वक वजन करना चाहिए। यदि आपको और भी अधिक अनुकूलन की आवश्यकता है, तो आप एक कदम नीचे जाने पर विचार कर सकते हैं - और कोड में अपने कोड के उन टुकड़ों को कोडित करें।

तो, अपने मूल प्रश्न का उत्तर देने के लिए - "क्या कोडिंग करते समय सूक्ष्म अनुकूलन महत्वपूर्ण है?" -- उत्तर है, यह निर्भर करता है --

  • आप किस तरह का काम कर रहे हैं: एप्लिकेशन डोमेन, जटिलता?
  • क्या माइक्रोसेकंड की गति में सुधार आपके कार्यक्रम के लिए महत्वपूर्ण है?
  • किस प्रकार का अनुकूलन सबसे अधिक लाभकारी होगा? यह हमेशा कोड अनुकूलन नहीं हो सकता है, लेकिन बाहरी कुछ।
  • माइक्रो-ऑप्टिमाइज़िंग में आपके द्वारा निवेश किए जाने के समय में कितनी "अच्छाई" (गति के मामले में) है?
  • क्या अन्य तरीकों से बेहतर गति प्राप्त की जा सकती है - हार्डवेयर, रैम और प्रोसेसर को बदलकर, कोड को समानांतर रूप से निष्पादित करके या वितरित सिस्टम पर?

न केवल माइक्रो-ऑप्टिमाइज़ेशन (उस मामले के लिए कोड ऑप्टिमाइज़ेशन) समय लेने वाला है, यह आपके कोड की प्राकृतिक पठनीयता को "विकृत" करता है, इस प्रकार यह रखरखाव को भारी बनाता है। हमेशा इसे एक अंतिम उपाय मानते हैं - हमेशा अलग-अलग कोड फ़ाइलों को अनुकूलित करने की तुलना में बेहतर हार्डवेयर और बेहतर वास्तुकला को अपनाकर पूरे एप्लिकेशन को अनुकूलित करने का प्रयास करें।


18

ऐसे कई उत्तर प्रतीत होते हैं जो कहते हैं कि माइक्रो ऑप्टिमाइज़ेशन है

सभी ट्रेडऑफ के बारे में - प्रदर्शन, समय, लागत, प्रयास, पठनीयता / रखरखाव, और इसी तरह।

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

if (counter < X && shouldDoThis()) // shouldDoThis() is an expensive function

हमेशा से अच्छा है

if (shouldDoThis() && counter < X ) 

आपके कोड को इस तरह "गति" करने के लिए काफी कुछ तरीके हैं और अंतर आमतौर पर नगण्य है (हालांकि हमेशा नहीं), लेकिन मुझे अच्छा लगता है अगर मैं इसे लिखता हूं।

मुझे नहीं पता कि क्या कोई इसे वास्तव में अनुकूलन भी मानता है, लेकिन मुझे लगता है कि एक प्रोग्रामर को अपना कोड लिखते समय इन बातों को जानना और विचार करना चाहिए।


2
यह इस विशेष मामले के लिए महत्वपूर्ण नहीं हो सकता है । हालांकि मुझे लगता है कि यह है बहुत इस तरह के अनुकूलन पहचान करने के लिए सक्षम होने के लिए महत्वपूर्ण है ताकि जब यह करता है बात है, आप अनावश्यक समय की रूपरेखा और इस तथ्य के बाद के अनुकूलन खर्च करने की जरूरत नहीं है।
tskuzzy

4
यह बहुत ही खतरनाक उदाहरण है। एक अनुकूलन को कभी भी व्यवहार में बदलाव नहीं करना चाहिए । यहां तक ​​कि सुझाव है कि cheap() && expensive()यह expensive () && cheap()लोगों के लिए एक दूसरे के साथ नेत्रहीन रूप से स्थानापन्न करने के लिए आमंत्रित करने का एक अनुकूलन है जो इसे महत्वपूर्ण अर्थ परिवर्तन के लिए बनाता है (उन भाषाओं में जहां &&शॉर्ट-सर्किट ऑपरेटर है)।
मार्क बूथ

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

3
@MarkBooth मैं यहाँ phkahler से सहमत होना है, इन कार्यों में से कोई भी दुष्प्रभाव नहीं होना चाहिए! अगर एक बयान में कॉन्डियनोस के आदेश का कार्यक्रम के परिणाम पर प्रभाव नहीं होना चाहिए। मेरा उदाहरण बेहतर लिखा जाएगा if (x<100 && isPrime(x)), बस इसे और अधिक स्पष्ट करने के लिए।
zidarsk8

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

11

मेरे करियर की शुरुआत में, "सूक्ष्म रूप से अनुकूलन न करें" जैसे कंबल वाले बयानों ने बहुत भ्रम पैदा किया। सब कुछ परिस्थितिजन्य है; इस प्रकार, लोग कहते हैं, "ऐसा करने" के बजाय "सर्वोत्तम अभ्यास"।

"बेस्ट प्रैक्टिस" सभी परिस्थितियों को देखते हुए शीर्ष विकल्प है। उदाहरण के लिए, इनलाइन SQL के बदले में LINQ और Entity Framework का उपयोग किया जाना चाहिए। मेरी कंपनी में हम SQL Server 2000 पर हैं । SQL Server 2000 एंटिटी फ्रेमवर्क का समर्थन नहीं करता है। सर्वोत्तम प्रथाओं की आवश्यकता है:

  • SQL सर्वर के नए संस्करण को खरीदने के विचार पर मेरे मालिक को बेचना जिसका अर्थ है कई हजार रुपये।
  • नई तकनीक सीखने के विचार पर डेवलपर्स को बेचना।

मैं अनुभव से जानता हूं कि यह होने वाला नहीं है। इसलिए, मैं छोड़ सकता हूं, सबसे अच्छा अभ्यास करने के लिए कोई अंत नहीं है या नहीं।

निर्णयों के पीछे राजनीतिक, तकनीकी और मौद्रिक विचार हैं जो समग्र परिणाम को प्रभावित करते हैं। निर्णय लेते समय इस तथ्य को याद रखें और अपनी लड़ाई बुद्धिमानी से चुनें।

" सब कुछ के लिए एक मौसम है, स्वर्ग के तहत हर गतिविधि का समय है। "


1
BTW, आप Dapper को माइक्रो-ओआरएम वैकल्पिक इनलाइन SQL के रूप में उपयोग कर सकते हैं ।
Dan

2
LINQ and Entity Framework should be used in lieu of inline SQL- जब तक आपको वास्तव में कुछ को अनुकूलित करने के लिए इनलाइन SQL की आवश्यकता होती है; SQL जो EF का उत्पादन करता है वह हमेशा इष्टतम नहीं होता है।
रॉबर्ट हार्वे

1
fwiw, अपने मालिक एसक्यूएल 2k8 के लाइसेंस लागत (या जो कुछ भी वर्तमान हो सकता है) के बारे में चिंतित है, तो आप बात-आउट चाहिए कि यह काफी पुरानी है EOL पर आ-अप होने के लिए बहुत जल्द ही (यदि वह पहले नहीं है)
वॉरेन

@warren - कुछ कंपनियाँ ऐसी बातों को ध्यान में नहीं रखती हैं। कुछ के लिए, अगर यह अभी भी "काम करता है" तो वे अपग्रेड नहीं करेंगे। काम से, मेरा मतलब है कि सर्वर अभी भी चलता है। हम पहले से ही ईएफ के साथ समर्थन की कमी देखते हैं। यह बस उन्हें किसी भी पैसे खर्च करने के लिए मनाने के लिए पर्याप्त नहीं है।
पी। ब्रायन। मैके

1
जैसा कि आप जानते हैं, आप SQL 2000 के साथ EF का उपयोग कर सकते हैं। डिज़ाइनर काम नहीं करता है, लेकिन वास्तविक इकाई ढांचा SQL 2000 का समर्थन करता है। डिजाइनर सीमा के आसपास जाने के लिए, आप उसी स्कीमा के साथ sql 2008 एक्सप्रेस में एक स्थानीय डेटाबेस बना सकते हैं। sql 2000 डेटाबेस के रूप में, सभी वर्गों को उत्पन्न करने के लिए उस पर डिज़ाइनर को इंगित करें, फिर .edmx फ़ाइल में जाएँ और लक्ष्य डेटाबेस संस्करण को 2000 में बदलें और अपने sql सर्वर 2000 डेटाबेस में कनेक्शन स्ट्रिंग को इंगित करें। सबसे अच्छा समाधान नहीं है, लेकिन अगर आप इसे काम नहीं कर सकते।
नील

8

यह हमेशा एक व्यापार है।

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

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

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

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

तीसरा, अनुकूलन अक्सर अपरिवर्तनीय होता है क्योंकि एल्गोरिथम जटिलता आमतौर पर आपके द्वारा किए गए किसी भी माइक्रो-ऑप्टिमाइज़ेशन को दूर कर देगी यदि डेटा सेट बढ़ता है। अफसोस की बात है कि माइक्रो-ऑप्टिमाइज़ेशन आपके कोड को बनाए रखने / विकसित करने के लिए कठिन बना देता है, थॉट्स ऑप्टिमाइज़ेशन करना कठिन हो सकता है।

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

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

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


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

+1 रखरखाव और विकास सूक्ष्म रूप से अधिक मूल्यवान हैं। हालाँकि मुझे यकीन है कि कंप्यूटर उद्योग सिर्फ पैसे से ज्यादा है? उदाहरण के लिए, खुला स्रोत, शिक्षा, नवाचार, शासन, समुदाय, आदि मुझे यकीन है कि इसके मूल में पैसा मिल सकता है, लेकिन यह ज्यादातर चीजों के लिए सही है।
बोज

@Boz kay> यह आंशिक रूप से सत्य है। पहला इसलिए क्योंकि आपके बॉस और कस्टूम को ज्यादातर पैसे और पैसे की परवाह नहीं है। यदि आप कुछ ओपन सोर्स टूल्स को बढ़ावा देना चाहते हैं, तो आपको उन्हें यह बताना होगा कि यह कंपनी के ब्रांड को कैसे बेहतर बनाएगा या कैसे यह डिवेलपमेंट लागत को कम करेगा। इसके अलावा, डेवेलपर्स को खुश करना आपकी कंपनी में अच्छा डेव पाने का एक तरीका है। अच्छा देव पैसा बनाता है (ज्यादातर गुणवत्ता और नवाचार फेंक)। अंत में, पैसा कुंजी है। और मैं लिख रहा हूँ कि मेरे लिनक्स कंप्यूटर से एक महान मुफ्त सॉफ्टवेयर समर्थक। वही शिक्षा के लिए जाता है।
deadalnix

8

प्रदर्शन एक विशेषता है

जेफ एटवुड का लेख उच्च प्रदर्शन वेबसाइट बनाने और ऐसा करने के महत्व पर एक महान है ...

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

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


7

डेवलपर समय की लागत कंप्यूटर समय से अधिक है। यह आमतौर पर आप क्या चाहते हैं। परंतु:

  • माइक्रो-ऑप्टिमाइज़ेशन और एल्गोरिथम जटिलता के बीच अंतर है। यह सुनिश्चित करने के लिए पर्याप्त समय बिताएं कि आप सही एल्गोरिदम का उपयोग कर रहे हैं ।
  • सुनिश्चित करें कि आप सही सवाल पूछ रहे हैं, select (select count(*) from foo) >= 1जैसी बात नहीं है select exists(select 1 from foo)
  • कुछ भाषा मुहावरे केवल इसलिए लोकप्रिय हैं क्योंकि वे तेज़ हैं, उनका उपयोग करना ठीक है, क्योंकि भाषा के अधिकांश धाराप्रवाह उपयोगकर्ता उनसे परिचित होंगे। (आपका उदाहरण एक अच्छा उदाहरण है)।

7

आप क्या अनुकूलित करना चाहते हैं?

  • सॉफ्टवेयर प्रदर्शन?
  • विश्वसनीयता?
  • प्रोग्रामर उत्पादकता?
  • ग्राहक संतुष्टि?
  • पावर दक्षता?
  • रख-रखाव की?
  • बाजार के लिए समय?
  • लागत?

"ऑप्टिमाइज़" का मतलब यह नहीं है कि कोड को जितना जल्दी हो सके उतना तेज चलाएं। ऐसे समय होते हैं जब कुछ करने के लिए सबसे तेज़ तरीका खोजना सबसे महत्वपूर्ण होता है, लेकिन यह वास्तव में अधिकांश कोड में ऐसा नहीं है। यदि उपयोगकर्ता 50 और 100 माइक्रोसेकंड के बीच अंतर नहीं देख सकते हैं, तो कोड में दोनों के बीच प्रभावी रूप से कोई अंतर नहीं है जो केवल कभी-कभी ही चलेगा। यहाँ एक उदाहरण है:

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

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

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


1
+1 उल्लेख नहीं है कि पिछले कुछ वर्षों में, मोबाइल डिवाइस फिर से कोड अनुकूलन पर अत्यधिक निर्भर हो गए हैं। कोई है जो अनुकूलित कोड नहीं लिखता है या कम से कम यह विचार करता है कि मोबाइल डिवाइस पर आसानी से चलाने के लिए उनके सीपीयू गहन ऐप को प्राप्त करने में मुश्किल समय हो सकता है।
स्टाइलर

+1 आपकी संभावित आशाओं की सूची को बहुत पसंद करता है। उन्होंने
बोज़

@ स्टाइलर: यह तब तक लंबा नहीं होगा जब तक मोबाइल उपकरणों में क्वाड कोर सीपीयू मेमोरी के साथ जीबी न हो, हमारे पास पहले से ही दोहरे कोर स्मार्टफोन हैं।
रेयान

@ ली रयान: हाँ यह सच है, लेकिन अधिकांश अग्रदूतों की तरह उन्हें भी लकड़ी की नावों में यात्रा करनी पड़ी;)
स्टाइलर

7

कोड लिखते समय माइक्रो ऑप्टिमाइज़ेशन करना महत्वपूर्ण नहीं है। ऑप्टिमाइज़ेशन एक प्रोफाइलर की मदद से किया जाना चाहिए, कोड को अनुकूलित करना जहां यह मायने रखता है।

फिर भी , एक प्रोग्रामर को कोड लिखते समय स्पष्ट रूप से बेवकूफ चीजों को करने से बचने की कोशिश करनी चाहिए

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

एक अनुभवी प्रोग्रामर को याद रखने के लिए ये चीजें आसान होती हैं और लगभग हमेशा कोड की गुणवत्ता में सुधार होता है।


एहसास हुआ कि मुझे अपने प्रश्न को संपादित करने में स्पष्ट होने की आवश्यकता है, मैं वास्तव में एक ही बात कह रहा था - मैंने इसे अपडेट किया है।
Boz

7

जब तय करना है कि क्या अनुकूलन करना है, तो हमेशा अमदहल के नियम को याद रखें । सटीक गणित के लिए लिंक देखें; याद करने के लिए तीखा कथन है:

यदि आपके प्रोग्राम का एक हिस्सा इसके रनटाइम के 10% के लिए है, और आप उस हिस्से को दो बार तेजी से चलाने के लिए ऑप्टिमाइज़ करते हैं, तो पूरे के रूप में प्रोग्राम केवल 5% की गति देगा।

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

तो माइक्रो-ऑप्टिमाइज़ेशन के बारे में आमदाल का कानून क्या कहता है? यह कहता है कि वे शायद इसके लायक हैं यदि वे बोर्ड में लागू होते हैं। यदि आप अपने कार्यक्रम में हर फ़ंक्शन के रनटाइम से एक प्रतिशत दाढ़ी कर सकते हैं, तो बधाई! आपने कार्यक्रम को एक प्रतिशत बढ़ा दिया है। क्या वह करने लायक था? ठीक है, एक संकलक आदमी के रूप में मुझे एक अनुकूलन खोजने में खुशी होगी जिसने ऐसा किया, लेकिन अगर आप इसे हाथ से कर रहे हैं, तो मैं कहूंगा कि कुछ बड़ा करना चाहिए।


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

वहाँ "औसत" शब्द में शैतान का। यह गणितीय रूप से ऐसा मामला है कि किसी कार्यक्रम को 50% तक बढ़ाने के लिए हर टुकड़े पर औसतन 50% तक की कटौती करनी चाहिए । अब, यदि आप प्रोग्राम को एक ऐसी नौकरी में बाँट सकते हैं जो run५% रनटाइम लेती है और दूसरी जो २५% लेती है, और पूर्व ३ एक्स को गति देती है, तो वह आपको बाद के काम के लिए कुछ भी नहीं करने के बावजूद कुल मिलाकर ५०% देगी। लेकिन बहुत अधिक सामान्य मामला यह है कि दर्जनों "नौकरियां" हैं जो प्रत्येक में 5% से कम रनटाइम लेती हैं - और फिर आपको उनमें से कई को गति या छुटकारा पाना होगा।
3

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

6

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

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

यदि आपको वास्तव में धीमे कोड के बारे में उपयोगकर्ताओं से शिकायतें मिल रही हैं, तो वे विचार करने लायक हो सकते हैं, लेकिन केवल तभी जब सब कुछ हल हो गया हो, अर्थात्:

  • क्या कोड अच्छी तरह से लिखा गया है?
  • क्या एप्लिकेशन किसी भी मुद्दे के बिना अपने डेटा तक पहुंचने में सक्षम है?
  • क्या एक बेहतर एल्गोरिथम का उपयोग किया जा सकता है?

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


5

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


5

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

एंबेडेड सिस्टम को माइक्रो-ऑप्टिमाइज़ेशन की आवश्यकता होती है क्योंकि बाधाओं को अधिक आसानी से मारा जाता है। हालाँकि, यहां तक ​​कि माइक्रो-ऑप्टिमाइज़ेशन केवल आपको अभी तक मिलता है; आप अपने तरीके को खराब डिज़ाइन से माइक्रो-ऑप्टिमाइज़ नहीं कर सकते। एक प्रणाली में अच्छे डिजाइन के बारे में बात यह है कि आप पूरे सिस्टम के बारे में तर्क कर सकते हैं। ऐसे अवयव जिन्हें माइक्रो-ऑप्टिमाइज़ेशन की आवश्यकता होती है, उन्हें बड़े करीने से और ऐसे तरीके से अनुकूलित किया जाना चाहिए जो सिस्टम के डिज़ाइन से समझौता न करें।

ध्यान दें कि आज छोटे "एंबेडेड" सिस्टम वैक्सन या पीडीपी -11 के पुराने समय के काफी करीब हो सकते हैं , इसलिए ये मुद्दे अधिक सामान्य हुआ करते थे। आधुनिक सामान्य वाणिज्यिक कंप्यूटिंग में एक सामान्य सामान्य उद्देश्य प्रणाली पर, सूक्ष्म अनुकूलन दुर्लभ है। यह संभवत: इस बात का हिस्सा है कि आपके पिता वह क्यों करते हैं।

हालाँकि, इससे कोई फर्क नहीं पड़ता कि आप नैनोसेकंड, मिलीसेकंड, सेकंड या घंटों के साथ काम कर रहे हैं; मुद्दे समान हैं। उन्हें प्रणाली के संदर्भ में मूल्यांकन किया जाना है और आप क्या हासिल करने की कोशिश कर रहे हैं।

यह एक हालिया प्रश्न से एक उदाहरण है, जिसका मैंने स्टैक ओवरफ्लो पर एक ऐसे मामले के लिए उत्तर दिया था जिसमें माइक्रो-ऑप्टिमाइज़ेशन आवश्यक था: एक एम्बेडेड सिस्टम के लिए ओपन सोर्स वीडियो एनकोडर


4

माइक्रो-ऑप्टिमाइज़ेशन के साथ सबसे बड़ी समस्या यह है कि यह आपको एक कोड को बनाए रखने के लिए कठिन लिखने के लिए ले जाता है।

एक अन्य समस्या कंप्यूटर कॉन्फ़िगरेशन पर निर्भर करती है कभी-कभी आपके माइक्रो-ऑप्टिमाइज़ेशन में 'ऑप्टिमाइज़ेशन' के बिना सबसे खराब प्रदर्शन हो सकता है।

कई माइक्रो-ऑप्टिमाइज़ेशन करने से आपको किसी ऐसी चीज़ से लड़ने में बहुत समय लगेगा जो वास्तव में मायने नहीं रखती है।

एक बेहतर दृष्टिकोण एक क्लीनर कोड बनाकर, बनाए रखने में आसान है, और यदि आपको प्रदर्शन के मुद्दे मिलते हैं, तो आप यह जानने के लिए एक प्रोफ़ाइल चलाते हैं कि वास्तव में आपका कोड धीमा हो रहा है। और वास्तव में क्या वास्तव में बुरा है यह जानकर आप इसे ठीक कर सकते हैं।

मैं यह नहीं कह रहा हूं कि माइक्रो-ऑप्टिमाइज़ेशन नहीं करना बेवकूफ कोड लिखने का बहाना है।


4

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

पर्यावरणीय कारक सवाल से बाहर हैं, वे सर्वर वैसे भी 24/7 चलते हैं और अगर वे वास्तव में कुछ प्रक्रिया करते हैं तो केवल तभी बात होगी जब यह वास्तव में बहुत लंबे समय तक चलने वाला कार्य हो।

सबसे अधिक संभावना है कि आपके कार्यालय में प्रकाश और हमारे कंप्यूटरों में उपयोग की जाने वाली ऊर्जा, जबकि हम सभी सवाल और जवाब टाइप कर रहे थे, किसी भी प्रकार के सूक्ष्म अनुकूलन की तुलना में कहीं अधिक ऊर्जा का उपयोग करते थे, जिसे आप अपने अनुप्रयोगों में यथोचित रूप से कभी भी सहेज सकते हैं।


+1 प्रकाश को बंद करना या सवालों के जवाब नहीं देना।
बोज

4

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

तब, यदि प्रोफाइलिंग संख्या यह बताती है कि आपकी पसंद का सबसे अच्छा, सरल एल्गोरिथ्म काफी अच्छा नहीं था, तो आप अनुकूलन शुरू कर सकते हैं (जो आमतौर पर पठनीयता की लागत के रूप में होता है)।


जब आपके डेटा को लगभग केवल कुछ आवारा तत्वों के साथ सॉर्ट किया जाता है जो उनके अंतिम गंतव्य से बहुत दूर नहीं होता है तो बबलोर्ट वास्तव में क्विकसॉर्ट या मर्जर्ट से बेहतर हो सकता है। हालांकि अन्य सभी कार्यों के लिए, आपको अंतर्निहित सॉर्टिंग फ़ंक्शन का उपयोग करना चाहिए जो आपकी प्रोग्रामिंग भाषा आपके लिए प्रदान करती है; यह आरंभ करने का सबसे सरल तरीका है (और अधिकांश भाषाओं में अंतर्निहित सॉर्टिंग फ़ंक्शन का अच्छा प्रदर्शन है)। बुरा सलाह:, start out with bad runtime characteristicजानबूझकर खराब रनटाइम विशेषता के साथ शुरू न करें।
रयान

@Lie, यदि आप जानते हैं कि आपके डेटा लगभग क्रमबद्ध हो जाता है और इसलिए आप bubblesort उपयोग कर सकते हैं, तो आप बिल्कुल हैं आँख बंद करके अपने एल्गोरिथ्म चुनने टाइपो ओर इशारा करते हुए के लिए धन्यवाद ... इसके अलावा।

4

मैंने इसे पहले कहा है, और मैं इसे यहां कहूंगा: "समयपूर्व अनुकूलन सभी बुराई की जड़ है" । यह किसी भी प्रोग्रामर के दिमाग के केंद्र में नियमों में से एक होना चाहिए।

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

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

कुछ चीजें हैं जो आपको तय करनी होंगी कि प्रदर्शन पर क्या असर पड़ेगा; इस समाधान को लागू करने के लिए आप किस भाषा / रनटाइम का उपयोग करेंगे जैसे बहुत ही बुनियादी निर्णय। इनमें से कई एक विधि बनाम दूसरी पद्धति को कॉल करने से अधिक परिमाण के कई आदेशों द्वारा प्रदर्शन को प्रभावित करेंगे। ईमानदारी से, PHP, एक स्क्रिप्टेड भाषा के रूप में, पहले से ही एक प्रदर्शन हिट है, लेकिन जैसा कि बहुत कम स्क्रिप्ट वाली साइटें C / C ++ में नीचे से बनाई गई हैं, यह उन अन्य तकनीकों की तुलना में है जिन्हें आप संभवतः (Java Servlets, ASP.NET) से चुनेंगे। , आदि)।

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


2
+1 निर्माण कोड जो हमेशा काम करता है वह पहली प्राथमिकता होनी चाहिए।
Boz

2
@ कीथ, वास्तव में नथ ने पहले कहा था, और उन्होंने कहा कि इससे थोड़ा अधिक है।

"इसे काम करो, फिर इसे उतनी तेजी से काम करो जितना इसे काम करने की आवश्यकता है", अनोन।
जॉन सॉन्डर्स

1
वास्तव में धर्म सभी बुराई की जड़ है, लेकिन मैं पचाता हूं।
थॉमस ईडिंग

4

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

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


3

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


3

यह महत्वपूर्ण है अगर:

1) किसी का जीवन आपके कोड पर निर्भर करता है। किसी के हृदय गति की निगरानी में निष्पादित करने के लिए 25ms लेने वाला एक फ़ंक्शन शायद एक बुरा विचार है।

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


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

3

क्या कोडिंग करते समय माइक्रो-ऑप्टिमाइज़ेशन महत्वपूर्ण है?

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

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


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


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

1

मुझे लगता है कि अच्छी प्रोग्रामिंग और माइक्रो-ऑप्टिमाइज़ेशन के बीच एक बड़ा अंतर है।

यदि एक ही कार्य को करने के दो तरीके हैं, एक दूसरे की तुलना में तेज़ और दोनों में एक ही पठनीयता होने पर, आपको तेज़ का उपयोग करना चाहिए। हमेशा। और यह अच्छा प्रोग्रामिंग है। किसी समस्या को हल करने के लिए एक बेहतर एल्गोरिथ्म का उपयोग नहीं करने का कोई कारण नहीं है। और यहां तक ​​कि इसका दस्तावेजीकरण करना आसान है: एल्गोरिथ्म का नाम दें, हर कोई इसे Google करने में सक्षम होगा और इसके बारे में अधिक जानकारी पा सकता है कि यह कैसे काम करता है।

और अच्छे एल्गोरिदम पहले से ही अनुकूलित हैं। वे उपवास करेंगे। वे छोटे होंगे। वे न्यूनतम आवश्यक मेमोरी का उपयोग करेंगे।

यहां तक ​​कि अगर उनका उपयोग करते हुए भी आपके कार्यक्रम में वह प्रदर्शन नहीं है, तो आप उन्हें माइक्रो-ऑप्टिमाइज़ करने पर विचार कर सकते हैं। और आपको माइक्रो-ऑप्टिमाइज़ करने में सक्षम होने के लिए भाषा को वास्तव में जानना होगा।

और हार्डवेयर पर कुछ और पैसे खर्च करने के लिए हमेशा जगह है। हार्डवेयर सस्ता है, प्रोग्रामर महंगे हैं । जब आप सिर्फ हार्डवेयर खरीद सकते हैं तो अनुकूलन करके बहुत अधिक समय / पैसा खर्च न करें।


1

IMHO कोड-पठनीयता माइक्रो-ऑप्टिमाइज़ेशन से अधिक महत्वपूर्ण है क्योंकि अधिकांश मामलों में माइक्रो-ऑप्टिमाइज़ेशन इसके लायक नहीं है।

गैर-सूक्ष्म सूक्ष्‍म अनुकूलन के बारे में लेख :

हम में से अधिकांश के रूप में, मैं गैर-अर्थ माइक्रो-अनुकूलन के बारे में ब्लॉग पोस्ट पढ़ने के लिए थक गया हूं जैसे कि इको द्वारा प्रिंट की जगह, + $ i द्वारा $ i ++, या एकल उद्धरण द्वारा डबल उद्धरण। क्यों? क्योंकि 99.999999% समय, यह अप्रासंगिक है। क्यों? क्योंकि 99.99% समय, आप एपीसी जैसे एक PHP त्वरक को बेहतर तरीके से स्थापित करेंगे, या अपने डेटाबेस कॉलम पर इन लापता अनुक्रमितों को जोड़ सकते हैं, या उन 1000 डेटाबेस अनुरोधों से बचने की कोशिश करेंगे जो आपके पास मुखपृष्ठ पर हैं।

प्रिंट एक और opcode का उपयोग करता है क्योंकि यह वास्तव में कुछ देता है। हम यह निष्कर्ष निकाल सकते हैं कि प्रतिध्वनि प्रिंट से तेज है। लेकिन एक opcode लागत कुछ भी नहीं, वास्तव में कुछ भी नहीं है।

मैंने एक ताजा वर्डप्रेस इंस्टालेशन पर कोशिश की है। स्क्रिप्ट मेरे लैपटॉप पर "बस त्रुटि" के साथ समाप्त होने से पहले रुक जाती है, लेकिन opcodes की संख्या पहले से ही 2.3 मिलियन से अधिक थी। पर्याप्त कथन।

इसलिए ज्यादातर मामलों में माइक्रो-ऑप्टिमाइज़ेशन लाखों लोगों के बीच 1 ऑपरेशन को बचाता है, लेकिन पठनीयता को बदतर बना देता है।


1

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

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

मैं यहां अच्छे और बुरे दोनों प्रकार के अनुकूलन के निरर्थकता के रूप में दूसरों द्वारा किए गए बिंदुओं को दोहराऊंगा:

  1. एक विशिष्ट समस्या के लिए आपकी निर्भरता बदल सकती है और आपके आवेदन के तार्किक अनुभाग को पूरा करने से पहले अनुकूलन पर खर्च किया गया कोई भी समय बर्बाद होता है। मेरा मतलब है कि अपेक्षाकृत शुरुआती स्तर पर अनुकूलन। आज आपके पास एक List<T>समय है और आपके ऐप के जहाजों को आपको इसे बदलना होगा LinkedList<T>और अब सभी बेंचमार्किंग समय और प्रयास की बर्बादी थी।

  2. अधिकतर आपके आवेदन की वास्तविक अड़चन (औसत दर्जे का अंतर के रूप में पढ़ें) आपके कोड का 5% (ज्यादातर sql वाले) हो सकता है और अन्य 95% का अनुकूलन आपके ग्राहकों को कोई लाभ नहीं देता है।

  3. आमतौर पर "तकनीकी रूप से" बेहतर प्रदर्शन करने वाले कोड का अर्थ अधिक क्रियात्मकता होता है, जिसका अर्थ है अधिक त्रुटि प्रवण कोड जिसका अर्थ है कि कठिन रख-रखाव और अधिक समय खर्च करना जिसका अर्थ है कि आप कम पैसा कमाते हैं।

  4. कार्बन फुटप्रिंट जो आप पूरी दुनिया के लिए बचाते हैं, 1% प्रदर्शन लाभ आसानी से ग्रीनहाउस गैसों द्वारा बौना है आपकी टीम को डिबगिंग और उस कोड को बनाए रखने पर फेंकना होगा।

विशेष रूप से खराब अनुकूलन के नकारात्मक हैं:

  1. यह अक्सर आपको वह प्रदर्शन नहीं देता है जिसकी आप अपेक्षा करते हैं। इस प्रश्न को SO पर देखें, जहां अनुकूलन गलत हो गए हैंवास्तव में इसका प्रतिकूल प्रभाव हो सकता है। यह अनिर्दिष्ट व्यवहार के साथ समस्या है।

  2. वैसे भी ज्यादातर आधुनिक संकलक आपके लिए यह करेंगे।

मैं बुरे और अच्छे अनुकूलन के कुछ उदाहरण दूंगा:

खराब -

  1. के बजाय छोटे पूर्णांक प्रकारों का उपयोग Int32

  2. ++i के बजाय इस्तेमाल किया i++

  3. forके बजाय foreach(सबसे बुरा मैंने देखा है, पूरी तरह से तर्क को हरा देता है)

  4. बंद चर से बचना

    string p;
    foreach (var item in collection)
        p = ...;
    
  5. charस्ट्रिंग संघनन के दौरान स्ट्रिंग के बजाय का उपयोग करना, जैसे:

    string me = 'i' + "me myself"; // something along that line - causes boxing
    

अच्छा (.NET दुनिया से। आत्म-व्याख्यात्मक होना चाहिए) -

  1. डबल लुकिंग

    if (Dictionary<K, V>.TryGetValue(K, out V))
        do something with V
    

    के बजाय

    if (Dictionary<K, V>.ContainsKey(K))
        do something with Dictionary<K, V>[K]
    
  2. लोड उन्हें सब

    DirectoryInfo.EnumerateFiles();
    

    के बजाय

    DirectoryInfo.GetFiles();
    
  3. दो चरण कास्टिंग:

    s = o as string;
    if (s != null)
        proceed
    

    के बजाय

    if (o is string)
        s = (string)o;
    
  4. यदि आदेश कोई फर्क नहीं पड़ता

    if (counter < X || expensiveFunction())
    

    के बजाय

    if (expensiveFunction() || counter < X)
    
  5. मुक्केबाज़ी

    void M<T>(T o) //avoids boxing
    {
    
    }
    

    के बजाय

    void M(object o)
    {
    
    }
    

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


1

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

सोडा की कैन खरीदने के लिए कुछ पैसे बचाना मुझे बहुत अच्छा नहीं लगेगा अगर मुझे उन पेनी को बचाने के लिए एक दूरी तय करनी पड़े, खासकर यह देखते हुए कि मैं शायद ही कभी इन दिनों सोडा पीता हूं। एक लाख की खरीद पर कुछ पैसे बचाने के लिए सोडा की एक बड़ी राशि हो सकती है।

इस बीच कुछ पैसे बचाने के लिए जब दो लोग मेरे ठीक बगल में होते हैं और एक कुछ पेनी के लिए एक ही सटीक चीज प्रदान करता है और दूसरा सस्ता नहीं होता है, और मैं अधिक महंगा एक चुनता हूं क्योंकि मुझे उनकी टोपी बेहतर लगती है जैसे कि एक मूर्खतापूर्ण मामला निराशा का।

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

मैं इतनी देर से कामयाब नहीं हुआ, 24 सेकंड से 25 मिलीसेकंड (लगभग 960 गुना तेज) से एक ऑपरेशन को कम कर देता हूं, समान आउटपुट (स्वचालित परीक्षणों द्वारा सुरक्षित) के साथ, एल्गोरिथम जटिलता में कोई बदलाव नहीं होने के साथ, वॉल्यूमेट्रिक हीट डिफ्यूजन स्किनिंग के माध्यम से। "माइक्रो-ऑप्टिमाइज़ेशन" (जिनमें से सबसे बड़ा मेमोरी लेआउट में बदलाव से आया जो इसे लगभग 2 सेकंड तक कम हो गया, फिर बाकी सिमड जैसी चीजें थीं और वीटीएन में कैश मिस का आगे विश्लेषण और मेमोरी लेआउट के कुछ और पुनर्व्यवस्था)।

वोल्फेयर यहां तकनीक की व्याख्या करता है, और वह आवश्यक समय के साथ संघर्ष करता है: http://blog.wolfire.com/2009/11/volumetric-heat-diffusion-skinning/

मेरा कार्यान्वयन मिलिसेकंड में ऐसा करने में सक्षम था, जबकि वह इसे एक मिनट से भी कम समय में प्राप्त करने के लिए संघर्ष कर रहा था: यहां छवि विवरण दर्ज करें

मैं "माइक्रो-ऑप्टिमाइज़्ड" होने के बाद इसे 24 सेकंड से 25ms तक कम करता था, जो वर्कफ़्लो में एक गेम-चेंजर था। अब कलाकार हर बार 24 सेकंड प्रतीक्षा किए बिना 30 से अधिक एफपीएस पर रियल टाइम में अपने रिग्स को बदल सकते हैं, उन्होंने अपनी रिग में कोई भी छोटा बदलाव नहीं किया। और यह वास्तव में मेरे सॉफ्टवेयर के पूरे डिजाइन को बदल दिया है क्योंकि मुझे अब प्रगति पट्टी और इस तरह की चीजों की आवश्यकता नहीं है, यह सिर्फ इंटरैक्टिव हो गया है। तो यह इस मायने में "सूक्ष्म अनुकूलन" हो सकता है कि सभी सुधार एल्गोरिदम की जटिलता में सुधार के बिना आए, लेकिन यह "मेगा-ऑप्टिमाइज़ेशन" प्रभाव में था जो कि पूर्व में एक दर्दनाक, गैर-इंटरैक्टिव प्रक्रिया थी। एक वास्तविक समय में, इंटरैक्टिव एक जिसने उपयोगकर्ताओं के काम करने के तरीके को पूरी तरह से बदल दिया।

माप, उपयोगकर्ता-अंत आवश्यकताएँ, संदर्भ

मुझे यहां रॉबर्ट की टिप्पणी बहुत पसंद आई और शायद मैं वह बिंदु बनाने में असफल रहा जो मैं चाहता था:

खैर, चलो। कोई भी यह तर्क देने वाला नहीं है कि इस तरह का परिवर्तन "इसके लायक" नहीं है। आप एक मूर्त लाभ प्रदर्शित करने में सक्षम थे; कई तथाकथित सूक्ष्म अनुकूलन नहीं कर सकते।

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

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

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


2
खैर, चलो। कोई भी यह तर्क देने वाला नहीं है कि इस तरह का परिवर्तन "इसके लायक" नहीं है। आप एक मूर्त लाभ प्रदर्शित करने में सक्षम थे; कई तथाकथित सूक्ष्म अनुकूलन नहीं कर सकते।
रॉबर्ट हार्वे

1
@RobertHarvey यह बात मैं बनाने के लिए उम्मीद थी की तरह था, कुछ लोग "सूक्ष्म अनुकूलन" आदि प्रभाव में जरूरी सूक्ष्म नहीं है, लेकिन यह संदर्भ पर इतना अधिक निर्भर है, माप, के बाद से issetबनाम strlenध्यान में अधिक miniscule लगता है संदर्भ और माप अनुपस्थित। :-D
ड्रैगन एनर्जी

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

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

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

0

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


यह पोस्ट पढ़ना मुश्किल है (पाठ की दीवार)। आप आपत्ति तो नहीं है संपादित एक बेहतर आकार में यह ing?
gnat
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.