使用memcpy函数的耗时测试（拷贝不同大小数据量耗时不同）

最新推荐文章于 2024-06-05 15:35:09 发布
最新推荐文章于 2024-06-05 15:35:09 发布
阅读量1.8w 收藏 33
点赞数 5
分类专栏： QT Linux Windows 文章标签： memcpy()耗时
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43935474/article/details/100173679
版权
QT 同时被 3 个专栏收录
124 篇文章 59 订阅
订阅专栏
Linux
15 篇文章 0 订阅
订阅专栏
Windows
11 篇文章 0 订阅
订阅专栏

今天公司里的一个大神给我普及了一下知识，使用memcpy函数的耗时在拷贝不同大小数据的时候，速度是不一样的，于是我写了个程序测试了一下，具体如下：
目标：比较 使用memcpy（）拷贝1k，4k，16k，512k，2M，4M，8M，16M，128M，500M数据的耗时

主要代码如下（编译时会自动区分当前是什么系统）：

#include "mainwindow.h"
#include "ui_mainwindow.h"
#include <QDebug>
#if defined(Q_OS_LINUX)
#include "time.h"
#else
#include <windows.h>
class chronograph
{
public:
    chronograph()
    {
        QueryPerformanceFrequency(&m_freq);
        QueryPerformanceCounter(&m_bgn);
    }
    void start()
    {
        QueryPerformanceCounter(&m_bgn);
    }

double duration()
{
    QueryPerformanceCounter(&m_end);
    return (m_end.QuadPart - m_bgn.QuadPart) * 1000.0 / m_freq.QuadPart;
}
LARGE_INTEGER now()
{
    LARGE_INTEGER now;
    QueryPerformanceCounter(&now);
    return now;
}
double DoubleNow()
{
    LARGE_INTEGER now;
    QueryPerformanceCounter(&now);
    return now.QuadPart*1000.0 / m_freq.QuadPart;
}
private:
    LARGE_INTEGER m_freq;
    LARGE_INTEGER m_bgn;
    LARGE_INTEGER m_end;
};
#endif
MainWindow::MainWindow(QWidget *parent) :
    QMainWindow(parent),
    ui(new Ui::MainWindow)
{
    ui->setupUi(this);
    #if defined(Q_OS_LINUX)
    //在linux下测试memcpy的耗时
    double usetime1k,usetime4k,usetime16k,usetime512k,usetime2M,usetime4M,usetime8M,usetime16M,usetime128M,usetime500M;
    usetime1k = 0;
    usetime4k = 0;
    usetime16k = 0;
    usetime512k = 0;
    usetime2M = 0;
    usetime4M = 0;
    usetime8M = 0;
    usetime16M = 0;
    usetime128M = 0;
    usetime500M = 0;

char *cData1k = new char[1024];//1k
char *cData4k = new char[1024*4];//4k
char *cData16k = new char[1024*16];//16k
char *cData512k = new char[1024*512];//512k
char *cData2M = new char[1024*1024*2];//2M  //(char*)malloc(1024*1024*1024*2); //
char *cData4M = new char[1024*1024*4];//4M
char *cData8M = new char[1024*1024*8];//8M
char *cData16M = new char[1024*1024*16];//64M
char *cData128M = new char[1024*1024*128];//128M
char *cData500M = new char[1024*1024*500];//128M

char *cData1kCP = new char[1024];//1k
char *cData4kCP = new char[1024*4];//4k
char *cData16kCP = new char[1024*16];//16k
char *cData512kCP = new char[1024*512];//512k
char *cData2MCP = new char[1024*1024*2];//2M  //(char*)malloc(1024*1024*1024*2);//
char *cData4MCP = new char[1024*1024*4];//4M
char *cData8MCP = new char[1024*1024*8];//8M
char *cData16MCP = new char[1024*1024*16];//64M
char *cData128MCP = new char[1024*1024*128];//128M
char *cData500MCP = new char[1024*1024*500];//128M

memset(cData1kCP,1,1024);
memset(cData4kCP,1,1024*4);
memset(cData16kCP,1,1024*16);
memset(cData512kCP,1,1024*512);
memset(cData2MCP,1,1024*1024*2);
memset(cData4MCP,1,1024*1024*4);
memset(cData8MCP,1,1024*1024*8);
memset(cData16MCP,1,1024*1024*16);
memset(cData128MCP,1,1024*1024*128);
memset(cData500MCP,1,1024*1024*500);


struct timespec time1,time2;
for(int i = 0;i<100;i++)
{
    clock_gettime(CLOCK_MONOTONIC,&time1);//start time
    memcpy(cData1k,cData1kCP,1024*sizeof(char));
    clock_gettime(CLOCK_MONOTONIC,&time2);//end time
    usetime1k += (time2.tv_sec-time1.tv_sec)*1000.0+(time2.tv_nsec-time1.tv_nsec)/1000000.0;//ms

    clock_gettime(CLOCK_MONOTONIC,&time1);//start time
    memcpy(cData4k,cData4kCP,1024*4*sizeof(char));
    clock_gettime(CLOCK_MONOTONIC,&time2);//end time
    usetime4k += (time2.tv_sec-time1.tv_sec)*1000.0+(time2.tv_nsec-time1.tv_nsec)/1000000.0;//ms

    clock_gettime(CLOCK_MONOTONIC,&time1);//start time
    memcpy(cData16k,cData16kCP,1024*16*sizeof(char));
    clock_gettime(CLOCK_MONOTONIC,&time2);//end time
    usetime16k += (time2.tv_sec-time1.tv_sec)*1000.0+(time2.tv_nsec-time1.tv_nsec)/1000000.0;//ms

    clock_gettime(CLOCK_MONOTONIC,&time1);//start time
    memcpy(cData512k,cData512kCP,1024*512*sizeof(char));
    clock_gettime(CLOCK_MONOTONIC,&time2);//end time
    usetime512k += (time2.tv_sec-time1.tv_sec)*1000.0+(time2.tv_nsec-time1.tv_nsec)/1000000.0;//ms
    clock_gettime(CLOCK_MONOTONIC,&time1);//start time
    memcpy(cData2M,cData2MCP,1024*1024*2*sizeof(char));
    clock_gettime(CLOCK_MONOTONIC,&time2);//end time
    usetime2M += (time2.tv_sec-time1.tv_sec)*1000.0+(time2.tv_nsec-time1.tv_nsec)/1000000.0;//ms

    clock_gettime(CLOCK_MONOTONIC,&time1);//start time
    memcpy(cData4M,cData4MCP,1024*1024*4*sizeof(char));
    clock_gettime(CLOCK_MONOTONIC,&time2);//end time
    usetime4M += (time2.tv_sec-time1.tv_sec)*1000.0+(time2.tv_nsec-time1.tv_nsec)/1000000.0;//ms

    clock_gettime(CLOCK_MONOTONIC,&time1);//start time
    memcpy(cData8M,cData8MCP,1024*1024*8*sizeof(char));
    clock_gettime(CLOCK_MONOTONIC,&time2);//end time
    usetime8M += (time2.tv_sec-time1.tv_sec)*1000.0+(time2.tv_nsec-time1.tv_nsec)/1000000.0;//ms

    clock_gettime(CLOCK_MONOTONIC,&time1);//start time
    memcpy(cData16M,cData16MCP,1024*1024*16*sizeof(char));
    clock_gettime(CLOCK_MONOTONIC,&time2);//end time
    usetime16M += (time2.tv_sec-time1.tv_sec)*1000.0+(time2.tv_nsec-time1.tv_nsec)/1000000.0;//ms

    clock_gettime(CLOCK_MONOTONIC,&time1);//start time
    memcpy(cData128M,cData128MCP,1024*1024*128*sizeof(char));
    clock_gettime(CLOCK_MONOTONIC,&time2);//end time
    usetime128M += (time2.tv_sec-time1.tv_sec)*1000.0+(time2.tv_nsec-time1.tv_nsec)/1000000.0;//ms

    clock_gettime(CLOCK_MONOTONIC,&time1);//start time
    memcpy(cData500M,cData500MCP,1024*1024*500*sizeof(char));
    clock_gettime(CLOCK_MONOTONIC,&time2);//end time
    usetime500M += (time2.tv_sec-time1.tv_sec)*1000.0+(time2.tv_nsec-time1.tv_nsec)/1000000.0;//ms
}
qDebug()<<"memcpy 1k data usetime:"<<usetime1k/100<<"ms,speed = "<<usetime1k*10<<"um/1kbit";
qDebug()<<"memcpy 4k data usetime:"<<usetime4k/100<<"ms,speed = "<<usetime4k/4*10<<"um/1kbit";
qDebug()<<"memcpy 16k data usetime:"<<usetime16k/100<<"ms,speed = "<<usetime16k/16*10<<"um/1kbit";
qDebug()<<"memcpy 512k data usetime:"<<usetime512k/100<<"ms,speed = "<<usetime512k/512*10<<"um/1kbit";
qDebug()<<"memcpy 2M data usetime:"<<usetime2M/100<<"ms,speed = "<<usetime2M/1024/4*10<<"um/1kbit";
qDebug()<<"memcpy 4M data usetime:"<<usetime4M/100<<"ms,speed = "<<usetime4M/1024/4*10<<"um/1kbit";
qDebug()<<"memcpy 8M data usetime:"<<usetime8M/100<<"ms,speed = "<<usetime8M/1024/8*10<<"um/1kbit";
qDebug()<<"memcpy 16M data usetime:"<<usetime16M/100<<"ms,speed = "<<usetime16M/1024/16*10<<"um/1kbit";
qDebug()<<"memcpy 128M data usetime:"<<usetime128M/100<<"ms,speed = "<<usetime128M/1024/128*10<<"um/1kbit";
qDebug()<<"memcpy 500M data usetime:"<<usetime500M/100<<"ms,speed = "<<usetime500M/1024/500*10<<"um/1kbit";
#else
    //在windows下测试memcpy()的耗时
    chronograph calTime;
    double usetime1k,usetime4k,usetime16k,usetime512k,usetime2M,usetime4M,usetime8M,usetime16M,usetime128M,usetime500M;
    usetime1k = 0;
    usetime4k = 0;
    usetime16k = 0;
    usetime512k = 0;
    usetime2M = 0;
    usetime4M = 0;
    usetime8M = 0;
    usetime16M = 0;
    usetime128M = 0;
    usetime500M = 0;
char *cData1k = new char[1024];//1k
char *cData4k = new char[1024*4];//4k
char *cData16k = new char[1024*16];//16k
char *cData512k = new char[1024*512];//512k
char *cData2M = new char[1024*1024*2];//2M  //(char*)malloc(1024*1024*1024*2); //
char *cData4M = new char[1024*1024*4];//4M
char *cData8M = new char[1024*1024*8];//8M
char *cData16M = new char[1024*1024*16];//64M
char *cData128M = new char[1024*1024*128];//128M
char *cData500M = new char[1024*1024*500];//128M

char *cData1kCP = new char[1024];//1k
char *cData4kCP = new char[1024*4];//4k
char *cData16kCP = new char[1024*16];//16k
char *cData512kCP = new char[1024*512];//512k
char *cData2MCP = new char[1024*1024*2];//2M  //(char*)malloc(1024*1024*1024*2);//
char *cData4MCP = new char[1024*1024*4];//4M
char *cData8MCP = new char[1024*1024*8];//8M
char *cData16MCP = new char[1024*1024*16];//64M
char *cData128MCP = new char[1024*1024*128];//128M
char *cData500MCP = new char[1024*1024*500];//128M

memset(cData1kCP,1,1024);
memset(cData4kCP,1,1024*4);
memset(cData16kCP,1,1024*16);
memset(cData512kCP,1,1024*512);
memset(cData2MCP,1,1024*1024*2);
memset(cData4MCP,1,1024*1024*4);
memset(cData8MCP,1,1024*1024*8);
memset(cData16MCP,1,1024*1024*16);
memset(cData128MCP,1,1024*1024*128);
memset(cData500MCP,1,1024*1024*500);

for(int i = 0;i<100;i++)
{
    calTime.start();//start time
    memcpy(cData1k,cData1kCP,1024*sizeof(char));
    usetime1k += calTime.duration();

    calTime.start();//start time
    memcpy(cData4k,cData4kCP,1024*4*sizeof(char));
    usetime4k += calTime.duration();

    calTime.start();//start time
    memcpy(cData16k,cData16kCP,1024*16*sizeof(char));
    usetime16k += calTime.duration();

    calTime.start();//start time
    memcpy(cData512k,cData512kCP,1024*512*sizeof(char));
    usetime512k += calTime.duration();

    calTime.start();//start time
    memcpy(cData2M,cData2MCP,1024*1024*2*sizeof(char));
    usetime2M += calTime.duration();

    calTime.start();//start time
    memcpy(cData4M,cData4MCP,1024*1024*4*sizeof(char));
    usetime4M += calTime.duration();

    calTime.start();//start time
    memcpy(cData8M,cData8MCP,1024*1024*8*sizeof(char));
    usetime8M += calTime.duration();

    calTime.start();//start time
    memcpy(cData16M,cData16MCP,1024*1024*16*sizeof(char));
    usetime16M += calTime.duration();

    calTime.start();//start time
    memcpy(cData128M,cData128MCP,1024*1024*128*sizeof(char));
    usetime128M += calTime.duration();

    calTime.start();//start time
    memcpy(cData500M,cData500MCP,1024*1024*500*sizeof(char));
    usetime500M += calTime.duration();
}
qDebug()<<"memcpy 1k data usetime:"<<usetime1k/100<<"ms,speed = "<<usetime1k*10<<"um/1kbit";
qDebug()<<"memcpy 4k data usetime:"<<usetime4k/100<<"ms,speed = "<<usetime4k/4*10<<"um/1kbit";
qDebug()<<"memcpy 16k data usetime:"<<usetime16k/100<<"ms,speed = "<<usetime16k/16*10<<"um/1kbit";
qDebug()<<"memcpy 512k data usetime:"<<usetime512k/100<<"ms,speed = "<<usetime512k/512*10<<"um/1kbit";
qDebug()<<"memcpy 2M data usetime:"<<usetime2M/100<<"ms,speed = "<<usetime2M/1024/4*10<<"um/1kbit";
qDebug()<<"memcpy 4M data usetime:"<<usetime4M/100<<"ms,speed = "<<usetime4M/1024/4*10<<"um/1kbit";
qDebug()<<"memcpy 8M data usetime:"<<usetime8M/100<<"ms,speed = "<<usetime8M/1024/8*10<<"um/1kbit";
qDebug()<<"memcpy 16M data usetime:"<<usetime16M/100<<"ms,speed = "<<usetime16M/1024/16*10<<"um/1kbit";
qDebug()<<"memcpy 128M data usetime:"<<usetime128M/100<<"ms,speed = "<<usetime128M/1024/128*10<<"um/1kbit";
qDebug()<<"memcpy 500M data usetime:"<<usetime500M/100<<"ms,speed = "<<usetime500M/1024/500*10<<"um/1kbit";
#endif
}

MainWindow::~MainWindow()
{
    delete ui;
}

在Tx2设备上运行结果如下：在这里插入图片描述

可以看到拷贝数据在2M大小的时候，速度达到峰值。为什么拷贝2M数据速度最快呢，因为Tx2设备的处理器二级缓存就是2M，参数如下图：
在这里插入图片描述

在Thinkpad T570上运行的结果如下：
在这里插入图片描述
可以看到也是在拷贝2M数据的时候速度最快，CPU为i7-7500U，是3级缓存，大小为4M

GreenHandBruce
关注
  • 5
    点赞
  • 踩
  • 33
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 3
    评论
专栏目录
memcpy性能测试用例设计
coleoptile的专栏
08-15 664
memcpy性能测试用例设计朴素思维获取系统当前时间执行多少次合适测试数据的研究回见 背景：小作业-实现memcpy函数，性能尽量比肩开源库。所以得先想清楚怎么测试性能！在网上也发现了一些测试用例，但是觉得不是很合理，在这里整理下思路，仅作笔记！ 朴素思维 在执行memcpy前，获取系统当前时间start_time; 在执行memcpy后，获取系统当前时间end_time; end_time -...
memcpy 优化---性能大幅提升几倍
03-02
。虽然因为硬件限制没有达到AMD文档中所说memcpy函数300%的性能提升，但在我机器上实测也有%175-%200的明显性能提升（此数据可能根据机器情况不同）。
C函数之memcpy()函数用法
12-22
函数原型 　　void *memcpy(void*dest， const void *src， size_t n); 　　功能 　　由src指向地址为起始地址的连续n个字节的数据复制到以destin指向地址为起始地址的空间内。 　　头文件 　　#include<string> 　　返回值 　　函数返回一个指向dest的指针。 　　说明 　　1.source和destin所指内存区域不能重叠，函数返回指向destin的指针。 　　2.与strcpy相比，memcpy并不是遇到''结束，而是一定会拷贝完n个字节。 　　memcpy用来做内存拷贝，你可以拿它拷贝任何数据类型
snprintf/strncpy/memcpy函数字符串拷贝性能比较及实测
最新发布
zhangqi306891687的博客
06-05 383
常用字符串拷贝函数(snprintf、strncpy、memcpy)性能比较
C++执行内存memcpy的效率测试
07-04
C++执行内存memcpy的效率测试
数组或结构体赋值时memcpy与直接赋值的效率比较
罗伯特祥的博客
05-17 3801
数组或结构体赋值时memcpy与直接赋值的效率比较。
C++ memcpy_s耗时测试
a553455的博客
09-04 1933
测试代码如下 const int length = 100 * 1024 * 1024; char* testme = new char[length]; char* testme2 = new char[length]; memset(testme2, 1, length); clock_t start = clock(); for (int i = 0; i < 100; i...
基于C++执行内存memcpy效率测试的分析
01-01
在进行memcpy操作时，虽然是内存操作，但是仍然是耗一点点CPU的，今天测试了一下单线程中执行memcpy的效率，这个结果对于配置TCP epoll中的work thread 数量有指导意义。如下基于8K的内存快执行memcpy， 1个线程大约1S能够拷贝500M，如果服务器带宽或网卡到上限是1G,那么网络io的work thread 开2个即可，考虑到消息的解析损耗，3个线程足以抗住硬件的最高负载。 在我到测试机器上到测试结果是： Intel(R) Xeon(R) CPU           E5405  @ 2.00GHz do memcpy speed:12.27 ms/MBeach
stm32 memcpy效率
紫枫洛天的博客
08-25 3354
总结: 如果不开优化, memcpy最快, 如果开优化直接拷贝最快。stm32h7 400m不开cache。memcpy时间 37us。memcpy时间 37us。循环拷贝时间 69us。4字节拷贝时间20ms。循环拷贝时间 15us。4字节拷贝时间11us。数组已经64字节对齐。1 采用memcpy。...
memcpy在不同cpu使用率情况下耗时不一样
sydyh43的博客
03-17 1283
待补充
探索内存函数的奥秘【memcpy、memmove、memset、memcmp】
天行健、君子以自强不息
11-11 745
详细介绍了memcpy、memmove、memset和memcmp函数的用法及模拟实现
C语言中memcpy 函数的用法详解
08-30
在上面的示例代码中，我们使用memcpy函数将字符串"Pierre de Fermat"拷贝到结构体person的name成员中，然后将结构体person拷贝到结构体person_copy中。最后，我们打印出person_copy的内容。 除了使用标准库中的...
字符串拷贝函数memcpy和strncpy以及snprintf 的性能比较
12-31
问题：函数memcpy(dest, src, sizeof(dest))、strncpy(dest, src, sizeof(dest))和snprintf(dest, sizeof(dest), “%s”, src)都可以将src字符串中的内容拷贝到dest字符串中。哪一种方式效率最高呢？就是说，哪种...
memcpy与memmove的速度差别
架构设计
10-16 4126
VC6.0: 1、memcpy 从一块缓存到另一块缓存复制30M数据耗时 （12.6 + 11.5 + 11.8 + 11.7 + 11.3 ） / 5 = 11.78ms 2、memmove 从一块缓存到另一块缓存复制30M数据耗时 （10.1 + 10.2 + 10.3 + 12.6 + 11.1）/ 5 = 10.86ms 不同的缓存地址，memmove 与memcpy 速度相当，me...
memset对memcpy耗费时间的影响
YellowMax
12-03 1万+
源于之前几天的一个测试程序，作用是用来测试某个系统的内存访问能力，主体测试策略是分配一个缓冲区，然后使用memcpy在分配的缓冲区之间拷贝若干次，计算拷贝时间，然后在多线程的环境下运行多个拷贝程序，再次分别计算每个线程花费的时间，以此来估算系统的内存访问能力、线程调度性能以及带宽分配性能。然而，测试过程中却发生了很多问题，从而也引发了不少的思考，下面细细道来。
字符串拷贝函数memcpy()、strncpy()和snprintf()性能之比较
weixin_30354675的博客
03-29 148
问题： 函数memcpy(dest, src, sizeof(dest))、strncpy(dest, src, sizeof(dest))和snprintf(dest, sizeof(dest), "%s", src)都可以将src字符串中的内容拷贝到dest字符串中。 哪一种方式效率最高呢？ 就是说，哪种方式性能最好呢？ 解决办法： 1. 建立三个文件test_memcp...
memcpy速度太慢？掌握这个技术让内存拷贝效率成倍提升
热门推荐
音视频开发进阶
03-24 1万+
封面出自：板栗懒得很  memcpy是C/C++的一个标准函数，原型void *memcpy(void *dest, const void *src, ...
memcpy与sprintf执行时间粗略比较
独LeLe不若与人LeLe
09-18 2859
在copy功能上，虽然有许多先人都说过了memcpy比sprintf性能更高，但一直没找到相关的数据说明，近期借工程需要，自己简单的用地摊的方法测试了一下：    LARGE_INTEGER litmp;    LONGLONG qt1,qt2;    double dff,dfm;    QueryPerformanceFrequency(&litmp);    //获得时钟频率    dff=
memcpy函数效率如何
qq_37003193的博客
05-19 1614
实测4416*4416*1.5位数据使用函数拷贝10000次平均时间2.3ms，理论值是1.57ms左右还是有一定差距。然后就是MOV指令一次能拷贝多少数据，这个取决于使用的操作系统位数，一般是32位和64位。比如2.9GHz的意思就是时钟速度，通俗来讲就是一秒可以执行2.9亿次操作。我自己的分析是别的操作也在占用CPU导致效率下降，如果不对欢迎大佬指正。首先我们要知道CPU的参数，一般可以看到多少多少GHz的字样。2、MOV指令是CPU的汇编指令。系统位数：B(单位：b)数据量：d（单位：M）
memcpy函数是深拷贝还是浅拷贝
07-08
memcpy函数是执行字节级别的拷贝操作，它属于浅拷贝。memcpy函数会按字节大小将源内存块的数据复制到目标内存块中，但它不会考虑数据结构中可能存在的指针或引用关系，只是简单地复制字节内容。因此，如果源内存块中存在指针或引用，复制后的目标内存块中的指针或引用仍然会指向原始的内存地址，这就是浅拷贝。如果需要进行深拷贝，需要手动处理指针或引用的复制。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

GreenHandBruce

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值