हैलो गोफ़र्स?

इस ब्लॉग पोस्ट में, मैं आपको दिखाऊंगा कि #गोलंग परीक्षण पैकेज में निर्मित एक अद्भुत टूल का उपयोग कैसे करें। आप किसी कोड के टुकड़े या फ़ंक्शन के प्रदर्शन का परीक्षण कैसे करेंगे? बेंचमार्क परीक्षणों का उपयोग करें।

चल दर।

इस परीक्षण के लिए, मैं क्लासिक फाइबोनैचि संख्या या फाइबोनैचि अनुक्रम का उपयोग करूंगा, जो इसके द्वारा निर्धारित होता है:

if (x 



यह क्रम महत्वपूर्ण है क्योंकि यह गणित और प्रकृति के कई हिस्सों में भी दिखाई देता है, जैसा कि नीचे दिखाया गया है:



इस कोड को लागू करने के कई तरीके हैं, और मैं हमारे बेंचमार्क परीक्षण के लिए दो को चुनूंगा: इसकी गणना के पुनरावर्ती और पुनरावृत्त तरीके। फ़ंक्शन का मुख्य उद्देश्य एक स्थिति प्रदान करना और उस स्थिति पर फाइबोनैचि संख्या लौटाना है।


  
  
  पुनरावर्ती विधि




// main.go

func fibRecursive(n int) int {
    if n 




  
  
  पुनरावर्ती विधि




// main.go

func fibIterative(position uint) uint {
    slc := make([]uint, position)
    slc[0] = 1
    slc[1] = 1

    if position 



ये तरीके अनुकूलित नहीं हैं, लेकिन थोड़ी संख्या के लिए भी परीक्षणों के परिणाम काफी भिन्न होते हैं। आप इसे परीक्षणों में देखेंगे. कोड के साथ अनुसरण करने के लिए, आप यहां क्लिक कर सकते हैं।

अब, बेंचमार्क परीक्षणों के लिए, आइए _main_test.go फ़ाइल में कुछ परीक्षण लिखें। बेंचमार्क पर गोलांग के दस्तावेज़ का उपयोग करके, आप निम्नानुसार परीक्षण किए जाने वाले फ़ंक्शन बना सकते हैं: 



// main_test.go

// The key is to start every function you want to benchmark with the keyword Benchmark and use b *testing.B instead of t *testing.T as input 
func BenchmarkFibIterative(b *testing.B) {
    // Use this for-loop to ensure the code will behave correctly. 
    // Now, you can put the function or piece of code you want to test
    for i := 0; i 




आगे बढ़ने से पहले प्रश्न: कौन सा तेज़ है?


आइए छोटी संख्या (10) और थोड़ी बड़ी संख्या (80) के लिए परीक्षण चलाएं। बेंचमार्क परीक्षण चलाने के लिए, आप बस कमांड चलाएँ:

जाओ परीक्षण -बेंच=फ़ंक्शन का नाम

यदि आप इस कमांड के बारे में अधिक जानना चाहते हैं, तो यहां देखें।

पहला परीक्षण: स्थिति=10



//(fibIterative)
Results:
cpu: Intel(R) Core(TM) i7-7700HQ CPU @ 2.80GHz
BenchmarkFibIterative-8         24491042                42.50 ns/op
PASS
ok      playground      1.651s




आइए इस छवि की सहायता से विश्लेषण करें:



छवि के अनुसार, हमारे पास परीक्षणों के लिए 8 कोर हैं, कोई समय सीमा नहीं है (यह पूरा होने तक चलेगा)। कार्य को पूरा करने में 1.651 सेकंड लगे।



==== Extra ====
We got 24,491,042 iterations (computations), and each iteration (op) took 42.50 ns.

Doing some math, we can calculate how much time one op took:

42.50 ns/op with 1 ns = 1/1,000,000,000 s
op ≈ 2.35270590588e-12 s
==== Extra ====




यह एक अच्छा परिणाम है। आइए स्थिति 10 के लिए पुनरावर्ती फ़ंक्शन की जाँच करें:



// Results
BenchmarkFibRecursive-8          6035011               187.8 ns/op
PASS
ok      playground      1.882s




हम देख सकते हैं कि कार्य को पूरा करने में 1.882 सेकंड लगे।

पुनरावृत्तीय फ़ंक्शन कुछ डेसीसेकंड से जीत गया। आइए इसके साथ एक और परीक्षण आज़माएँ:

स्थिति 50



// Results for the Iterative Function

cpu: Intel(R) Core(TM) i7-7700HQ CPU @ 2.80GHz
BenchmarkFibIterative-8         27896118                45.37 ns/op
PASS
ok      playground      2.876s

// Results for the Recursive Function

cpu: Intel(R) Core(TM) i7-7700HQ CPU @ 2.80GHz
BenchmarkFibRecursive-8          6365198               186.3 ns/op
PASS
ok      playground      1.918s




बहुत खूब! अब पुनरावर्ती कार्य तेज़ है?

आइए थोड़ी बड़ी संख्या के साथ समाप्त करें।

स्थिति 80



// Results for the Iterative Function

cpu: Intel(R) Core(TM) i7-7700HQ CPU @ 2.80GHz
BenchmarkFibIterative-8          5102344               229.5 ns/op
PASS
ok      playground      1.933s

// Results for the Recursive Function
// My poor PC couldn’t handle it, so I had to reduce the position to 50 just to get some results printed.

cpu: Intel(R) Core(TM) i7-7700HQ CPU @ 2.80GHz
BenchmarkFibRecursive-8                1        44319299474 ns/op
PASS
ok      playground      44.951s




अंतर बहुत बड़ा है। स्थिति 80 के लिए, पुनरावृत्तीय दृष्टिकोण में लगभग 2 सेकंड लगे। स्थिति 50 के लिए, पुनरावर्ती कार्य में लगभग 45 सेकंड लगे। जब आपका गोलांग प्रोजेक्ट धीमा होने लगता है तो यह आपके कोड को बेंचमार्क करने के महत्व को दर्शाता है।


  
  
  निष्कर्ष


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


साइड नोट: सभी कोड जो देखने में सुंदर होते हैं, वे अधिक उपयोगी नहीं होते।



  
  
  अतिरिक्त व्यायाम


क्या आप पुनरावर्ती फ़ंक्शन को बेहतर बनाने का कोई बेहतर तरीका ढूंढ सकते हैं? (टिप: डायनामिक प्रोग्रामिंग का उपयोग करें)। यह आलेख बताता है कि क्यों कुछ छोटी संख्याओं के लिए, पुनरावर्ती रणनीति बेहतर है।