又求解释：

[iamnobody]

还是做了一个strlen()函数的测试：
my::strlen() PK std::strlen();
问题1：

我用内联汇编用scas指令写的函数用时竟然稳定地保持在std::strlen()“优化”板本的三倍，他的“优化”后的核心代码是：

01181040  mov         cl,byte ptr [eax]  
01181042  inc         eax  
01181043  test        cl,cl  
01181045  jne         main+40h (1181040h)  

然后我用内联汇编写：

size_t strlen(char* pch){

	char* pcrr;
	_asm{
		mov edi,pch
		xor ecx,ecx
		cld
		dec ecx
		xor eax,eax
		repne scasb
		mov pcrr,edi

	}
	return pcrr - pch;
}

优化后也差不多这个样。
为什么 scasb指针会这么慢，竟然比不上普通的mov 和 jne

问题2：std::strlen()的代码也有看过,在不release时比release时快，这个之前讨论过了。下面是根据类似原理写的strlen(),想不到在我的编译器上还是被优化成了这个鸟样：

size_t strlen(char* pch){

	char * pcrr = pch - 1;
	int x;
	do{
		pcrr++;
		if (((int)pcrr) & 3 == 0){
			do{
				pcrr += 4;
				x = *(int*)pcrr;
			}while(!((x - 0x01010101) & ~x & 0x80808080));
			pcrr -= 4;
		}
	}while(*pcrr != '\0');
	return pcrr - pch;
}

release后：

00121057  inc         esi  
00121058  cmp         byte ptr [esi],0  
0012105B  jne         main+57h (121057h) 

问题2：怎么控制编译器的这种低效的优化？我记得以前它还会按照我写法四个字节比较的。以前优化后是这样的：

012610D0  mov         eax,dword ptr [ebx]   
012610D2  lea         edx,[eax-1010101h]   
012610D8  not         eax   
012610DA  and         edx,eax  
012610DC  add         ebx,4    
012610DF  test        edx,80808080h    
012610E5  je          main+90h (12610D0h) 

主函数代码：

const int num = 1024 * 1024 * 32;
	static char arr[num];
	memset(arr,'1',num);
0118100C  push        2000000h  
01181011  push        31h  
01181013  push        offset arr (1183370h)  
01181018  call        memset (1181BFAh)  
	arr[num - 1] = 0;
	clock_t beg = clock();
0118101D  mov         ebx,dword ptr [__imp__clock (11820D4h)]  
01181023  add         esp,0Ch  
01181026  mov         byte ptr ds:[318336Fh],0  
0118102D  call        ebx  
0118102F  mov         dword ptr [esp+14h],eax  
	int len1 = strlen(arr);
01181033  mov         eax,offset arr (1183370h)  
01181038  lea         edx,[eax+1]  
0118103B  jmp         main+40h (1181040h)  
0118103D  lea         ecx,[ecx]  
01181040  mov         cl,byte ptr [eax]  
01181042  inc         eax  
01181043  test        cl,cl  
01181045  jne         main+40h (1181040h)  
01181047  sub         eax,edx  
01181049  mov         dword ptr [esp+10h],eax  
	clock_t mid = clock();
0118104D  call        ebx  
0118104F  mov         esi,eax  
	int len2 = my::strlen(arr);
01181051  mov         edi,offset arr (1183370h)  
01181056  xor         ecx,ecx  
01181058  cld  
01181059  dec         ecx  
0118105A  xor         eax,eax  
0118105C  repne scas  byte ptr es:[edi]  
0118105E  mov         dword ptr [esp+0Ch],edi  
	clock_t end = clock();
01181062  call        ebx  

[iamnobody]

问题2是我2了，忘了加括号：(((int)pcrr) & 3 == 0) =》 ((((int)pcrr) & 3) == 0){

，请高手回答问题1：：：

[周晓荣]

mark~~~

帮顶，等会看。

[PG]

LZ数据帝啊，膜拜~~帮顶~~~

[zuo187qiang]

帮顶...菜鸟看不懂....

[qq120848369]

表示没学过汇编。

[柯本]

问题1:可查intel每条指令的clocks,自己算一下.不过我暂时只找到scasb为12个时钟周期,还要考虑不同CPU的相同指令时钟周期不同,加上流水线优化等,但我感觉这个是可能的.
问题2:编译器都有控制优化指令-O,你试一下你不同-O参数的结果,当然也可能达不到你的要求,那就是编译器的问题了.所以编译器所带的库文件,很多也是ASM写的而非C/C++,以前研究过borland的字串strcpy就是用asm写的,它是用每次拷贝一字长(4字节)以提高速度

;[]-----------------------------------------------------------------[]
;|   QSTRCPY.ASM -- copy string src to string dest (quick version)   |
;[]-----------------------------------------------------------------[]

DWALIGN equ     1               ; set to 1 to enable dword-aligning of string

;
;       C/C++ Run Time Library - Version 11.0
; 
;       Copyright (c) 1991, 2002 by Borland Software Corporation
;       All Rights Reserved.
; 

; $Revision: 9.4.2.1 $

        include RULES.ASI

;       Segments Definitions

Header@

;-----------------------------------------------------------------------
;
;Name           __strcpy__ - copy string src to string dest
;
;Usage          char *__strcpy__ (char *dest, const char *src);
;
;Prototype in   string.h
;
;Description    Copy the ASCIIZ string *src to  the buffer *dest. It is the
;               callers responsibility  to ensure that  the dest buffer  is
;               large enough  to contain the  string, and to  guard against
;               supplying NULL arguments.
;
;               NOTE: this is the "quick" version of strcpy; it cheats
;               by fetching 32-bit words, which can GP fault if the
;               src string is near the end of a memory region and DWALIGN
;               is not enabled above.
;
;Return value   __strcpy__ returns dest.
;
;-----------------------------------------------------------------------

Code_seg@

Func@   __strcpy__, public, _RTLENTRYF, <pointer dest>, <pointer src>

        Link@
        mov     ecx, src        ; get source string
        mov     edx, dest       ; get destination buffer
if DWALIGN
        mov     eax, ecx
        and     eax, 3
        jmp     jmptab[eax*4]

jmptab  dd      offset FLAT:fetch
        dd      offset FLAT:fetch3
        dd      offset FLAT:fetch2
        dd      offset FLAT:fetch1

; Copy three bytes

fetch3:
        mov     al, [ecx]
        or      al, al
        je      return0
        mov     [edx], al
        add     ecx, 1
        add     edx, 1

; Copy two bytes

fetch2:
        mov     al, [ecx]
        or      al, al
        je      return0
        mov     [edx], al
        add     ecx, 1
        add     edx, 1

; Copy one byte

fetch1:
        mov     al, [ecx]
        or      al, al
        je      return0
        mov     [edx], al
        add     ecx, 1
        add     edx, 1

;       jmp     fetch

endif   ; DWALIGN

fetch:
        mov     eax, [ecx]      ; get four bytes from source
        or      al, al          ; check byte 0 for null
        jz      return0
        or      ah, ah          ; check byte 1 for null
        jz      return1
        test    eax, 000ff0000h ; check byte 2 for null
        jz      return2
        test    eax, 0ff000000h ; check byte 3 for null
        jz      return3
        mov     [edx], eax
        add     ecx, 4
        add     edx, 4
        jmp     fetch
return3:
        mov     [edx], eax      ; copy bytes 0-3
        mov     eax, dest       ; return dest
        Unlink@
        Return@
return2:
        mov     [edx], ax       ; copy bytes 0-2
        mov     byte ptr [edx+2], 0
        mov     eax, dest       ; return dest
        Unlink@
        Return@
return1:
        mov     [edx], ax       ; copy bytes 0-1
        mov     eax, dest       ; return dest
        Unlink@
        Return@
return0:
        mov     [edx], al       ; copy byte 0
        mov     eax, dest       ; return dest
        Unlink@
        Return@

EndFunc@ __strcpy__

Code_EndS@

        end

[lengxujun]

对于编译器来说，在做优化的时候，对于达到同样功能的代码段，如果它越难“理解”你的代码逻辑，所能做出的优化效果越差。也就是说，你用编写的表面上更高效的代码，可能比不上表面更糟糕但更容易被编译器“理解”的代码。这也就是你在debug模式下的代码（表面上更高效但不那么被编译器“理解”，代码未经过优化），而release模式下优化时缺翻译成了更低效的代码（因为编译器没“理解”的真正意图）。
这些涉及到编译器的优化理论，lz可以专门研究一下（管窥优化等等之类的）。

一家之言，仅供参考。

[iamnobody]

[Quote=引用 6 楼 keiy 的回复:]
问题1:可查intel每条指令的clocks,自己算一下.不过我暂时只找到scasb为12个时钟周期,还要考虑不同CPU的相同指令时钟周期不同,加上流水线优化等,但我感觉这个是可能的.
问题2:编译器都有控制优化指令-O,你试一下你不同-O参数的结果,当然也可能达不到你的要求,那就是编译器的问题了.所以编译器所带的库文件,很多也是ASM写的而非C/C++,以前研究过borland的字串strcp……
[/Quote]

rep scasb 9 + 4*cx
7 if cx=0
查到了，是pentium的。没什么不妥。。。
同样的次数竟然比普通循环慢那么多。。。