x86-64 मशीन कोड (लिनक्स सिस्टम कॉल): 78 बाइट्स
आरडीटीसीएस स्पिन-लूप टाइमिंग, लिनक्स sys_writeसिस्टम कॉल।
x86-64 रन टाइम पर आरडीसीएस "रेफरेंस क्लॉक" फ्रीक्वेंसी को क्वेरी करने का एक सुविधाजनक तरीका प्रदान नहीं करता है। आप एक एमएसआर पढ़ सकते हैं (और उस पर आधारित गणना कर सकते हैं) , लेकिन इसके लिए कर्नेल मोड, या रूट + ओपनिंग की आवश्यकता होती है /dev/cpu/%d/msr, इसलिए मैंने आवृत्ति को बिल्ड-टाइम स्थिर बनाने का निर्णय लिया। ( FREQ_RDTSCआवश्यक रूप से समायोजित करें : कोई भी 32-बिट स्थिरांक मशीन कोड के आकार को नहीं बदलेगा)
ध्यान दें कि कई वर्षों के लिए x86 सीपीयू ने आरडीटीसीटी आवृत्ति को निर्धारित किया है इसलिए यह एक टाइमसोर्स के रूप में उपयोग करने योग्य है, न कि एक कोर घड़ी चक्र प्रदर्शन काउंटर जब तक आप आवृत्ति परिवर्तनों को अक्षम करने के लिए कदम नहीं उठाते हैं। (वास्तविक सीपीयू चक्रों की गिनती के लिए वास्तविक पूर्ण काउंटर हैं।) आमतौर पर यह नाममात्र स्टिकर आवृत्ति पर टिक करता है, जैसे कि टर्बो या पावरस्वाइनिंग की परवाह किए बिना मेरे i7-6700k के लिए 4.0GHz। वैसे भी, यह व्यस्त-प्रतीक्षा समय लोड औसत (एक कैलिब्रेटेड देरी-लूप की तरह) पर निर्भर नहीं करता है, और सीपीयू बिजली की बचत के लिए भी संवेदनशील नहीं है।
यह कोड किसी भी x86 के लिए 2 ^ 32 हर्ट्ज से नीचे के संदर्भ आवृत्ति के साथ काम करेगा, यानी ~ 4.29 गीगाहर्ट्ज़ तक। इसके अलावा, टाइमस्टैम्प का कम 32 1 सेकंड में सभी तरह से लपेट जाएगा, इसलिए मुझे edxपरिणाम के उच्च 32 बिट्स पर भी ध्यान देना होगा।
सारांश :
00:00:00\nस्टैक पर धक्का । फिर एक पाश में:
sys_write सिस्टम कॉल- एडीसी-लूप अंकों पर (आखिरी के साथ शुरू) समय को बढ़ाने के लिए 1. रैपिंग / कैरी-आउट एक
cmp/ के साथ संभाला cmov, सीएफ परिणाम के साथ अगले अंक के लिए ले-इन प्रदान करते हैं।
rdtsc और शुरू समय बचाने के लिए।rdtscजब तक डेल्टा है पर स्पिन > आरडीटीसीटी आवृत्ति के प्रति सेकंड टिक्स।
NASM लिस्टिंग:
1 Address ; mov %1, %2 ; use this macro to copy 64-bit registers in 2 bytes (no REX prefix)
2 Machine code %macro MOVE 2
3 bytes push %2
4 pop %1
5 %endmacro
6
7 ; frequency as a build-time constant because there's no easy way detect it without root + system calls, or kernel mode.
8 FREQ_RDTSC equ 4000000000
9 global _start
10 _start:
11 00000000 6A0A push 0xa ; newline
12 00000002 48BB30303A30303A3030 mov rbx, "00:00:00"
13 0000000C 53 push rbx
14 ; rsp points to `00:00:00\n`
20
21 ; rbp = 0 (Linux process startup. push imm8 / pop is as short as LEA for small constants)
22 ; low byte of rbx = '0'
23 .print:
24 ; edx potentially holds garbage (from rdtsc)
25
26 0000000D 8D4501 lea eax, [rbp+1] ; __NR_write = 1
27 00000010 89C7 mov edi, eax ; fd = 1 = stdout
28 MOVE rsi, rsp
28 00000012 54 <1> push %2
28 00000013 5E <1> pop %1
29 00000014 8D5008 lea edx, [rax-1 + 9] ; len = 9 bytes.
30 00000017 0F05 syscall ; sys_write(1, buf, 9)
31
32 ;; increment counter string: least-significant digits are at high addresses (in printing order)
33 00000019 FD std ; so loop backwards from the end, wrapping each digit manually
34 0000001A 488D7E07 lea rdi, [rsi+7]
35 MOVE rsi, rdi
35 0000001E 57 <1> push %2
35 0000001F 5E <1> pop %1
36
37 ;; edx=9 from the system call
38 00000020 83C2FA add edx, -9 + 3 ; edx=3 and set CF (so the low digit of seconds will be incremented by the carry-in)
39 ;stc
40 .string_increment_60: ; do {
41 00000023 66B93902 mov cx, 0x0200 + '9' ; saves 1 byte vs. ecx.
42 ; cl = '9' = wrap limit for manual carry of low digit. ch = 2 = digit counter
43 .digitpair:
44 00000027 AC lodsb
45 00000028 1400 adc al, 0 ; carry-in = cmp from previous iteration; other instructions preserve CF
46 0000002A 38C1 cmp cl, al ; manual carry-out + wrapping at '9' or '5'
47 0000002C 0F42C3 cmovc eax, ebx ; bl = '0'. 1B shorter than JNC over a MOV al, '0'
48 0000002F AA stosb
49
50 00000030 8D49FC lea ecx, [rcx-4] ; '9' -> '5' for the tens digit, so we wrap at 59
51 00000033 FECD dec ch
52 00000035 75F0 jnz .digitpair
53 ; hours wrap from 59 to 00, so the max count is 59:59:59
54
55 00000037 AC lodsb ; skip the ":" separator
56 00000038 AA stosb ; and increment rdi by storing the byte back again. scasb would clobber CF
57
58 00000039 FFCA dec edx
59 0000003B 75E6 jnz .string_increment_60
60
61 ; busy-wait for 1 second. Note that time spent printing isn't counted, so error accumulates with a bias in one direction
62 0000003D 0F31 rdtsc ; looking only at the 32-bit low halves works as long as RDTSC freq < 2^32 = ~4.29GHz
63 0000003F 89C1 mov ecx, eax ; ecx = start
64 .spinwait:
65 ; pause
66 00000041 0F31 rdtsc ; edx:eax = reference cycles since boot
67 00000043 29C8 sub eax, ecx ; delta = now - start. This may wrap, but now we have the delta ready for a normal compare
68 00000045 3D00286BEE cmp eax, FREQ_RDTSC ; } while(delta < counts_per_second)
69 ; cmp eax, 40 ; fast count to test printing
70 0000004A 72F5 jb .spinwait
71
72 0000004C EBBF jmp .print
next address = 0x4E = size = 78 bytes.
pauseमहत्वपूर्ण शक्ति को बचाने के लिए निर्देश को रद्द करें : यह एक कोर को ~ 15 डिग्री सेल्सियस के बिना गर्म करता है pause, लेकिन केवल ~ 9 के साथ pause। (स्काइलेक पर, जहां pause~ 5 के बजाय ~ 100 चक्रों के लिए नींद आती है । मुझे लगता है कि यह अधिक बचत करेगा यदि rdtscधीमी-ईश भी नहीं था इसलिए सीपीयू बहुत अधिक समय नहीं कर रहा है)।
एक 32-बिट संस्करण कुछ बाइट्स छोटा होगा, उदाहरण के लिए प्रारंभिक 00: 00: 00 \ n स्ट्रिंग को पुश करने के लिए 32-बिट संस्करण का उपयोग करना।
16 ; mov ebx, "00:0"
17 ; push rbx
18 ; bswap ebx
19 ; mov dword [rsp+4], ebx ; in 32-bit mode, mov-imm / push / bswap / push would be 9 bytes vs. 11
और 1-बाइट का उपयोग करके भी dec edx। int 0x80सिस्टम कॉल ABI का उपयोग नहीं होता ईएसआई / ईडीआई, तो syscall बनाम lodsb / stosb के लिए रजिस्टर सेटअप सरल हो सकता है।
