我需要将一块内存与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;
}
}
答案 0 :(得分:2)
一个解决方案:
创建一个包含所有相同值的缓冲区并迭代比较。这样,您就可以获得高效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),但这种方法比完整缓冲区快两倍(可能是由于优越的缓存性能),而且几乎<强>比逐个字符比较快十倍。
答案 1 :(得分: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并得到相同的结果。
答案 2 :(得分:1)
memcmp
地址 是比较内存块的最佳选择。无论您是使用块内联还是使用块的内存地址,您仍然需要将块存储在某处。
您可以在编译时使用以下内容创建这样的块:
int block[] = {3, 1, 4, 1, 5, 9};
然后只需在block
中使用memcmp
。
如果您只是想确保将内存块设置为特定值,请使用for
循环解决方案。你提出的任何其他解决方案都必须做同样的事情,检查整个块。
另一种选择,如果它是一个非常巨大的内存块并且花费的时间太长,则完全取消了这一要求。通过这种方式,我的意思是重新设计您的算法,以便它变得不必要。假设您有1G块。
示例:不要将它们全部设置为零。相反,只需将位置设置在您正在使用的前面并保持一个单独的length
变量,以指示您正在使用多少。
经过大量优化的memcmp
可能胜过用户循环,但您也可能发现它没有,只是因为它必须迎合一般情况 - 您的具体检查情况反对零可能允许编译器引入失败memcmp
的优化。
与所有优化一样,测量,不要猜测!
答案 3 :(得分:0)
一种选择是从memcmp的源代码开始,并且迭代地修改它以与固定缓冲区进行比较。这样,您将保留内置于memcmp中的优化,避免外部循环的开销,并仍然实现您的目标。您可以使用以下功能:
int memcmp2(const void *s1, size_t n1, const void *s2, size_t n2);
其中n1是缓冲区s1的大小,n2是s2的大小。
答案 4 :(得分:0)
如果您无法控制谁写入该内存块,那么就不可能存在允许与单个值进行有效比较的智能算法。您将需要迭代整个块,您甚至不能跳过一个单词。您唯一能做的就是一次比较更多数据,可能使用可以同时处理多个单词的机器指令。
如果您确实可以控制该内存并且只有您可以写入内存,那么您可以更聪明地确定其中的内容。例如,通过“浪费”一些空间来保持一个位模式,该位模式确定哪些单词是零。例如,如果你的单词是32位,那么你将有一个单独的内存块,你可以保留与实际内存块中的单词总和相同位数的单词。在这种情况下,这将花费您每32字节可用内存1个字节,这并不可怕。如果你确实需要字节粒度,那么成本要高得多:每8个。但是你通常不需要它;一旦找到一个未归零的单词,就可以缩小搜索范围,只搜索那个非零字节的单词。
答案 5 :(得分:0)
如果在运行memcmp()之后,为什么你会期望内存更改?如果内存只属于您的进程,则不会修改它。如果这是共享内存,则问题会变得非常不同。
作为一个替代建议,我正在考虑使用memset()将所有内存设置为已知值 - 您已经在不到546个刻度中完成了这些内容。
原因是:memset()会在一次传递中将内存设置为已知值 - 通过相同的内存进行第二次传递以进行验证需要大约两倍的时间。