बिल्ट-इन गो फीचर

गो आपको असेंबलर में लिखने की अनुमति देता है। लेकिन भाषा के लेखकों ने ऐसी मानक लाइब्रेरी लिखी है कि ऐसा नहीं करना होगा। एक ही समय में पोर्टेबल और तेज कोड लिखने के तरीके हैं। कैसे? कट के तहत स्वागत है।

कोडांतरक में कार्यों को लिखना शुरू करना बहुत सरल है। उदाहरण के लिए, फ़ंक्शन को Add (आगे की घोषणा) घोषित करें, जिसमें 2 इंट 64 शामिल हैं:

 func Add(a int64, b int64) int64 

यह एक सामान्य फ़ंक्शन है, लेकिन फ़ंक्शन बॉडी गायब है। कंपाइलर एक पैकेज संकलित करने की कोशिश करते समय यथोचित शपथ लेंगे।

 % go build examples/asm ./decl.go:4:6: missing function body 

एक्सटेंशन .s के साथ एक फ़ाइल जोड़ें और कोडांतरक में फ़ंक्शन को लागू करें।

 TEXT ·Add(SB),$0-24 MOVQ a+0(FP), AX ADDQ b+8(FP), AX MOVQ AX, ret+16(FP) RET 

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

लेकिन एक समस्या है - asm पर फंक्शन्स को ऑप्टिमाइज़ और बिल्ट-इन (इनलाइन) नहीं किया जा सकता है। इसके बिना, ओवरहेड निषेधात्मक हो सकता है।

 var Result int64 func BenchmarkAddNative(b *testing.B) { var r int64 for i := 0; i < bN; i++ { r = int64(i) + int64(i) } Result = r } func BenchmarkAddAsm(b *testing.B) { var r int64 for i := 0; i < bN; i++ { r = Add(int64(i), int64(i)) } Result = r } 

 BenchmarkAddNative-8 1000000000 0.300 ns/op BenchmarkAddAsm-8 606165915 1.930 ns/op 

इनलाइन असेंबलर के लिए कई सुझाव दिए गए थे, क्योंकि gcc में asm(...) निर्देश। उनमें से कोई भी स्वीकार नहीं किया गया था। इसके स्थान पर, जोड़ा गया आंतरिक कार्य करते हैं।

बिल्ट-इन कार्यों को सादे गो में लिखा गया है। लेकिन कंपाइलर जानता है कि उन्हें कुछ अधिक इष्टतम के साथ बदला जा सकता है। 1.13 गो में, एम्बेडेड फ़ंक्शन math/bits और sync/atomic में निहित हैं।

इन पैकेजों के कार्यों में फैंसी हस्ताक्षर हैं। वास्तव में, वे प्रोसेसर कमांड के हस्ताक्षर दोहराते हैं। यह संकलक को अनुमति देता है, यदि लक्ष्य वास्तुकला समर्थन करता है, तो फ़ंक्शन कॉल को पारदर्शी रूप से कोडांतरक निर्देशों के साथ बदलने के लिए।

नीचे मैं दो अलग-अलग तरीकों के बारे में बात करना चाहता हूं जिसमें गो कंपाइलर अंतर्निहित कार्यों का उपयोग करके अधिक कुशल कोड बनाता है।

जनसंख्या की गणना

एक संख्या के बाइनरी प्रतिनिधित्व में इकाइयों की यह संख्या एक महत्वपूर्ण क्रिप्टोग्राफ़िक आदिम है। चूंकि यह एक महत्वपूर्ण ऑपरेशन है, इसलिए अधिकांश आधुनिक सीपीयू हार्डवेयर में कार्यान्वयन प्रदान करते हैं।
math/bits पैकेज OnesCount* फ़ंक्शंस में यह ऑपरेशन प्रदान करता है। उन्हें पहचाना और POPCNT प्रोसेसर POPCNT साथ बदल दिया गया है।

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

 func kernighan(x uint64) (count int) { for x > 0 { count++ x &= x - 1 } return count } 

एल्गोरिथ्म के चक्रों की संख्या बिट्स सेट की संख्या के साथ मेल खाती है। अधिक बिट्स - लंबे समय तक निष्पादन का समय, जो संभवतः तीसरे पक्ष के चैनलों पर सूचना के रिसाव की ओर जाता है।

दूसरी एल्गोरिथ्म हैकर की डिलाईट से है ।

 func hackersdelight(x uint64) uint8 { const m1 = 0b0101010101010101010101010101010101010101010101010101010101010101 const m2 = 0b0011001100110011001100110011001100110011001100110011001100110011 const m4 = 0b0000111100001111000011110000111100001111000011110000111100001111 const h1 = 0b0000000100000001000000010000000100000001000000010000000100000001 x -= (x >> 1) & m1 x = (x & m2) + ((x >> 2) & m2) x = (x + (x >> 4)) & m4 return uint8((x * h1) >> 56) } 

विभाजन और जीत की रणनीति इस संस्करण को लंबे समय से O (log a) के लिए काम करने की अनुमति देती है, और बिट्स की संख्या से लगातार समय के लिए, जो क्रिप्टोग्राफी के लिए महत्वपूर्ण है। चलो math/bits.OnesCount64 साथ प्रदर्शन की तुलना करें math/bits.OnesCount64 ।

 func BenchmarkKernighan(b *testing.B) { var r int for i := 0; i < bN; i++ { r = kernighan(uint64(i)) } runtime.KeepAlive(r) } func BenchmarkPopcnt(b *testing.B) { var r int for i := 0; i < bN; i++ { r = hackersdelight(uint64(i)) } runtime.KeepAlive(r) } func BenchmarkMathBitsOnesCount64(b *testing.B) { var r int for i := 0; i < bN; i++ { r = bits.OnesCount64(uint64(i)) } runtime.KeepAlive(r) } 

ईमानदार होने के लिए, हम कार्यों के लिए एक ही पैरामीटर पास करते हैं: 0 से bN तक का अनुक्रम यह कर्निगन विधि के लिए अधिक सही है, क्योंकि इसके निष्पादन का समय इनपुट तर्क के बिट्स की संख्या के साथ बढ़ता है। ➚

 BenchmarkKernighan-4 100000000 12.9 ns/op BenchmarkPopcnt-4 485724267 2.63 ns/op BenchmarkMathBitsOnesCount64-4 1000000000 0.673 ns/op 

math/bits.OnesCount64 4 बार गति में जीतता है। लेकिन क्या यह वास्तव में एक हार्डवेयर कार्यान्वयन का उपयोग करता है, या हैकर ने सिर्फ हैकर्स डिलाइट से एल्गोरिथ्म का बेहतर अनुकूलन किया है? यह कोडांतरक में आने का समय है।

 go test -c #     

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


यहां बहुत कुछ हो रहा है। सबसे महत्वपूर्ण: x86 POPCNT निर्देश को परीक्षण के कोड में ही बनाया गया है, जैसा कि हमने उम्मीद की थी। यह प्रतिबंधों को विकल्पों की तुलना में तेज बनाता है।

यह ब्रांचिंग दिलचस्प है।

 cmp cs:runtime_x86HasPOPCNT, 0 jz lable 

हां, यह असेंबलर पर पॉलीफाइल है। सभी प्रोसेसर POPCNT समर्थन नहीं करते हैं। जब प्रोग्राम शुरू होता है, तो आपके main से पहले, runtime.cpuinit फ़ंक्शन जाँचता है कि क्या कोई आवश्यक निर्देश है और इसे runtime.x86HasPOPCNT में सहेजता है। हर बार कार्यक्रम यह जाँचता है कि क्या POPCNT का उपयोग करना संभव है, या एक पॉलीफ़ाइल का उपयोग करना। चूंकि runtime.x86HasPOPCNT का मान। runtime.x86HasPOPCNT इनिशियलाइज़ेशन के बाद नहीं बदलता है, प्रोसेसर ब्रांचिंग की भविष्यवाणी अपेक्षाकृत सटीक है।

परमाणु काउंटर

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

 package main import ( "sync/atomic" ) type counter uint64 func (c *counter) get() uint64 { return atomic.LoadUint64((*uint64)(c)) } func (c *counter) inc() uint64 { return atomic.AddUint64((*uint64)(c), 1) } func (c *counter) reset() uint64 { return atomic.SwapUint64((*uint64)(c), 0) } func F() uint64 { var c counter c.inc() c.get() return c.reset() } func main() { F() } 

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


क्रम में। c.inc lock xadd [rax], 1 में बदल जाता है - x86 का परमाणु जोड़। c.get सामान्य चल अनुदेश बन जाता है, जो x86 में पहले से ही परमाणु है। c.reset शून्य रजिस्टर और मेमोरी के बीच xchg का परमाणु विनिमय बन जाता है।

निष्कर्ष

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