पर्ल में असाइनमेंट के तरीकों की तुलना

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



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



मान लीजिए कि हमारे पास $hash



- कई क्षेत्रों के साथ एक $hash



लिंक है, और हम उनमें से तीन को अपडेट करना चाहते हैं। इसे लिखने का एक सामान्य तरीका:

  <फ़ॉन्ट रंग = "ग्रे"> $ हैश -> {foo} = 456;
 $ हैश -> {बार} = $ बार;
 $ हैश -> {बाज} = 'बाज';

 </ Font> 

आप हैश स्लाइस का उपयोग कर सकते हैं - और तीन स्केलर असाइनमेंट ऑपरेटरों के बजाय, एक सूची असाइनमेंट ऑपरेटर के साथ एक ही प्रभाव प्राप्त करें:

  <फ़ॉन्ट रंग = "ग्रे"> @ $ हैश {qw (फू बार बाज)) = (456, $ बार, 'बाज');

 </ Font> 

आप बस हैश असाइन कर सकते हैं ( %$hash



अंदर निर्दिष्ट करके ताकि अन्य फ़ील्ड सहेजे जाएं):

  <फ़ॉन्ट रंग = "ग्रे">% $ हैश = (% $ हैश, फू => 456, बार => $ बार, बाज => 'बाज');

 </ Font> 

अंत में, आप लूप का उपयोग कर सकते हैं (यह अक्सर सुविधाजनक होता है):

  <font color = "grey"> my% h = (foo => 456, bar => $ bar, baz => 'baz');
 $ हैश -> {$ _} = $ h {$ _} qw (फू बार बाज) के लिए;

 </ Font> 

या मानचित्र निर्माण के रूप में एक ही बात लिखें:

  <font color = "ग्रे"> नक्शा {$ हैश -> {$ _} = $ h {$ _}} qw (फू बार बाज);

 </ Font> 

आपको क्या लगता है सबसे तेज़ तरीका है? एक परीक्षण चलाएं जो हैश फ़ील्ड को अपडेट करने के विभिन्न तरीकों की निष्पादन गति की तुलना करता है:

  <फ़ॉन्ट रंग = "ग्रे"> #! / usr / बिन / पर्ल

 सख्त का उपयोग करें;
 बेंचमार्क qw (cmpthese) का उपयोग करें;

 मेरी $ हैश = {
	 foo => 'foo',
	 बार => 123,
	 बाज => अपराजित,
 };

 मेरे $ बार = 'बार';

 Cmpthese (
	 -10,
	 {
		 h_direct => उप {
			 $ हैश -> {foo} = 456;
			 $ हैश -> {बार} = $ बार;
			 $ हैश -> {बाज} = 'बाज';
		 }
		 h_list => उप {
			 @ $ हैश {qw (फू बार बाज)} = (456, $ बार, 'बाज');
		 }
		 h_hash => उप {
			 % $ हैश = (% $ हैश, फू => ४५६, बार => $ बार, बाज => 'बाज);
		 }
		 h_for => उप {
			 my% h = (foo => 456, bar => $ bar, baz => 'baz');
			 $ हैश -> {$ _} = $ h {$ _} qw (फू बार बाज) के लिए;
		 }
		 h_forref => उप {
			 my $ h = {foo => 456, bar => $ bar, baz => 'baz'};
			 $ हैश -> {$ _} = $ h -> {$ _} qw (फू बार बाज) के लिए;
		 }
		 h_map => उप {
			 my% h = (foo => 456, bar => $ bar, baz => 'baz');
			 नक्शा {$ हैश -> {$ _} = $ h {$ _}} qw (फू बार बाज);
		 }
		 h_mapref => उप {
			 my $ h = {foo => 456, bar => $ bar, baz => 'baz'};
			 नक्शा {$ हैश -> {$ _} = $ h -> {$ _}} qw (फू बार बाज);
		 }
	 });

 </ Font> 

यहाँ इसके परिणाम हैं:

               दर h_hash h_forref h_mapref h_for h_map h_list h_direct
 h_hash 100913 / s - -30% -42% -43% -53% -80% -91%
 h_forref 144297 / s 43% - -17% -19% -32% -71% -88%
 h_mapref 174524 / s 73% 21% - -2% -18% -65% -85%
 h_for 177449 ​​/ s 76% 23% 2% - -17% -65% -85%
 h_map 213368 / s 111% 48% 22% 20% - -58% -82%
 h_list 505768 / s 401% 251% 190% 185% 137% - -57%
 h_direct 1169409 / s 1059% 710% 570% 559% 448% 131% -

जैसा कि आप देख सकते हैं, सबसे तेज़ तरीका प्रत्यक्ष असाइनमेंट है। हैश स्लाइस दो बार धीमी गति से काम करता है, एक चक्र के साथ डिजाइन - एक और 2-3 बार धीमा। मैप लूप इसके लिए संबंधित की तुलना में थोड़ा तेज है।

हालांकि, डेटा न केवल हैश में संग्रहीत किया जा सकता है, बल्कि सरणियों में भी। एक सरणी के लिए एक समान परीक्षण समान परिणाम देता है:

  <फ़ॉन्ट रंग = "ग्रे"> #! / usr / बिन / पर्ल

 सख्त का उपयोग करें;
 बेंचमार्क qw (cmpthese) का उपयोग करें;

 मेरी $ सूची = ['फू', 123, अपवित्र];

 मेरे $ बार = 'बार';

 Cmpthese (
	 -10,
	 {
		 l_direct => उप {
			 $ सूची -> [0] = 456;
			 $ सूची -> [1] = $ बार;
			 $ सूची -> [2] = 'बाज';
		 }
		 l_list => उप {
			 @ $ सूची [0 .. 2] = (456, $ बार, 'बाज');
		 }
		 l_for => उप {
			 my @l = (456, $ बार, 'बाज');
			 $ सूची -> [$ _] = $ l [$ _] 0 .. 2 के लिए;
		 }
		 l_forref => उप {
			 मेरे $ l = [456, $ बार, 'बाज'];
			 $ सूची -> [$ _] = $ l -> [$ _] ० के लिए .. २;
		 }
		 l_map => उप {
			 my @l = (456, $ बार, 'बाज');
			 नक्शा {$ सूची -> [$ _] = $ l [$ _]} 0 .. 2;
		 }
		 l_mapref => उप {
			 मेरे $ l = [456, $ बार, 'बाज'];
			 नक्शा {$ सूची -> [$ _] = $ l -> [$ _]} 0 .. 2;
		 }
	 });

 </ Font> 

               दर l_forref l_for l_mapref l_map l_list l_direct
 l_forref 197498 / s - -11% -17% -38% -65% -86%
 l_for 222737 / s 13% - -6% -30% -60% -84%
 l_mapref 237429 / s 20% 7% - -25% -58% -83%
 l_map 318127 / s 61% 43% 34% - -43% -77%
 l_list 559192 / s 183% 151% 136% 76% - -60%
 l_direct 1395278 / s 606% 526% 488% 339% 150% -

तीन मशीनों (विंडोज एक्सपी के तहत डेस्कटॉप और फ्रीबीएसडी के तहत दो सर्वर) पर पर्ल 5.8.8 के लिए तुलना की गई थी। विशिष्ट संख्याएं बदलती हैं, लेकिन अनुपात हर जगह समान है।



PS <pre> में लिपटा कोड यहां किसी तरह बदसूरत दिखता है। क्या इसे प्रीतिकर बनाने का कोई तरीका है?