String 字符串反转的奇怪执行时间

String 字符串反转的奇怪执行时间,string,assembly,x86,timing,String,Assembly,X86,Timing,上周我读了一些关于字符串的评论 反转程序。 我决定亲自测试一下,结果发现了一个明显的反常现象。 由于某些原因,第二个例程的执行情况因时间而异 字符串的长度是否小于128字节 UsingXchg UsingMov UsingBswap add eax, ebx add eax, ebx mov edx, eax jmp B jmp B

上周我读了一些关于字符串的评论 反转程序。 我决定亲自测试一下,结果发现了一个明显的反常现象。 由于某些原因,第二个例程的执行情况因时间而异 字符串的长度是否小于128字节

   UsingXchg              UsingMov              UsingBswap

   add   eax, ebx         add   eax, ebx        mov   edx, eax
   jmp   B                jmp   B               add   eax, ebx
A: mov   dl, [ebx]     A: mov   dl, [ebx]       jmp   B
   xchg  dl, [eax]        mov   cl, [eax]    A: sub   eax, 4
   mov   [ebx], dl        mov   [eax], dl       mov   esi, [ebx]
   inc   ebx              mov   [ebx], cl       mov   edi, [eax]
B: dec   eax              inc   ebx             bswap esi
   cmp   ebx, eax      B: dec   eax             bswap edi
   jb    A                cmp   ebx, eax        mov   [eax], esi
                          jb    A               mov   [ebx], edi
                                                add   ebx, 4
                                             B: sub   edx, 8
                                                jnb   A
                                                jmp   D
   On entry: EBX is address                  C: mov   dl, [ebx]
             EAX is length                      mov   cl, [eax]
                                                mov   [eax], dl
                                                mov   [ebx], cl
                                                inc   ebx
                                             D: dec   eax
                                                cmp   ebx, eax
                                                jb    C
接下来是我测量的大量重复次数(以毫秒为单位)

StringSize     UsingXchg   UsingMov    UsingBswap

   26             30.7        17.4         6.4
   52             60.9        33.4        12.2
   78             90.5        49.4        17.9
  104            121.9        65.4        22.7
                            /------\
  127                       | 79.0 |
  128                       | 27.3 |
                            \------/
  130            152.1        27.6        27.9
  156            181.9        30.7        33.5
  182            211.8        34.4        39.2
  208            241.8        37.2        44.0

  260            301.6        43.6        54.9
 2600           2996.5       337.2       538.4
26000          29949.2      3226.5      5350.4
  • 使用XCHG和BSWAP都显示出规律性,但使用MOV则清晰可见 在128字节标记处换档。 我怀疑缓存是这个小问题的核心,但为什么不呢 所有3个例程都显示相同的效果

  • 我想得出结论,最好的字符串反转例程是使用BSWAP 如果字符串超过127字节,则使用旁路。
    这是一个有效的结论吗

   mov   edx, eax  ;Remaining string length
   add   eax, ebx  ;Turn EAX into a pointer
   cmp   edx, 127
   ja    D         ;Don't use Bswap on long strings
   jmp   B
A: sub   eax, 4
   ...
D: dec   eax
   cmp   ebx, eax
   jb    C         ;Still 2 bytes left