कौन तेज है: मेमसेट, बेज़ेरो या एसटीडी :: फिल

यह माना जाता है कि std :: fill () एल्गोरिथ्म सरल पुराने प्रकारों के रूप में कुशलतापूर्वक काम करता है जैसे कि अच्छा पुराना मेमसेट () (चूंकि यह कुछ विशेषताओं में इसका उपयोग करता है)।

लेकिन कभी-कभी सब कुछ उतना पारदर्शी नहीं होता जितना हम चाहेंगे। कार्यक्रम पर विचार करें।

#include <cstdlib> #include <algorithm> int main(int argc, char* argv[]) { int mode = argc > 1 ? std::atoi(argv[1]) : 1; int n = 1024 * 1024 * 1024 * 1; char* buf = new char[n]; if (mode == 1) std::memset(buf, 0, n * sizeof(*buf)); else if (mode == 2) bzero(buf, n * sizeof(*buf)); else if (mode == 3) std::fill(buf, buf + n, 0); else if (mode == 4) std::fill(buf, buf + n, '\0'); return buf[0]; } 

शाखाओं 3 और 4 पर ध्यान दें। वे लगभग समान हैं, लेकिन काफी नहीं।

सामान्य तौर पर, भरने की इस विशेषज्ञता को प्राप्त करने के लिए एक विचार था:

 // Specialization: for one-byte types we can use memset. inline void fill(unsigned char* __first, unsigned char* __last, const unsigned char& __c) { __glibcxx_requires_valid_range(__first, __last); const unsigned char __tmp = __c; std::memset(__first, __tmp, __last - __first); } 

तो मेकफाइल:

 all: build run .SILENT: target = memset_bzero_fill build: g++ -O3 -o $(target) $(target).cpp run: run-memset run-bzero run-fill-1 run-fill-2 go: (time -p ./$(target) $(mode)) 2>&1 | head -1 | cut -d' ' -f 2 run-memset: echo $@ `$(MAKE) go mode=1` run-bzero: echo $@ `$(MAKE) go mode=2` run-fill-1: echo $@ `$(MAKE) go mode=3` run-fill-2: echo $@ `$(MAKE) go mode=4` 

कंपाइलर "gcc संस्करण 4.2.1 (Apple Inc. build 5666) (dot 3)।"

हम लॉन्च करते हैं:

  run-memset 1.47 run-bzero 1.45 run-fill-1 1.69 run-fill-2 1.42 

यह देखा जा सकता है कि कैसे शाखा 3 (रन-फिल -1) 4 की तुलना में काफी धीमा हो जाती है, हालांकि अंतिम पैरामीटर के प्रकार में अंतर केवल 0 और '\ 0' है।

हम कोडांतरक को देखते हैं:

 (gdb) disass main Dump of assembler code for function main: 0x0000000100000e70 <main+0>: push %rbp 0x0000000100000e71 <main+1>: mov %rsp,%rbp 0x0000000100000e74 <main+4>: push %r12 0x0000000100000e76 <main+6>: push %rbx 0x0000000100000e77 <main+7>: dec %edi 0x0000000100000e79 <main+9>: jle 0x100000ec3 <main+83> 0x0000000100000e7b <main+11>: mov 0x8(%rsi),%rdi 0x0000000100000e7f <main+15>: callq 0x100000efe <dyld_stub_atoi> 0x0000000100000e84 <main+20>: mov %eax,%r12d 0x0000000100000e87 <main+23>: mov $0x40000000,%edi 0x0000000100000e8c <main+28>: callq 0x100000ef8 <dyld_stub__Znam> 0x0000000100000e91 <main+33>: mov %rax,%rbx 0x0000000100000e94 <main+36>: cmp $0x1,%r12d 0x0000000100000e98 <main+40>: je 0x100000eac <main+60> ; mode == 1 0x0000000100000e9a <main+42>: cmp $0x2,%r12d 0x0000000100000e9e <main+46>: je 0x100000eac <main+60> ; mode == 2 0x0000000100000ea0 <main+48>: cmp $0x3,%r12d 0x0000000100000ea4 <main+52>: je 0x100000ed2 <main+98> ; mode == 3 0x0000000100000ea6 <main+54>: cmp $0x4,%r12d 0x0000000100000eaa <main+58>: jne 0x100000ebb <main+75> ; mode != 4 ->  ;   memset(). 0x0000000100000eac <main+60>: mov $0x40000000,%edx ; mode = 1, 2  4 0x0000000100000eb1 <main+65>: xor %esi,%esi 0x0000000100000eb3 <main+67>: mov %rbx,%rdi 0x0000000100000eb6 <main+70>: callq 0x100000f0a <dyld_stub_memset> 0x0000000100000ebb <main+75>: movsbl (%rbx),%eax ;  0x0000000100000ebe <main+78>: pop %rbx 0x0000000100000ebf <main+79>: pop %r12 0x0000000100000ec1 <main+81>: leaveq 0x0000000100000ec2 <main+82>: retq 0x0000000100000ec3 <main+83>: mov $0x40000000,%edi 0x0000000100000ec8 <main+88>: callq 0x100000ef8 <dyld_stub__Znam> 0x0000000100000ecd <main+93>: mov %rax,%rbx 0x0000000100000ed0 <main+96>: jmp 0x100000eac <main+60> ;    . 0x0000000100000ed2 <main+98>: movb $0x0,(%rax) ; mode = 3 0x0000000100000ed5 <main+101>: mov $0x1,%eax 0x0000000100000eda <main+106>: nopw 0x0(%rax,%rax,1) 0x0000000100000ee0 <main+112>: movb $0x0,(%rax,%rbx,1) 0x0000000100000ee4 <main+116>: inc %rax 0x0000000100000ee7 <main+119>: cmp $0x40000000,%rax 0x0000000100000eed <main+125>: jne 0x100000ee0 <main+112> 0x0000000100000eef <main+127>: movsbl (%rbx),%eax ;  0x0000000100000ef2 <main+130>: pop %rbx 0x0000000100000ef3 <main+131>: pop %r12 0x0000000100000ef5 <main+133>: leaveq 0x0000000100000ef6 <main+134>: retq 

यह देखा जा सकता है कि अनुकूलन के माध्यम से, शाखाओं 1, 2 और 4 को उसी तरह से लागू किया जाता है - मेमसेट () के माध्यम से। शाखा 4 में भरा () कॉल को कम करने के लिए () किया गया था।

लेकिन शाखा 3 को एक मैनुअल चक्र के रूप में लागू किया गया है। संकलक, निश्चित रूप से, एक अच्छा काम किया - चक्र लगभग सही है, लेकिन यह अभी भी चालाक मेमसेट () की तुलना में धीमी गति से काम करता है, जो समूह कोडांतरक संचालन के सभी प्रकार के चाल का उपयोग करता है।

एक गलत प्रकार के शून्य ने कंपाइलर को टेम्पलेट विशेषज्ञता को सही ढंग से चुनने से रोक दिया।

नैतिक? और यहाँ नैतिक बहुत अच्छा नहीं है।

मुझे ऐसा लगता है कि "std :: fill (buf, buf + n, 0)" लिखने वाले लोगों की संख्या "std :: fill (buf, buf + n, '\ 0') की तुलना में बहुत अधिक है।"

और अंतर बहुत महत्वपूर्ण है।