我想了解的区别memcpy()和memmove(),和我读的文本memcpy(),而没有照顾重叠源和目的地memmove()一样.

但是,当我在重叠的内存块上执行这两个函数时,它们都会给出相同的结果.例如,在memmove()帮助页面上采用以下MSDN示例: -

有没有更好的例子来理解它的缺点memcpy和memmove解决方法？

// crt_memcpy.c
// Illustrate overlapping copy: memmove always handles it correctly; memcpy may handle
// it correctly.

#include <memory.h>
#include <string.h>
#include <stdio.h>

char str1[7] = "aabbcc";

int main( void )
{
    printf( "The string: %s\n", str1 );
    memcpy( str1 + 2, str1, 4 );
    printf( "New string: %s\n", str1 );

    strcpy_s( str1, sizeof(str1), "aabbcc" );   // reset string

    printf( "The string: …

memmove和之间有什么区别memcpy？您经常使用哪一个以及如何使用？

我一直在阅读有关Windows XP和Windows Server 2003上针对GDI +的旧版漏洞,我正在研究一个名为JPEG of death的项目.

该漏洞利用在以下链接中得到了很好的解释:http: //www.infosecwriters.com/text_resources/pdf/JPEG.pdf

基本上,JPEG文件包含一个名为COM的部分,其中包含一个(可能为空)注释字段,以及一个包含COM大小的双字节值.如果没有注释,则大小为2.读取器(GDI +)读取大小,减去两个,并分配适当大小的缓冲区以复制堆中的注释.攻击涉及0在现场放置一个值.GDI +减去2,导致的一个值-2 (0xFFFe),其被转化成无符号整数0XFFFFFFFE的memcpy.

示例代码:

unsigned int size;
size = len - 2;
char *comment = (char *)malloc(size + 1);
memcpy(comment, src, size);

注意malloc(0)在第三行应返回指向堆上未分配内存的指针.如何写入0XFFFFFFFE字节(4GB!!!!)可能不会使程序崩溃？这是否超出堆区域并进入其他程序和操作系统的空间？那么会发生什么？

据我所知memcpy,它只是简单地将n字符从目的地复制到源.在这种情况下,源应该在堆栈上,堆上的目标,并且n是4GB.

当我无法移动/复制memmove()/ memcpy()作为边缘情况时,我是否需要处理案例

int numberOfBytes = ...
if( numberOfBytes != 0 ) {
    memmove( dest, source, numberOfBytes );
}

或者我应该在没有检查的情况下调用该函数

int numberOfBytes = ...
memmove( dest, source, numberOfBytes );

是否需要检查前片段？

我不太熟悉C标准,所以请耐心等待.

我想知道,按标准保证memcpy(0,0,0)是否安全.

我能找到的唯一限制是,如果内存区域重叠,那么行为是未定义的......

但我们可以认为这里的内存区域重叠吗？

memcpy()和strcpy()有什么区别？我试图在一个程序的帮助下找到它,但两者都提供相同的输出.

int main()
{
    char s[5]={'s','a','\0','c','h'};
    char p[5];
    char t[5];
    strcpy(p,s);
    memcpy(t,s,5);
    printf("sachin p is [%s], t is [%s]",p,t);
    return 0;
}

产量

sachin p is [sa], t is [sa]

我们最近购买了一些新的服务器,并且正在经历糟糕的memcpy性能.与我们的笔记本电脑相比,服务器上的memcpy性能要慢3倍.

服务器规格

• 底盘和Mobo:SUPER MICRO 1027GR-TRF
• CPU:2x Intel Xeon E5-2680 @ 2.70 Ghz
• 内存:8x 16GB DDR3 1600MHz

编辑:我也在另一台具有更高规格的服务器上进行测试,并看到与上述服务器相同的结果

服务器2规格

• 底盘和Mobo:SUPER MICRO 10227GR-TRFT
• CPU:2x Intel Xeon E5-2650 v2 @ 2.6 Ghz
• 内存:8x 16GB DDR3 1866MHz

笔记本电脑规格

• 机箱:联想W530
• CPU:1x Intel Core i7 i7-3720QM @ 2.6Ghz
• 内存:4x 4GB DDR3 1600MHz

操作系统

$ cat /etc/redhat-release
Scientific Linux release 6.5 (Carbon) 
$ uname -a                      
Linux r113 2.6.32-431.1.2.el6.x86_64 #1 SMP Thu Dec 12 13:59:19 CST 2013 x86_64 x86_64 x86_64 GNU/Linux

编译器(在所有系统上)

$ gcc --version
gcc (GCC) 4.6.1 …

来自http://en.cppreference.com/w/cpp/string/byte/memcpy:

如果对象不是TriviallyCopyable(例如标量,数组,C兼容结构),则行为未定义.

在我的工作中,我们使用std::memcpy了很长时间来按比例交换不是TriviallyCopyable的对象:

void swapMemory(Entity* ePtr1, Entity* ePtr2)
{
   static const int size = sizeof(Entity); 
   char swapBuffer[size];

   memcpy(swapBuffer, ePtr1, size);
   memcpy(ePtr1, ePtr2, size);
   memcpy(ePtr2, swapBuffer, size);
}

从来没有任何问题.

我理解滥用std::memcpy非TriviallyCopyable对象并导致下游的未定义行为是微不足道的.但是,我的问题是:

std::memcpy当与非TriviallyCopyable对象一起使用时,为什么它本身的行为是未定义的？为什么标准认为有必要指定？

UPDATE

http://en.cppreference.com/w/cpp/string/byte/memcpy的内容已经过修改,以回应这篇文章和帖子的答案.目前的描述说:

如果对象不是TriviallyCopyable(例如标量,数组,C兼容结构),则行为是未定义的,除非程序不依赖于目标对象(不运行memcpy)的析构函数的效果和生命周期目标对象(已结束,但未开始memcpy)由其他一些方法启动,例如placement-new.

PS

@Cubbi的评论:

@RSahu如果有东西保证UB下游,它会使整个程序不确定.但我同意在这种情况下似乎可以绕过UB并相应​​地修改cppreference.

我测试了memcpy()在i*4KB时注意速度急剧下降的速度.结果如下:Y轴是速度(MB /秒),X轴是缓冲区的大小memcpy(),从1KB增加到2MB.子图2和子图3详述了1KB-150KB和1KB-32KB的部分.

环境:

CPU:Intel(R)Xeon(R)CPU E5620 @ 2.40GHz

操作系统:2.6.35-22-通用#33-Ubuntu

GCC编译器标志:-O3 -msse4 -DINTEL_SSE4 -Wall -std = c99

我想它必须与缓存相关,但我无法从以下缓存不友好的情况中找到原因:

• 为什么我的程序在完全循环8192个元素时会变慢？

• 为什么转换512x512的矩阵要比转换513x513的矩阵慢得多？

由于这两种情况的性能下降是由不友好的循环引起的,这些循环将分散的字节读入高速缓存,浪费了高速缓存行的其余空间.

这是我的代码:

void memcpy_speed(unsigned long buf_size, unsigned long iters){
    struct timeval start,  end;
    unsigned char * pbuff_1;
    unsigned char * pbuff_2;

    pbuff_1 = malloc(buf_size);
    pbuff_2 = malloc(buf_size);

    gettimeofday(&start, NULL);
    for(int i = 0; i < iters; ++i){
        memcpy(pbuff_2, pbuff_1, buf_size);
    }   
    gettimeofday(&end, NULL);
    printf("%5.3f\n", ((buf_size*iters)/(1.024*1.024))/((end.tv_sec - \
    start.tv_sec)*1000*1000+(end.tv_usec - start.tv_usec)));
    free(pbuff_1);
    free(pbuff_2);
}

UPDATE

考虑到来自@ usr,@ ChrisW和@Leeor的建议,我更准确地重新测试了测试,下面的图表显示了结果.缓冲区大小从26KB到38KB,我每隔64B测试一次(26KB,26KB + …

我想使用增强的REP MOVSB(ERMSB)为自定义获得高带宽memcpy.

ERMSB引入了Ivy Bridge微体系结构.如果您不知道ERMSB是什么,请参阅英特尔优化手册中的"增强型REP MOVSB和STOSB操作(ERMSB)" 部分.

我知道直接执行此操作的唯一方法是使用内联汇编.我从https://groups.google.com/forum/#!topic/gnu.gcc.help/-Bmlm_EG_fE获得了以下功能

static inline void *__movsb(void *d, const void *s, size_t n) {
  asm volatile ("rep movsb"
                : "=D" (d),
                  "=S" (s),
                  "=c" (n)
                : "0" (d),
                  "1" (s),
                  "2" (n)
                : "memory");
  return d;
}

然而,当我使用它时,带宽远小于memcpy. 使用我的i7-6700HQ(Skylake)系统,Ubuntu 16.10,DDR4 @ 2400 MHz双通道32 GB,GCC 6.2,__movsb获得15 GB/s并memcpy获得26 GB/s.

为什么带宽如此低REP MOVSB？我该怎么做才能改善它？

这是我用来测试它的代码.

//gcc -O3 -march=native -fopenmp foo.c
#include <stdlib.h>
#include <string.h>
#include <stdio.h>
#include …