C / C +: ये कपटी स्ट्रिंग सेट हैं।

कई "जानते हैं" कि सी / सी ++ में प्रोग्रामिंग आपको ऐसे प्रोग्राम प्राप्त करने की अनुमति देता है जो लगभग असेंबलर में लिखे गए कार्यक्रमों के रूप में तेजी से काम करते हैं, और यहां तक ​​कि वे, जो सिद्धांत रूप में संभव के रूप में तेज़ हैं।



वास्तव में, निश्चित रूप से, यह पूरी तरह से सच नहीं है (और दुर्लभ मामलों में, यह बिल्कुल भी ऐसा नहीं है), लेकिन सामान्य तौर पर, C / C ++ प्रोग्राम वास्तव में तेज़ हैं, थोड़ी मेमोरी की आवश्यकता होती है और तुरंत चलाते हैं। यदि आप उन्हें सही तरीके से लिखते हैं।



इस बारे में कि C / C ++ में कैसे लिखना है, और मैं थोड़ी बात करना चाहूंगा। आज मैं रसेट के मुद्दे पर चर्चा करना चाहता हूं। यही है, प्रक्रियाओं के बारे में जो आपको एक संख्या से एक स्ट्रिंग प्राप्त करने की अनुमति देते हैं, और एक स्ट्रिंग से एक संख्या।



ऐसी सूचियाँ कहाँ होती हैं? ठीक है, उदाहरण के लिए, ये HTML टोकन की सूची हो सकती है जो आपके प्रोग्राम के साथ काम करती है। या आपके शेल को स्वीकार करने वाले आदेशों की एक सूची। लेकिन, निश्चित रूप से, अक्सर ऐसे सेट सभी प्रकार की त्रुटियों की सूची के रूप में दिखाई देते हैं: स्ट्ररोर, गैस्ट्रॉस्टर, रेगुलेटर्स, आदि। मुझे लगता है कि प्रत्येक प्रोग्रामर को कम से कम एक बार इसी तरह की समस्या का सामना करना पड़ा है।



मैं एक आरक्षण बनाना चाहता हूं कि निम्नलिखित विवरण केवल ऑपरेटिंग सिस्टम पर लागू होता है जो कि एलएलएफ प्रारूप: लिनक्स, मैकओएस इत्यादि का उपयोग करता है। विंडोज या एम्बेडेड सिस्टम पर, स्थिति थोड़ी अलग हो सकती है। साथ ही, इस बार मैं खुद को केवल एक सीधी समस्या (संख्या द्वारा एक स्ट्रिंग प्राप्त करने के लिए) में सीमित कर दूंगा क्योंकि यह है, सबसे पहले, सरल, और दूसरी बात, उलटा समस्या के कई समाधानों में समाधान के हिस्से के रूप में एक सीधी समस्या है।



तो, चलो कार्य सेट करें। हम एक गलत कार्य करना चाहते हैं जो त्रुटि संख्या द्वारा एक स्ट्रिंग लौटाता है। मैं एक समान फ़ंक्शन कैसे लिख सकता हूं?



उदाहरण के लिए, माथे में:



const char * इरेटा ( int nr ) {

स्विच ( एनआर ) {

मामला 0 : रिटर्न "X00000X" ;

केस 1 : रिटर्न "X00001X" ;

...

मामला 9999 : रिटर्न "X09999X" ;

डिफ़ॉल्ट : "अज्ञात त्रुटि" लौटाएं ;

}

}



क्या यह विकल्प काम करता है? यह है। लेकिन इसके लिए कितने संसाधनों की आवश्यकता है? आइए देखें:

$ gcc -march = देशी -fPIC -O2 -sared -o libgen1.so gen1.c

$ स्ट्रिप --स्ट्रिप-अनएडेड लिबजेन 1। एसो

$ आकार libgen1.so

टेक्स्ट	डेटा	बीएसएस	दिसम्बर	हेक्स	फ़ाइल नाम
201,116	272	28	201,416	312c8	libgen1.so

हमने प्रति पंक्ति 20 बाइट्स खर्च किए। इस तथ्य के बावजूद कि स्ट्रिंग स्वयं 8 बाइट्स लेती है। क्या बेहतर करना संभव है? मम्म ... हाँ, बिल्कुल! यह एक सरणी के रूप में लाइनों की एक सूची बनाने और तत्वों को निकालने के लिए एक सरल कार्य करने के लिए पर्याप्त है। सरणी में पॉइंटर्स प्रत्येक पर 4 बाइट्स पर कब्जा कर लेंगे और प्रति पंक्ति 20 बाइट्स के बजाय हम केवल 12 प्राप्त करेंगे - 40% की बचत! खेल निश्चित रूप से मोमबत्ती के लायक है।



जल्द से जल्द नहीं कहा:



स्थिर कास्ट चार * कास्ट संदेश [ ] = {

[ ० ] = "X00000X" ,

[ १ ] = "X00001X" ,

...

[ 9999 ] = "X09999X" ,

} ;



const char * इरेटा ( int nr ) {

if ( nr < 0 || nr> sizeof ( msgs ) / sizeof ( msgs [ 0 ] ) )

वापसी "अज्ञात त्रुटि" ;

वापसी संदेश [ एनआर ] ;

}



$ gcc -march = देशी -fPIC -O2 -sared -o libgen2.so gen2.c

$ स्ट्रिप --स्ट्रिप-अनएडेड लिबजेन 2। एसो

$ आकार libgen2.so

टेक्स्ट	डेटा	बीएसएस	दिसम्बर	हेक्स	फ़ाइल नाम
161,110	40272	28	201,410	312c2	libgen2.so

एक भव्य उपलब्धि! 6 बाइट्स बचाएं? क्या हुआ? तालिका में 80'000 बाइट्स हैं (इसे संशोधित नहीं किया जा सकता है ताकि इसे पाठ के रूप में संरक्षित किया जा सके), लेकिन हमें टेक्स्ट की ~ 80'000 अधिक बाइट्स कहां मिलीं (हम 40'000 बाइट्स की उम्मीद कर रहे थे) और ~ 40'000 बाइट्स का डेटा (और वे बिल्कुल मौजूद नहीं होना चाहिए - क्या हमारे पास सभी टेबल स्थिर हैं?)। चलिए इसका पता लगाते हैं:

$ relinfo libgen2.so

libgen2.so: 10007 स्थानांतरण, 10002 रिश्तेदार (99%), 3 पीएलटी प्रविष्टियां, स्थानीय जिम के लिए 0 (0%), 0 उपयोगकर्ता

हाँ। अब यह स्पष्ट है! कंपाइलर इस तालिका की गणना नहीं कर सकता है और इसे लाइब्रेरी को लिख सकता है: इसके लिए आपको उस पते का पता होना चाहिए जिस पर लाइब्रेरी को रनटाइम में मेमोरी में रखा जाएगा - और यह जानकारी उसे ज्ञात नहीं है। इसके अलावा: एक नियम के रूप में, यह जानकारी लिंकर के लिए भी अज्ञात है - इसलिए, यह पाठ खंड में नहीं, बल्कि डेटा खंड में एक तालिका बनाता है और एक और तालिका बनाता है - पहले से ही गतिशील लिंकर के लिए। जो कार्यक्रम शुरू करने के समय इसे भरता है। हम्म ... और यह सब - तालिका के लिए, जो, सबसे अधिक संभावना है, इसका उपयोग बिल्कुल नहीं किया जाएगा! कौन तुरंत कार्यक्रमों को शुरू करने के बारे में बात कर रहा था?



क्या करें? जाहिर है, टेबल को पुनर्गठित करना अच्छा होगा ताकि गणना गतिशील लिंकर द्वारा हर बार कार्यक्रम शुरू होने पर नहीं, बल्कि हमारे कार्यक्रम द्वारा की जाए - और केवल जहां उन्हें जरूरत हो। यह कैसे करना है? अकेले हम इस समस्या का सामना नहीं कर रहे हैं? यह कैसे किया जाता है, कहते हैं, glibc में? और इसलिए : सभी लाइनों को एक अलग फ़ाइल में निकाला जाता है, जिसका उपयोग मुख्य कार्यक्रम द्वारा किया जाता है।

फ़ाइल stringtab.h में निम्नलिखित शामिल हैं:

_S ( 0 , "X00000X" )

_S ( 1 , "X00001X" )

...

_S ( 9999 , "X09999X" )

और कार्यक्रम यह है:

# अलग करें <stddef.h>



#define MSGSTRFIELD (लाइन) MSGSTRFIELD1 (लाइन)

#define MSGSTRFIELD1 (लाइन) str ## लाइन

स्थिर कास्ट संघ।

संरचना {

#define _S (n, s) चार MSGSTRFIELD (__ लाइन __) [sizeof (s)];

# जारी करें "stringtab.h"

#undef _S

} ;

char str [को ० ] ;

}} = { {

#define _S (n, s) s,

# जारी करें "stringtab.h"

#undef _S

} } ;

स्थिर कॉन्स्टेबल अहस्ताक्षरित int .x [ ] = {

#define _S (n, s) ऑफसेटऑफ़ (Union/2017_t, MSGSTRFIELD (__ LINE__)),

# जारी करें "stringtab.h"

#undef _S

} ;

const char * इरेटा ( int nr ) {

if ( nr < 0 || nr> sizeof ( /2017x ) / sizeof ( msgstr " [ 0 ] ) )

वापसी "अज्ञात त्रुटि" ;

वापसी //.str + msgstrx [ nr ] ;

}

$ gcc -march = देशी -fPIC -O2 -sared -o libgen3.so gen3.c

$ स्ट्रिप --स्ट्रिप-अनएडेड लिबजेन 3। एसो

$ आकार libgen3.so

टेक्स्ट	डेटा	बीएसएस	दिसम्बर	हेक्स	फ़ाइल नाम
121,136	272	28	121,436	1da5c	libgen3.so

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



इन उद्देश्यों के लिए, मैंने एक छोटा सा कार्यक्रम लिखा और जीसीसी 4.2.2 का उपयोग करते हुए, तीन प्रणालियों पर इसके व्यवहार की जांच की: एएमडी ओपर्टन (टीएम) प्रोसेसर 175 के साथ, इंटेल कोर (टीएम) 2 सीपीयू 6600 और इंटेल पेंटियम डी सीपीयू 3.00GHz के साथ।



#define _GNU_SOURCE

# जारी <शेड्यूल>

# अलग करें <stdio.h>

# जीत "gen.h"



#define NUMTESTS 1000

#define NUMSTRINGS 10000



#ifdef __i386__

स्थिर इनलाइन अहस्ताक्षरित लंबे लंबे read_tsc ( शून्य )

{

अहस्ताक्षरित लंबी लंबी घाटी;

__asm__ __volatile__ ( "rdtsc" : "= A" ( val ) ) ;

वापसी घाटी;

}

#endif



#ifdef __x86_64__

स्थिर इनलाइन अहस्ताक्षरित लंबे लंबे read_tsc ( शून्य )

{

अहस्ताक्षरित int __a, __d;

__asm__ __volatile__ ( "rdtsc" : "= a" ( __a ) , "= d" ( __d ) ) ;

वापसी ( ( लंबे समय तक ) __a ) | ( ( अहस्ताक्षरित लंबा ) __d ) << 32 ) ;

}

#endif



int main ( )

{

cpu_set_t आत्मीयता;

CPU_ZERO ( & संबंध ) ;

CPU_SET ( 1 , और आत्मीयता ) ;

शेड्यूल_सेटफ़िनिटी ( 0 , साइज़ोफ़ ( cpu_set_t ) , और आत्मीयता ) ;

अहस्ताक्षरित लंबे लंबे परीक्षण [ NUMTESTS ] ;

for ( int i = 0 ; मैं <NUMTESTS; ++ i ) {

अहस्ताक्षरित लंबी लंबी शुरुआत = read_tsc ( ) ;

for ( int i = 0 ; मैं <NUMSTRINGS; ++ i ) {

// कुछ न करें - ओवरहेड को मापें

}

testresults [ i ] = read_tsc ( ) - प्रारंभ;

}

अहस्ताक्षरित लंबे लंबे ओवरहेड = वृषण [ 0 ] ;

for ( int i = 1 ; मैं <NUMTESTS; ++ i ) {

अगर ( वृषण [ i ] <ओवरहेड )

ओवरहेड = वृषण [ i ] ;

}

for ( int i = 0 ; मैं <NUMTESTS; ++ i ) {

अहस्ताक्षरित लंबी लंबी शुरुआत = read_tsc ( ) ;

for ( int i = 0 ; मैं <NUMSTRINGS; ++ i ) {

असत्य ( i ) ;

}

testresults [ i ] = read_tsc ( ) - प्रारंभ;

}

अहस्ताक्षरित लंबे लंबे वृषण = वृषण [को ० ] ;

for ( int i = 1 ; मैं <NUMTESTS; ++ i ) {

अगर ( वृषण [ i ] <वृषण )

testrun = testresults [ i ] ;

}

printf ( "असत्य% g सीपीयू चक्र प्रति कॉल \ n लेता है" ,)

( वृषण - उपरि ) / ( NUMSTRINGS * 1.0 ) ) ;

वापसी 0 ;

}

$ gcc -march = देशी -O2 -std = c99 -o main1 main.c -L। -lgen1

$ gcc -march = मूल -O2 -std = c99 -o main2 main.c -L। -lgen2

$ gcc -march = देशी -O2 -std = c99 -o main3 main.c -L। -lgen3

$ LD_LIBRARY_PATH =। ./main1

असत्य 44.748 सीपीयू चक्र प्रति कॉल लेता है

$ LD_LIBRARY_PATH =। ./main2

प्रति कॉल 12.9996 सीपीयू चक्र लेता है

$ LD_LIBRARY_PATH =। ./main3

असत्य 13 सीपीयू चक्र प्रति कॉल लेता है

	विकल्प 1	विकल्प 2	विकल्प 3
AMD Opteron (32 बिट):	28.13 सीपीयू चक्र	15 सीपीयू साइकिल	16 सीपीयू सीपीयू चक्र
AMD Opteron (64 बिट):	30.83 सीपीयू चक्र	10 सीपीयू साइकिल	11 सीपीयू सीपीयू चक्र
इंटेल कोर 2 (32 बिट):	44.67 सीपीयू साइकिल	13 सीपीयू साइकिल	13 सीपीयू सीपीयू चक्र
इंटेल कोर 2 (64 बिट):	39.37 सीपीयू चक्र	9 सीपीयू साइकिल	10 सीपीयू सीपीयू चक्र
इंटेल पेंटियम डी (32 बिट):	111.34 सीपीयू साइकिल	26 सीपीयू साइकिल	26 सीपीयू सीपीयू चक्र
इंटेल पेंटियम डी (64 बिट):	99.05 सीपीयू साइकिल	16 सीपीयू साइकिल	14 सीपीयू सीपीयू चक्र

परिणाम खुद के लिए बोलते हैं: सूची में से एक विकल्प के साथ विकल्प शाखा भविष्यवक्ता के साथ संघर्ष करता है और इसलिए बहुत धीमी गति से काम करता है, "मानक" विकल्प, एक नियम के रूप में, सबसे तेज़ है, लेकिन "किफायती" संस्करण आधे मामलों में पीछे नहीं रहता है, और वहाँ जहां यह पिछड़ जाता है, यह प्रोसेसर का केवल एक घड़ी चक्र खो देता है, इसलिए यदि आपको इस फ़ंक्शन की आवश्यकता नहीं है, तो सबसे "आंतरिक" चक्र है, तो यह हो सकता है (और अगर बहुत सारी लाइनें हैं, तो आपको इसकी सिफारिश करने की आवश्यकता है)। यह दिलचस्प है, वैसे, विकल्पों में से एक में (इंटेल पेंटियम डी 64 बिट) "किफायती" विकल्प तेज है - जो इस तथ्य के कारण सबसे अधिक संभावना है कि इसके लिए आधी मेमोरी की आवश्यकता होती है और कैश तक पहुंच की गति अंतहीन है ...