Question

我需要将一块内存与C中的固定值进行比较。我可以用memcmp做这个吗？类似的东西：

memcmp（starting_address， fixed_value ，num_byte）

我需要fixed_value为固定值而不是块的起始地址。

将固定值写入整个临时内存块不是一种选择，因为我的空间有限。
使用循环逐个写入和检查内存不是一种选择，因为它非常慢。

如果不可能，任何人都可以告诉我一个与memcmp一样快（或更快）的解决方案吗？

谢谢，

编辑：假设我有5GB的内存保持0。我正在努力确保他们都是0。检查块的第一个字节是否安全，然后执行此操作：

memcmp（starting_address，starting_address + ONE_BYTE，FIVE_GB）; ？

编辑：这就是为什么我需要使用memcmp而不是用户定义的循环：

此代码需要546个时钟周期才能运行：

memset(0x80000000 , 0x1 , 0x10000000);
memset(0x90000000 , 0x1 , 0x10000000);
memcmp(0x80000000 , 0x90000000 , 0x10000000);

vs这个花了7669个时钟滴答：

unsigned int i;
int flag = 0;
int *p = 0x80000000;
int *q = 0x90000000;
while(p < 0x90000000)
{
    if(*p++ != *q++)
    {
        flag = 1;
    }
}

Answer 1

一个解决方案：

创建一个包含所有相同值的缓冲区并迭代比较。这样，您就可以获得高效memcmp实现的优势，而无需编写太多代码：

static char val[4096]; // tune the size of the buffer if desired
/* at initialization: memset(val, 0x01, sizeof(val)) */

char *start, *ptr, *end;
// initialize start and end
for(ptr = start; ptr < end-sizeof(val); ptr += sizeof(val)) {
    if(memcmp(ptr, val, sizeof(val))
        goto not_all_val;
}
if(memcmp(ptr, val, end - ptr))
    goto not_all_val;

/* all val */
puts("all val");
return;

not_all_val:
puts("not all val");
return;

效果比较：

10000 memcmp(buf, buf2, 4000000)次迭代（两个长度相同的缓冲区，与问题中的第一个方法相同）：

real    0m7.480s
user    0m7.375s
sys 0m0.103s

超过4000000字节的10000次迭代逐字符比较（与第二种方法相同）：

real    0m27.004s
user    0m26.908s
sys 0m0.094s

上述建议方法的10000次迭代超过4000000字节：

real    0m3.194s
user    0m3.151s
sys 0m0.042s

YMMV（我正在使用已有三年历史的Macbook Pro），但这种方法比完整缓冲区快两倍（可能是由于优越的缓存性能），而且几乎<强>比逐个字符比较快十倍。

Answer 2

我刚在Mac上测试了这个循环，它击败了memcmp：

uint64_t *p = (uint64_t *)buffer1;
uint64_t compare;
memset(&compare, 1, sizeof compare);
for (i = 0; i < length/sizeof compare; i++)
{
    if (p[i] != compare)
        break;
}

完整的示例代码：

#include <stdio.h>
#include <string.h>
#include <sys/resource.h>
#include <time.h>
#include <stdlib.h>
#include <stdint.h>

// from: http://www.gnu.org/software/libc/manual/html_node/Elapsed-Time.html
void timeval_subtract(struct timeval *result, struct timeval *x, struct timeval *y)
{
    /* Perform the carry for the later subtraction by updating y. */
    if (x->tv_usec < y->tv_usec)
    {
        int nsec = (y->tv_usec - x->tv_usec) / 1000000 + 1;
        y->tv_usec -= 1000000 * nsec;
        y->tv_sec += nsec;
    }

    if (x->tv_usec - y->tv_usec > 1000000)
    {
        int nsec = (x->tv_usec - y->tv_usec) / 1000000;
        y->tv_usec += 1000000 * nsec;
        y->tv_sec -= nsec;
    }

    /* Compute the time remaining to wait. tv_usec is certainly positive. */
    result->tv_sec = x->tv_sec - y->tv_sec;
    result->tv_usec = x->tv_usec - y->tv_usec;
}

int main(int argc, char **argv)
{
    struct rusage before;
    struct rusage after;
    struct timeval diff;
    size_t i;

    size_t length = strtoull(argv[1], NULL, 0);

    char *buffer1 = malloc(length);
    char *buffer2 = malloc(length);

    printf("filling...");
    fflush(stdout);
    memset(buffer1, 1, length);
    memset(buffer2, 1, length);
    printf(" done\n");

    getrusage(RUSAGE_SELF, &before);
    uint64_t *p = (uint64_t *)buffer1;
    uint64_t compare;
    memset(&compare, 1, sizeof compare);
    for (i = 0; i < length/sizeof compare; i++)
    {
        if (p[i] != compare)
            break;
    }
    if (i == length/sizeof compare)
        i = 0;
    getrusage(RUSAGE_SELF, &after);

    printf("\nloop (returned %zu):\n", i);
    timeval_subtract(&diff, &after.ru_utime, &before.ru_utime);
    printf("User:   %ld.%06d s\n", diff.tv_sec, diff.tv_usec);

    timeval_subtract(&diff, &after.ru_stime, &before.ru_stime);
    printf("System: %ld.%06d s\n", diff.tv_sec, diff.tv_usec);

    getrusage(RUSAGE_SELF, &before);
    i = memcmp(buffer1, buffer2, length);
    getrusage(RUSAGE_SELF, &after);

    printf("\nmemcmp (returned %zu):\n", i);
    timeval_subtract(&diff, &after.ru_utime, &before.ru_utime);
    printf("User:   %ld.%06d s\n", diff.tv_sec, diff.tv_usec);

    timeval_subtract(&diff, &after.ru_stime, &before.ru_stime);
    printf("System: %ld.%06d s\n", diff.tv_sec, diff.tv_usec);

    return 0;
}

并运行结果：

$ make
clang -Wall -Wextra -Werror -O3 -g -o example example.c
./example 0x10000000
filling... done

loop (returned 0):
User:   0.024078 s
System: 0.000011 s

memcmp (returned 0):
User:   0.036752 s
System: 0.000017 s

也许你可以做类似的事情？

注意：对于那些担心缓存变暖的人，我也在循环之前尝试使用memcmp并得到相同的结果。

Answer 3

memcmp地址是比较内存块的最佳选择。无论您是使用块内联还是使用块的内存地址，您仍然需要将块存储在某处。

您可以在编译时使用以下内容创建这样的块：

int block[] = {3, 1, 4, 1, 5, 9};

然后只需在block中使用memcmp。

如果您只是想确保将内存块设置为特定值，请使用for循环解决方案。你提出的任何其他解决方案都必须做同样的事情，检查整个块。

另一种选择，如果它是一个非常巨大的内存块并且花费的时间太长，则完全取消了这一要求。通过这种方式，我的意思是重新设计您的算法，以便它变得不必要。假设您有1G块。

示例：不要将它们全部设置为零。相反，只需将位置设置在您正在使用的前面并保持一个单独的length变量，以指示您正在使用多少。

经过大量优化的memcmp 可能胜过用户循环，但您也可能发现它没有，只是因为它必须迎合一般情况 - 您的具体检查情况反对零可能允许编译器引入失败memcmp的优化。

与所有优化一样，测量，不要猜测！

Answer 4

一种选择是从memcmp的源代码开始，并且迭代地修改它以与固定缓冲区进行比较。这样，您将保留内置于memcmp中的优化，避免外部循环的开销，并仍然实现您的目标。您可以使用以下功能：

int memcmp2(const void *s1, size_t n1, const void *s2, size_t n2);

其中n1是缓冲区s1的大小，n2是s2的大小。

Answer 5

如果您无法控制谁写入该内存块，那么就不可能存在允许与单个值进行有效比较的智能算法。您将需要迭代整个块，您甚至不能跳过一个单词。您唯一能做的就是一次比较更多数据，可能使用可以同时处理多个单词的机器指令。

如果您确实可以控制该内存并且只有您可以写入内存，那么您可以更聪明地确定其中的内容。例如，通过“浪费”一些空间来保持一个位模式，该位模式确定哪些单词是零。例如，如果你的单词是32位，那么你将有一个单独的内存块，你可以保留与实际内存块中的单词总和相同位数的单词。在这种情况下，这将花费您每32字节可用内存1个字节，这并不可怕。如果你确实需要字节粒度，那么成本要高得多：每8个。但是你通常不需要它;一旦找到一个未归零的单词，就可以缩小搜索范围，只搜索那个非零字节的单词。

Answer 6

如果在运行memcmp（）之后，为什么你会期望内存更改？如果内存只属于您的进程，则不会修改它。如果这是共享内存，则问题会变得非常不同。

作为一个替代建议，我正在考虑使用memset（）将所有内存设置为已知值 - 您已经在不到546个刻度中完成了这些内容。

原因是：memset（）会在一次传递中将内存设置为已知值 - 通过相同的内存进行第二次传递以进行验证需要大约两倍的时间。

memcmp但需要将块与固定值进行比较

6 个答案: