https://stackoverflow.com/questions/14936/faster-means-of-eck-for-an-empty-buffer-in-c/1493963#1493963” 驳回的想法:

int is_empty(char *buf, size_t size)
{
    static const char zero[999] = { 0 };
    return !memcmp(zero, buf, size > 999 ? 999 : size);
}

请注意,你可以将这一解决办法用于任意规模。 你可以这样做:

int is_empty(char *buf, size_t size)
{
    char *zero = calloc(size);
    int i = memcmp(zero, buf, size);
    free(zero);
    return i;
}

但是,任何有活力的记忆分配都将比你少。 第一个解决办法的唯一原因是它能够使用<代码>mcmp(>,该编码将由图书馆作者以组装语言进行手提,其速度将大大快于您在C中能够制定的任何内容。

EDIT:根据先前关于缓冲状态“类似”的观察,没有人提到优化: 如果一个缓冲地带没有空,在开始时或结束时,它可能不会空洞吗? 如果更可能最终制造香料,你可以最终开始检查,并可能看到业绩几乎没有提高。

EDIT 2. 由于被告在评论中:

int is_empty(char *buf, size_t size)
{
    return buf[0] == 0 && !memcmp(buf, buf + 1, size - 1);
}

这基本上将缓冲本身进行比较,初步检查看第一个要素是否为零。 这样,任何非零元素都将导致<代码>mcmp()失效。 我不知道如何比较使用另一种版本,但我确实知道,如果第一个要素是非零,那么它会很快失败(在我们甚至 lo之前)。 如果您更有可能在结尾处安装新产品,将更改<代码>buf[0]至buf[size],以取得相同效果。

四个功能用于测试一个简单基准的缓冲的零度:

#include <stdio.h> 
#include <string.h> 
#include <wchar.h> 
#include <inttypes.h> 

#define SIZE (8*1024) 
char zero[SIZE] __attribute__(( aligned(8) ));

#define RDTSC(var)  __asm__ __volatile__ ( "rdtsc" : "=A" (var)); 

#define MEASURE( func ) {  
  uint64_t start, stop;  
  RDTSC( start );  
  int ret = func( zero, SIZE );  
  RDTSC( stop );  
  printf( #func ": %s   %12"PRIu64"
", ret?"non zero": "zero", stop-start );  
} 


int func1( char *buff, size_t size ){
  while(size--) if(*buff++) return 1;
  return 0;
}

int func2( char *buff, size_t size ){
  return *buff || memcmp(buff, buff+1, size-1);
}

int func3( char *buff, size_t size ){
  return *(uint64_t*)buff || memcmp(buff, buff+sizeof(uint64_t), size-sizeof(uint64_t));
}

int func4( char *buff, size_t size ){
  return *(wchar_t*)buff || wmemcmp((wchar_t*)buff, (wchar_t*)buff+1, size/sizeof(wchar_t)-1);
}

int main(){
  MEASURE( func1 );
  MEASURE( func2 );
  MEASURE( func3 );
  MEASURE( func4 );
}

依据我原来的《刑法》:

func1: zero         108668
func2: zero          38680
func3: zero           8504
func4: zero          24768

如果你的方案只有x86,或只有x64,你可以方便地优化使用在线萨姆布。 REPE SCASD指示将扫描一个缓冲地带,直到发现非欧安会的口号。

由于没有同等的标准图书馆功能,因此不可能使用这些指示(如《苏菲尼亚法典》所确认)。

从头来看,如果你的缓冲时间是4比特(MASM syntax)的,那么就这样做了:

_asm {
   CLD                ; search forward
   XOR EAX, EAX       ; search for non-zero
   LEA EDI, [buf]     ; search in buf
   MOV ECX, [buflen]  ; search buflen bytes
   SHR ECX, 2         ; using dwords so len/=4
   REPE SCASD         ; perform scan
   JCXZ bufferEmpty:  ; completes? then buffer is 0
}

Tomas

EDIT:用Tony D 固定装置更新

简而言之,你需要看到汇编者正在产生什么法典。

$ gcc -S -O3 -o empty.s empty.c

The content of the Assembly:

        .text
        .align 4,0x90
.globl _is_empty
_is_empty:
        pushl       %ebp
        movl        %esp, %ebp
        movl        12(%ebp), %edx  ; edx = pointer to buffer
        movl        8(%ebp), %ecx   ; ecx = size
        testl       %edx, %edx
        jle L3
        xorl        %eax, %eax
        cmpb        $0, (%ecx)
        jne L5
        .align 4,0x90
L6:
        incl        %eax            ; real guts of the loop are in here
        cmpl        %eax, %edx
        je  L3
        cmpb        $0, (%ecx,%eax) ; compare byte-by-byte of buffer
        je  L6
L5:
        leave
        xorl        %eax, %eax
        ret
        .align 4,0x90
L3:
        leave
        movl        $1, %eax
        ret
        .subsections_via_symbols

这非常优化。 The loop do three matters:

• Increase the offset
• Compare the offset to the size
• Compare the byte-data in memory at base+offset to 0

可以通过逐字比较来略微优化,但随后,你需要担心一致性和这种协调。

当所有其他失败时,首先,不进行猜测。

如果可能的话,利用内部变量核对缓冲(应当加以调整)。

我的头顶部(不完善、未经测试的法典)几乎肯定至少有一ug。 这只是一个总的想法:

/* check the start of the buf byte by byte while it s unaligned */
while (size && !int_aligned( buf)) {
    if (*buf != 0) {
        return 0;
    }

    ++buf;
    --size;
}


/* check the bulk of the buf int by int while it s aligned */

size_t n_ints = size / sizeof( int);
size_t rem = size / sizeof( int);

int* pInts = (int*) buf;

while (n_ints) {
    if (*pInt != 0) {
        return 0;
    }

    ++pInt;
    --n_ints;
}


/* now wrap up the remaining unaligned part of the buf byte by byte */

buf = (char*) pInts;

while (rem) {
    if (*buf != 0) {
        return 0;
    }

    ++buf;
    --rem;
}

return 1;

如果有X86,你可以使用SSE测试16个 by子:

#include "smmintrin.h" // note: requires SSE 4.1

int is_empty(const char *buf, const size_t size) 
{
    size_t i;
    for (i = 0; i + 16 <= size; i += 16)
    {
        __m128i v = _mm_loadu_si128((m128i *)&buf[i]);
        if (!_mm_testz_si128(v, v))
            return 0;
    }
    for ( ; i < size; ++i)
    {
        if (buf[i] != 0)
            return 0;
    }
    return 1;
}

这可能随着停业而得到进一步改善。

在拥有AVX的现代S86 CPU上,你甚至可以使用256倍的SIMD,在某个时候测试32台。