🧚🏿 ⚔️ 👃🏽 जाओ: क्या मुझे अपनी संरचना की एक प्रति के बजाय एक सूचक का उपयोग करना चाहिए? 🤭 🏦 🧚

रेने फ्रेंच द्वारा बनाई गई एक मूल गोफर से ए जर्नी विथ गो के लिए बनाया गया चित्रण।

प्रदर्शन के संदर्भ में, कई गो डेवलपर्स के लिए संरचनाओं को साझा करने के लिए संरचना को कॉपी करने के बजाय पॉइंटर्स का व्यवस्थित उपयोग सबसे अच्छा विकल्प लगता है। संरचना की एक प्रति के बजाय एक सूचक का उपयोग करने के प्रभाव को समझने के लिए, हम दो उपयोग मामलों पर विचार करेंगे।

गहन डेटा वितरण

आइए एक सरल उदाहरण देखें जब आप इसके मूल्यों तक पहुंचने के लिए एक संरचना साझा करना चाहते हैं:

type S struct {
  a, b, c int64
  d, e, f string
  g, h, i float64
}

यहां मूल संरचना है, जिसकी पहुंच कॉपी या पॉइंटर द्वारा साझा की जा सकती है:

func byCopy() S {
  return S{
     a: 1, b: 1, c: 1,
     e: "foo", f: "foo",
     g: 1.0, h: 1.0, i: 1.0,
  }
}

func byPointer() *S {
  return &S{
     a: 1, b: 1, c: 1,
     e: "foo", f: "foo",
     g: 1.0, h: 1.0, i: 1.0,
  }
}

इन दो तरीकों के आधार पर, हम 2 बेंचमार्क लिख सकते हैं। पहला वह स्थान है जहाँ संरचना को एक प्रति के साथ पारित किया जाता है:

func BenchmarkMemoryStack(b *testing.B) {
  var s S

  f, err := os.Create("stack.out")
  if err != nil {
     panic(err)
  }
  defer f.Close()

  err = trace.Start(f)
  if err != nil {
     panic(err)
  }

  for i := 0; i < b.N; i++ {
     s = byCopy()
  }

  trace.Stop()

  b.StopTimer()

  _ = fmt.Sprintf("%v", s.a)
}

दूसरा - पहले के समान - जहां संरचना सूचक द्वारा पारित की जाती है:

func BenchmarkMemoryHeap(b *testing.B) {
  var s *S

  f, err := os.Create("heap.out")
  if err != nil {
     panic(err)
  }
  defer f.Close()

  err = trace.Start(f)
  if err != nil {
     panic(err)
  }

  for i := 0; i < b.N; i++ {
     s = byPointer()
  }

  trace.Stop()

  b.StopTimer()

  _ = fmt.Sprintf("%v", s.a)
}

चलो बेंचमार्क चलाते हैं:

go test ./... -bench=BenchmarkMemoryHeap -benchmem -run=^$ -count=10 > head.txt && benchstat head.txt
go test ./... -bench=BenchmarkMemoryStack -benchmem -run=^$ -count=10 > stack.txt && benchstat stack.txt

हमें निम्नलिखित आँकड़े मिलते हैं:

name          time/op
MemoryHeap-4  75.0ns ± 5%

name          alloc/op
MemoryHeap-4   96.0B ± 0%

name          allocs/op
MemoryHeap-4    1.00 ± 0%

------------------

name           time/op
MemoryStack-4  8.93ns ± 4%

name           alloc/op
MemoryStack-4   0.00B

name           allocs/op
MemoryStack-4    0.00

इसकी एक पॉइंटर का उपयोग करने की तुलना में संरचना की एक प्रति का उपयोग 8 गुना तेज था!

यह समझने के लिए कि, आइए ट्रेस द्वारा जनरेट किए गए ग्राफ़ को देखें: पॉइंटर द्वारा पास किए गए स्ट्रक्चर के लिए ग्राफ़

द्वारा कॉपी

किए गए स्ट्रक्चर के लिए

ग्राफ़ पहला ग्राफ़ बहुत सरल है। चूंकि ढेर का उपयोग नहीं किया जाता है, कोई कचरा कलेक्टर और अतिरिक्त गोरूटिन नहीं है।

दूसरे मामले में, पॉइंटर्स का उपयोग करके गो कंपाइलर को वेरिएबल को ढेर में ले जाने और कचरा संग्रहकर्ता के रूप में काम करने का कारण बनता है । यदि हम ग्राफ के पैमाने को बढ़ाते हैं, तो हम देखेंगे कि कचरा कलेक्टर प्रक्रिया के एक महत्वपूर्ण हिस्से पर कब्जा कर लेता है:

यह ग्राफ दिखाता है कि कचरा कलेक्टर प्रत्येक 4 एमएस से शुरू होता है।

यदि हम फिर से ज़ूम करते हैं, तो हम इस बारे में विस्तृत जानकारी प्राप्त कर सकते हैं कि वास्तव में क्या हो रहा है:

नीली, गुलाबी और लाल धारियाँ कचरा संग्राहक के चरण हैं, और भूरे रंग ढेर में आवंटन से जुड़े हैं (ग्राफ पर "runtime.bgspepep" चिह्नित):

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

www.ardanlabs.com/blog/2018/12/garbage-collection-in-go-part1-semantics.html

यहां तक कि अगर यह उदाहरण थोड़ा चरम पर है, तो हम देखते हैं कि ढेर के बजाय ढेर पर एक चर आवंटित करना कितना महंगा हो सकता है। हमारे उदाहरण में, ढेर पर संरचना को बहुत तेजी से आवंटित किया गया है और ढेर पर बनाया गया है और इसका पता साझा किया गया है।

यदि आप स्टैक / हीप से परिचित नहीं हैं, और यदि आप उनके आंतरिक विवरण के बारे में अधिक जानना चाहते हैं, तो आप इंटरनेट पर बहुत सारी जानकारी पा सकते हैं, उदाहरण के लिए, पॉल ग्रिबबल का यह लेख ।

अगर हम प्रोसेसर को GOMAXPROCS = 1 का उपयोग करके 1 तक सीमित करते हैं तो हालात और भी बुरे हो सकते हैं:

name        time/op
MemoryHeap  114ns ± 4%

name        alloc/op
MemoryHeap  96.0B ± 0%

name        allocs/op
MemoryHeap   1.00 ± 0%

------------------

name         time/op
MemoryStack  8.77ns ± 5%

name         alloc/op
MemoryStack   0.00B

name         allocs/op
MemoryStack    0.00

यदि स्टैक पर रखने के बेंचमार्क में बदलाव नहीं हुआ, तो ढेर पर संकेतक 75ns / op से घटकर 114ns / op हो गया।

गहन समारोह कॉल

हम अपनी संरचना में दो खाली तरीके जोड़ेंगे और अपने बेंचमार्क को थोड़ा अनुकूलित करेंगे:

func (s S) stack(s1 S) {}

func (s *S) heap(s1 *S) {}

स्टैक पर प्लेसमेंट के साथ बेंचमार्क संरचना का निर्माण करेगा और इसे एक प्रति देगा:

func BenchmarkMemoryStack(b *testing.B) {
  var s S
  var s1 S

  s = byCopy()
  s1 = byCopy()
  for i := 0; i < b.N; i++ {
     for i := 0; i < 1000000; i++  {
        s.stack(s1)
     }
  }
}

और ढेर के लिए बेंचमार्क पॉइंटर द्वारा संरचना को पास करेगा:

func BenchmarkMemoryHeap(b *testing.B) {
  var s *S
  var s1 *S

  s = byPointer()
  s1 = byPointer()
  for i := 0; i < b.N; i++ {
     for i := 0; i < 1000000; i++ {
        s.heap(s1)
     }
  }
}

उम्मीद के मुताबिक, परिणाम अब पूरी तरह से अलग हैं:

name          time/op
MemoryHeap-4  301µs ± 4%

name          alloc/op
MemoryHeap-4  0.00B

name          allocs/op
MemoryHeap-4   0.00

------------------

name           time/op
MemoryStack-4  595µs ± 2%

name           alloc/op
MemoryStack-4  0.00B

name           allocs/op
MemoryStack-4   0.00

निष्कर्ष

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

जाओ: क्या मुझे अपनी संरचना की एक प्रति के बजाय एक सूचक का उपयोग करना चाहिए?

गहन डेटा वितरण

गहन समारोह कॉल

निष्कर्ष

More articles: