आज हम गो में 30% छोटी लाइनों की बॉन्डिंग को तेज करेंगे। और इसके लिए हमें स्वयं गो को संशोधित करने की आवश्यकता नहीं होगी, यह सब तीसरे पक्ष के पुस्तकालय के रूप में लागू किया जाएगा।

उस कटौती के तहत जिसका आप इंतजार कर रहे हैं:

• तुलना + , strings.Builder और देशी संघनन कार्य
• आंतरिक पंक्ति विवरण पर जाएं
• थोड़ा असेंबल करें

इस लेख को CL123256 पर चर्चा करने के लिए एक बहाना भी माना जा सकता है : रनटाइम, cmd / संकलन: concatstring2 विशेषज्ञ । इस परिवर्तन सूची में सुधार के लिए विचारों का स्वागत है।

तुरंत परिणाम

कंपाइलर के go tip (मास्टर) संस्करण के साथ तुलना की गई थी। आप गो 1.5 के आसपास संस्करणों पर समान परिणाम प्राप्त कर सकते हैं। concatstrings कार्य के लिए अंतिम महत्वपूर्ण परिवर्तन CL3120: cmd / gc था: स्टैक पर गैर-एस्केप स्ट्रिंग्स के लिए बफ़र्स आवंटित करें ।

 BenchmarkConcat2Operator-8 20000000 83.8 ns/op BenchmarkConcat2Builder-8 20000000 70.9 ns/op BenchmarkConcat2-8 20000000 62.1 ns/op BenchmarkConcat3Operator-8 20000000 104 ns/op BenchmarkConcat3Builder-8 20000000 89.9 ns/op BenchmarkConcat3-8 20000000 82.1 ns/op 

ConcatOperator + का उपयोग करता है।
ConcatBuilder सही पूर्व-आवंटन के साथ ConcatBuilder का उपयोग करता है।
Concat उस फ़ंक्शन का उपयोग करता है जिसे हम इस कहानी के हिस्से के रूप में कार्यान्वित करते हैं।

बेंचस्टैट के माध्यम से तुलना:

 name old time/op new time/op delta Concat2-8 84.2ns ± 1% 62.7ns ± 2% -25.49% (p=0.000 n=9+10) Concat3-8 103ns ± 3% 83ns ± 4% -19.83% (p=0.000 n=10+9) 

GOARCH=AMD64 तहत कोडांतरक कार्यान्वयन थोड़ा तेज है और इसमें अतिरिक्त अनुकूलन है, जो बिल्ट-इन + ऑपरेटर में मौजूद है, लेकिन नीचे उस पर और अधिक:

 name old time/op new time/op delta Concat2-8 84.2ns ± 1% 57.1ns ± 3% -32.20% (p=0.000 n=9+9) 

हम असेंबलर फ़ंक्शन को 100% प्रदर्शन (शेष कार्यान्वयन के सापेक्ष) के रूप में लेंगे।

लंबी लाइनों के परिणाम README.md में देखे जा सकते हैं। स्ट्रिंग जितनी लंबी होगी, कार्यान्वयन के बीच का अंतर उतना ही कम होगा।

भोलापन

सबसे आसान उपाय है + ऑपरेटर का उपयोग करना।

इस कथन के शब्दार्थ इस प्रकार हैं: दो पंक्तियाँ लें और एक परिणाम स्ट्रिंग लौटाएँ जिसमें दोनों रेखाओं का संघात हो। इस बात की कोई गारंटी नहीं है कि एक नई लाइन वापस आ जाएगी। उदाहरण के लिए, यदि खाली स्ट्रिंग और किसी भी अन्य का संयोजन है, तो रनटाइम एक गैर-रिक्त तर्क लौटा सकता है, नई मेमोरी को आवंटित करने और वहां डेटा कॉपी करने की आवश्यकता से बचता है।

लेकिन, जैसा कि लेख की शुरुआत में परिणामों से देखा जा सकता है, यह सबसे धीमा तरीका है।

 func concat2operator(x, y string) string { return x + y } 

प्रदर्शन रेटिंग: 67.8% ।

strings.Builder

बहुत समय पहले नहीं, गो - स्ट्रिंग्स के लिए एक नया प्रकार जोड़ा गया था। यह bytes.Buffer का एक एनालॉग है। bytes.Buffer , लेकिन String() विधि को कॉल करते समय, मेमोरी को फिर से आवंटित नहीं किया जाता है और डेटा की प्रतिलिपि नहीं बनाई जाती है।

bytes.Buffer विपरीत। bytes.Buffer , बिल्डर के पास एक छोटे बफर का अनुकूलन नहीं है और इसलिए, पहले एक स्ट्रिंग के लिए आवंटित मेमोरी। यदि आप Grow विधि का उपयोग नहीं करते हैं, तो प्रदर्शन bytes.Buffer से भी बदतर होगा। bytes.Buffer । गो 1.11 में कई रेजिस्टर इस विशेष सुविधा के कारण होते हैं ( CL113235 देखें)।

हमारे कोड में, प्रयोग की शुद्धता के लिए, हम इस त्रुटि से बचेंगे।

 func concat2builder(x, y string) string { var builder strings.Builder builder.Grow(len(x) + len(y)) //      builder.WriteString(x) builder.WriteString(y) return builder.String() } 

प्रदर्शन रेटिंग: 80.5% (+12.7)।

कॉनटैटन के लिए कोड जनरेशन

यदि हम देखते हैं कि कंपाइलर + ऑपरेटर के लिए किस कोड को उत्पन्न करता है, तो हम concatstring2 , concatstring3 concatstring2 को कॉल करेंगे, और इसी तरह ( concatstring5 समावेशी तक)।

 func concat2codegen(x, y) string { return x + y } // => CALL runtime.concatstring2(SB) func concat3codegen(x, y, z) string { return x + y + z } // => CALL runtime.concatstring3(SB) 

स्वयं रनटाइम / स्ट्रिंग पर एक नज़र डालें:

 func concatstring2(buf *tmpBuf, a [2]string) string { return concatstrings(buf, a[:]) } func concatstring3(buf *tmpBuf, a [3]string) string { return concatstrings(buf, a[:]) } 

इसलिए, यह फंक्शन concatstrings सीखना concatstrings ।
स्पॉइलर के नीचे एक पूरी लिस्टिंग उपलब्ध है, लेकिन यहां एक उच्च-स्तरीय विवरण दिया गया है:

1. buf पैरामीटर nil हो सकता है। यह बफर संकलक द्वारा आवंटित किया जाता है यदि रेखा अपनी परिभाषा से "बच" नहीं जाती है। यदि स्ट्रिंग फ्रेम से अधिक समय तक रहती है, तो यह बफर हमेशा nil (जैसा कि अक्सर होता है)। हालाँकि, यदि यह बफ़र उपलब्ध है, तो परिणाम के आबंटन से बचने के लिए संभव होगा, जब परिणाम इसमें टूटता है (इसका आकार 32 बाइट्स है)।
2. यदि एक को छोड़कर सभी लाइनें खाली हैं, तो फ़ंक्शन इस लाइन को वापस कर देगा। लेकिन एक ही समय में, स्टैक पर चयनित लाइनों और उनके फ्रेम को छोड़कर इस अनुकूलन को बायपास कर दिया जाता है ताकि कॉलर को पहले से ही मुक्त मेमोरी प्राप्त न हो।
3. इसके अलावा, सभी लाइनों को नई मेमोरी में कॉपी किया जाता है।

 // concatstrings implements a Go string concatenation x+y+z+... // The operands are passed in the slice a. // If buf != nil, the compiler has determined that the result does not // escape the calling function, so the string data can be stored in buf // if small enough. func concatstrings(buf *tmpBuf, a []string) string { idx := 0 l := 0 count := 0 for i, x := range a { n := len(x) if n == 0 { continue } if l+n < l { throw("string concatenation too long") } l += n count++ idx = i } if count == 0 { return "" } // If there is just one string and either it is not on the stack // or our result does not escape the calling frame (buf != nil), // then we can return that string directly. if count == 1 && (buf != nil || !stringDataOnStack(a[idx])) { return a[idx] } s, b := rawstringtmp(buf, l) for _, x := range a { copy(b, x) b = b[len(x):] } return s } 

यहाँ हम एक साथ कई स्थानों को देखते हैं जिन्हें किसी विशेष मामले के लिए अनुकूलित किया जा सकता है:

• buf सबसे अधिक बार खाली होता है। जब कंपाइलर यह साबित नहीं कर सका कि स्ट्रिंग को स्टैक पर रखने के लिए सुरक्षित है, तो एक अतिरिक्त पैरामीटर पास करना और फ़ंक्शन के अंदर nil लिए इसे जांचना केवल ओवरहेड देता है।
• len(a) == 2 साथ विशेष मामले के लिए len(a) == 2 हमें एक चक्र की आवश्यकता नहीं है और गणना को सरल बनाया जा सकता है। और यह संघनन का सबसे आम रूप है।

सभी आर्किटेक्चर के लिए संस्करण

विशेषज्ञता को लागू करने के लिए, हमें यह जानना होगा कि गो में लाइनों का प्रतिनिधित्व कैसे किया जाता है। द्विआधारी संगतता हमारे लिए महत्वपूर्ण है, जबकि unsafe.Pointer बिना किसी बलिदान के *byte साथ प्रतिस्थापित किया जा सकता है।

 type stringStruct struct { str *byte len int } 

दूसरा महत्वपूर्ण निष्कर्ष जिसे हम रनटाइम से आकर्षित कर सकते हैं: लाइनें उनके जीवन को परस्पर रूप से शुरू करती हैं। मेमोरी का एक टुकड़ा आवंटित किया जाता है जिसे []byte द्वारा संदर्भित किया []byte , जिसमें नई लाइन की सामग्री लिखी जाती है, और उसके बाद ही []byte छोड़ दिया जाता है, और जिस मेमोरी को इसे संदर्भित किया जाता है, उसे stringStruct में संग्रहीत किया जाता है।

जो लोग अधिक विवरण चाहते हैं, उनके लिए rawstringtmp और rawstring के कार्यों का अध्ययन करने का सुझाव दिया गया है।

 // rawstring allocates storage for a new string. The returned // string and byte slice both refer to the same storage. // The storage is not zeroed. Callers should use // b to set the string contents and then drop b. func rawstring(size int) (s string, b []byte) { p := mallocgc(uintptr(size), nil, false) stringStructOf(&s).str = p stringStructOf(&s).len = size *(*slice)(unsafe.Pointer(&b)) = slice{p, size, size} return } 

unsafe पैकेज के अंधेरे पक्ष का उपयोग करते हुए, हम लगभग समान रूप से क्रैंक कर सकते हैं:

 func concat2(x, y string) string { length := len(x) + len(y) if length == 0 { return "" } b := make([]byte, length) copy(b, x) copy(b[len(x):], y) return goString(&b[0], length) } 

हम []byte हाइलाइट करते हैं, जिसका उपयोग हम एक नई लाइन की सामग्री बनाने के लिए करते हैं। तब हम केवल अपेक्षित रनटाइम प्रतिनिधित्व को लाकर लाइन को अंतिम रूप दे सकते हैं। इसके लिए goString फ़ंक्शन जिम्मेदार है:

 func goString(ptr *byte, length int) string { s := stringStruct{str: ptr, len: length} return *(*string)(unsafe.Pointer(&s)) } 

प्रदर्शन रेटिंग: 91.9% (+10.9)।

AMD64 संस्करण

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

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

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

मान लीजिए कि एक फ़ंक्शन को तर्कों के साथ कहा जाता है concat2("", "123") । x एक खाली स्ट्रिंग है, और यदि y स्टैक पर आवंटित नहीं किया गया है, तो हम इसे संघनन के परिणाम के रूप में वापस कर सकते हैं।

 //; ,  x  y   stringStruct. //; CX - y.str. //; SI - y.len. maybe_return_y: //;      . MOVQ (TLS), AX //; *g CMPQ CX, (AX) JL return_y //;  y_str < g.stack.lo CMPQ CX, 8(AX) JGE return_y //;  y_str >= g.stack.hi JMP concatenate //; y  ,    return_y: MOVQ CX, ret+32(FP) //; stringStruct.len MOVQ SI, ret+40(FP) //; stringStruct.str RET 

MOVQ (TLS), AX * को रजिस्टर में ले MOVQ (TLS), AX । शून्य ऑफसेट पर पढ़ने से g.stack.lo फ़ील्ड g.stack.lo , और g.stack.hi 8 वीं बाइट (64-बिट प्लेटफ़ॉर्म के लिए) से शुरू होता है।

 type g struct { stack struct { lo uintptr // 0(AX) hi uintptr // 8(AX) } stackguard0 uintptr // 16(AX) stackguard1 uintptr // 24(AX) // ...   } 

concatenate शरीर स्मृति को आवंटित करता है, इसे दोनों रेखाओं से भरता है, और एक नई रेखा देता है।

 #include "textflag.h" #include "funcdata.h" TEXT ·Strings(SB), 0, $48-48 NO_LOCAL_POINTERS //    . MOVQ x+0(FP), DX MOVQ x+8(FP), DI MOVQ y+16(FP), CX MOVQ y+24(FP), SI TESTQ DI, DI JZ maybe_return_y // x -  ,   y TESTQ SI, SI JZ maybe_return_x // y -  ,   x concatenate: LEAQ (DI)(SI*1), R8 // len(x) + len(y) //     . MOVQ R8, 0(SP) MOVQ $0, 8(SP) MOVB $0, 16(SP) CALL runtime·mallocgc(SB) MOVQ 24(SP), AX //     MOVQ AX, newstr-8(SP) //  x. MOVQ x+0(FP), DX MOVQ x+8(FP), DI MOVQ AX, 0(SP) MOVQ DX, 8(SP) MOVQ DI, 16(SP) CALL runtime·memmove(SB) //  y   len(x). MOVQ x+8(FP), DI MOVQ y+16(FP), CX MOVQ y+24(FP), SI MOVQ newstr-8(SP), AX LEAQ (AX)(DI*1), BX MOVQ BX, 0(SP) MOVQ CX, 8(SP) MOVQ SI, 16(SP) CALL runtime·memmove(SB) //   . MOVQ newstr-8(SP), AX MOVQ x+8(FP), R8 ADDQ y+24(FP), R8 MOVQ AX, ret+32(FP) MOVQ R8, ret+40(FP) RET maybe_return_y: //      . MOVQ (TLS), AX // *g CMPQ CX, (AX) JL return_y //  y_ptr < stk.lo CMPQ CX, 8(AX) JGE return_y //  y_ptr >= stk.hi JMP concatenate // y  ,    return_y: MOVQ CX, ret+32(FP) MOVQ SI, ret+40(FP) RET maybe_return_x: //      . MOVQ (TLS), AX // *g CMPQ DX, (AX) JL return_x //  x_ptr < stk.lo CMPQ DX, 8(AX) JGE return_x //  x_ptr >= stk.hi JMP concatenate // x  ,    return_x: MOVQ DX, ret+32(FP) MOVQ DI, ret+40(FP) RET 

प्रदर्शन रेटिंग: 100% (+8.6)।

निष्कर्ष में

सभी कोड को कॉनैट पैकेज के रूप में प्रदान किया जाता है।

क्या दुनिया इस तरह के त्वरित समझौते के लिए तैयार है? कौन जानता है।

लेख की शुरुआत में, CL123256 का उल्लेख किया गया था। उसके पास कई विकास पथ हैं:

1. इस मामले के लिए विविधतापूर्ण विशेषज्ञता जब कंपाइलर एक अस्थायी बफर आवंटित नहीं करता है। प्रत्येक मामले के लिए कम विकास होता है, लेकिन यह अधिक प्रकार के संघनन को कवर करता है और व्यावहारिक रूप से कोड (मशीन और गो कोड दोनों) के आकार में वृद्धि नहीं करता है।
2. विशेष मामलों के लिए अधिक विशेषज्ञता। अधिक लाभ, लेकिन अधिक मशीन कोड, अनुदेश कैश को नुकसान पहुंचा सकता है।
3. प्रत्येक विशेष मामले और विशिष्ट मेमोव के लिए, मशीन कोड के टोंस, इस तरह से कैसे ग्लिबक में किया जाता है। यहाँ मुख्य रूप से समीचीनता के प्रश्न उठते हैं।

वर्तमान प्रस्तावित विकल्प स्ट्रिंग्स की एक जोड़ी के समवशरण का सबसे आम और सरल मामला तेज करता है (arity = 2)।

यदि गो इस परिवर्तन को स्वीकार नहीं करता है, तो तीसरे पक्ष के पुस्तकालय के रूप में स्ट्रिंग संचालन को लागू करके तुलनीय त्वरण प्राप्त किया जा सकता है। कम सुविधाजनक, सुंदर और सुरुचिपूर्ण, लेकिन यह काम करता है।