Go માં બિટમેપ અનુક્રમણિકાઓ: જંગલી ઝડપે શોધો

પરિચય

મેં આ અહેવાલ મોસ્કોમાં ગોફરકોન રશિયા 2019 કોન્ફરન્સમાં અંગ્રેજીમાં અને નિઝની નોવગોરોડમાં એક બેઠકમાં રશિયનમાં આપ્યો હતો. અમે બીટમેપ ઇન્ડેક્સ વિશે વાત કરી રહ્યા છીએ - બી-ટ્રી કરતાં ઓછું સામાન્ય, પરંતુ ઓછું રસપ્રદ નથી. શેરિંગ રેકોર્ડિંગ કોન્ફરન્સમાં અંગ્રેજીમાં ભાષણો અને રશિયનમાં ટેક્સ્ટ ટ્રાન્સક્રિપ્ટ.

બીટમેપ ઇન્ડેક્સ કેવી રીતે કામ કરે છે, તે ક્યારે વધુ સારું છે, જ્યારે તે અન્ય ઇન્ડેક્સ કરતાં ખરાબ છે અને કયા કિસ્સામાં તે તેમના કરતાં નોંધપાત્ર રીતે ઝડપી છે તે અમે જોઈશું; ચાલો જોઈએ કે કયા લોકપ્રિય DBMSs પાસે પહેલાથી જ બીટમેપ ઇન્ડેક્સ છે; ચાલો ગોમાં આપણું પોતાનું લખવાનો પ્રયત્ન કરીએ. અને "ડેઝર્ટ માટે" અમે અમારા પોતાના સુપર-ફાસ્ટ વિશિષ્ટ ડેટાબેઝ બનાવવા માટે તૈયાર પુસ્તકાલયોનો ઉપયોગ કરીશું.

હું ખરેખર આશા રાખું છું કે મારા કાર્યો તમારા માટે ઉપયોગી અને રસપ્રદ રહેશે. જાઓ!

પરિચય

http://bit.ly/bitmapindexes
https://github.com/mkevac/gopherconrussia2019

કેમ છો બધા! સાંજના છ વાગ્યા છે અને અમે બધા ખૂબ થાકી ગયા છીએ. કંટાળાજનક ડેટાબેઝ ઇન્ડેક્સ થિયરી વિશે વાત કરવાનો સરસ સમય, બરાબર? ચિંતા કરશો નહીં, મારી પાસે અહીં અને ત્યાં સોર્સ કોડની બે લીટીઓ હશે. 🙂

બધા ટુચકાઓ બાજુ પર રાખો, અહેવાલ માહિતીથી ભરપૂર છે, અને અમારી પાસે વધુ સમય નથી. તો ચાલો શરુ કરીએ.

આજે હું નીચેના વિશે વાત કરીશ:

• સૂચકાંકો શું છે;
• બીટમેપ ઇન્ડેક્સ શું છે;
• તેનો ઉપયોગ ક્યાં થાય છે અને ક્યાં તેનો ઉપયોગ થતો નથી અને શા માટે;
• ગોમાં સરળ અમલીકરણ અને કમ્પાઇલર સાથે થોડો સંઘર્ષ;
• ગો એસેમ્બલરમાં થોડું ઓછું સરળ, પરંતુ વધુ ઉત્પાદક અમલીકરણ;
• બીટમેપ ઇન્ડેક્સની "સમસ્યાઓ";
• હાલના અમલીકરણો.

તો ઈન્ડેક્સ શું છે?

ઇન્ડેક્સ એ એક અલગ ડેટા માળખું છે જે અમે મુખ્ય ડેટા ઉપરાંત જાળવીએ છીએ અને અપડેટ કરીએ છીએ. તેનો ઉપયોગ શોધને ઝડપી બનાવવા માટે થાય છે. અનુક્રમણિકાઓ વિના, શોધ માટે ડેટાને સંપૂર્ણ રીતે પસાર કરવાની જરૂર પડશે (જે પ્રક્રિયાને પૂર્ણ સ્કેન કહેવાય છે), અને આ પ્રક્રિયામાં રેખીય અલ્ગોરિધમિક જટિલતા છે. પરંતુ ડેટાબેઝમાં સામાન્ય રીતે મોટી માત્રામાં ડેટા હોય છે અને રેખીય જટિલતા ખૂબ ધીમી હોય છે. આદર્શરીતે, આપણને લઘુગણક અથવા સતત એક મળશે.

આ એક ખૂબ જ જટિલ વિષય છે, જે સૂક્ષ્મતા અને ટ્રેડ-ઓફથી ભરેલો છે, પરંતુ દાયકાઓના ડેટાબેઝ વિકાસ અને સંશોધનને જોયા પછી, હું કહેવા તૈયાર છું કે ડેટાબેઝ અનુક્રમણિકાઓ બનાવવા માટે માત્ર થોડા જ વ્યાપક રીતે ઉપયોગમાં લેવાતા અભિગમો છે.

પ્રથમ અભિગમ એ શોધ જગ્યાને અધિક્રમિક રીતે ઘટાડવાનો છે, શોધ જગ્યાને નાના ભાગોમાં વિભાજીત કરવી.

અમે સામાન્ય રીતે આ વિવિધ પ્રકારના વૃક્ષોનો ઉપયોગ કરીને કરીએ છીએ. એક ઉદાહરણ તમારા કબાટમાં સામગ્રીનું એક મોટું બોક્સ હશે જેમાં વિવિધ વિષયોમાં વિભાજિત સામગ્રીના નાના બોક્સ હોય છે. જો તમને સામગ્રીની જરૂર હોય, તો તમે કદાચ તેમને "કુકીઝ" કહેતા બોક્સને બદલે "સામગ્રી" કહેતા બોક્સમાં જોશો, ખરું ને?

બીજો અભિગમ તરત જ ઇચ્છિત તત્વ અથવા તત્વોના જૂથને પસંદ કરવાનો છે. અમે આ હેશ નકશા અથવા વિપરીત અનુક્રમણિકાઓમાં કરીએ છીએ. હેશ નકશાનો ઉપયોગ કરવો એ અગાઉના ઉદાહરણ જેવું જ છે, પરંતુ બોક્સના બોક્સને બદલે, તમારી પાસે તમારા કબાટમાં અંતિમ વસ્તુઓના નાના બોક્સનો સમૂહ છે.

ત્રીજો અભિગમ શોધની જરૂરિયાતને દૂર કરવાનો છે. અમે બ્લૂમ ફિલ્ટર અથવા કોયલ ફિલ્ટરનો ઉપયોગ કરીને આ કરીએ છીએ. પ્રથમ લોકો તરત જ જવાબ આપે છે, જે તમને શોધવામાં પડતાં બચાવે છે.

છેલ્લો અભિગમ એ તમામ શક્તિનો સંપૂર્ણ ઉપયોગ કરવાનો છે જે આધુનિક હાર્ડવેર આપણને આપે છે. આ બરાબર છે જે આપણે બીટમેપ ઇન્ડેક્સમાં કરીએ છીએ. હા, તેનો ઉપયોગ કરતી વખતે આપણને કેટલીકવાર સમગ્ર ઇન્ડેક્સમાંથી પસાર થવાની જરૂર પડે છે, પરંતુ અમે તે ખૂબ જ અસરકારક રીતે કરીએ છીએ.

મેં કહ્યું તેમ, ડેટાબેઝ ઇન્ડેક્સનો વિષય વિશાળ અને સમાધાનથી ભરેલો છે. આનો અર્થ એ છે કે કેટલીકવાર આપણે એક જ સમયે અનેક અભિગમોનો ઉપયોગ કરી શકીએ છીએ: જો આપણે શોધને વધુ ઝડપી બનાવવાની જરૂર હોય, અથવા જો આપણે તમામ સંભવિત શોધ પ્રકારોને આવરી લેવાની જરૂર હોય.

આજે હું આના સૌથી ઓછા જાણીતા અભિગમ વિશે વાત કરીશ - બીટમેપ ઇન્ડેક્સ.

આ વિષય પર બોલવાવાળો હું કોણ છું?

હું Badoo ખાતે ટીમ લીડ તરીકે કામ કરું છું (કદાચ તમે અમારા અન્ય ઉત્પાદન, બમ્બલથી વધુ પરિચિત છો). અમારી પાસે પહેલેથી જ વિશ્વભરમાં 400 મિલિયનથી વધુ વપરાશકર્તાઓ છે અને ઘણી સુવિધાઓ છે જે તેમના માટે શ્રેષ્ઠ મેચ પસંદ કરે છે. અમે બીટમેપ ઇન્ડેક્સ સહિત કસ્ટમ સેવાઓનો ઉપયોગ કરીને આ કરીએ છીએ.

તો બીટમેપ ઇન્ડેક્સ શું છે?

બીટમેપ ઇન્ડેક્સ, નામ સૂચવે છે તેમ, શોધ ઇન્ડેક્સને અમલમાં મૂકવા માટે બીટમેપ અથવા બિટસેટ્સનો ઉપયોગ કરો. પક્ષીની આંખના દૃષ્ટિકોણથી, આ અનુક્રમણિકામાં કોઈપણ એન્ટિટી (જેમ કે લોકો) અને તેમના ગુણધર્મો અથવા પરિમાણો (ઉંમર, આંખનો રંગ, વગેરે) અને બીટ ઑપરેશન્સ (AND, OR, NOT) નો ઉપયોગ કરીને એક અલ્ગોરિધમનું પ્રતિનિધિત્વ કરતા આવા એક અથવા વધુ બીટમેપનો સમાવેશ થાય છે. ) શોધ ક્વેરીનો જવાબ આપવા માટે.

અમને કહેવામાં આવ્યું છે કે બીટમેપ અનુક્રમણિકા એવા કિસ્સાઓ માટે શ્રેષ્ઠ અનુરૂપ અને ખૂબ જ પ્રભાવશાળી છે કે જ્યાં ઘણી ઓછી કાર્ડિનલિટી કૉલમ્સમાં ક્વેરીઝને જોડતી શોધ હોય છે (વિચારો "આંખનો રંગ" અથવા "વૈવાહિક સ્થિતિ" વિરુદ્ધ "શહેરના કેન્દ્રથી અંતર" જેવું કંઈક). પરંતુ હું પછી બતાવીશ કે તેઓ ઉચ્ચ કાર્ડિનલિટી કૉલમ માટે પણ બરાબર કામ કરે છે.

ચાલો બીટમેપ ઇન્ડેક્સનું સૌથી સરળ ઉદાહરણ જોઈએ.

કલ્પના કરો કે અમારી પાસે આના જેવી દ્વિસંગી ગુણધર્મો સાથે મોસ્કો રેસ્ટોરન્ટ્સની સૂચિ છે:

• મેટ્રો નજીક;
• ત્યાં ખાનગી પાર્કિંગ છે;
• ત્યાં એક વરંડા છે (ટેરેસ છે);
• તમે ટેબલ આરક્ષિત કરી શકો છો (આરક્ષણ સ્વીકારે છે);
• શાકાહારીઓ માટે યોગ્ય (શાકાહારી મૈત્રીપૂર્ણ);
• ખર્ચાળ (ખર્ચાળ).

ચાલો દરેક રેસ્ટોરન્ટને 0 થી શરૂ થતો ક્રમ નંબર આપીએ અને 6 બીટમેપ્સ (દરેક લાક્ષણિકતા માટે એક) માટે મેમરી ફાળવીએ. પછી રેસ્ટોરન્ટ પાસે આ મિલકત છે કે નહીં તેના આધારે અમે આ બીટમેપ્સને પોપ્યુલેટ કરીશું. જો રેસ્ટોરન્ટ 4 પાસે વરંડા છે, તો પછી “હેઝ એ વરંડા” માં બીટ નંબર 4 બીટમેપ 1 પર સેટ કરવામાં આવશે (જો ત્યાં કોઈ વરંડા નથી, તો પછી 0 પર).

હવે અમારી પાસે શક્ય સૌથી સરળ બીટમેપ ઇન્ડેક્સ છે, અને અમે તેનો ઉપયોગ પ્રશ્નોના જવાબ આપવા માટે કરી શકીએ છીએ જેમ કે:

• “મને શાકાહારી-મૈત્રીપૂર્ણ રેસ્ટોરાં બતાવો”;
• "મને વરંડાવાળી સસ્તી રેસ્ટોરાં બતાવો જ્યાં તમે ટેબલ આરક્ષિત કરી શકો."

કેવી રીતે? ચાલો એક નજર કરીએ. પ્રથમ વિનંતી ખૂબ જ સરળ છે. અમારે ફક્ત "શાકાહારી મૈત્રીપૂર્ણ" બીટમેપ લેવાની જરૂર છે અને તેને રેસ્ટોરાંની યાદીમાં ફેરવવાની જરૂર છે જેના બિટ્સ ખુલ્લા છે.


બીજી વિનંતી થોડી વધુ જટિલ છે. સસ્તી રેસ્ટોરાંની સૂચિ મેળવવા માટે આપણે “મોંઘા” બીટમેપ પર નૉટ બીટમેપનો ઉપયોગ કરવાની જરૂર છે, પછી અને તે “શું હું ટેબલ બુક કરી શકું છું” બીટમેપ સાથે અને અને પરિણામ “એક વરંડા છે” બીટમેપ સાથે. પરિણામી બીટમેપમાં અમારા તમામ માપદંડોને પૂર્ણ કરતી સંસ્થાઓની યાદી હશે. આ ઉદાહરણમાં, આ ફક્ત યુનોસ્ટ રેસ્ટોરન્ટ છે.


તેમાં ઘણી બધી થિયરી સામેલ છે, પરંતુ ચિંતા કરશો નહીં, અમે ટૂંક સમયમાં કોડ જોઈશું.

બીટમેપ ઇન્ડેક્સ ક્યાં વપરાય છે?

જો તમે Google બીટમેપ ઇન્ડેક્સ કરો છો, તો 90% જવાબો એક અથવા બીજી રીતે Oracle DB સાથે સંબંધિત હશે. પરંતુ અન્ય ડીબીએમએસ પણ કદાચ આવી સરસ વસ્તુને સમર્થન આપે છે, ખરું? ખરેખર નથી.

ચાલો મુખ્ય શંકાસ્પદોની સૂચિમાંથી પસાર થઈએ.

MySQL હજુ સુધી બીટમેપ ઇન્ડેક્સને સપોર્ટ કરતું નથી, પરંતુ આ વિકલ્પ ઉમેરવાનું સૂચન કરતી દરખાસ્ત છે (https://dev.mysql.com/worklog/task/?id=1524).

PostgreSQL બીટમેપ અનુક્રમણિકાઓને સમર્થન આપતું નથી, પરંતુ અન્ય બહુવિધ અનુક્રમણિકાઓમાં શોધ પરિણામોને જોડવા માટે સરળ બીટમેપ્સ અને બીટ ઓપરેશન્સનો ઉપયોગ કરે છે.

Tarantool પાસે બિટસેટ અનુક્રમણિકાઓ છે અને તેના પર સરળ શોધને સમર્થન આપે છે.

રેડિસમાં સરળ બીટફિલ્ડ્સ છે (https://redis.io/commands/bitfield) તેમને શોધવાની ક્ષમતા વિના.

મોંગોડીબી હજુ સુધી બીટમેપ ઇન્ડેક્સને સપોર્ટ કરતું નથી, પરંતુ આ વિકલ્પ ઉમેરવાનું સૂચન કરતી દરખાસ્ત પણ છે https://jira.mongodb.org/browse/SERVER-1723

Elasticsearch આંતરિક રીતે બીટમેપનો ઉપયોગ કરે છે (https://www.elastic.co/blog/frame-of-reference-and-roaring-bitmaps).

• પરંતુ અમારા ઘરમાં એક નવો પાડોશી દેખાયો: પિલોસા. આ ગોમાં લખાયેલ નવો બિન-સંબંધિત ડેટાબેઝ છે. તેમાં ફક્ત બીટમેપ ઇન્ડેક્સ હોય છે અને તેના પર બધું જ આધાર રાખે છે. અમે તેના વિશે થોડી વાર પછી વાત કરીશું.

ગો માં અમલીકરણ

પરંતુ શા માટે બીટમેપ ઇન્ડેક્સ આટલા ભાગ્યે જ ઉપયોગમાં લેવાય છે? આ પ્રશ્નનો જવાબ આપતા પહેલા, હું તમને બતાવવા માંગુ છું કે ગોમાં એક ખૂબ જ સરળ બીટમેપ ઇન્ડેક્સ કેવી રીતે અમલમાં મૂકવો.

બીટમેપ્સ એ અનિવાર્યપણે માત્ર ડેટાના ટુકડા છે. Go માં, ચાલો આ માટે બાઈટ સ્લાઈસનો ઉપયોગ કરીએ.

અમારી પાસે એક રેસ્ટોરન્ટની લાક્ષણિકતા માટે એક બીટમેપ છે, અને બીટમેપમાં દરેક બીટ સૂચવે છે કે કોઈ ચોક્કસ રેસ્ટોરન્ટ પાસે આ મિલકત છે કે નહીં.

અમને બે સહાયક કાર્યોની જરૂર પડશે. એકનો ઉપયોગ અમારા બીટમેપ્સને રેન્ડમ ડેટાથી ભરવા માટે કરવામાં આવશે. રેન્ડમ, પરંતુ ચોક્કસ સંભાવના સાથે કે રેસ્ટોરન્ટમાં દરેક મિલકત છે. ઉદાહરણ તરીકે, હું માનું છું કે મોસ્કોમાં ઘણી ઓછી રેસ્ટોરન્ટ્સ છે જ્યાં તમે ટેબલ આરક્ષિત કરી શકતા નથી, અને મને લાગે છે કે લગભગ 20% સંસ્થાઓ શાકાહારીઓ માટે યોગ્ય છે.

બીજું કાર્ય બીટમેપને રેસ્ટોરાંની યાદીમાં રૂપાંતરિત કરશે.


ક્વેરીનો જવાબ આપવા માટે "મને એવી સસ્તી રેસ્ટોરન્ટ્સ બતાવો કે જેમાં પેશિયો હોય અને તેઓ રિઝર્વેશન કરી શકે," અમને બે બીટ ઑપરેશનની જરૂર છે: NOT અને AND.

અમે વધુ જટિલ AND NOT ઓપરેટરનો ઉપયોગ કરીને અમારા કોડને થોડો સરળ બનાવી શકીએ છીએ.

અમારી પાસે આ દરેક કામગીરી માટે કાર્યો છે. તે બંને સ્લાઇસેસમાંથી પસાર થાય છે, દરેકમાંથી અનુરૂપ તત્વો લો, તેમને થોડી કામગીરી સાથે જોડો અને પરિણામી સ્લાઇસમાં પરિણામ મૂકો.

અને હવે આપણે સર્ચ ક્વેરીનો જવાબ આપવા માટે અમારા બીટમેપ્સ અને ફંક્શનનો ઉપયોગ કરી શકીએ છીએ.

ફંક્શન ખૂબ જ સરળ હોવા છતાં પણ પરફોર્મન્સ એટલું ઊંચું નથી અને દરેક વખતે ફંક્શનને કૉલ કરવામાં આવે ત્યારે અમે નવી પરિણામી સ્લાઇસ પરત ન કરીને ઘણા પૈસા બચાવ્યા.

pprof સાથે થોડી પ્રોફાઇલિંગ કર્યા પછી, મેં નોંધ્યું કે Go કમ્પાઇલરમાં એક ખૂબ જ સરળ પરંતુ ખૂબ જ મહત્વપૂર્ણ ઑપ્ટિમાઇઝેશન ખૂટે છે: ફંક્શન ઇનલાઇનિંગ.

હકીકત એ છે કે ગો કમ્પાઇલર લૂપ્સથી ભયંકર રીતે ભયભીત છે જે સ્લાઇસેસમાંથી પસાર થાય છે, અને આવા લૂપ્સ ધરાવતા ઇનલાઇન ફંક્શન્સને સ્પષ્ટપણે ઇનકાર કરે છે.

પરંતુ હું ડરતો નથી અને હું લૂપને બદલે ગોટોનો ઉપયોગ કરીને કમ્પાઇલરને મૂર્ખ બનાવી શકું છું, જેમ કે સારા જૂના દિવસોમાં.

અને, જેમ તમે જોઈ શકો છો, હવે કમ્પાઈલર અમારા કાર્યને ખુશીથી ઇનલાઇન કરશે! પરિણામે, અમે લગભગ 2 માઇક્રોસેકન્ડ્સ બચાવવાનું મેનેજ કરીએ છીએ. ખરાબ નથી!

જો તમે એસેમ્બલી આઉટપુટને નજીકથી જોશો તો બીજી અડચણ જોવાનું સરળ છે. કમ્પાઇલરે અમારા સૌથી ગરમ લૂપની અંદર એક સ્લાઇસ બાઉન્ડ્રી ચેક ઉમેર્યો. હકીકત એ છે કે ગો સલામત ભાષા છે, કમ્પાઇલરને ડર છે કે મારી ત્રણ દલીલો (ત્રણ સ્લાઇસેસ) વિવિધ કદની છે. છેવટે, પછી કહેવાતા બફર ઓવરફ્લોની ઘટનાની સૈદ્ધાંતિક સંભાવના હશે.

ચાલો કમ્પાઈલરને તે બતાવીને આશ્વાસન આપીએ કે બધી સ્લાઈસ સમાન માપની છે. અમે અમારા કાર્યની શરૂઆતમાં એક સરળ ચેક ઉમેરીને આ કરી શકીએ છીએ.

આ જોઈને, કમ્પાઈલર ખુશીથી ચેકને છોડી દે છે, અને અમે બીજા 500 નેનોસેકન્ડની બચત કરીએ છીએ.

મોટા બુચ

ઠીક છે, અમે અમારા સરળ અમલીકરણમાંથી કેટલાક પ્રભાવને સ્ક્વિઝ કરવામાં વ્યવસ્થાપિત છીએ, પરંતુ આ પરિણામ વાસ્તવમાં વર્તમાન હાર્ડવેર સાથે શક્ય છે તેના કરતા ઘણું ખરાબ છે.

અમે જે કરીએ છીએ તે મૂળભૂત બિટ ઑપરેશન્સ છે, અને અમારા પ્રોસેસરો તેને ખૂબ જ અસરકારક રીતે કરે છે. પરંતુ, કમનસીબે, અમે અમારા પ્રોસેસરને ખૂબ નાના કામ સાથે "ફીડ" કરીએ છીએ. અમારા કાર્યો બાઇટ-બાય-બાઇટ આધારે કામગીરી કરે છે. અમે UInt8 સ્લાઇસેસનો ઉપયોગ કરીને 64-બાઇટ હિસ્સા સાથે કામ કરવા માટે અમારા કોડને ખૂબ જ સરળતાથી ટ્વિક કરી શકીએ છીએ.

જેમ તમે જોઈ શકો છો, આ નાના ફેરફારે બેચના કદમાં આઠ ગણો વધારો કરીને અમારા પ્રોગ્રામને આઠ ગણો વેગ આપ્યો. ગેઇન રેખીય કહી શકાય.

એસેમ્બલરમાં અમલીકરણ

પરંતુ આ અંત નથી. અમારા પ્રોસેસર્સ 16, 32 અને 64 બાઈટના હિસ્સા સાથે કામ કરી શકે છે. આવા "વ્યાપક" ઓપરેશન્સને સિંગલ ઇન્સ્ટ્રક્શન મલ્ટિપલ ડેટા (SIMD; એક સૂચના, ઘણા ડેટા) કહેવામાં આવે છે અને કોડ ટ્રાન્સફોર્મ કરવાની પ્રક્રિયા જેથી તે આવી કામગીરીનો ઉપયોગ કરે છે તેને વેક્ટરાઇઝેશન કહેવામાં આવે છે.

કમનસીબે, ગો કમ્પાઇલર વેક્ટરાઇઝેશનમાં શ્રેષ્ઠ નથી. હાલમાં, ગો કોડને વેક્ટરાઇઝ કરવાનો એકમાત્ર રસ્તો એ છે કે ગો એસેમ્બલરનો ઉપયોગ કરીને આ ઑપરેશન્સને મેન્યુઅલી લેવા અને મૂકવા.

ગો એસેમ્બલર એક વિચિત્ર જાનવર છે. તમે કદાચ જાણો છો કે એસેમ્બલી લેંગ્વેજ એ એવી વસ્તુ છે જે તમે જે કમ્પ્યુટર માટે લખી રહ્યાં છો તેના આર્કિટેક્ચર સાથે ભારે જોડાયેલી છે, પરંતુ ગોમાં એવું નથી. ગો એસેમ્બલર વધુ IRL (મધ્યવર્તી પ્રતિનિધિત્વ ભાષા) અથવા મધ્યવર્તી ભાષા જેવું છે: તે વ્યવહારીક રીતે પ્લેટફોર્મ સ્વતંત્ર છે. રોબ પાઈકે ઉત્તમ પ્રદર્શન કર્યું અહેવાલ આ વિષય પર ઘણા વર્ષો પહેલા ડેનવરમાં ગોફરકોન ખાતે.

વધુમાં, ગો અસામાન્ય પ્લાન 9 ફોર્મેટનો ઉપયોગ કરે છે, જે સામાન્ય રીતે સ્વીકૃત AT&T અને Intel ફોર્મેટથી અલગ છે.

તે કહેવું સલામત છે કે હાથથી ગો એસેમ્બલર લખવું એ સૌથી વધુ મજા નથી.

પરંતુ, સદભાગ્યે, ત્યાં પહેલેથી જ બે ઉચ્ચ-સ્તરનાં સાધનો છે જે અમને Go એસેમ્બલર લખવામાં મદદ કરે છે: PeachPy અને avo. બંને ઉપયોગિતાઓ અનુક્રમે Python અને Go માં લખેલા ઉચ્ચ-સ્તરના કોડમાંથી Go એસેમ્બલર જનરેટ કરે છે.

આ ઉપયોગિતાઓ રજીસ્ટર ફાળવણી, લેખન લૂપ્સ જેવી વસ્તુઓને સરળ બનાવે છે અને સામાન્ય રીતે ગોમાં એસેમ્બલી પ્રોગ્રામિંગની દુનિયામાં પ્રવેશવાની પ્રક્રિયાને સરળ બનાવે છે.

અમે avo નો ઉપયોગ કરીશું, તેથી અમારા પ્રોગ્રામ લગભગ નિયમિત ગો પ્રોગ્રામ્સ હશે.

એવો પ્રોગ્રામનું સૌથી સરળ ઉદાહરણ આ જેવું દેખાય છે. અમારી પાસે એક મુખ્ય() ફંક્શન છે, જે પોતાની અંદર Add() ફંક્શનને વ્યાખ્યાયિત કરે છે, જેનો અર્થ બે નંબરો ઉમેરવાનો છે. નામ દ્વારા પરિમાણો મેળવવા અને મફત અને યોગ્ય પ્રોસેસર રજીસ્ટરોમાંથી એક મેળવવા માટે અહીં સહાયક કાર્યો છે. દરેક પ્રોસેસર ઑપરેશન એવૉ પર અનુરૂપ કાર્ય ધરાવે છે, જેમ કે ADDQ માં જોવામાં આવ્યું છે. અંતે, આપણે પરિણામી મૂલ્યને સંગ્રહિત કરવા માટે સહાયક કાર્ય જોઈએ છીએ.

ગો જનરેટને કૉલ કરીને, અમે એવો પર પ્રોગ્રામને એક્ઝિક્યુટ કરીશું અને પરિણામે, બે ફાઇલો જનરેટ થશે:

• Go એસેમ્બલરમાં પરિણામી કોડ સાથે add.s;
• બે વિશ્વને જોડવા માટે ફંક્શન હેડરો સાથે stub.go: જાઓ અને એસેમ્બલર.

હવે આપણે જોયું કે avo શું કરે છે અને કેવી રીતે, ચાલો આપણા કાર્યો જોઈએ. મેં વિધેયોના સ્કેલર અને વેક્ટર (SIMD) વર્ઝન બંનેનો અમલ કર્યો.

ચાલો પહેલા સ્કેલર વર્ઝન જોઈએ.

અગાઉના ઉદાહરણની જેમ, અમે મફત અને માન્ય સામાન્ય હેતુ રજિસ્ટર માટે પૂછી રહ્યા છીએ, અમારે દલીલો માટે ઑફસેટ્સ અને કદની ગણતરી કરવાની જરૂર નથી. avo આ બધું આપણા માટે કરે છે.

અમે પર્ફોર્મન્સ સુધારવા અને ગો કમ્પાઈલરને ટ્રિક કરવા માટે લેબલ્સ અને ગોટો (અથવા જમ્પ્સ) નો ઉપયોગ કરતા હતા, પરંતુ હવે અમે શરૂઆતથી જ કરી રહ્યા છીએ. મુદ્દો એ છે કે ચક્ર એ ઉચ્ચ સ્તરીય ખ્યાલ છે. એસેમ્બલરમાં, અમારી પાસે ફક્ત લેબલ્સ અને જમ્પ્સ છે.

બાકીનો કોડ પહેલેથી જ પરિચિત અને સમજી શકાય તેવો હોવો જોઈએ. અમે લેબલ અને કૂદકા સાથે લૂપનું અનુકરણ કરીએ છીએ, અમારા બે સ્લાઇસમાંથી ડેટાનો એક નાનો ટુકડો લઈએ છીએ, તેને થોડી કામગીરી સાથે જોડીએ છીએ (અને આ કિસ્સામાં નહીં) અને પછી પરિણામને પરિણામી સ્લાઇસમાં મૂકીએ છીએ. બધા.

અંતિમ એસેમ્બલર કોડ જેવો દેખાય છે તે આ છે. અમારે ઑફસેટ્સ અને કદની ગણતરી કરવાની જરૂર નહોતી (લીલા રંગમાં પ્રકાશિત) અથવા વપરાયેલ રજિસ્ટરનો ટ્રૅક રાખવાની જરૂર નહોતી (લાલ રંગમાં પ્રકાશિત).

જો આપણે એસેમ્બલી ભાષાના અમલીકરણની કામગીરીની Go માં શ્રેષ્ઠ અમલીકરણની કામગીરી સાથે તુલના કરીએ, તો આપણે જોશું કે તે સમાન છે. અને આ અપેક્ષિત છે. છેવટે, અમે કંઈ ખાસ કર્યું નથી - અમે હમણાં જ પુનઃઉત્પાદન કર્યું છે કે ગો કમ્પાઈલર શું કરશે.

કમનસીબે, અમે કમ્પાઈલરને એસેમ્બલી ભાષામાં લખેલા અમારા કાર્યોને ઇનલાઇન કરવા દબાણ કરી શકતા નથી. ગો કમ્પાઈલરમાં હાલમાં આવી કોઈ વિશેષતા નથી, જો કે ઘણા સમયથી તેને ઉમેરવાની વિનંતી કરવામાં આવી રહી છે.

આથી એસેમ્બલી લેંગ્વેજમાં નાના કાર્યોથી કોઈ ફાયદો મેળવવો અશક્ય છે. અમારે કાં તો મોટા ફંક્શન લખવાની જરૂર છે, અથવા નવા ગણિત/બિટ્સ પેકેજનો ઉપયોગ કરવો પડશે, અથવા એસેમ્બલર ભાષાને બાયપાસ કરવાની જરૂર છે.

ચાલો હવે આપણા કાર્યોના વેક્ટર સંસ્કરણો જોઈએ.

આ ઉદાહરણ માટે, મેં AVX2 નો ઉપયોગ કરવાનું નક્કી કર્યું છે, તેથી અમે 32-બાઇટ હિસ્સા પર કામ કરતા ઓપરેશન્સનો ઉપયોગ કરીશું. કોડનું માળખું સ્કેલર વર્ઝન જેવું જ છે: પેરામીટર લોડ કરવું, ફ્રી શેર્ડ રજિસ્ટર માટે પૂછવું વગેરે.

એક નવીનતા એ છે કે વ્યાપક વેક્ટર કામગીરી ખાસ વિશાળ રજિસ્ટરનો ઉપયોગ કરે છે. 32-બાઈટના હિસ્સાના કિસ્સામાં, આ Y સાથે ઉપસર્ગવાળા રજિસ્ટર છે. આ કારણે તમે કોડમાં YMM() ફંક્શન જુઓ છો. જો હું 512-બીટ હિસ્સા સાથે AVX-64 નો ઉપયોગ કરતો હોઉં, તો ઉપસર્ગ Z હશે.

બીજી નવીનતા એ છે કે મેં લૂપ અનરોલિંગ નામના ઓપ્ટિમાઇઝેશનનો ઉપયોગ કરવાનું નક્કી કર્યું, જેનો અર્થ છે લૂપની શરૂઆતમાં કૂદકો મારતા પહેલા મેન્યુઅલી આઠ લૂપ ઓપરેશન કરવું. આ ઑપ્ટિમાઇઝેશન કોડમાં શાખાઓની સંખ્યાને ઘટાડે છે, અને ઉપલબ્ધ મફત રજિસ્ટરની સંખ્યા દ્વારા મર્યાદિત છે.

સારું, પ્રદર્શન વિશે શું? તેણી સુંદર છે! શ્રેષ્ઠ ગો ​​સોલ્યુશનની સરખામણીમાં અમે લગભગ સાત ગણી ઝડપ હાંસલ કરી છે. પ્રભાવશાળી, અધિકાર?

પરંતુ ક્વેરી શેડ્યૂલર માટે AVX-512, પ્રીફેચિંગ અથવા JIT (જસ્ટ-ઇન-ટાઇમ કમ્પાઇલર) નો ઉપયોગ કરીને પણ આ અમલીકરણને સંભવિત રીતે ઝડપી કરી શકાય છે. પરંતુ આ ચોક્કસપણે એક અલગ અહેવાલ માટેનો વિષય છે.

બીટમેપ ઇન્ડેક્સ સાથે સમસ્યાઓ

હવે જ્યારે આપણે ગોમાં બીટમેપ ઇન્ડેક્સના સરળ અમલીકરણ અને એસેમ્બલી ભાષામાં વધુ ઉત્પાદકતા જોઈ ચૂક્યા છીએ, ચાલો આખરે વાત કરીએ કે શા માટે બીટમેપ ઇન્ડેક્સનો ભાગ્યે જ ઉપયોગ થાય છે.

જૂના કાગળો બીટમેપ અનુક્રમણિકા સાથે ત્રણ સમસ્યાઓનો ઉલ્લેખ કરે છે, પરંતુ નવા કાગળો અને હું દલીલ કરું છું કે તે હવે સંબંધિત નથી. અમે આ દરેક સમસ્યામાં ઊંડાણપૂર્વક ડૂબકી મારશું નહીં, પરંતુ તેમને ઉપરછલ્લી રીતે જોઈશું.

ઉચ્ચ કાર્ડિનલિટીની સમસ્યા

તેથી, અમને કહેવામાં આવ્યું છે કે બીટમેપ અનુક્રમણિકાઓ ફક્ત ઓછી મુખ્યતાવાળા ક્ષેત્રો માટે જ યોગ્ય છે, એટલે કે, જે ઓછા મૂલ્યો ધરાવે છે (ઉદાહરણ તરીકે, લિંગ અથવા આંખનો રંગ), અને તેનું કારણ એ છે કે આવા ક્ષેત્રોની સામાન્ય રજૂઆત (એક મૂલ્ય દીઠ બીટ) ઉચ્ચ કાર્ડિનલિટીના કિસ્સામાં, તે ખૂબ જ જગ્યા લેશે અને વધુમાં, આ બીટમેપ અનુક્રમણિકાઓ નબળી રીતે (ભાગ્યે જ) ભરેલી હશે.


કેટલીકવાર આપણે એક અલગ પ્રતિનિધિત્વનો ઉપયોગ કરી શકીએ છીએ, જેમ કે અમે સંખ્યાઓનું પ્રતિનિધિત્વ કરવા માટે જે પ્રમાણભૂતનો ઉપયોગ કરીએ છીએ. પરંતુ તે કમ્પ્રેશન એલ્ગોરિધમ્સનું આગમન હતું જેણે બધું જ બદલી નાખ્યું. છેલ્લા દાયકાઓમાં, વૈજ્ઞાનિકો અને સંશોધકો બીટમેપ્સ માટે મોટી સંખ્યામાં કમ્પ્રેશન અલ્ગોરિધમ્સ સાથે આવ્યા છે. તેમનો મુખ્ય ફાયદો એ છે કે બીટ ઓપરેશન્સ કરવા માટે બીટમેપ્સને ડિકમ્પ્રેસ કરવાની જરૂર નથી - અમે બીટ ઓપરેશન્સ સીધા કોમ્પ્રેસ્ડ બીટમેપ્સ પર કરી શકીએ છીએ.

તાજેતરમાં, હાઇબ્રિડ અભિગમો દેખાવાનું શરૂ થયું છે, જેમ કે રોરિંગ બીટમેપ્સ. તેઓ એકસાથે બીટમેપ્સ માટે ત્રણ અલગ-અલગ રજૂઆતોનો ઉપયોગ કરે છે - બીટમેપ્સ પોતે, એરે અને કહેવાતા બીટ રન - અને પ્રદર્શનને મહત્તમ કરવા અને મેમરી વપરાશ ઘટાડવા માટે તેમની વચ્ચે સંતુલન.

તમે સૌથી વધુ લોકપ્રિય એપ્લિકેશન્સમાં રોરિંગ બીટમેપ્સ શોધી શકો છો. ગો માટે ત્રણ કરતાં વધુ અમલીકરણો સહિત વિવિધ પ્રકારની પ્રોગ્રામિંગ ભાષાઓ માટે પહેલેથી જ મોટી સંખ્યામાં અમલીકરણો છે.

અન્ય અભિગમ કે જે અમને ઉચ્ચ કાર્ડિનલિટી સાથે વ્યવહાર કરવામાં મદદ કરી શકે છે તેને બિનિંગ કહેવામાં આવે છે. કલ્પના કરો કે તમારી પાસે વ્યક્તિની ઊંચાઈ દર્શાવતું ક્ષેત્ર છે. ઊંચાઈ એ ફ્લોટિંગ પોઈન્ટ નંબર છે, પરંતુ આપણે મનુષ્યો તેને તે રીતે વિચારતા નથી. અમારા માટે ઊંચાઈ 185,2 સેમી અને 185,3 સેમી વચ્ચે કોઈ તફાવત નથી.

તે તારણ આપે છે કે આપણે સમાન મૂલ્યોને 1 સે.મી.ની અંદર જૂથોમાં જૂથબદ્ધ કરી શકીએ છીએ.

અને જો આપણે એ પણ જાણીએ કે બહુ ઓછા લોકો 50 સે.મી.થી નાના અને 250 સે.મી.થી ઊંચા હોય છે, તો આપણે અનિવાર્યપણે અનંત કાર્ડિનલિટીવાળા ક્ષેત્રને લગભગ 200 મૂલ્યોની કાર્ડિનલિટીવાળા ક્ષેત્રમાં ફેરવી શકીએ છીએ.

અલબત્ત, જો જરૂરી હોય તો, અમે પછીથી વધારાના ફિલ્ટરિંગ કરી શકીએ છીએ.

ઉચ્ચ બેન્ડવિડ્થ સમસ્યા

બીટમેપ અનુક્રમણિકાઓની આગામી સમસ્યા એ છે કે તેમને અપડેટ કરવું ખૂબ ખર્ચાળ હોઈ શકે છે.

ડેટાબેસેસ ડેટાને અપડેટ કરવામાં સક્ષમ હોવા જોઈએ જ્યારે સંભવિત રીતે સેંકડો અન્ય ક્વેરી ડેટાને શોધી રહી હોય. સહવર્તી ડેટા ઍક્સેસ અથવા અન્ય શેરિંગ સમસ્યાઓથી બચવા માટે અમને તાળાઓની જરૂર છે. અને જ્યાં એક મોટું તાળું છે, ત્યાં એક સમસ્યા છે - લોક વિવાદ, જ્યારે આ તાળું અવરોધ બની જાય છે.

આ સમસ્યાને શાર્ડિંગનો ઉપયોગ કરીને અથવા વર્ઝનેડ ઇન્ડેક્સનો ઉપયોગ કરીને હલ કરી શકાય છે અથવા અટકાવી શકાય છે.

શેરિંગ એ એક સરળ અને જાણીતી વસ્તુ છે. તમે બીટમેપ ઇન્ડેક્સને અન્ય ડેટાની જેમ શાર્ડ કરી શકો છો. એક મોટા તાળાને બદલે, તમને નાના તાળાઓનો સમૂહ મળશે અને આમ તાળાની તકરારથી છુટકારો મેળવશો.

સમસ્યા હલ કરવાની બીજી રીત એ છે કે વર્ઝનેડ ઇન્ડેક્સનો ઉપયોગ કરવો. તમારી પાસે અનુક્રમણિકાની એક નકલ હોઈ શકે છે જેનો ઉપયોગ તમે શોધવા અથવા વાંચવા માટે કરો છો, અને એક જેનો ઉપયોગ તમે લખવા અથવા અપડેટ કરવા માટે કરો છો. અને ચોક્કસ સમયગાળામાં એકવાર (ઉદાહરણ તરીકે, દર 100 ms અથવા 500 ms માં એકવાર) તમે તેને ડુપ્લિકેટ કરો અને તેને સ્વેપ કરો. અલબત્ત, આ અભિગમ ફક્ત એવા કિસ્સાઓમાં જ લાગુ પડે છે કે જ્યાં તમારી એપ્લિકેશન થોડી પાછળ રહેલ શોધ ઇન્ડેક્સને સંભાળી શકે.

આ બે અભિગમો એકસાથે વાપરી શકાય છે: તમારી પાસે શાર્ડેડ વર્ઝન ઇન્ડેક્સ હોઈ શકે છે.

વધુ જટિલ પ્રશ્નો

બીટમેપ અનુક્રમણિકાઓની અંતિમ સમસ્યા એ છે કે અમને કહેવામાં આવે છે કે તેઓ વધુ જટિલ પ્રકારની ક્વેરીઝ માટે યોગ્ય નથી, જેમ કે સ્પાન ક્વેરીઝ.

ખરેખર, જો તમે તેના વિશે વિચારો છો, તો AND, OR, વગેરે જેવા બીટ ઑપરેશન્સ "મને 200 થી 300 ડૉલર પ્રતિ રાત્રિના રૂમના દરો ધરાવતી હોટેલ્સ બતાવો"ના પ્રશ્નો માટે ખૂબ જ યોગ્ય નથી.

એક નિષ્કપટ અને ખૂબ જ મૂર્ખ ઉકેલ એ છે કે દરેક ડોલરના મૂલ્ય માટે પરિણામો લેવા અને તેને બીટવાઇઝ અથવા ઑપરેશન સાથે જોડવું.

જૂથનો ઉપયોગ કરવાનો થોડો સારો ઉકેલ હશે. ઉદાહરણ તરીકે, 50 ડોલરના જૂથોમાં. આ અમારી પ્રક્રિયાને 50 ગણી ઝડપી કરશે.

પરંતુ આ પ્રકારની વિનંતી માટે ખાસ બનાવેલ દૃશ્યનો ઉપયોગ કરીને સમસ્યા પણ સરળતાથી ઉકેલી શકાય છે. વૈજ્ઞાનિક પેપર્સમાં તેને રેન્જ-એનકોડેડ બીટમેપ્સ કહેવામાં આવે છે.

આ રજૂઆતમાં, અમે અમુક મૂલ્ય (ઉદાહરણ તરીકે, 200) માટે માત્ર એક બીટ સેટ કરતા નથી, પરંતુ આ મૂલ્ય અને બધું વધારે સેટ કરીએ છીએ. 200 અને તેથી વધુ. 300: 300 અને તેથી વધુ માટે સમાન. અને તેથી વધુ.

આ રજૂઆતનો ઉપયોગ કરીને, અમે આ પ્રકારની શોધ ક્વેરીનો જવાબ માત્ર બે વાર અનુક્રમણિકાને પાર કરીને આપી શકીએ છીએ. સૌપ્રથમ, અમને એવી હોટલોની યાદી મળશે કે જ્યાં રૂમની કિંમત ઓછી અથવા $300 છે, અને પછી અમે તેમાંથી તેમાંથી દૂર કરીશું જ્યાં રૂમની કિંમત ઓછી અથવા $199 છે. તૈયાર છે.

તમને આશ્ચર્ય થશે, પરંતુ બીટમેપ ઇન્ડેક્સનો ઉપયોગ કરીને જીઓક્વેરીઝ પણ શક્ય છે. યુક્તિ એ ભૌમિતિક રજૂઆતનો ઉપયોગ કરવાની છે જે તમારા સંકલનને ભૌમિતિક આકૃતિ સાથે ઘેરી લે છે. ઉદાહરણ તરીકે, Google તરફથી S2. આકૃતિને ત્રણ અથવા વધુ છેદતી રેખાઓના સ્વરૂપમાં રજૂ કરવાનું શક્ય હોવું જોઈએ જેને ક્રમાંકિત કરી શકાય. આ રીતે આપણે આપણી ભૌગોલિક ક્વેરીઝને "ગેપ સાથે" (આ ક્રમાંકિત રેખાઓ સાથે) અનેક પ્રશ્નોમાં ફેરવી શકીએ છીએ.

તૈયાર ઉકેલો

મને આશા છે કે મને તમને થોડો રસ છે અને હવે તમારી પાસે તમારા શસ્ત્રાગારમાં બીજું ઉપયોગી સાધન છે. જો તમારે ક્યારેય આવું કંઈક કરવાની જરૂર હોય, તો તમને ખબર પડશે કે કઈ રીતે જોવું.

જો કે, દરેક પાસે શરૂઆતથી બીટમેપ ઇન્ડેક્સ બનાવવા માટે સમય, ધીરજ અથવા સંસાધનો હોતા નથી. ખાસ કરીને વધુ અદ્યતન, ઉદાહરણ તરીકે, SIMD નો ઉપયોગ કરીને.

સદભાગ્યે, તમને મદદ કરવા માટે ઘણા તૈયાર ઉકેલો છે.

રોરિંગ બીટમેપ્સ

પ્રથમ, ત્યાં તે જ રોરિંગ બીટમેપ્સ લાઇબ્રેરી છે જેના વિશે મેં પહેલેથી જ વાત કરી છે. તેમાં તમામ જરૂરી કન્ટેનર અને બીટ ઑપરેશન્સ છે જે તમારે સંપૂર્ણ બિટમેપ ઇન્ડેક્સ બનાવવાની જરૂર પડશે.

કમનસીબે, આ ક્ષણે, Go અમલીકરણોમાંથી કોઈ પણ SIMD નો ઉપયોગ કરતું નથી, જેનો અર્થ છે કે Go અમલીકરણો C અમલીકરણ કરતાં ઓછા પ્રભાવશાળી છે, ઉદાહરણ તરીકે.

પિલોસા

અન્ય ઉત્પાદન જે તમને મદદ કરી શકે છે તે છે Pilosa DBMS, જે હકીકતમાં માત્ર બીટમેપ ઇન્ડેક્સ ધરાવે છે. આ પ્રમાણમાં નવો ઉકેલ છે, પરંતુ તે ખૂબ જ ઝડપે દિલ જીતી રહ્યું છે.

પિલોસા આંતરિક રીતે રોરિંગ બીટમેપ્સનો ઉપયોગ કરે છે અને તમને તેનો ઉપયોગ કરવાની ક્ષમતા આપે છે, મેં ઉપર જે વિશે વાત કરી છે તે બધી બાબતોને સરળ બનાવે છે અને સમજાવે છે: જૂથીકરણ, શ્રેણી-એનકોડેડ બીટમેપ્સ, ક્ષેત્રનો ખ્યાલ, વગેરે.

ચાલો તમે પહેલાથી જ પરિચિત છો તેવા પ્રશ્નનો જવાબ આપવા માટે પિલોસાનો ઉપયોગ કરવાના ઉદાહરણ પર એક ઝડપી નજર નાખીએ.

ઉદાહરણ તમે પહેલા જે જોયું તેના જેવું જ છે. અમે પિલોસા સર્વર પર એક ક્લાયંટ બનાવીએ છીએ, ઇન્ડેક્સ અને જરૂરી ફીલ્ડ્સ બનાવીએ છીએ, પછી અમારા ફીલ્ડ્સને સંભાવનાઓ સાથે રેન્ડમ ડેટાથી ભરીએ છીએ અને અંતે, પરિચિત ક્વેરીનો અમલ કરીએ છીએ.

તે પછી, અમે "મોંઘા" ફીલ્ડ પર NOT નો ઉપયોગ કરીએ છીએ, પછી પરિણામ (અથવા અને તેને) "ટેરેસ" ફીલ્ડ અને "રિઝર્વેશન" ફીલ્ડ સાથે છેદે છે. અને અંતે, અમને અંતિમ પરિણામ મળે છે.

હું ખરેખર આશા રાખું છું કે નજીકના ભવિષ્યમાં આ નવા પ્રકારનો ઇન્ડેક્સ MySQL અને PostgreSQL - bitmap ઇન્ડેક્સ જેવા DBMSs માં પણ દેખાશે.

નિષ્કર્ષ

જો તમે હજી ઊંઘી નથી, તો આભાર. મર્યાદિત સમયને કારણે મારે ઘણા વિષયો પર સંક્ષિપ્તમાં સ્પર્શ કરવો પડ્યો, પરંતુ હું આશા રાખું છું કે ચર્ચા ઉપયોગી અને કદાચ પ્રેરક પણ હતી.

બીટમેપ અનુક્રમણિકાઓ વિશે જાણવું સારું છે, ભલે તમને અત્યારે તેમની જરૂર ન હોય. તેમને તમારા ટૂલબોક્સમાં અન્ય સાધન બનવા દો.

અમે ગો માટે વિવિધ પર્ફોર્મન્સ યુક્તિઓ જોઈ છે અને ગો કમ્પાઈલર હજુ સુધી સારી રીતે હેન્ડલ કરતું નથી. પરંતુ દરેક ગો પ્રોગ્રામરને જાણવા માટે આ એકદમ ઉપયોગી છે.

આટલું જ હું તમને કહેવા માંગતો હતો. આભાર!

સોર્સ: www.habr.com