Fast strlen function

 strlen:       2168 ticks <-+ first run effects
 strlen:       2144 ticks   |
 strlen:       2117 ticks   |
 strlen:       2139 ticks <-+
 strlen:       2107 ticks
 strlen:       2107 ticks
 strlen:       2107 ticks
 strlen:       2107 ticks
 strlen:       2107 ticks
 strlen:       2107 ticks
 strlen:       2107 ticks
 strlen:       2107 ticks
 strlen:       2107 ticks
 strlen:       2107 ticks
 strlen:       2823 ticks <-+ a surge probably caused by task switch
 strlen:       2112 ticks <-+
 strlen:       2107 ticks
 strlen:       2107 ticks

   #define has_nullbyte_(x) ((x - 0x01010101) & ~x & 0x80808080) 

   has_nullbyte_(e) 

strlen - short strings (x64):
Finished Default              - with   47180255 iterations over 12000 ms
Finished Peter's original     - with   94500072 iterations over 12000 ms
Finished Peter's optimized    - with  141820205 iterations over 12000 ms
Finished Agner Fog's assembly - with  161002095 iterations over 12000 ms
Finished Traditional assembly - with  167928843 iterations over 12000 ms

strlen - long strings (x64):
Finished Default              - with   47324770 iterations over 12000 ms
Finished Peter's original     - with   94649438 iterations over 12000 ms
Finished Peter's optimized    - with  141971792 iterations over 12000 ms
Finished Agner Fog's assembly - with  163672178 iterations over 12000 ms
Finished Traditional assembly - with  167573645 iterations over 12000 ms

dwEnd = ::GetTickCount() + SAMPLING_INTERVAL;
do
{
    ALIGN UINT64 start = GetRDTSC();
    testfunc(strlenfunc);
    ALIGN UINT64 time = GetRDTSC() - start;
    dwCounter += (UINT32)time;
    dwNow = ::GetTickCount();
    g_dwTotalIterations++;
}
while(dwNow < dwEnd);
printf("Finished %10u iters\n", g_dwTotalIterations );

	TestStrLen(name_default, 
	TestStrLen(name_peter, 
	TestStrLen(name_peter_new, 
	TestStrLen(name_agner_fog,
	TestStrLen(name_trad, 

	TestStrLen(name_trad, 
	TestStrLen(name_default, 
	TestStrLen(name_agner_fog,
	TestStrLen(name_peter_new, 
	TestStrLen(name_peter, 

rdtsc
mov [result_hi], edx
mov [result_lo], eax

You missed an obvious optimization. You can detect a null in a four-byte word like:

    unsigned y = x & 0x7F7F7F7Fu;
    y += 0x7F7F7F7F;
    y |= x;
    if ((y & 0x80808080) != 0x80808080u) {
        /* x has a nul- check each byte */
    } else {
        /* x does not have a null */
    }

The advantage this approach has is fewer jumps- and it uses only simple (1-clock) instructions, and 2 registers- allowing you to unroll this loop 2 or 3 times and give the execution units plenty to do.

Regarding invalid accesses, one possibility is this (sorry for the goto, so much easier to write it this way):

len = 0;
if ((((intptr_t)p) & (sizeof(long)-1)) == 0) goto loop;
if (*p++ == 0) return len; else len++;
if ((((intptr_t)p) & (sizeof(long)-1)) == 0) goto loop;
if (*p++ == 0) return len; else len++;
if ((((intptr_t)p) & (sizeof(long)-1)) == 0) goto loop;
if (*p++ == 0) return len; else len++;
if ((((intptr_t)p) & (sizeof(long)-1)) == 0) goto loop;
if (*p++ == 0) return len; else len++;
loop:
    for(;;) {
        unsigned x = *(unsigned*)s;
        if((x & 0xFF) == 0) return len;
        if((x & 0xFF00) == 0) return len + 1;
        if((x & 0xFF0000) == 0) return len + 2;
        if((x & 0xFF000000) == 0) return len + 3;
        s += 4, len += 4;
    }

By aligning the address at the beginning, you ensure the code will never perform memory accesses that span two pages.

Thank you, it's a nice idea! I would rewrite it with a fall-through switch (similar to Duff's device) to avoid the excess conditions:

int strlen_my(const char *s) {
    int len = 0;
    const char *p = s;
    switch ( (intptr_t)p & 3 ) {
        case 3:
            if (*p++ == 0)
               return p - s;
        case 2:
            if (*p++ == 0)
               return p - s;
        case 1:
            if (*p++ == 0)
               return p - s;
    }
 
    for(;;) {
        unsigned x = *(unsigned*)p;
        if((x & 0xFF) == 0) return p - s;
        if((x & 0xFF00) == 0) return p - s + 1;
        if((x & 0xFF0000) == 0) return p - s + 2;
        if((x & 0xFF000000) == 0) return p - s + 3;
        p += 4;
    }
}

The benchmark shows that this code is slower on short strings, but slightly faster on a long string because of aligned memory access. Thank you again for the idea.

Can you find where is the break-even point WRT Agner's code now? Probably this is as good as you can be for reasonably sized strings; and safer than your original code which makes the comparison with your code apples-to-oranges, basically.

(Note that you are trading up to 3 conditions for always 2 conditions – or no change at all if the compiler decides it's not worth using a decision tree implementation of the switch statement – so not much is changing regarding the number of jumps).

s+=4; => ((unsigned*)s)++;
// Increment is more usefull i think.

I would propose aligning in while{} loop to avoid excessive conditions, this shall outperform fall-through switch as well, at least in my syntetic tests by +1.5%.

size_t __aux_strlen(const char *str)
{
    register size_t len = 0;
    // align pointer to 32 bits
    while ((((intptr_t)str) & (sizeof(unsigned int)-1)) != 0)
    {
        if (*str ++ == 0) 
            return len; 
        ++ len;
    }
    // search for 0
    for (;;)
    {
        unsigned int v = *(unsigned int *)str;
        if ((v & 0x000000FFU) == 0) return (len);
        if ((v & 0x0000FF00U) == 0) return (len + 1);
        if ((v & 0x00FF0000U) == 0) return (len + 2);
        if ((v & 0xFF000000U) == 0) return (len + 3);
        str += sizeof(unsigned int);
        len += sizeof(unsigned int);
    }
}

Thank you very much, Dmitry. Your function is also 29 bytes shorter when compiled with MSVC++ 2005.

"Four bytes are examined at once." Really? How odd. This _looks_ like it's supposed to be C code, so let's apply C rules:

1) A byte has a _minimum_ size, defined by its required range, of some 8 bits, but might be 32 or more - and often is. 2) An unsigned has a minimum size, defined by its required range, of 16 bits. 3) A string's length can exceed the range of an int, so the code can produce negative results. A string of length -17? Neat trick. 4) If I recall correctly, identifiers with names of the form str* are reserved.

Thus, we have no idea how many bytes are being examined, but we do know that as far as C (or, for that matter, C++) is concerned, the code is only required to access 16 bits at a time, and it is not required to work at all if the data isn't aligned properly for access as an unsigned.

Rather than worrying about code that's "fast", how about worrying about code that's actually correct, first? If there's no requirement that the code actually functions correctly, I can make a much faster version for you:

int mystrlen(const char *s ) {

return 17;

}

You'd be hard pressed to beat it's performance, and unlike your version, it is at least expected to work.

To Spanky: Which compiler actually uses "char" of more than 8 bits? Do you know of any? I don't mean "wchar_t", I mean "char".

(On another side, I believe that it would be possible to make a C compiler which would generate code for old machines which used 6 bits for char, had 24-bit words and were bit addressable. So I agree that using "char" and "unsigned" as presented here is not portable. Not to mention endianness. There should probably be some line in the article that mentiones it's all for x86 world.)

Spanky, thank you for the comments. I added "for x86 only" line. A generalized code for any processor would be too complex (see SSE2 optimised strlen as an example). The compilers might have a different size of unsigned (usually from 16 to 64 bits) and endianness, so you have to use #ifdefs for that.

3), 4) Thanks, I corrected this.

Another implementation of strlen() uses the same approach, outperforms run-time function by 120% on larger strings

#define  SIZEOF_SIZE_T     (sizeof(size_t))
#define  SIZEOF_SIZE_T_BITS     (8*(SIZEOF_SIZE_T))

size_t __fast_strlen(const char *str)
{
   register size_t len = 0;

   // align pointer to natural size_t aligment
   while ((((size_t)str) & (SIZEOF_SIZE_T - 1)) != 0) {
      if (*str++ == 0) {
         return len;
      }
      ++len;
   }

   size_t n = (size_t)0x7F7F7F7F7F7F7F7FLL; 

   // search for 0 - little endian
   for(;;) {
      size_t v = *(size_t *)str;
      if (v == 0) return (len);

      size_t y = (v & n) + n;     // convert each null byte into 0x80 and each non null byte into 0x00
      y = ~(y | v | n);
      if( y == 0) {   // no null bytes
         str += SIZEOF_SIZE_T;
         len += SIZEOF_SIZE_T;
         continue;
      }

      size_t  yy0  = y & 0xFFFFFFFFLL;
      if( yy0 == 0) {  yy0 = y >> (SIZEOF_SIZE_T_BITS/2); len += SIZEOF_SIZE_T/2; }

      size_t  yy1  = yy0 & 0xFFFFLL;
      if( yy1 == 0) {  yy1 = yy0 >> (SIZEOF_SIZE_T_BITS/4); len += SIZEOF_SIZE_T/4; }

      size_t  yy2  = yy1 & 0xFFLL;
      if( yy2 == 0) {  yy2 = yy1 >> (SIZEOF_SIZE_T_BITS/8); len += SIZEOF_SIZE_T/8; }

      return len;
   }

   return len;  // newer gets here, make compiler happy
}

if anyone needs I can paste a template that works with wchar_t and on big endian machine.

Thanks Peter fro your idea.

forgot to mention, this is for 64 bit compiler (size_t = 8)

Of course nothing beats SSE 4.2 PCMPxSTRx instructions. Finally they introduced an instruction that can significantly speed up all memxxx(), strxxx() functions.

For those who do not like resort to an assembler, here is an strlen() that uses microsoft C compiler intrinsic.

It outperforms run time library strlen() 500 percent.

#define EQUAL_ANY	0x00    // 0000b
#define RANGES		0x04    // 0100b
#define EQUAL_EACH	0x08    // 1000b
#define EQUAL_ORDERED	(0x8+0x04)    // 1100b
#define NEGATIVE_POLARITY  0x10     // 010000b
#define BYTE_MASK	   0x40     // 1000000b


size_t  sse4_strlen(const char *str)
{
   size_t len = 0;
   __m128i  z, c;

   z = _mm_setzero_si128();

   int idx;
   while(true) {

      c = _mm_loadu_si128( (const __m128i*)(str) ); 
      idx = _mm_cmpistri(z, c, EQUAL_EACH);   //returns index of the first byte that matches
      if(idx < sizeof(__m128i)) break;
      len += sizeof(__m128i);
      str += sizeof(__m128i); 
   }
   return len + idx;
}



 

Obviously all other strxxx() family of functions can be easily implemented

For example strchr()

#define EFLAG_CARRY     (0x0001LL<<0)
#define EFLAG_PARITY    (0x0001LL<<2)
#define EFLAG_ADJUST    (0x0001LL<<4)
#define EFLAG_ZERO      (0x0001LL<<6)
#define EFLAG_SIGN      (0x0001LL<<7)
#define EFLAG_OVERFLOW  (0x0001LL<<11)

size_t  sse4_strchr(const char *str, char ch)
{
   size_t len = 0;
   __m128i  z, c;
   __int64  eflags;

   z = _mm_set1_epi8(ch);  // convert character to a string of characters

   int idx;
   while(true) {

      c = _mm_loadu_si128( (const __m128i*)(str) ); 
      idx = _mm_cmpistri(z, c, EQUAL_EACH);   // returns index of a first matched byte or 16 otherwise
      eflags = __readeflags();
      if(idx < sizeof(__m128i)) break;
      if(eflags & EFLAG_ZERO) {   // Zero Flag is set if operand contains zero byte
         return (size_t(-1));
      }
      len += sizeof(__m128i);
      str += sizeof(__m128i); 
   }
   return len + idx;
}

Also performance in comparison with run time library function increase is very significant

You don't need sse4 to get this speed-up; pcmpeq + movemask + bfs do the job quite well.

Here's an sse2 equivalent, with attention to using aligned loads. It's gcc 4.4.

Pardon my dense style and presumed #includes

#define xmload(p)   _mm_load_si128((__m128i const*)p)
#define xmatch(a,b) _mm_movemask_epi8(_mm_cmpeq_epi8(a, b))

char const *sse2_strchr(char const *str, char ch)
{
    __m128i     x, zero = {}, p0 = _mm_set1_epi8(ch);
    unsigned    z, m, f = 15 & (uintptr_t)str;

    // Initial unaligned chunk of tgt:
    if (f) {
        z = xmatch(x = xmload(str - f), zero) >> f;
        m = (xmatch(x,p0) >> f) & ~z & (z - 1)
        if (m) return tgt + ffs(m) - 1;
        if (z) return NULL;
        tgt += 16 - f;
    }

    // 16-byte aligned chunks of str:
    for (; !(z = xmatch(x = xmload(str), zero)); str += 16)
        if ((m = xmatch(x,p0)))
            return str + ffs(m) - 1;

    // Final 0..15 bytes of tgt:
    if ((m = xmatch(x,p0) & ~z & (z - 1)))
        return str + ffs(m) - 1;

    return NULL;
}

Thank you. Agner Fog uses the same approach for strlen in his asmlib. Unfortunately, even after small corrections your code fails the tests.

#include <stdio.h>
#include <stdint.h>
#include <string.h>
#include <assert.h>
#include <emmintrin.h>

#define xmload(p)   _mm_load_si128((__m128i const*)p)
#define xmatch(a,b) _mm_movemask_epi8(_mm_cmpeq_epi8(a, b))
#ifdef __GNUC__
#define ctz(a) __builtin_ctz(a)
#elif defined(_MSC_VER)
#include <intrin.h>
inline unsigned long ctz(unsigned long x) {
	unsigned long index;
	_BitScanForward(&index, x);
	return index;
}
#endif

// by mischa sandberg
char const *sse2_strchr(char const *str, char ch)
{
    __m128i     x, zero = {}, p0 = _mm_set1_epi8(ch);
    unsigned    z, m, f = 15 & (uintptr_t)str;

    // Initial unaligned chunk of tgt:
    if (f) {
        z = xmatch(x = xmload(str - f), zero) >> f;
        m = (xmatch(x,p0) >> f) & ~z & (z - 1);
        if (m) return str + ctz(m);
        if (z) return NULL;
        str += 16 - f;
    }

    // 16-byte aligned chunks of str:
    for (; !(z = xmatch(x = xmload(str), zero)); str += 16)
        if ((m = xmatch(x,p0)))
            return str + ctz(m);

    // Final 0..15 bytes of tgt:
    if ((m = xmatch(x,p0) & ~z & (z - 1)))
        return str + ctz(m);

    return NULL;
}


int main() {
    assert( strcmp( sse2_strchr("abc", 'a'), "abc" ) ==0 );
    assert( NULL == sse2_strchr("", 'a') );
    assert( strcmp( sse2_strchr("abc", 'b'), "bc" ) ==0 );
    assert( NULL == sse2_strchr("abc", 'z') );
    
    assert( "st" == sse2_strchr("abc def ghi jkl mno pqr st", 's') );
    assert( "mno pqr st" == sse2_strchr("abc def ghi jkl mno pqr st", 'm') );
    return 0;
}

Gah! Sorry. To save space I compressed xmload/xmatch from static inline functions into #define's.

The fix is:

#define xmload(p)   _mm_load_si128((__m128i const*)(p))

Also, I'm fascinated that

   assert("st" == sse2_strchr(...)) 

works, as opposed to

   assert(!strcmp("st", sse2_strchr(...)))

With the compile switches I use, that doesn't get past a compile error:

"comparison with string literal results in unspecified behavior"

The above logic can be extended to a strstr that scans for a match on the first two chars of the pattern.

Sorry for not working out the MSVC details here.

$ cat toad.c
#include <string.h>
#include <stdint.h>
#include <emmintrin.h>
static inline int under(int x) { return ~x & (x - 1); }
#define ctz(m)      (ffs(m) - 1)
#define xmload(p)   _mm_load_si128((__m128i const*)(p))
#define xmatch(a,b) _mm_movemask_epi8(_mm_cmpeq_epi8(a, b))
static char const *scanchr2(char const *str, char const pat[2])
{
    __m128i     x, zero = {};
    __m128i     p0 = _mm_set1_epi8(pat[0]), p1 = _mm_set1_epi8(pat[1]);
    uint16_t    pair = *(uint16_t const*)pat;
    unsigned    z, m, f = 15 & (uintptr_t)str;

    // Initial unaligned chunk of str:
    if (f) {
        z = xmatch(x = xmload(str - f), zero) >> f;
        m = under(z) & ((xmatch(x,p0) & (xmatch(x,p1) >> 1)) >> f);
        if (m) return str + ctz(m);
        if (z) return NULL;
        str += 16 - f;
        if (*(uint16_t const*)(str - 1) == pair)
            return str - 1;
    }

    // 16-byte aligned chunks of str:
    while (!(z = xmatch(x = xmload(str), zero))) {
        m = xmatch(x,p0) & (xmatch(x,p1) >> 1);
        if (m) return str + ctz(m);
        str += 16;
        if (*(uint16_t const*)(str - 1) == pair)
            return str - 1;
    }

    // Final 0..15 bytes of str:
    m = under(z) & xmatch(x,p0) & (xmatch(x,p1) >> 1);
    return m ? str + ctz(m) : NULL;
}

static char const *sse2_strstr(char const *str, char const *pat)
{
    unsigned patlen = strlen(pat);
    if (patlen == 0) return str;
    if (patlen == 1) return strchr(str, *pat);
    while ((str = scanchr2(str, pat)))
        if (!memcmp(str+2, pat+2, patlen-2))
            return str;
    return NULL;
}

int main(void)
{
    return strcmp("world", sse2_strstr("hello, world", "world"));
}

$ gmake toad
cc -g -MMD -O9 -fno-strict-aliasing -fstack-protector --param ssp-buffer-size=4 -Wall -Werror -Wextra -Wcast-align -Wcast-qual -Wformat=2 -Wformat-security -Winline -Wmissing-prototypes -Wnested-externs -Wpointer-arith -Wredundant-decls -Wshadow -Wstrict-prototypes -Wunused -Wwrite-strings -O0 -msse3 -D_GNU_SOURCE -I/usr/local/include  -c -o toad.o toad.c
cc -L/usr/local/lib  toad.o  -ldl -lresolv -o toad
$ ./toad
$ echo $?
0

The above runs at about 10-15 times the speed of the glibc 4.4.5 strstr for any pattern less than 32 bytes.

This includes edge cases like the match occurring at offset 0 of the target string.

Note that glibc strlen (and hence glibc strstr) benefits from the same strlen that in fact uses the basic above idea.

There's a speed drop to 2-3 times the speed of the glibc strstr at 32 bytes ... still chewing on why.

mischasan.wordpress.com for the things I've been finding.

And, umm, scratch the -O0 in the above "cc" line if you want to see the 10-15 times speedup :-)

Also, I'm fascinated that assert("st" == sse2_strchr(...)) works

I'm sorry, it certainly should be strcmp. The two-char strstr is a great idea. I've subscribed to your blog.

On x86 and x86_64 (on core I7), there is no penalty for any misaligned memory access within a cache line, and for misaligned accesses crossing a cache line, the penalty is one cycle. You might as well consider misaligned accesses completely free. AMD architectures also have negligible penalties for misalignment.

I think I know why: I was doing performance analysis once and I enabled alignment checking in the eflags register and setup my debugger to catch the alignment traps and record the stack traces. To my surprise, I was getting millions of misaligned accesses throughout windows code and in the CRT. My theory is, Intel engineers did a similar investigation and found misaligned accesses to be happening so often, that they realized that they needed to make it super fast. In Core I7, the handling of misaligned accesses is absolutely amazing.

The first Intel processors x86 with no penalty for some misaligned memory access that I know of were some Core 2 models on 45 nm. The ones on 65 nm were significantly slower.

you could eliminate the len+=4 from the loop by using a local char* instead of s.

char *buf=s;
...
... return buf-s;
... return buf-s+1;
... return buf-s+2;
... return buf-s+3;
buf+=4;

Brad, thank you very much for noticing. Your version has one instruction less in the loop. However, len += 4 can be executed in parallel with s += 4 on a superscalar processor. As far as I remember, both versions have the same speed for this reason.

Hi Peter,

I've found that standard strlen works faster than your implementation with Ubuntu Linux 12.4 x86_64 (g++-4.6.3).

I disassembled `libc.so` and saw that strlen function checks the cpu features and calls one of the functions: __strlen_sse2_pminub, __strlen_sse2, __strlen_sse42 or __strlen_sse2_no_bsf.

Sometimes standard `strlen` function works 8x times faster (with the long string).

Hi Denis,

thank you for noticing. My friend Dmitry wrote a faster SSE2 implementation:

http://www.strchr.com/sse2_optimised_strlen

Peter, I've seen the sse2 implementation by Dmitry.

For the short string your implementation is the fastest (1.4x faster than the glibc's implementation and 1.5x faster than the Dmitry's one).

For the long string your implementation is the slowest (7.5x slower than the glibc's and 4.3x slower than the Dmitry's).

So the fastest implementation is the `standard` glibc's one.

Ubuntu 12.04 is `LTS` and contains 2 yrs. old version of `glibc`. It would be really interesting to test the newest version of `strlen`.

FWIW, here is an implementation that prevents crossing MMU pages using SSE instructions. String addresses are passed in RSI and RDI.

; strcmp2-
;
;  String comparison using pcmpistri instruction 
; and computing string lengths ahead of time.

strcmp2     proc

xmm0Save	textequ	<[rsp]>
xmm1Save	textequ	<[rsp+16]>

            push	rsi
            push    rdi
            push    rcx
            sub	rsp, 32
            movdqu	xmm0Save, xmm0
            movdqu	xmm1Save, xmm1

            ; Make RDI dependent on RSI so we can
            ; step through RDI by incrementing RSI:

            sub	rdi, rsi

            ; Okay, 16-byte align string 1 (pointed
            ; at by RSI):

paraAlign:	mov	al, [rsi]
	cmp	al, [rdi][rsi*1]
	jne	different

	; Move on to next character

	inc	rsi
		
	; Check for end of string:

	cmp	al, 0
	je	same
	; Now we need to see if we've aligned RSI on
	; a 16-byte boundary

	test	rsi, 0fh
	jnz	paraAlign
	
; RSI is now paragraph aligned. We can fetch blocks of
; 16 bytes at [RSI] without fear of a general protection
; fault. However, we don't know what RDI's alignment is,
; so we have to test to see if it's legal to fetch 16 bytes
; at a time from RDI (which is really [rdi][rsi*1] at this
; point).

	sub	  rsi, 16
scLoop:	add	  rsi, 16		;On to next block.
scLoop2:	lea	  rcx, [rdi][rsi*1]	;Check the src2
	and	  rcx, 0fffh		; block to see if
	cmp	  rcx, 0fh		; there are at		
	jbe	  lt16inPage		; least 16 bytes
					; left on MMU page.

; If we have at least 16 bytes left on the MMU page for the
; src2 block, then use pcmpistri to compare the 16 bytes
; at src1 (which we know is completely on an MMU page as
; RSI is 16-byte aligned) against the 16 bytes at src2
; (RDI+RSI). Load src1 bytes into XMM1 and use src2 as
; the pcmpistri operand (because we can use movdqa for
; src1, as it is aligned, and pcmpistri allows non-aligned
; accesses).
	
isAligned:	movdqa	  xmm1, [rsi]
	pcmpistri xmm1, [rsi][rdi*1], scFlags
	ja	  scLoop	;Equal, no zero bytes
	jc	  different2	;Not equal
	
; At this point, the zero flag must be set, so there
; must have been a zero byte in src1 or src2. As the
; characters also match, the strings must be equal.

same:	xor	rax, rax
	jmp	exit
	
; lt16inPage-
;
;  Code transfers to this label when there are fewer
; than 16 characters left in the src2 memory page.
; We must compare byte-by-byte until we hit a zero
; byte or cross the MMU page boundary.
;
; Note that if RCX is zero at this point, then
; RCX is already 16-byte aligned and we can jump
; right back up to the loop above. 

lt16inPage:	jrcxz	isAligned
cmpUpTo16:	mov	al, [rsi]
	cmp	al, [rdi][rsi*1]
	jne	different
	inc	rsi
	cmp	al, 0
	je	same
	dec	rcx
	jnz	cmpUpTo16
	jmp	paraAlign

; Branch to this point from the code where we were
; aligning RSI to a 16-byte boundary and found a
; different character (betwen RSI and RDI).

different2:	add	rsi, rcx	
different:	mov	al, [rsi]
	sub	al, [rdi][rsi*1]
	movsx	rax, al
exit:	movdqa	xmm0, xmm0Save
	movdqa	xmm1, xmm1Save
	add	rsp, 32
	pop     rcx
            pop     rdi
            pop     rsi
            ret
            
strcmp2     endp

1st check if the start of your string is sizeof(unsigned) aligned.

If not check the first few bytes that are not aligned one by one.

Then check the aligned unsigned.

With this, no need to put an extra 3 bytes at the end as you will never hit a page that you can’t read, hence no crash.

And your code will be faster as you will read aligned unsigned values